0ba8bd3a2c
When a hoster server replies with a body that JSON-parses to a
non-object (literal "null", a bare string, a number, a top-level
array), uploadFile's downstream code crashed:
payload.msg → TypeError on null
payload.status → TypeError on null
config.parseResult() → TypeError inside parseDoodstreamResult
(payload.result) and parseByseResult
(payload.files / payload.result)
The user saw a confusing "Cannot read properties of null" instead of
a useful "server returned no JSON object". Found by deep-audit pass.
Fix in three places:
1. uploadFile (lib/hosters.js): after JSON.parse, normalise non-object
payloads to {}. Subsequent `payload.X` accesses then return
undefined and the existing fallback paths handle the empty case.
2. parseDoodstreamResult: defensive `payload && payload.result` so
direct callers (tests, hypothetical future callers) get the same
guarantee instead of relying on uploadFile to have normalised.
3. parseByseResult: same `payload || typeof payload !== 'object'`
short-circuit at entry, plus null-checks on `f` (the first files
entry) so a server returning [null] in files doesn't crash either.
Tests: 7 new unit tests covering null/undefined/string/number/array
payloads, malformed files entries, the fileRejected/accountError
classification (regression-pinning the 3.1.4 phrasing tweaks), and
the valid-filecode happy path. 126/126 green.
96 lines
3.7 KiB
JavaScript
96 lines
3.7 KiB
JavaScript
const { describe, it } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
|
|
const { __test } = require('../lib/hosters');
|
|
|
|
describe('hosters helpers', () => {
|
|
it('extracts VOE file_code from nested result payloads', () => {
|
|
assert.deepEqual(__test.parseVoeResult({ result: { file: { file_code: 'abc123' } } }), {
|
|
download_url: 'https://voe.sx/abc123',
|
|
embed_url: 'https://voe.sx/e/abc123',
|
|
file_code: 'abc123'
|
|
});
|
|
});
|
|
|
|
it('extracts VOE file_code from flat fallback payloads', () => {
|
|
assert.deepEqual(__test.parseVoeResult({ file_code: 'xyz789' }), {
|
|
download_url: 'https://voe.sx/xyz789',
|
|
embed_url: 'https://voe.sx/e/xyz789',
|
|
file_code: 'xyz789'
|
|
});
|
|
});
|
|
|
|
it('extracts upload server URLs from nested API responses', () => {
|
|
const url = __test.extractUploadServerUrl({
|
|
result: {
|
|
server: {
|
|
upload_url: 'https://delivery-hydra.voe-network.net/upload/01'
|
|
}
|
|
}
|
|
}, 'https://voe.sx');
|
|
|
|
assert.equal(url, 'https://delivery-hydra.voe-network.net/upload/01');
|
|
});
|
|
|
|
it('parseDoodstreamResult tolerates null/non-object payload without throwing', () => {
|
|
// Direct callers may bypass uploadFile's normalisation. The parser must
|
|
// never throw on bad input — empty fields are the contract.
|
|
for (const bad of [null, undefined, 'string', 42, true]) {
|
|
const r = __test.parseDoodstreamResult(bad);
|
|
assert.equal(r.file_code, null);
|
|
assert.equal(r.download_url, null);
|
|
assert.equal(r.embed_url, null);
|
|
}
|
|
});
|
|
|
|
it('parseDoodstreamResult handles result-as-array and result-as-object', () => {
|
|
const arr = __test.parseDoodstreamResult({ result: [{ filecode: 'AB1', protected_dl: 'https://x/1', protected_embed: 'https://x/e/1' }] });
|
|
assert.equal(arr.file_code, 'AB1');
|
|
assert.equal(arr.download_url, 'https://x/1');
|
|
assert.equal(arr.embed_url, 'https://x/e/1');
|
|
|
|
const obj = __test.parseDoodstreamResult({ result: { filecode: 'OBJ1', download_url: 'https://x/2' } });
|
|
assert.equal(obj.file_code, 'OBJ1');
|
|
assert.equal(obj.download_url, 'https://x/2');
|
|
});
|
|
|
|
it('parseByseResult tolerates null/non-object payload without throwing', () => {
|
|
for (const bad of [null, undefined, 'string', 42, []]) {
|
|
const r = __test.parseByseResult(bad);
|
|
assert.equal(r.file_code, null);
|
|
assert.equal(r.download_url, null);
|
|
assert.equal(r.embed_url, null);
|
|
}
|
|
});
|
|
|
|
it('parseByseResult handles malformed files entries (null, missing fields)', () => {
|
|
// Files array with a null first element (server returned [null])
|
|
const a = __test.parseByseResult({ files: [null] });
|
|
assert.equal(a.file_code, null);
|
|
// Files array with object missing both filecode and status
|
|
const b = __test.parseByseResult({ files: [{}] });
|
|
assert.equal(b.file_code, null);
|
|
});
|
|
|
|
it('parseByseResult throws fileRejected for non-OK status with empty filecode', () => {
|
|
assert.throws(
|
|
() => __test.parseByseResult({ files: [{ status: 'Not video file format' }] }),
|
|
(err) => err.fileRejected === true && /Not video file format/i.test(err.message)
|
|
);
|
|
});
|
|
|
|
it('parseByseResult flips to accountError for storage-exhausted phrasing', () => {
|
|
assert.throws(
|
|
() => __test.parseByseResult({ files: [{ status: 'not enough disk space on your account' }] }),
|
|
(err) => err.accountError === true
|
|
);
|
|
});
|
|
|
|
it('parseByseResult succeeds with valid filecode in files[0]', () => {
|
|
const r = __test.parseByseResult({ files: [{ filecode: 'GOOD123', status: 'OK' }] });
|
|
assert.equal(r.file_code, 'GOOD123');
|
|
assert.equal(r.download_url, 'https://byse.sx/d/GOOD123');
|
|
assert.equal(r.embed_url, 'https://byse.sx/e/GOOD123');
|
|
});
|
|
});
|