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

main
ts 118 lines 4.18 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { Role } from "@alchemy.run/aws/IAM";
3 import { Server, User } from "@alchemy.run/aws/Transfer";
4 import { expect } from "@alchemy.run/test";
5 import * as Test from "@alchemy.run/test/Alchemy";
6 import * as transfer from "@distilled.cloud/aws/transfer";
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 // Ungated typed-error probe: proves the distilled error union carries the
13 // not-found tag this provider's read/delete paths depend on.
14 test.provider(
15 "describeServer on a nonexistent server fails with ResourceNotFoundException",
16 () =>
17 Effect.gen(function* () {
18 const error = yield* Effect.flip(
19 transfer.describeServer({ ServerId: "s-00000000000000000" }),
20 );
21 expect(error._tag).toBe("ResourceNotFoundException");
22 }),
23 { tags: ["provider:aws", "provider:aws:transfer", "live"] },
24 );
25
26 const describeServer = (serverId: string) =>
27 transfer.describeServer({ ServerId: serverId }).pipe(
28 Effect.map((r) => r.Server),
29 Effect.catchTag("ResourceNotFoundException", () => Effect.succeed(undefined)),
30 );
31
32 const assertServerGone = (serverId: string) =>
33 describeServer(serverId).pipe(
34 Effect.flatMap((server) =>
35 server === undefined
36 ? Effect.void
37 : Effect.fail(new Error(`server '${serverId}' still exists`)),
38 ),
39 Effect.retry({ schedule: Schedule.max([Schedule.fixed("5 seconds"), Schedule.recurs(24)]) }),
40 );
41
42 // A running Transfer server is billed hourly. Provisioning to ONLINE takes a
43 // few minutes. The full lifecycle is skipped under `--fast` and always
44 // destroys what it created.
45 test.provider.skipIf(!!process.env.FAST)(
46 "create SFTP server + service-managed user, destroy, verify gone",
47 (stack) =>
48 Effect.gen(function* () {
49 yield* stack.destroy();
50
51 const { server, user } = yield* stack.deploy(
52 Effect.gen(function* () {
53 const server = yield* Server("Sftp", {
54 protocols: ["SFTP"],
55 domain: "S3",
56 endpointType: "PUBLIC",
57 identityProviderType: "SERVICE_MANAGED",
58 tags: { env: "test" },
59 });
60 const role = yield* Role("TransferUserRole", {
61 assumeRolePolicyDocument: {
62 Version: "2012-10-17",
63 Statement: [
64 {
65 Effect: "Allow",
66 Principal: { Service: "transfer.amazonaws.com" },
67 Action: ["sts:AssumeRole"],
68 },
69 ],
70 },
71 inlinePolicies: {
72 s3: {
73 Version: "2012-10-17",
74 Statement: [
75 {
76 Effect: "Allow",
77 Action: ["s3:ListBucket", "s3:GetObject", "s3:PutObject"],
78 Resource: ["*"],
79 },
80 ],
81 },
82 },
83 });
84 const user = yield* User("Alice", {
85 serverId: server.serverId,
86 userName: "alice",
87 role: role.roleArn,
88 homeDirectory: "/example-bucket/alice",
89 tags: { env: "test" },
90 });
91 return { server, user };
92 }),
93 );
94
95 expect(server.arn).toContain(":server/");
96 expect(server.protocols).toContain("SFTP");
97 expect(server.domain).toBe("S3");
98 expect(["ONLINE", "OFFLINE", "STARTING"]).toContain(server.state);
99 expect(server.tags.env).toBe("test");
100
101 // Out-of-band verification via distilled.
102 const observedServer = yield* describeServer(server.serverId);
103 expect(observedServer?.IdentityProviderType).toBe("SERVICE_MANAGED");
104
105 expect(user.userName).toBe("alice");
106 expect(user.arn).toContain(":user/");
107 const observedUser = yield* transfer.describeUser({
108 ServerId: server.serverId,
109 UserName: "alice",
110 });
111 expect(observedUser.User.HomeDirectory).toBe("/example-bucket/alice");
112 expect(observedUser.User.Role).toBe(user.role);
113
114 yield* stack.destroy();
115 yield* assertServerGone(server.serverId);
116 }),
117 { tags: ["provider:aws", "provider:aws:iam", "provider:aws:transfer", "live"], timeout: 900_000 },
118 );