@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 152 lines 6.24 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { Application } from "@alchemy.run/aws/CodeDeploy/Application";
3 import { DeploymentConfig } from "@alchemy.run/aws/CodeDeploy/DeploymentConfig";
4 import { DeploymentGroup } from "@alchemy.run/aws/CodeDeploy/DeploymentGroup";
5 import { expect } from "@alchemy.run/test";
6 import * as Test from "@alchemy.run/test/Alchemy";
7 import * as codedeploy from "@distilled.cloud/aws/codedeploy";
8 import * as Provider from "alchemy/Provider";
9 import * as Effect from "effect/Effect";
10
11 const { test } = Test.make({ providers: AWS.providers() });
12
13 const applicationName = "alchemy-test-cd-app";
14 const deploymentGroupName = "alchemy-test-cd-dg";
15 const deploymentConfigName = "alchemy-test-cd-config";
16
17 const getGroup = codedeploy.getDeploymentGroup({ applicationName, deploymentGroupName }).pipe(
18 Effect.map((res) => res.deploymentGroupInfo),
19 Effect.catchTag(
20 ["DeploymentGroupDoesNotExistException", "ApplicationDoesNotExistException"],
21 () => Effect.succeed(undefined),
22 ),
23 );
24
25 // A Lambda-platform deployment group: an application, a custom canary
26 // deployment configuration, a CodeDeploy service role (assumed by
27 // codedeploy.amazonaws.com, granted the AWS-managed Lambda policy), and the
28 // group tying a deployment config to the application.
29 const makeStack = (useCustomConfig: boolean) =>
30 Effect.gen(function* () {
31 const app = yield* Application("App", {
32 applicationName,
33 computePlatform: "Lambda",
34 });
35 const config = yield* DeploymentConfig("Config", {
36 deploymentConfigName,
37 computePlatform: "Lambda",
38 trafficRoutingConfig: {
39 type: "TimeBasedCanary",
40 timeBasedCanary: { canaryPercentage: 10, canaryInterval: 1 },
41 },
42 });
43 const role = yield* AWS.IAM.Role("DeployRole", {
44 assumeRolePolicyDocument: {
45 Version: "2012-10-17",
46 Statement: [
47 {
48 Effect: "Allow",
49 Principal: { Service: "codedeploy.amazonaws.com" },
50 Action: ["sts:AssumeRole"],
51 },
52 ],
53 },
54 managedPolicyArns: ["arn:aws:iam::aws:policy/service-role/AWSCodeDeployRoleForLambda"],
55 });
56 const group = yield* DeploymentGroup("Group", {
57 applicationName: app.applicationName,
58 deploymentGroupName,
59 serviceRoleArn: role.roleArn,
60 deploymentConfigName: useCustomConfig
61 ? config.deploymentConfigName
62 : "CodeDeployDefault.LambdaAllAtOnce",
63 deploymentStyle: {
64 deploymentType: "BLUE_GREEN",
65 deploymentOption: "WITH_TRAFFIC_CONTROL",
66 },
67 autoRollbackConfiguration: {
68 enabled: true,
69 events: ["DEPLOYMENT_FAILURE"],
70 },
71 tags: { env: "test" },
72 });
73 return { app, config, group };
74 });
75
76 test.provider(
77 "lifecycle: create Lambda application + deployment group, update config, destroy",
78 (stack) =>
79 Effect.gen(function* () {
80 yield* stack.destroy();
81
82 // Create.
83 const deployed = yield* stack.deploy(makeStack(false));
84 expect(deployed.app.applicationName).toBe(applicationName);
85 expect(deployed.app.applicationArn).toContain(":application:");
86 expect(deployed.app.computePlatform).toBe("Lambda");
87 expect(deployed.group.deploymentGroupName).toBe(deploymentGroupName);
88 expect(deployed.group.deploymentGroupArn).toContain(":deploymentgroup:");
89 expect(deployed.config.deploymentConfigName).toBe(deploymentConfigName);
90 expect(deployed.config.deploymentConfigArn).toContain(":deploymentconfig:");
91 expect(deployed.config.deploymentConfigId).toBeTruthy();
92 expect(deployed.config.computePlatform).toBe("Lambda");
93
94 // Out-of-band verification via distilled.
95 const created = yield* getGroup;
96 expect(created?.deploymentGroupName).toBe(deploymentGroupName);
97 expect(created?.computePlatform).toBe("Lambda");
98 expect(created?.deploymentConfigName).toBe("CodeDeployDefault.LambdaAllAtOnce");
99
100 const appCheck = yield* codedeploy.getApplication({ applicationName });
101 expect(appCheck.application?.computePlatform).toBe("Lambda");
102
103 // Out-of-band verification of the custom deployment configuration.
104 const configCheck = yield* codedeploy.getDeploymentConfig({
105 deploymentConfigName,
106 });
107 expect(configCheck.deploymentConfigInfo?.computePlatform).toBe("Lambda");
108 expect(
109 configCheck.deploymentConfigInfo?.trafficRoutingConfig?.timeBasedCanary?.canaryPercentage,
110 ).toBe(10);
111
112 // Canonical list() coverage for Application.
113 const appProvider = yield* Provider.findProvider(Application);
114 const apps = yield* appProvider.list();
115 expect(apps.some((a) => a.applicationName === applicationName)).toBe(true);
116
117 // Canonical list() coverage for DeploymentConfig — custom configs are
118 // listed, AWS-managed CodeDeployDefault.* ones are filtered out.
119 const configProvider = yield* Provider.findProvider(DeploymentConfig);
120 const configs = yield* configProvider.list();
121 expect(configs.some((c) => c.deploymentConfigName === deploymentConfigName)).toBe(true);
122 expect(configs.every((c) => !c.deploymentConfigName.startsWith("CodeDeployDefault."))).toBe(
123 true,
124 );
125
126 // Update — point the group at the custom config in place (no
127 // replacement).
128 yield* stack.deploy(makeStack(true));
129 const updated = yield* getGroup;
130 expect(updated?.deploymentConfigName).toBe(deploymentConfigName);
131
132 // Destroy — verify the group, application, and config are gone
133 // out-of-band.
134 yield* stack.destroy();
135 const afterGroup = yield* getGroup;
136 expect(afterGroup).toBeUndefined();
137 const afterApp = yield* codedeploy.getApplication({ applicationName }).pipe(
138 Effect.map((res) => res.application),
139 Effect.catchTag("ApplicationDoesNotExistException", () => Effect.succeed(undefined)),
140 );
141 expect(afterApp).toBeUndefined();
142 const afterConfig = yield* codedeploy.getDeploymentConfig({ deploymentConfigName }).pipe(
143 Effect.map((res) => res.deploymentConfigInfo),
144 Effect.catchTag("DeploymentConfigDoesNotExistException", () => Effect.succeed(undefined)),
145 );
146 expect(afterConfig).toBeUndefined();
147 }),
148 {
149 tags: ["provider:aws", "provider:aws:codedeploy", "provider:aws:iam", "live"],
150 timeout: 300_000,
151 },
152 );