kami
255 lines
13 KiB
TypeScript
255 lines
13 KiB
TypeScript
import { AxiosError } from 'axios';
|
|
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
|
import type { Track } from '../types';
|
|
import { usePlaybackStore } from '../store/usePlaybackStore';
|
|
import { useVibeStore } from '../store/useVibeStore';
|
|
|
|
const { start, next, advancePastUnplayable, event, end, getTrack } = vi.hoisted(() => ({
|
|
start: vi.fn(), next: vi.fn(), advancePastUnplayable: vi.fn(), event: vi.fn(), end: vi.fn(), getTrack: vi.fn(),
|
|
}));
|
|
vi.mock('./vibeService', () => ({ vibeService: { start, next, advancePastUnplayable, event, end } }));
|
|
vi.mock('./trackService', () => ({ trackService: { getTrack } }));
|
|
|
|
import { advancePastUnplayableVibeTrack, advanceVibe, endVibeSession, reportVibeEvent, startVibeSession } from './vibeSession';
|
|
|
|
const track = (id: string): Track => ({
|
|
id, path: `/music/${id}.mp3`, hash: id, title: id, artist: 'Artist',
|
|
album_id: 'album', duration: 180, state: 'LIBRARY', source_type: 'MANUAL',
|
|
play_count: 0, skip_count: 0, dislike_count: 0,
|
|
});
|
|
|
|
const item = (track_id: string, committed = false, ordinal = 0) => ({
|
|
plan_version_id: 'plan', ordinal, track_id, slot_role: null, candidate_source: 'test',
|
|
score: 1, score_breakdown: {}, explanation: [], committed,
|
|
});
|
|
|
|
const response = (planVersion: number, now = item('one', true), preview = [item('two')]) => ({
|
|
sessionId: 'session-a', planVersion, now, preview, state: {}, replanned: false, replanReason: null,
|
|
});
|
|
|
|
describe('durable Vibe session client', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
useVibeStore.getState().reset();
|
|
usePlaybackStore.setState({
|
|
currentTrack: null, queue: [], currentIndex: -1, isPlaying: false, vibeAdvanceHandler: null, queueOwner: 'ordinary',
|
|
});
|
|
getTrack.mockImplementation((id: string) => Promise.resolve(track(id)));
|
|
});
|
|
|
|
it('starts by version-serving and hydrating the first durable plan item', async () => {
|
|
start.mockResolvedValue(response(1, item('one'), [item('two')]));
|
|
next.mockResolvedValue(response(1, item('one', true), [item('two')]));
|
|
|
|
await expect(startVibeSession(track('seed'))).resolves.toMatchObject({ status: 'complete', tracks: [track('one'), track('two')] });
|
|
|
|
expect(next).toHaveBeenCalledWith('session-a', 1);
|
|
expect(useVibeStore.getState()).toMatchObject({ activeSessionId: 'session-a', planVersion: 1, buffer: [track('two')] });
|
|
expect(usePlaybackStore.getState().currentTrack).toEqual(track('one'));
|
|
});
|
|
|
|
it('replans, version-serves, and removes stale prefetched tracks before advancing', async () => {
|
|
start.mockResolvedValue(response(1, item('one'), [item('stale')]));
|
|
next
|
|
.mockResolvedValueOnce(response(1, item('one', true), [item('stale')]))
|
|
.mockResolvedValueOnce(response(2, item('two', true), [item('three')]));
|
|
event.mockResolvedValue({ ...response(2, item('two'), [item('three')]), replanned: true, event: {}, idempotent: false });
|
|
await startVibeSession(track('seed'));
|
|
|
|
await advanceVibe('skipped');
|
|
|
|
expect(next).toHaveBeenLastCalledWith('session-a', 2);
|
|
expect(usePlaybackStore.getState().queue.map((entry) => entry.id)).toEqual(['one', 'two', 'three']);
|
|
expect(usePlaybackStore.getState().currentTrack?.id).toBe('two');
|
|
expect(useVibeStore.getState().buffer.map((entry) => entry.id)).toEqual(['three']);
|
|
expect(usePlaybackStore.getState().queue.map((entry) => entry.id)).not.toContain('stale');
|
|
expect(event).toHaveBeenCalledWith('session-a', expect.objectContaining({ type: 'skipped', trackId: 'one', eventId: expect.any(String) }));
|
|
});
|
|
|
|
it('replaces only the future when a keep event replans', async () => {
|
|
start.mockResolvedValue(response(1, item('one'), [item('stale')]));
|
|
next.mockResolvedValue(response(1, item('one', true), [item('stale')]));
|
|
event.mockResolvedValue({ ...response(2, item('fresh'), [item('fresh'), item('later')]), replanned: true, event: {}, idempotent: false });
|
|
await startVibeSession(track('seed'));
|
|
|
|
await reportVibeEvent('kept', 'one');
|
|
|
|
expect(usePlaybackStore.getState().queue.map((entry) => entry.id)).toEqual(['one', 'fresh', 'later']);
|
|
expect(usePlaybackStore.getState().currentTrack?.id).toBe('one');
|
|
expect(useVibeStore.getState().planVersion).toBe(2);
|
|
});
|
|
|
|
it('reconciles the canonical replacement returned by an idempotent material-event retry', async () => {
|
|
start.mockResolvedValue(response(1, item('one'), [item('stale')]));
|
|
next.mockResolvedValue(response(1, item('one', true), [item('stale')]));
|
|
// The first response was lost after it published revision 2. Retrying the
|
|
// same client event returns that revision with replanned=false.
|
|
event.mockResolvedValue({
|
|
...response(2, item('fresh'), [item('fresh'), item('later')]),
|
|
replanned: false,
|
|
event: {},
|
|
idempotent: true,
|
|
});
|
|
await startVibeSession(track('seed'));
|
|
|
|
await reportVibeEvent('kept', 'one');
|
|
|
|
expect(useVibeStore.getState()).toMatchObject({ planVersion: 2, buffer: [track('fresh'), track('later')] });
|
|
expect(usePlaybackStore.getState().queue.map((entry) => entry.id)).toEqual(['one', 'fresh', 'later']);
|
|
});
|
|
|
|
it('cleans up local playback when the durable session is gone', async () => {
|
|
start.mockResolvedValue(response(1, item('one'), [item('stale')]));
|
|
next.mockResolvedValue(response(1, item('one', true), [item('stale')]));
|
|
event.mockRejectedValue(new AxiosError('gone', undefined, undefined, undefined, {
|
|
data: {}, status: 404, statusText: 'Not Found', headers: {}, config: {} as never,
|
|
}));
|
|
await startVibeSession(track('seed'));
|
|
|
|
await expect(reportVibeEvent('kept', 'one')).rejects.toThrow('gone');
|
|
|
|
expect(useVibeStore.getState().activeSessionId).toBeNull();
|
|
expect(usePlaybackStore.getState()).toMatchObject({ currentTrack: null, queue: [], isPlaying: false });
|
|
});
|
|
|
|
it('hands ordinary playback back to browse queues without Vibe reporting or next interception', async () => {
|
|
start.mockResolvedValue(response(1, item('one'), [item('two')]));
|
|
next.mockResolvedValue(response(1, item('one', true), [item('two')]));
|
|
await startVibeSession(track('seed'));
|
|
|
|
const ordinary = track('ordinary');
|
|
const playback = usePlaybackStore.getState();
|
|
playback.setQueue([ordinary, track('ordinary-next')]);
|
|
playback.playTrack(ordinary);
|
|
playback.nextWithReason('completed');
|
|
|
|
expect(usePlaybackStore.getState()).toMatchObject({
|
|
queueOwner: 'ordinary', currentTrack: track('ordinary-next'), vibeAdvanceHandler: null,
|
|
});
|
|
expect(event).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('serializes material events and ignores an older plan revision', async () => {
|
|
start.mockResolvedValue(response(1, item('one'), [item('old')]));
|
|
next.mockResolvedValue(response(1, item('one', true), [item('old')]));
|
|
await startVibeSession(track('seed'));
|
|
|
|
let resolveFirst!: (value: ReturnType<typeof response> & { event: object; idempotent: boolean }) => void;
|
|
event.mockImplementationOnce(() => new Promise((resolve) => { resolveFirst = resolve; }));
|
|
event.mockResolvedValueOnce({ ...response(1, item('stale'), [item('stale')]), replanned: true, event: {}, idempotent: false });
|
|
|
|
const first = reportVibeEvent('kept', 'one');
|
|
const second = reportVibeEvent('completed', 'one');
|
|
await Promise.resolve();
|
|
expect(event).toHaveBeenCalledTimes(1);
|
|
resolveFirst({ ...response(2, item('fresh'), [item('fresh')]), replanned: true, event: {}, idempotent: false });
|
|
await Promise.all([first, second]);
|
|
|
|
expect(event).toHaveBeenCalledTimes(2);
|
|
expect(useVibeStore.getState()).toMatchObject({ planVersion: 2, buffer: [track('fresh')] });
|
|
expect(usePlaybackStore.getState().queue.map((entry) => entry.id)).toEqual(['one', 'fresh']);
|
|
});
|
|
|
|
it('retries a failed event with the same idempotency key until it is acknowledged', async () => {
|
|
start.mockResolvedValue(response(1, item('one'), [item('two')]));
|
|
next.mockResolvedValue(response(1, item('one', true), [item('two')]));
|
|
event.mockRejectedValueOnce(new Error('network dropped')).mockResolvedValueOnce({
|
|
...response(1), event: {}, idempotent: true,
|
|
});
|
|
await startVibeSession(track('seed'));
|
|
|
|
await reportVibeEvent('progress', 'one', 30000, 180000);
|
|
|
|
expect(event).toHaveBeenCalledTimes(2);
|
|
expect(event.mock.calls[0][1].eventId).toBe(event.mock.calls[1][1].eventId);
|
|
});
|
|
|
|
it('skips a hidden plan item and starts from the next playable item', async () => {
|
|
start.mockResolvedValue(response(1, item('hidden'), [item('good')]));
|
|
next
|
|
.mockResolvedValueOnce(response(1, item('hidden', true), [item('good')]));
|
|
advancePastUnplayable.mockResolvedValueOnce(response(1, item('good', true), [item('later')]));
|
|
getTrack.mockImplementation((id: string) => id === 'hidden'
|
|
? Promise.resolve({ ...track(id), state: 'HIDDEN' })
|
|
: Promise.resolve(track(id)));
|
|
|
|
await expect(startVibeSession(track('seed'))).resolves.toMatchObject({ status: 'complete', tracks: [track('good'), track('later')] });
|
|
|
|
expect(next).toHaveBeenCalledTimes(1);
|
|
expect(advancePastUnplayable).toHaveBeenCalledWith('session-a', 1, expect.objectContaining({
|
|
planVersionId: 'plan', ordinal: 0, trackId: 'hidden', eventId: expect.any(String),
|
|
}));
|
|
expect(usePlaybackStore.getState().currentTrack?.id).toBe('good');
|
|
expect(usePlaybackStore.getState().queue.map((entry) => entry.id)).not.toContain('hidden');
|
|
});
|
|
|
|
it('advances consecutive hidden replacements directly without replaying an older served cursor', async () => {
|
|
start.mockResolvedValue(response(1, item('hidden-one'), [item('hidden-two', false, 1)]));
|
|
next.mockResolvedValueOnce(response(1, item('hidden-one', true), [item('hidden-two', false, 1)]));
|
|
advancePastUnplayable
|
|
.mockResolvedValueOnce(response(1, item('hidden-two', true, 1), [item('good', false, 2)]))
|
|
.mockResolvedValueOnce(response(1, item('good', true, 2), [item('later', false, 3)]));
|
|
getTrack.mockImplementation((id: string) => ['hidden-one', 'hidden-two'].includes(id)
|
|
? Promise.resolve({ ...track(id), state: 'HIDDEN' })
|
|
: Promise.resolve(track(id)));
|
|
|
|
await expect(startVibeSession(track('seed'))).resolves.toMatchObject({
|
|
status: 'complete', tracks: [track('good'), track('later')],
|
|
});
|
|
|
|
expect(next).toHaveBeenCalledTimes(1);
|
|
expect(advancePastUnplayable).toHaveBeenCalledTimes(2);
|
|
expect(advancePastUnplayable.mock.calls.map(([, , input]) => [input.ordinal, input.trackId]))
|
|
.toEqual([[0, 'hidden-one'], [1, 'hidden-two']]);
|
|
expect(usePlaybackStore.getState().currentTrack?.id).toBe('good');
|
|
});
|
|
|
|
it('retries an unplayable advancement with its original event id after a lost response', async () => {
|
|
start.mockResolvedValue(response(1, item('hidden'), [item('good')]));
|
|
next.mockResolvedValueOnce(response(1, item('hidden', true), [item('good')]));
|
|
advancePastUnplayable
|
|
.mockRejectedValueOnce(new Error('response dropped'))
|
|
.mockResolvedValueOnce(response(1, item('good', true), [item('later')]));
|
|
getTrack.mockImplementation((id: string) => id === 'hidden'
|
|
? Promise.resolve({ ...track(id), state: 'MISSING' })
|
|
: Promise.resolve(track(id)));
|
|
|
|
await startVibeSession(track('seed'));
|
|
|
|
expect(advancePastUnplayable).toHaveBeenCalledTimes(2);
|
|
expect(advancePastUnplayable.mock.calls[0][2].eventId)
|
|
.toBe(advancePastUnplayable.mock.calls[1][2].eventId);
|
|
});
|
|
|
|
it('advances a stream-error track through its stored durable cursor without ordinary feedback', async () => {
|
|
start.mockResolvedValue(response(1, item('one'), [item('two', false, 1)]));
|
|
next.mockResolvedValueOnce(response(1, item('one', true), [item('two', false, 1)]));
|
|
advancePastUnplayable.mockResolvedValueOnce(response(1, item('two', true, 1), [item('later', false, 2)]));
|
|
await startVibeSession(track('seed'));
|
|
|
|
await advancePastUnplayableVibeTrack('one');
|
|
|
|
expect(advancePastUnplayable).toHaveBeenCalledWith('session-a', 1, expect.objectContaining({
|
|
planVersionId: 'plan', ordinal: 0, trackId: 'one', eventId: expect.any(String),
|
|
}));
|
|
expect(event).not.toHaveBeenCalledWith('session-a', expect.objectContaining({ type: 'skipped', trackId: 'one' }));
|
|
expect(usePlaybackStore.getState().currentTrack?.id).toBe('two');
|
|
expect(useVibeStore.getState().currentPlanItem).toMatchObject({ track_id: 'two', ordinal: 1 });
|
|
});
|
|
|
|
it('ends a Vibe by removing Vibe ownership and clearing the local queue', async () => {
|
|
start.mockResolvedValue(response(1, item('one'), [item('two')]));
|
|
next.mockResolvedValue(response(1, item('one', true), [item('two')]));
|
|
end.mockResolvedValue(response(1));
|
|
await startVibeSession(track('seed'));
|
|
|
|
await endVibeSession();
|
|
|
|
expect(end).toHaveBeenCalledWith('session-a');
|
|
expect(useVibeStore.getState().activeSessionId).toBeNull();
|
|
expect(usePlaybackStore.getState()).toMatchObject({
|
|
queueOwner: 'ordinary', vibeAdvanceHandler: null, currentTrack: null, queue: [], isPlaying: false,
|
|
});
|
|
});
|
|
});
|