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

package/core/tests/apiAccountDeletion.test.js

@@ -0,0 +1,125 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { phihelp } from '../apps/apiSetting.js'
+import { phisstk } from '../apps/session.js'
+import getBanGroup from '../model/user/getBanGroup.js'
+import makeRequestFnc from '../model/api/makeRequestFnc.js'
+import send from '../model/render/send.js'
+import { UserCredentials } from '../model/user/userCredentials.js'
+
+const event = (msg = '') => ({
+    msg,
+    user_id: 'test-user',
+    self_id: 'test-bot',
+    isGroup: false,
+    isPrivate: true,
+})
+
+test('clearApiData requires confirmation and authenticates deletion with SSTK', async () => {
+    const originals = {
+        getBan: getBanGroup.get,
+        getToken: UserCredentials.prototype.getSessionToken,
+        deleteLocalSave: UserCredentials.prototype.deleteApiCachedSave,
+        makePlatform: makeRequestFnc.makePlatform,
+        clear: UserCredentials.prototype.deleteApiAccount,
+        send: send.send_with_At,
+    }
+    /** @type {any[]} */ const messages = []
+    /** @type {any[]} */ const contexts = []
+    /** @type {any[]} */ const finished = []
+    /** @type {any[]} */ const clearRequests = []
+
+    getBanGroup.get = async () => false
+    UserCredentials.prototype.getSessionToken = /** @type {any} */ (async () => 'sstk-value')
+    UserCredentials.prototype.deleteApiCachedSave = async () => true
+    makeRequestFnc.makePlatform = /** @type {any} */ (() => ({ platform: 'test', platform_id: 'test-user', _local_user_id: 'test-user' }))
+    UserCredentials.prototype.deleteApiAccount = /** @type {any} */ (async function () {
+        clearRequests.push({ ...(await this.platformParams()), token: await this.getSessionToken() })
+        return { message: 'ok' }
+    })
+    send.send_with_At = /** @type {any} */ ((/** @type {any} */ _e, /** @type {any} */ message) => messages.push(message))
+
+    try {
+        const command = new phihelp()
+        command.checkApiEnabled = async () => true
+        command.setContext = (...args) => contexts.push(args)
+        command.finish = (...args) => finished.push(args)
+
+        assert.equal(await command.clearApiData(/** @type {any} */ (event('/phi clearApiData'))), true)
+        assert.equal(clearRequests.length, 0)
+        assert.equal(contexts[0][0], 'confirmClearApiData')
+        assert.match(messages[0], /永久清除云端账号及全部数据/)
+
+        command.e = /** @type {any} */ (event('确认'))
+        assert.equal(await command.confirmClearApiData(), true)
+        assert.deepEqual(clearRequests, [{
+            platform: 'test',
+            platform_id: 'test-user',
+            _local_user_id: 'test-user',
+            token: 'sstk-value',
+        }])
+        assert.equal(finished[0][0], 'confirmClearApiData')
+        assert.match(messages.at(-1), /账号已注销/)
+    } finally {
+        getBanGroup.get = originals.getBan
+        UserCredentials.prototype.getSessionToken = originals.getToken
+        UserCredentials.prototype.deleteApiCachedSave = originals.deleteLocalSave
+        makeRequestFnc.makePlatform = originals.makePlatform
+        UserCredentials.prototype.deleteApiAccount = originals.clear
+        send.send_with_At = originals.send
+    }
+})
+
+test('clearApiData cancellation does not call the API', async () => {
+    const originalSend = send.send_with_At
+    const originalDeleteAccount = UserCredentials.prototype.deleteApiAccount
+    let requested = false
+
+    UserCredentials.prototype.deleteApiAccount = /** @type {any} */ (async () => {
+        requested = true
+        return null
+    })
+    send.send_with_At = /** @type {any} */ (async () => undefined)
+
+    try {
+        const command = new phihelp()
+        command.e = /** @type {any} */ (event('取消'))
+        command.finish = () => undefined
+
+        assert.equal(await command.confirmClearApiData(), true)
+        assert.equal(requested, false)
+    } finally {
+        UserCredentials.prototype.deleteApiAccount = originalDeleteAccount
+        send.send_with_At = originalSend
+    }
+})
+
+test('unbind always describes a local-only operation', async () => {
+    const originals = {
+        getBan: getBanGroup.get,
+        getCredentials: UserCredentials.prototype.getLocalCredentials,
+        send: send.send_with_At,
+    }
+    /** @type {any[]} */ const messages = []
+
+    getBanGroup.get = async () => false
+    send.send_with_At = /** @type {any} */ ((/** @type {any} */ _e, /** @type {any} */ message) => messages.push(message))
+
+    try {
+        const command = new phisstk()
+        command.setContext = () => undefined
+
+        UserCredentials.prototype.getLocalCredentials = /** @type {any} */ (async () => ({ sessionToken: 'sstk-value', apiId: '123' }))
+        assert.equal(await command.unbind(/** @type {any} */ (event('/phi unbind'))), true)
+        assert.match(messages.at(-1), /只会清除当前 Bot 本地保存的绑定、存档和历史/)
+        assert.match(messages.at(-1), /不会修改 API 数据/)
+
+        UserCredentials.prototype.getLocalCredentials = /** @type {any} */ (async () => ({ sessionToken: 'sstk-value', apiId: null }))
+        assert.equal(await command.unbind(/** @type {any} */ (event('/phi unbind'))), true)
+        assert.match(messages.at(-1), /不会修改 API 数据/)
+    } finally {
+        getBanGroup.get = originals.getBan
+        UserCredentials.prototype.getLocalCredentials = originals.getCredentials
+        send.send_with_At = originals.send
+    }
+})

package/core/tests/apiPermission.test.js

@@ -0,0 +1,44 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import Config from '../components/Config.js'
+import autoSeekApi from '../model/api/autoSeekApi.js'
+import getNotes from '../model/user/getNotes.js'
+import { getApiAccessState, isApiCapabilityConfigured } from '../model/user/apiPermission.js'
+
+test('API capability switches are subordinate to the master switch', () => {
+    const originalGetUserCfg = Config.getUserCfg
+    let master = true
+    let customTheme = true
+    Config.getUserCfg = /** @type {any} */ ((/** @type {string} */ _name, /** @type {string} */ key) => {
+        if (key === 'openPhiPluginApi') return master
+        if (key === 'enableCustomThemeApi') return customTheme
+        return true
+    })
+    try {
+        assert.equal(isApiCapabilityConfigured('customTheme'), true)
+        customTheme = false
+        assert.equal(isApiCapabilityConfigured('customTheme'), false)
+        customTheme = true
+        master = false
+        assert.equal(isApiCapabilityConfigured('customTheme'), false)
+    } finally {
+        Config.getUserCfg = originalGetUserCfg
+    }
+})
+
+test('score statistics do not require user consent while online score does', async () => {
+    const originalGetUserCfg = Config.getUserCfg
+    const originalGetNotesData = getNotes.getNotesData
+    const originalOpen = autoSeekApi.openPhiPluginApi
+    Config.getUserCfg = /** @type {any} */ (() => true)
+    getNotes.getNotesData = async () => /** @type {any} */ ({ allowApiUsage: false })
+    autoSeekApi.openPhiPluginApi = true
+    try {
+        assert.equal((await getApiAccessState(/** @type {any} */ ({ user_id: 'user' }), 'scoreStatistics')).enabled, true)
+        assert.equal((await getApiAccessState(/** @type {any} */ ({ user_id: 'user' }), 'onlineScore')).enabled, false)
+    } finally {
+        Config.getUserCfg = originalGetUserCfg
+        getNotes.getNotesData = originalGetNotesData
+        autoSeekApi.openPhiPluginApi = originalOpen
+    }
+})

package/core/tests/apiVersion.test.js

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import {
+    compareApiVersion,
+    isApiVersionBlocked,
+    parseApiVersion,
+    setApiVersionBlocked,
+    SUPPORTED_API_VERSION,
+} from '../model/api/apiVersion.js'
+import { AutoSeekApi } from '../model/api/autoSeekApi.js'
+
+test('API protocol version parser accepts only complete semantic versions', () => {
+    assert.deepEqual(parseApiVersion('v1.2.3'), {
+        major: 1,
+        minor: 2,
+        patch: 3,
+        normalized: '1.2.3',
+    })
+    assert.equal(parseApiVersion('1.2'), null)
+    assert.equal(parseApiVersion('latest'), null)
+})
+
+test('API protocol compatibility follows major and minor version policy', () => {
+    assert.equal(compareApiVersion(SUPPORTED_API_VERSION).status, 'compatible')
+    assert.equal(compareApiVersion('1.0.9').status, 'minor_mismatch')
+    assert.equal(compareApiVersion('1.1.0').status, 'compatible')
+    assert.equal(compareApiVersion('2.0.0').status, 'major_mismatch')
+    assert.equal(compareApiVersion(undefined).status, 'invalid')
+})
+
+test('API connectivity state is blocked only for incompatible or invalid protocol versions', () => {
+    setApiVersionBlocked(false)
+    const api = new AutoSeekApi()
+
+    assert.equal(api.validateApiVersion('1.0.0'), true)
+    assert.equal(api.isVersionBlocked(), false)
+
+    assert.equal(api.validateApiVersion('1.0.9'), true)
+    assert.equal(api.isVersionBlocked(), false)
+
+    assert.equal(api.validateApiVersion('1.1.0'), true)
+    assert.equal(api.isVersionBlocked(), false)
+
+    api.openPhiPluginApi = true
+    api.seekingApi = true
+    assert.equal(api.validateApiVersion('2.0.0'), false)
+    assert.equal(api.openPhiPluginApi, false)
+    assert.equal(api.seekingApi, false)
+    assert.equal(api.isVersionBlocked(), true)
+
+    assert.equal(api.validateApiVersion('invalid'), false)
+    assert.equal(api.isVersionBlocked(), true)
+    assert.equal(isApiVersionBlocked(), true)
+    setApiVersionBlocked(false)
+})

package/core/tests/b30Analysis.test.js

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import {
+    buildRksHistogram,
+    getB30AnalysisRecords,
+} from '../model/game/b30Analysis.js'
+
+/** @param {string} id @param {string} rank @param {number} rks @returns {any} */
+const record = (id, rank, rks) => ({ id, rank, rks })
+
+test('uses P3 and B27 for the local RKS histogram', () => {
+    const records = getB30AnalysisRecords({
+        phi: [record('song-a', 'IN', 16), record('song-b', 'AT', 15.8), record('legacy-song', 'LEGACY', 15.7)],
+        b19_list: [record('song-a', 'IN', 15.7), record('song-a', 'HD', 15.5), ...Array.from({ length: 30 }, (_, i) => record(`song-${i}`, 'IN', 15 - i / 100))],
+    })
+    assert.equal(records.filter(item => item.kind === 'phi').length, 3)
+    assert.equal(records.filter(item => item.kind === 'best').length, 27)
+    assert.deepEqual(records.slice(0, 4).map(item => item.slot), ['P1', 'P2', 'P3', 'B1'])
+})
+
+test('builds a slot-based histogram with a horizontal average marker', () => {
+    const records = [
+        { ...record('a', 'IN', 15), kind: 'phi', slot: 'P1' },
+        { ...record('b', 'IN', 15.5), kind: 'best', slot: 'B1' },
+        { ...record('c', 'IN', 16), kind: 'best', slot: 'B2' },
+    ]
+
+    const histogram = buildRksHistogram(records)
+    assert.equal(histogram.count, 3)
+    assert.equal(histogram.average, 15.5)
+    assert.ok(histogram.averagePosition > 0 && histogram.averagePosition < 100)
+    assert.deepEqual(histogram.slots.map(slot => slot.label), ['P1', 'B1', 'B2'])
+    assert.deepEqual(histogram.slots.map(slot => slot.rks), [15, 15.5, 16])
+    assert.ok(histogram.ticks.length >= 3)
+
+    const singleValue = buildRksHistogram([{ ...record('only', 'LEGACY', 15.5), kind: 'best', slot: 'B1' }])
+    assert.ok(Math.abs(singleValue.averagePosition - 50) < 1e-9)
+})

package/core/tests/backgroundIllustration.test.js

@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import fCompute from '../model/game/fCompute.js'
+import getInfo from '../model/game/getInfo.js'
+
+test('SP个人背景曲绘通过内部ID解析', async () => {
+    await getInfo.init()
+
+    assert.equal(getInfo.SongGetId(/** @type {songString} */ ('Introduction')), 'Introduction.0')
+    assert.equal(
+        getInfo.SongGetId(/** @type {songString} */ ('Oblivion:PHIN')),
+        'OblivionPHIN.Daily天利vsEndCat终猫ftAiSSw夜輪.0'
+    )
+
+    const result = fCompute.getBackground('Introduction')
+    if (!result) assert.fail('Introduction背景解析失败')
+
+    const background = result.replace(/\\/g, '/')
+    assert.match(background, /\/SP\/Introduction\.png$/)
+    assert.doesNotMatch(background, /\/otherimg\/phigros\.png$/)
+})

package/core/tests/botApiAuthRecovery.test.js

@@ -0,0 +1,148 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import Config from '../components/Config.js'
+import { BotApiAuth } from '../model/api/botApiAuth.js'
+import {
+    PhiApiError,
+    classifyApiConnectionError,
+    getPhiApiUserMessage,
+    hasPhiApiUserMessage,
+    isApiConnectionError,
+    isFatalBotIdentityError,
+} from '../model/api/phiApiErrors.js'
+import { setApiVersionBlocked } from '../model/api/apiVersion.js'
+
+test('API connection failures retain a specific stable error code', () => {
+    const cases = [
+        ['ECONNABORTED', 'api_timeout'],
+        ['ETIMEDOUT', 'api_timeout'],
+        ['ENOTFOUND', 'api_dns_error'],
+        ['EAI_AGAIN', 'api_dns_error'],
+        ['ECONNREFUSED', 'api_connection_refused'],
+        ['CERT_HAS_EXPIRED', 'api_tls_error'],
+        ['ECONNRESET', 'api_network_error'],
+    ]
+
+    for (const [nativeCode, expected] of cases) {
+        const error = classifyApiConnectionError(Object.assign(new Error(nativeCode), { code: nativeCode }))
+        assert.equal(error.code, expected)
+        assert.equal(isApiConnectionError(error), true)
+    }
+})
+
+test('BotApiAuth exposes only Bot identity and direct API transport responsibilities', () => {
+    const auth = new BotApiAuth()
+    for (const method of ['bind', 'ensureBinding', 'invalidateBinding', 'readCachedBinding', 'saveBinding', 'requestHeaders']) {
+        assert.equal(typeof /** @type {any} */ (auth)[method], 'undefined')
+    }
+    assert.equal(typeof auth.getClientId, 'function')
+    assert.equal(typeof auth.signedRequest, 'function')
+})
+
+test('Bot authentication requests are stopped after an incompatible API version is detected', async () => {
+    const auth = new BotApiAuth()
+    setApiVersionBlocked(true)
+    try {
+        await assert.rejects(
+            auth.initialize(),
+            (/** @type {any} */ error) => error.code === 'api_version_incompatible',
+        )
+        await assert.rejects(
+            auth.signedRequest('/bot-clients/self', undefined, 'GET'),
+            (/** @type {any} */ error) => error.code === 'api_version_incompatible',
+        )
+    } finally {
+        setApiVersionBlocked(false)
+    }
+})
+
+test('user-facing API errors explain the actual failure and next action', () => {
+    assert.match(getPhiApiUserMessage(new PhiApiError('', 0, 'api_timeout')), /超时/)
+    assert.match(getPhiApiUserMessage(new PhiApiError('', 0, 'api_dns_error')), /解析API地址/)
+    assert.match(getPhiApiUserMessage(new PhiApiError('', 401, 'bot_client_unknown')), /重置API Bot身份/)
+    assert.match(getPhiApiUserMessage(new PhiApiError('', 404, 'binding_not_found')), /sessionToken绑定/)
+    const privateBindingMessage = getPhiApiUserMessage(new PhiApiError('', 403, 'user_id_binding_disabled'))
+    assert.match(privateBindingMessage, /bind <sessionToken>/)
+    assert.match(privateBindingMessage, /bind qrcode/)
+    assert.equal(hasPhiApiUserMessage(new PhiApiError('', 500, 'internal_error')), false)
+})
+
+test('temporary identity verification failures are retried instead of cached forever', async () => {
+    const originalGetUserCfg = Config.getUserCfg
+    Config.getUserCfg = /** @type {any} */ ((/** @type {any} */ _name, /** @type {string} */ style) => /** @type {Record<string, any>} */ ({
+        apiBotClientId: 'issued-client-id',
+        apiBotClientSecret: 'issued-secret',
+        apiBotSecretVersion: 1,
+    })[style])
+
+    const auth = new BotApiAuth()
+    let requests = 0
+    auth.signedRequest = async () => {
+        requests += 1
+        if (requests === 1) throw new PhiApiError('timeout', 0, 'api_timeout')
+        return { clientId: 'issued-client-id' }
+    }
+
+    try {
+        await assert.rejects(auth.initialize(), (/** @type {any} */ error) => error.code === 'api_timeout')
+        const identity = await auth.initialize()
+        assert.equal(identity.clientId, 'issued-client-id')
+        assert.equal(requests, 2)
+    } finally {
+        Config.getUserCfg = originalGetUserCfg
+    }
+})
+
+test('invalid issued credentials remain stopped until the identity changes', async () => {
+    const originalGetUserCfg = Config.getUserCfg
+    Config.getUserCfg = /** @type {any} */ ((/** @type {any} */ _name, /** @type {string} */ style) => /** @type {Record<string, any>} */ ({
+        apiBotClientId: 'revoked-client-id',
+        apiBotClientSecret: 'revoked-secret',
+        apiBotSecretVersion: 1,
+    })[style])
+
+    const auth = new BotApiAuth()
+    let requests = 0
+    auth.signedRequest = async () => {
+        requests += 1
+        throw new PhiApiError('revoked', 403, 'bot_client_revoked')
+    }
+
+    try {
+        await assert.rejects(auth.initialize(), (/** @type {any} */ error) => isFatalBotIdentityError(error))
+        await assert.rejects(auth.initialize(), (/** @type {any} */ error) => error.code === 'bot_client_revoked')
+        assert.equal(requests, 1)
+    } finally {
+        Config.getUserCfg = originalGetUserCfg
+    }
+})
+
+test('a missing Bot identity is registered on reconnect and concurrent recovery is single-flight', async () => {
+    const originalGetUserCfg = Config.getUserCfg
+    Config.getUserCfg = /** @type {any} */ ((/** @type {any} */ _name, /** @type {string} */ style) => /** @type {Record<string, any>} */ ({
+        apiBotClientId: '',
+        apiBotClientSecret: '',
+        apiBotSecretVersion: 0,
+    })[style])
+
+    const auth = new BotApiAuth()
+    let registrations = 0
+    auth.register = async () => {
+        registrations += 1
+        await new Promise(resolve => setTimeout(resolve, 5))
+        auth.ready = true
+        return { clientId: 'new-client-id', secret: 'secret', secretVersion: 1, claimUrl: undefined, claimExpiresAt: undefined }
+    }
+
+    try {
+        const [first, second] = await Promise.all([
+            auth.recoverAfterReconnect('v1.0.0'),
+            auth.recoverAfterReconnect('v1.0.0'),
+        ])
+        assert.equal(first.clientId, 'new-client-id')
+        assert.equal(second.clientId, 'new-client-id')
+        assert.equal(registrations, 1)
+    } finally {
+        Config.getUserCfg = originalGetUserCfg
+    }
+})

package/core/tests/botSyncService.test.js

@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { BotSyncService } from '../model/api/botSyncService.js'
+import makeRequest from '../model/api/makeRequest.js'
+import { setPlatformAdapter } from '../components/platform/index.js'
+
+test('Bot sync acknowledges a message only after private delivery succeeds', async () => {
+    const service = new BotSyncService()
+    const originalSync = makeRequest.syncBot
+    /** @type {any[]} */
+    const requests = []
+    let delivered = 0
+    makeRequest.syncBot = async body => {
+        requests.push(body)
+        return {
+            ok: true,
+            serverTime: new Date().toISOString(),
+            nextSyncAfterSeconds: 60,
+            reporting: { renderPressure: false },
+            messages: requests.length === 1 ? [{
+                id: '00000000-0000-4000-8000-000000000001',
+                type: 'test',
+                schemaVersion: 1,
+                target: { platform: 'yunzai', platformId: '10001' },
+                text: '审核结果',
+                payload: {},
+                createdAt: new Date().toISOString(),
+                expiresAt: new Date(Date.now() + 60_000).toISOString(),
+            }] : [],
+        }
+    }
+    setPlatformAdapter({ relpyPrivate: async () => { delivered += 1; return { message_id: 'sent' } } })
+    try {
+        await service.sync()
+        assert.equal(delivered, 1)
+        assert.deepEqual(requests[0].acknowledgedMessageIds, [])
+        await service.sync()
+        assert.deepEqual(requests[1].acknowledgedMessageIds, ['00000000-0000-4000-8000-000000000001'])
+    } finally {
+        makeRequest.syncBot = originalSync
+    }
+})

package/core/tests/fileWatcherRegistry.test.js

@@ -0,0 +1,44 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+import { FileWatcherRegistry } from '../components/FileWatcherRegistry.js'
+
+test('reuses a watcher while replacing stale hot-reload callbacks', async () => {
+    const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'phi-watcher-'))
+    const file = path.join(directory, 'config.yaml')
+    const registry = new FileWatcherRegistry()
+    await fs.writeFile(file, 'value: 1\n')
+
+    try {
+        let staleCalls = 0
+        const firstLease = registry.watch('config', file, () => staleCalls++)
+        await firstLease.ready
+
+        /** @type {() => void} */
+        let resolveChanged = () => {}
+        const changed = new Promise(resolve => { resolveChanged = () => resolve(undefined) })
+        const secondLease = registry.watch('config', file, resolveChanged)
+        assert.equal(secondLease.watcher, firstLease.watcher)
+        await secondLease.ready
+        void firstLease.close()
+        await fs.writeFile(file, 'value: 2\n')
+        await changed
+
+        assert.equal(staleCalls, 0)
+
+        const replacementFile = path.join(directory, 'replacement.yaml')
+        await fs.writeFile(replacementFile, 'value: 3\n')
+        const replacementLease = registry.watch('config', replacementFile, () => {})
+        assert.notEqual(replacementLease.watcher, firstLease.watcher)
+        await firstLease.close()
+        assert.equal(registry.entries.get('config')?.watcher, replacementLease.watcher)
+
+        await registry.closeAll()
+        assert.equal(registry.entries.size, 0)
+    } finally {
+        await registry.closeAll()
+        await fs.rm(directory, { recursive: true, force: true })
+    }
+})

package/core/tests/gameRecordPayload.test.js

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { buildGameRecordPayload } from '../model/api/gameRecordPayload.js'
+
+test('buildGameRecordPayload strips derived fields and LEGACY records', () => {
+    const payload = buildGameRecordPayload({
+        'Glaciaxion.SunsetRay.0': [
+            {
+                score: 1_000_000,
+                acc: 100,
+                fc: 1,
+                id: 'Glaciaxion.SunsetRay.0',
+                rank: 'EZ',
+                Rating: 'phi',
+                rks: 12.5,
+                song: 'Glaciaxion',
+                illustration: 'https://example.com/cover.png',
+            },
+            null,
+            { score: 987_654, acc: 98.7654, fc: false, rank: 'IN' },
+            null,
+            { score: 900_000, acc: 95, fc: true, rank: 'LEGACY' },
+        ],
+    })
+
+    assert.deepEqual(payload, {
+        'Glaciaxion.SunsetRay.0': [
+            { score: 1_000_000, acc: 100, fc: true },
+            null,
+            { score: 987_654, acc: 98.7654, fc: false },
+            null,
+        ],
+    })
+})

package/core/tests/guessLetter.test.js

@@ -0,0 +1,79 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import {
+    LETTER_HIDDEN_CHAR,
+    allGuessed,
+    encryptSongName,
+    getRevealCandidates,
+    hasHiddenCharacters,
+    revealCharacter
+} from '../apps/guessGame/letterGameUtils.js'
+
+test('literal star remains a valid tip candidate without being confused with the mask', () => {
+    const title = '7 colors*'
+    const blur = `7 colors${LETTER_HIDDEN_CHAR}`
+    const game = { ansList: [title], blurlist: [blur] }
+
+    assert.deepEqual(getRevealCandidates(game), ['*'])
+
+    const revealed = revealCharacter(title, blur, '*')
+    assert.equal(revealed, title)
+    assert.equal(hasHiddenCharacters(revealed), false)
+})
+
+test('mask and reveal operations use Unicode code points consistently', () => {
+    const title = 'A😀*'
+    const encrypted = encryptSongName(title)
+
+    assert.equal(Array.from(encrypted).length, Array.from(title).length)
+    assert.deepEqual(getRevealCandidates({ ansList: [title], blurlist: [encrypted] }), ['A', '😀', '*'])
+
+    const emojiRevealed = revealCharacter(title, encrypted, '😀')
+    assert.deepEqual(Array.from(emojiRevealed), [LETTER_HIDDEN_CHAR, '😀', LETTER_HIDDEN_CHAR])
+})
+
+test('empty and completed games have no reveal candidates', () => {
+    assert.deepEqual(getRevealCandidates({ ansList: ['done'], blurlist: [null] }), [])
+    assert.deepEqual(getRevealCandidates({ ansList: [], blurlist: [] }), [])
+})
+
+test('repeated tips always finish titles containing literal stars', () => {
+    const titles = [
+        '7 colors*',
+        'Altair (feat. *spiLa*)',
+        'cocoro*cosmetic',
+        'strawberry*passion'
+    ]
+    const game = /** @type {{letterNum: number, ansList: string[], blurlist: (string|null)[]}} */ ({
+        letterNum: titles.length,
+        ansList: titles,
+        blurlist: titles.map(encryptSongName)
+    })
+    const maximumSteps = titles.reduce((total, title) => total + Array.from(title).length, 0)
+    let steps = 0
+
+    while (!allGuessed(game)) {
+        const symbol = getRevealCandidates(game)[0]
+        assert.notEqual(symbol, undefined)
+
+        game.blurlist = game.blurlist.map((blur, index) => {
+            if (!blur) return null
+            const revealed = revealCharacter(titles[index], blur, symbol)
+            return hasHiddenCharacters(revealed) ? revealed : null
+        })
+        steps++
+        assert.ok(steps <= maximumSteps)
+    }
+
+    assert.deepEqual(getRevealCandidates(game), [])
+})
+
+test('completion requires every configured slot to be an explicit null', () => {
+    assert.equal(allGuessed(/** @type {any} */ ({ letterNum: 2, blurlist: [null, null] })), true)
+
+    const sparse = new Array(2)
+    sparse[0] = null
+    assert.equal(allGuessed(/** @type {any} */ ({ letterNum: 2, blurlist: sparse })), false)
+    assert.equal(allGuessed(/** @type {any} */ ({ letterNum: 2, blurlist: [null] })), false)
+})