223 lines
7.7 KiB
TypeScript
223 lines
7.7 KiB
TypeScript
/**
|
||
* Lidify predeploy smoke tests (API-level).
|
||
*
|
||
* Goals:
|
||
* - deterministic, fast "is the app basically working?" checks
|
||
* - no build step (runs via tsx)
|
||
*
|
||
* Usage:
|
||
* LIDIFY_API_BASE_URL=http://127.0.0.1:3006 \
|
||
* LIDIFY_TEST_USERNAME=predeploy \
|
||
* LIDIFY_TEST_PASSWORD=predeploy-password \
|
||
* npm run test:smoke
|
||
*/
|
||
|
||
type Json = any;
|
||
|
||
const API_BASE_URL = (process.env.LIDIFY_API_BASE_URL || "http://127.0.0.1:3006").replace(/\/$/, "");
|
||
const USERNAME = process.env.LIDIFY_TEST_USERNAME || "predeploy";
|
||
const PASSWORD = process.env.LIDIFY_TEST_PASSWORD || "predeploy-password";
|
||
|
||
const WAIT_MS = Number(process.env.LIDIFY_SMOKE_WAIT_MS || "60000"); // total budget
|
||
const POLL_INTERVAL_MS = Number(process.env.LIDIFY_SMOKE_POLL_INTERVAL_MS || "1000");
|
||
|
||
function sleep(ms: number) {
|
||
return new Promise((r) => setTimeout(r, ms));
|
||
}
|
||
|
||
function assert(condition: any, message: string): asserts condition {
|
||
if (!condition) throw new Error(message);
|
||
}
|
||
|
||
async function fetchJson(
|
||
path: string,
|
||
opts: RequestInit & { token?: string } = {}
|
||
): Promise<{ status: number; ok: boolean; json: Json }> {
|
||
const url = `${API_BASE_URL}${path}`;
|
||
const headers: Record<string, string> = {
|
||
"Content-Type": "application/json",
|
||
...(opts.headers as any),
|
||
};
|
||
if (opts.token) headers.Authorization = `Bearer ${opts.token}`;
|
||
|
||
const res = await fetch(url, { ...opts, headers });
|
||
const json = await res.json().catch(() => ({}));
|
||
return { status: res.status, ok: res.ok, json };
|
||
}
|
||
|
||
async function waitForHealth() {
|
||
const start = Date.now();
|
||
let lastErr: any = null;
|
||
|
||
while (Date.now() - start < WAIT_MS) {
|
||
try {
|
||
const res = await fetch(`${API_BASE_URL}/health`);
|
||
if (res.ok) return;
|
||
lastErr = new Error(`health returned ${res.status}`);
|
||
} catch (e) {
|
||
lastErr = e;
|
||
}
|
||
await sleep(POLL_INTERVAL_MS);
|
||
}
|
||
|
||
throw new Error(
|
||
`Backend did not become healthy at ${API_BASE_URL}/health within ${WAIT_MS}ms. Last error: ${
|
||
lastErr instanceof Error ? lastErr.message : String(lastErr)
|
||
}`
|
||
);
|
||
}
|
||
|
||
async function ensureTestUserAndToken(): Promise<string> {
|
||
// Prefer onboarding/register because it's available without admin and works even when users exist.
|
||
const register = await fetchJson("/api/onboarding/register", {
|
||
method: "POST",
|
||
body: JSON.stringify({ username: USERNAME, password: PASSWORD }),
|
||
});
|
||
|
||
if (register.ok && register.json?.token) {
|
||
return register.json.token as string;
|
||
}
|
||
|
||
// If user already exists, login.
|
||
const login = await fetchJson("/api/auth/login", {
|
||
method: "POST",
|
||
body: JSON.stringify({ username: USERNAME, password: PASSWORD }),
|
||
});
|
||
assert(login.ok, `Login failed: status=${login.status} body=${JSON.stringify(login.json)}`);
|
||
assert(login.json?.token, `Login did not return token: ${JSON.stringify(login.json)}`);
|
||
return login.json.token as string;
|
||
}
|
||
|
||
async function completeOnboarding(token: string) {
|
||
const res = await fetchJson("/api/onboarding/complete", {
|
||
method: "POST",
|
||
token,
|
||
});
|
||
// It's fine if it's already complete; endpoint should still succeed.
|
||
assert(res.ok, `Onboarding complete failed: status=${res.status} body=${JSON.stringify(res.json)}`);
|
||
}
|
||
|
||
async function getOneTrackId(token: string): Promise<string | null> {
|
||
const tracks = await fetchJson("/api/library/tracks?limit=1&offset=0", { method: "GET", token });
|
||
assert(tracks.ok, `Fetch tracks failed: status=${tracks.status} body=${JSON.stringify(tracks.json)}`);
|
||
const id = tracks.json?.tracks?.[0]?.id;
|
||
return typeof id === "string" ? id : null;
|
||
}
|
||
|
||
async function scanLibraryIfNeeded(token: string) {
|
||
// If you already have at least one track, don’t force a scan (keeps it fast).
|
||
const existing = await getOneTrackId(token);
|
||
if (existing) return;
|
||
|
||
const scan = await fetchJson("/api/library/scan", { method: "POST", token });
|
||
assert(scan.ok, `Library scan start failed: status=${scan.status} body=${JSON.stringify(scan.json)}`);
|
||
const jobId = scan.json?.jobId;
|
||
assert(typeof jobId === "string", `Library scan did not return jobId: ${JSON.stringify(scan.json)}`);
|
||
|
||
const start = Date.now();
|
||
while (Date.now() - start < WAIT_MS) {
|
||
const status = await fetchJson(`/api/library/scan/status/${jobId}`, { method: "GET", token });
|
||
assert(status.ok, `Library scan status failed: status=${status.status} body=${JSON.stringify(status.json)}`);
|
||
const s = status.json?.status;
|
||
if (s === "completed" || s === "complete" || s === "done" || s === "success") return;
|
||
if (s === "failed" || s === "error") {
|
||
throw new Error(`Library scan failed: ${JSON.stringify(status.json)}`);
|
||
}
|
||
await sleep(POLL_INTERVAL_MS);
|
||
}
|
||
|
||
throw new Error(`Library scan did not complete within ${WAIT_MS}ms (jobId=${jobId}).`);
|
||
}
|
||
|
||
async function playlistsCrud(token: string) {
|
||
// Needs at least one track.
|
||
const trackId = await getOneTrackId(token);
|
||
assert(
|
||
trackId,
|
||
`No tracks found. Set MUSIC_PATH to a library with at least one track, or run a scan before testing.`
|
||
);
|
||
|
||
const created = await fetchJson("/api/playlists", {
|
||
method: "POST",
|
||
token,
|
||
body: JSON.stringify({ name: `predeploy-smoke-${Date.now()}`, isPublic: false }),
|
||
});
|
||
assert(created.ok, `Create playlist failed: status=${created.status} body=${JSON.stringify(created.json)}`);
|
||
const playlistId = created.json?.id;
|
||
assert(typeof playlistId === "string", `Create playlist missing id: ${JSON.stringify(created.json)}`);
|
||
|
||
const add = await fetchJson(`/api/playlists/${playlistId}/items`, {
|
||
method: "POST",
|
||
token,
|
||
body: JSON.stringify({ trackId }),
|
||
});
|
||
assert(add.ok, `Add track to playlist failed: status=${add.status} body=${JSON.stringify(add.json)}`);
|
||
|
||
const del = await fetchJson(`/api/playlists/${playlistId}`, { method: "DELETE", token });
|
||
assert(del.ok, `Delete playlist failed: status=${del.status} body=${JSON.stringify(del.json)}`);
|
||
}
|
||
|
||
async function playbackStateRoundTrip(token: string) {
|
||
const trackId = await getOneTrackId(token);
|
||
assert(
|
||
trackId,
|
||
`No tracks found. Set MUSIC_PATH to a library with at least one track, or run a scan before testing.`
|
||
);
|
||
|
||
const payload = {
|
||
playbackType: "track",
|
||
trackId,
|
||
queue: [{ id: trackId }],
|
||
currentIndex: 0,
|
||
isShuffle: false,
|
||
};
|
||
|
||
const save = await fetchJson("/api/playback-state", {
|
||
method: "POST",
|
||
token,
|
||
body: JSON.stringify(payload),
|
||
});
|
||
assert(save.ok, `Save playback state failed: status=${save.status} body=${JSON.stringify(save.json)}`);
|
||
|
||
const got = await fetchJson("/api/playback-state", { method: "GET", token });
|
||
assert(got.ok, `Get playback state failed: status=${got.status} body=${JSON.stringify(got.json)}`);
|
||
}
|
||
|
||
async function main() {
|
||
const started = Date.now();
|
||
console.log(`[smoke] API_BASE_URL=${API_BASE_URL}`);
|
||
|
||
await waitForHealth();
|
||
console.log("[smoke] health ok");
|
||
|
||
const token = await ensureTestUserAndToken();
|
||
console.log(`[smoke] got token for user=${USERNAME}`);
|
||
|
||
await completeOnboarding(token);
|
||
console.log("[smoke] onboarding marked complete");
|
||
|
||
await scanLibraryIfNeeded(token);
|
||
console.log("[smoke] library ready");
|
||
|
||
await playlistsCrud(token);
|
||
console.log("[smoke] playlists CRUD ok");
|
||
|
||
await playbackStateRoundTrip(token);
|
||
console.log("[smoke] playback-state roundtrip ok");
|
||
|
||
console.log(`[smoke] PASS in ${Date.now() - started}ms`);
|
||
}
|
||
|
||
main().catch((err) => {
|
||
console.error("[smoke] FAIL", err);
|
||
process.exit(1);
|
||
});
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|