Add Docker tests for various non-default network configurations

Author: pimterry

src/dns-server.ts

@@ -61,7 +61,7 @@ class DnsServer extends dns2.UDPServer {
         const answers = this.getHostAddresses(question.name);
 
         if (answers.size > 1) {
-            console.log(`Multiple hosts in internal DNS for hostname ${question.name}: ${answers}`);
+            console.log(`Multiple hosts in internal DNS for hostname ${question.name}:`, answers);
         }
 
         if (answers) {

test/fixtures/docker/compose/Dockerfile

@@ -5,5 +5,4 @@ WORKDIR /usr/src/app
 
 COPY . .
 
-EXPOSE 8000
 CMD node /usr/src/app/index.js

test/fixtures/docker/compose/docker-compose.networks.yml

@@ -0,0 +1,50 @@
+version: '3.3'
+
+# This compose file tests every network configuration I can think of, starting the same HTTP
+# app and checking self, remote & neighbour connectivity & interception. This is in addition
+# to the non-network compose file in this folder, which tests default docker-compose networks.
+
+services:
+  host:
+    build: .
+    network_mode: 'host'
+
+  none:
+    build: .
+    network_mode: 'none'
+    environment:
+      SKIP_REQUESTS: 'true'
+
+  default-service-a:
+    build: .
+    network_mode: 'bridge' # Docker's default bridge network
+
+  default-linked-service-b:
+    build: .
+    network_mode: 'bridge' # Docker's default bridge network
+    environment:
+      EXTRA_TARGET: 'http://a:9876'
+    # Links are deprecated, but should still work:
+    links:
+      - "default-service-a:a"
+
+  multi-network-a:
+    build: .
+    networks:
+      - custom_net_1
+      - custom_net_2
+    environment:
+      EXTRA_TARGET: 'http://host.docker.internal:9876' # The host container
+
+  multi-network-b:
+    build: .
+    networks:
+      - custom_net_2
+      - custom_net_3
+    environment:
+      EXTRA_TARGET: 'http://multi-network-a:9876' # Container on some shared networks
+
+networks:
+  custom_net_1:
+  custom_net_2:
+  custom_net_3:

test/fixtures/docker/compose/docker-compose.yml

@@ -4,8 +4,8 @@ services:
   service-a:
     build: .
     environment:
-      - TARGET=service-b
+      - EXTRA_TARGET=http://service-b:9876
   service-b:
     build: .
     environment:
-      - TARGET=service-a
+      - EXTRA_TARGET=http://service-a:9876

test/fixtures/docker/compose/index.js

@@ -1,10 +1,17 @@
 const http = require('http');
 const https = require('https');
 
-const makeRequest = async (method, url) => {
+// The 'none' network container can just shutdown immediately - we only want
+// to check it starts OK, but we'll clearly never be able to proxy anything.
+if (process.env.SKIP_REQUESTS) {
+    console.log('Skipping');
+    process.exit(0);
+}
+
+const makeRequest = async (url) => {
     const sendRequest = url.startsWith('https') ? https.request : http.request;
 
-    const request = sendRequest(url, { method });
+    const request = sendRequest(url);
     request.end();
 
     return new Promise((resolve, reject) => {
@@ -13,46 +20,74 @@ const makeRequest = async (method, url) => {
     });
 };
 
-const SERVER_PORT = 8000;
+const getBody = (response) => new Promise((resolve, reject) => {
+    let body = "";
+    response.on('data', (d) => {
+        body = body + d;
+    });
+    response.on('end', () => resolve(body));
+    response.on('error', reject);
+});
+
+const SERVER_PORT = 9876;
+const OUR_HOSTNAME = process.env.HOSTNAME;
 
-const DOCKER_TARGET_URL = `http://${process.env.TARGET}:${SERVER_PORT}/`;
-const SELF_LOCALHOST_TARGET_URL = `http://localhost:${SERVER_PORT}/`;
-const SELF_HOSTNAME_TARGET_URL = `http://${process.env.HOSTNAME}:${SERVER_PORT}/`;
-const EXTERNAL_TARGET_URL = `https://example.test/`; // Never normally reachable
+const isOurHostname = (v) => v === OUR_HOSTNAME;
+const isNotOurHostname = (v) => v !== OUR_HOSTNAME;
+const is = (x) => (v) => v === x;
+
+const TARGETS = [
+    // Can we remotely resolve our own loopback address?
+    [`http://localhost:${SERVER_PORT}/`, isOurHostname],
+    [`http://127.0.0.1:${SERVER_PORT}/`, isOurHostname],
+    // We can remote resolve our Docker hostname?
+    [`http://${OUR_HOSTNAME}:${SERVER_PORT}/`, isOurHostname],
+    // Can we resolve a mocked-only URL? (This will always fail normally)
+    [`https://example.test/`, is('Mock response')],
+];
+
+if (process.env.EXTRA_TARGET) {
+    TARGETS.push([process.env.EXTRA_TARGET, isNotOurHostname]);
+}
 
 const server = http.createServer((req, res) => {
-    res.writeHead(200).end();
+    res.writeHead(200).end(OUR_HOSTNAME);
 });
 
 server.listen(SERVER_PORT, () => {
     console.log('Server started');
 });
 
 const pollInterval = setInterval(async () => {
-    console.log("Sending requests to ",
-        DOCKER_TARGET_URL,
-        SELF_LOCALHOST_TARGET_URL,
-        SELF_HOSTNAME_TARGET_URL,
-        EXTERNAL_TARGET_URL
-    );
-    const responses = await Promise.all([
-        makeRequest("POST", DOCKER_TARGET_URL).catch(e => e), // Will return 200
-        makeRequest("POST", SELF_LOCALHOST_TARGET_URL).catch(e => e), // Will return 200
-        makeRequest("POST", SELF_HOSTNAME_TARGET_URL).catch(e => e), // Will return 200
-        makeRequest("GET", EXTERNAL_TARGET_URL).catch(e => e) // Will not resolve
-    ]);
+    console.log("Sending requests to ", TARGETS);
+
+    const responses = await Promise.all(TARGETS.map(([target]) =>
+        makeRequest(target).catch(e => e)
+    ));
 
     // ^ This will always fail normally, because the external request fails. Will only pass if it's
     // intercepted such that both external & all internal requests are successful at the same time.
 
-    if (responses.every(r => !(r instanceof Error) && r.statusCode === 200)) {
+    if (responses.every((response) =>
+        !(response instanceof Error) &&
+        response.statusCode === 200
+    )) {
+        // Check the bodies, fail hard if any have the wrong content (i.e. went to the wrong host)
+        const responseBodies = await Promise.all(responses.map(r => getBody(r)));
+        responseBodies.forEach((body, i) => {
+            const validateBody = TARGETS[i][1];
+            if (!validateBody(body)) throw new Error(
+                `Request ${i} to ${TARGETS[i][0]} unexpectedly returned ${body}`
+            );
+        });
+
         console.log("All requests ok");
         clearInterval(pollInterval);
 
         // Exit OK, but after a delay, so the other container can still make requests to us.
         setTimeout(() => {
             process.exit(0);
-        }, 500);
+        }, 1000);
     } else {
         console.log("Requests failed with", responses.map(r => r.message || r.statusCode));
     }

test/interceptors/docker-terminal-interception.spec.ts

@@ -184,12 +184,20 @@ Successfully built <hash>
         this.timeout(30000);
 
         const { server, httpsConfig, getPassThroughOptions } = await testSetup;
-        const externalRule = await server.get("https://example.test").thenReply(200, "Mock response");
-        const internalRule = await server.post().thenPassThrough(await getPassThroughOptions());
+        const externalRule = await server.anyRequest()
+            .forHost("example.test")
+            .thenReply(200, "Mock response");
+        const internalRule = await server
+            .unmatchedRequest()
+            .thenPassThrough(await getPassThroughOptions());
 
         // Create non-intercepted docker-compose containers, like normal use:
         const composeRoot = path.join(__dirname, '..', 'fixtures', 'docker', 'compose');
-        await spawnToResult('docker-compose', ['create', '--force-recreate', '--build'], { cwd: composeRoot }, true);
+        await spawnToResult(
+            'docker-compose', ['create', '--force-recreate', '--build'],
+            { cwd: composeRoot },
+            true
+        );
 
         const terminalEnvOverrides = getTerminalEnvVars(server.port, httpsConfig, process.env, {}, {
             dockerEnabled: true
@@ -214,9 +222,62 @@ Successfully built <hash>
 
         const seenInternalRequests = await internalRule.getSeenRequests();
         const seenInternalUrls = seenInternalRequests.map(r => r.url);
-        expect(seenInternalUrls).to.include("http://service-a:8000/");
-        expect(seenInternalUrls).to.include("http://service-b:8000/");
-        expect(seenInternalUrls).to.include("http://localhost:8000/");
+        expect(seenInternalUrls).to.include("http://service-a:9876/");
+        expect(seenInternalUrls).to.include("http://service-b:9876/");
+        expect(seenInternalUrls).to.include("http://localhost:9876/");
+        expect(seenInternalUrls).to.include("http://127.0.0.1:9876/");
+    });
+
+    it("should intercept all network modes", async function () {
+        this.timeout(30000);
+
+        const { server, httpsConfig, getPassThroughOptions } = await testSetup;
+        const externalRule = await server.anyRequest()
+            .forHost("example.test")
+            .thenReply(200, "Mock response");
+        const internalRule = await server
+            .unmatchedRequest()
+            .thenPassThrough(await getPassThroughOptions());
+
+        // Create non-intercepted docker-compose containers, like normal use:
+        const composeRoot = path.join(__dirname, '..', 'fixtures', 'docker', 'compose');
+        await spawnToResult(
+            'docker-compose', ['-f', 'docker-compose.networks.yml', 'create', '--force-recreate', '--build'],
+            { cwd: composeRoot },
+            true
+        );
+
+        const terminalEnvOverrides = getTerminalEnvVars(server.port, httpsConfig, process.env, {}, {
+            dockerEnabled: true
+        });
+
+        // "DC Up" the same project, but in an intercepted env. Should ignore the existing containers,
+        // create new intercepted containers, and then up those as normal.
+        const { exitCode, stdout } = await spawnToResult(
+            'docker-compose', ['-f', 'docker-compose.networks.yml', 'up'],
+            {
+                env: { ...process.env, ...terminalEnvOverrides },
+                cwd: composeRoot
+            },
+            true
+        );
+
+        expect(exitCode).to.equal(0);
+
+        const dcOutput = stdout
+            .replace(/\u001b\[\d+m/g, '') // Strip terminal colour commands
+            .replace(/\s+\|/g, ' |'); // Strip container name variable whitespace
+
+        [
+            `compose_host_1_HTK${server.port}`,
+            `compose_default-service-a_1_HTK${server.port}`,
+            `compose_default-linked-service-b_1_HTK${server.port}`,
+            `compose_multi-network-a_1_HTK${server.port}`,
+            `compose_multi-network-b_1_HTK${server.port}`
+        ].forEach((container) => {
+            expect(dcOutput).to.include(`${container} | All requests ok`);
+        });
+        expect(dcOutput).to.include(`compose_none_1_HTK${server.port} | Skipping`);
     });
 
     it("should clean up containers after shutdown", async () => {