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

main
ts 174 lines 6.35 KB
Raw
1 import * as Docker from "@alchemy.run/docker";
2 import { describe, expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import { adopt, OwnedBySomeoneElse } from "alchemy/AdoptPolicy";
5 import * as Provider from "alchemy/Provider";
6 import { inMemoryState } from "alchemy/State";
7 import * as Cause from "effect/Cause";
8 import * as Effect from "effect/Effect";
9
10 const { test } = Test.make({ providers: Docker.providers(), state: inMemoryState() });
11
12 test.provider(
13 "diff replaces a network when labels change",
14 () =>
15 Effect.gen(function* () {
16 const networkProvider = yield* Provider.findProvider(Docker.Network);
17 const networkDiff = yield* networkProvider.diff!({
18 id: "app",
19 fqn: "app",
20 instanceId: "instance",
21 olds: { name: "app", labels: { usage: "old" } },
22 news: { name: "app", labels: { usage: "new" } },
23 oldBindings: [],
24 newBindings: [],
25 output: {
26 id: "app",
27 name: "app",
28 driver: "bridge",
29 enableIPv6: false,
30 labels: { usage: "old" },
31 createdAt: 0,
32 },
33 });
34 expect(networkDiff).toEqual({ action: "replace", deleteFirst: true });
35 }),
36 { tags: ["provider:docker", "provider:docker:network", "local"] },
37 );
38
39 test.provider(
40 "diff replaces a network when its Docker context changes",
41 () =>
42 Effect.gen(function* () {
43 const networkProvider = yield* Provider.findProvider(Docker.Network);
44 const networkDiff = yield* networkProvider.diff!({
45 id: "app",
46 fqn: "app",
47 instanceId: "instance",
48 olds: { name: "app", context: "default" },
49 news: { name: "app", context: "remote-build" },
50 oldBindings: [],
51 newBindings: [],
52 output: {
53 id: "app",
54 name: "app",
55 driver: "bridge",
56 enableIPv6: false,
57 labels: {},
58 createdAt: 0,
59 },
60 });
61 expect(networkDiff).toEqual({ action: "replace", deleteFirst: true });
62 }),
63 { tags: ["provider:docker", "provider:docker:network", "local"] },
64 );
65
66 describe(
67 "Docker.Network",
68 { tags: ["provider:docker", "provider:docker:network", "local"], concurrent: false },
69 () => {
70 // Every prop is optional: `Docker.Network("app")` must plan, deploy,
71 // redeploy in place, and destroy without a props object.
72 test.provider("deploys a network declared without props", (stack) =>
73 Effect.gen(function* () {
74 const docker = yield* Docker.Docker;
75 yield* stack.destroy();
76 const first = yield* stack.deploy(Docker.Network("bare-network"));
77 const second = yield* stack.deploy(Docker.Network("bare-network"));
78 expect(second.id).toBe(first.id);
79 yield* stack.destroy();
80 const gone = yield* docker.network.inspect(first.id).pipe(Effect.flip);
81 expect(gone.reason._tag).toBe("NotFound");
82 }),
83 );
84
85 test.provider("creates a bridge network", (stack) =>
86 Effect.gen(function* () {
87 const network = yield* stack.deploy(
88 Docker.Network("created-network", { labels: { "com.alchemy.test": "true" } }),
89 );
90 expect(network).toMatchObject({
91 name: expect.any(String),
92 driver: "bridge",
93 id: expect.any(String),
94 labels: { "com.alchemy.test": "true" },
95 });
96 }),
97 );
98
99 test.provider("refuses a pre-existing network unless explicitly adopted", (stack) =>
100 Effect.gen(function* () {
101 const docker = yield* Docker.Docker;
102 const networkName = "alchemy-test-network-adoption";
103 yield* Effect.addFinalizer(() => docker.network.remove(networkName).pipe(Effect.ignore));
104 yield* docker.network
105 .remove(networkName)
106 .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.void));
107 yield* docker.network.create({ name: networkName, driver: "bridge" });
108
109 const error = yield* stack
110 .deploy(Docker.Network("existing-network", { name: networkName }))
111 .pipe(
112 Effect.as(undefined),
113 Effect.catchCause((cause) => Effect.succeed(findOwnedError(cause))),
114 );
115 expect(error).toBeInstanceOf(OwnedBySomeoneElse);
116
117 const network = yield* stack.deploy(
118 Docker.Network("existing-network", { name: networkName }).pipe(adopt(true)),
119 );
120 expect(network.name).toBe(networkName);
121 expect(network.id.length).toBeGreaterThan(0);
122 }),
123 );
124
125 test.provider("adopts an existing same-name network with stack adoption", (stack) =>
126 Effect.gen(function* () {
127 const docker = yield* Docker.Docker;
128 const networkName = "alchemy-test-network-adopt-existing";
129 yield* Effect.addFinalizer(() => docker.network.remove(networkName).pipe(Effect.ignore));
130 yield* docker.network
131 .remove(networkName)
132 .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.void));
133 yield* docker.network.create({ name: networkName, driver: "bridge" });
134
135 const network = yield* stack.deploy(
136 Docker.Network("existing-network", { name: networkName, driver: "bridge" }).pipe(
137 adopt(true),
138 ),
139 );
140 expect(network.name).toBe(networkName);
141 expect(network.id.length).toBeGreaterThan(0);
142 }),
143 );
144
145 test.provider("replaces a network when its labels change", (stack) =>
146 Effect.gen(function* () {
147 const docker = yield* Docker.Docker;
148 const name = "alchemy-test-network-replace";
149 yield* docker.network
150 .remove(name)
151 .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.void));
152 const first = yield* stack.deploy(
153 Docker.Network("replaceable-network", { name, labels: { generation: "1" } }),
154 );
155 const second = yield* stack.deploy(
156 Docker.Network("replaceable-network", { name, labels: { generation: "2" } }),
157 );
158 expect(second.id).not.toBe(first.id);
159 expect(second.labels.generation).toBe("2");
160 }),
161 );
162 },
163 );
164
165 const findOwnedError = (cause: Cause.Cause<unknown>): OwnedBySomeoneElse | undefined =>
166 cause.reasons
167 .map((reason) =>
168 Cause.isFailReason(reason)
169 ? reason.error
170 : Cause.isDieReason(reason)
171 ? reason.defect
172 : undefined,
173 )
174 .find((value): value is OwnedBySomeoneElse => value instanceof OwnedBySomeoneElse);