@axiom-lattice/microsandbox-service 0.0.1

package/dist/server.mjs

@@ -0,0 +1,82 @@
+import {
+  __require,
+  buildApp
+} from "./chunk-2W4CTYPX.mjs";
+
+// src/lib/server-cli.ts
+function parsePort(raw, source) {
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`Invalid value for ${source}: ${raw}`);
+  }
+  return value;
+}
+function parseServerArgs(argv) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--port") {
+      const raw = argv[index + 1];
+      if (!raw) {
+        throw new Error("Missing value for --port");
+      }
+      parsed.port = parsePort(raw, "--port");
+      index += 1;
+      continue;
+    }
+    if (token === "--host") {
+      const raw = argv[index + 1];
+      if (!raw) {
+        throw new Error("Missing value for --host");
+      }
+      parsed.host = raw;
+      index += 1;
+    }
+  }
+  return parsed;
+}
+function resolveServerConfig({
+  args,
+  env
+}) {
+  return {
+    host: args.host ?? env.HOST ?? "0.0.0.0",
+    port: args.port ?? (env.PORT ? parsePort(env.PORT, "PORT") : 4002)
+  };
+}
+
+// src/server.ts
+async function startServer({
+  argv = process.argv.slice(2),
+  env = process.env,
+  app = buildApp()
+} = {}) {
+  const config = resolveServerConfig({ args: parseServerArgs(argv), env });
+  const shutdown = async (code) => {
+    try {
+      await app.close();
+      process.exit(code);
+    } catch (error) {
+      console.error("Failed to shutdown microsandbox-service cleanly", error);
+      process.exit(1);
+    }
+  };
+  process.once("SIGINT", () => {
+    void shutdown(0);
+  });
+  process.once("SIGTERM", () => {
+    void shutdown(0);
+  });
+  await app.listen({ port: config.port, host: config.host });
+  return app;
+}
+if (__require.main === module) {
+  void startServer().catch((error) => {
+    console.error("Failed to start microsandbox-service", error);
+    process.exit(1);
+  });
+}
+export {
+  startServer
+};
+//# sourceMappingURL=server.mjs.map

package/dist/server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/server-cli.ts","../src/server.ts"],"sourcesContent":["export interface ParsedServerArgs {\n  host?: string;\n  port?: number;\n}\n\nexport interface ResolvedServerConfig {\n  host: string;\n  port: number;\n}\n\nfunction parsePort(raw: string, source: string): number {\n  const value = Number(raw);\n  if (!Number.isInteger(value) || value <= 0) {\n    throw new Error(`Invalid value for ${source}: ${raw}`);\n  }\n  return value;\n}\n\nexport function parseServerArgs(argv: string[]): ParsedServerArgs {\n  const parsed: ParsedServerArgs = {};\n\n  for (let index = 0; index < argv.length; index += 1) {\n    const token = argv[index];\n\n    if (token === \"--port\") {\n      const raw = argv[index + 1];\n      if (!raw) {\n        throw new Error(\"Missing value for --port\");\n      }\n      parsed.port = parsePort(raw, \"--port\");\n      index += 1;\n      continue;\n    }\n\n    if (token === \"--host\") {\n      const raw = argv[index + 1];\n      if (!raw) {\n        throw new Error(\"Missing value for --host\");\n      }\n      parsed.host = raw;\n      index += 1;\n    }\n  }\n\n  return parsed;\n}\n\nexport function resolveServerConfig({\n  args,\n  env,\n}: {\n  args: ParsedServerArgs;\n  env: NodeJS.ProcessEnv;\n}): ResolvedServerConfig {\n  return {\n    host: args.host ?? env.HOST ?? \"0.0.0.0\",\n    port: args.port ?? (env.PORT ? parsePort(env.PORT, \"PORT\") : 4002),\n  };\n}\n","import type { FastifyInstance } from \"fastify\";\nimport { buildApp } from \"./app\";\nimport { parseServerArgs, resolveServerConfig } from \"./lib/server-cli\";\n\nexport async function startServer({\n  argv = process.argv.slice(2),\n  env = process.env,\n  app = buildApp(),\n}: {\n  argv?: string[];\n  env?: NodeJS.ProcessEnv;\n  app?: Pick<FastifyInstance, \"listen\" | \"close\">;\n} = {}): Promise<Pick<FastifyInstance, \"listen\" | \"close\">> {\n  const config = resolveServerConfig({ args: parseServerArgs(argv), env });\n\n  const shutdown = async (code: number): Promise<void> => {\n    try {\n      await app.close();\n      process.exit(code);\n    } catch (error) {\n      console.error(\"Failed to shutdown microsandbox-service cleanly\", error);\n      process.exit(1);\n    }\n  };\n\n  process.once(\"SIGINT\", () => {\n    void shutdown(0);\n  });\n\n  process.once(\"SIGTERM\", () => {\n    void shutdown(0);\n  });\n\n  await app.listen({ port: config.port, host: config.host });\n  return app;\n}\n\nif (require.main === module) {\n  void startServer().catch((error) => {\n    console.error(\"Failed to start microsandbox-service\", error);\n    process.exit(1);\n  });\n}\n"],"mappings":";;;;;;AAUA,SAAS,UAAU,KAAa,QAAwB;AACtD,QAAM,QAAQ,OAAO,GAAG;AACxB,MAAI,CAAC,OAAO,UAAU,KAAK,KAAK,SAAS,GAAG;AAC1C,UAAM,IAAI,MAAM,qBAAqB,MAAM,KAAK,GAAG,EAAE;AAAA,EACvD;AACA,SAAO;AACT;AAEO,SAAS,gBAAgB,MAAkC;AAChE,QAAM,SAA2B,CAAC;AAElC,WAAS,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG;AACnD,UAAM,QAAQ,KAAK,KAAK;AAExB,QAAI,UAAU,UAAU;AACtB,YAAM,MAAM,KAAK,QAAQ,CAAC;AAC1B,UAAI,CAAC,KAAK;AACR,cAAM,IAAI,MAAM,0BAA0B;AAAA,MAC5C;AACA,aAAO,OAAO,UAAU,KAAK,QAAQ;AACrC,eAAS;AACT;AAAA,IACF;AAEA,QAAI,UAAU,UAAU;AACtB,YAAM,MAAM,KAAK,QAAQ,CAAC;AAC1B,UAAI,CAAC,KAAK;AACR,cAAM,IAAI,MAAM,0BAA0B;AAAA,MAC5C;AACA,aAAO,OAAO;AACd,eAAS;AAAA,IACX;AAAA,EACF;AAEA,SAAO;AACT;AAEO,SAAS,oBAAoB;AAAA,EAClC;AAAA,EACA;AACF,GAGyB;AACvB,SAAO;AAAA,IACL,MAAM,KAAK,QAAQ,IAAI,QAAQ;AAAA,IAC/B,MAAM,KAAK,SAAS,IAAI,OAAO,UAAU,IAAI,MAAM,MAAM,IAAI;AAAA,EAC/D;AACF;;;ACtDA,eAAsB,YAAY;AAAA,EAChC,OAAO,QAAQ,KAAK,MAAM,CAAC;AAAA,EAC3B,MAAM,QAAQ;AAAA,EACd,MAAM,SAAS;AACjB,IAII,CAAC,GAAuD;AAC1D,QAAM,SAAS,oBAAoB,EAAE,MAAM,gBAAgB,IAAI,GAAG,IAAI,CAAC;AAEvE,QAAM,WAAW,OAAO,SAAgC;AACtD,QAAI;AACF,YAAM,IAAI,MAAM;AAChB,cAAQ,KAAK,IAAI;AAAA,IACnB,SAAS,OAAO;AACd,cAAQ,MAAM,mDAAmD,KAAK;AACtE,cAAQ,KAAK,CAAC;AAAA,IAChB;AAAA,EACF;AAEA,UAAQ,KAAK,UAAU,MAAM;AAC3B,SAAK,SAAS,CAAC;AAAA,EACjB,CAAC;AAED,UAAQ,KAAK,WAAW,MAAM;AAC5B,SAAK,SAAS,CAAC;AAAA,EACjB,CAAC;AAED,QAAM,IAAI,OAAO,EAAE,MAAM,OAAO,MAAM,MAAM,OAAO,KAAK,CAAC;AACzD,SAAO;AACT;AAEA,IAAI,UAAQ,SAAS,QAAQ;AAC3B,OAAK,YAAY,EAAE,MAAM,CAAC,UAAU;AAClC,YAAQ,MAAM,wCAAwC,KAAK;AAC3D,YAAQ,KAAK,CAAC;AAAA,EAChB,CAAC;AACH;","names":[]}

package/jest.config.js

@@ -0,0 +1,17 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  roots: ["<rootDir>/src"],
+  testMatch: ["**/__tests__/**/*.test.ts", "**/?(*.)+(spec|test).ts"],
+  transform: {
+    "^.+\\.ts$": [
+      "ts-jest",
+      {
+        isolatedModules: true,
+      },
+    ],
+  },
+  collectCoverageFrom: ["src/**/*.ts", "!src/**/*.d.ts", "!src/__tests__/**/*"],
+  coverageReporters: ["text", "lcov", "html"],
+  testTimeout: 30000,
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@axiom-lattice/microsandbox-service",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "lattice-microsandbox-service": "./dist/server.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.mjs",
+      "require": "./dist/server.js"
+    }
+  },
+  "dependencies": {
+    "@fastify/cors": "^11.0.0",
+    "@fastify/multipart": "^9.4.0",
+    "@fastify/sensible": "^6.0.3",
+    "fastify": "^5.5.0",
+    "microsandbox": "^0.3.12",
+    "zod": "3.25.76"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.19.13",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.2"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/server.ts --format cjs,esm --dts --clean --sourcemap",
+    "start": "node dist/server.js",
+    "dev": "tsup src/index.ts src/server.ts --format cjs,esm --dts --watch --sourcemap --onSuccess \"node dist/server.js\"",
+    "lint": "tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  }
+}

package/src/__tests__/MicrosandboxRuntimeService.test.ts

@@ -0,0 +1,251 @@
+import { Mount, Sandbox } from "microsandbox";
+import { SandboxRegistry } from "../services/SandboxRegistry";
+import { MicrosandboxRuntimeService } from "../services/MicrosandboxRuntimeService";
+
+jest.mock("microsandbox", () => ({
+  Mount: {
+    bind: jest.fn((source: string, options?: unknown) => ({ kind: "bind", source, options })),
+    named: jest.fn((name: string, options?: unknown) => ({ kind: "named", name, options })),
+    tmpfs: jest.fn((options?: unknown) => ({ kind: "tmpfs", options })),
+  },
+  Sandbox: {
+    get: jest.fn(),
+    start: jest.fn(),
+    createDetached: jest.fn(),
+    remove: jest.fn(),
+  },
+}));
+
+describe("MicrosandboxRuntimeService", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("translates bind, named, and tmpfs volumes on ensure", async () => {
+    const native = { fs: jest.fn(), execWithConfig: jest.fn() };
+
+    (Sandbox.get as jest.Mock).mockRejectedValue(new Error("not found"));
+    (Sandbox.createDetached as jest.Mock).mockResolvedValue(native);
+
+    const service = new MicrosandboxRuntimeService({ registry: new SandboxRegistry() });
+
+    await service.ensureSandbox("tenant-a", {
+      image: "python:3.11-slim",
+      volumes: {
+        "/data/src": { type: "bind", source: "/srv/src", readonly: true },
+        "/data/cache": { type: "named", name: "cache-vol" },
+        "/tmp/scratch": { type: "tmpfs", sizeMib: 64 },
+      },
+    });
+
+    expect(Mount.bind).toHaveBeenCalledWith("/srv/src", { readonly: true });
+    expect(Mount.named).toHaveBeenCalledWith("cache-vol", { readonly: false });
+    expect(Mount.tmpfs).toHaveBeenCalledWith({ sizeMib: 64 });
+    expect(Sandbox.createDetached).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: "tenant-a",
+        image: "python:3.11-slim",
+      })
+    );
+  });
+
+  it("startSandbox clears the cached handle and re-ensures the sandbox", async () => {
+    const registry = {
+      delete: jest.fn(),
+      ensure: jest.fn().mockResolvedValue({ id: "native" }),
+    } as unknown as SandboxRegistry;
+
+    (Sandbox.start as jest.Mock).mockResolvedValue({ id: "started" });
+
+    const service = new MicrosandboxRuntimeService({ registry });
+
+    await expect(service.startSandbox("tenant-a")).resolves.toEqual({
+      name: "tenant-a",
+      status: "running",
+    });
+
+    expect(Sandbox.start).toHaveBeenCalledWith("tenant-a");
+    expect(registry.delete).toHaveBeenCalledWith("tenant-a");
+    expect(registry.ensure).toHaveBeenCalledWith("tenant-a");
+  });
+
+  it("stopSandbox clears the registry state", async () => {
+    const native = { stop: jest.fn().mockResolvedValue(undefined) };
+    const registry = {
+      get: jest.fn().mockReturnValue(native),
+      delete: jest.fn(),
+    } as unknown as SandboxRegistry;
+
+    const service = new MicrosandboxRuntimeService({ registry });
+
+    await expect(service.stopSandbox("tenant-a")).resolves.toEqual({
+      name: "tenant-a",
+      status: "stopped",
+    });
+
+    expect(native.stop).toHaveBeenCalledTimes(1);
+    expect(registry.delete).toHaveBeenCalledWith("tenant-a");
+  });
+
+  it("killSandbox clears the registry state", async () => {
+    const native = { kill: jest.fn().mockResolvedValue(undefined) };
+    const registry = {
+      get: jest.fn().mockReturnValue(native),
+      delete: jest.fn(),
+    } as unknown as SandboxRegistry;
+
+    const service = new MicrosandboxRuntimeService({ registry });
+
+    await expect(service.killSandbox("tenant-a")).resolves.toEqual({
+      name: "tenant-a",
+      status: "unknown",
+    });
+
+    expect(native.kill).toHaveBeenCalledTimes(1);
+    expect(registry.delete).toHaveBeenCalledWith("tenant-a");
+  });
+
+  it("deleteSandbox clears registry state after removing the sandbox", async () => {
+    const native = { kill: jest.fn().mockResolvedValue(undefined) };
+    const registry = {
+      get: jest.fn().mockReturnValue(native),
+      delete: jest.fn(),
+    } as unknown as SandboxRegistry;
+
+    const service = new MicrosandboxRuntimeService({ registry });
+
+    await expect(service.deleteSandbox("tenant-a")).resolves.toEqual({
+      name: "tenant-a",
+      status: "unknown",
+    });
+
+    expect(native.kill).toHaveBeenCalledTimes(1);
+    expect(Sandbox.remove).toHaveBeenCalledWith("tenant-a");
+    expect(registry.delete).toHaveBeenCalledWith("tenant-a");
+  });
+
+  it("deleteSandbox still removes the sandbox when no cached handle exists", async () => {
+    const registry = {
+      get: jest.fn().mockImplementation(() => {
+        throw new Error("missing");
+      }),
+      delete: jest.fn(),
+    } as unknown as SandboxRegistry;
+
+    const service = new MicrosandboxRuntimeService({ registry });
+
+    await expect(service.deleteSandbox("tenant-b")).resolves.toEqual({
+      name: "tenant-b",
+      status: "unknown",
+    });
+
+    expect(Sandbox.remove).toHaveBeenCalledWith("tenant-b");
+    expect(registry.delete).toHaveBeenCalledWith("tenant-b");
+  });
+
+  it("getStatus does not create a missing sandbox", async () => {
+    const registry = {
+      get: jest.fn().mockImplementation(() => {
+        throw new Error("missing");
+      }),
+      ensure: jest.fn(),
+    } as unknown as SandboxRegistry;
+
+    const service = new MicrosandboxRuntimeService({ registry });
+
+    await expect(service.getStatus("tenant-missing")).resolves.toEqual({
+      name: "tenant-missing",
+      status: "unknown",
+    });
+
+    expect(registry.ensure).not.toHaveBeenCalled();
+  });
+
+  it("stopSandbox reconnects by name when the cache is empty", async () => {
+    const native = { stop: jest.fn().mockResolvedValue(undefined) };
+    const registry = {
+      get: jest.fn().mockImplementation(() => {
+        throw new Error("missing");
+      }),
+      ensure: jest.fn().mockResolvedValue(native),
+      delete: jest.fn(),
+    } as unknown as SandboxRegistry;
+
+    const service = new MicrosandboxRuntimeService({ registry });
+
+    await expect(service.stopSandbox("tenant-a")).resolves.toEqual({
+      name: "tenant-a",
+      status: "stopped",
+    });
+
+    expect(registry.ensure).toHaveBeenCalledWith("tenant-a");
+    expect(native.stop).toHaveBeenCalledTimes(1);
+    expect(registry.delete).toHaveBeenCalledWith("tenant-a");
+  });
+
+  it("killSandbox reconnects by name when the cache is empty", async () => {
+    const native = { kill: jest.fn().mockResolvedValue(undefined) };
+    const registry = {
+      get: jest.fn().mockImplementation(() => {
+        throw new Error("missing");
+      }),
+      ensure: jest.fn().mockResolvedValue(native),
+      delete: jest.fn(),
+    } as unknown as SandboxRegistry;
+
+    const service = new MicrosandboxRuntimeService({ registry });
+
+    await expect(service.killSandbox("tenant-a")).resolves.toEqual({
+      name: "tenant-a",
+      status: "unknown",
+    });
+
+    expect(registry.ensure).toHaveBeenCalledWith("tenant-a");
+    expect(native.kill).toHaveBeenCalledTimes(1);
+    expect(registry.delete).toHaveBeenCalledWith("tenant-a");
+  });
+
+  it("searchInFile returns an empty match result when grep finds nothing", async () => {
+    const native = {
+      execWithConfig: jest.fn().mockRejectedValue({ code: 1 }),
+    };
+    const registry = {
+      get: jest.fn().mockReturnValue(native),
+    } as unknown as SandboxRegistry;
+
+    const service = new MicrosandboxRuntimeService({ registry });
+
+    await expect(service.searchInFile("tenant-a", "/tmp/test.txt", "hello")).resolves.toEqual({
+      matches: [],
+    });
+  });
+
+  it("forwards recursive list requests and preserves nested paths plus binary upload/download payloads", async () => {
+    const binary = Buffer.from([0, 255, 1]);
+    const fs = {
+      list: jest.fn().mockResolvedValue([{ path: "/tmp/subdir/file.txt", kind: "file" }]),
+      write: jest.fn().mockResolvedValue(undefined),
+      read: jest.fn().mockResolvedValue(binary),
+    };
+    const registry = {
+      get: jest.fn().mockReturnValue({ fs: () => fs }),
+    } as unknown as SandboxRegistry;
+
+    const service = new MicrosandboxRuntimeService({ registry });
+
+    await expect(service.listPath("tenant-a", "/tmp", true)).resolves.toEqual({
+      entries: [{ path: "/tmp/subdir/file.txt", type: "file" }],
+    });
+    await expect(service.uploadFile("tenant-a", "/tmp/blob.bin", binary.toString("base64"))).resolves.toEqual({
+      path: "/tmp/blob.bin",
+    });
+    await expect(service.downloadFile("tenant-a", "/tmp/blob.bin")).resolves.toEqual({
+      path: "/tmp/blob.bin",
+      contentBase64: binary.toString("base64"),
+    });
+
+    expect(fs.list).toHaveBeenCalledWith("/tmp", { recursive: true });
+    expect(fs.write).toHaveBeenCalledWith("/tmp/blob.bin", binary);
+    expect(fs.read).toHaveBeenCalledWith("/tmp/blob.bin");
+  });
+});

package/src/__tests__/SandboxRegistry.test.ts

@@ -0,0 +1,101 @@
+import { Sandbox } from "microsandbox";
+import { SandboxRegistry } from "../services/SandboxRegistry";
+
+jest.mock("microsandbox", () => ({
+  Sandbox: {
+    get: jest.fn(),
+    start: jest.fn(),
+    createDetached: jest.fn(),
+    remove: jest.fn(),
+  },
+}));
+
+describe("SandboxRegistry", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("reuses a running sandbox connection", async () => {
+    const native = { id: "native" };
+    const connect = jest.fn().mockResolvedValue(native);
+
+    (Sandbox.get as jest.Mock).mockResolvedValue({ status: "running", connect });
+
+    const registry = new SandboxRegistry();
+    const first = await registry.ensure("tenant-a");
+    const second = await registry.ensure("tenant-a");
+
+    expect(first).toBe(second);
+    expect(connect).toHaveBeenCalledTimes(1);
+  });
+
+  it("reconnects a stopped sandbox by starting it", async () => {
+    const native = { id: "started" };
+
+    (Sandbox.get as jest.Mock).mockResolvedValue({ status: "stopped" });
+    (Sandbox.start as jest.Mock).mockResolvedValue(native);
+
+    const registry = new SandboxRegistry();
+    const sandbox = await registry.ensure("tenant-b");
+
+    expect(sandbox).toBe(native);
+    expect(Sandbox.start).toHaveBeenCalledWith("tenant-b");
+    expect(Sandbox.createDetached).not.toHaveBeenCalled();
+  });
+
+  it("removes crashed sandboxes and recreates them", async () => {
+    const native = { id: "created" };
+
+    (Sandbox.get as jest.Mock).mockResolvedValue({ status: "crashed" });
+    (Sandbox.createDetached as jest.Mock).mockResolvedValue(native);
+
+    const registry = new SandboxRegistry();
+    const sandbox = await registry.ensure("tenant-c", { image: "python:3.11-slim" });
+
+    expect(sandbox).toBe(native);
+    expect(Sandbox.remove).toHaveBeenCalledWith("tenant-c");
+    expect(Sandbox.createDetached).toHaveBeenCalledWith({
+      name: "tenant-c",
+      image: "python:3.11-slim",
+    });
+  });
+
+  it("removes draining sandboxes and recreates them", async () => {
+    const native = { id: "created" };
+
+    (Sandbox.get as jest.Mock).mockResolvedValue({ status: "draining" });
+    (Sandbox.createDetached as jest.Mock).mockResolvedValue(native);
+
+    const registry = new SandboxRegistry();
+
+    await registry.ensure("tenant-d");
+
+    expect(Sandbox.remove).toHaveBeenCalledWith("tenant-d");
+    expect(Sandbox.createDetached).toHaveBeenCalledWith({
+      name: "tenant-d",
+      image: "python:3.11-slim",
+    });
+  });
+
+  it("creates a fresh handle after cache invalidation", async () => {
+    const firstNative = { id: "first" };
+    const secondNative = { id: "second" };
+    const firstConnect = jest.fn().mockResolvedValue(firstNative);
+    const secondConnect = jest.fn().mockResolvedValue(secondNative);
+
+    (Sandbox.get as jest.Mock)
+      .mockResolvedValueOnce({ status: "running", connect: firstConnect })
+      .mockResolvedValueOnce({ status: "running", connect: secondConnect });
+
+    const registry = new SandboxRegistry();
+    const first = await registry.ensure("tenant-e");
+    registry.delete("tenant-e");
+    const second = await registry.ensure("tenant-e");
+
+    expect(first).toBe(firstNative);
+    expect(second).toBe(secondNative);
+    expect(second).not.toBe(first);
+    expect(firstConnect).toHaveBeenCalledTimes(1);
+    expect(secondConnect).toHaveBeenCalledTimes(1);
+  });
+});