@platforma-sdk/package-builder-lib 1.1.0

package/src/core/__tests__/docker-python.test.ts

@@ -0,0 +1,374 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { getRunEnvironmentPythonInfo, prepareDockerOptions } from "../docker-python";
+import type * as artifacts from "../schemas/artifacts";
+import type winston from "winston";
+import * as util from "../util";
+
+// Mock the os module
+vi.mock("node:os", () => ({
+  platform: vi.fn(),
+  tmpdir: vi.fn(),
+}));
+
+// Mock winston logger
+const mockLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  debug: vi.fn(),
+  error: vi.fn(),
+} as unknown as winston.Logger;
+
+// Mock Python package for testing - will be set in beforeEach
+let mockPythonPackage: artifacts.pythonType;
+
+const createRunEnvironmentSwJson = (
+  packageRoot: string,
+  runenvArtifactID: string,
+  pythonVersion: string,
+  envVars: string[],
+) => {
+  const [runenvPackageName, runenvEntrypointName] = util.rSplit(runenvArtifactID, ":", 2);
+
+  const entrypointPath = path.join(
+    packageRoot,
+    "node_modules",
+    runenvPackageName,
+    "dist",
+    "tengo",
+    "software",
+    runenvEntrypointName + ".sw.json",
+  );
+  fs.mkdirSync(path.dirname(entrypointPath), { recursive: true });
+
+  fs.writeFileSync(
+    entrypointPath,
+    JSON.stringify(
+      {
+        name: `${runenvPackageName}:${runenvEntrypointName}`,
+        runEnv: {
+          type: "python",
+          "python-version": pythonVersion,
+          envVars: envVars,
+          registry: "example-python-registry",
+          package: "software/package-path/py3/1.1.0-{os}-{arch}.tgz",
+          binDir: ".",
+        },
+      },
+      null,
+      2,
+    ),
+  );
+};
+
+describe("Docker Python Functions", () => {
+  let tempDir: string;
+  let testPackageRoot: string;
+
+  beforeEach(() => {
+    // Set up OS mocks
+    vi.mocked(os.platform).mockReturnValue("linux");
+    vi.mocked(os.tmpdir).mockReturnValue("/tmp");
+
+    // Create temporary directories for testing
+    tempDir = fs.mkdtempSync(path.join("/tmp", "python-docker-test"));
+    testPackageRoot = path.join(tempDir, "package");
+
+    fs.mkdirSync(testPackageRoot, { recursive: true });
+
+    // Create src directory for the root property
+    fs.mkdirSync(path.join(testPackageRoot, "src"), { recursive: true });
+
+    // Create a mock requirements.txt file
+    fs.writeFileSync(path.join(testPackageRoot, "requirements.txt"), "requests>=2.25.0\n");
+
+    createRunEnvironmentSwJson(
+      testPackageRoot,
+      "@platforma-open/milaboratories.runenv-python-3:3.12.10",
+      "3.12.10",
+      [],
+    );
+
+    // Initialize mockPythonPackage with absolute path
+    mockPythonPackage = {
+      name: "test-python-package",
+      version: "1.0.0",
+      type: "python",
+      environment: "@platforma-open/milaboratories.runenv-python-3:3.12.10",
+      registry: { name: "test" },
+      "docker-registry": "test-docker-registry",
+      root: path.join(testPackageRoot, "src"), // Use absolute path
+      pkg: "/app",
+    };
+
+    // Clear all mocks
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    // Clean up temporary directories
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe("prepareDockerOptions", () => {
+    it("should create dist/docker directories recursively", () => {
+      // Verify directories don't exist initially
+      expect(fs.existsSync(path.join(testPackageRoot, "dist"))).toBe(false);
+      expect(fs.existsSync(path.join(testPackageRoot, "dist", "docker"))).toBe(false);
+
+      const result = prepareDockerOptions(
+        mockLogger,
+        testPackageRoot,
+        "test-package",
+        "artifact-id",
+        mockPythonPackage,
+      );
+
+      // Verify directories were created
+      expect(fs.existsSync(path.join(testPackageRoot, "dist"))).toBe(true);
+      expect(fs.existsSync(path.join(testPackageRoot, "dist", "docker"))).toBe(true);
+
+      // Verify result structure
+      expect(result).toMatchObject({
+        context: expect.stringContaining(testPackageRoot) as string,
+        dockerfile: expect.stringContaining("Dockerfile") as string,
+        entrypoint: [],
+      });
+
+      // Verify Dockerfile was created
+      expect(fs.existsSync(result.dockerfile)).toBe(true);
+      expect(fs.existsSync(result.context)).toBe(true);
+    });
+
+    it("should prepare Docker options with default Python settings", () => {
+      const result = prepareDockerOptions(
+        mockLogger,
+        testPackageRoot,
+        "test-package",
+        "artifact-id",
+        mockPythonPackage,
+      );
+
+      // Verify result structure
+      expect(result).toMatchObject({
+        context: expect.stringContaining(testPackageRoot) as string,
+        dockerfile: expect.stringContaining("Dockerfile") as string,
+        entrypoint: [],
+      });
+
+      // Verify Dockerfile was created
+      expect(fs.existsSync(result.dockerfile)).toBe(true);
+      expect(fs.existsSync(result.context)).toBe(true);
+    });
+
+    it("should use default Python version when environment has no version", () => {
+      createRunEnvironmentSwJson(
+        testPackageRoot,
+        "@platforma-open/milaboratories.runenv-python-3:aaa",
+        "",
+        [],
+      );
+
+      const packageWithoutVersion: artifacts.pythonType = {
+        ...mockPythonPackage,
+        environment: "@platforma-open/milaboratories.runenv-python-3:aaa",
+        root: path.join(testPackageRoot, "src"), // Use absolute path
+      };
+
+      const result = prepareDockerOptions(
+        mockLogger,
+        testPackageRoot,
+        "test-package",
+        "artifact-id",
+        packageWithoutVersion,
+      );
+
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        "No Python version found in environment, using default: python:3.12-slim",
+      );
+      expect(result).toBeDefined();
+    });
+
+    it("should generate Dockerfile with correct content", () => {
+      const result = prepareDockerOptions(
+        mockLogger,
+        testPackageRoot,
+        "test-package",
+        "artifact-id",
+        mockPythonPackage,
+      );
+
+      const dockerfileContent = fs.readFileSync(result.dockerfile, "utf-8");
+
+      // Check essential Dockerfile components
+      expect(dockerfileContent).toContain("FROM python:3.12-slim");
+      expect(dockerfileContent).toContain("WORKDIR /app");
+      expect(dockerfileContent).toContain("COPY ");
+      expect(dockerfileContent).toContain("RUN pip install");
+      expect(dockerfileContent).toContain("ENV PYTHONPATH=/app");
+      expect(dockerfileContent).toContain('CMD ["bash"]');
+    });
+
+    it("should handle missing requirements.txt gracefully", () => {
+      // Remove requirements.txt
+      fs.unlinkSync(path.join(testPackageRoot, "requirements.txt"));
+
+      const result = prepareDockerOptions(
+        mockLogger,
+        testPackageRoot,
+        "test-package",
+        "artifact-id",
+        mockPythonPackage,
+      );
+
+      const dockerfileContent = fs.readFileSync(result.dockerfile, "utf-8");
+      expect(dockerfileContent).toContain("COPY");
+      expect(dockerfileContent).toContain("RUN pip install --no-cache-dir -r requirements.txt");
+
+      // Check that empty requirements.txt was created in context directory (src)
+      const emptyRequirementsPath = path.join(testPackageRoot, "src", "requirements.txt");
+      expect(fs.existsSync(emptyRequirementsPath)).toBe(true);
+      const emptyRequirementsContent = fs.readFileSync(emptyRequirementsPath, "utf-8");
+      expect(emptyRequirementsContent).toContain("# No dependencies specified");
+
+      // Should still create valid Docker options
+      expect(result).toBeDefined();
+      expect(result.dockerfile).toBeDefined();
+    });
+  });
+});
+
+describe("getPythonVersionFromEnvironment", () => {
+  let tempDir: string;
+  let testPackageRoot: string;
+
+  beforeEach(() => {
+    // Set up OS mocks
+    vi.mocked(os.platform).mockReturnValue("linux");
+    vi.mocked(os.tmpdir).mockReturnValue("/tmp");
+
+    // Create temporary directories for testing
+    tempDir = fs.mkdtempSync(path.join("/tmp", "python-docker-test"));
+    testPackageRoot = path.join(tempDir, "package");
+
+    fs.mkdirSync(testPackageRoot, { recursive: true });
+    vi.clearAllMocks();
+  });
+
+  const rawCases: [string, string, string][] = [
+    // Explicit version specified in the runenv
+    // ['@platforma-open/milaboratories.runenv-python-3:py-default', '3.12.0', '3.12.0'],
+    // ['@platforma-open/milaboratories.runenv-python-3:3.10.10', '3.4.5', '3.4.5'],
+
+    // Standard versions
+    ["@platforma-open/milaboratories.runenv-python-3:3.12.6", "", "3.12.6"],
+    ["@platforma-open/milaboratories.runenv-python-3:3.11.0", "", "3.11.0"],
+
+    // Pre-releases
+    ["@platforma-open/milaboratories.runenv-python-3:3.12.6-rc1", "", "3.12.6-rc1"],
+    ["@platforma-open/milaboratories.runenv-python-3:3.13.0a1", "", "3.13.0a1"],
+    ["@platforma-open/milaboratories.runenv-python-3:3.13.0b2", "", "3.13.0b2"],
+
+    // With tags/suffixes
+    ["@platforma-open/milaboratories.runenv-python-3:3.12.6:latest", "", "3.12.6:latest"],
+    ["@platforma-open/milaboratories.runenv-python-3:3.12.6+dev", "", "3.12.6+dev"],
+    ["@platforma-open/milaboratories.runenv-python-3:3.12.6_dev", "", "3.12.6_dev"],
+  ];
+
+  const dockerSafeCases: [string, string, string][] = [
+    // Explicit version specified in the runenv
+    ["@platforma-open/milaboratories.runenv-python-3:py-default", "3.12.0", "3.12.0"],
+    ["@platforma-open/milaboratories.runenv-python-3:3.10.10", "3.4.5", "3.4.5"],
+
+    // Second ":" is stripped
+    ["@platforma-open/milaboratories.runenv-python-3:3.12.6:latest", "", "3.12.6"],
+    // Digest is stripped
+    ["@platforma-open/milaboratories.runenv-python-3:3.12.6@sha256:deadbeef", "", "3.12.6"],
+    // Pre-release should remain valid
+    ["@platforma-open/milaboratories.runenv-python-3:3.13.0b2@sha256:123", "", "3.13.0b2"],
+    // With tags/suffixes
+    ["@platforma-open/milaboratories.runenv-python-3:3.14.0rc2-bookworm", "", "3.14.0rc2-bookworm"],
+    ["@platforma-open/milaboratories.runenv-python-3:3.9.23-alpine3.22", "", "3.9.23-alpine3.22"],
+    ["@platforma-open/milaboratories.runenv-python-3:3.12.6-slim", "", "3.12.6-slim"],
+    [
+      "@platforma-open/milaboratories.runenv-python-3:3.13.7-windowsservercore-ltsc2025",
+      "",
+      "3.13.7-windowsservercore-ltsc2025",
+    ],
+  ];
+
+  const undefinedCases: [string, string[]][] = [
+    ["@milaboratories/example-pl-package-runenv-1:python", ["MY_ENV_VAR=1234"]],
+    ["@milaboratories/example-pl-package-runenv-1:python", []],
+  ];
+
+  describe("without normalizeForDocker", () => {
+    rawCases.forEach(([input, pyVersion, expected]) => {
+      it(`should extract "${expected}" from "${input}"`, () => {
+        createRunEnvironmentSwJson(testPackageRoot, input, pyVersion, ["MY_ENV_VAR=1234"]);
+        expect(
+          getRunEnvironmentPythonInfo(mockLogger, testPackageRoot, "test-package", input, {
+            normalizeForDocker: false,
+          }),
+        ).toStrictEqual({
+          pythonVersion: expected,
+          envVars: ["MY_ENV_VAR=1234"],
+        });
+      });
+    });
+
+    undefinedCases.forEach(([input, envVars]) => {
+      it(`should return undefined for "${input}"`, () => {
+        if (input !== "") {
+          createRunEnvironmentSwJson(testPackageRoot, input, "", envVars);
+        }
+        expect(
+          getRunEnvironmentPythonInfo(mockLogger, testPackageRoot, "test-package", input, {
+            normalizeForDocker: false,
+          }),
+        ).toStrictEqual({
+          pythonVersion: undefined,
+          envVars,
+        });
+      });
+    });
+  });
+
+  describe("with normalizeForDocker = true", () => {
+    dockerSafeCases.forEach(([input, pyVersion, expected]) => {
+      it(`should extract docker-safe "${expected}" from "${input}"`, () => {
+        createRunEnvironmentSwJson(testPackageRoot, input, pyVersion, []);
+        expect(
+          getRunEnvironmentPythonInfo(mockLogger, testPackageRoot, "test-package", input, {
+            normalizeForDocker: true,
+          }),
+        ).toStrictEqual({
+          pythonVersion: expected,
+          envVars: [],
+        });
+      });
+    });
+
+    undefinedCases.forEach(([input, envVars]) => {
+      it(`should return undefined for "${input}"`, () => {
+        if (input !== "") {
+          createRunEnvironmentSwJson(testPackageRoot, input, "", envVars);
+        }
+        expect(
+          getRunEnvironmentPythonInfo(mockLogger, testPackageRoot, "test-package", input, {
+            normalizeForDocker: true,
+          }),
+        ).toStrictEqual({
+          pythonVersion: undefined,
+          envVars,
+        });
+      });
+    });
+  });
+});

package/src/core/__tests__/publish-docker-images.test.ts

@@ -0,0 +1,309 @@
+// Regression tests for Core.buildDockerImages + Core.publishDockerImages.
+//
+// Locks in two properties:
+//   1. each docker artifact is built and pushed exactly once across all
+//      block-software entrypoint shapes (python/conda autogen, explicit
+//      docker, java-only, multi-entrypoint). The autopush path used to
+//      iterate over both buildablePackages and dockerPackages, which for
+//      python→docker autogen counted the same artifact twice.
+//   2. the strict-platform gate keeps non-linux/x64 hosts out of the
+//      build+publish path in CI, so the matrix doesn't fan out duplicate
+//      pushes from arm/windows legs.
+//
+// docker.* is module-mocked so the tests don't shell out to the real
+// docker daemon. PackageInfo is constructed against a tmpdir with a
+// minimal package.json + the bits each shape needs (requirements.txt for
+// python, a stub runenv .sw.json for python autogen).
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import type winston from "winston";
+
+import { Core } from "../core";
+import * as docker from "../docker";
+import * as util from "../util";
+
+vi.mock("../docker", async (importOriginal) => {
+  const real = await importOriginal<typeof docker>();
+  return {
+    ...real,
+    build: vi.fn(),
+    push: vi.fn(),
+    addTag: vi.fn(),
+    removeTag: vi.fn(),
+    getImageHash: vi.fn(() => "deadbeef0123"),
+    getImageEntrypoint: vi.fn(() => [] as string[]),
+    localImageExists: vi.fn(() => true),
+    remoteImageExists: vi.fn(() => false),
+  };
+});
+
+const mockLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  debug: vi.fn(),
+  error: vi.fn(),
+  log: vi.fn(),
+} as unknown as winston.Logger;
+
+// Minimal stub for the python runenv .sw.json that PackageInfo's python
+// autogen path resolves through `node_modules`. Only the runEnv block is
+// inspected by docker-python so we keep this tiny.
+function writeRunenvSwJson(packageRoot: string, refId: string, pythonVersion: string) {
+  const [pkgName, ep] = refId.split(":");
+  const swPath = path.join(
+    packageRoot,
+    "node_modules",
+    pkgName,
+    "dist",
+    "tengo",
+    "software",
+    `${ep}.sw.json`,
+  );
+  fs.mkdirSync(path.dirname(swPath), { recursive: true });
+  fs.writeFileSync(
+    swPath,
+    JSON.stringify({
+      name: `${pkgName}:${ep}`,
+      runEnv: {
+        type: "python",
+        "python-version": pythonVersion,
+        envVars: [],
+        registry: "test-runenv-registry",
+        package: "software/test/py-{os}-{arch}.tgz",
+        binDir: ".",
+      },
+    }),
+  );
+}
+
+function makePackageRoot(
+  tmpDir: string,
+  pkgJson: Record<string, unknown>,
+  extras?: {
+    requirementsTxt?: boolean;
+    runenv?: { ref: string; pythonVersion: string };
+    dockerContext?: string;
+  },
+): string {
+  const root = path.join(tmpDir, "pkg");
+  fs.mkdirSync(path.join(root, "src"), { recursive: true });
+  fs.writeFileSync(path.join(root, "package.json"), JSON.stringify(pkgJson));
+
+  if (extras?.requirementsTxt) {
+    fs.writeFileSync(path.join(root, "src", "requirements.txt"), "");
+  }
+  if (extras?.runenv) {
+    writeRunenvSwJson(root, extras.runenv.ref, extras.runenv.pythonVersion);
+  }
+  if (extras?.dockerContext) {
+    fs.mkdirSync(path.join(root, extras.dockerContext), { recursive: true });
+    // dockerSchema defaults the Dockerfile path to <root>/Dockerfile, separate
+    // from the context dir. Provide both.
+    fs.writeFileSync(path.join(root, "Dockerfile"), "FROM scratch\n");
+    fs.writeFileSync(path.join(root, extras.dockerContext, ".keep"), "");
+  }
+
+  return root;
+}
+
+const RUNENV_REF = "@test/runenv-py:py3";
+
+const pythonEntrypoint = {
+  binary: {
+    artifact: {
+      type: "python",
+      registry: "platforma-open",
+      environment: RUNENV_REF,
+      root: "./src",
+      dependencies: { toolset: "pip", requirements: "requirements.txt" },
+    },
+    cmd: ["python", "{pkg}/main.py"],
+  },
+};
+
+const javaEntrypoint = {
+  binary: {
+    artifact: {
+      type: "java",
+      registry: "platforma-open",
+      environment: RUNENV_REF,
+      // 'roots' is omitted for java in the schema; archiveRulesSchema requires root.
+      root: "./src",
+    },
+    cmd: ["java", "-jar", "{pkg}/app.jar"],
+  },
+};
+
+const explicitDockerEntrypoint = {
+  docker: {
+    artifact: {
+      context: "docker-context",
+    },
+    cmd: ["echo", "hello"],
+  },
+};
+
+describe("Core.buildDockerImages + publishDockerImages", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Restore default return values that the per-test code may rely on.
+    vi.mocked(docker.remoteImageExists).mockReturnValue(false);
+    vi.mocked(docker.localImageExists).mockReturnValue(true);
+    vi.mocked(docker.getImageHash).mockReturnValue("deadbeef0123");
+    vi.mocked(docker.getImageEntrypoint).mockReturnValue([]);
+
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pub-docker-test-"));
+  });
+
+  afterEach(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  it("python autogen: one build, one push, no duplicate from virtual entrypoint", () => {
+    const root = makePackageRoot(
+      tempDir,
+      {
+        name: "@test/python-autogen",
+        version: "1.0.0",
+        "block-software": { entrypoints: { main: pythonEntrypoint } },
+      },
+      { requirementsTxt: true, runenv: { ref: RUNENV_REF, pythonVersion: "3.12.10" } },
+    );
+
+    const core = new Core(mockLogger, { packageRoot: root });
+    core.buildDockerImages({ registry: "test.local/repo" });
+    core.publishDockerImages();
+
+    expect(docker.build).toHaveBeenCalledTimes(1);
+    expect(docker.push).toHaveBeenCalledTimes(1);
+
+    const pushed = vi.mocked(docker.push).mock.calls[0][0];
+    expect(pushed).toBe("test.local/repo:test.python-autogen.main.deadbeef0123");
+  });
+
+  it("multi-entrypoint python: one build + one push per entrypoint, no overlap", () => {
+    const root = makePackageRoot(
+      tempDir,
+      {
+        name: "@test/multi-ep",
+        version: "1.0.0",
+        "block-software": {
+          entrypoints: {
+            main: pythonEntrypoint,
+            helper: pythonEntrypoint,
+          },
+        },
+      },
+      { requirementsTxt: true, runenv: { ref: RUNENV_REF, pythonVersion: "3.12.10" } },
+    );
+
+    const core = new Core(mockLogger, { packageRoot: root });
+    core.buildDockerImages({ registry: "test.local/repo" });
+    core.publishDockerImages();
+
+    expect(docker.build).toHaveBeenCalledTimes(2);
+    expect(docker.push).toHaveBeenCalledTimes(2);
+
+    const pushedTags = vi.mocked(docker.push).mock.calls.map((c) => c[0]);
+    expect(new Set(pushedTags).size).toBe(2);
+    expect(pushedTags).toEqual(
+      expect.arrayContaining([
+        "test.local/repo:test.multi-ep.main.deadbeef0123",
+        "test.local/repo:test.multi-ep.helper.deadbeef0123",
+      ]),
+    );
+  });
+
+  it("java-only: no docker work — type is not in dockerAutogenTypes", () => {
+    const root = makePackageRoot(tempDir, {
+      name: "@test/java-only",
+      version: "1.0.0",
+      "block-software": { entrypoints: { main: javaEntrypoint } },
+    });
+
+    const core = new Core(mockLogger, { packageRoot: root });
+    core.buildDockerImages({ registry: "test.local/repo" });
+    core.publishDockerImages();
+
+    expect(docker.build).not.toHaveBeenCalled();
+    expect(docker.push).not.toHaveBeenCalled();
+  });
+
+  it("explicit docker entrypoint: one build, one push", () => {
+    const root = makePackageRoot(
+      tempDir,
+      {
+        name: "@test/explicit-docker",
+        version: "1.0.0",
+        "block-software": { entrypoints: { main: explicitDockerEntrypoint } },
+      },
+      { dockerContext: "docker-context" },
+    );
+
+    const core = new Core(mockLogger, { packageRoot: root });
+    core.buildDockerImages({ registry: "test.local/repo" });
+    core.publishDockerImages();
+
+    expect(docker.build).toHaveBeenCalledTimes(1);
+    expect(docker.push).toHaveBeenCalledTimes(1);
+  });
+
+  it("remoteImageExists short-circuits push (idempotent rebuild)", () => {
+    vi.mocked(docker.remoteImageExists).mockReturnValue(true);
+
+    const root = makePackageRoot(
+      tempDir,
+      {
+        name: "@test/python-cached",
+        version: "1.0.0",
+        "block-software": { entrypoints: { main: pythonEntrypoint } },
+      },
+      { requirementsTxt: true, runenv: { ref: RUNENV_REF, pythonVersion: "3.12.10" } },
+    );
+
+    const core = new Core(mockLogger, { packageRoot: root });
+    core.buildDockerImages({ registry: "test.local/repo" });
+    core.publishDockerImages();
+
+    expect(docker.build).toHaveBeenCalledTimes(1);
+    expect(docker.push).not.toHaveBeenCalled();
+  });
+
+  it("strictPlatformMatching skips both build and publish on non-linux/x64 host", () => {
+    const currentOS = vi.spyOn(util, "currentOS");
+    const currentArch = vi.spyOn(util, "currentArch");
+    currentOS.mockReturnValue("macosx");
+    currentArch.mockReturnValue("aarch64");
+
+    try {
+      const root = makePackageRoot(
+        tempDir,
+        {
+          name: "@test/strict-skipped",
+          version: "1.0.0",
+          "block-software": { entrypoints: { main: pythonEntrypoint } },
+        },
+        { requirementsTxt: true, runenv: { ref: RUNENV_REF, pythonVersion: "3.12.10" } },
+      );
+
+      const core = new Core(mockLogger, { packageRoot: root });
+      core.buildDockerImages({ registry: "test.local/repo", strictPlatformMatching: true });
+      core.publishDockerImages({ strictPlatformMatching: true });
+
+      expect(docker.build).not.toHaveBeenCalled();
+      expect(docker.push).not.toHaveBeenCalled();
+    } finally {
+      currentOS.mockRestore();
+      currentArch.mockRestore();
+    }
+  });
+});