scribase-cli/tests/ota.test.ts
caelum0x 92f7df83c4 scribase CLI + TypeScript SDK (public edge repo)
Extracted from the private caelum0x/scribase monorepo's
packages/scribase-js with a fresh, single-commit history (no core
history leaks). The npx scribase CLI and the typed /v1 API client,
unchanged except: prepublishOnly simplified (the monorepo-only tarball
gitleaks gate dropped), repository/homepage/bugs fields added, and one
test that cross-checked embedded template strings against the
monorepo's templates/ directory removed (nothing it tested changed;
that directory isn't shipped here).
2026-11-12 18:10:58 +03:00

195 lines
9.4 KiB
TypeScript

/**
* Tests for `npx scribase ota` (PS3.1): arguments, the deploy flow (set up
* when needed, config and env written once, the secret key only in the child
* process), roll back and status, with no network and in-memory files.
*/
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { CONFIG_FILE, CONFIG_TEMPLATE, formatOta, otaMain, parseOtaArgs, runOta } from '../src/cli/capabilities/ota.js';
import type { OtaIo, OtaStatus } from '../src/cli/capabilities/ota.js';
import { InitError } from '../src/cli/init.js';
const ROOT = '/work/app';
const STATE = JSON.stringify({ organization_id: 'acme', project_id: 'shop', environment_id: 'production', api_url: 'https://api.example.test' });
const SECRET = 'sb_secret_abcdefghijklmnopqrstuvwxyz0123456789';
const URL_BASE = 'https://api.example.test/v1/organizations/acme/projects/shop/environments/production';
const RELEASE = {
id: '0199a000-0000-7000-8000-000000000002',
platform: 'ios',
channel: 'production',
target_app_version: '1.x.x',
fingerprint_hash: null,
enabled: true,
force_update: false,
rollout_percent: 100,
message: 'fix login',
created_at_epoch_seconds: 1759200000,
};
function status(overrides: Partial<OtaStatus> = {}): OtaStatus {
return {
enabled: true,
conflict: false,
update_url: 'https://acme-shop.scribase.app/functions/v1/ota',
bucket: 'ota-bundles',
releases: 1,
latest: [RELEASE as OtaStatus['latest'][number]],
...overrides,
};
}
type Answer = { status: number; body: unknown };
function fakeIo(routes: Record<string, Answer | Answer[]>, files: Record<string, string> = {}, runCode = 0) {
const store: Record<string, string> = { [`${ROOT}/.scribase/project.json`]: STATE, ...files };
const calls: { method: string; url: string; body: unknown; auth: string | null }[] = [];
const runs: { command: string; args: string[]; env: Record<string, string> }[] = [];
const logs: string[] = [];
const io: OtaIo = {
cwd: ROOT,
env: { SCRIBASE_ACCESS_TOKEN: 'pat_token' },
fetch: (async (url: string | URL | Request, init?: RequestInit) => {
const method = init?.method ?? 'GET';
const path = String(url).slice(URL_BASE.length);
calls.push({ method, url: String(url), body: init?.body ? JSON.parse(String(init.body)) : undefined, auth: new Headers(init?.headers).get('authorization') });
const entry = routes[`${method} ${path}`];
const answer = Array.isArray(entry) ? entry.shift() : entry;
if (!answer) return new Response('{"code":"not_found","detail":"no route"}', { status: 404 });
return new Response(JSON.stringify(answer.body), { status: answer.status });
}) as typeof fetch,
readFile: (path) => store[path] ?? null,
writeFile: (path, contents) => {
store[path] = contents;
},
credentials: () => ({}),
log: (line) => logs.push(line),
run: async (command, args, env) => {
runs.push({ command, args, env });
return runCode;
},
};
return { io, calls, runs, store, logs };
}
describe('scribase ota arguments', () => {
it('reads the action, platform, channel and deploy flags', () => {
assert.deepEqual(parseOtaArgs(['deploy', '-p', 'ios', '-m', 'fix', '-r', '25', '-f']), {
action: 'deploy',
platform: 'ios',
channel: 'production',
passthrough: ['-m', 'fix', '-r', '25', '-f'],
json: false,
});
assert.equal(parseOtaArgs(['rollback', '--platform', 'android', '-c', 'beta']).channel, 'beta');
assert.equal(parseOtaArgs(['status', '--json']).json, true);
});
it('refuses a missing platform, an unknown one, a bad channel and unknown flags', () => {
assert.throws(() => parseOtaArgs(['deploy']), InitError);
assert.throws(() => parseOtaArgs(['deploy', '-p', 'web']), InitError);
assert.throws(() => parseOtaArgs(['rollback', '-p', 'ios', '-c', 'a/b']), InitError);
assert.throws(() => parseOtaArgs(['status', '--secret', 'x']), InitError);
assert.throws(() => parseOtaArgs(['rollback', '-p', 'ios', '-m', 'x']), InitError);
assert.throws(() => parseOtaArgs(['publish']), InitError);
assert.throws(() => parseOtaArgs(['deploy', '-p']), InitError);
});
});
describe('scribase ota deploy', () => {
it('sets OTA up when needed, writes the config and the public URL, and gives the key only to the child', async () => {
const { io, calls, runs, store } = fakeIo({
'GET /ota': [
{ status: 200, body: status({ enabled: false, latest: [], releases: 0 }) },
{ status: 200, body: status() },
],
'POST /ota': { status: 200, body: status({ latest: [], releases: 0 }) },
'GET /api-keys': { status: 200, body: { api_url: 'https://acme-shop.scribase.app/', secret_key: SECRET, anon_key: 'anon' } },
});
const result = await runOta(parseOtaArgs(['deploy', '-p', 'ios', '-m', 'fix login']), io);
assert.equal(result.action, 'deploy');
assert.ok(result.action === 'deploy' && result.set_up && result.config_written);
assert.deepEqual(result.action === 'deploy' && result.env_written, ['EXPO_PUBLIC_HOT_UPDATER_URL']);
assert.equal(result.action === 'deploy' && result.release?.id, RELEASE.id);
assert.equal(store[`${ROOT}/${CONFIG_FILE}`], CONFIG_TEMPLATE);
assert.match(store[`${ROOT}/.env`] ?? '', /EXPO_PUBLIC_HOT_UPDATER_URL=.*functions\/v1\/ota/);
for (const contents of Object.values(store)) assert.ok(!contents.includes(SECRET), 'the secret key is never written');
assert.equal(runs.length, 1);
assert.deepEqual(runs[0]?.args, ['--yes', 'hot-updater@0.36.16', 'deploy', '-p', 'ios', '-c', 'production', '-m', 'fix login']);
assert.equal(runs[0]?.env.HOT_UPDATER_SUPABASE_SERVICE_ROLE_KEY, SECRET);
assert.equal(runs[0]?.env.HOT_UPDATER_SUPABASE_URL, 'https://acme-shop.scribase.app');
assert.equal(runs[0]?.env.HOT_UPDATER_SUPABASE_BUCKET_NAME, 'ota-bundles');
assert.ok(calls.every((call) => call.auth === 'Bearer pat_token'));
assert.deepEqual(calls.map((call) => `${call.method} ${call.url.slice(URL_BASE.length)}`), ['GET /ota', 'POST /ota', 'GET /api-keys', 'GET /ota']);
});
it('keeps an existing config and env value and does not set up twice', async () => {
const { io, calls, store } = fakeIo(
{
'GET /ota': { status: 200, body: status() },
'GET /api-keys': { status: 200, body: { api_url: 'https://acme-shop.scribase.app', service_role_key: 'eyJ.service.jwt' } },
},
{
[`${ROOT}/${CONFIG_FILE}`]: '// mine',
[`${ROOT}/.env.local`]: 'EXPO_PUBLIC_HOT_UPDATER_URL=https://acme-shop.scribase.app/functions/v1/ota\n',
},
);
const result = await runOta(parseOtaArgs(['deploy', '-p', 'ios']), io);
assert.ok(result.action === 'deploy' && !result.set_up && !result.config_written && result.env_written.length === 0);
assert.equal(store[`${ROOT}/${CONFIG_FILE}`], '// mine');
assert.ok(!calls.some((call) => call.method === 'POST'));
});
it('stops on a foreign bundles table, a role without the key, or a failed upload', async () => {
await assert.rejects(
runOta(parseOtaArgs(['deploy', '-p', 'ios']), fakeIo({ 'GET /ota': { status: 200, body: status({ enabled: false, conflict: true }) } }).io),
/own public.bundles/,
);
await assert.rejects(
runOta(
parseOtaArgs(['deploy', '-p', 'ios']),
fakeIo({ 'GET /ota': { status: 200, body: status() }, 'GET /api-keys': { status: 200, body: { api_url: 'https://x', secret_key: null } } }).io,
),
/secret key/,
);
await assert.rejects(
runOta(
parseOtaArgs(['deploy', '-p', 'android']),
fakeIo({ 'GET /ota': { status: 200, body: status() }, 'GET /api-keys': { status: 200, body: { api_url: 'https://x', secret_key: SECRET } } }, {}, 1).io,
),
/exited with code 1/,
);
});
});
describe('scribase ota rollback and status', () => {
it('rolls back the newest release and names what devices go back to', async () => {
const { io, calls } = fakeIo({
'POST /ota/rollback': { status: 200, body: { turned_off: RELEASE.id, now_serving: null, platform: 'ios', channel: 'production' } },
});
const result = await runOta(parseOtaArgs(['rollback', '-p', 'ios']), io);
assert.deepEqual(calls[0]?.body, { platform: 'ios', channel: 'production' });
assert.match(formatOta(result), /go back to the bundle built into the app/);
});
it('prints the published releases, or how to start', async () => {
const on = await runOta(parseOtaArgs(['status']), fakeIo({ 'GET /ota': { status: 200, body: status() } }).io);
assert.match(formatOta(on), /ios production: 0199a000-0000-7000-8000-000000000002 \(on for 100% of devices, app 1\.x\.x\)/);
const off = await runOta(parseOtaArgs(['status']), fakeIo({ 'GET /ota': { status: 200, body: status({ enabled: false }) } }).io);
assert.match(formatOta(off), /not set up yet/);
});
it('prints the API refusal and exits 1; help exits 0', async () => {
const lines: string[] = [];
const code = await otaMain(
['rollback', '-p', 'ios'],
fakeIo({ 'POST /ota/rollback': { status: 409, body: { code: 'nothing_to_roll_back', detail: 'no release is on for ios on the production channel' } } }).io,
(text) => lines.push(text),
);
assert.equal(code, 1);
assert.match(lines.join(''), /no release is on for ios \(HTTP 409\)|no release is on for ios on the production channel \(HTTP 409\)/);
assert.equal(await otaMain(['--help'], fakeIo({}).io, () => undefined), 0);
});
});