refactor: 重构获取anonymous token以及xeapikey的获取

util/runtimeState.test.js

@@ -0,0 +1,235 @@
+const assert = require('assert')
+
+describe('util/runtimeState', () => {
+  let runtimeState
+
+  beforeEach(() => {
+    // 每个用例从干净状态开始，并清掉可能影响 seed 的环境变量
+    delete process.env.NETEASE_ANONYMOUS_TOKEN
+    delete process.env.NETEASE_XEAPI_PUBLIC_KEY
+    delete require.cache[require.resolve('./runtimeState')]
+    runtimeState = require('./runtimeState')
+  })
+
+  afterEach(() => {
+    delete process.env.NETEASE_ANONYMOUS_TOKEN
+    delete process.env.NETEASE_XEAPI_PUBLIC_KEY
+  })
+
+  describe('anonymous token', () => {
+    it('set/get 往返', () => {
+      runtimeState.setAnonymousToken('TOKEN_A')
+      assert.strictEqual(runtimeState.getAnonymousToken(), 'TOKEN_A')
+    })
+
+    it('set 忽略空值，不覆盖已有 token', () => {
+      runtimeState.setAnonymousToken('TOKEN_A')
+      runtimeState.setAnonymousToken('')
+      runtimeState.setAnonymousToken(null)
+      assert.strictEqual(runtimeState.getAnonymousToken(), 'TOKEN_A')
+    })
+
+    it('优先从环境变量读取种子（需显式 loadSeed）', () => {
+      process.env.NETEASE_ANONYMOUS_TOKEN = 'ENV_TOKEN'
+      assert.strictEqual(runtimeState.getAnonymousToken(), '')
+      runtimeState.loadSeed()
+      assert.strictEqual(runtimeState.getAnonymousToken(), 'ENV_TOKEN')
+    })
+
+    it('缺失时 ensureAnonymousToken 调用 refresh 并写入', async () => {
+      let calls = 0
+      const token = await runtimeState.ensureAnonymousToken(async () => {
+        calls++
+        return 'FRESH_TOKEN'
+      })
+      assert.strictEqual(token, 'FRESH_TOKEN')
+      assert.strictEqual(runtimeState.getAnonymousToken(), 'FRESH_TOKEN')
+      assert.strictEqual(calls, 1)
+    })
+
+    it('已有 token 时 ensureAnonymousToken 不再调用 refresh', async () => {
+      runtimeState.setAnonymousToken('CACHED')
+      let calls = 0
+      const token = await runtimeState.ensureAnonymousToken(async () => {
+        calls++
+        return 'FRESH'
+      })
+      assert.strictEqual(token, 'CACHED')
+      assert.strictEqual(calls, 0)
+    })
+
+    it('并发调用共享同一个刷新任务（去重）', async () => {
+      let calls = 0
+      const slowRefresh = () =>
+        new Promise((resolve) =>
+          setTimeout(() => {
+            calls++
+            resolve('SHARED_TOKEN')
+          }, 20),
+        )
+
+      const results = await Promise.all([
+        runtimeState.ensureAnonymousToken(slowRefresh),
+        runtimeState.ensureAnonymousToken(slowRefresh),
+        runtimeState.ensureAnonymousToken(slowRefresh),
+      ])
+
+      assert.deepStrictEqual(results, [
+        'SHARED_TOKEN',
+        'SHARED_TOKEN',
+        'SHARED_TOKEN',
+      ])
+      assert.strictEqual(calls, 1)
+    })
+
+    it('refresh 失败后任务被清理，可再次重试', async () => {
+      await assert.rejects(
+        runtimeState.ensureAnonymousToken(async () => {
+          throw new Error('boom')
+        }),
+      )
+      assert.strictEqual(runtimeState.isAnonymousTokenRefreshing(), false)
+
+      const token = await runtimeState.ensureAnonymousToken(
+        async () => 'RETRY_OK',
+      )
+      assert.strictEqual(token, 'RETRY_OK')
+    })
+
+    it('刷新期间 isAnonymousTokenRefreshing 为 true', async () => {
+      let sawRefreshing = false
+      await runtimeState.ensureAnonymousToken(async () => {
+        sawRefreshing = runtimeState.isAnonymousTokenRefreshing()
+        return 'X'
+      })
+      assert.strictEqual(sawRefreshing, true)
+      assert.strictEqual(runtimeState.isAnonymousTokenRefreshing(), false)
+    })
+  })
+
+  describe('xeapi public key', () => {
+    it('set/get 往返', () => {
+      runtimeState.setXeapiPublicKey({ publicKey: 'PK', version: 'v1' })
+      assert.deepStrictEqual(runtimeState.getXeapiPublicKey(), {
+        publicKey: 'PK',
+        version: 'v1',
+      })
+    })
+
+    it('优先从环境变量读取 JSON 种子（需显式 loadSeed）', () => {
+      process.env.NETEASE_XEAPI_PUBLIC_KEY = JSON.stringify({
+        publicKey: 'ENV_PK',
+        version: 'env-v',
+      })
+      assert.strictEqual(runtimeState.getXeapiPublicKey(), null)
+      runtimeState.loadSeed()
+      assert.deepStrictEqual(runtimeState.getXeapiPublicKey(), {
+        publicKey: 'ENV_PK',
+        version: 'env-v',
+      })
+    })
+
+    it('环境变量中的非法 JSON 被忽略', () => {
+      process.env.NETEASE_XEAPI_PUBLIC_KEY = 'not-json'
+      runtimeState.loadSeed()
+      assert.strictEqual(runtimeState.getXeapiPublicKey(), null)
+    })
+
+    it('mergeXeapiPublicKey 保留旧 sk（服务端未下发时）', () => {
+      runtimeState.setXeapiPublicKey({ publicKey: 'PK1', sk: 'SK1' })
+      const merged = runtimeState.mergeXeapiPublicKey({ publicKey: 'PK2' })
+      assert.strictEqual(merged.sk, 'SK1')
+      assert.strictEqual(merged.publicKey, 'PK2')
+    })
+
+    it('mergeXeapiPublicKey 优先使用新 sk', () => {
+      runtimeState.setXeapiPublicKey({ publicKey: 'PK1', sk: 'SK1' })
+      const merged = runtimeState.mergeXeapiPublicKey({
+        publicKey: 'PK2',
+        sk: 'SK2',
+      })
+      assert.strictEqual(merged.sk, 'SK2')
+    })
+
+    it('缺失时 ensureXeapiPublicKey 调用 refresh 并合并写入', async () => {
+      let calls = 0
+      const result = await runtimeState.ensureXeapiPublicKey(async () => {
+        calls++
+        return { publicKey: 'FRESH_PK', version: 'v2' }
+      })
+      assert.strictEqual(calls, 1)
+      assert.deepStrictEqual(result, { publicKey: 'FRESH_PK', version: 'v2' })
+      assert.deepStrictEqual(runtimeState.getXeapiPublicKey(), {
+        publicKey: 'FRESH_PK',
+        version: 'v2',
+      })
+    })
+
+    it('已有 key 且未 force 时不刷新', async () => {
+      runtimeState.setXeapiPublicKey({ publicKey: 'CACHED' })
+      let calls = 0
+      const result = await runtimeState.ensureXeapiPublicKey(async () => {
+        calls++
+        return { publicKey: 'FRESH' }
+      })
+      assert.strictEqual(calls, 0)
+      assert.strictEqual(result.publicKey, 'CACHED')
+    })
+
+    it('force 时即使已有 key 也刷新', async () => {
+      runtimeState.setXeapiPublicKey({ publicKey: 'CACHED', sk: 'OLD_SK' })
+      let calls = 0
+      const result = await runtimeState.ensureXeapiPublicKey(
+        async () => {
+          calls++
+          return { publicKey: 'FRESH' }
+        },
+        { force: true },
+      )
+      assert.strictEqual(calls, 1)
+      assert.strictEqual(result.publicKey, 'FRESH')
+      // 旧 sk 被保留
+      assert.strictEqual(result.sk, 'OLD_SK')
+    })
+
+    it('并发 ensureXeapiPublicKey 共享同一刷新任务', async () => {
+      let calls = 0
+      const slowRefresh = () =>
+        new Promise((resolve) =>
+          setTimeout(() => {
+            calls++
+            resolve({ publicKey: 'SHARED_PK' })
+          }, 20),
+        )
+
+      const results = await Promise.all([
+        runtimeState.ensureXeapiPublicKey(slowRefresh),
+        runtimeState.ensureXeapiPublicKey(slowRefresh),
+      ])
+
+      assert.strictEqual(calls, 1)
+      assert.strictEqual(results[0].publicKey, 'SHARED_PK')
+      assert.strictEqual(results[1].publicKey, 'SHARED_PK')
+    })
+
+    it('刷新期间 isXeapiPublicKeyRefreshing 为 true', async () => {
+      let sawRefreshing = false
+      await runtimeState.ensureXeapiPublicKey(async () => {
+        sawRefreshing = runtimeState.isXeapiPublicKeyRefreshing()
+        return { publicKey: 'X' }
+      })
+      assert.strictEqual(sawRefreshing, true)
+      assert.strictEqual(runtimeState.isXeapiPublicKeyRefreshing(), false)
+    })
+  })
+
+  describe('reset', () => {
+    it('清空 token 与 publicKey', () => {
+      runtimeState.setAnonymousToken('TOKEN')
+      runtimeState.setXeapiPublicKey({ publicKey: 'PK' })
+      runtimeState.reset()
+      assert.strictEqual(runtimeState.getAnonymousToken(), '')
+      assert.strictEqual(runtimeState.getXeapiPublicKey(), null)
+    })
+  })
+})