Integration test of builders

apps/cli/.gitignore

@@ -9,3 +9,4 @@ node_modules
 oclif.manifest.json
 src/contracts.ts
 src/graphql/
+test/builder/output

apps/cli/src/builder/directory.ts

@@ -57,6 +57,7 @@ export const build = async (
                     cwd: destination,
                     image: sdkImage,
                 });
+                break;
             }
         }
     } finally {

apps/cli/src/exec.ts

@@ -30,7 +30,6 @@
                     "--workdir",
                     "/work",
                     "--interactive",
-                    "--tty",
                     "--user",
                     `${userInfo.uid}:${userInfo.gid}`,
                 ];
@@ -62,7 +61,7 @@
 ) => {
     const result = spawnSync(command, args, options);
     if (result.error) {
         const code = (result.error as any).code;
         if (code === "ENOENT" && options.image) {
             console.warn(
                 `error executing '${command}', falling back to docker execution using image '${options.image}'`,

apps/cli/test/builder/data/Dockerfile

@@ -0,0 +1,5 @@
+FROM --platform=linux/riscv64 ubuntu:22.04 AS test
+ADD ./file2 .
+
+FROM --platform=linux/riscv64 ubuntu:22.04
+ADD ./file1 .

apps/cli/test/builder/data/Dockerfile.nonriscv

@@ -0,0 +1,2 @@
+FROM scratch
+ADD ./file1 .

apps/cli/test/builder/data/sample1/file1

@@ -0,0 +1 @@
+lorem ipsum

apps/cli/test/builder/data/sample1/file2

@@ -0,0 +1 @@
+lorem ipsum lorem ipsum

apps/cli/test/builder/directory.test.ts

@@ -0,0 +1,97 @@
+import fs from "fs-extra";
+import path from "path";
+import { describe, expect } from "vitest";
+import { build } from "../../src/builder/directory";
+import { DirectoryDriveConfig } from "../../src/config";
+import { tmpdirTest } from "./tmpdirTest";
+
+describe("when building with the directory builder", () => {
+    const image = "cartesi/sdk:0.11.0";
+
+    tmpdirTest(
+        "should fail when the directory doesn't exists",
+        async ({ tmpdir }) => {
+            const destination = tmpdir;
+            const drive: DirectoryDriveConfig = {
+                builder: "directory",
+                directory: path.join(__dirname, "data", "invalid"),
+                extraSize: 0,
+                format: "ext2",
+            };
+            await expect(
+                build("root", drive, image, destination),
+            ).rejects.toThrow("no such file or directory");
+        },
+    );
+
+    tmpdirTest(
+        "should fail when the directory is empty",
+        async ({ tmpdir }) => {
+            const destination = tmpdir;
+            const directory = path.join(__dirname, "data", "empty");
+            fs.ensureDirSync(directory);
+            const drive: DirectoryDriveConfig = {
+                builder: "directory",
+                directory,
+                extraSize: 0,
+                format: "ext2",
+            };
+            await expect(
+                build("root", drive, image, destination),
+            ).rejects.toThrow("too few blocks");
+        },
+    );
+
+    tmpdirTest(
+        "should pass when the directory is empty but extra size is defined",
+        async ({ tmpdir }) => {
+            const destination = tmpdir;
+            const directory = path.join(__dirname, "data", "empty");
+            fs.ensureDirSync(directory);
+            const drive: DirectoryDriveConfig = {
+                builder: "directory",
+                directory,
+                extraSize: 1024 * 1024, // 1Mb
+                format: "ext2",
+            };
+            await build("root", drive, image, destination);
+            const filename = path.join(destination, "root.ext2");
+            const stat = fs.statSync(filename);
+            expect(stat.size).toEqual(1069056);
+        },
+    );
+
+    tmpdirTest(
+        "should pass for a populated directory (ext2)",
+        async ({ tmpdir }) => {
+            const destination = tmpdir;
+            const drive: DirectoryDriveConfig = {
+                builder: "directory",
+                directory: path.join(__dirname, "data", "sample1"),
+                extraSize: 0,
+                format: "ext2",
+            };
+            await build("root", drive, image, destination);
+            const filename = path.join(destination, "root.ext2");
+            const stat = fs.statSync(filename);
+            expect(stat.size).toEqual(32768);
+        },
+    );
+
+    tmpdirTest(
+        "should pass for a populated directory (sqfs)",
+        async ({ tmpdir }) => {
+            const destination = tmpdir;
+            const drive: DirectoryDriveConfig = {
+                builder: "directory",
+                directory: path.join(__dirname, "data", "sample1"),
+                extraSize: 0,
+                format: "sqfs",
+            };
+            await build("root", drive, image, destination);
+            const filename = path.join(destination, "root.sqfs");
+            const stat = fs.statSync(filename);
+            expect(stat.size).toEqual(4096);
+        },
+    );
+});

apps/cli/test/builder/docker.test.ts

@@ -0,0 +1,106 @@
+import fs from "fs-extra";
+import { beforeEach } from "node:test";
+import path from "path";
+import { describe, expect } from "vitest";
+import { build } from "../../src/builder/docker";
+import { DockerDriveConfig } from "../../src/config";
+import { tmpdirTest } from "./tmpdirTest";
+
+describe("when building with the docker builder", () => {
+    const image = "cartesi/sdk:0.11.0";
+
+    beforeEach(({ name }) => {
+        fs.mkdirpSync(path.join(__dirname, "output", name));
+    });
+
+    tmpdirTest("should fail without correct context", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const drive: DockerDriveConfig = {
+            builder: "docker",
+            context: ".",
+            dockerfile: "Dockerfile",
+            extraSize: 0,
+            format: "ext2",
+            tags: [],
+            image: undefined,
+            target: undefined,
+        };
+        await expect(build("root", drive, image, destination)).rejects.toThrow(
+            "exit code 1",
+        );
+    });
+
+    tmpdirTest("should fail a non-riscv image", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const drive: DockerDriveConfig = {
+            builder: "docker",
+            context: path.join(__dirname, "data"),
+            dockerfile: path.join(__dirname, "data", "Dockerfile.nonriscv"),
+            extraSize: 0,
+            format: "ext2",
+            tags: [],
+            image: undefined,
+            target: undefined,
+        };
+        await expect(build("root", drive, image, destination)).rejects.toThrow(
+            "Expected riscv64",
+        );
+    });
+
+    tmpdirTest(
+        "should build an ext2 drive with a target definition",
+        async ({ tmpdir }) => {
+            const destination = tmpdir;
+            const drive: DockerDriveConfig = {
+                builder: "docker",
+                context: path.join(__dirname, "data"),
+                dockerfile: path.join(__dirname, "data", "Dockerfile"),
+                extraSize: 0,
+                format: "ext2",
+                tags: [],
+                image: undefined,
+                target: "test",
+            };
+            await build("root", drive, image, destination);
+            const filename = path.join(destination, "root.ext2");
+            const stat = fs.statSync(filename);
+            expect(stat.size).toEqual(76087296);
+        },
+    );
+
+    tmpdirTest("should build an ext2 drive", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const drive: DockerDriveConfig = {
+            builder: "docker",
+            context: path.join(__dirname, "data"),
+            dockerfile: path.join(__dirname, "data", "Dockerfile"),
+            extraSize: 0,
+            format: "ext2",
+            tags: [],
+            image: undefined,
+            target: undefined,
+        };
+        await build("root", drive, image, destination);
+        const filename = path.join(destination, "root.ext2");
+        const stat = fs.statSync(filename);
+        expect(stat.size).toEqual(76087296);
+    });
+
+    tmpdirTest.skip("should build a sqfs drive", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const drive: DockerDriveConfig = {
+            builder: "docker",
+            context: path.join(__dirname, "data"),
+            dockerfile: path.join(__dirname, "data", "Dockerfile"),
+            extraSize: 0,
+            format: "sqfs",
+            tags: [],
+            image: undefined,
+            target: undefined,
+        };
+        await build("root", drive, image, destination);
+        const filename = path.join(destination, "root.sqfs");
+        const stat = fs.statSync(filename);
+        expect(stat.size).toEqual(29327360);
+    });
+});

apps/cli/test/builder/empty.test.ts

@@ -0,0 +1,56 @@
+import fs from "fs-extra";
+import path from "path";
+import { describe, expect } from "vitest";
+import { build } from "../../src/builder/empty";
+import { EmptyDriveConfig } from "../../src/config";
+import { tmpdirTest } from "./tmpdirTest";
+
+describe("when building with the empty builder", () => {
+    const image = "cartesi/sdk:0.11.0";
+
+    tmpdirTest("should fail with an invalid size", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const drive: EmptyDriveConfig = {
+            builder: "empty",
+            format: "ext2",
+            size: 0,
+        };
+        await expect(build("root", drive, image, destination)).rejects.toThrow(
+            "too few blocks",
+        );
+    });
+
+    tmpdirTest("should pass and create ext2 drive", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const driveName = "root.ext2";
+        const drive: EmptyDriveConfig = {
+            builder: "empty",
+            format: "ext2",
+            size: 1024 * 1024 * 1, // 1Mb
+        };
+        await build("root", drive, image, destination);
+
+        const filename = path.join(destination, driveName);
+        expect(fs.existsSync(filename)).toBeTruthy();
+        const stat = await fs.stat(filename);
+        expect(stat.isFile()).toBeTruthy();
+        expect(stat.size).toEqual(1 * 1024 * 1024);
+    });
+
+    tmpdirTest("should pass and create raw drive", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const driveName = "root.raw";
+        const drive: EmptyDriveConfig = {
+            builder: "empty",
+            format: "raw",
+            size: 1024 * 1024 * 1, // 1Mb
+        };
+        await build("root", drive, image, destination);
+
+        const filename = path.join(destination, driveName);
+        expect(fs.existsSync(filename)).toBeTruthy();
+        const stat = await fs.stat(filename);
+        expect(stat.isFile()).toBeTruthy();
+        expect(stat.size).toEqual(1 * 1024 * 1024);
+    });
+});

apps/cli/test/builder/none.test.ts

@@ -0,0 +1,34 @@
+import fs from "fs-extra";
+import path from "path";
+import { describe, expect } from "vitest";
+import { build } from "../../src/builder/none";
+import { ExistingDriveConfig } from "../../src/config";
+import { tmpdirTest } from "./tmpdirTest";
+
+describe("when building with the none builder", () => {
+    tmpdirTest("should not build a missing file", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const drive: ExistingDriveConfig = {
+            builder: "none",
+            filename: path.join(__dirname, "data", "missing.ext2"),
+            format: "ext2",
+        };
+        await expect(build("root", drive, destination)).rejects.toThrow(
+            "no such file or directory",
+        );
+    });
+
+    tmpdirTest("should just copy an existing drive", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const filename = path.join(__dirname, "data", "data.ext2");
+        const drive: ExistingDriveConfig = {
+            builder: "none",
+            filename,
+            format: "ext2",
+        };
+        await build("root", drive, destination);
+        const src = fs.statSync(filename);
+        const dest = fs.statSync(path.join(destination, "root.ext2"));
+        expect(dest.size).toEqual(src.size);
+    });
+});

apps/cli/test/builder/tar.test.ts

@@ -0,0 +1,51 @@
+import fs from "fs-extra";
+import path from "path";
+import { describe, expect } from "vitest";
+import { build } from "../../src/builder/tar";
+import { TarDriveConfig } from "../../src/config";
+import { tmpdirTest } from "./tmpdirTest";
+
+describe("when building with the tar builder", () => {
+    const image = "cartesi/sdk:0.11.0";
+
+    tmpdirTest("should not build a missing file", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const drive: TarDriveConfig = {
+            builder: "tar",
+            filename: path.join(__dirname, "data", "unexisting.tar"),
+            extraSize: 0,
+            format: "ext2",
+        };
+        await expect(build("root", drive, image, destination)).rejects.toThrow(
+            "no such file or directory",
+        );
+    });
+
+    tmpdirTest("should build a ext2 drive", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const drive: TarDriveConfig = {
+            builder: "tar",
+            filename: path.join(__dirname, "data", "data.tar"),
+            extraSize: 0,
+            format: "ext2",
+        };
+        await build("root", drive, image, destination);
+        const filename = path.join(destination, "root.ext2");
+        const stat = fs.statSync(filename);
+        expect(stat.size).toEqual(36864);
+    });
+
+    tmpdirTest("should build a sqfs drive", async ({ tmpdir }) => {
+        const destination = tmpdir;
+        const drive: TarDriveConfig = {
+            builder: "tar",
+            filename: path.join(__dirname, "data", "data.tar"),
+            extraSize: 0,
+            format: "sqfs",
+        };
+        await build("root", drive, image, destination);
+        const filename = path.join(destination, "root.sqfs");
+        const stat = fs.statSync(filename);
+        expect(stat.size).toEqual(4096);
+    });
+});