@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 144 lines 5.46 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as workers from "@distilled.cloud/cloudflare/workers";
6 import * as Provider from "alchemy/Provider";
7 import * as Effect from "effect/Effect";
8 import { MinimumLogLevel } from "effect/References";
9 import * as Schedule from "effect/Schedule";
10
11 const { test } = Test.make({ providers: Cloudflare.providers() });
12
13 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
14
15 const EMAIL = "test@alchemy.run";
16
17 // The policy an Issues automation notifies. Disabled so the test never
18 // sends a notification.
19 const IssuePolicy = Cloudflare.Alerting.NotificationPolicy("IssuePolicy", {
20 alertType: "workers_observability_real_time_issue",
21 enabled: false,
22 mechanisms: { email: [{ id: EMAIL }] },
23 });
24
25 test.provider(
26 "create, update, delete issue automation",
27 (stack) =>
28 Effect.gen(function* () {
29 const { accountId } = yield* yield* CloudflareEnvironment;
30
31 yield* stack.destroy();
32
33 const { policy, automation } = yield* stack.deploy(
34 Effect.gen(function* () {
35 const policy = yield* IssuePolicy;
36 const automation = yield* Cloudflare.Workers.IssueAutomation("Automation", {
37 policyId: policy.policyId,
38 afterOccurrences: 5,
39 });
40 return { policy, automation };
41 }),
42 );
43
44 expect(automation.accountId).toEqual(accountId);
45 expect(automation.policyId).toEqual(policy.policyId);
46 expect(automation.scope).toEqual("account");
47 expect(automation.triggerType).toEqual("occurrence_threshold");
48 expect(automation.afterOccurrences).toEqual(5);
49 expect(automation.enabled).toBe(true);
50
51 // Verify out-of-band via the API.
52 const created = yield* workers.getObservabilityIssueAutomation({
53 accountId,
54 automationId: automation.automationId,
55 });
56 expect(created.automation.name).toEqual(automation.name);
57 expect(created.automation.ansPolicyId).toEqual(policy.policyId);
58 expect(created.automation.threshold).toEqual(5);
59
60 // Redeploying the same props does not write.
61 const unchanged = yield* stack.deploy(
62 Effect.gen(function* () {
63 const policy = yield* IssuePolicy;
64 return yield* Cloudflare.Workers.IssueAutomation("Automation", {
65 policyId: policy.policyId,
66 afterOccurrences: 5,
67 });
68 }),
69 );
70 expect(unchanged.revision).toEqual(automation.revision);
71
72 // Switch the trigger, scope it to one Worker, and disable it — all
73 // in place, same id.
74 const updated = yield* stack.deploy(
75 Effect.gen(function* () {
76 const policy = yield* IssuePolicy;
77 return yield* Cloudflare.Workers.IssueAutomation("Automation", {
78 policyId: policy.policyId,
79 service: "alchemy-issue-automation-worker",
80 afterInactivitySeconds: 7200,
81 enabled: false,
82 });
83 }),
84 );
85 expect(updated.automationId).toEqual(automation.automationId);
86 expect(updated.name).toEqual(automation.name);
87 expect(updated.scope).toEqual("service");
88 expect(updated.service).toEqual("alchemy-issue-automation-worker");
89 expect(updated.triggerType).toEqual("recurrence_after_inactivity");
90 expect(updated.afterInactivitySeconds).toEqual(7200);
91 expect(updated.afterOccurrences).toBeUndefined();
92 expect(updated.enabled).toBe(false);
93
94 const afterUpdate = yield* workers.getObservabilityIssueAutomation({
95 accountId,
96 automationId: automation.automationId,
97 });
98 expect(afterUpdate.automation.inactivitySeconds).toEqual(7200);
99 expect(afterUpdate.automation.threshold).toBeNull();
100 expect(afterUpdate.automation.service).toEqual("alchemy-issue-automation-worker");
101 expect(afterUpdate.automation.enabled).toBe(false);
102
103 yield* stack.destroy();
104
105 yield* waitForAutomationDeleted(accountId, automation.automationId);
106 }).pipe(logLevel),
107 { tags: ["provider:cloudflare", "provider:cloudflare:worker", "live"] },
108 );
109
110 test.provider(
111 "list enumerates the deployed issue automation",
112 (stack) =>
113 Effect.gen(function* () {
114 yield* stack.destroy();
115
116 const deployed = yield* stack.deploy(
117 Effect.gen(function* () {
118 const policy = yield* IssuePolicy;
119 return yield* Cloudflare.Workers.IssueAutomation("ListAutomation", {
120 policyId: policy.policyId,
121 afterOccurrences: 1,
122 });
123 }),
124 );
125
126 const provider = yield* Provider.findProvider(Cloudflare.Workers.IssueAutomation);
127 const all = yield* provider.list();
128
129 expect(all.some((a) => a.automationId === deployed.automationId)).toBe(true);
130
131 yield* stack.destroy();
132 }).pipe(logLevel),
133 { tags: ["provider:cloudflare", "provider:cloudflare:worker", "live"] },
134 );
135
136 const waitForAutomationDeleted = (accountId: string, automationId: string) =>
137 workers.getObservabilityIssueAutomation({ accountId, automationId }).pipe(
138 Effect.flatMap(() => Effect.fail({ _tag: "AutomationNotDeleted" } as const)),
139 Effect.catchTag("ObservabilityIssueAutomationNotFound", () => Effect.void),
140 Effect.retry({
141 while: (e) => e._tag === "AutomationNotDeleted",
142 schedule: Schedule.max([Schedule.exponential("500 millis"), Schedule.recurs(10)]),
143 }),
144 );