Files
SubMiner/src/main/assemblies/settings.test.ts
T
sudacode 2924f04316 refactor(main): move domains into per-domain assemblies (#309)
* refactor(main): move the YouTube domain into an assembly

createYoutubeAssembly owns the YouTube flow, playback, media cache,
whisper subtitles, primary-subtitle notifications, and the in-app
browser, plus the browser quit-on-close state. main.ts builds it once
where the first YouTube runtime used to be and calls through the result.
Siblings built later are passed as getters or callbacks; tests pin that
construction calls none of them.

* docs(architecture): describe per-domain assemblies

* test(e2e): blank the line before mining the sub-delay cue

The previous test leaves the same cue on screen, so the overlay check
passed before the seek landed and --mine-sentence could read mpv's empty
mid-seek sub-text and skip the card.

* refactor(main): move the Jellyfin domain into an assembly

createJellyfinAssembly owns the Jellyfin composer call, its playback and
remote-progress state, the subtitle cache IO, mpv defaults, and the tray
discovery deps. main.ts builds it where the composer call used to be and
reads state through getActivePlayback/getQuitOnDisconnectArmed.

* refactor(main): move the AniList domain into an assembly

createAnilistAssembly owns the AniList setup and tracking composer calls,
the setup window, the state runtime, and the token, media-guess, in-flight
and attempted-update state they share. main.ts builds it where the setup
composer call used to be and keeps the rate limiter, which the stats
cover-art fetcher also uses.

* refactor(main): move config hot-reload, settings, and sync UI into assemblies

createSettingsAssembly owns config hot-reload and the settings window,
which share the hot-reload-applied handler; main.ts still supplies that
handler's cross-domain deps and the Yomitan deck-name helper.
createSyncAssembly owns the sync window, sync IPC runtime, and auto-sync
scheduler. Both are built where their blocks were; main.ts keeps the
registerHandlers()/start() calls at the same points.

* refactor(main): move dictionary runtimes into assemblies

createDictionariesAssembly owns the JLPT and frequency lookups and their
dictionary-root builders; main.ts still resolves the root paths at the
same point. createCharacterDictionaryAssembly owns the character
dictionary runtime, Yomitan auto-sync, and the portrait and name-candidate
lookups. Both are built where their blocks were; later siblings (Yomitan
profile policy, notifications, OSD, subtitle refresh) come in as getters
or callbacks.

* refactor(main): move overlay modal openers into an assembly

createOverlayModalsAssembly owns the shared open-with-notification helper
and the runtime options, Jimaku, TsukiHime, subtitle generation, session
help, changelog, character dictionary manager, controller, and playlist
browser openers. main.ts builds it where the openers used to live.

* refactor(logger): export the Logger type for assembly deps

The build emits declarations, and the Jellyfin assembly returns the logger
in its tray discovery deps, so tsc needs a nameable Logger type. Assemblies
now Pick from it directly.
2026-10-31 19:39:27 -07:00

46 lines
1.9 KiB
TypeScript

import assert from 'node:assert/strict';
import test from 'node:test';
import { createSettingsAssembly, type SettingsAssemblyDeps } from './settings';
// Every callback throws, so a test fails if the assembly calls a dep it should only call later.
function makeDeps(): SettingsAssemblyDeps {
const lazy = (name: string) => (): never => {
throw new Error(`${name} called unexpectedly`);
};
return {
appState: { configSettingsWindow: null },
configService: {
getConfig: lazy('getConfig'),
getConfigPath: lazy('getConfigPath'),
getRawConfig: lazy('getRawConfig'),
getWarnings: lazy('getWarnings'),
reloadConfigStrict: lazy('reloadConfigStrict'),
},
logger: { error: lazy('error') },
getOverlayNotifications: lazy('getOverlayNotifications'),
showMpvOsd: lazy('showMpvOsd'),
showDesktopNotification: lazy('showDesktopNotification'),
hotReloadApplied: {
setKeybindings: lazy('setKeybindings'),
setSessionBindings: lazy('setSessionBindings'),
refreshGlobalAndOverlayShortcuts: lazy('refreshGlobalAndOverlayShortcuts'),
setSecondarySubMode: lazy('setSecondarySubMode'),
broadcastToOverlayWindows: lazy('broadcastToOverlayWindows'),
applyAnkiRuntimeConfigPatch: lazy('applyAnkiRuntimeConfigPatch'),
},
getYomitanAnkiDeckName: lazy('getYomitanAnkiDeckName'),
showErrorBox: lazy('showErrorBox'),
createBrowserWindow: lazy('createBrowserWindow'),
mainDirname: '/tmp/subminer-main',
openPath: lazy('openPath'),
ipcMain: { handle: lazy('ipcMain.handle') },
};
}
// main.ts builds the assembly before most siblings exist, so construction must stay lazy.
test('createSettingsAssembly does not call its deps while constructing', () => {
const settings = createSettingsAssembly(makeDeps());
assert.equal(typeof settings.hotReload.start, 'function');
assert.equal(typeof settings.window.registerHandlers, 'function');
});