@zuplo/cli 6.52.4 → 6.52.6

package/dist/__tests__/integration/test-utils.js

@@ -0,0 +1,82 @@
+import nock from "nock";
+import settings from "../../common/settings.js";
+export const TEST_AUTH_TOKEN = "test-auth-token-123";
+export const TEST_ACCOUNT_NAME = "test-account";
+export const TEST_PROJECT_NAME = "test-project";
+export const TEST_BRANCH_NAME = "main";
+export const TEST_DEPLOYMENT_NAME = "test-deployment";
+export const TEST_API_BASE = settings.ZUPLO_DEVELOPER_API_ENDPOINT;
+export function setupAuthenticatedNock(scope) {
+    return scope.matchHeader("authorization", `Bearer ${TEST_AUTH_TOKEN}`);
+}
+export function setupTestEnvironment() {
+    process.env.ZUPLO_DEVELOPER_API_ENDPOINT =
+        settings.ZUPLO_DEVELOPER_API_ENDPOINT;
+    process.env.ZUPLO_API_KEY = TEST_AUTH_TOKEN;
+    setupAuthenticatedNock(nock(TEST_API_BASE))
+        .get("/v1/who-am-i")
+        .reply(200, { user: "test-user@example.com" })
+        .persist();
+}
+export function cleanupTest() {
+    nock.cleanAll();
+    delete process.env.ZUPLO_DEVELOPER_API_ENDPOINT;
+    delete process.env.ZUPLO_API_KEY;
+}
+export class RequestCapture {
+    requests = [];
+    capture(req, _interceptor, body) {
+        const captured = {
+            method: req.method || "GET",
+            path: req.path || "",
+            headers: this.normalizeHeaders(req.headers || {}),
+        };
+        if (body) {
+            if (typeof body === "string") {
+                try {
+                    captured.body = JSON.parse(body);
+                }
+                catch {
+                    captured.body = "[FormData or non-JSON body]";
+                }
+            }
+            else {
+                captured.body = body;
+            }
+        }
+        this.requests.push(captured);
+    }
+    getRequests() {
+        return [...this.requests];
+    }
+    clear() {
+        this.requests = [];
+    }
+    normalizeHeaders(headers) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(headers)) {
+            const normalizedKey = key.toLowerCase();
+            if (normalizedKey === "authorization") {
+                normalized[normalizedKey] = "[REDACTED]";
+            }
+            else if (normalizedKey === "user-agent") {
+                normalized[normalizedKey] = "[USER_AGENT]";
+            }
+            else if (normalizedKey === "content-length") {
+                normalized[normalizedKey] = "[CONTENT_LENGTH]";
+            }
+            else if (normalizedKey === "host") {
+                normalized[normalizedKey] = "[HOST]";
+            }
+            else if (normalizedKey === "content-type" &&
+                String(value).startsWith("multipart/form-data")) {
+                normalized[normalizedKey] = "multipart/form-data; boundary=[BOUNDARY]";
+            }
+            else {
+                normalized[normalizedKey] = String(value);
+            }
+        }
+        return normalized;
+    }
+}
+//# sourceMappingURL=test-utils.js.map

package/dist/__tests__/integration/test-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.js","sourceRoot":"","sources":["../../../src/__tests__/integration/test-utils.ts"],"names":[],"mappings":"AAGA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,QAAQ,MAAM,0BAA0B,CAAC;AAGhD,MAAM,CAAC,MAAM,eAAe,GAAG,qBAAqB,CAAC;AACrD,MAAM,CAAC,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAChD,MAAM,CAAC,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAChD,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC;AACvC,MAAM,CAAC,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAGtD,MAAM,CAAC,MAAM,aAAa,GAAG,QAAQ,CAAC,4BAA4B,CAAC;AAKnE,MAAM,UAAU,sBAAsB,CAAC,KAAiB;IACtD,OAAO,KAAK,CAAC,WAAW,CAAC,eAAe,EAAE,UAAU,eAAe,EAAE,CAAC,CAAC;AACzE,CAAC;AAKD,MAAM,UAAU,oBAAoB;IAElC,OAAO,CAAC,GAAG,CAAC,4BAA4B;QACtC,QAAQ,CAAC,4BAA4B,CAAC;IAExC,OAAO,CAAC,GAAG,CAAC,aAAa,GAAG,eAAe,CAAC;IAG5C,sBAAsB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SACxC,GAAG,CAAC,cAAc,CAAC;SACnB,KAAK,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,uBAAuB,EAAE,CAAC;SAC7C,OAAO,EAAE,CAAC;AACf,CAAC;AAKD,MAAM,UAAU,WAAW;IACzB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAEhB,OAAO,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC;IAEhD,OAAO,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC;AACnC,CAAC;AAkBD,MAAM,OAAO,cAAc;IACjB,QAAQ,GAAsB,EAAE,CAAC;IAEzC,OAAO,CAAC,GAAgB,EAAE,YAAsB,EAAE,IAAc;QAC9D,MAAM,QAAQ,GAAoB;YAChC,MAAM,EAAE,GAAG,CAAC,MAAM,IAAI,KAAK;YAC3B,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE;YACpB,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC;SAClD,CAAC;QAEF,IAAI,IAAI,EAAE,CAAC;YACT,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC7B,IAAI,CAAC;oBACH,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBACnC,CAAC;gBAAC,MAAM,CAAC;oBAEP,QAAQ,CAAC,IAAI,GAAG,6BAA6B,CAAC;gBAChD,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAC;YACvB,CAAC;QACH,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC/B,CAAC;IAED,WAAW;QACT,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAEO,gBAAgB,CACtB,OAAgC;QAEhC,MAAM,UAAU,GAA2B,EAAE,CAAC;QAE9C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAEnD,MAAM,aAAa,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC;YAExC,IAAI,aAAa,KAAK,eAAe,EAAE,CAAC;gBACtC,UAAU,CAAC,aAAa,CAAC,GAAG,YAAY,CAAC;YAC3C,CAAC;iBAAM,IAAI,aAAa,KAAK,YAAY,EAAE,CAAC;gBAC1C,UAAU,CAAC,aAAa,CAAC,GAAG,cAAc,CAAC;YAC7C,CAAC;iBAAM,IAAI,aAAa,KAAK,gBAAgB,EAAE,CAAC;gBAC9C,UAAU,CAAC,aAAa,CAAC,GAAG,kBAAkB,CAAC;YACjD,CAAC;iBAAM,IAAI,aAAa,KAAK,MAAM,EAAE,CAAC;gBACpC,UAAU,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC;YACvC,CAAC;iBAAM,IACL,aAAa,KAAK,cAAc;gBAChC,MAAM,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,qBAAqB,CAAC,EAC/C,CAAC;gBACD,UAAU,CAAC,aAAa,CAAC,GAAG,0CAA0C,CAAC;YACzE,CAAC;iBAAM,CAAC;gBACN,UAAU,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;CACF","sourcesContent":["/**\n * Test utilities for CLI integration tests with nock interceptors\n */\nimport nock from \"nock\";\nimport settings from \"../../common/settings.js\";\n\n// Constants for testing\nexport const TEST_AUTH_TOKEN = \"test-auth-token-123\";\nexport const TEST_ACCOUNT_NAME = \"test-account\";\nexport const TEST_PROJECT_NAME = \"test-project\";\nexport const TEST_BRANCH_NAME = \"main\";\nexport const TEST_DEPLOYMENT_NAME = \"test-deployment\";\n\n// Base API endpoint for tests\nexport const TEST_API_BASE = settings.ZUPLO_DEVELOPER_API_ENDPOINT;\n\n/**\n * Common nock setup for authenticated requests\n */\nexport function setupAuthenticatedNock(scope: nock.Scope): nock.Scope {\n  return scope.matchHeader(\"authorization\", `Bearer ${TEST_AUTH_TOKEN}`);\n}\n\n/**\n * Setup common environment variables for tests\n */\nexport function setupTestEnvironment() {\n  // eslint-disable-next-line node/no-process-env\n  process.env.ZUPLO_DEVELOPER_API_ENDPOINT =\n    settings.ZUPLO_DEVELOPER_API_ENDPOINT;\n  // eslint-disable-next-line node/no-process-env\n  process.env.ZUPLO_API_KEY = TEST_AUTH_TOKEN;\n\n  // Add a catch-all for any authentication validation calls\n  setupAuthenticatedNock(nock(TEST_API_BASE))\n    .get(\"/v1/who-am-i\")\n    .reply(200, { user: \"test-user@example.com\" })\n    .persist();\n}\n\n/**\n * Clean up environment and nock after tests\n */\nexport function cleanupTest() {\n  nock.cleanAll();\n  // eslint-disable-next-line node/no-process-env\n  delete process.env.ZUPLO_DEVELOPER_API_ENDPOINT;\n  // eslint-disable-next-line node/no-process-env\n  delete process.env.ZUPLO_API_KEY;\n}\n\n/**\n * Helper to capture and normalize nock requests for snapshots\n */\nexport interface CapturedRequest {\n  method: string;\n  path: string;\n  headers: Record<string, string>;\n  body?: unknown;\n}\n\ninterface NockRequest {\n  method?: string;\n  path?: string;\n  headers?: Record<string, unknown>;\n}\n\nexport class RequestCapture {\n  private requests: CapturedRequest[] = [];\n\n  capture(req: NockRequest, _interceptor?: unknown, body?: unknown): void {\n    const captured: CapturedRequest = {\n      method: req.method || \"GET\",\n      path: req.path || \"\",\n      headers: this.normalizeHeaders(req.headers || {}),\n    };\n\n    if (body) {\n      if (typeof body === \"string\") {\n        try {\n          captured.body = JSON.parse(body);\n        } catch {\n          // If JSON parsing fails, store as string (e.g., FormData)\n          captured.body = \"[FormData or non-JSON body]\";\n        }\n      } else {\n        captured.body = body;\n      }\n    }\n\n    this.requests.push(captured);\n  }\n\n  getRequests(): CapturedRequest[] {\n    return [...this.requests];\n  }\n\n  clear(): void {\n    this.requests = [];\n  }\n\n  private normalizeHeaders(\n    headers: Record<string, unknown>\n  ): Record<string, string> {\n    const normalized: Record<string, string> = {};\n\n    for (const [key, value] of Object.entries(headers)) {\n      // Normalize header names to lowercase and exclude dynamic values\n      const normalizedKey = key.toLowerCase();\n\n      if (normalizedKey === \"authorization\") {\n        normalized[normalizedKey] = \"[REDACTED]\";\n      } else if (normalizedKey === \"user-agent\") {\n        normalized[normalizedKey] = \"[USER_AGENT]\";\n      } else if (normalizedKey === \"content-length\") {\n        normalized[normalizedKey] = \"[CONTENT_LENGTH]\";\n      } else if (normalizedKey === \"host\") {\n        normalized[normalizedKey] = \"[HOST]\";\n      } else if (\n        normalizedKey === \"content-type\" &&\n        String(value).startsWith(\"multipart/form-data\")\n      ) {\n        normalized[normalizedKey] = \"multipart/form-data; boundary=[BOUNDARY]\";\n      } else {\n        normalized[normalizedKey] = String(value);\n      }\n    }\n\n    return normalized;\n  }\n}\n"]}

package/dist/__tests__/integration/tunnel.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tunnel.integration.test.d.ts.map

package/dist/__tests__/integration/tunnel.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel.integration.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/integration/tunnel.integration.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/integration/tunnel.integration.test.js

@@ -0,0 +1,477 @@
+import nock from "nock";
+import yargs from "yargs/yargs";
+import tunnelCommand from "../../cmds/tunnel/index.js";
+import { setupTestEnvironment, cleanupTest, setupAuthenticatedNock, RequestCapture, TEST_API_BASE, TEST_ACCOUNT_NAME, TEST_AUTH_TOKEN, } from "./test-utils.js";
+async function executeTunnelCommand(subcommand, args) {
+    const yargsInstance = yargs([])
+        .command(tunnelCommand)
+        .help(false)
+        .version(false)
+        .exitProcess(false);
+    const commandArgs = ["tunnel", subcommand];
+    if (args.account) {
+        commandArgs.push("--account", args.account);
+    }
+    if (args["api-key"]) {
+        commandArgs.push("--api-key", args["api-key"]);
+    }
+    if (args["tunnel-name"]) {
+        commandArgs.push("--tunnel-name", args["tunnel-name"]);
+    }
+    if (args["tunnel-id"]) {
+        commandArgs.push("--tunnel-id", args["tunnel-id"]);
+    }
+    return await yargsInstance.parse(commandArgs);
+}
+async function executeTunnelServicesCommand(subcommand, args) {
+    const yargsInstance = yargs([])
+        .command(tunnelCommand)
+        .help(false)
+        .version(false)
+        .exitProcess(false);
+    const commandArgs = ["tunnel", "services", subcommand];
+    if (args.account) {
+        commandArgs.push("--account", args.account);
+    }
+    if (args["api-key"]) {
+        commandArgs.push("--api-key", args["api-key"]);
+    }
+    if (args["tunnel-id"]) {
+        commandArgs.push("--tunnel-id", args["tunnel-id"]);
+    }
+    if (args["configuration-file"]) {
+        commandArgs.push("--configuration-file", args["configuration-file"]);
+    }
+    return await yargsInstance.parse(commandArgs);
+}
+const mockPrintResult = jest.mocked(require("../../common/output.js").printResultToConsoleAndExitGracefully);
+const mockPrintTable = jest.mocked(require("../../common/output.js").printTableToConsoleAndExitGracefully);
+const mockPrintDiagnostics = jest.mocked(require("../../common/output.js").printDiagnosticsToConsole);
+describe("Tunnel Command Integration Tests", () => {
+    let requestCapture;
+    beforeEach(() => {
+        setupTestEnvironment();
+        requestCapture = new RequestCapture();
+        nock.disableNetConnect();
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        cleanupTest();
+        requestCapture.clear();
+    });
+    describe("Tunnel Create Command", () => {
+        it("should intercept POST request to create tunnel", async () => {
+            const testTunnelName = "my-test-tunnel";
+            const mockResponse = {
+                id: "tunnel-123",
+                name: testTunnelName,
+                token: "tunnel-token-abc123",
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .post(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
+                .reply(201, mockResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("create", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-name": testTunnelName,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintTable).toHaveBeenCalledWith(mockResponse);
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-create-requests");
+            const request = capturedRequests[0];
+            expect(request.method).toBe("POST");
+            expect(request.body).toEqual({
+                name: testTunnelName,
+            });
+        });
+        it("should handle tunnel creation error", async () => {
+            const testTunnelName = "invalid-tunnel";
+            const errorResponse = {
+                error: "Bad Request",
+                message: "Tunnel name already exists",
+                statusCode: 400,
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .post(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
+                .reply(400, errorResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("create", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-name": testTunnelName,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintDiagnostics).toHaveBeenCalled();
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-create-error-requests");
+        });
+    });
+    describe("Tunnel List Command", () => {
+        it("should intercept GET request to list tunnels", async () => {
+            const mockResponse = {
+                data: [
+                    { id: "tunnel-123", name: "tunnel-1" },
+                    { id: "tunnel-456", name: "tunnel-2" },
+                ],
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
+                .reply(200, mockResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("list", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+            });
+            expect(scope.isDone()).toBe(true);
+            const expectedTable = [
+                { "tunnel-id": "tunnel-123", name: "tunnel-1" },
+                { "tunnel-id": "tunnel-456", name: "tunnel-2" },
+            ];
+            expect(mockPrintTable).toHaveBeenCalledWith(expectedTable);
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-list-requests");
+        });
+        it("should handle empty tunnels list", async () => {
+            const mockResponse = { data: [] };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
+                .reply(200, mockResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("list", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintResult).toHaveBeenCalledWith("No tunnels found");
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-list-empty-requests");
+        });
+        it("should handle API error responses", async () => {
+            const errorResponse = {
+                error: "Forbidden",
+                message: "Access denied",
+                statusCode: 403,
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
+                .reply(403, errorResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("list", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintDiagnostics).toHaveBeenCalled();
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-list-error-requests");
+        });
+    });
+    describe("Tunnel Delete Command", () => {
+        it("should intercept DELETE request to delete tunnel", async () => {
+            const tunnelId = "test-tunnel-123";
+            const mockTeardownResponse = {
+                id: "teardown-op-456",
+                status: "in-progress",
+            };
+            const mockCompletedTeardown = {
+                id: "teardown-op-456",
+                status: "success",
+                message: "Tunnel deleted successfully",
+            };
+            const deleteScope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .delete(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}`)
+                .reply(200, mockTeardownResponse);
+            const pollScope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/teardown-operations/teardown-op-456`)
+                .reply(200, mockCompletedTeardown);
+            deleteScope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            pollScope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("delete", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-id": tunnelId,
+            });
+            expect(deleteScope.isDone()).toBe(true);
+            expect(pollScope.isDone()).toBe(true);
+            expect(mockPrintResult).toHaveBeenCalledWith("Tunnel test-tunnel-123 deleted successfully.");
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-delete-requests");
+        });
+        it("should handle tunnel deletion error", async () => {
+            const tunnelId = "nonexistent-tunnel";
+            const errorResponse = {
+                error: "Not Found",
+                message: "Tunnel not found",
+                statusCode: 404,
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .delete(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}`)
+                .reply(404, errorResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("delete", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-id": tunnelId,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintDiagnostics).toHaveBeenCalled();
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-delete-error-requests");
+        });
+    });
+    describe("Tunnel Describe Command", () => {
+        it("should intercept GET request to describe tunnel", async () => {
+            const tunnelId = "test-tunnel-123";
+            const mockTunnelDetails = {
+                id: tunnelId,
+                name: "Test Tunnel",
+                status: "active",
+                endpoint: "https://test-tunnel.zuplo.dev",
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}`)
+                .reply(200, mockTunnelDetails);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("describe", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-id": tunnelId,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintTable).toHaveBeenCalledWith(mockTunnelDetails);
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-describe-requests");
+        });
+        it("should handle tunnel describe error", async () => {
+            const tunnelId = "nonexistent-tunnel";
+            const errorResponse = {
+                error: "Not Found",
+                message: "Tunnel not found",
+                statusCode: 404,
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}`)
+                .reply(404, errorResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("describe", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-id": tunnelId,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintDiagnostics).toHaveBeenCalled();
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-describe-error-requests");
+        });
+    });
+    describe("Tunnel Rotate Token Command", () => {
+        it("should intercept POST request to rotate tunnel token", async () => {
+            const tunnelId = "test-tunnel-123";
+            const mockTokenResponse = {
+                tunnelId: tunnelId,
+                newToken: "new-token-abc123",
+                message: "Token rotated successfully",
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .post(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/$rotate-token`)
+                .reply(200, mockTokenResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("rotate-token", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-id": tunnelId,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintTable).toHaveBeenCalledWith(mockTokenResponse);
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-rotate-token-requests");
+        });
+        it("should handle token rotation error", async () => {
+            const tunnelId = "nonexistent-tunnel";
+            const errorResponse = {
+                error: "Forbidden",
+                message: "Access denied",
+                statusCode: 403,
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .post(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/$rotate-token`)
+                .reply(403, errorResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("rotate-token", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-id": tunnelId,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintDiagnostics).toHaveBeenCalled();
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-rotate-token-error-requests");
+        });
+    });
+    describe("Tunnel Services Describe Command", () => {
+        it("should intercept GET request to describe tunnel services", async () => {
+            const tunnelId = "test-tunnel-123";
+            const mockServicesResponse = {
+                tunnelId: tunnelId,
+                services: [
+                    { name: "api-service", port: 3000, status: "running" },
+                    { name: "web-service", port: 8080, status: "running" },
+                ],
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/services-configuration`)
+                .reply(200, mockServicesResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelServicesCommand("describe", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-id": tunnelId,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintResult).toHaveBeenCalledWith(JSON.stringify(mockServicesResponse, null, 2));
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-services-describe-requests");
+        });
+        it("should handle services describe error", async () => {
+            const tunnelId = "nonexistent-tunnel";
+            const errorResponse = {
+                error: "Not Found",
+                message: "Tunnel not found",
+                statusCode: 404,
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/services-configuration`)
+                .reply(404, errorResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelServicesCommand("describe", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-id": tunnelId,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintDiagnostics).toHaveBeenCalled();
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-services-describe-error-requests");
+        });
+    });
+    describe("Tunnel Services Update Command", () => {
+        it("should handle services update error due to file read failure", async () => {
+            const tunnelId = "test-tunnel-123";
+            const configFile = "/nonexistent/config.json";
+            await expect(executeTunnelServicesCommand("update", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-id": tunnelId,
+                "configuration-file": configFile,
+            })).rejects.toThrow("Process would exit");
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-services-update-file-error-requests");
+        });
+        it("should handle services update API error", async () => {
+            const tunnelId = "test-tunnel-123";
+            const tempConfigFile = "/tmp/test-config.json";
+            const mockFs = require("node:fs/promises");
+            const originalReadFile = mockFs.readFile;
+            mockFs.readFile = jest.fn().mockResolvedValue('{"services": []}');
+            const errorResponse = {
+                error: "Bad Request",
+                message: "Invalid configuration file",
+                statusCode: 400,
+            };
+            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
+                .put(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/services-configuration`)
+                .reply(400, errorResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelServicesCommand("update", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-id": tunnelId,
+                "configuration-file": tempConfigFile,
+            });
+            expect(scope.isDone()).toBe(true);
+            expect(mockPrintDiagnostics).toHaveBeenCalled();
+            mockFs.readFile = originalReadFile;
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-services-update-error-requests");
+        });
+    });
+    describe("Request validation", () => {
+        it("should include correct headers for create request", async () => {
+            const testTunnelName = "test-tunnel";
+            const mockResponse = {
+                id: "tunnel-123",
+                name: testTunnelName,
+                token: "tunnel-token-abc123",
+            };
+            const scope = nock(TEST_API_BASE)
+                .post(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
+                .matchHeader("authorization", `Bearer ${TEST_AUTH_TOKEN}`)
+                .matchHeader("content-type", "application/json")
+                .reply(201, mockResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("create", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+                "tunnel-name": testTunnelName,
+            });
+            expect(scope.isDone()).toBe(true);
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-create-headers-validation");
+        });
+        it("should include correct headers for list request", async () => {
+            const mockResponse = { data: [{ id: "tunnel-123", name: "tunnel-1" }] };
+            const scope = nock(TEST_API_BASE)
+                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
+                .matchHeader("authorization", `Bearer ${TEST_AUTH_TOKEN}`)
+                .reply(200, mockResponse);
+            scope.on("request", (req, interceptor, body) => {
+                requestCapture.capture(req, interceptor, body);
+            });
+            await executeTunnelCommand("list", {
+                account: TEST_ACCOUNT_NAME,
+                "api-key": TEST_AUTH_TOKEN,
+            });
+            expect(scope.isDone()).toBe(true);
+            const capturedRequests = requestCapture.getRequests();
+            expect(capturedRequests).toMatchSnapshot("tunnel-list-headers-validation");
+            const request = capturedRequests[0];
+            expect(request.method).toBe("GET");
+            expect(request.body).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=tunnel.integration.test.js.map