312 lines
10 KiB
JavaScript
312 lines
10 KiB
JavaScript
/**
|
|
* Unit tests for js/pleroma-adapter.js.
|
|
*
|
|
* The adapter is an IIFE that wraps window.fetch. It is loaded in a vm
|
|
* context with a mocked window object, so tests can call the wrapped
|
|
* fetch and inspect how Pleroma API responses are mapped to the
|
|
* Mastodon format expected by mastodon-timeline.umd.js.
|
|
*/
|
|
'use strict';
|
|
|
|
const { describe, test } = require('node:test');
|
|
const assert = require('node:assert');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const vm = require('node:vm');
|
|
|
|
const ADAPTER_PATH = path.join(__dirname, '..', '..', 'js', 'pleroma-adapter.js');
|
|
const ADAPTER_SOURCE = fs.readFileSync(ADAPTER_PATH, 'utf8');
|
|
|
|
const TIMELINE_URL = 'https://pleroma.example/api/v1/timelines/public';
|
|
const ACCOUNT_STATUSES_URL = 'https://pleroma.example/api/v1/accounts/42/statuses';
|
|
|
|
/**
|
|
* Loads the adapter in an isolated vm context.
|
|
*
|
|
* @param {Function} handler Fake backend: receives the URL, returns a Response
|
|
* @returns {{fetch: Function, warnings: string[]}} The wrapped fetch and logged warnings
|
|
*/
|
|
function loadAdapter(handler) {
|
|
const warnings = [];
|
|
const windowMock = {
|
|
fetch: async (url) => handler(url)
|
|
};
|
|
|
|
const sandbox = {
|
|
window: windowMock,
|
|
Response,
|
|
console: {
|
|
log() {},
|
|
warn: (...args) => warnings.push(args.join(' ')),
|
|
error() {}
|
|
}
|
|
};
|
|
|
|
vm.createContext(sandbox);
|
|
vm.runInContext(ADAPTER_SOURCE, sandbox);
|
|
|
|
return { fetch: windowMock.fetch, warnings };
|
|
}
|
|
|
|
function jsonResponse(data, init = {}) {
|
|
return new Response(JSON.stringify(data), {
|
|
status: 200,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
...init
|
|
});
|
|
}
|
|
|
|
describe('Pleroma adapter', () => {
|
|
test('adds default meta to timeline attachments missing meta', async () => {
|
|
const posts = [
|
|
{
|
|
id: '1',
|
|
content: 'hello',
|
|
media_attachments: [
|
|
{ id: 'a1', type: 'image', url: 'https://pleroma.example/img.png' }
|
|
]
|
|
},
|
|
{ id: '2', content: 'no media' }
|
|
];
|
|
const { fetch } = loadAdapter(() => jsonResponse(posts));
|
|
|
|
const res = await fetch(TIMELINE_URL);
|
|
const data = await res.json();
|
|
|
|
assert.strictEqual(res.status, 200);
|
|
assert.strictEqual(data.length, 2);
|
|
|
|
const attachment = data[0].media_attachments[0];
|
|
assert.deepStrictEqual(attachment.meta.original, {
|
|
width: 1280,
|
|
height: 720,
|
|
aspect: 1280 / 720
|
|
});
|
|
assert.deepStrictEqual(attachment.meta.small, {
|
|
width: 640,
|
|
height: 360,
|
|
aspect: 1280 / 720
|
|
});
|
|
// Other fields are preserved
|
|
assert.strictEqual(attachment.url, 'https://pleroma.example/img.png');
|
|
assert.strictEqual(data[0].content, 'hello');
|
|
assert.strictEqual(data[1].content, 'no media');
|
|
assert.strictEqual(data[1].media_attachments, undefined);
|
|
});
|
|
|
|
test('uses 1920x1080 for video attachments (pleroma mime_type)', async () => {
|
|
const posts = [
|
|
{
|
|
id: '9',
|
|
media_attachments: [
|
|
{ id: 'v1', pleroma: { mime_type: 'video/mp4' } }
|
|
]
|
|
}
|
|
];
|
|
const { fetch } = loadAdapter(() => jsonResponse(posts));
|
|
|
|
const res = await fetch(ACCOUNT_STATUSES_URL);
|
|
const data = await res.json();
|
|
|
|
const meta = data[0].media_attachments[0].meta;
|
|
assert.deepStrictEqual(meta.original, {
|
|
width: 1920,
|
|
height: 1080,
|
|
aspect: 1920 / 1080
|
|
});
|
|
assert.deepStrictEqual(meta.small, {
|
|
width: 960,
|
|
height: 540,
|
|
aspect: 1920 / 1080
|
|
});
|
|
});
|
|
|
|
test('uses 1200x800 for image attachments (pleroma mime_type)', async () => {
|
|
const post = {
|
|
id: '10',
|
|
media_attachments: [
|
|
{ id: 'i1', pleroma: { mime_type: 'image/jpeg' } }
|
|
]
|
|
};
|
|
const { fetch } = loadAdapter(() => jsonResponse(post));
|
|
|
|
const res = await fetch(TIMELINE_URL);
|
|
const data = await res.json();
|
|
|
|
const meta = data.media_attachments[0].meta;
|
|
assert.deepStrictEqual(meta.original, {
|
|
width: 1200,
|
|
height: 800,
|
|
aspect: 1200 / 800
|
|
});
|
|
assert.deepStrictEqual(meta.small, {
|
|
width: 600,
|
|
height: 400,
|
|
aspect: 1200 / 800
|
|
});
|
|
});
|
|
|
|
test('adapts a single (non-array) post object', async () => {
|
|
const post = {
|
|
id: 'single',
|
|
media_attachments: [{ id: 's1' }]
|
|
};
|
|
const { fetch } = loadAdapter(() => jsonResponse(post));
|
|
|
|
const res = await fetch(TIMELINE_URL);
|
|
const data = await res.json();
|
|
|
|
assert.strictEqual(Array.isArray(data), false);
|
|
assert.strictEqual(data.id, 'single');
|
|
assert.deepStrictEqual(data.media_attachments[0].meta.original, {
|
|
width: 1280,
|
|
height: 720,
|
|
aspect: 1280 / 720
|
|
});
|
|
});
|
|
|
|
test('leaves attachments with complete meta untouched', async () => {
|
|
const completeMeta = {
|
|
original: { width: 640, height: 480, aspect: 640 / 480 },
|
|
small: { width: 320, height: 240, aspect: 640 / 480 }
|
|
};
|
|
const posts = [
|
|
{ id: 'm1', media_attachments: [{ id: 'ok', meta: completeMeta }] }
|
|
];
|
|
const { fetch } = loadAdapter(() => jsonResponse(posts));
|
|
|
|
const res = await fetch(TIMELINE_URL);
|
|
const data = await res.json();
|
|
|
|
assert.deepStrictEqual(data[0].media_attachments[0].meta, completeMeta);
|
|
});
|
|
|
|
test('keeps existing partial meta.original and fills meta.small', async () => {
|
|
const posts = [
|
|
{
|
|
id: 'p1',
|
|
media_attachments: [
|
|
{
|
|
id: 'partial',
|
|
meta: { original: { width: 640, height: 480, aspect: 640 / 480 } }
|
|
}
|
|
]
|
|
}
|
|
];
|
|
const { fetch } = loadAdapter(() => jsonResponse(posts));
|
|
|
|
const res = await fetch(TIMELINE_URL);
|
|
const data = await res.json();
|
|
|
|
const meta = data[0].media_attachments[0].meta;
|
|
assert.deepStrictEqual(meta.original, { width: 640, height: 480, aspect: 640 / 480 });
|
|
// meta.small is created from the default dimensions
|
|
assert.deepStrictEqual(meta.small, {
|
|
width: 640,
|
|
height: 360,
|
|
aspect: 1280 / 720
|
|
});
|
|
});
|
|
|
|
test('adapts media attachments inside reblogs recursively', async () => {
|
|
const posts = [
|
|
{
|
|
id: 'r1',
|
|
reblog: {
|
|
id: 'r2',
|
|
media_attachments: [
|
|
{ id: 'rb', pleroma: { mime_type: 'image/png' } }
|
|
]
|
|
}
|
|
}
|
|
];
|
|
const { fetch } = loadAdapter(() => jsonResponse(posts));
|
|
|
|
const res = await fetch(TIMELINE_URL);
|
|
const data = await res.json();
|
|
|
|
const meta = data[0].reblog.media_attachments[0].meta;
|
|
assert.deepStrictEqual(meta.original, {
|
|
width: 1200,
|
|
height: 800,
|
|
aspect: 1200 / 800
|
|
});
|
|
});
|
|
|
|
test('does not mutate the original payload objects', async () => {
|
|
const attachment = { id: 'orig' };
|
|
const posts = [{ id: 'n1', media_attachments: [attachment] }];
|
|
const { fetch } = loadAdapter(() => jsonResponse(posts));
|
|
|
|
const res = await fetch(TIMELINE_URL);
|
|
await res.json();
|
|
|
|
assert.strictEqual(attachment.meta, undefined);
|
|
assert.deepStrictEqual(posts[0].media_attachments, [attachment]);
|
|
});
|
|
|
|
test('passes non-object array entries through unchanged', async () => {
|
|
const posts = [null, 'not-a-post', { id: 'real', media_attachments: [{ id: 'x' }] }];
|
|
const { fetch } = loadAdapter(() => jsonResponse(posts));
|
|
|
|
const res = await fetch(TIMELINE_URL);
|
|
const data = await res.json();
|
|
|
|
assert.strictEqual(data[0], null);
|
|
assert.strictEqual(data[1], 'not-a-post');
|
|
assert.ok(data[2].media_attachments[0].meta);
|
|
});
|
|
|
|
test('intercepts account statuses URLs only when they contain /statuses', async () => {
|
|
const posts = [{ id: 'a', media_attachments: [{ id: 'x' }] }];
|
|
const { fetch } = loadAdapter(() => jsonResponse(posts));
|
|
|
|
// /api/v1/accounts/42/statuses is adapted
|
|
const resStatuses = await fetch(ACCOUNT_STATUSES_URL);
|
|
const dataStatuses = await resStatuses.json();
|
|
assert.ok(dataStatuses[0].media_attachments[0].meta);
|
|
|
|
// /api/v1/accounts/42 (no /statuses) is left as-is
|
|
const resAccount = await fetch('https://pleroma.example/api/v1/accounts/42');
|
|
const dataAccount = await resAccount.json();
|
|
assert.strictEqual(dataAccount[0].media_attachments[0].meta, undefined);
|
|
});
|
|
|
|
test('returns non-API responses untouched (same Response object)', async () => {
|
|
let original;
|
|
const { fetch } = loadAdapter(() => {
|
|
original = jsonResponse({ ok: true });
|
|
return original;
|
|
});
|
|
|
|
const res = await fetch('https://example.com/about');
|
|
|
|
assert.strictEqual(res, original);
|
|
assert.deepStrictEqual(await res.json(), { ok: true });
|
|
});
|
|
|
|
test('falls back to the original response when JSON parsing fails', async () => {
|
|
let original;
|
|
const { fetch, warnings } = loadAdapter(() => {
|
|
original = new Response('not-json', { status: 200 });
|
|
return original;
|
|
});
|
|
|
|
const res = await fetch(TIMELINE_URL);
|
|
|
|
assert.strictEqual(res, original);
|
|
assert.strictEqual(await res.text(), 'not-json');
|
|
assert.strictEqual(warnings.length, 1);
|
|
});
|
|
|
|
test('preserves response status on adapted responses', async () => {
|
|
const posts = [{ id: 's', media_attachments: [] }];
|
|
const { fetch } = loadAdapter(() => jsonResponse(posts, { status: 201 }));
|
|
|
|
const res = await fetch(TIMELINE_URL);
|
|
|
|
assert.strictEqual(res.status, 201);
|
|
assert.deepStrictEqual(await res.json(), posts);
|
|
});
|
|
});
|