@lf_maple/koishi-plugin-phi-plugin-full 0.1.80

package/core/tests/makeRequestHandling.test.js

@@ -0,0 +1,118 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import makeRequest from '../model/api/makeRequest.js'
+import phiApiClient from '../model/api/phiApiClient.js'
+import { PhiApiError } from '../model/api/phiApiErrors.js'
+import platform from '../components/platform/index.js'
+import { UserCredentials } from '../model/user/userCredentials.js'
+
+const event = {
+    msg: '',
+    user_id: 'request-user',
+    userId: 'request-user',
+    platform: 'qq',
+    isGroup: false,
+    isPrivate: true,
+}
+
+test('makeRequest endpoint execution only ignores explicit unbound errors', async () => {
+    const originalSend = platform.sendWithAt
+    /** @type {string[]} */
+    const messages = []
+    platform.sendWithAt = async (_event, message) => { messages.push(String(message)) }
+    const originalRequest = phiApiClient.request
+    try {
+        phiApiClient.request = async () => { throw new PhiApiError('not bound', 404, 'binding_not_found') }
+        const ignored = await makeRequest.getUserBan(
+            /** @type {any} */ ({ platform: 'qq', platform_id: 'request-user' }),
+            {
+                event: /** @type {any} */ (event),
+                ignoreUnboundError: true,
+                notifyUser: true,
+            },
+        )
+        assert.equal(ignored, null)
+        assert.deepEqual(messages, [])
+
+        phiApiClient.request = async () => { throw new PhiApiError('forbidden', 403, 'permission_denied') }
+        const rejected = await makeRequest.getUserBan(
+            /** @type {any} */ ({ platform: 'qq', platform_id: 'request-user' }),
+            {
+                event: /** @type {any} */ (event),
+                ignoreUnboundError: true,
+                notifyUser: true,
+            },
+        )
+        assert.equal(rejected, null)
+        assert.equal(messages.length, 1)
+        assert.match(messages[0], /API访问被拒绝/)
+    } finally {
+        phiApiClient.request = originalRequest
+        platform.sendWithAt = originalSend
+    }
+})
+
+test('UserCredentials endpoint methods forward ignoreUnboundError and use the typed makeRequest endpoint', async () => {
+    const originalSend = platform.sendWithAt
+    /** @type {string[]} */
+    const messages = []
+    /** @type {any[]} */
+    const calls = []
+    const store = {
+        getSessionToken: async () => 'sstk-value',
+        getApiId: async () => undefined,
+    }
+    const originalRequest = phiApiClient.request
+    phiApiClient.request = /** @type {any} */ (async function (/** @type {any} */ path, /** @type {any} */ params, /** @type {any} */ method = 'POST') {
+        calls.push({ path, params, method, argumentCount: arguments.length })
+        throw new PhiApiError('not bound', 404, 'binding_not_found')
+    })
+    platform.sendWithAt = async (_event, message) => { messages.push(String(message)) }
+    try {
+        const credentials = UserCredentials.fromEvent(event, {
+            store: /** @type {any} */ (store),
+        })
+        const result = await credentials.getUserAPIBanStatus({
+            ignoreUnboundError: true,
+        })
+
+        assert.equal(result, null)
+        assert.deepEqual(messages, [])
+        assert.equal(calls.length, 1)
+        assert.equal(calls[0].path, '/get/banUser')
+        assert.equal(calls[0].params.platform_id, 'request-user')
+        assert.equal(calls[0].params.token, 'sstk-value')
+        assert.equal(calls[0].argumentCount, 3)
+    } finally {
+        phiApiClient.request = originalRequest
+        platform.sendWithAt = originalSend
+    }
+})
+
+test('UserCredentials can ignore missing local credentials before making the API request', async () => {
+    let calls = 0
+    const store = {
+        getSessionToken: async () => undefined,
+        getApiId: async () => undefined,
+    }
+    const originalRequest = phiApiClient.request
+    phiApiClient.request = async () => { calls += 1 }
+    try {
+        const credentials = UserCredentials.fromEvent(event, {
+            store: /** @type {any} */ (store),
+        })
+
+        assert.equal(
+            await credentials.getUserAPIBanStatus({ ignoreUnboundError: true }),
+            null,
+        )
+        assert.equal(calls, 0)
+        await assert.rejects(
+            credentials.getUserAPIBanStatus(),
+            (/** @type {any} */ error) => error.code === 'binding_not_found',
+        )
+        assert.equal(calls, 0)
+    } finally {
+        phiApiClient.request = originalRequest
+    }
+})

package/core/tests/marketOverflow.test.js

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import test from 'node:test'
+import { buildMarketQuickMarkdown } from '../model/game/markdown.js'
+
+test('market Markdown collapses control whitespace in displayed theme names', () => {
+    const markdown = buildMarketQuickMarkdown([{
+        slug: 'ocean-salt',
+        name: 'Ocean\r\nSalt\tTheme\u0000Name',
+        botDownloadAllowed: true,
+    }])
+    assert.match(markdown, /Ocean Salt Theme Name/)
+    assert.doesNotMatch(markdown, /Ocean\r|Salt\t|\u0000/)
+})
+
+test('market styles constrain long content to the fixed render width', () => {
+    const css = fs.readFileSync(new URL('../resources/html/market/market.css', import.meta.url), 'utf8')
+    assert.match(css, /body\s*\{[^}]*overflow-x:\s*hidden/)
+    assert.match(css, /\.theme-card\s*\{[^}]*min-width:\s*0[^}]*max-width:\s*100%/)
+    assert.match(css, /\.detail-description\s*\{[^}]*overflow-wrap:\s*anywhere/)
+    assert.match(css, /\.release-notes p\s*\{[^}]*overflow-wrap:\s*anywhere/)
+    assert.match(css, /grid-template-columns:\s*repeat\(4,\s*minmax\(0,\s*1fr\)\)/)
+})
+
+test('layout emits the theme font URL without HTML escaping inside <style>', () => {
+    const layout = fs.readFileSync(new URL('../resources/html/common/layout/default.art', import.meta.url), 'utf8')
+    // <style> 是 raw text，实体不会解码；fontUrl 已按路径段 encodeURIComponent，
+    // 必须用原始输出语法，否则含 ' 或 & 的字体文件名会被 &#39;/&amp; 破坏。
+    assert.match(layout, /src:\s*url\("\{\{@ themeInfo\.fontUrl\}\}"\)/)
+    assert.doesNotMatch(layout, /url\("\{\{themeInfo\.fontUrl\}\}/)
+})

package/core/tests/platformTemplateCache.test.js

@@ -0,0 +1,92 @@
+import assert from 'node:assert/strict'
+import fsSync from 'node:fs'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+import { withReliableTemplateCache, YunzaiRenderer } from '../components/platform/yunzai.js'
+import { KoishiRenderer } from '../components/platform/koishi.js'
+
+/** @param {new (data?: any) => any} Renderer @param {string} label */
+async function assertAtomicTemplateRefresh(Renderer, label) {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), `phi-${label}-template-`))
+    const liveDir = path.join(root, 'live')
+    const replacementDir = path.join(root, 'replacement')
+    const oldDir = path.join(root, 'old')
+    const tplFile = path.join(liveDir, 'page.art')
+    const renderName = `phi-template-cache-${label}-${process.pid}`
+    const outputDir = path.resolve('temp', 'html', renderName)
+    const renderer = new Renderer({ id: label })
+
+    try {
+        await fs.mkdir(liveDir)
+        await fs.mkdir(replacementDir)
+        await fs.writeFile(tplFile, 'old template: {{value}}')
+        await fs.writeFile(path.join(replacementDir, 'page.art'), 'new template: {{value}}')
+
+        const first = renderer.dealTpl(renderName, { tplFile, saveId: 'first', value: 'one' })
+        assert.equal(typeof first, 'string')
+        assert.match(await fs.readFile(String(first), 'utf8'), /old template: one/)
+
+        await fs.rename(liveDir, oldDir)
+        await fs.rename(replacementDir, liveDir)
+
+        const second = renderer.dealTpl(renderName, { tplFile, saveId: 'second', value: 'two' })
+        assert.equal(typeof second, 'string')
+        assert.match(await fs.readFile(String(second), 'utf8'), /new template: two/)
+    } finally {
+        await renderer.watcher[tplFile]?.close()
+        await fs.rm(root, { recursive: true, force: true })
+        await fs.rm(outputDir, { recursive: true, force: true })
+    }
+}
+
+test('Yunzai renderer refreshes templates after atomic directory replacement', async () => {
+    await assertAtomicTemplateRefresh(YunzaiRenderer, 'yunzai')
+})
+
+test('Koishi renderer refreshes templates after atomic directory replacement', async () => {
+    await assertAtomicTemplateRefresh(KoishiRenderer, 'koishi')
+})
+
+test('Yunzai host wrapper retries when a directory swap races the host template read', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'phi-yunzai-host-race-'))
+    const liveDir = path.join(root, 'live')
+    const replacementDir = path.join(root, 'replacement')
+    const oldDir = path.join(root, 'old')
+    const tplFile = path.join(liveDir, 'page.art')
+
+    class RacingHostRenderer {
+        constructor() {
+            /** @type {Record<string, string>} */
+            this.html = {}
+            this.watcher = {}
+            this.swapped = false
+        }
+
+        /** @param {string} _name @param {{tplFile:string}} data */
+        dealTpl(_name, data) {
+            if (!this.html[data.tplFile]) {
+                this.html[data.tplFile] = fsSync.readFileSync(data.tplFile, 'utf8')
+                if (!this.swapped) {
+                    fsSync.renameSync(liveDir, oldDir)
+                    fsSync.renameSync(replacementDir, liveDir)
+                    this.swapped = true
+                }
+            }
+            return this.html[data.tplFile]
+        }
+    }
+
+    try {
+        await fs.mkdir(liveDir)
+        await fs.mkdir(replacementDir)
+        await fs.writeFile(tplFile, 'old host template')
+        await fs.writeFile(path.join(replacementDir, 'page.art'), 'new host template')
+        const ReliableRenderer = withReliableTemplateCache(RacingHostRenderer)
+        const renderer = new ReliableRenderer()
+        assert.equal(renderer.dealTpl('race', { tplFile }), 'new host template')
+    } finally {
+        await fs.rm(root, { recursive: true, force: true })
+    }
+})

package/core/tests/pluginDataThemePreference.test.js

@@ -0,0 +1,36 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import PluginData from '../model/user/pluginData.js'
+import themeManager from '../model/theme/manager.js'
+
+test('temporary theme policy denial keeps the persisted user preference', () => {
+    const originalIsCustomTheme = themeManager.isCustomTheme
+    const originalIsThemeAvailable = themeManager.isThemeAvailable
+    let available = false
+    themeManager.isCustomTheme = themeId => themeId === 'milthm'
+    themeManager.isThemeAvailable = themeId => themeId === 'milthm' && available
+
+    try {
+        const denied = new PluginData({ theme: 'milthm' })
+        assert.equal(denied.theme, 'default')
+        assert.equal(denied.themePreference, 'milthm')
+        const persisted = JSON.parse(JSON.stringify(denied))
+        assert.equal(persisted.theme, 'milthm')
+        assert.equal('themePreference' in persisted, false)
+
+        available = true
+        const restored = new PluginData(persisted)
+        assert.equal(restored.theme, 'milthm')
+        assert.equal(restored.themePreference, 'milthm')
+    } finally {
+        themeManager.isCustomTheme = originalIsCustomTheme
+        themeManager.isThemeAvailable = originalIsThemeAvailable
+    }
+})
+
+test('changing theme preference updates both the persisted preference and effective theme', () => {
+    const data = new PluginData({ theme: 'default' })
+    assert.equal(data.setThemePreference('star'), 'star')
+    assert.equal(data.theme, 'star')
+    assert.equal(JSON.parse(JSON.stringify(data)).theme, 'star')
+})

package/core/tests/processCleanup.test.js

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict'
+import { EventEmitter } from 'node:events'
+import test from 'node:test'
+import { ProcessCleanupManager } from '../components/ProcessCleanup.js'
+
+class FakeProcess extends EventEmitter {
+    constructor() {
+        super()
+        this.pid = 123
+        /** @type {{pid: number, signal: NodeJS.Signals}[]} */
+        this.killed = []
+        /** @type {(number | undefined)[]} */
+        this.exitCodes = []
+    }
+
+    /**
+     * @param {number} pid
+     * @param {NodeJS.Signals} signal
+     */
+    kill(pid, signal) {
+        this.killed.push({ pid, signal })
+        return true
+    }
+
+    /** @param {number | undefined} code */
+    exit(code) {
+        this.exitCodes.push(code)
+    }
+}
+
+test('gracefully cleans up and then relays an exit signal', async () => {
+    const target = /** @type {NodeJS.Process} */ (/** @type {unknown} */ (new FakeProcess()))
+    const manager = new ProcessCleanupManager(target, 100)
+    let gracefulCalls = 0
+    let emergencyCalls = 0
+    manager.register(async () => { gracefulCalls++ }, () => { emergencyCalls++ })
+
+    target.emit('SIGTERM')
+    await new Promise(resolve => setImmediate(resolve))
+
+    assert.equal(gracefulCalls, 1)
+    assert.equal(emergencyCalls, 1)
+    const fakeTarget = /** @type {FakeProcess} */ (/** @type {unknown} */ (target))
+    assert.deepEqual(fakeTarget.killed, [{ pid: 123, signal: 'SIGTERM' }])
+    manager.dispose()
+})
+
+test('runs synchronous emergency cleanup during process exit', () => {
+    const target = /** @type {NodeJS.Process} */ (/** @type {unknown} */ (new FakeProcess()))
+    const manager = new ProcessCleanupManager(target)
+    let emergencyCalls = 0
+    manager.register(async () => {}, () => { emergencyCalls++ })
+
+    target.emit('exit', 0)
+
+    assert.equal(emergencyCalls, 1)
+    manager.dispose()
+})

package/core/tests/puppeteerShutdown.test.js

@@ -0,0 +1,17 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import Puppeteer from '../model/render/puppeteer.js'
+
+test('force shutdown kills the tracked browser and prevents relaunch', async () => {
+    const renderer = new Puppeteer({ idleTimeout: 0 }, 'shutdown-test')
+    renderer.browserPid = 321
+    let killedPid
+    renderer.killProcess = pid => { killedPid = pid }
+
+    renderer.forceShutdown()
+
+    assert.equal(killedPid, 321)
+    assert.equal(renderer.browser, false)
+    assert.equal(renderer.browserPid, null)
+    assert.equal(await renderer.browserInit(), false)
+})

package/core/tests/renderPressureHistory.test.js

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { RenderPressureHistory } from '../model/render/renderPressureHistory.js'
+
+/**
+ * @param {string} windowStartedAt
+ * @param {Partial<{capacity:number, active:number, queued:number, maxActive:number, maxQueued:number, completed:number, failed:number, timedOut:number}>} [overrides]
+ */
+function pressure(windowStartedAt, overrides = {}) {
+    return {
+        windowStartedAt,
+        capacity: 2,
+        active: 0,
+        queued: 0,
+        maxActive: 0,
+        maxQueued: 0,
+        completed: 0,
+        failed: 0,
+        timedOut: 0,
+        ...overrides,
+    }
+}
+
+test('render pressure history retains only the latest 30 minutes', () => {
+    const history = new RenderPressureHistory()
+    const base = Date.parse('2026-09-05T12:00:30.000Z')
+    for (let minute = 0; minute <= 30; minute += 1) {
+        const endedAt = new Date(base + minute * 60_000).toISOString()
+        history.record(pressure(new Date(base + (minute - 1) * 60_000).toISOString()), endedAt)
+    }
+
+    const samples = history.snapshot()
+    assert.equal(samples.length, 30)
+    assert.equal(samples[0].endedAt, '2026-09-05T12:01:30.000Z')
+    assert.equal(samples.at(-1)?.endedAt, '2026-09-05T12:30:30.000Z')
+})
+
+test('render pressure history merges repeated syncs in the same minute', () => {
+    const history = new RenderPressureHistory()
+    history.record(pressure('2026-09-05T12:00:00.000Z', {
+        active: 1, maxActive: 1, completed: 2,
+    }), '2026-09-05T12:00:15.000Z')
+    history.record(pressure('2026-09-05T12:00:15.000Z', {
+        queued: 1, maxQueued: 2, completed: 3, failed: 1,
+    }), '2026-09-05T12:00:50.000Z')
+
+    assert.deepEqual(history.snapshot(), [{
+        startedAt: '2026-09-05T12:00:00.000Z',
+        endedAt: '2026-09-05T12:00:50.000Z',
+        capacity: 2,
+        active: 0,
+        queued: 1,
+        maxActive: 1,
+        maxQueued: 2,
+        completed: 5,
+        failed: 1,
+        timedOut: 0,
+    }])
+})

package/core/tests/saveStats.test.js

@@ -0,0 +1,26 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import Save from '../model/save/Save.js'
+import getInfo from '../model/game/getInfo.js'
+
+test('getStats does not count Legacy placeholders as AT unlocks', async () => {
+    const originalInfo = getInfo.ori_info
+    getInfo.ori_info = /** @type {any} */ ({
+        'regular-song.0': { chart: { AT: { difficulty: 15 } } },
+        'legacy-song.0': { chart: { LY: { difficulty: 15 } } },
+    })
+
+    try {
+        const stats = await Save.prototype.getStats.call({
+            gameRecord: {
+                'regular-song.0': [undefined, undefined, undefined, null],
+                'legacy-song.0': [undefined, undefined, undefined, null, { score: 1000000 }],
+            },
+        })
+
+        assert.equal(stats[3].tot, 1)
+        assert.equal(stats[3].unlock, 1)
+    } finally {
+        getInfo.ori_info = originalInfo
+    }
+})