@platforma-sdk/package-builder-lib 1.1.0

package/src/__test__/docker.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import { dockerSchema } from "../core/schemas/artifacts";
+
+describe("Docker Package Schema Validation", () => {
+  it('should reject context with "./"', () => {
+    const invalidPackage = {
+      type: "docker" as const,
+      context: "./",
+      dockerfile: "Dockerfile",
+    };
+
+    const result = dockerSchema.safeParse(invalidPackage);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0].message).toContain('Context cannot be "./" or "."');
+    }
+  });
+
+  it('should reject context with "."', () => {
+    const invalidPackage = {
+      type: "docker" as const,
+      context: ".",
+      dockerfile: "Dockerfile",
+    };
+
+    const result = dockerSchema.safeParse(invalidPackage);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0].message).toContain('Context cannot be "./" or "."');
+    }
+  });
+
+  it("should accept valid context paths", () => {
+    const validPackages = [
+      {
+        type: "docker" as const,
+        context: "docker-context",
+        dockerfile: "Dockerfile",
+      },
+      {
+        type: "docker" as const,
+        context: "/absolute/path",
+        dockerfile: "Dockerfile",
+      },
+      {
+        type: "docker" as const,
+        context: "../relative/path",
+        dockerfile: "Dockerfile",
+      },
+    ];
+
+    for (const validPackage of validPackages) {
+      const result = dockerSchema.safeParse(validPackage);
+      expect(result.success).toBe(true);
+    }
+  });
+
+  it("should accept docker package without optional fields", () => {
+    const minimalPackage = {
+      type: "docker" as const,
+      context: "valid-context",
+    };
+
+    const result = dockerSchema.safeParse(minimalPackage);
+    expect(result.success).toBe(true);
+  });
+});

package/src/__test__/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@platforma-open/docker-build-test",
+  "version": "0.0.1",
+  "dependencies": {
+    "@platforma-open/milaboratories.runenv-python-3": "catalog:"
+  },
+  "block-software": {
+    "entrypoints": {
+      "test-docker": {
+        "binary": {
+          "artifact": {
+            "type": "python",
+            "registry": "platforma-open",
+            "environment": "@platforma-open/milaboratories.runenv-python-3:3.12.10",
+            "dependencies": {
+              "toolset": "pip",
+              "requirements": "requirements.txt"
+            },
+            "root": "./python-example"
+          },
+          "cmd": [
+            "aaaa"
+          ]
+        },
+        "docker": {
+          "artifact": {
+            "type": "docker",
+            "dockerfile": "Dockerfile",
+            "context": "docker-context"
+          },
+          "cmd": [
+            "echo",
+            "hello"
+          ]
+        }
+      }
+    }
+  }
+}

package/src/__test__/python-example/main.py

@@ -0,0 +1 @@
+print("Hello, World!")

package/src/__test__/vite.config.mts

@@ -0,0 +1,7 @@
+export default {
+  build: {
+    rolldownOptions: {
+      external: ["package.json"],
+    },
+  },
+};

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

@@ -0,0 +1,145 @@
+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 { prepareDockerOptions } from "../docker-conda";
+import type * as artifacts from "../schemas/artifacts";
+import type winston from "winston";
+
+import * as defaults from "../../defaults";
+import * as util from "../util";
+
+// Mock the os module
+vi.mock("node:os", () => ({
+  platform: vi.fn(),
+  tmpdir: vi.fn(),
+  arch: vi.fn().mockReturnValue("x64"),
+}));
+
+// 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 mockCondaPackage: artifacts.condaType;
+
+describe("Docker Conda 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 spec file
+    fs.writeFileSync(
+      path.join(testPackageRoot, "some-spec.yaml"),
+      `
+name: my-env
+channels: []
+dependencies: []
+`,
+    );
+
+    // Initialize mockPythonPackage with absolute path
+    mockCondaPackage = {
+      type: "conda",
+      name: "test-conda-package",
+      version: "1.0.0",
+      registry: { name: "test" },
+      roots: {
+        "linux-x64": path.join(testPackageRoot, "src"), // Use absolute path
+      },
+      "docker-registry": "test-docker-registry",
+
+      "micromamba-version": "some-micromamba-version",
+      "conda-root-dir": "some-conda-root-dir",
+      spec: "some-spec.yaml",
+      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);
+
+      const result = prepareDockerOptions(
+        mockLogger,
+        testPackageRoot,
+        "artifact-id",
+        mockCondaPackage,
+        util.currentArch(),
+      );
+
+      // Verify directories were created
+      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 generate Dockerfile with correct content", () => {
+      const result = prepareDockerOptions(
+        mockLogger,
+        testPackageRoot,
+        "artifact-id",
+        mockCondaPackage,
+        util.currentArch(),
+      );
+
+      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);
+
+      const dockerfileContent = fs.readFileSync(result.dockerfile, "utf-8");
+
+      // Check essential Dockerfile components
+      expect(dockerfileContent).toContain(`FROM ${defaults.CONDA_DOCKER_BASE_IMAGE}`);
+      expect(dockerfileContent).toContain("COPY . /app");
+      expect(dockerfileContent).toContain("RUN micromamba");
+      expect(dockerfileContent).toContain(defaults.CONDA_FROZEN_ENV_SPEC_FILE);
+      expect(dockerfileContent).toContain(defaults.CONDA_DATA_LOCATION);
+    });
+  });
+});

package/src/core/__tests__/docker-entrypoint-generation.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { PackageInfo } from "../package-info";
+import type winston from "winston";
+
+// Mock winston logger
+const mockLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  debug: vi.fn(),
+  error: vi.fn(),
+} as unknown as winston.Logger;
+
+// Mock the docker-python module
+vi.mock("../docker-python", () => ({
+  prepareDockerOptions: vi.fn().mockReturnValue({
+    context: "/tmp/test-context",
+    dockerfile: "/tmp/test-dockerfile",
+    entrypoint: [],
+  }),
+}));
+
+describe("Docker Entrypoint Generation", () => {
+  let tempDir: string;
+  let testPackageRoot: string;
+
+  beforeEach(() => {
+    // Create temporary directories for testing
+    tempDir = fs.mkdtempSync(path.join("/tmp", "docker-entrypoint-test-"));
+    testPackageRoot = path.join(tempDir, "package");
+
+    fs.mkdirSync(testPackageRoot, { recursive: true });
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    // Clean up temporary directories
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  it("should generate Docker entrypoint for Python binary entrypoint", () => {
+    const packageJson = {
+      name: "test-python-package",
+      version: "1.0.0",
+      "block-software": {
+        entrypoints: {
+          script1: {
+            binary: {
+              artifact: {
+                type: "python",
+                environment: "@platforma-open/milaboratories.runenv-python-3:3.12.10",
+                root: "./src",
+                registry: "test-registry",
+              },
+              cmd: ["{pkg}/script1"],
+            },
+          },
+        },
+      },
+    };
+
+    fs.writeFileSync(
+      path.join(testPackageRoot, "package.json"),
+      JSON.stringify(packageJson, null, 2),
+    );
+
+    const packageInfo = new PackageInfo(mockLogger, { packageRoot: testPackageRoot });
+    const entrypoints = packageInfo.entrypoints;
+
+    expect(entrypoints.has("script1")).toBe(true);
+    expect(entrypoints.has("script1:docker")).toBe(true);
+
+    const dockerEntrypoint = entrypoints.get("script1:docker")!;
+    expect(dockerEntrypoint.type).toBe("software");
+    if (dockerEntrypoint.type === "software") {
+      expect(dockerEntrypoint.artifact.type).toBe("docker");
+      expect(dockerEntrypoint.cmd).toEqual(["{pkg}/script1"]);
+    }
+  });
+
+  it("should not generate Docker entrypoint for non-Python packages", () => {
+    const packageJson = {
+      name: "test-binary-package",
+      version: "1.0.0",
+      "block-software": {
+        entrypoints: {
+          script1: {
+            binary: {
+              artifact: {
+                type: "binary",
+                roots: {
+                  "linux-x64": "./src",
+                },
+                registry: "test-registry",
+              },
+              cmd: ["{pkg}/script1"],
+            },
+          },
+        },
+      },
+    };
+
+    fs.writeFileSync(
+      path.join(testPackageRoot, "package.json"),
+      JSON.stringify(packageJson, null, 2),
+    );
+
+    const packageInfo = new PackageInfo(mockLogger, { packageRoot: testPackageRoot });
+    const entrypoints = packageInfo.entrypoints;
+
+    expect(entrypoints.has("script1")).toBe(true);
+    expect(entrypoints.has("script1:docker")).toBe(false);
+  });
+});