偶发 Bug 怎样用日志、时间线和最小复现缩小范围

let cache = { value: null, expiresAt: 0 };

export async function getCatalog() {
  if (Date.now() >= cache.expiresAt) {
    const value = await loadCatalogFromUpstream();
    cache = { value, expiresAt: Date.now() + 60_000 };
  }
  return cache.value;
}

cache.expiresAt = 0;
upstream.reset({ maxConcurrent: 1, delayMs: 80 });

const results = await Promise.allSettled(
  Array.from({ length: 20 }, () => getCatalog())
);

expect(upstream.calls).toBe(1);
expect(results.every(x => x.status === 'fulfilled')).toBe(true);

let cache = { value: null, expiresAt: 0 };
let refreshPromise = null;

export async function getCatalog() {
  if (Date.now() < cache.expiresAt) return cache.value;

  if (!refreshPromise) {
    refreshPromise = loadCatalogFromUpstream()
      .then(value => {
        cache = { value, expiresAt: Date.now() + 60_000 };
        return value;
      })
      .finally(() => { refreshPromise = null; });
  }

  return refreshPromise;
}

import test from 'node:test';
import assert from 'node:assert/strict';
function createCache(load, ttl = 100) {
 let value, expires = 0, inflight;
 return function getCatalog(now) {
  if (value !== undefined && now < expires) return Promise.resolve(value);
  if (inflight) return inflight;
  inflight = Promise.resolve().then(load).then(next => {
   value = next; expires = now + ttl; return next;
  }).finally(() => { inflight = undefined; });
  return inflight;
 };
}
test('同一实例并发只刷新一次', async () => {
 let calls = 0;
 const get = createCache(async () => { calls++; return ['book']; });
 assert.deepEqual(await Promise.all([get(0), get(0)]), [['book'], ['book']]);
 assert.equal(calls, 1);
});
test('刷新失败后下一次能重新尝试', async () => {
 let calls = 0;
 const get = createCache(async () => {
  calls++; if (calls === 1) throw new Error('upstream unavailable');
  return ['book'];
 });
 await assert.rejects(get(0), /upstream unavailable/);
 assert.deepEqual(await get(1), ['book']);
 assert.equal(calls, 2);
});
test('未过期命中，过期后刷新', async () => {
 let calls = 0;
 const get = createCache(async () => [++calls]);
 assert.deepEqual(await get(0), [1]);
 assert.deepEqual(await get(99), [1]);
 assert.deepEqual(await get(100), [2]);
 assert.equal(calls, 2);
});