@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 142 lines 5.48 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { ResponseHeadersPolicy } from "@alchemy.run/aws/CloudFront";
3 import { describe, expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as cloudfront from "@distilled.cloud/aws/cloudfront";
6 import * as Provider from "alchemy/Provider";
7 import * as Effect from "effect/Effect";
8 import * as Schedule from "effect/Schedule";
9
10 const { test } = Test.make({ providers: AWS.providers() });
11
12 describe(
13 "AWS.CloudFront.ResponseHeadersPolicy",
14 { tags: ["provider:aws", "provider:aws:cloudfront", "live"] },
15 () => {
16 test.provider(
17 "create, update, and delete a response headers policy",
18 (stack) =>
19 Effect.gen(function* () {
20 yield* stack.destroy();
21
22 const created = yield* stack.deploy(
23 Effect.gen(function* () {
24 return yield* ResponseHeadersPolicy("AppResponseHeaders", {
25 comment: "initial",
26 securityHeadersConfig: {
27 StrictTransportSecurity: {
28 AccessControlMaxAgeSec: 31536000,
29 IncludeSubdomains: true,
30 Preload: true,
31 Override: true,
32 },
33 ContentTypeOptions: { Override: true },
34 FrameOptions: { FrameOption: "DENY", Override: true },
35 ReferrerPolicy: { ReferrerPolicy: "no-referrer", Override: true },
36 },
37 });
38 }),
39 );
40
41 const initial = yield* cloudfront.getResponseHeadersPolicy({
42 Id: created.responseHeadersPolicyId,
43 });
44 expect(initial.ResponseHeadersPolicy?.Id).toEqual(created.responseHeadersPolicyId);
45 expect(initial.ResponseHeadersPolicy?.ResponseHeadersPolicyConfig?.Comment).toEqual(
46 "initial",
47 );
48 expect(
49 initial.ResponseHeadersPolicy?.ResponseHeadersPolicyConfig?.SecurityHeadersConfig
50 ?.FrameOptions?.FrameOption,
51 ).toEqual("DENY");
52
53 const updated = yield* stack.deploy(
54 Effect.gen(function* () {
55 return yield* ResponseHeadersPolicy("AppResponseHeaders", {
56 comment: "updated",
57 corsConfig: {
58 AccessControlAllowOrigins: { Quantity: 1, Items: ["https://app.example.com"] },
59 AccessControlAllowMethods: { Quantity: 2, Items: ["GET", "OPTIONS"] },
60 AccessControlAllowHeaders: { Quantity: 1, Items: ["Authorization"] },
61 AccessControlAllowCredentials: false,
62 OriginOverride: true,
63 },
64 securityHeadersConfig: {
65 FrameOptions: { FrameOption: "SAMEORIGIN", Override: true },
66 },
67 });
68 }),
69 );
70
71 expect(updated.responseHeadersPolicyId).toEqual(created.responseHeadersPolicyId);
72
73 // Control-plane reads are eventually consistent — poll until the
74 // update is visible, then assert.
75 const after = yield* cloudfront
76 .getResponseHeadersPolicy({ Id: updated.responseHeadersPolicyId })
77 .pipe(
78 Effect.repeat({
79 schedule: Schedule.fixed("2 seconds"),
80 until: (r) =>
81 r.ResponseHeadersPolicy?.ResponseHeadersPolicyConfig?.Comment === "updated",
82 times: 15,
83 }),
84 );
85 expect(after.ResponseHeadersPolicy?.ResponseHeadersPolicyConfig?.Comment).toEqual(
86 "updated",
87 );
88 expect(
89 after.ResponseHeadersPolicy?.ResponseHeadersPolicyConfig?.SecurityHeadersConfig
90 ?.FrameOptions?.FrameOption,
91 ).toEqual("SAMEORIGIN");
92 expect(
93 after.ResponseHeadersPolicy?.ResponseHeadersPolicyConfig?.CorsConfig
94 ?.AccessControlAllowOrigins?.Items,
95 ).toEqual(["https://app.example.com"]);
96
97 yield* stack.destroy();
98 yield* assertResponseHeadersPolicyDeleted(updated.responseHeadersPolicyId);
99 }),
100 { timeout: 300_000 },
101 );
102
103 test.provider(
104 "list enumerates the deployed response headers policy",
105 (stack) =>
106 Effect.gen(function* () {
107 yield* stack.destroy();
108
109 const deployed = yield* stack.deploy(
110 Effect.gen(function* () {
111 return yield* ResponseHeadersPolicy("ListResponseHeaders", {
112 comment: "list",
113 securityHeadersConfig: { ContentTypeOptions: { Override: true } },
114 });
115 }),
116 );
117
118 const provider = yield* Provider.findProvider(ResponseHeadersPolicy);
119 const all = yield* provider.list();
120
121 expect(
122 all.some((p) => p.responseHeadersPolicyId === deployed.responseHeadersPolicyId),
123 ).toBe(true);
124
125 yield* stack.destroy();
126 yield* assertResponseHeadersPolicyDeleted(deployed.responseHeadersPolicyId);
127 }),
128 { timeout: 300_000 },
129 );
130 },
131 );
132
133 const assertResponseHeadersPolicyDeleted = (id: string) =>
134 cloudfront.getResponseHeadersPolicy({ Id: id }).pipe(
135 Effect.flatMap(() => Effect.fail(new Error("ResponseHeadersPolicyStillExists"))),
136 Effect.catchTag("NoSuchResponseHeadersPolicy", () => Effect.void),
137 Effect.retry({
138 while: (error) =>
139 error instanceof Error && error.message === "ResponseHeadersPolicyStillExists",
140 schedule: Schedule.max([Schedule.fixed("5 seconds"), Schedule.recurs(24)]),
141 }),
142 );