Add some basic smoke tests to check that workers with multiple containers work as expected (#9960)

* add multi-containers tests in interactive-dev-tests

* add multi-containers wrangler deploy tests

Author: dario-piotrowicz

fixtures/interactive-dev-tests/multi-containers-app/DockerfileA

@@ -0,0 +1,20 @@
+FROM node:22-alpine
+
+WORKDIR /usr/src/app
+RUN echo '{"name": "simple-node-app-a", "version": "1.0.0"}' > package.json
+RUN npm install
+
+RUN sleep 1
+
+RUN echo 'const { createServer } = require("http");\
+\
+const server = createServer(function (req, res) {\
+	res.writeHead(200, { "Content-Type": "text/plain" });\
+	res.write("Hello from Container A");\
+	res.end();\
+});\
+\
+server.listen(8080);\
+' > app.js
+
+EXPOSE 8080

fixtures/interactive-dev-tests/multi-containers-app/DockerfileB

@@ -0,0 +1,20 @@
+FROM node:22-alpine
+
+WORKDIR /usr/src/app
+RUN echo '{"name": "simple-node-app-b", "version": "1.0.0"}' > package.json
+RUN npm install
+
+RUN sleep 1
+
+RUN echo 'const { createServer } = require("http");\
+\
+const server = createServer(function (req, res) {\
+	res.writeHead(200, { "Content-Type": "text/plain" });\
+	res.write("Hello from Container B");\
+	res.end();\
+});\
+\
+server.listen(8080);\
+' > app.js
+
+EXPOSE 8080

fixtures/interactive-dev-tests/multi-containers-app/src/index.ts

@@ -0,0 +1,49 @@
+import { DurableObject } from "cloudflare:workers";
+
+class FixtureTestContainerBase extends DurableObject<Env> {
+	container: globalThis.Container;
+
+	constructor(ctx: DurableObjectState, env: Env) {
+		super(ctx, env);
+		this.container = ctx.container;
+	}
+
+	async fetch(req: Request) {
+		if (!this.container.running) {
+			this.container.start({
+				entrypoint: ["node", "app.js"],
+				enableInternet: false,
+			});
+			// On the first request we simply start the container and return,
+			// on the following requests the container can actually be accessed.
+			// Note that we do this this way becase container.start is not awaitable
+			// meaning that we can't simply wait here for the container to be ready
+			return new Response("Container started");
+		}
+		return this.container
+			.getTcpPort(8080)
+			.fetch("http://foo/bar/baz", { method: "POST", body: "hello" });
+	}
+}
+
+export class FixtureTestContainerA extends FixtureTestContainerBase {}
+export class FixtureTestContainerB extends FixtureTestContainerBase {}
+
+export default {
+	async fetch(request, env): Promise<Response> {
+		const getContainerText = async (
+			container: "CONTAINER_A" | "CONTAINER_B"
+		) => {
+			const id = env[container].idFromName("container");
+			const stub = env[container].get(id);
+			return await (await stub.fetch(request)).text();
+		};
+		const containerAText = await getContainerText("CONTAINER_A");
+		const containerBText = await getContainerText("CONTAINER_B");
+		return new Response(
+			`Response from A: "${containerAText}"` +
+				" " +
+				`Response from B: "${containerBText}"`
+		);
+	},
+} satisfies ExportedHandler<Env>;

fixtures/interactive-dev-tests/multi-containers-app/src/tsconfig.json

@@ -0,0 +1,12 @@
+{
+	"compilerOptions": {
+		"target": "ES2020",
+		"module": "ESNext",
+		"lib": ["ES2020"],
+		"types": ["@cloudflare/workers-types"],
+		"moduleResolution": "node",
+		"noEmit": true,
+		"skipLibCheck": true
+	},
+	"include": ["**/*.ts"]
+}

fixtures/interactive-dev-tests/multi-containers-app/src/worker-configuration.d.ts

@@ -0,0 +1,8 @@
+declare namespace Cloudflare {
+	interface Env {
+		CONTAINER_A: DurableObjectNamespace<import("./src").FixtureTestContainerA>;
+		CONTAINER_B: DurableObjectNamespace<import("./src").FixtureTestContainerB>;
+	}
+}
+
+interface Env extends Cloudflare.Env {}

fixtures/interactive-dev-tests/multi-containers-app/wrangler.jsonc

@@ -0,0 +1,41 @@
+{
+	"name": "multi-containers-app",
+	"main": "src/index.ts",
+	"compatibility_date": "2025-04-03",
+	"containers": [
+		{
+			"image": "./DockerfileA",
+			"class_name": "FixtureTestContainerA",
+			"name": "containerA",
+			"max_instances": 2,
+		},
+		{
+			"image": "./DockerfileB",
+			"class_name": "FixtureTestContainerB",
+			"name": "containerB",
+			"max_instances": 2,
+		},
+	],
+	"durable_objects": {
+		"bindings": [
+			{
+				"class_name": "FixtureTestContainerA",
+				"name": "CONTAINER_A",
+			},
+			{
+				"class_name": "FixtureTestContainerB",
+				"name": "CONTAINER_B",
+			},
+		],
+	},
+	"migrations": [
+		{
+			"tag": "v1",
+			"new_sqlite_classes": ["FixtureTestContainerA"],
+		},
+		{
+			"tag": "v1",
+			"new_sqlite_classes": ["FixtureTestContainerB"],
+		},
+	],
+}

fixtures/interactive-dev-tests/tests/index.test.ts

@@ -7,7 +7,7 @@ import rl from "node:readline";
 import stream from "node:stream";
 import { setTimeout } from "node:timers/promises";
 import stripAnsi from "strip-ansi";
-import { fetch } from "undici";
+import { fetch, RequestInfo } from "undici";
 import {
 	afterAll,
 	afterEach,
@@ -561,6 +561,170 @@ baseDescribe.skipIf(process.platform !== "linux" && process.env.CI === "true")(
 	}
 );
 
+baseDescribe.skipIf(process.platform !== "linux" && process.env.CI === "true")(
+	"multi-containers dev",
+	{ retry: 0, timeout: 50000 },
+	() => {
+		let tmpDir: string;
+		beforeAll(async () => {
+			tmpDir = fs.mkdtempSync(
+				path.join(tmpdir(), "wrangler-multi-containers-")
+			);
+			fs.cpSync(
+				path.resolve(__dirname, "../", "multi-containers-app"),
+				path.join(tmpDir),
+				{
+					recursive: true,
+				}
+			);
+
+			const ids = getContainerIds();
+			if (ids.length > 0) {
+				execSync("docker rm -f " + ids.join(" "), {
+					encoding: "utf8",
+				});
+			}
+		});
+
+		afterEach(async () => {
+			const ids = getContainerIds();
+			if (ids.length > 0) {
+				execSync("docker rm -f " + ids.join(" "), {
+					encoding: "utf8",
+				});
+			}
+		});
+		afterAll(async () => {
+			try {
+				fs.rmSync(tmpDir, { recursive: true, force: true });
+			} catch (e) {
+				// It seems that Windows doesn't let us delete this, with errors like:
+				//
+				// Error: EBUSY: resource busy or locked, rmdir 'C:\Users\RUNNER~1\AppData\Local\Temp\wrangler-modules-pKJ7OQ'
+				// ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
+				// Serialized Error: {
+				// 	"code": "EBUSY",
+				// 	"errno": -4082,
+				// 	"path": "C:\Users\RUNNER~1\AppData\Local\Temp\wrangler-modules-pKJ7OQ",
+				// 	"syscall": "rmdir",
+				// }
+				console.error(e);
+			}
+		});
+
+		async function fetchWithTimeout(input: RequestInfo) {
+			const controller = new AbortController();
+			const { signal } = controller;
+			setTimeout(3_000).then(() => {
+				controller.abort();
+			});
+			return await fetch(input, { signal });
+		}
+
+		it("should print build logs for all the containers", async () => {
+			const wrangler = await startWranglerDev([
+				"dev",
+				"-c",
+				path.join(tmpDir, "wrangler.jsonc"),
+			]);
+			await vi.waitFor(
+				() => {
+					expect(wrangler.stdout).toContain('"name": "simple-node-app-a"');
+					expect(wrangler.stdout).toContain('"name": "simple-node-app-b"');
+				},
+				{ timeout: 10_000 }
+			);
+			wrangler.pty.kill();
+		});
+
+		it("should rebuild all the containers when the hotkey is pressed", async () => {
+			const wrangler = await startWranglerDev([
+				"dev",
+				"-c",
+				path.join(tmpDir, "wrangler.jsonc"),
+			]);
+
+			await vi.waitFor(
+				async () => {
+					const text = await (await fetchWithTimeout(wrangler.url)).text();
+					expect(text).toBe(
+						'Response from A: "Hello from Container A" Response from B: "Hello from Container B"'
+					);
+				},
+				{ timeout: 30_000, interval: 1000 }
+			);
+
+			const tmpDockerfileAPath = path.join(tmpDir, "DockerfileA");
+			const dockerFileAContent = fs.readFileSync(tmpDockerfileAPath, "utf8");
+			fs.writeFileSync(
+				tmpDockerfileAPath,
+				dockerFileAContent.replace(
+					'"Hello from Container A"',
+					'"Hello World from Container A"'
+				),
+				"utf-8"
+			);
+
+			const tmpDockerfileBPath = path.join(tmpDir, "DockerfileB");
+			const dockerFileBContent = fs.readFileSync(tmpDockerfileBPath, "utf8");
+			fs.writeFileSync(
+				tmpDockerfileBPath,
+				dockerFileBContent.replace(
+					'"Hello from Container B"',
+					'"Hello from the B Container"'
+				),
+				"utf-8"
+			);
+
+			wrangler.pty.write("r");
+
+			await vi.waitFor(
+				async () => {
+					const text = await (await fetchWithTimeout(wrangler.url)).text();
+					expect(text).toBe(
+						'Response from A: "Hello World from Container A" Response from B: "Hello from the B Container"'
+					);
+				},
+				{ timeout: 30_000, interval: 1000 }
+			);
+
+			fs.writeFileSync(tmpDockerfileAPath, dockerFileAContent, "utf-8");
+			fs.writeFileSync(tmpDockerfileBPath, dockerFileBContent, "utf-8");
+
+			wrangler.pty.kill();
+		});
+
+		it("should clean up any containers that were started", async () => {
+			const wrangler = await startWranglerDev([
+				"dev",
+				"-c",
+				path.join(tmpDir, "wrangler.jsonc"),
+			]);
+			// wait container to be ready
+			await vi.waitFor(
+				async () => {
+					const text = await (await fetchWithTimeout(wrangler.url)).text();
+					expect(text).toBe(
+						'Response from A: "Hello from Container A" Response from B: "Hello from Container B"'
+					);
+				},
+				{ timeout: 30_000, interval: 1000 }
+			);
+			const ids = getContainerIds();
+			expect(ids.length).toBe(2);
+
+			wrangler.pty.kill("SIGINT");
+			await new Promise<void>((resolve) => {
+				wrangler.pty.onExit(() => resolve());
+			});
+			vi.waitFor(() => {
+				const remainingIds = getContainerIds();
+				expect(remainingIds.length).toBe(0);
+			});
+		});
+	}
+);
+
 /** gets any containers that were created by running this fixture */
 const getContainerIds = () => {
 	// note the -a to include stopped containers