import * as Docker from "@alchemy.run/docker";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import { adopt, OwnedBySomeoneElse } from "alchemy/AdoptPolicy";
import * as Provider from "alchemy/Provider";
import { inMemoryState } from "alchemy/State";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
const { test } = Test.make({ providers: Docker.providers(), state: inMemoryState() });
test.provider(
"diff replaces a network when labels change",
() =>
Effect.gen(function* () {
const networkProvider = yield* Provider.findProvider(Docker.Network);
const networkDiff = yield* networkProvider.diff!({
id: "app",
fqn: "app",
instanceId: "instance",
olds: { name: "app", labels: { usage: "old" } },
news: { name: "app", labels: { usage: "new" } },
oldBindings: [],
newBindings: [],
output: {
id: "app",
name: "app",
driver: "bridge",
enableIPv6: false,
labels: { usage: "old" },
createdAt: 0,
},
});
expect(networkDiff).toEqual({ action: "replace", deleteFirst: true });
}),
{ tags: ["provider:docker", "provider:docker:network", "local"] },
);
test.provider(
"diff replaces a network when its Docker context changes",
() =>
Effect.gen(function* () {
const networkProvider = yield* Provider.findProvider(Docker.Network);
const networkDiff = yield* networkProvider.diff!({
id: "app",
fqn: "app",
instanceId: "instance",
olds: { name: "app", context: "default" },
news: { name: "app", context: "remote-build" },
oldBindings: [],
newBindings: [],
output: {
id: "app",
name: "app",
driver: "bridge",
enableIPv6: false,
labels: {},
createdAt: 0,
},
});
expect(networkDiff).toEqual({ action: "replace", deleteFirst: true });
}),
{ tags: ["provider:docker", "provider:docker:network", "local"] },
);
describe(
"Docker.Network",
{ tags: ["provider:docker", "provider:docker:network", "local"], concurrent: false },
() => {
// Every prop is optional: `Docker.Network("app")` must plan, deploy,
// redeploy in place, and destroy without a props object.
test.provider("deploys a network declared without props", (stack) =>
Effect.gen(function* () {
const docker = yield* Docker.Docker;
yield* stack.destroy();
const first = yield* stack.deploy(Docker.Network("bare-network"));
const second = yield* stack.deploy(Docker.Network("bare-network"));
expect(second.id).toBe(first.id);
yield* stack.destroy();
const gone = yield* docker.network.inspect(first.id).pipe(Effect.flip);
expect(gone.reason._tag).toBe("NotFound");
}),
);
test.provider("creates a bridge network", (stack) =>
Effect.gen(function* () {
const network = yield* stack.deploy(
Docker.Network("created-network", { labels: { "com.alchemy.test": "true" } }),
);
expect(network).toMatchObject({
name: expect.any(String),
driver: "bridge",
id: expect.any(String),
labels: { "com.alchemy.test": "true" },
});
}),
);
test.provider("refuses a pre-existing network unless explicitly adopted", (stack) =>
Effect.gen(function* () {
const docker = yield* Docker.Docker;
const networkName = "alchemy-test-network-adoption";
yield* Effect.addFinalizer(() => docker.network.remove(networkName).pipe(Effect.ignore));
yield* docker.network
.remove(networkName)
.pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.void));
yield* docker.network.create({ name: networkName, driver: "bridge" });
const error = yield* stack
.deploy(Docker.Network("existing-network", { name: networkName }))
.pipe(
Effect.as(undefined),
Effect.catchCause((cause) => Effect.succeed(findOwnedError(cause))),
);
expect(error).toBeInstanceOf(OwnedBySomeoneElse);
const network = yield* stack.deploy(
Docker.Network("existing-network", { name: networkName }).pipe(adopt(true)),
);
expect(network.name).toBe(networkName);
expect(network.id.length).toBeGreaterThan(0);
}),
);
test.provider("adopts an existing same-name network with stack adoption", (stack) =>
Effect.gen(function* () {
const docker = yield* Docker.Docker;
const networkName = "alchemy-test-network-adopt-existing";
yield* Effect.addFinalizer(() => docker.network.remove(networkName).pipe(Effect.ignore));
yield* docker.network
.remove(networkName)
.pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.void));
yield* docker.network.create({ name: networkName, driver: "bridge" });
const network = yield* stack.deploy(
Docker.Network("existing-network", { name: networkName, driver: "bridge" }).pipe(
adopt(true),
),
);
expect(network.name).toBe(networkName);
expect(network.id.length).toBeGreaterThan(0);
}),
);
test.provider("replaces a network when its labels change", (stack) =>
Effect.gen(function* () {
const docker = yield* Docker.Docker;
const name = "alchemy-test-network-replace";
yield* docker.network
.remove(name)
.pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.void));
const first = yield* stack.deploy(
Docker.Network("replaceable-network", { name, labels: { generation: "1" } }),
);
const second = yield* stack.deploy(
Docker.Network("replaceable-network", { name, labels: { generation: "2" } }),
);
expect(second.id).not.toBe(first.id);
expect(second.labels.generation).toBe("2");
}),
);
},
);
const findOwnedError = (cause: Cause.Cause<unknown>): OwnedBySomeoneElse | undefined =>
cause.reasons
.map((reason) =>
Cause.isFailReason(reason)
? reason.error
: Cause.isDieReason(reason)
? reason.defect
: undefined,
)
.find((value): value is OwnedBySomeoneElse => value instanceof OwnedBySomeoneElse);