@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 356 lines 13 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { AWSEnvironment } from "@alchemy.run/aws/Environment";
3 import { Role } from "@alchemy.run/aws/IAM";
4 import { Bucket } from "@alchemy.run/aws/S3";
5 import { ReceiptRule, ReceiptRuleSet } from "@alchemy.run/aws/SES";
6 import { expect } from "@alchemy.run/test";
7 import * as Test from "@alchemy.run/test/Alchemy";
8 import * as iam from "@distilled.cloud/aws/iam";
9 import * as s3 from "@distilled.cloud/aws/s3";
10 import * as ses from "@distilled.cloud/aws/ses";
11 import * as Output from "alchemy/Output";
12 import * as Data from "effect/Data";
13 import * as Effect from "effect/Effect";
14 import * as Result from "effect/Result";
15 import * as Schedule from "effect/Schedule";
16
17 const { test } = Test.make({ providers: AWS.providers() });
18
19 class RuleStillExists extends Data.TaggedError("RuleStillExists")<{
20 readonly ruleSetName: string;
21 readonly ruleName: string;
22 }> {}
23
24 const assertRuleDeleted = (ruleSetName: string, ruleName: string) =>
25 ses.describeReceiptRule({ RuleSetName: ruleSetName, RuleName: ruleName }).pipe(
26 Effect.flatMap(() => Effect.fail(new RuleStillExists({ ruleSetName, ruleName }))),
27 Effect.catchTag(
28 ["RuleDoesNotExistException", "RuleSetDoesNotExistException"],
29 () => Effect.void,
30 ),
31 Effect.retry({
32 while: (e) => e._tag === "RuleStillExists",
33 schedule: Schedule.max([Schedule.exponential(500), Schedule.recurs(8)]),
34 }),
35 );
36
37 test.provider(
38 "receipt rule lifecycle: create with actions, update in place, delete",
39 (stack) =>
40 Effect.gen(function* () {
41 yield* stack.destroy();
42
43 const { ruleSet, rule } = yield* stack.deploy(
44 Effect.gen(function* () {
45 const ruleSet = yield* ReceiptRuleSet("RuleLifecycleSet", {});
46 const rule = yield* ReceiptRule("Rule", {
47 ruleSetName: ruleSet.ruleSetName,
48 recipients: ["support@ses-bindings.alchemy-test.example.com"],
49 scanEnabled: true,
50 actions: [
51 {
52 AddHeaderAction: {
53 HeaderName: "X-Alchemy-Test",
54 HeaderValue: "inbound",
55 },
56 },
57 { StopAction: { Scope: "RuleSet" } },
58 ],
59 });
60 return { ruleSet, rule };
61 }),
62 );
63
64 expect(rule.ruleName).toBeDefined();
65 expect(rule.ruleSetName).toBe(ruleSet.ruleSetName);
66
67 // out-of-band verification via distilled
68 const observed = yield* ses.describeReceiptRule({
69 RuleSetName: ruleSet.ruleSetName,
70 RuleName: rule.ruleName,
71 });
72 expect(observed.Rule?.Name).toBe(rule.ruleName);
73 // `enabled` was omitted: the provider must apply the documented default
74 // (the wire API defaults an omitted Enabled to false, which would
75 // silently bounce all inbound mail).
76 expect(observed.Rule?.Enabled).toBe(true);
77 expect(observed.Rule?.ScanEnabled).toBe(true);
78 expect(observed.Rule?.Actions?.[0]?.AddHeaderAction?.HeaderValue).toBe("inbound");
79 expect(observed.Rule?.Recipients).toEqual(["support@ses-bindings.alchemy-test.example.com"]);
80
81 // update in place: swap the action set, disable scanning, require TLS.
82 // (A BounceAction is not usable here — SES validates its Sender against
83 // the account's verified identities at update time; see the probe test
84 // below.)
85 yield* stack.deploy(
86 Effect.gen(function* () {
87 const ruleSet = yield* ReceiptRuleSet("RuleLifecycleSet", {});
88 yield* ReceiptRule("Rule", {
89 ruleSetName: ruleSet.ruleSetName,
90 enabled: false,
91 scanEnabled: false,
92 tlsPolicy: "Require",
93 actions: [
94 {
95 AddHeaderAction: {
96 HeaderName: "X-Alchemy-Test",
97 HeaderValue: "updated",
98 },
99 },
100 ],
101 });
102 }),
103 );
104 const updated = yield* ses.describeReceiptRule({
105 RuleSetName: ruleSet.ruleSetName,
106 RuleName: rule.ruleName,
107 });
108 expect(updated.Rule?.Enabled).toBe(false);
109 expect(updated.Rule?.ScanEnabled).toBe(false);
110 expect(updated.Rule?.TlsPolicy).toBe("Require");
111 expect(updated.Rule?.Actions).toHaveLength(1);
112 expect(updated.Rule?.Actions?.[0]?.AddHeaderAction?.HeaderValue).toBe("updated");
113
114 yield* stack.destroy();
115 yield* assertRuleDeleted(ruleSet.ruleSetName, rule.ruleName);
116 }),
117 { tags: ["provider:aws", "provider:aws:ses", "live"], timeout: 120_000 },
118 );
119
120 // A fresh role exercises IAM propagation without inserting a sleep before SES.
121 // Whether AWS actually returns the transient error on a given run is not
122 // deterministic; verify the real deployment rather than mocking the error.
123 test.provider(
124 "creates an S3 action with a freshly created IAM role",
125 (stack) =>
126 Effect.gen(function* () {
127 yield* stack.destroy();
128 const { rule, role, bucket } = yield* stack.deploy(
129 Effect.gen(function* () {
130 const { accountId, region } = yield* AWSEnvironment.current;
131 const ruleSet = yield* ReceiptRuleSet("RoleSet", {});
132 const bucket = yield* Bucket("Mail", { forceDestroy: true });
133 const ruleName = "deliver-to-s3";
134 const role = yield* Role("DeliveryRole", {
135 assumeRolePolicyDocument: {
136 Version: "2012-10-17",
137 Statement: [
138 {
139 Effect: "Allow",
140 Principal: { Service: "ses.amazonaws.com" },
141 Action: ["sts:AssumeRole"],
142 Condition: {
143 StringEquals: { "AWS:SourceAccount": accountId },
144 ArnEquals: {
145 "AWS:SourceArn": Output.interpolate`arn:aws:ses:${region}:${accountId}:receipt-rule-set/${ruleSet.ruleSetName}:receipt-rule/${ruleName}`,
146 },
147 },
148 },
149 ],
150 },
151 inlinePolicies: {
152 DeliverMail: {
153 Version: "2012-10-17",
154 Statement: [
155 {
156 Effect: "Allow",
157 Action: ["s3:PutObject"],
158 Resource: [Output.interpolate`${bucket.bucketArn}/*`],
159 },
160 ],
161 },
162 },
163 });
164 const rule = yield* ReceiptRule("Rule", {
165 ruleSetName: ruleSet.ruleSetName,
166 ruleName,
167 actions: [
168 {
169 S3Action: {
170 BucketName: bucket.bucketName,
171 IamRoleArn: role.roleArn,
172 },
173 },
174 ],
175 });
176 return { rule, role, bucket };
177 }),
178 );
179
180 const observed = yield* ses.describeReceiptRule({
181 RuleSetName: rule.ruleSetName,
182 RuleName: rule.ruleName,
183 });
184 expect(observed.Rule?.Actions).toEqual([
185 {
186 S3Action: { BucketName: bucket.bucketName, IamRoleArn: role.roleArn },
187 },
188 ]);
189
190 yield* stack.destroy();
191 yield* assertRuleDeleted(rule.ruleSetName, rule.ruleName);
192 expect(yield* iam.getRole({ RoleName: role.roleName }).pipe(Effect.flip)).toMatchObject({
193 _tag: "NoSuchEntityException",
194 });
195 expect(yield* s3.headBucket({ Bucket: bucket.bucketName }).pipe(Effect.flip)).toMatchObject({
196 _tag: "NotFound",
197 });
198 }),
199 { tags: ["provider:aws", "provider:aws:ses", "live"], timeout: 120_000 },
200 );
201
202 test.provider(
203 "does not retry unrelated InvalidParameterValue errors",
204 (stack) =>
205 Effect.gen(function* () {
206 yield* stack.destroy();
207 yield* stack.deploy(ReceiptRuleSet("InvalidRecipientSet", {}));
208 const failure = yield* stack
209 .deploy(
210 Effect.gen(function* () {
211 const ruleSet = yield* ReceiptRuleSet("InvalidRecipientSet", {});
212 yield* ReceiptRule("InvalidRecipient", {
213 ruleSetName: ruleSet.ruleSetName,
214 recipients: ["not a valid recipient"],
215 actions: [{ StopAction: { Scope: "RuleSet" } }],
216 });
217 }),
218 )
219 .pipe(
220 // Retrying every InvalidParameterValue would take at least 60s.
221 Effect.timeout("30 seconds"),
222 Effect.flip,
223 );
224 expect(failure).toMatchObject({ _tag: "InvalidParameterValue" });
225 expect(failure.message).not.toContain("Could not assume the provided IAM Role");
226 yield* stack.destroy();
227 }),
228 { tags: ["provider:aws", "provider:aws:ses", "live"], timeout: 120_000 },
229 );
230
231 test.provider(
232 "renaming a rule replaces it within the same rule set",
233 (stack) =>
234 Effect.gen(function* () {
235 yield* stack.destroy();
236
237 // The rule set stays deployed across the replacement so the engine never
238 // has to remove a dependency of the resource being replaced.
239 const first = yield* stack.deploy(
240 Effect.gen(function* () {
241 const ruleSet = yield* ReceiptRuleSet("RenameSet", {});
242 const rule = yield* ReceiptRule("RenameRule", {
243 ruleSetName: ruleSet.ruleSetName,
244 ruleName: "alchemy-test-rule-a",
245 actions: [{ StopAction: { Scope: "RuleSet" } }],
246 });
247 return { ruleSetName: ruleSet.ruleSetName, ruleName: rule.ruleName };
248 }),
249 );
250 expect(first.ruleName).toBe("alchemy-test-rule-a");
251
252 const second = yield* stack.deploy(
253 Effect.gen(function* () {
254 const ruleSet = yield* ReceiptRuleSet("RenameSet", {});
255 const rule = yield* ReceiptRule("RenameRule", {
256 ruleSetName: ruleSet.ruleSetName,
257 ruleName: "alchemy-test-rule-b",
258 actions: [{ StopAction: { Scope: "RuleSet" } }],
259 });
260 return { ruleSetName: ruleSet.ruleSetName, ruleName: rule.ruleName };
261 }),
262 );
263 expect(second.ruleName).toBe("alchemy-test-rule-b");
264 yield* assertRuleDeleted(first.ruleSetName, "alchemy-test-rule-a");
265
266 yield* stack.destroy();
267 yield* assertRuleDeleted(second.ruleSetName, "alchemy-test-rule-b");
268 }),
269 { tags: ["provider:aws", "provider:aws:ses", "live"], timeout: 120_000 },
270 );
271
272 test.provider(
273 "rules are ordered by the `after` position",
274 (stack) =>
275 Effect.gen(function* () {
276 yield* stack.destroy();
277
278 const { ruleSetName } = yield* stack.deploy(
279 Effect.gen(function* () {
280 const ruleSet = yield* ReceiptRuleSet("OrderSet", {});
281 const first = yield* ReceiptRule("First", {
282 ruleSetName: ruleSet.ruleSetName,
283 ruleName: "alchemy-test-order-first",
284 actions: [{ StopAction: { Scope: "RuleSet" } }],
285 });
286 yield* ReceiptRule("Second", {
287 ruleSetName: ruleSet.ruleSetName,
288 ruleName: "alchemy-test-order-second",
289 after: first.ruleName,
290 actions: [{ StopAction: { Scope: "RuleSet" } }],
291 });
292 return { ruleSetName: ruleSet.ruleSetName };
293 }),
294 );
295
296 // out-of-band: the rule set lists rules in evaluation order
297 const observed = yield* ses.describeReceiptRuleSet({
298 RuleSetName: ruleSetName,
299 });
300 const order = (observed.Rules ?? []).map((r) => r.Name);
301 expect(order.indexOf("alchemy-test-order-first")).toBeLessThan(
302 order.indexOf("alchemy-test-order-second"),
303 );
304
305 yield* stack.destroy();
306 yield* assertRuleDeleted(ruleSetName, "alchemy-test-order-first");
307 }),
308 { tags: ["provider:aws", "provider:aws:ses", "live"], timeout: 120_000 },
309 );
310
311 // Ungated probe: SES validates a BounceAction's Sender against the account's
312 // verified identities at create/update time. In the sandbox (no verified
313 // identities) that rejection surfaces as the typed IdentityNotVerified tag —
314 // carved out of the classic API's untyped InvalidParameterValue by the
315 // distilled ses patch. This pins the patch forever at near-zero cost; on an
316 // account where the identity IS verified the create simply succeeds.
317 test.provider(
318 "a BounceAction with an unverified Sender fails with the typed IdentityNotVerified tag",
319 () =>
320 Effect.gen(function* () {
321 const ruleSetName = "alchemy-test-bounce-sender-probe";
322 yield* ses
323 .createReceiptRuleSet({ RuleSetName: ruleSetName })
324 .pipe(Effect.catchTag("AlreadyExistsException", () => Effect.void));
325
326 const created = yield* Effect.result(
327 ses.createReceiptRule({
328 RuleSetName: ruleSetName,
329 Rule: {
330 Name: "probe",
331 Actions: [
332 {
333 BounceAction: {
334 SmtpReplyCode: "550",
335 Message: "Mailbox does not exist",
336 Sender: "mailer-daemon@ses-bindings.alchemy-test.example.com",
337 },
338 },
339 ],
340 },
341 }),
342 );
343 if (Result.isFailure(created)) {
344 expect(created.failure._tag).toBe("IdentityNotVerified");
345 }
346 }).pipe(
347 Effect.ensuring(
348 ses
349 .deleteReceiptRuleSet({
350 RuleSetName: "alchemy-test-bounce-sender-probe",
351 })
352 .pipe(Effect.ignore),
353 ),
354 ),
355 { tags: ["provider:aws", "provider:aws:ses", "live"], timeout: 60_000 },
356 );