3
import { dirname, join } from 'node:path';
4
import { tmpdir } from 'node:os';
5
import { BunFileSystem, BunPath } from '@effect/platform-bun';
6
-import { Effect, Layer } from 'effect';
6
+import { Effect, Fiber, Layer } from 'effect';
7
import { withHttpServerEffect } from 'test/__utils__/http-server';
8
import type { TerminalUI } from 'src/services/terminal-ui';
9
import {
71
}));
72
}
73
74
+function makeDeferred<T>() {
75
+ let resolve!: (value: T | PromiseLike<T>) => void;
76
+ let reject!: (reason?: unknown) => void;
77
+ const promise = new Promise<T>((resolvePromise, rejectPromise) => {
78
+ resolve = resolvePromise;
79
+ reject = rejectPromise;
80
+ });
81
+ return { promise, resolve, reject };
82
+}
83
+
84
// ── parseLatestVersionFromReleases (pure) ───────────────────────────────
85
86
describe('parseLatestVersionFromReleases', () => {
274
current: '0.2.0',
275
latestStable: '0.3.0',
276
updateAvailable: true,
277
+ checkStatus: 'update-available',
278
lastChecked: expect.any(String),
279
});
280
}).pipe(Effect.provide(PlatformLayers))
281
);
282
272
- it.effect('reports no update when the fetch fails and no cache exists', () =>
283
+ it.effect('reports an unknown status when the fetch fails and no cache exists', () =>
284
Effect.gen(function* () {
285
const config = makeConfig({
286
currentVersion: '0.2.0',
290
291
const status = yield* getUpdateStatus;
292
282
- expect(status.updateAvailable).toBe(false);
283
- expect(status.lastChecked).toEqual(expect.any(String));
293
+ expect(status).toEqual({
294
+ current: '0.2.0',
295
+ latestStable: null,
296
+ updateAvailable: false,
297
+ checkStatus: 'unknown',
298
+ lastChecked: null,
299
+ });
300
+ expect(existsSync(config.stateFile)).toBe(false);
301
+ }).pipe(Effect.provide(PlatformLayers))
302
+ );
303
+
304
+ it.effect('does not call a stale cached version up to date after a failed refresh', () =>
305
+ Effect.gen(function* () {
306
+ const config = makeConfig({
307
+ currentVersion: '0.2.0',
308
+ fetchFn: vi.fn().mockRejectedValue(new Error('offline')) as unknown as typeof fetch,
309
+ });
310
+ const lastChecked = '2020-01-01T00:00:00.000Z';
311
+ writeState(config, { lastChecked, latestVersion: '0.2.0' });
312
+ const { getUpdateStatus } = createUpdateChecker(config);
313
+
314
+ const status = yield* getUpdateStatus;
315
+
316
+ expect(status).toEqual({
317
+ current: '0.2.0',
318
+ latestStable: '0.2.0',
319
+ updateAvailable: false,
320
+ checkStatus: 'unknown',
321
+ lastChecked,
322
+ });
323
}).pipe(Effect.provide(PlatformLayers))
324
);
325
336
337
expect(status.latestStable).toBeNull();
338
expect(status.updateAvailable).toBe(false);
339
+ expect(status.checkStatus).toBe('unknown');
340
}).pipe(Effect.provide(PlatformLayers))
341
);
342
355
expect(fetchFn).not.toHaveBeenCalled();
356
expect(status.latestStable).toBe('0.2.1');
357
expect(status.updateAvailable).toBe(true);
358
+ expect(status.checkStatus).toBe('update-available');
359
+ }).pipe(Effect.provide(PlatformLayers))
360
+ );
361
+
362
+ it.effect('reports an unknown status for an invalid installed version', () =>
363
+ Effect.gen(function* () {
364
+ const config = makeConfig({ currentVersion: 'corrupt-tag' });
365
+ writeState(config, { lastChecked: new Date().toISOString(), latestVersion: '0.3.0' });
366
+ const { getUpdateStatus } = createUpdateChecker(config);
367
+
368
+ const status = yield* getUpdateStatus;
369
+
370
+ expect(status).toEqual({
371
+ current: 'corrupt-tag',
372
+ latestStable: '0.3.0',
373
+ updateAvailable: false,
374
+ checkStatus: 'unknown',
375
+ lastChecked: expect.any(String),
376
+ });
377
}).pipe(Effect.provide(PlatformLayers))
378
);
379
});
525
}).pipe(Effect.provide(PlatformLayers))
526
);
527
469
- it.effect('writes lastChecked on HTTP errors to prevent retry loops', () =>
528
+ it.effect('does not create authoritative state after an HTTP error', () =>
529
Effect.gen(function* () {
530
const config = makeConfig({
531
fetchFn: vi.fn().mockResolvedValue({
538
// Should not fail
539
yield* checkForUpdate;
540
482
- expect(existsSync(config.stateFile)).toBe(true);
483
- const state: UpdateCheckState = JSON.parse(readFileSync(config.stateFile, 'utf-8'));
484
- expect(state.lastChecked).toBeDefined();
485
- expect(state.latestVersion).toBe(config.currentVersion);
541
+ expect(existsSync(config.stateFile)).toBe(false);
542
}).pipe(Effect.provide(PlatformLayers))
543
);
544
489
- it.effect('writes lastChecked on network errors to prevent retry loops', () =>
545
+ it.effect('does not create authoritative state after a network error', () =>
546
Effect.gen(function* () {
547
const config = makeConfig({
548
fetchFn: vi.fn().mockRejectedValue(new Error('DNS failed')) as unknown as typeof fetch,
551
552
yield* checkForUpdate;
553
498
- expect(existsSync(config.stateFile)).toBe(true);
554
+ expect(existsSync(config.stateFile)).toBe(false);
555
+ }).pipe(Effect.provide(PlatformLayers))
556
+ );
557
+
558
+ it.effect('throttles repeated network errors without creating authoritative state', () =>
559
+ Effect.gen(function* () {
560
+ const fetchFn = vi.fn().mockRejectedValue(new Error('DNS failed'));
561
+ const config = makeConfig({ fetchFn: fetchFn as unknown as typeof fetch });
562
+ const { checkForUpdate } = createUpdateChecker(config);
563
+
564
+ yield* checkForUpdate;
565
+ yield* checkForUpdate;
566
+
567
+ expect(fetchFn).toHaveBeenCalledOnce();
568
+ expect(existsSync(config.stateFile)).toBe(false);
569
+ expect(existsSync(`${config.stateFile}.attempt`)).toBe(true);
570
+ }).pipe(Effect.provide(PlatformLayers))
571
+ );
572
+
573
+ it.effect('preserves stale successful state after a network error', () =>
574
+ Effect.gen(function* () {
575
+ const config = makeConfig({
576
+ fetchFn: vi.fn().mockRejectedValue(new Error('DNS failed')) as unknown as typeof fetch,
577
+ });
578
+ const previousState: UpdateCheckState = {
579
+ lastChecked: staleLastChecked,
580
+ latestVersion: '0.3.0',
581
+ };
582
+ writeState(config, previousState);
583
+ const { checkForUpdate } = createUpdateChecker(config);
584
+
585
+ yield* checkForUpdate;
586
+
587
const state: UpdateCheckState = JSON.parse(readFileSync(config.stateFile, 'utf-8'));
500
- expect(state.lastChecked).toBeDefined();
501
- expect(state.latestVersion).toBe(config.currentVersion);
588
+ expect(state).toEqual(previousState);
589
+ }).pipe(Effect.provide(PlatformLayers))
590
+ );
591
+
592
+ it.effect('does not let an older failed check supersede successful state', () =>
593
+ Effect.gen(function* () {
594
+ const failedResponse = makeDeferred<Response>();
595
+ const failedRequestStarted = makeDeferred<void>();
596
+ const failingConfig = makeConfig({
597
+ fetchFn: vi.fn(() => {
598
+ failedRequestStarted.resolve();
599
+ return failedResponse.promise;
600
+ }),
601
+ });
602
+ const successfulConfig = makeConfig({
603
+ fetchFn: vi.fn().mockResolvedValue({
604
+ ok: true,
605
+ json: () => Promise.resolve(makeReleasesPayload(['0.3.0'])),
606
+ }) as unknown as typeof fetch,
607
+ });
608
+ const failingFiber = yield* Effect.fork(createUpdateChecker(failingConfig).checkForUpdate);
609
+
610
+ yield* Effect.promise(() => failedRequestStarted.promise);
611
+ const successfulAt = new Date(pinnedNow.getTime() + 60_000);
612
+ yield* Effect.sync(() => vi.setSystemTime(successfulAt));
613
+ yield* createUpdateChecker(successfulConfig).checkForUpdate;
614
+ yield* Effect.sync(() => vi.setSystemTime(new Date(successfulAt.getTime() + 60_000)));
615
+ yield* Effect.sync(() => failedResponse.reject(new Error('transient failure')));
616
+ yield* Fiber.join(failingFiber);
617
+
618
+ const state: UpdateCheckState = JSON.parse(readFileSync(failingConfig.stateFile, 'utf-8'));
619
+ expect(state).toEqual({
620
+ lastChecked: successfulAt.toISOString(),
621
+ latestVersion: '0.3.0',
622
+ });
623
+ expect(JSON.parse(readFileSync(`${failingConfig.stateFile}.attempt`, 'utf-8'))).toEqual({
624
+ lastAttempted: pinnedNow.toISOString(),
625
+ });
626
+
627
+ const recoveryFetch = vi.fn().mockResolvedValue({
628
+ ok: true,
629
+ json: () => Promise.resolve(makeReleasesPayload(['0.4.0'])),
630
+ });
631
+ yield* Effect.sync(() =>
632
+ vi.setSystemTime(new Date(successfulAt.getTime() + failingConfig.checkIntervalMs + 1))
633
+ );
634
+ yield* createUpdateChecker(makeConfig({ fetchFn: recoveryFetch as unknown as typeof fetch }))
635
+ .checkForUpdate;
636
+
637
+ expect(recoveryFetch).toHaveBeenCalledOnce();
638
+ const refreshedState: UpdateCheckState = JSON.parse(
639
+ readFileSync(failingConfig.stateFile, 'utf-8')
640
+ );
641
+ expect(refreshedState.latestVersion).toBe('0.4.0');
642
+ expect(existsSync(`${failingConfig.stateFile}.attempt`)).toBe(false);
643
}).pipe(Effect.provide(PlatformLayers))
644
);
645