buninu-linux 0.8.56 → 0.10.56

package/test/bootstrap.test.js

@@ -0,0 +1,65 @@
+// Run with Bun inside bunproot or the Buninu Linux VM.
+import { afterAll, expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+  assertAbsent, bootstrap, download, hasBuninuId, normalizeArch, options,
+} from "../initramfs/usr/lib/bootstrap/lib/common.js";
+
+const work = mkdtempSync(join(tmpdir(), "bootstrap-test-"));
+afterAll(() => rmSync(work, { recursive: true, force: true }));
+
+test("architecture aliases and optional destination", () => {
+  for (const alias of ["a", "arm64", "aarch64"]) {
+    expect(options([alias])).toEqual({ arch: "aarch64", rootfs: resolve("roota") });
+  }
+  for (const alias of ["x", "x64", "x86_64", "x86-64"]) {
+    expect(options([alias])).toEqual({ arch: "x86_64", rootfs: resolve("rootx") });
+  }
+  const arch = normalizeArch(process.arch);
+  expect(options([])).toEqual({ arch, rootfs: resolve(arch === "aarch64" ? "roota" : "rootx") });
+  expect(options(["./a path's root"])).toEqual({ arch, rootfs: resolve("./a path's root") });
+  expect(options(["x", "./custom"])).toEqual({ arch: "x86_64", rootfs: resolve("custom") });
+  expect(() => options(["--arch", "x"])).toThrow();
+  expect(() => options(["x", "one", "two"])).toThrow();
+  expect(() => normalizeArch("riscv64")).toThrow();
+});
+
+test("local mode requires the exact ID, never NAME or a substring", () => {
+  for (const value of ["buninu-linux", '"buninu-linux"', "'buninu-linux'"]) {
+    expect(hasBuninuId(`NAME="Buninu Linux"\nID=${value}\n`)).toBe(true);
+  }
+  for (const text of [
+    'NAME="Buninu Linux"\nID=alpine\n',
+    'ID_LIKE=buninu-linux\n', '# ID=buninu-linux\n',
+    'ID=buninu-linux-other\n', 'ID=buninu-linux\nID=alpine\n',
+    'ID="$(echo buninu-linux)"\n',
+  ]) expect(hasBuninuId(text)).toBe(false);
+});
+
+test("existing destinations, including dangling links, are refused", () => {
+  const file = join(work, "file"), link = join(work, "link");
+  writeFileSync(file, "keep me");
+  symlinkSync("missing", link);
+  expect(() => assertAbsent(file)).toThrow("Refusing existing destination");
+  expect(() => assertAbsent(link)).toThrow("Refusing existing destination");
+  expect(() => assertAbsent(join(work, "new"))).not.toThrow();
+  expect(readFileSync(file, "utf8")).toBe("keep me");
+});
+
+test("a corrupt cached tarball is rejected before extraction or refetch", async () => {
+  const old = process.env.XDG_CACHE_HOME;
+  process.env.XDG_CACHE_HOME = work;
+  try {
+    const [url, pin] = Bun.YAML.parse(readFileSync(join(bootstrap, "downloads.md"), "utf8"))["buninu-linux@0.9.56"];
+    const cache = join(work, "buninu-bootstrap");
+    mkdirSync(cache);
+    writeFileSync(join(cache, pin.slice(7) + "-" + new URL(url).pathname.split("/").at(-1)), "corrupt");
+    await expect(download("buninu-linux@0.9.56")).rejects.toThrow("Cached file hash mismatch");
+    await expect(download("unlisted@version")).rejects.toThrow("Missing or invalid download pin");
+  } finally {
+    if (old === undefined) delete process.env.XDG_CACHE_HOME;
+    else process.env.XDG_CACHE_HOME = old;
+  }
+});

package/test/tar-strip.test.js

@@ -216,3 +216,39 @@ test("does not follow a pre-existing symlink parent or an archive symlink parent
   expect(result.status).toBe(2);
   expect(existsSync(join(outside, "nested"))).toBe(false);
 });
+
+test("APK concatenated gzip/tar streams list and extract every section", () => {
+  const signature = tar([{ name: ".SIGN.test", data: "signature" }]);
+  const control = tar([{ name: ".PKGINFO", data: "pkgname = sample\n" }]);
+  const data = tar([
+    { name: "usr/include/stdio.h", data: "header\n" },
+    { name: "usr/lib/crt1.o", data: "object\n" },
+    { name: "usr/lib/link", type: "2", target: "crt1.o" },
+  ]);
+  // APK signature/control streams can omit end markers; also cover complete
+  // concatenated tar archives, and a single gzip stream containing them all.
+  for (const raw of [false, true]) {
+    const parts = [raw ? signature.subarray(0, -1024) : signature,
+      raw ? control.subarray(0, -1024) : control, data];
+    for (const bytes of [Buffer.concat(parts.map(p => Bun.gzipSync(p))), Bun.gzipSync(Buffer.concat(parts))]) {
+      const result = extract(bytes, [], true);
+      expect(result.status).toBe(0);
+      expect(readFileSync(join(result.dir, ".PKGINFO"), "utf8")).toBe("pkgname = sample\n");
+      expect(readFileSync(join(result.dir, "usr/include/stdio.h"), "utf8")).toBe("header\n");
+      expect(readlinkSync(join(result.dir, "usr/lib/link"))).toBe("crt1.o");
+      const listed = run(["-tf", "-"], bytes);
+      expect(listed.status).toBe(0);
+      expect(listed.stdout.trim().split("\n")).toEqual([
+        ".SIGN.test", ".PKGINFO", "usr/include/stdio.h", "usr/lib/crt1.o", "usr/lib/link",
+      ]);
+      const selected = extract(bytes, ["usr/include"], true);
+      expect(selected.status).toBe(0);
+      expect(existsSync(join(selected.dir, ".PKGINFO"))).toBe(false);
+      expect(readFileSync(join(selected.dir, "usr/include/stdio.h"), "utf8")).toBe("header\n");
+      const stripped = extract(bytes, ["--strip-components=2", "--exclude=usr/lib", "usr"], true);
+      expect(stripped.status).toBe(0);
+      expect(readFileSync(join(stripped.dir, "stdio.h"), "utf8")).toBe("header\n");
+      expect(existsSync(join(stripped.dir, "crt1.o"))).toBe(false);
+    }
+  }
+});