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

main
ts 147 lines 5.39 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 Effect from "effect/Effect";
8
9 const { test } = Test.make({ providers: Docker.providers(), state: inMemoryState() });
10
11 test.provider(
12 "diff replaces a volume when labels change",
13 () =>
14 Effect.gen(function* () {
15 const volumeProvider = yield* Provider.findProvider(Docker.Volume);
16 const volumeDiff = yield* volumeProvider.diff!({
17 id: "data",
18 fqn: "data",
19 instanceId: "instance",
20 olds: { name: "data", labels: { usage: "old" } },
21 news: { name: "data", labels: { usage: "new" } },
22 oldBindings: [],
23 newBindings: [],
24 output: {
25 id: "data",
26 name: "data",
27 driver: "local",
28 driverOpts: {},
29 labels: { usage: "old" },
30 mountpoint: undefined,
31 createdAt: 0,
32 },
33 });
34 expect(volumeDiff).toEqual({ action: "replace", deleteFirst: true });
35 }),
36 { tags: ["provider:docker", "provider:docker:volume", "local"] },
37 );
38
39 test.provider(
40 "diff replaces a volume when its Docker context changes",
41 () =>
42 Effect.gen(function* () {
43 const volumeProvider = yield* Provider.findProvider(Docker.Volume);
44 const volumeDiff = yield* volumeProvider.diff!({
45 id: "data",
46 fqn: "data",
47 instanceId: "instance",
48 olds: { name: "data", context: "default" },
49 news: { name: "data", context: "remote-build" },
50 oldBindings: [],
51 newBindings: [],
52 output: {
53 id: "data",
54 name: "data",
55 driver: "local",
56 driverOpts: {},
57 labels: {},
58 mountpoint: undefined,
59 createdAt: 0,
60 },
61 });
62 expect(volumeDiff).toEqual({ action: "replace", deleteFirst: true });
63 }),
64 { tags: ["provider:docker", "provider:docker:volume", "local"] },
65 );
66
67 describe(
68 "Docker.Volume",
69 { tags: ["provider:docker", "provider:docker:volume", "local"], concurrent: false },
70 () => {
71 // Every prop is optional: `Docker.Volume("data")` must plan, deploy,
72 // redeploy in place, and destroy without a props object.
73 test.provider("deploys a volume declared without props", (stack) =>
74 Effect.gen(function* () {
75 const docker = yield* Docker.Docker;
76 yield* stack.destroy();
77 const first = yield* stack.deploy(Docker.Volume("bare-volume"));
78 expect(first.driver).toBe("local");
79 const second = yield* stack.deploy(Docker.Volume("bare-volume"));
80 expect(second.createdAt).toBe(first.createdAt);
81 yield* stack.destroy();
82 const gone = yield* docker.volume.inspect(first.name).pipe(Effect.flip);
83 expect(gone.reason._tag).toBe("NotFound");
84 }),
85 );
86
87 test.provider("creates a volume with labels", (stack) =>
88 Effect.gen(function* () {
89 const docker = yield* Docker.Docker;
90 const volumeName = "alchemy-test-volume-create";
91 yield* Effect.addFinalizer(() => docker.volume.remove(volumeName).pipe(Effect.ignore));
92 const volume = yield* stack.deploy(
93 Docker.Volume("created-volume", {
94 name: volumeName,
95 labels: { "com.alchemy.test": "true" },
96 }),
97 );
98 expect(volume.name).toBe(volumeName);
99 expect(volume.id).toBe(volumeName);
100 expect(volume.driver).toBe("local");
101 expect(volume.labels["com.alchemy.test"]).toBe("true");
102 expect(volume.mountpoint?.length).toBeGreaterThan(0);
103 }),
104 );
105
106 test.provider("adopts an existing Docker volume", (stack) =>
107 Effect.gen(function* () {
108 const docker = yield* Docker.Docker;
109 const volumeName = "alchemy-test-volume-adopt-existing";
110 yield* Effect.addFinalizer(() => docker.volume.remove(volumeName).pipe(Effect.ignore));
111 yield* docker.volume
112 .remove(volumeName)
113 .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.void));
114 yield* docker.volume.create({ name: volumeName });
115
116 const error = yield* stack
117 .deploy(Docker.Volume("existing-volume", { name: volumeName }))
118 .pipe(Effect.flip);
119 expect(error).toBeInstanceOf(OwnedBySomeoneElse);
120 const volume = yield* stack.deploy(
121 Docker.Volume("existing-volume", { name: volumeName }).pipe(adopt(true)),
122 );
123 expect(volume.name).toBe(volumeName);
124 expect(volume.id).toBe(volumeName);
125 expect(volume.driver).toBe("local");
126 }),
127 );
128
129 test.provider("replaces a volume when its labels change", (stack) =>
130 Effect.gen(function* () {
131 const docker = yield* Docker.Docker;
132 const volumeName = "alchemy-test-volume-replace";
133 yield* docker.volume
134 .remove(volumeName)
135 .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.void));
136 const first = yield* stack.deploy(
137 Docker.Volume("replaceable-volume", { labels: { generation: "1" } }),
138 );
139 const second = yield* stack.deploy(
140 Docker.Volume("replaceable-volume", { labels: { generation: "2" } }),
141 );
142 expect(second.id).not.toBe(first.id);
143 expect(second.labels.generation).toBe("2");
144 }),
145 );
146 },
147 );