@devries-cameron20 / t3code-1 / commits / 12c91aef7a
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

test(server): restore DST scheduling tests deleted in the test snap (#23991)

Theo Browne committed Oct 23, 2026 at 03:13 UTC 12c91aef7ac3577fd7df6ca39c8667578cd7e40c
1 file changed +131
apps/server/src/scheduledTasks/ScheduledTaskService.interval.test.ts new
+131
@@ -0,0 +1,131 @@
1 +import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2 +import { expect, it } from "@effect/vitest";
3 +import { ScheduledTaskUpsertInput } from "@t3tools/contracts";
4 +import * as Effect from "effect/Effect";
5 +import * as Layer from "effect/Layer";
6 +import * as Schema from "effect/Schema";
7 +import * as TestClock from "effect/testing/TestClock";
8 +import { afterEach, vi } from "vite-plus/test";
9 +
10 +import * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts";
11 +import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
12 +import * as SqlitePersistence from "../persistence/Sqlite.ts";
13 +import * as ManagedProjectFolders from "../project/ManagedProjectFolders.ts";
14 +import * as Scheduler from "../scheduling/Scheduler.ts";
15 +import * as SecretRequests from "../secrets/SecretRequests.ts";
16 +import { ServerActivation } from "../serverActivation.ts";
17 +import * as ScheduledTaskService from "./ScheduledTaskService.ts";
18 +
19 +afterEach(() => vi.unstubAllEnvs());
20 +
21 +const dependencies = Layer.mergeAll(
22 + NodeCrypto.layer,
23 + Scheduler.layer,
24 + Layer.mock(ThreadLaunchService.ThreadLaunchService)({
25 + launch: () => Effect.die("synthetic dispatch failure"),
26 + }),
27 + Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({
28 + namedProjectsRoot: "/projects",
29 + isScratchProject: () => Effect.succeed(false),
30 + }),
31 + Layer.mock(ThreadManagementService.ThreadManagementService)({}),
32 + Layer.mock(SecretRequests.SecretRequests)({}),
33 +);
34 +const serviceLayer = ScheduledTaskService.layer.pipe(Layer.provide(dependencies));
35 +const decodeInput = Schema.decodeUnknownEffect(ScheduledTaskUpsertInput);
36 +const input = {
37 + commandId: "interval-duration",
38 + title: "Interval review",
39 + prompt: "Review the open pull requests.",
40 + enabled: true,
41 + projectId: "project-interval-duration",
42 + workspaceStrategy: { type: "root" },
43 + modelSelection: { instanceId: "codex", model: "gpt-5.4" },
44 + runtimeMode: "full-access",
45 + interactionMode: "default",
46 +};
47 +
48 +it.effect.each([
49 + {
50 + zone: "America/New_York",
51 + from: "2026-03-08T06:30:00.000Z",
52 + everyMs: 7_200_000,
53 + expected: "2026-03-08T08:30:00.000Z",
54 + },
55 + {
56 + zone: "America/New_York",
57 + from: "2026-11-01T05:30:00.000Z",
58 + everyMs: 7_200_000,
59 + expected: "2026-11-01T07:30:00.000Z",
60 + },
61 + {
62 + zone: "America/New_York",
63 + from: "2026-11-01T06:30:00.000Z",
64 + everyMs: 60_000,
65 + expected: "2026-11-01T06:31:00.000Z",
66 + },
67 + {
68 + zone: "UTC",
69 + from: "2026-11-01T06:30:00.000Z",
70 + everyMs: 60_000,
71 + expected: "2026-11-01T06:31:00.000Z",
72 + },
73 + {
74 + zone: "Asia/Tokyo",
75 + from: "2026-03-08T06:30:00.000Z",
76 + everyMs: 7_200_000,
77 + expected: "2026-03-08T08:30:00.000Z",
78 + },
79 +] as const)("persists elapsed interval $zone from $from", ({ zone, from, everyMs, expected }) =>
80 + Effect.gen(function* () {
81 + vi.stubEnv("TZ", zone);
82 + yield* TestClock.setTime(Date.parse(from));
83 + yield* Effect.gen(function* () {
84 + const service = yield* ScheduledTaskService.ScheduledTaskService;
85 + const decoded = yield* decodeInput({ ...input, schedule: { type: "interval", everyMs } });
86 + const created = yield* service.upsert(decoded);
87 + expect(created.task.nextRunAt).toBe(expected);
88 + expect((yield* service.list()).tasks[0]?.nextRunAt).toBe(expected);
89 +
90 + const paused = yield* service.setEnabled({ id: created.task.id, enabled: false });
91 + expect(paused.task.nextRunAt).toBeNull();
92 + const resumed = yield* service.setEnabled({ id: created.task.id, enabled: true });
93 + expect(resumed.task.nextRunAt).toBe(expected);
94 +
95 + // Exercise completion rescheduling without starting any provider process.
96 + const completed = yield* service.runNow({ id: created.task.id });
97 + expect(completed.task.lastRunStatus).toBe("failed");
98 + expect(completed.threadId).toBeNull();
99 + expect(completed.task.runCount).toBe(1);
100 + expect(completed.task.nextRunAt).toBe(expected);
101 + expect((yield* service.list()).tasks[0]?.nextRunAt).toBe(expected);
102 + }).pipe(Effect.provide(serviceLayer));
103 + }).pipe(
104 + // Keep the real scheduler parked while exercising finite service actions.
105 + Effect.provideService(ServerActivation, Effect.never),
106 + Effect.provide(SqlitePersistence.layerMemory),
107 + ),
108 +);
109 +
110 +it.effect.each([
111 + { from: "2026-03-07T23:30:00.000Z", expected: "2026-03-08T13:00:00.000Z" },
112 + { from: "2026-10-31T23:30:00.000Z", expected: "2026-11-01T14:00:00.000Z" },
113 +] as const)("keeps fixed-time schedules on the local calendar from $from", ({ from, expected }) =>
114 + Effect.gen(function* () {
115 + vi.stubEnv("TZ", "America/New_York");
116 + yield* TestClock.setTime(Date.parse(from));
117 + yield* Effect.gen(function* () {
118 + const service = yield* ScheduledTaskService.ScheduledTaskService;
119 + const decoded = yield* decodeInput({
120 + ...input,
121 + schedule: { type: "fixed_time", timeOfDay: "09:00" },
122 + });
123 + const created = yield* service.upsert(decoded);
124 + expect(created.task.nextRunAt).toBe(expected);
125 + expect((yield* service.list()).tasks[0]?.nextRunAt).toBe(expected);
126 + }).pipe(Effect.provide(serviceLayer));
127 + }).pipe(
128 + Effect.provideService(ServerActivation, Effect.never),
129 + Effect.provide(SqlitePersistence.layerMemory),
130 + ),
131 +);