@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, 04:45 UTC

main
ts 162 lines 5.71 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { SamplingRule } from "@alchemy.run/aws/XRay";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as xray from "@distilled.cloud/aws/xray";
6 import * as Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import * as Option from "effect/Option";
9 import * as Schedule from "effect/Schedule";
10 import * as Stream from "effect/Stream";
11
12 const { test } = Test.make({ providers: AWS.providers() });
13
14 const findRule = (ruleName: string) =>
15 xray.getSamplingRules.items({}).pipe(
16 Stream.filter((record) => record.SamplingRule?.RuleName === ruleName),
17 Stream.runHead,
18 Effect.map((record) => Option.getOrUndefined(record)?.SamplingRule),
19 );
20
21 class SamplingRuleStillExists extends Data.TaggedError("SamplingRuleStillExists")<{
22 readonly ruleName: string;
23 }> {}
24
25 const assertRuleDeleted = (ruleName: string) =>
26 findRule(ruleName).pipe(
27 Effect.flatMap((rule) =>
28 rule === undefined ? Effect.void : Effect.fail(new SamplingRuleStillExists({ ruleName })),
29 ),
30 Effect.retry({
31 while: (e) => e._tag === "SamplingRuleStillExists",
32 schedule: Schedule.max([Schedule.exponential(500), Schedule.recurs(8)]),
33 }),
34 );
35
36 test.provider(
37 "create, update, no-op, delete sampling rule",
38 (stack) =>
39 Effect.gen(function* () {
40 yield* stack.destroy();
41
42 const rule = yield* stack.deploy(
43 Effect.gen(function* () {
44 return yield* SamplingRule("TestRule", {
45 priority: 9000,
46 fixedRate: 0.05,
47 reservoirSize: 1,
48 serviceName: "alchemy-xray-test-*",
49 tags: { Environment: "test" },
50 });
51 }),
52 );
53
54 expect(rule.ruleName).toBeDefined();
55 expect(rule.ruleArn).toContain(":sampling-rule/");
56
57 // out-of-band verification via distilled
58 const created = yield* findRule(rule.ruleName);
59 expect(created?.Priority).toBe(9000);
60 expect(created?.FixedRate).toBe(0.05);
61 expect(created?.ReservoirSize).toBe(1);
62 expect(created?.ServiceName).toBe("alchemy-xray-test-*");
63 expect(created?.ServiceType).toBe("*");
64 const tags = yield* xray
65 .listTagsForResource({ ResourceARN: rule.ruleArn })
66 .pipe(Effect.map((r) => Object.fromEntries((r.Tags ?? []).map((t) => [t.Key, t.Value]))));
67 expect(tags.Environment).toBe("test");
68 expect(tags["alchemy::id"]).toBe("TestRule");
69
70 // update mutable fields (priority, rates, matchers, attributes, tags)
71 const updated = yield* stack.deploy(
72 Effect.gen(function* () {
73 return yield* SamplingRule("TestRule", {
74 priority: 8000,
75 fixedRate: 0.1,
76 reservoirSize: 2,
77 serviceName: "alchemy-xray-test-*",
78 httpMethod: "GET",
79 attributes: { tier: "premium" },
80 tags: { Environment: "test", Extra: "1" },
81 });
82 }),
83 );
84 expect(updated.ruleName).toBe(rule.ruleName);
85 expect(updated.ruleArn).toBe(rule.ruleArn);
86
87 const afterUpdate = yield* findRule(rule.ruleName);
88 expect(afterUpdate?.Priority).toBe(8000);
89 expect(afterUpdate?.FixedRate).toBe(0.1);
90 expect(afterUpdate?.ReservoirSize).toBe(2);
91 expect(afterUpdate?.HTTPMethod).toBe("GET");
92 expect(afterUpdate?.Attributes).toEqual({ tier: "premium" });
93 const updatedTags = yield* xray
94 .listTagsForResource({ ResourceARN: rule.ruleArn })
95 .pipe(Effect.map((r) => Object.fromEntries((r.Tags ?? []).map((t) => [t.Key, t.Value]))));
96 expect(updatedTags.Extra).toBe("1");
97
98 // remove a tag — converges via untagResource
99 yield* stack.deploy(
100 Effect.gen(function* () {
101 return yield* SamplingRule("TestRule", {
102 priority: 8000,
103 fixedRate: 0.1,
104 reservoirSize: 2,
105 serviceName: "alchemy-xray-test-*",
106 httpMethod: "GET",
107 attributes: { tier: "premium" },
108 tags: { Environment: "test" },
109 });
110 }),
111 );
112 const afterTagRemoval = yield* xray
113 .listTagsForResource({ ResourceARN: rule.ruleArn })
114 .pipe(Effect.map((r) => Object.fromEntries((r.Tags ?? []).map((t) => [t.Key, t.Value]))));
115 expect(afterTagRemoval.Extra).toBeUndefined();
116 expect(afterTagRemoval.Environment).toBe("test");
117
118 yield* stack.destroy();
119 yield* assertRuleDeleted(rule.ruleName);
120 }),
121 { tags: ["provider:aws", "provider:aws:xray", "live"], timeout: 120_000 },
122 );
123
124 test.provider(
125 "custom rule name and replacement on rename",
126 (stack) =>
127 Effect.gen(function* () {
128 yield* stack.destroy();
129
130 const first = yield* stack.deploy(
131 Effect.gen(function* () {
132 return yield* SamplingRule("NamedRule", {
133 ruleName: "alchemy-test-rule-a",
134 priority: 9100,
135 fixedRate: 0.01,
136 });
137 }),
138 );
139 expect(first.ruleName).toBe("alchemy-test-rule-a");
140 expect(first.ruleArn).toContain(":sampling-rule/alchemy-test-rule-a");
141
142 // renaming triggers a replacement: new physical rule, old one gone
143 const second = yield* stack.deploy(
144 Effect.gen(function* () {
145 return yield* SamplingRule("NamedRule", {
146 ruleName: "alchemy-test-rule-b",
147 priority: 9100,
148 fixedRate: 0.01,
149 });
150 }),
151 );
152 expect(second.ruleName).toBe("alchemy-test-rule-b");
153
154 const observed = yield* findRule("alchemy-test-rule-b");
155 expect(observed?.Priority).toBe(9100);
156 yield* assertRuleDeleted("alchemy-test-rule-a");
157
158 yield* stack.destroy();
159 yield* assertRuleDeleted("alchemy-test-rule-b");
160 }),
161 { tags: ["provider:aws", "provider:aws:xray", "live"], timeout: 120_000 },
162 );