Senko-san
ceee9b9d12
Three tiers of offline support, all scoped to the active backend's localStorage namespace (mirroring the auth slice): Tier 1 — persist client state. queue + player slices are saved (queue entries/index/source; player track/position/volume/repeat/shuffle) and rehydrated on load, so a reload with no backend restores where the user left off. Playback never auto-resumes (browsers block autoplay). Retires the DEMO_QUEUE and isQueueOpen:true stubs. Tier 2 — persist the RTK Query cache. Last-seen library/albums/artists are snapshotted (fulfilled queries only) and replayed via RTKQ's extractRehydrationInfo at startup, so the library renders read-only when the backend is down. ConnectionStatus tooltip flags cached data offline. No server data is copied into a slice — the cache feeds itself back. Tier 3 — service worker audio + cover cache (PWA). Audio streams are cached keyed by content id (token stripped), range-aware (synthetic 206 slicing), with a 500MB LRU cap, so already-played tracks play fully offline. Cover art uses stale-while-revalidate in its own bounded cache. Module worker (ESM); pure helpers split into sw-core.js and unit-tested. Web app manifest enables "Install app". Player source badge now reflects real cached state. tsc clean, lint clean, 19 new tests pass, production build verified. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
83 lines
2.4 KiB
TypeScript
83 lines
2.4 KiB
TypeScript
// @rstest-environment jsdom
|
|
import { expect, test, beforeEach, rstest } from '@rstest/core';
|
|
import {
|
|
rehydrateApiCache,
|
|
startApiPersistence,
|
|
} from '../src/store/rtkqPersist';
|
|
import { REHYDRATE_API } from '../src/api/rehydrate';
|
|
import {
|
|
upsertInstance,
|
|
setActiveInstanceId,
|
|
instanceStorage,
|
|
} from '../src/config/instances';
|
|
import type { RootState } from '../src/store/index';
|
|
|
|
beforeEach(() => {
|
|
localStorage.clear();
|
|
const inst = upsertInstance('http://test.local');
|
|
setActiveInstanceId(inst.id);
|
|
});
|
|
|
|
function apiStateWith(queries: Record<string, unknown>) {
|
|
return {
|
|
api: { queries, mutations: {}, provided: {}, subscriptions: {}, config: {} },
|
|
} as unknown as RootState;
|
|
}
|
|
|
|
test('rehydrateApiCache dispatches nothing when no cache is stored', () => {
|
|
const dispatched: unknown[] = [];
|
|
rehydrateApiCache((a) => dispatched.push(a));
|
|
expect(dispatched).toHaveLength(0);
|
|
});
|
|
|
|
test('rehydrateApiCache replays a stored cache as a rehydrate action', () => {
|
|
instanceStorage.set(
|
|
'rtkq',
|
|
JSON.stringify({
|
|
queries: { 'getLibrary(undefined)': { status: 'fulfilled', data: [1] } },
|
|
mutations: {},
|
|
}),
|
|
);
|
|
const dispatched: Array<{ type: string; payload: unknown }> = [];
|
|
rehydrateApiCache((a) =>
|
|
dispatched.push(a as { type: string; payload: unknown }),
|
|
);
|
|
expect(dispatched).toHaveLength(1);
|
|
expect(dispatched[0].type).toBe(REHYDRATE_API);
|
|
expect(dispatched[0].payload).toMatchObject({
|
|
queries: { 'getLibrary(undefined)': { status: 'fulfilled' } },
|
|
});
|
|
});
|
|
|
|
test('startApiPersistence saves only fulfilled queries after throttle', () => {
|
|
rstest.useFakeTimers();
|
|
let state = apiStateWith({});
|
|
let listener: (() => void) | null = null;
|
|
const store = {
|
|
getState: () => state,
|
|
subscribe: (l: () => void) => {
|
|
listener = l;
|
|
return () => {};
|
|
},
|
|
};
|
|
|
|
startApiPersistence(store);
|
|
|
|
state = apiStateWith({
|
|
'getAlbums(undefined)': { status: 'fulfilled', data: ['a'] },
|
|
'getArtists(undefined)': { status: 'pending' },
|
|
'getTracks(undefined)': { status: 'rejected', error: 'boom' },
|
|
});
|
|
listener!();
|
|
|
|
// throttled — nothing yet
|
|
expect(instanceStorage.get('rtkq')).toBeNull();
|
|
|
|
rstest.advanceTimersByTime(2000);
|
|
const saved = JSON.parse(instanceStorage.get('rtkq')!);
|
|
expect(Object.keys(saved.queries)).toEqual(['getAlbums(undefined)']);
|
|
expect(saved.mutations).toEqual({});
|
|
|
|
rstest.useRealTimers();
|
|
});
|