diff --git a/build-scripts/check-coverage-thresholds.js b/build-scripts/check-coverage-thresholds.js index 5632630..9e2cf62 100644 --- a/build-scripts/check-coverage-thresholds.js +++ b/build-scripts/check-coverage-thresholds.js @@ -13,6 +13,9 @@ const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf8')); const thresholds = { 'src/main/main.ts': { lines: 12, statements: 12 }, 'src/main/preload.ts': { lines: 80, statements: 80 }, + 'src/main/processKill.ts': { lines: 80, statements: 80 }, + 'src/utils/validation.ts': { lines: 85, statements: 85 }, + 'src/utils/downloadLifecycle.ts': { lines: 90, statements: 90 }, }; function findCoverageEntry(suffix) { @@ -46,4 +49,4 @@ if (failures.length > 0) { process.exit(1); } -console.log('Coverage thresholds passed for main.ts and preload.ts.'); +console.log('Coverage thresholds passed.'); diff --git a/build-scripts/test-all.js b/build-scripts/test-all.js index 7705c1b..b18de74 100644 --- a/build-scripts/test-all.js +++ b/build-scripts/test-all.js @@ -16,6 +16,7 @@ const colors = { const results = { unit: { status: 'pending', passed: 0, failed: 0 }, + compile: { status: 'pending' }, lint: { status: 'pending' }, format: { status: 'pending' }, typecheck: { status: 'pending' }, @@ -152,6 +153,10 @@ function runConfigChecks() { 'package.json: scripts.test:all must run build-scripts/test-all.js' ); assertConfig(pkg.main === 'dist/main/main.js', 'package.json: main must be dist/main/main.js'); + assertConfig( + pkg.desktopName === 'com.burnttoasters.rosi.desktop', + 'package.json: desktopName must be com.burnttoasters.rosi.desktop' + ); assertConfig( Boolean(pkg.scripts && pkg.scripts['ffmpeg:check']), 'package.json: missing scripts.ffmpeg:check' @@ -186,6 +191,10 @@ function runConfigChecks() { Array.isArray(baseConfig.linux?.extraResources), 'electron-builder.base.yml: linux.extraResources missing for yt-dlp binaries' ); + assertConfig( + baseConfig.linux?.syncDesktopName === true, + 'electron-builder.base.yml: linux.syncDesktopName must be true' + ); assertConfig( Boolean(githubConfig.publish), 'electron-builder.github.yml: missing publish config' @@ -209,6 +218,7 @@ function runConfigChecks() { 'build/app-icon.icns', 'build/app-icon.png', 'build/appx/appxmanifest.xml', + 'com.burnttoasters.rosi.desktop', ]; for (const relativePath of requiredFiles) { assertConfig( @@ -234,6 +244,9 @@ function run() { const unitResult = runCommand('unit', 'npm test', parseUnitTests); results.unit.status = unitResult.ok ? 'passed' : 'failed'; + const compileResult = runCommand('compile', 'npm run compile'); + results.compile.status = compileResult.ok ? 'passed' : 'failed'; + const lintResult = runCommand('lint', 'npm run lint'); results.lint.status = lintResult.ok ? 'passed' : 'failed'; @@ -250,6 +263,7 @@ function run() { const summaryLines = [ `${colors.bold}Unit:${colors.reset} ${results.unit.status === 'passed' ? colors.green + '✓ PASS' : colors.red + '✗ FAIL'}${colors.reset} (${results.unit.passed} passed${results.unit.failed > 0 ? `, ${results.unit.failed} failed` : ''})`, + `${colors.bold}Compile:${colors.reset} ${results.compile.status === 'passed' ? colors.green + '✓ PASS' : colors.red + '✗ FAIL'}${colors.reset}`, `${colors.bold}Lint:${colors.reset} ${results.lint.status === 'passed' ? colors.green + '✓ PASS' : colors.red + '✗ FAIL'}${colors.reset}`, `${colors.bold}Format:${colors.reset} ${results.format.status === 'passed' ? colors.green + '✓ PASS' : colors.red + '✗ FAIL'}${colors.reset}`, `${colors.bold}Typecheck:${colors.reset} ${results.typecheck.status === 'passed' ? colors.green + '✓ PASS' : colors.red + '✗ FAIL'}${colors.reset}`, @@ -289,4 +303,11 @@ if (require.main === module) { run(); } -module.exports = { runCommand, runSyntaxChecks, runConfigChecks }; +module.exports = { + runCommand, + runSyntaxChecks, + runConfigChecks, + stripAnsi, + parseUnitTests, + results, +}; diff --git a/com.burnttoasters.rosi.desktop b/com.burnttoasters.rosi.desktop index f83458c..e84fb5c 100644 --- a/com.burnttoasters.rosi.desktop +++ b/com.burnttoasters.rosi.desktop @@ -6,5 +6,5 @@ Icon=com.burnttoasters.rosi Type=Application Categories=Utility;AudioVideo;Network; StartupNotify=true -StartupWMClass=Rosi +StartupWMClass=com.burnttoasters.rosi Keywords=video;download;yt-dlp;youtube;converter;ffmpeg; diff --git a/electron-builder.base.yml b/electron-builder.base.yml index 7c52f5e..fb673f7 100644 --- a/electron-builder.base.yml +++ b/electron-builder.base.yml @@ -66,6 +66,7 @@ linux: - rpm icon: build/app-icon.png category: Utility + syncDesktopName: true extraResources: - from: assets/ to: assets/ diff --git a/package.json b/package.json index 62f1df1..663d3d4 100644 --- a/package.json +++ b/package.json @@ -3,6 +3,7 @@ "version": "4.1.0-beta.2", "private": true, "description": "Electron GUI for yt-dlp", + "desktopName": "com.burnttoasters.rosi.desktop", "keywords": [ "electron", "yt-dlp", diff --git a/src/tests/buildScripts.gitPrune.test.ts b/src/tests/buildScripts.gitPrune.test.ts new file mode 100644 index 0000000..a772f93 --- /dev/null +++ b/src/tests/buildScripts.gitPrune.test.ts @@ -0,0 +1,37 @@ +import { describe, expect, it } from 'vitest'; + +const { + parseArgs, + selectBranchesToDelete, + stripRemotePrefix, +} = require('../../build-scripts/git-prune-local-branches.js'); + +describe('git-prune-local-branches helpers', () => { + it('parseArgs reads remote, dry-run, and force flags', () => { + expect(parseArgs(['node', 'script.js'])).toEqual({ + remote: 'origin', + dryRun: false, + force: false, + }); + expect(parseArgs(['node', 'script.js', '--remote', 'upstream', '-n', '--force'])).toEqual({ + remote: 'upstream', + dryRun: true, + force: true, + }); + }); + + it('stripRemotePrefix removes the remote prefix', () => { + expect(stripRemotePrefix('origin/main', 'origin')).toBe('main'); + expect(stripRemotePrefix('origin/HEAD', 'origin')).toBeNull(); + expect(stripRemotePrefix('main', 'origin')).toBeNull(); + }); + + it('selectBranchesToDelete keeps current and remote-tracking branches', () => { + const result = selectBranchesToDelete( + ['main', 'feature/a', 'feature/b'], + ['main', 'feature/a'], + 'main' + ); + expect(result).toEqual(['feature/b']); + }); +}); diff --git a/src/tests/buildScripts.postRelease.test.ts b/src/tests/buildScripts.postRelease.test.ts new file mode 100644 index 0000000..6d33ea7 --- /dev/null +++ b/src/tests/buildScripts.postRelease.test.ts @@ -0,0 +1,70 @@ +import fs from 'fs'; +import os from 'os'; +import path from 'path'; +import { afterEach, describe, expect, it } from 'vitest'; + +const { + cleanReleaseArtifacts, + copyReleaseAssets, + getAfterPackLocation, + run, +} = require('../../build-scripts/post-release-assets.js'); + +function makeTempDir(prefix: string) { + return fs.mkdtempSync(path.join(os.tmpdir(), prefix)); +} + +describe('post-release-assets helpers', () => { + const tempDirs: string[] = []; + + afterEach(() => { + for (const dir of tempDirs.splice(0)) { + fs.rmSync(dir, { recursive: true, force: true }); + } + }); + + it('reads AFTER_PACK_LOC from the environment', () => { + expect(getAfterPackLocation({})).toBe(''); + expect(getAfterPackLocation({ AFTER_PACK_LOC: ' /tmp/rosi-mirror ' })).toBe( + '/tmp/rosi-mirror' + ); + }); + + it('cleans build-only release artifacts', () => { + const releaseDir = makeTempDir('rosi-release-clean-'); + tempDirs.push(releaseDir); + fs.mkdirSync(path.join(releaseDir, 'win-unpacked')); + fs.writeFileSync(path.join(releaseDir, 'builder-debug.yml'), 'debug'); + + cleanReleaseArtifacts(releaseDir); + + expect(fs.existsSync(path.join(releaseDir, 'win-unpacked'))).toBe(false); + expect(fs.existsSync(path.join(releaseDir, 'builder-debug.yml'))).toBe(false); + }); + + it('mirrors cleaned release assets to AFTER_PACK_LOC', () => { + const releaseDir = makeTempDir('rosi-release-src-'); + const destination = makeTempDir('rosi-release-dest-'); + tempDirs.push(releaseDir, destination); + fs.writeFileSync(path.join(releaseDir, 'ROSI-Linux-amd64.deb'), 'deb'); + + const result = run({ + releaseDir, + env: { AFTER_PACK_LOC: destination }, + }); + + expect(result).toEqual({ mirrored: true, destination: path.resolve(destination) }); + expect(fs.existsSync(path.join(destination, 'ROSI-Linux-amd64.deb'))).toBe(true); + expect(fs.existsSync(path.join(releaseDir, 'ROSI-Linux-amd64.deb'))).toBe(true); + }); + + it('rejects mirroring into a subdirectory of the release folder', () => { + const releaseDir = makeTempDir('rosi-release-nested-'); + tempDirs.push(releaseDir); + fs.writeFileSync(path.join(releaseDir, 'artifact.txt'), 'data'); + + expect(() => copyReleaseAssets(releaseDir, path.join(releaseDir, 'mirror'))).toThrow( + 'AFTER_PACK_LOC cannot be inside the release directory' + ); + }); +}); diff --git a/src/tests/buildScripts.testAll.test.ts b/src/tests/buildScripts.testAll.test.ts new file mode 100644 index 0000000..4a50faf --- /dev/null +++ b/src/tests/buildScripts.testAll.test.ts @@ -0,0 +1,15 @@ +import { describe, expect, it } from 'vitest'; + +const { parseUnitTests, stripAnsi, results } = require('../../build-scripts/test-all.js'); + +describe('test-all helpers', () => { + it('stripAnsi removes terminal color codes', () => { + expect(stripAnsi('\u001b[32mPASS\u001b[0m')).toBe('PASS'); + }); + + it('parseUnitTests extracts passed and failed counts', () => { + parseUnitTests('Tests 12 passed | 2 failed (14)'); + expect(results.unit.passed).toBe(12); + expect(results.unit.failed).toBe(2); + }); +}); diff --git a/src/tests/constants.contract.test.ts b/src/tests/constants.contract.test.ts new file mode 100644 index 0000000..81c4d4d --- /dev/null +++ b/src/tests/constants.contract.test.ts @@ -0,0 +1,41 @@ +import { describe, expect, it } from 'vitest'; +import { + ALLOWED_AUDIO_FORMATS, + ALLOWED_BROWSERS, + ALLOWED_CONVERT_FORMATS, + CURRENT_SETTINGS_VERSION, + FORMAT_ID_PATTERN, + MAX_QUEUE_SIZE, + SUBTITLE_LANGS_PATTERN, +} from '../main/constants'; + +describe('constants contracts', () => { + it('accepts valid yt-dlp format IDs', () => { + expect(FORMAT_ID_PATTERN.test('137')).toBe(true); + expect(FORMAT_ID_PATTERN.test('hls-1080')).toBe(true); + expect(FORMAT_ID_PATTERN.test('136-drc')).toBe(true); + expect(FORMAT_ID_PATTERN.test('137; rm -rf /')).toBe(false); + expect(FORMAT_ID_PATTERN.test('best audio')).toBe(false); + }); + + it('accepts valid subtitle language lists', () => { + expect(SUBTITLE_LANGS_PATTERN.test('en')).toBe(true); + expect(SUBTITLE_LANGS_PATTERN.test('en,es,fr')).toBe(true); + expect(SUBTITLE_LANGS_PATTERN.test('en.*')).toBe(true); + expect(SUBTITLE_LANGS_PATTERN.test('en; rm -rf /')).toBe(false); + }); + + it('keeps allowed format and browser sets aligned with validation', () => { + expect(ALLOWED_CONVERT_FORMATS.has('mp4')).toBe(true); + expect(ALLOWED_CONVERT_FORMATS.has('avi')).toBe(false); + expect(ALLOWED_AUDIO_FORMATS.has('m4a')).toBe(true); + expect(ALLOWED_AUDIO_FORMATS.has('wma')).toBe(false); + expect(ALLOWED_BROWSERS.has('firefox')).toBe(true); + expect(ALLOWED_BROWSERS.has('internet explorer')).toBe(false); + }); + + it('keeps queue and settings version contracts stable', () => { + expect(MAX_QUEUE_SIZE).toBe(500); + expect(CURRENT_SETTINGS_VERSION).toBeGreaterThanOrEqual(1); + }); +}); diff --git a/src/tests/downloader.session.test.ts b/src/tests/downloader.session.test.ts new file mode 100644 index 0000000..64f91a7 --- /dev/null +++ b/src/tests/downloader.session.test.ts @@ -0,0 +1,181 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import { EventEmitter } from 'events'; +import * as os from 'os'; +import * as path from 'path'; + +const { existsSyncMock, statSyncMock, mkdirSyncMock, spawnWithEnvMock } = vi.hoisted(() => ({ + existsSyncMock: vi.fn(), + statSyncMock: vi.fn(), + mkdirSyncMock: vi.fn(), + spawnWithEnvMock: vi.fn(), +})); + +vi.mock('fs', () => ({ + existsSync: existsSyncMock, + statSync: statSyncMock, + mkdirSync: mkdirSyncMock, + rmSync: vi.fn(), +})); + +vi.mock('../main/platform', () => ({ + spawnWithEnv: spawnWithEnvMock, + getEffectiveFfmpegPath: vi.fn(() => 'ffmpeg'), + ytdlpBinary: 'yt-dlp', + isWindows: process.platform === 'win32', + isMac: process.platform === 'darwin', +})); + +vi.mock('../main/settings', () => ({ + loadSettings: vi.fn(() => ({ + settingsVersion: 1, + theme: 'system', + showConsoleOutput: false, + consoleCollapsed: false, + advancedOptions: false, + audioOnly: false, + convertEnabled: false, + convertFormat: 'mp4', + keepOriginalAfterConvert: true, + firstLaunch: false, + hookBrowser: false, + browserChoice: 'Chrome', + animateBackground: true, + notifications: true, + denoReminderDismissed: false, + gpuAcceleration: false, + gpuType: 'auto', + bestQuality: false, + ffmpegPath: '', + hideSupportModal: false, + checkUpdatesOnStartup: true, + updateChannel: 'auto', + audioFormat: 'mp3', + })), + recordDownload: vi.fn(), +})); + +vi.mock('electron', () => ({ + dialog: { + showMessageBox: vi.fn(), + }, +})); + +vi.mock('electron-log/main.js', () => ({ + default: { + warn: vi.fn(), + error: vi.fn(), + }, +})); + +import { + canStartDownload, + cancelActiveSession, + getDownloadSessionOwner, + isDownloadBusy, + startDownload, +} from '../main/downloader'; + +function createProc() { + const proc = new EventEmitter() as EventEmitter & { + stdout: EventEmitter; + stderr: EventEmitter; + kill: () => void; + killed: boolean; + pid: number; + }; + proc.stdout = new EventEmitter(); + proc.stderr = new EventEmitter(); + proc.pid = 1234; + proc.killed = false; + proc.kill = vi.fn(() => { + proc.killed = true; + setImmediate(() => proc.emit('close', 1)); + }); + return proc; +} + +function createSender() { + return { + send: vi.fn(), + isDestroyed: () => false, + } as unknown as Electron.WebContents; +} + +describe('downloader session state', () => { + const outputPath = path.join(os.homedir(), 'Downloads', 'rosi-session-test'); + + beforeEach(() => { + vi.clearAllMocks(); + existsSyncMock.mockImplementation((target: string) => { + const normalized = String(target).replace(/\\/g, '/'); + return normalized.includes('yt-dlp') || normalized.includes('rosi-session-test'); + }); + statSyncMock.mockReturnValue({ isDirectory: () => true }); + spawnWithEnvMock.mockReturnValue(createProc()); + }); + + afterEach(() => { + cancelActiveSession(false); + }); + + it('starts idle with no active owner', () => { + expect(isDownloadBusy()).toBe(false); + expect(getDownloadSessionOwner()).toBeNull(); + expect(canStartDownload('manual')).toBe(true); + expect(canStartDownload('queue')).toBe(true); + }); + + it('tracks the active owner while a download is running', () => { + startDownload( + '/tmp/yt-dlp', + createSender(), + { url: 'https://example.com/video', outputPath }, + null, + undefined, + 'manual' + ); + + expect(isDownloadBusy()).toBe(true); + expect(getDownloadSessionOwner()).toBe('manual'); + expect(canStartDownload('manual')).toBe(true); + expect(canStartDownload('queue')).toBe(false); + }); + + it('rejects starting a queue download while manual owns the session', () => { + startDownload( + '/tmp/yt-dlp', + createSender(), + { url: 'https://example.com/video', outputPath }, + null, + undefined, + 'manual' + ); + + expect(() => + startDownload( + '/tmp/yt-dlp', + createSender(), + { url: 'https://example.com/other', outputPath }, + null, + undefined, + 'queue' + ) + ).toThrow('Download session already active with a different owner.'); + }); + + it('clears session state when cancelled', () => { + startDownload( + '/tmp/yt-dlp', + createSender(), + { url: 'https://example.com/video', outputPath }, + null, + undefined, + 'queue' + ); + + expect(isDownloadBusy()).toBe(true); + cancelActiveSession(false); + expect(isDownloadBusy()).toBe(false); + expect(getDownloadSessionOwner()).toBeNull(); + }); +}); diff --git a/src/tests/ipc.contract.test.ts b/src/tests/ipc.contract.test.ts new file mode 100644 index 0000000..e454384 --- /dev/null +++ b/src/tests/ipc.contract.test.ts @@ -0,0 +1,46 @@ +import fs from 'fs'; +import path from 'path'; +import { describe, expect, it } from 'vitest'; + +function readRepoFile(relativePath: string) { + return fs.readFileSync(path.join(process.cwd(), relativePath), 'utf8'); +} + +function extractQuotedCalls(source: string, pattern: RegExp): string[] { + return [...source.matchAll(pattern)].map((match) => match[1]).filter(Boolean); +} + +describe('IPC channel contracts', () => { + const preload = readRepoFile('src/main/preload.ts'); + const main = readRepoFile('src/main/main.ts'); + + const invokeChannels = extractQuotedCalls(preload, /ipcRenderer\.invoke\('([^']+)'/g); + const sendChannels = extractQuotedCalls(preload, /ipcRenderer\.send\('([^']+)'/g); + const rendererEventChannels = extractQuotedCalls(preload, /ipcRenderer\.on\('([^']+)'/g); + const mainHandlers = extractQuotedCalls(main, /ipcMain\.handle\('([^']+)'/g); + const mainEvents = extractQuotedCalls(main, /ipcMain\.on\('([^']+)'/g); + + it('registers a main handler for every preload invoke channel', () => { + const missing = invokeChannels.filter((channel) => !mainHandlers.includes(channel)); + expect(missing, `missing ipcMain.handle registrations: ${missing.join(', ')}`).toEqual([]); + }); + + it('registers a main listener for every preload send channel', () => { + const missing = sendChannels.filter((channel) => !mainEvents.includes(channel)); + expect(missing, `missing ipcMain.on registrations: ${missing.join(', ')}`).toEqual([]); + }); + + it('documents renderer event channels used by preload subscriptions', () => { + expect(rendererEventChannels.sort()).toEqual( + [ + 'complete', + 'prepare-for-close', + 'progress', + 'queue-update', + 'settings-imported', + 'updater-progress', + 'updater-status', + ].sort() + ); + }); +}); diff --git a/src/tests/ipcValidation.paths.test.ts b/src/tests/ipcValidation.paths.test.ts new file mode 100644 index 0000000..d45042f --- /dev/null +++ b/src/tests/ipcValidation.paths.test.ts @@ -0,0 +1,49 @@ +import * as os from 'os'; +import * as path from 'path'; +import { describe, expect, it } from 'vitest'; +import { validateDownloadPath, validateFfmpegPathValue } from '../utils/ipcValidation'; + +function pathOutsideAllowedDownloadBases(): string { + if (process.platform === 'win32') { + return path.join(process.env.SystemRoot ?? 'C:\\Windows', 'Temp', 'rosi-outside-test'); + } + return '/tmp/rosi-outside-test'; +} + +describe('ipc path validation', () => { + it('accepts home-relative download paths', () => { + const homeFolder = path.join(os.homedir(), 'Downloads', 'rosi'); + const result = validateDownloadPath(homeFolder); + expect(result.ok).toBe(true); + if (result.ok) { + expect(result.data).toBe(path.resolve(homeFolder)); + } + }); + + it('rejects relative download paths', () => { + const result = validateDownloadPath('relative/downloads'); + expect(result.ok).toBe(false); + if (!result.ok) { + expect(result.error.code).toBe('INVALID_PATH'); + } + }); + + it('rejects paths outside allowed download bases', () => { + const result = validateDownloadPath(pathOutsideAllowedDownloadBases()); + expect(result.ok).toBe(false); + }); + + it('accepts empty download path as clear-to-default', () => { + const result = validateDownloadPath(' '); + expect(result.ok).toBe(true); + if (result.ok) expect(result.data).toBe(''); + }); + + it('validates ffmpeg path sentinel and empty values', () => { + expect(validateFfmpegPathValue(undefined).ok).toBe(true); + expect(validateFfmpegPathValue('ffmpeg').ok).toBe(true); + expect(validateFfmpegPathValue(' ').ok).toBe(true); + expect(validateFfmpegPathValue('relative/ffmpeg').ok).toBe(false); + expect(validateFfmpegPathValue(path.join(os.homedir(), 'bin', 'ffprobe')).ok).toBe(false); + }); +}); diff --git a/src/tests/ipcValidation.test.ts b/src/tests/ipcValidation.test.ts index 6535710..9e7514a 100644 --- a/src/tests/ipcValidation.test.ts +++ b/src/tests/ipcValidation.test.ts @@ -11,6 +11,13 @@ import { validateSettingsPatchPayload, } from '../utils/ipcValidation'; +function pathOutsideAllowedDownloadBases(): string { + if (process.platform === 'win32') { + return path.join(process.env.SystemRoot ?? 'C:\\Windows', 'Temp', 'rosi-outside-test'); + } + return '/tmp/rosi-outside-test'; +} + describe('ipc validation helpers', () => { it('builds typed ok and error result wrappers', () => { expect(okResult({ started: true })).toEqual({ @@ -53,7 +60,7 @@ describe('ipc validation helpers', () => { it('rejects outputPath outside the user home directory', () => { const result = validateDownloadRequestPayload({ url: 'https://example.com', - outputPath: '/tmp/downloads', + outputPath: pathOutsideAllowedDownloadBases(), }); expect(result.ok).toBe(false); if (!result.ok) { @@ -253,7 +260,9 @@ describe('ipc validation helpers', () => { expect(validateSettingsPatchPayload({ downloadFolder: null }).ok).toBe(false); expect(validateSettingsPatchPayload({ downloadFolder: 42 }).ok).toBe(false); expect(validateSettingsPatchPayload({ downloadFolder: 'relative/path' }).ok).toBe(false); - expect(validateSettingsPatchPayload({ downloadFolder: '/tmp/outside-home' }).ok).toBe(false); + expect( + validateSettingsPatchPayload({ downloadFolder: pathOutsideAllowedDownloadBases() }).ok + ).toBe(false); expect(validateSettingsPatchPayload({ downloadFolder: 'x'.repeat(4097) }).ok).toBe(false); }); diff --git a/src/tests/msStoreDetector.test.ts b/src/tests/msStoreDetector.test.ts new file mode 100644 index 0000000..581f574 --- /dev/null +++ b/src/tests/msStoreDetector.test.ts @@ -0,0 +1,40 @@ +// @vitest-environment jsdom +import * as fs from 'fs'; +import * as path from 'path'; +import { beforeEach, describe, expect, it, vi } from 'vitest'; + +const REPO = path.resolve(__dirname, '..', '..'); +const DETECTOR = path.join(REPO, 'src', 'renderer', 'msStoreDetector.js'); + +function runDetector(channel: string | null) { + document.body.innerHTML = ` + + + `; + (window as unknown as { api?: { getChannel: () => string | null } }).api = { + getChannel: () => channel, + }; + const source = fs.readFileSync(DETECTOR, 'utf-8'); + (0, eval)(source); +} + +describe('msStoreDetector', () => { + beforeEach(() => { + document.body.innerHTML = ''; + delete (window as unknown as { api?: unknown }).api; + }); + + it('hides update controls for Microsoft Store builds', () => { + runDetector('msstore'); + + expect(document.getElementById('checkUpdateBtn')?.style.display).toBe('none'); + expect(document.getElementById('checkUpdatesOnStartupLabel')?.style.display).toBe('none'); + }); + + it('leaves update controls visible for GitHub builds', () => { + runDetector('github'); + + expect(document.getElementById('checkUpdateBtn')?.style.display).toBe(''); + expect(document.getElementById('checkUpdatesOnStartupLabel')?.style.display).toBe(''); + }); +}); diff --git a/src/tests/packaging.contract.test.ts b/src/tests/packaging.contract.test.ts new file mode 100644 index 0000000..1743f35 --- /dev/null +++ b/src/tests/packaging.contract.test.ts @@ -0,0 +1,46 @@ +import fs from 'fs'; +import path from 'path'; +import { describe, expect, it } from 'vitest'; + +function readRepoFile(relativePath: string) { + return fs.readFileSync(path.join(process.cwd(), relativePath), 'utf8'); +} + +describe('packaging and desktop contracts', () => { + it('keeps Linux desktop integration aligned across package, builder, and Flatpak', () => { + const pkg = JSON.parse(readRepoFile('package.json')); + const desktop = readRepoFile('com.burnttoasters.rosi.desktop'); + const baseConfig = readRepoFile('electron-builder.base.yml'); + + expect(pkg.desktopName).toBe('com.burnttoasters.rosi.desktop'); + expect(baseConfig).toMatch(/syncDesktopName:\s*true/); + expect(desktop).toMatch(/StartupWMClass=com\.burnttoasters\.rosi/); + expect(desktop).toMatch(/Icon=com\.burnttoasters\.rosi/); + }); + + it('keeps renderer script load order stable', () => { + const indexHtml = readRepoFile('src/renderer/index.html'); + const moduleIndex = indexHtml.indexOf('modules/ui.js'); + const engineIndex = indexHtml.indexOf('rosiEngine.js'); + const detectorIndex = indexHtml.indexOf('msStoreDetector.js'); + + expect(moduleIndex).toBeGreaterThan(-1); + expect(engineIndex).toBeGreaterThan(moduleIndex); + expect(detectorIndex).toBeGreaterThan(engineIndex); + }); + + it('keeps splash screen basics for headless packaging checks', () => { + const splash = readRepoFile('src/renderer/splash.html'); + + expect(splash).toMatch(//); + expect(splash).toMatch(/Content-Security-Policy/); + expect(splash).toMatch(/Loading ROSI<\/title>/); + }); + + it('keeps AppStream launchable aligned with the desktop entry', () => { + const metainfo = readRepoFile('com.burnttoasters.rosi.metainfo.xml'); + expect(metainfo).toMatch( + /<launchable type="desktop-id">com\.burnttoasters\.rosi\.desktop<\/launchable>/ + ); + }); +}); diff --git a/src/tests/processKill.test.ts b/src/tests/processKill.test.ts new file mode 100644 index 0000000..82b21a6 --- /dev/null +++ b/src/tests/processKill.test.ts @@ -0,0 +1,113 @@ +import { EventEmitter } from 'events'; +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import type { ChildProcess } from 'child_process'; + +const { execFileMock, isWindowsMock, logErrorMock } = vi.hoisted(() => ({ + execFileMock: vi.fn(), + isWindowsMock: vi.fn(() => false), + logErrorMock: vi.fn(), +})); + +vi.mock('child_process', () => ({ + execFile: execFileMock, +})); + +vi.mock('../main/platform', () => ({ + isWindows: isWindowsMock, +})); + +vi.mock('electron-log/main.js', () => ({ + default: { + error: logErrorMock, + }, +})); + +import { killChildProcess } from '../main/processKill'; + +function createProc(pid = 4242) { + const proc = new EventEmitter() as ChildProcess & { + killed: boolean; + kill: ReturnType<typeof vi.fn>; + }; + proc.pid = pid; + proc.killed = false; + proc.kill = vi.fn((signal?: NodeJS.Signals | number) => { + if (signal === 'SIGKILL') { + proc.killed = true; + } + }); + return proc; +} + +describe('killChildProcess', () => { + beforeEach(() => { + vi.clearAllMocks(); + vi.useFakeTimers(); + isWindowsMock.mockReturnValue(false); + }); + + afterEach(() => { + vi.useRealTimers(); + }); + + it('no-ops for null or already killed processes', () => { + const proc = createProc(); + proc.killed = true; + killChildProcess(null, 'yt-dlp'); + killChildProcess(proc, 'yt-dlp'); + expect(proc.kill).not.toHaveBeenCalled(); + }); + + it('sends SIGTERM and schedules SIGKILL after 5 seconds', () => { + const proc = createProc(); + killChildProcess(proc, 'yt-dlp'); + + expect(proc.kill).toHaveBeenCalledWith('SIGTERM'); + expect(proc.kill).not.toHaveBeenCalledWith('SIGKILL'); + + vi.advanceTimersByTime(5000); + expect(proc.kill).toHaveBeenCalledWith('SIGKILL'); + }); + + it('clears the force-kill timer when the process exits', () => { + const proc = createProc(); + killChildProcess(proc, 'yt-dlp'); + + proc.emit('exit', 0); + vi.advanceTimersByTime(5000); + + expect(proc.kill).toHaveBeenCalledTimes(1); + expect(proc.kill).toHaveBeenCalledWith('SIGTERM'); + }); + + it('uses taskkill on Windows when force-kill is needed', () => { + isWindowsMock.mockReturnValue(true); + const proc = createProc(9001); + killChildProcess(proc, 'ffmpeg'); + + vi.advanceTimersByTime(5000); + + expect(execFileMock).toHaveBeenCalledWith( + 'taskkill', + ['/PID', '9001', '/T', '/F'], + expect.any(Function) + ); + }); + + it('logs and falls back to taskkill on Windows when SIGTERM throws', () => { + isWindowsMock.mockReturnValue(true); + const proc = createProc(9002); + proc.kill = vi.fn(() => { + throw new Error('kill failed'); + }); + + killChildProcess(proc, 'yt-dlp'); + + expect(logErrorMock).toHaveBeenCalled(); + expect(execFileMock).toHaveBeenCalledWith( + 'taskkill', + ['/PID', '9002', '/T', '/F'], + expect.any(Function) + ); + }); +}); diff --git a/src/tests/queue.test.ts b/src/tests/queue.test.ts index 5a621a6..5d2ac7c 100644 --- a/src/tests/queue.test.ts +++ b/src/tests/queue.test.ts @@ -225,25 +225,99 @@ function clearHandlerMaps() { for (const key of Object.keys(handleHandlers)) delete handleHandlers[key]; } +function destroyAllBrowserWindows() { + for (const window of BrowserWindowMock.getAllWindows()) { + window.destroy(); + } +} + +function resetDownloadMocks() { + startDownloadMock.mockReset(); + startDownloadMock.mockImplementation( + ( + _ytdlpPath: string, + _sender: unknown, + _options: unknown, + _mainWindow: unknown, + onComplete?: (status: string, outcome: string) => void + ) => { + if (typeof onComplete === 'function') onComplete('✅ Done', 'success'); + } + ); + cancelActiveSessionMock.mockReset(); +} + +async function waitForAuthorizedHandlers() { + for (let attempt = 0; attempt < 50; attempt += 1) { + const getQueue = handleHandlers['get-queue']; + if (getQueue) { + const result = await getQueue(queueEvent); + if (Array.isArray(result)) return; + } + await new Promise((resolve) => setTimeout(resolve, 10)); + } + throw new Error('IPC handlers were not ready after module init'); +} + async function initializeMainModule() { const userDataDir = appMock.getPath('userData'); fs.rmSync(userDataDir, { recursive: true, force: true }); fs.mkdirSync(path.join(userDataDir, 'downloads'), { recursive: true }); + destroyAllBrowserWindows(); + clearHandlerMaps(); + sendMock.mockClear(); + resetDownloadMocks(); + fs.mkdirSync(path.dirname(ytdlpFixturePath), { recursive: true }); + fs.writeFileSync(ytdlpFixturePath, ''); + vi.resetModules(); + await import('../main/main'); + await appMock.whenReady.mock.results.at(-1)?.value; + await waitForAuthorizedHandlers(); +} + +async function reloadMainModulePreservingUserData() { + destroyAllBrowserWindows(); clearHandlerMaps(); sendMock.mockClear(); - startDownloadMock.mockClear(); - cancelActiveSessionMock.mockClear(); fs.mkdirSync(path.dirname(ytdlpFixturePath), { recursive: true }); fs.writeFileSync(ytdlpFixturePath, ''); vi.resetModules(); await import('../main/main'); - await new Promise((resolve) => setTimeout(resolve, 10)); + await appMock.whenReady.mock.results.at(-1)?.value; + await waitForAuthorizedHandlers(); +} + +async function getAuthorizedQueue(options?: { minLength?: number }) { + for (let attempt = 0; attempt < 50; attempt += 1) { + const result = await handleHandlers['get-queue']!(queueEvent); + if (Array.isArray(result)) { + if (options?.minLength !== undefined && result.length < options.minLength) { + await new Promise((resolve) => setTimeout(resolve, 10)); + continue; + } + return result; + } + await new Promise((resolve) => setTimeout(resolve, 10)); + } + throw new Error('get-queue never returned an authorized queue array'); +} + +async function flushScheduledQueuePersist() { + await vi.advanceTimersByTimeAsync(300); + await vi.runOnlyPendingTimersAsync(); +} + +function readPersistedQueueFile() { + const queuePath = path.join(appMock.getPath('userData'), 'download-queue.json'); + expect(fs.existsSync(queuePath)).toBe(true); + return JSON.parse(fs.readFileSync(queuePath, 'utf8')) as Array<{ url: string }>; } const queueEvent = { sender: { id: 1 } }; describe('queue edge cases and error handling', () => { beforeEach(async () => { + vi.useRealTimers(); await initializeMainModule(); }); @@ -468,25 +542,22 @@ describe('queue edge cases and error handling', () => { vi.useFakeTimers(); const addToQueue = handleHandlers['add-to-queue']!; await addToQueue({ sender: { id: 1 } }, ['https://example.com/persisted']); - await vi.advanceTimersByTimeAsync(300); + await flushScheduledQueuePersist(); + + const persisted = readPersistedQueueFile(); + expect(persisted).toHaveLength(1); + expect(persisted[0]!.url).toBe('https://example.com/persisted'); + + vi.clearAllTimers(); vi.useRealTimers(); const queue1 = (await handleHandlers['get-queue']!(queueEvent)) as Array<{ url: string }>; expect(queue1).toHaveLength(1); expect(queue1[0]!.url).toBe('https://example.com/persisted'); - const queuePath = path.join(appMock.getPath('userData'), 'download-queue.json'); - expect(fs.existsSync(queuePath)).toBe(true); - - clearHandlerMaps(); - sendMock.mockClear(); - fs.mkdirSync(path.dirname(ytdlpFixturePath), { recursive: true }); - fs.writeFileSync(ytdlpFixturePath, ''); - vi.resetModules(); - await import('../main/main'); - await new Promise((resolve) => setTimeout(resolve, 10)); + await reloadMainModulePreservingUserData(); - const queue2 = (await handleHandlers['get-queue']!(queueEvent)) as Array<{ url: string }>; + const queue2 = (await getAuthorizedQueue({ minLength: 1 })) as Array<{ url: string }>; expect(queue2).toHaveLength(1); expect(queue2[0]!.url).toBe('https://example.com/persisted'); }); @@ -494,24 +565,18 @@ describe('queue edge cases and error handling', () => { it('restores queue from backup when primary is corrupted', async () => { vi.useFakeTimers(); await handleHandlers['clear-queue']!({ sender: { id: 1 } }); - await vi.advanceTimersByTimeAsync(300); + await flushScheduledQueuePersist(); const addToQueue = handleHandlers['add-to-queue']!; await addToQueue({ sender: { id: 1 } }, ['https://example.com/backup-test']); - await vi.advanceTimersByTimeAsync(300); + await flushScheduledQueuePersist(); vi.useRealTimers(); const queuePath = path.join(appMock.getPath('userData'), 'download-queue.json'); fs.writeFileSync(queuePath, '{invalid json}'); - clearHandlerMaps(); - sendMock.mockClear(); - fs.mkdirSync(path.dirname(ytdlpFixturePath), { recursive: true }); - fs.writeFileSync(ytdlpFixturePath, ''); - vi.resetModules(); - await import('../main/main'); - await new Promise((resolve) => setTimeout(resolve, 10)); + await reloadMainModulePreservingUserData(); - const queue = (await handleHandlers['get-queue']!(queueEvent)) as Array<{ url: string }>; + const queue = (await getAuthorizedQueue({ minLength: 1 })) as Array<{ url: string }>; expect(queue).toHaveLength(1); expect(queue[0]!.url).toBe('https://example.com/backup-test'); }); @@ -524,13 +589,9 @@ describe('queue edge cases and error handling', () => { fs.writeFileSync(queuePath, '{bad}'); fs.writeFileSync(backupPath, '{also bad}'); - clearHandlerMaps(); - sendMock.mockClear(); - vi.resetModules(); - await import('../main/main'); - await new Promise((resolve) => setTimeout(resolve, 10)); + await reloadMainModulePreservingUserData(); - const queue = await handleHandlers['get-queue']!(queueEvent); + const queue = await getAuthorizedQueue(); expect(queue).toEqual([]); }); @@ -543,13 +604,9 @@ describe('queue edge cases and error handling', () => { ]; fs.writeFileSync(queuePath, JSON.stringify(staleQueue)); - clearHandlerMaps(); - sendMock.mockClear(); - vi.resetModules(); - await import('../main/main'); - await new Promise((resolve) => setTimeout(resolve, 10)); + await reloadMainModulePreservingUserData(); - const queue = (await handleHandlers['get-queue']!(queueEvent)) as Array<{ status: string }>; + const queue = (await getAuthorizedQueue({ minLength: 1 })) as Array<{ status: string }>; expect(queue[0]!.status).toBe('pending'); }); }); diff --git a/src/tests/rendererModules.test.ts b/src/tests/rendererModules.test.ts index d40e722..c89c016 100644 --- a/src/tests/rendererModules.test.ts +++ b/src/tests/rendererModules.test.ts @@ -34,6 +34,17 @@ type RosiModules = { }; ui?: { isValidUrl: (value: string) => boolean; + showToast: (message: unknown, options?: { type?: string; duration?: number }) => void; + setButtonLoading: ( + button: HTMLButtonElement | null, + isLoading: boolean, + onCancel?: (() => void) | null + ) => void; + appendConsoleOutput: (outputEl: HTMLElement | null, text: string) => void; + updateConsoleVisibility: (show: boolean) => void; + toggleAdvancedUI: (show: boolean) => void; + getModifierKey: () => 'metaKey' | 'ctrlKey'; + getModifierKeyName: () => 'Cmd' | 'Ctrl'; }; updates?: { isPrereleaseVersion: (version: string) => boolean; @@ -58,8 +69,10 @@ type RosiModules = { deps: { escapeHtml: (value: string) => string; removeFromQueue: (id: string) => unknown; + focusQueueItemId?: string | null; } ) => void; + resolveQueueSectionElement: (root?: Document) => HTMLElement | null; }; settings?: { bindExternalLink: ( @@ -117,7 +130,11 @@ describe('renderer modules', () => { }); describe('ui module', () => { - beforeEach(() => loadModule('ui')); + beforeEach(() => { + document.body.innerHTML = + '<div id="toast-container"></div><section id="console-section"></section><div id="advanced-options" hidden></div>'; + loadModule('ui'); + }); it('isValidUrl accepts http and https URLs', () => { expect(modules().ui!.isValidUrl('https://example.com/video')).toBe(true); @@ -129,15 +146,91 @@ describe('renderer modules', () => { expect(modules().ui!.isValidUrl('ftp://example.com')).toBe(false); expect(modules().ui!.isValidUrl('javascript:alert(1)')).toBe(false); }); + + it('showToast renders a dismissible toast message', () => { + modules().ui!.showToast('Saved settings', { type: 'success', duration: 0 }); + const toast = document.querySelector('.toast-success'); + expect(toast).not.toBeNull(); + expect(toast?.textContent).toContain('Saved settings'); + expect(toast?.getAttribute('role')).toBeNull(); + }); + + it('setButtonLoading toggles loading state and aria-busy', () => { + const button = document.createElement('button'); + button.textContent = 'Download'; + document.body.appendChild(button); + + modules().ui!.setButtonLoading(button, true); + expect(button.classList.contains('loading')).toBe(true); + expect(button.getAttribute('aria-busy')).toBe('true'); + + modules().ui!.setButtonLoading(button, false); + expect(button.classList.contains('loading')).toBe(false); + expect(button.getAttribute('aria-busy')).toBeNull(); + }); + + it('appendConsoleOutput appends text and toggles console visibility', () => { + const output = document.createElement('pre'); + modules().ui!.appendConsoleOutput(output, 'line one'); + expect(output.textContent).toContain('line one'); + + modules().ui!.updateConsoleVisibility(true); + expect(document.getElementById('console-section')?.classList.contains('visible')).toBe(true); + expect(document.body.classList.contains('console-visible')).toBe(true); + }); + + it('reports platform modifier keys', () => { + vi.spyOn(navigator, 'platform', 'get').mockReturnValue('MacIntel'); + expect(modules().ui!.getModifierKey()).toBe('metaKey'); + expect(modules().ui!.getModifierKeyName()).toBe('Cmd'); + }); + + it('toggleAdvancedUI shows and hides the format options section', () => { + const formatSection = document.createElement('section'); + formatSection.id = 'formatOptions'; + document.body.appendChild(formatSection); + + modules().ui!.toggleAdvancedUI(true); + expect(formatSection.classList.contains('visible')).toBe(true); + + modules().ui!.toggleAdvancedUI(false); + expect(formatSection.classList.contains('visible')).toBe(false); + }); }); describe('queue module', () => { beforeEach(() => { document.body.innerHTML = - '<section id="queue-section"><div id="queue-list"></div><span id="queue-count"></span></section>'; + '<section id="queueSection"><div id="queue-list"></div><span id="queue-count"></span></section>'; loadModule('queue'); }); + it('resolveQueueSectionElement finds queueSection and legacy queue-section ids', () => { + expect(modules().queue!.resolveQueueSectionElement()?.id).toBe('queueSection'); + const legacy = document.createElement('section'); + legacy.id = 'queue-section'; + document.body.appendChild(legacy); + expect(modules().queue!.resolveQueueSectionElement()?.id).toBe('queueSection'); + }); + + it('renderQueue shows an empty-state message', () => { + const queueSection = document.getElementById('queueSection')!; + modules().queue!.renderQueue( + [], + { + queueList: document.getElementById('queue-list'), + queueSection, + queueCount: document.getElementById('queue-count'), + }, + { escapeHtml: (value) => value, removeFromQueue: vi.fn() } + ); + + expect(queueSection.classList.contains('has-items')).toBe(false); + expect(document.querySelector('.queue-empty-message')?.textContent).toContain( + 'No items in queue' + ); + }); + it('escapes malicious URL content in renderQueue output', () => { const escapeHtml = (value: string) => value @@ -150,7 +243,7 @@ describe('renderer modules', () => { [{ id: 'q_xss', status: 'pending', url: maliciousUrl }], { queueList: document.getElementById('queue-list'), - queueSection: document.getElementById('queue-section'), + queueSection: document.getElementById('queueSection'), queueCount: document.getElementById('queue-count'), }, { escapeHtml, removeFromQueue: vi.fn() } @@ -161,6 +254,24 @@ describe('renderer modules', () => { expect(queueList.querySelector('.queue-item-url')!.textContent).toContain('example.com'); expect(queueList.innerHTML).toContain('"'); }); + + it('removes pending queue items through the remove button', async () => { + const removeFromQueue = vi.fn().mockResolvedValue(undefined); + modules().queue!.renderQueue( + [{ id: 'q1', status: 'pending', url: 'https://example.com/video' }], + { + queueList: document.getElementById('queue-list'), + queueSection: document.getElementById('queueSection'), + queueCount: document.getElementById('queue-count'), + }, + { escapeHtml: (value) => value, removeFromQueue } + ); + + const removeBtn = document.querySelector<HTMLButtonElement>('.queue-item-remove'); + expect(removeBtn).not.toBeNull(); + removeBtn!.click(); + expect(removeFromQueue).toHaveBeenCalledWith('q1'); + }); }); describe('settings module', () => { @@ -195,7 +306,9 @@ describe('renderer modules', () => { expect(modules().updates!.isPrereleaseVersion('4.0.0-beta.1')).toBe(true); expect(modules().updates!.isPrereleaseVersion('4.0.0-alpha.2')).toBe(true); expect(modules().updates!.isPrereleaseVersion('4.0.0-rc.1')).toBe(true); + expect(modules().updates!.isPrereleaseVersion('4.0.0-RC.2')).toBe(true); expect(modules().updates!.isPrereleaseVersion('4.0.0')).toBe(false); + expect(modules().updates!.isPrereleaseVersion('4.0.0-dev')).toBe(false); }); it('formatUpdateProgressInfo formats progress with byte helper', () => { diff --git a/src/tests/rosiEngine.dom.test.ts b/src/tests/rosiEngine.dom.test.ts index 86e1477..6b481d7 100644 --- a/src/tests/rosiEngine.dom.test.ts +++ b/src/tests/rosiEngine.dom.test.ts @@ -302,6 +302,20 @@ describe('rosiEngine DOM wiring', () => { expect(container.classList.contains('visible')).toBe(true); }); + it('hides the setup wizard back button on the first step', async () => { + const api = buildMockApi({ + getSettings: vi.fn(() => + Promise.resolve({ + ...defaultSettings(), + firstLaunch: true, + }) + ), + }); + await loadEngine(api); + const backBtn = document.getElementById('wizard-back') as HTMLButtonElement; + expect(backBtn.hasAttribute('hidden')).toBe(true); + }); + it('records download history in localStorage on completion', async () => { let completeCb: ((msg: string) => void) | null = null; const api = buildMockApi({ diff --git a/src/tests/updaterVersioning.test.ts b/src/tests/updaterVersioning.test.ts index 3f8f0e4..db1ccee 100644 --- a/src/tests/updaterVersioning.test.ts +++ b/src/tests/updaterVersioning.test.ts @@ -41,12 +41,14 @@ vi.mock('electron-log/main.js', () => ({ import { app } from 'electron'; import { applyChannel, + applyChannelFromSettings, comparePrerelease, compareVersions, isBetaVersion, parseVersion, resolveUseBeta, } from '../main/updater'; +import type { Settings } from '../types'; describe('updater versioning helpers', () => { it('detects prerelease versions', () => { @@ -96,4 +98,16 @@ describe('updater versioning helpers', () => { expect(mockAutoUpdater.channel).toBe('latest'); expect(mockAutoUpdater.allowPrerelease).toBe(false); }); + + it('applyChannelFromSettings uses the saved update channel', () => { + mockAppGetVersion.mockReturnValue('4.1.0-beta.2'); + applyChannelFromSettings({ updateChannel: 'beta' } as Settings); + expect(mockAutoUpdater.channel).toBe('beta'); + expect(mockAutoUpdater.allowPrerelease).toBe(true); + + mockAppGetVersion.mockReturnValue('4.1.0'); + applyChannelFromSettings({ updateChannel: 'stable' } as Settings); + expect(mockAutoUpdater.channel).toBe('latest'); + expect(mockAutoUpdater.allowPrerelease).toBe(false); + }); }); diff --git a/src/tests/validation.edge.test.ts b/src/tests/validation.edge.test.ts new file mode 100644 index 0000000..902c405 --- /dev/null +++ b/src/tests/validation.edge.test.ts @@ -0,0 +1,26 @@ +import { describe, expect, it } from 'vitest'; +import * as validation from '../utils/validation'; + +describe('validation edge cases', () => { + describe('isPrivateOrLocalHost', () => { + it('rejects hex IPv4 literals', () => { + expect(validation.isPrivateOrLocalHost('0x7f000001')).toBe(true); + expect(validation.isSafeHttpUrl('http://0x7f000001/video')).toBe(false); + }); + + it('rejects IPv6 loopback and link-local hosts', () => { + expect(validation.isPrivateOrLocalHost('::1')).toBe(true); + expect(validation.isPrivateOrLocalHost('fe80::1')).toBe(true); + expect(validation.isPrivateOrLocalHost('::ffff:127.0.0.1')).toBe(true); + expect(validation.isPrivateOrLocalHost('::ffff:7f00:1')).toBe(true); + expect(validation.isPrivateOrLocalHost('fc00::1')).toBe(true); + expect(validation.isSafeHttpUrl('http://[::1]/video')).toBe(false); + expect(validation.isSafeHttpUrl('http://[fc00::1]/video')).toBe(false); + }); + + it('rejects localhost subdomains', () => { + expect(validation.isPrivateOrLocalHost('app.localhost')).toBe(true); + expect(validation.isSafeHttpUrl('http://app.localhost/video')).toBe(false); + }); + }); +}); diff --git a/src/tests/validation.test.ts b/src/tests/validation.test.ts index 07dc6ed..180acd6 100644 --- a/src/tests/validation.test.ts +++ b/src/tests/validation.test.ts @@ -1,3 +1,5 @@ +import * as path from 'path'; +import { pathToFileURL } from 'url'; import { describe, it, expect } from 'vitest'; import * as validation from '../utils/validation'; @@ -77,21 +79,20 @@ describe('validation helpers', () => { describe('isAllowedNavigationUrl', () => { it('only allows file URLs', () => { + const sampleFile = pathToFileURL(path.resolve(path.join('app', 'index.html'))).href; + expect(validation.isAllowedNavigationUrl(sampleFile)).toBe(true); expect(validation.isAllowedNavigationUrl('file:///C:/app/index.html')).toBe(true); - expect(validation.isAllowedNavigationUrl('file:///Users/test/app/index.html')).toBe(true); expect(validation.isAllowedNavigationUrl('https://example.com')).toBe(false); expect(validation.isAllowedNavigationUrl('javascript:alert(1)')).toBe(false); expect(validation.isAllowedNavigationUrl('')).toBe(false); }); it('restricts file URLs to an allowed base when provided', () => { - const base = '/Users/test/app'; - expect(validation.isAllowedNavigationUrl('file:///Users/test/app/index.html', base)).toBe( - true - ); - expect(validation.isAllowedNavigationUrl('file:///Users/test/other/index.html', base)).toBe( - false - ); + const base = path.resolve(path.join('rosi-nav-test', 'app')); + const insideFile = path.join(base, 'index.html'); + const outsideFile = path.resolve(base, '..', 'other', 'index.html'); + expect(validation.isAllowedNavigationUrl(pathToFileURL(insideFile).href, base)).toBe(true); + expect(validation.isAllowedNavigationUrl(pathToFileURL(outsideFile).href, base)).toBe(false); }); }); }); diff --git a/src/tests/videoInfo.test.ts b/src/tests/videoInfo.test.ts index a22ce1f..7b01d0b 100644 --- a/src/tests/videoInfo.test.ts +++ b/src/tests/videoInfo.test.ts @@ -85,6 +85,12 @@ describe('parseVideoInfo', () => { expect(info?.thumbnail).toBe('https://example.com/a.jpg'); }); + it('uses Playlist as the fallback title for playlist payloads', () => { + const info = parseVideoInfo(JSON.stringify({ _type: 'playlist', entries: [{ title: 'a' }] })); + expect(info?.title).toBe('Playlist'); + expect(info?.isPlaylist).toBe(true); + }); + it('defaults missing optional fields to null', () => { const info = parseVideoInfo(JSON.stringify({ title: 'Bare' })); expect(info).toEqual({