mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
533 lines
30 KiB
JavaScript
533 lines
30 KiB
JavaScript
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const vm = require('node:vm');
|
|
const ts = require('typescript');
|
|
|
|
function load(file, modules = {}, globals = {}) {
|
|
const sandbox = { exports: {}, console, JSON, Promise, Date, Math, setTimeout, clearTimeout, require: id => {
|
|
if (!(id in modules)) throw new Error(`Unstubbed import: ${id}`);
|
|
return modules[id];
|
|
}, ...globals };
|
|
vm.runInNewContext(ts.transpileModule(fs.readFileSync(path.join(__dirname, '..', file), 'utf8'), {
|
|
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
|
}).outputText, sandbox);
|
|
return sandbox.exports;
|
|
}
|
|
|
|
const CLIENT_ID = '0123456789abcdef0123456789abcdef';
|
|
|
|
/** Values from the sandbox carry its own Array/Object prototypes; compare their plain JSON form. */
|
|
const plain = value => JSON.parse(JSON.stringify(value));
|
|
|
|
/** settings-store stand-in: synchronous change notifications. */
|
|
function fakeSettings(initial = {}) {
|
|
const values = new Map(Object.entries(initial));
|
|
const listeners = new Set();
|
|
return {
|
|
values,
|
|
getStringSetting: (key, fallback) => (values.has(key) ? values.get(key) : fallback),
|
|
setStringSetting: (key, value) => { values.set(key, value); for (const listener of listeners) listener(key); },
|
|
onSettingsStoreChanged: listener => { listeners.add(listener); return () => listeners.delete(listener); },
|
|
};
|
|
}
|
|
|
|
/** Manual timers: run() fires everything due, in order. */
|
|
function fakeTimers() {
|
|
let now = 1_000_000; let nextId = 1;
|
|
const pending = new Map();
|
|
return {
|
|
now: () => now,
|
|
setTimeout: (fn, delay) => { const id = nextId++; pending.set(id, { fn, at: now + (delay || 0) }); return id; },
|
|
clearTimeout: id => pending.delete(id),
|
|
advance(ms) {
|
|
now += ms;
|
|
for (const [id, timer] of [...pending].sort((a, b) => a[1].at - b[1].at)) {
|
|
if (timer.at <= now && pending.has(id)) { pending.delete(id); timer.fn(); }
|
|
}
|
|
},
|
|
delays: () => [...pending.values()].map(timer => timer.at - now),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Spotify's endpoints as a route table: "METHOD /path" -> response or function(call).
|
|
* Records every call with its parsed URL, headers and body.
|
|
*/
|
|
function fakeFetch(routes) {
|
|
const calls = [];
|
|
const fetch = async (url, init) => {
|
|
const parsed = new URL(url);
|
|
const call = { url, method: init.method, path: parsed.pathname.replace('/v1', ''), query: Object.fromEntries(parsed.searchParams),
|
|
headers: init.headers, body: init.body };
|
|
calls.push(call);
|
|
let route = routes[`${init.method} ${call.path}`];
|
|
if (typeof route === 'function') route = route(call);
|
|
if (Array.isArray(route)) route = route.length > 1 ? route.shift() : route[0];
|
|
const { status = 200, body = '' } = route ?? { status: 404, body: '{"error":{"status":404,"message":"no route"}}' };
|
|
return { status, text: async () => (typeof body === 'string' ? body : JSON.stringify(body)) };
|
|
};
|
|
return { fetch, calls };
|
|
}
|
|
|
|
function loadSpotify({ settings = fakeSettings(), timers = null } = {}) {
|
|
const globals = timers ? { setTimeout: timers.setTimeout, clearTimeout: timers.clearTimeout } : {};
|
|
const types = load('app/native/media-types.ts');
|
|
const api = load('app/native/spotify-web-api.ts', {}, globals);
|
|
const auth = load('app/native/spotify-auth.ts', { './settings-store': settings, './spotify-web-api': api }, globals);
|
|
const player = load('app/native/spotify-player.ts', { './media-types': types, './spotify-web-api': api }, globals);
|
|
const library = load('app/native/spotify-library.ts', { './spotify-player': player }, globals);
|
|
const service = load('app/native/spotify-service.ts', {
|
|
'./settings-store': settings, './spotify-auth': auth, './spotify-library': library, './spotify-player': player, './spotify-web-api': api,
|
|
}, globals);
|
|
return { types, api, auth, player, library, service, settings };
|
|
}
|
|
|
|
function signedIn(extra = {}) {
|
|
return fakeSettings({
|
|
'music.spotify.clientId': CLIENT_ID,
|
|
'music.spotify.account': JSON.stringify({ clientId: CLIENT_ID, accessToken: 'access-1', refreshToken: 'refresh-1',
|
|
expiresAtMs: 9e15, userId: 'jim', displayName: 'Jim', product: 'premium', ...extra }),
|
|
});
|
|
}
|
|
|
|
const tokens = { accessToken: async force => (force ? 'fresh' : 'stale') };
|
|
|
|
function track(id, extra = {}) {
|
|
return { type: 'track', uri: `spotify:track:${id}`, name: `Song ${id}`, duration_ms: 200_000,
|
|
artists: [{ name: 'Band' }, { name: 'Guest' }], album: { name: 'Record', images: [
|
|
{ url: 'https://i.scdn.co/640', width: 640, height: 640 },
|
|
{ url: 'https://i.scdn.co/300', width: 300, height: 300 },
|
|
{ url: 'https://i.scdn.co/64', width: 64, height: 64 }] }, ...extra };
|
|
}
|
|
|
|
function playbackBody(extra = {}) {
|
|
return { device: { id: 'phone', name: "Jim's iPhone", type: 'Smartphone', is_active: true, volume_percent: 70, supports_volume: false },
|
|
is_playing: true, progress_ms: 30_000, shuffle_state: false, repeat_state: 'off', context: { uri: 'spotify:playlist:p1' },
|
|
item: track('a'), currently_playing_type: 'track', actions: { disallows: { resuming: true } }, ...extra };
|
|
}
|
|
|
|
test('the Web API client parses playback, retries a 401 with a fresh token and names player errors', async () => {
|
|
const { api } = loadSpotify();
|
|
const f = fakeFetch({
|
|
'GET /me/player': [{ status: 401, body: '' }, { body: playbackBody({
|
|
item: { type: 'episode', uri: 'spotify:episode:e', name: 'Ep', duration_ms: 1000, images: [], show: { name: 'Show', images: [{ url: 'u', width: 300 }] } },
|
|
}) }],
|
|
'PUT /me/player/play': { status: 404, body: { error: { status: 404, message: 'Player command failed: No active device found', reason: 'NO_ACTIVE_DEVICE' } } },
|
|
'POST /me/player/next': { status: 403, body: { error: { status: 403, message: 'Premium required', reason: 'PREMIUM_REQUIRED' } } },
|
|
'PUT /me/player/pause': { status: 204 },
|
|
});
|
|
const client = new api.SpotifyClient(f.fetch, tokens);
|
|
const playback = await client.playback();
|
|
assert.deepEqual(f.calls.map(call => call.headers.Authorization), ['Bearer stale', 'Bearer fresh']);
|
|
assert.equal(f.calls[0].query.additional_types, 'episode');
|
|
assert.equal(playback.playing, true); assert.equal(playback.device.type, 'Smartphone'); assert.equal(playback.device.volumePercent, 70);
|
|
assert.deepEqual(plain(playback.disallows), ['resuming']); assert.equal(playback.contextUri, 'spotify:playlist:p1');
|
|
assert.equal(playback.item.type, 'episode'); assert.equal(playback.item.artists, 'Show'); assert.equal(playback.item.images[0].url, 'u');
|
|
|
|
await assert.rejects(client.play({ contextUri: 'spotify:album:x', offsetUri: 'spotify:track:y' }),
|
|
error => error instanceof api.SpotifyApiError && error.reason === 'NO_ACTIVE_DEVICE' && /Open Spotify/.test(error.message));
|
|
const play = f.calls.find(call => call.path === '/me/player/play');
|
|
assert.deepEqual(JSON.parse(play.body), { context_uri: 'spotify:album:x', offset: { uri: 'spotify:track:y' } });
|
|
assert.equal(play.headers['Content-Type'], 'application/json');
|
|
await assert.rejects(client.next(), /needs Spotify Premium/);
|
|
// Body-less commands still send an (empty) body, or Spotify answers 411.
|
|
await client.pause();
|
|
assert.equal(f.calls.at(-1).body, '');
|
|
assert.equal(f.calls.find(call => call.method === 'GET').body, undefined);
|
|
});
|
|
|
|
test('the Web API client follows next links and reads the renamed playlist item field', async () => {
|
|
const { api } = loadSpotify();
|
|
const f = fakeFetch({
|
|
'GET /playlists/p1/items': call => (call.query.offset === '2'
|
|
? { body: { items: [{ track: track('c') }], next: null } }
|
|
: { body: { items: [{ item: track('a') }, { item: null }, { item: track('b') }], next: 'https://api.spotify.com/v1/playlists/p1/items?offset=2' } }),
|
|
'GET /me/following': { body: { artists: { items: [{ id: 'ar', name: 'Artist', uri: 'spotify:artist:ar' }], next: null } } },
|
|
'GET /search': { body: { tracks: { items: [track('s')] }, playlists: { items: [null, { id: 'pl', name: 'Mix', owner: { id: 'o' } }] } } },
|
|
});
|
|
const client = new api.SpotifyClient(f.fetch, tokens);
|
|
assert.deepEqual(plain((await client.playlistItems('p1')).map(item => item.name)), ['Song a', 'Song b', 'Song c']);
|
|
assert.equal(f.calls[0].query.limit, '50');
|
|
assert.equal((await client.followedArtists())[0].name, 'Artist');
|
|
const results = await client.search('daft punk', ['track', 'playlist'], 50);
|
|
assert.equal(f.calls.at(-1).query.limit, '10'); // development-mode maximum
|
|
assert.equal(f.calls.at(-1).query.q, 'daft punk');
|
|
assert.equal(results.tracks[0].artists, 'Band, Guest');
|
|
assert.equal(results.playlists.length, 1); assert.equal(results.playlists[0].uri, 'spotify:playlist:pl');
|
|
});
|
|
|
|
test('sign-in builds a PKCE authorize URL, exchanges the code and stores the account', async () => {
|
|
const settings = fakeSettings({ 'music.spotify.clientId': CLIENT_ID });
|
|
const { auth } = loadSpotify({ settings });
|
|
const f = fakeFetch({
|
|
'POST /api/token': { body: { access_token: 'access-1', refresh_token: 'refresh-1', expires_in: 3600 } },
|
|
'GET /me': { body: { id: 'jim', display_name: 'Jim', product: 'premium' } },
|
|
});
|
|
let opened = null;
|
|
const webSignIn = {
|
|
createPkce: () => ({ verifier: 'verifier-1', challenge: 'challenge-1' }),
|
|
randomState: () => 'state-1',
|
|
open: async (url, port, redirectPath) => {
|
|
opened = { url, port, redirectPath };
|
|
return 'http://127.0.0.1:43823/spotify-callback?code=AQB%2Fcode&state=state-1';
|
|
},
|
|
cancel: () => {},
|
|
};
|
|
const account = await auth.signInToSpotify(f.fetch, webSignIn, () => 5_000);
|
|
const authorize = new URL(opened.url);
|
|
assert.equal(authorize.origin + authorize.pathname, 'https://accounts.spotify.com/authorize');
|
|
assert.equal(authorize.searchParams.get('client_id'), CLIENT_ID);
|
|
assert.equal(authorize.searchParams.get('redirect_uri'), 'http://127.0.0.1:43823/spotify-callback');
|
|
assert.equal(authorize.searchParams.get('code_challenge_method'), 'S256');
|
|
assert.equal(authorize.searchParams.get('code_challenge'), 'challenge-1');
|
|
assert.match(authorize.searchParams.get('scope'), /user-modify-playback-state .*user-library-modify/);
|
|
assert.deepEqual([opened.port, opened.redirectPath], [43823, '/spotify-callback']);
|
|
|
|
const exchange = Object.fromEntries(new URLSearchParams(f.calls[0].body));
|
|
assert.deepEqual(exchange, { grant_type: 'authorization_code', code: 'AQB/code', redirect_uri: 'http://127.0.0.1:43823/spotify-callback',
|
|
client_id: CLIENT_ID, code_verifier: 'verifier-1' });
|
|
assert.equal(f.calls[1].headers.Authorization, 'Bearer access-1');
|
|
assert.equal(account.displayName, 'Jim'); assert.equal(account.expiresAtMs, 5_000 + 3_600_000);
|
|
assert.equal(auth.readSpotifyAccount().refreshToken, 'refresh-1');
|
|
|
|
// Another client ID: the stored sign-in no longer counts.
|
|
settings.setStringSetting('music.spotify.clientId', 'f'.repeat(32));
|
|
assert.equal(auth.readSpotifyAccount(), null);
|
|
});
|
|
|
|
test('redirect parsing rejects mismatched state and reports a declined sign-in', () => {
|
|
const { auth } = loadSpotify();
|
|
assert.equal(auth.parseSpotifyRedirect('http://127.0.0.1:1/cb?state=s&code=a%20b', 's'), 'a b');
|
|
assert.throws(() => auth.parseSpotifyRedirect('http://127.0.0.1:1/cb?state=x&code=a', 's'), /didn't match/);
|
|
assert.throws(() => auth.parseSpotifyRedirect('http://127.0.0.1:1/cb?error=access_denied&state=s', 's'), /declined/);
|
|
assert.throws(() => auth.parseSpotifyRedirect('http://127.0.0.1:1/cb?state=s', 's'), /no authorization code/);
|
|
});
|
|
|
|
test('the session refreshes an expired token once for concurrent callers and signs out when revoked', async () => {
|
|
const settings = signedIn({ expiresAtMs: 0 });
|
|
const { auth } = loadSpotify({ settings });
|
|
let refreshes = 0;
|
|
const f = fakeFetch({ 'POST /api/token': () => {
|
|
refreshes++;
|
|
return refreshes === 1 ? { body: { access_token: 'access-2', refresh_token: 'refresh-2', expires_in: 3600 } }
|
|
: { status: 400, body: { error: 'invalid_grant', error_description: 'Refresh token revoked' } };
|
|
} });
|
|
const session = new auth.SpotifySession(f.fetch, () => 10_000);
|
|
assert.deepEqual(await Promise.all([session.accessToken(false), session.accessToken(false)]), ['access-2', 'access-2']);
|
|
assert.equal(refreshes, 1);
|
|
assert.equal(Object.fromEntries(new URLSearchParams(f.calls[0].body)).refresh_token, 'refresh-1');
|
|
// The rotated refresh token is kept; the new access token is used until it nears expiry.
|
|
assert.equal(auth.readSpotifyAccount().refreshToken, 'refresh-2');
|
|
assert.equal(await session.accessToken(false), 'access-2'); assert.equal(refreshes, 1);
|
|
|
|
await assert.rejects(session.accessToken(true), /Sign in again/);
|
|
assert.equal(auth.readSpotifyAccount(), null);
|
|
await assert.rejects(session.accessToken(false), /Not signed in/);
|
|
});
|
|
|
|
function playerFixture({ routes = {}, settings = signedIn() } = {}) {
|
|
const timers = fakeTimers();
|
|
const s = loadSpotify({ settings, timers });
|
|
const f = fakeFetch({ 'GET /me/player': { body: playbackBody() }, 'GET /me/library/contains': { body: [false] },
|
|
'GET /me/player/queue': { body: { currently_playing: track('a'), queue: [track('b'), track('c', { artists: [{ name: 'Other' }] })] } },
|
|
...routes });
|
|
const downloads = []; const decodes = []; const system = { volume: 40, set: [] };
|
|
const service = new s.service.SpotifyService({
|
|
packageName: 'com.spotify.client',
|
|
fetch: f.fetch,
|
|
webSignIn: { createPkce: () => ({}), randomState: () => '', open: async () => '', cancel: () => {} },
|
|
download: async url => { downloads.push(url); return new Uint8Array([1, 2, 3]); },
|
|
decodeArt: (_bytes, size) => { decodes.push(size); return { size }; },
|
|
systemVolume: { get: () => system.volume, set: value => system.set.push(value) },
|
|
});
|
|
// The player reads time from Date.now by default; give it the fake clock.
|
|
const player = new s.player.SpotifyPlayer({ client: service.client, packageName: 'com.spotify.client',
|
|
isSignedIn: () => s.auth.readSpotifyAccount() !== null,
|
|
download: async url => { downloads.push(url); return new Uint8Array([1, 2, 3]); },
|
|
decodeArt: (_bytes, size) => { decodes.push(size); return { size }; },
|
|
systemVolume: { get: () => system.volume, set: value => system.set.push(value) }, now: timers.now });
|
|
const flush = () => new Promise(resolve => setImmediate(resolve));
|
|
const settle = async () => { for (let i = 0; i < 6; i++) await flush(); };
|
|
return { ...s, f, timers, service, player, downloads, decodes, system, settle };
|
|
}
|
|
|
|
test('the player polls while listened to and maps playback, art and actions into the media state', async () => {
|
|
const p = playerFixture();
|
|
const states = [];
|
|
const unsubscribe = p.player.onStateChange(state => states.push(state));
|
|
assert.equal(states[0].available, false); assert.equal(states[0].accessEnabled, true);
|
|
p.timers.advance(0); await p.settle();
|
|
const state = p.player.snapshot();
|
|
assert.equal(state.available, true); assert.equal(state.playbackState, 'playing');
|
|
assert.equal(state.title, 'Song a'); assert.equal(state.artist, 'Band, Guest'); assert.equal(state.album, 'Record');
|
|
assert.equal(state.appName, 'Spotify'); assert.equal(state.packageName, 'com.spotify.client');
|
|
assert.equal(state.canPlayPause, true); assert.equal(state.canSkipNext, true);
|
|
assert.deepEqual(plain(state.customActions.map(action => action.name)), ['Shuffle: off', 'Repeat: off', 'Like song']);
|
|
// The 300px image (the smallest at least 128 wide), downloaded once and decoded per size.
|
|
assert.deepEqual(p.downloads, ['https://i.scdn.co/300']);
|
|
assert.deepEqual(plain(p.player.getAlbumArt(112)), { size: 112 }); p.player.getAlbumArt(112);
|
|
assert.deepEqual(p.decodes, [112]);
|
|
// Position advances between polls.
|
|
p.timers.advance(1_000);
|
|
assert.equal(p.player.snapshot().positionMs, 31_000);
|
|
// Polling continues on a playing interval, and stops with the last listener.
|
|
assert.ok(p.timers.delays().some(delay => delay > 0 && delay <= 5_000));
|
|
unsubscribe();
|
|
assert.deepEqual(p.timers.delays(), []);
|
|
});
|
|
|
|
test('pausing applies at once, resuming with no active device starts on an open phone, and failures become a notice', async () => {
|
|
let active = true;
|
|
const p = playerFixture({ routes: {
|
|
'PUT /me/player/pause': { status: 204 },
|
|
'PUT /me/player/play': call => (call.query.device_id || active ? { status: 204 }
|
|
: { status: 404, body: { error: { status: 404, reason: 'NO_ACTIVE_DEVICE', message: 'none' } } }),
|
|
'GET /me/player/devices': { body: { devices: [
|
|
{ id: 'mac', name: 'MacBook', type: 'Computer', is_active: false },
|
|
{ id: 'iphone', name: 'iPhone', type: 'Smartphone', is_active: false },
|
|
{ id: 'tv', name: 'TV', type: 'TV', is_restricted: true }] } },
|
|
'POST /me/player/next': { status: 403, body: { error: { status: 403, reason: 'PREMIUM_REQUIRED', message: 'x' } } },
|
|
} });
|
|
p.player.onStateChange(() => {});
|
|
p.timers.advance(0); await p.settle();
|
|
await p.player.playPause();
|
|
assert.equal(p.player.snapshot().playbackState, 'paused');
|
|
assert.equal(p.f.calls.filter(call => call.path === '/me/player/pause').length, 1);
|
|
|
|
active = false;
|
|
await p.player.playPause();
|
|
const plays = p.f.calls.filter(call => call.path === '/me/player/play');
|
|
assert.deepEqual(plays.map(call => call.query.device_id ?? ''), ['', 'iphone']);
|
|
assert.deepEqual(JSON.parse(plays[1].body), {});
|
|
|
|
await p.player.skipNext();
|
|
assert.match(p.player.snapshot().notice, /Premium/);
|
|
// A settle poll re-reads soon after each command.
|
|
assert.ok(p.timers.delays().some(delay => delay <= 600));
|
|
p.timers.advance(8_100);
|
|
assert.equal(p.player.snapshot().notice, '');
|
|
});
|
|
|
|
test('the queue lists the current track first and jumping skips forward to the chosen item', async () => {
|
|
const p = playerFixture({ routes: { 'POST /me/player/next': { status: 204 } } });
|
|
p.player.onStateChange(() => {});
|
|
p.timers.advance(0); await p.settle();
|
|
assert.deepEqual(plain(p.player.getQueue()), []); // first read in flight
|
|
await p.settle();
|
|
assert.deepEqual(plain(p.player.getQueue().map(item => [item.id, item.title, item.subtitle, item.active])),
|
|
[[0, 'Song a', 'Band, Guest', true], [1, 'Song b', 'Band, Guest', false], [2, 'Song c', 'Other', false]]);
|
|
await p.player.skipToQueueItem(2);
|
|
assert.equal(p.f.calls.filter(call => call.path === '/me/player/next').length, 2);
|
|
assert.equal(p.player.snapshot().title, 'Song c');
|
|
assert.deepEqual(plain(p.player.getQueue().map(item => item.title)), ['Song c']);
|
|
});
|
|
|
|
test('volume goes to a speaker through Spotify and to this phone through the system volume', async () => {
|
|
const p = playerFixture({ routes: {
|
|
'GET /me/player': { body: playbackBody({ device: { id: 'spk', name: 'Kitchen', type: 'Speaker', is_active: true, volume_percent: 30, supports_volume: true } }) },
|
|
'PUT /me/player/volume': { status: 204 },
|
|
} });
|
|
p.player.onStateChange(() => {});
|
|
p.timers.advance(0); await p.settle();
|
|
assert.equal(p.player.snapshot().appName, 'Spotify · Kitchen');
|
|
assert.equal(p.player.getMediaVolumePercent(), 30);
|
|
p.player.setMediaVolumePercent(32); p.player.setMediaVolumePercent(34);
|
|
assert.equal(p.player.getMediaVolumePercent(), 34);
|
|
await p.settle();
|
|
const volumes = p.f.calls.filter(call => call.path === '/me/player/volume');
|
|
// One request in flight; the latest value follows it.
|
|
assert.deepEqual(volumes.map(call => [call.query.volume_percent, call.query.device_id]), [['32', 'spk'], ['34', 'spk']]);
|
|
|
|
const phone = playerFixture();
|
|
phone.player.onStateChange(() => {});
|
|
phone.timers.advance(0); await phone.settle();
|
|
assert.equal(phone.player.getMediaVolumePercent(), 40);
|
|
phone.player.setMediaVolumePercent(55);
|
|
assert.deepEqual(phone.system.set, [55]);
|
|
assert.equal(phone.f.calls.some(call => call.path === '/me/player/volume'), false);
|
|
});
|
|
|
|
test('shuffle, repeat and like run their Web API calls and relabel at once', async () => {
|
|
const p = playerFixture({ routes: {
|
|
'PUT /me/player/shuffle': { status: 204 }, 'PUT /me/player/repeat': { status: 204 }, 'PUT /me/library': { status: 200 },
|
|
} });
|
|
p.player.onStateChange(() => {});
|
|
p.timers.advance(0); await p.settle();
|
|
await p.player.sendCustomAction('shuffle');
|
|
await p.player.sendCustomAction('repeat');
|
|
await p.player.sendCustomAction('like');
|
|
assert.deepEqual(plain(p.player.snapshot().customActions.map(action => action.name)), ['Shuffle: on', 'Repeat: all', 'Unlike song']);
|
|
const calls = p.f.calls.filter(call => call.method === 'PUT');
|
|
assert.deepEqual(calls.map(call => [call.path, call.query.state ?? call.query.uris]),
|
|
[['/me/player/shuffle', 'true'], ['/me/player/repeat', 'context'], ['/me/library', 'spotify:track:a']]);
|
|
});
|
|
|
|
test('signed out, the player reports no access and never calls the API', async () => {
|
|
const p = playerFixture({ settings: fakeSettings({ 'music.spotify.clientId': CLIENT_ID }) });
|
|
p.player.onStateChange(() => {});
|
|
p.timers.advance(0); await p.settle();
|
|
assert.equal(p.player.snapshot().accessEnabled, false);
|
|
assert.equal(p.f.calls.length, 0);
|
|
});
|
|
|
|
test('the library tree lists owned playlists as browsable and plays tracks within their context', async () => {
|
|
const s = loadSpotify({ settings: signedIn() });
|
|
const f = fakeFetch({
|
|
'GET /me/playlists': { body: { items: [
|
|
{ id: 'mine', name: 'Mine', owner: { id: 'jim' } },
|
|
{ id: 'theirs', name: 'Theirs', owner: { id: 'spotify', display_name: 'Spotify' } },
|
|
{ id: 'collab', name: 'Collab', collaborative: true, owner: { id: 'friend' } }], next: null } },
|
|
'GET /me/player/recently-played': { body: { items: [
|
|
{ track: track('a'), context: { uri: 'spotify:album:al' } }, { track: track('a'), context: null }, { track: track('b'), context: null }] } },
|
|
});
|
|
const plays = [];
|
|
const library = new s.library.SpotifyLibrary({ client: new s.api.SpotifyClient(f.fetch, tokens), packageName: 'com.spotify.client',
|
|
player: { startPlayback: async request => { plays.push(request); return true; } },
|
|
isSignedIn: () => true, userId: () => 'jim' });
|
|
const [app] = library.listBrowsableApps();
|
|
assert.equal(await library.connect(app), 'root');
|
|
assert.deepEqual(plain((await library.browse('root')).map(row => row.title)), ['Recently played', 'Playlists', 'Liked Songs', 'Albums', 'Artists']);
|
|
const playlists = await library.browse('playlists');
|
|
assert.deepEqual(plain(playlists.map(row => [row.title, row.browsable, row.subtitle])),
|
|
[['Mine', true, ''], ['Theirs', false, 'Spotify'], ['Collab', true, '']]);
|
|
const recent = await library.browse('recent');
|
|
assert.deepEqual(plain(recent.map(row => row.mediaId)), ['track:spotify:track:a|spotify:album:al', 'track:spotify:track:b']);
|
|
|
|
library.playFromMediaId(recent[0].mediaId);
|
|
library.playFromMediaId(recent[1].mediaId);
|
|
library.playFromMediaId('track:spotify:track:z|liked');
|
|
library.playFromMediaId('liked');
|
|
library.playFromMediaId('playlist:mine');
|
|
assert.deepEqual(plain(plays), [
|
|
{ contextUri: 'spotify:album:al', offsetUri: 'spotify:track:a' },
|
|
{ uris: ['spotify:track:b'] },
|
|
{ contextUri: 'spotify:user:jim:collection', offsetUri: 'spotify:track:z' },
|
|
{ contextUri: 'spotify:user:jim:collection' },
|
|
{ contextUri: 'spotify:playlist:mine' },
|
|
]);
|
|
library.disconnect();
|
|
await assert.rejects(library.browse('root'), /Not connected/);
|
|
});
|
|
|
|
test('search-and-play starts the best match and explains failures', async () => {
|
|
const p = playerFixture({ routes: {
|
|
'GET /search': call => ({ body: call.query.type === 'album'
|
|
? { albums: { items: [{ id: 'al', name: 'Discovery', uri: 'spotify:album:al', artists: [{ name: 'Daft Punk' }] }] } }
|
|
: { tracks: { items: [] } } }),
|
|
'PUT /me/player/play': { status: 204 },
|
|
} });
|
|
assert.equal(await p.service.playSearch('discovery', 'album'), 'the album Discovery by Daft Punk');
|
|
const play = p.f.calls.find(call => call.path === '/me/player/play');
|
|
assert.deepEqual(JSON.parse(play.body), { context_uri: 'spotify:album:al' });
|
|
await assert.rejects(p.service.playSearch('nothing'), /found no track/);
|
|
});
|
|
|
|
test('the service resets the player when the signed-in account changes, not when tokens refresh', async () => {
|
|
const p = playerFixture();
|
|
const reset = [];
|
|
p.service.player.accountChanged = () => reset.push('reset');
|
|
const changes = [];
|
|
p.service.onChange(() => changes.push('change'));
|
|
const account = JSON.parse(p.settings.values.get('music.spotify.account'));
|
|
p.settings.setStringSetting('music.spotify.account', JSON.stringify({ ...account, accessToken: 'access-9' }));
|
|
assert.deepEqual(reset, []);
|
|
p.service.signOut();
|
|
assert.deepEqual(reset, ['reset']);
|
|
assert.equal(p.service.account(), null);
|
|
assert.ok(changes.length >= 2);
|
|
});
|
|
|
|
function composite(appleState, spotifyState, spotifyLastPlayingAtMs = 0) {
|
|
const types = load('app/native/media-types.ts');
|
|
const calls = [];
|
|
const fakeBridge = (name, state) => ({
|
|
accessLabel: `${name} label`, accessAction: `${name} action`, skipRebuildsQueue: name === 'spotify', state, lastPlayingAtMs: 0,
|
|
onStateChange(listener) { listener(this.state); return () => {}; },
|
|
snapshot() { return this.state; }, start: async () => calls.push(`${name}:start`), stop: async () => {},
|
|
playPause: async () => calls.push(`${name}:playPause`), skipNext: async () => calls.push(`${name}:next`),
|
|
getAlbumArt: () => name, getQueue: () => [], refresh: async () => calls.push(`${name}:refresh`),
|
|
hasAccess: () => name === 'apple', requestAccess: async () => calls.push(`${name}:access`),
|
|
});
|
|
const apple = fakeBridge('apple', appleState);
|
|
const spotify = fakeBridge('spotify', spotifyState);
|
|
spotify.lastPlayingAtMs = spotifyLastPlayingAtMs;
|
|
const api = load('app/native/media-controller.ios.ts', {
|
|
'@nativescript/core': { Dialogs: {}, Utils: {} }, './image-files': {}, './kotlin-data': {}, './media-types': types,
|
|
'./spotify.ios': { spotifyService: () => null },
|
|
});
|
|
const bridge = new api.IosMediaControllerBridge(apple, () => (spotifyState ? spotify : null), () => 50);
|
|
return { api, bridge, calls, apple, spotify, types };
|
|
}
|
|
|
|
test('the iOS bridge follows whichever player is playing and routes commands to it', async () => {
|
|
const types = load('app/native/media-types.ts');
|
|
const base = { ...types.DEFAULT_MEDIA_STATE, accessEnabled: true };
|
|
const playing = { ...base, available: true, playbackState: 'playing', title: 'Playing' };
|
|
const paused = { ...base, available: true, playbackState: 'paused', title: 'Paused' };
|
|
const { chooseMediaSource } = composite(base, null).api;
|
|
assert.equal(chooseMediaSource('apple-music', base, null, 0, 0), 'apple-music');
|
|
assert.equal(chooseMediaSource('apple-music', { ...base, accessEnabled: false }, base, 0, 0), 'spotify');
|
|
assert.equal(chooseMediaSource('apple-music', paused, playing, 0, 0), 'spotify');
|
|
assert.equal(chooseMediaSource('spotify', playing, paused, 0, 0), 'apple-music');
|
|
assert.equal(chooseMediaSource('spotify', playing, playing, 0, 0), 'spotify'); // no flapping
|
|
assert.equal(chooseMediaSource('spotify', paused, paused, 20, 10), 'apple-music'); // played last
|
|
assert.equal(chooseMediaSource('apple-music', paused, paused, 0, 0), 'spotify');
|
|
assert.equal(chooseMediaSource('apple-music', paused, base, 0, 0), 'apple-music');
|
|
|
|
const c = composite(paused, { ...playing, notice: '' });
|
|
assert.equal(c.bridge.snapshot().title, 'Playing');
|
|
assert.equal(c.bridge.skipRebuildsQueue, true);
|
|
await c.bridge.playPause(); await c.bridge.refresh();
|
|
assert.deepEqual(c.calls, ['spotify:playPause', 'spotify:refresh']);
|
|
assert.equal(c.bridge.getAlbumArt(10), 'spotify');
|
|
const firstArt = c.bridge.snapshot().artVersion;
|
|
// Switching players changes the art version even when the sources' versions match.
|
|
c.spotify.state = { ...paused, notice: 'Spotify needs Premium' };
|
|
c.apple.state = { ...playing, title: 'Apple' };
|
|
const state = c.bridge.snapshot();
|
|
assert.equal(state.title, 'Apple'); assert.notEqual(state.artVersion, firstArt);
|
|
// A Spotify failure still shows while Apple Music is the player shown.
|
|
assert.equal(state.notice, 'Spotify needs Premium');
|
|
assert.equal(c.bridge.hasAccess(), true); // Apple Music's permission
|
|
await c.bridge.requestAccess();
|
|
assert.equal(c.calls.at(-1), 'apple:access');
|
|
|
|
const idle = composite(base, base);
|
|
assert.equal(idle.bridge.snapshot().status, 'Nothing is playing.');
|
|
});
|
|
|
|
test('the assistant offers Spotify search-and-play once signed in and refreshes before reading media state', async () => {
|
|
let account = null; const searches = []; const refreshes = [];
|
|
const spotify = {
|
|
account: () => account,
|
|
playSearch: async (query, kind) => { searches.push([query, kind]); if (query === 'fail') throw new Error('No device'); return 'Song by Band'; },
|
|
};
|
|
const registered = new Map(); const systemTools = new Map();
|
|
const { registerSystemTools } = load('app/assistant/system-tools.ts', {
|
|
'../native/calendar': {}, '../native/calendar-permissions': {},
|
|
'../native/media-controller': { mediaControllerBridge: { start: async () => {}, refresh: async () => refreshes.push('refresh'),
|
|
snapshot: () => ({ accessEnabled: true, playbackState: 'playing', title: 'Song', artist: 'Band', appName: 'Spotify' }) } },
|
|
'../native/spotify': { spotifyService: () => spotify },
|
|
'../native/notification-icons': {}, '../ui/shell/shell': {}, './tool-registry': {},
|
|
}, { global: { isIOS: true } });
|
|
registerSystemTools({
|
|
registerSystemTool: (definition, handler) => systemTools.set(definition.name, handler),
|
|
register: registration => registered.set(registration.spec.name, registration),
|
|
});
|
|
assert.match((await systemTools.get('media.now_playing')()).content, /Playing: Song by Band in Spotify/);
|
|
assert.deepEqual(refreshes, ['refresh']);
|
|
|
|
const tool = registered.get('media.spotify_play');
|
|
assert.equal(tool.spec.availability, 'always');
|
|
assert.equal(tool.isAvailable(), false);
|
|
account = { userId: 'jim' };
|
|
assert.equal(tool.isAvailable(), true);
|
|
assert.equal((await tool.handler({ query: ' discovery ', kind: 'album' })).content, 'Playing Song by Band on Spotify.');
|
|
await tool.handler({ query: 'x', kind: 'podcast' });
|
|
assert.deepEqual(plain(searches), [['discovery', 'album'], ['x', 'track']]);
|
|
assert.equal((await tool.handler({ query: 'fail' })).error, 'No device');
|
|
assert.equal((await tool.handler({ query: ' ' })).ok, false);
|
|
});
|