"""Tests for ``blackcat dockerize`` (stdlib, offline, no daemon). Every subprocess is injected: the tests assert the exact argv that podman or docker would receive, the scaffold contents, the fingerprint rules and the user/ownership decisions, without touching a container runtime. """ # retoor import argparse import contextlib import io import json import subprocess import sys import tempfile import unittest from pathlib import Path from blackcat.cli import build_parser from blackcat.dockerize import ( BACKENDS, DEFAULT_CONTAINER, DEFAULT_IMAGE, FALLBACKS, FINGERPRINT_LABEL, SCAFFOLD_FILES, ContainerRuntime, DockerizeCommand, DockerizeError, DockerizeOptions, FallbackRuntime, build_command, build_context, build_files, bwrap_command, detect_backend, detect_runtime, ensure_scaffold, fallback_command, fallback_inner, fingerprint, hash_tree, image_is_current, local_command, proot_command, read_image_labels, resolve_options, rmi_command, run_command, stop_command, template_bytes, unshare_command, uses_host_user, validate_project, ) REPO = Path(__file__).resolve().parents[1] PODMAN = ContainerRuntime(name="podman", path="/usr/bin/podman", version="5.7.0", rootless=True) DOCKER = ContainerRuntime(name="docker", path="/usr/bin/docker", version="29.1.3") BWRAP = FallbackRuntime(name="bwrap", path="/usr/bin/bwrap", version="0.9.0") UNSHARE = FallbackRuntime(name="unshare", path="/usr/bin/unshare") PROOT = FallbackRuntime(name="proot", path="/usr/bin/proot") LOCAL = FallbackRuntime(name="local", path=sys.executable) def which_only(table): def which(name): return table.get(name) return which def which_every(name): return {"podman": "/usr/bin/podman", "docker": "/usr/bin/docker", "bwrap": "/usr/bin/bwrap", "unshare": "/usr/bin/unshare", "proot": "/usr/bin/proot"}.get(name) def make_args(**overrides): base = { "path": None, "runtime": "auto", "image": None, "name": None, "browser": False, "context": "minimal", "rebuild": False, "pull": False, "build_only": False, "no_scaffold": False, "force": False, "shell": False, "entrypoint": None, "user": "auto", "keep": False, "stop": False, "rm_image": False, "dry_run": False, "args": [], "verbose": 0, "quiet": 0, "log_level": None, "log_file": None, } base.update(overrides) return argparse.Namespace(**base) def make_opts(root, **overrides): base = { "root": root, "dockerized": root / "dockerized", "image": DEFAULT_IMAGE, "name": DEFAULT_CONTAINER, "runtime_requested": "auto", "context": "minimal", "browser": False, "rebuild": False, "pull": False, "build_only": False, "scaffold": True, "force": False, "shell": False, "entrypoint": None, "user_mode": "auto", "keep": False, "stop": False, "rmi": False, "dry_run": False, "args": (), "uid": 1000, "gid": 1000, "platform": "linux", "selinux": False, "tty": True, "term": "xterm-256color", "colorterm": None, "quiet": False, } base.update(overrides) return DockerizeOptions(**base) def make_project(base: Path) -> Path: root = base / "proj" (root / "blackcat").mkdir(parents=True) (root / "blackcat" / "__init__.py").write_text("") (root / "pyproject.toml").write_text( (REPO / "pyproject.toml").read_text()) (root / "README.md").write_text("# proj\n") return root def which_all(name): return {"podman": "/usr/bin/podman", "docker": "/usr/bin/docker"}.get( name) class Recorder: """Records argv, returning canned capture results and stream codes.""" def __init__(self, results=None, stream_codes=None, default_stream=0): self.calls = [] self.results = results or {} self.stream_codes = stream_codes or {} self.default_stream = default_stream self.stream_calls = [] def capture(self, command): cmd = list(command) self.calls.append(cmd) for needle, result in self.results.items(): if needle in cmd: return result return subprocess.CompletedProcess(cmd, 0, "", "") def stream(self, command): cmd = list(command) self.stream_calls.append(cmd) for needle, code in self.stream_codes.items(): if needle in cmd: return code return self.default_stream def labels_result(payload, rc=0): stdout = payload if isinstance(payload, str) else json.dumps(payload) return subprocess.CompletedProcess([], rc, stdout, "") class TestParser(unittest.TestCase): def test_defaults(self): args = build_parser().parse_args(["dockerize"]) self.assertEqual(args.command, "dockerize") self.assertEqual(args.runtime, "auto") self.assertEqual(args.context, "minimal") self.assertEqual(args.user, "auto") self.assertEqual(args.args, []) self.assertFalse(args.dry_run) def test_every_flag_parses(self): args = build_parser().parse_args([ "dockerize", "--path", "/tmp/x", "--runtime", "docker", "--image", "img:1", "--name", "box", "--browser", "--context", "project", "--rebuild", "--pull", "--build-only", "--no-scaffold", "--force", "--shell", "--entrypoint", "/bin/sh", "--user", "root", "--keep", "--stop", "--rm-image", "--dry-run"]) self.assertEqual((args.image, args.name), ("img:1", "box")) self.assertTrue(args.browser and args.rebuild and args.pull) self.assertTrue(args.build_only and args.no_scaffold and args.force) self.assertTrue(args.shell and args.keep and args.stop) self.assertTrue(args.rm_image and args.dry_run) self.assertEqual(args.entrypoint, "/bin/sh") def test_passthrough_needs_double_dash(self): args = build_parser().parse_args( ["dockerize", "--", "--provider", "echo", "tui"]) self.assertEqual(args.args, ["--", "--provider", "echo", "tui"]) def test_every_backend_parses(self): for backend in ("auto", "podman", "docker", "bwrap", "unshare", "proot", "local"): with self.subTest(backend=backend): args = build_parser().parse_args( ["dockerize", "--runtime", backend]) self.assertEqual(args.runtime, backend) self.assertEqual( BACKENDS, ("podman", "docker", "bwrap", "unshare", "proot", "local")) def test_typo_is_rejected(self): with self.assertRaises(SystemExit) as caught: with contextlib.redirect_stderr(io.StringIO()): build_parser().parse_args(["dockerize", "--rebuild-x"]) self.assertEqual(caught.exception.code, 2) class TestTemplates(unittest.TestCase): def test_every_asset_readable(self): for name in SCAFFOLD_FILES: data = template_bytes(name) self.assertTrue(data, name) self.assertIn(b"\n", data, name) def test_generated_scaffold_matches_templates(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) ensure_scaffold(make_opts(root)) for name in SCAFFOLD_FILES: with self.subTest(name=name): target = root / "dockerized" / name self.assertTrue(target.is_file(), target) self.assertEqual(target.read_bytes(), template_bytes(name)) def test_gitignore_covers_the_generated_folder_only(self): lines = [line.strip() for line in (REPO / ".gitignore").read_text().splitlines()] self.assertIn("/dockerized/", lines) self.assertNotIn("dockerized/", lines) self.assertNotIn("dockerized", lines) def test_package_data_declared(self): text = (REPO / "pyproject.toml").read_text() self.assertIn('blackcat = ["templates/dockerized/*"]', text) def test_missing_asset_names_itself(self): with self.assertRaises(DockerizeError) as caught: template_bytes("nope.txt") self.assertIn("nope.txt", str(caught.exception)) class TestResolveOptions(unittest.TestCase): def test_relative_path_is_resolved(self): with tempfile.TemporaryDirectory() as tmp: opts = resolve_options( make_args(path="sub"), environ={}, cwd=Path(tmp), platform="linux", tty=False, selinux=False, ids=(1, 2)) self.assertTrue(opts.root.is_absolute()) self.assertEqual(opts.root, (Path(tmp) / "sub").resolve()) self.assertEqual(opts.dockerized, opts.root / "dockerized") self.assertEqual((opts.uid, opts.gid), (1, 2)) def test_env_fallbacks(self): environ = { "BLACKCAT_CONTAINER_RUNTIME": "docker", "BLACKCAT_CONTAINER_IMAGE": "env:1", "BLACKCAT_CONTAINER_NAME": "env-box", "TERM": "screen-256color", "COLORTERM": "truecolor", } with tempfile.TemporaryDirectory() as tmp: opts = resolve_options(make_args(), environ=environ, cwd=Path(tmp), platform="linux", tty=False, selinux=False, ids=(0, 0)) self.assertEqual(opts.runtime_requested, "docker") self.assertEqual(opts.image, "env:1") self.assertEqual(opts.name, "env-box") self.assertEqual(opts.term, "screen-256color") self.assertEqual(opts.colorterm, "truecolor") def test_flags_beat_env(self): environ = {"BLACKCAT_CONTAINER_RUNTIME": "docker", "BLACKCAT_CONTAINER_IMAGE": "env:1"} with tempfile.TemporaryDirectory() as tmp: opts = resolve_options( make_args(runtime="podman", image="flag:1"), environ=environ, cwd=Path(tmp), platform="linux", tty=False, selinux=False, ids=(0, 0)) self.assertEqual(opts.runtime_requested, "podman") self.assertEqual(opts.image, "flag:1") def test_empty_env_falls_back_to_defaults(self): with tempfile.TemporaryDirectory() as tmp: opts = resolve_options( make_args(), environ={"BLACKCAT_CONTAINER_IMAGE": ""}, cwd=Path(tmp), platform="linux", tty=False, selinux=False, ids=(0, 0)) self.assertEqual(opts.image, DEFAULT_IMAGE) self.assertEqual(opts.name, DEFAULT_CONTAINER) self.assertEqual(opts.term, "xterm-256color") self.assertIsNone(opts.colorterm) def test_windows_is_refused(self): with tempfile.TemporaryDirectory() as tmp: with self.assertRaises(DockerizeError) as caught: resolve_options(make_args(), environ={}, cwd=Path(tmp), platform="win32", tty=False, selinux=False, ids=(0, 0)) self.assertIn("WSL", str(caught.exception)) def test_leading_double_dash_stripped(self): with tempfile.TemporaryDirectory() as tmp: opts = resolve_options( make_args(args=["--", "--provider", "echo"]), environ={}, cwd=Path(tmp), platform="linux", tty=False, selinux=False, ids=(0, 0)) self.assertEqual(opts.args, ("--provider", "echo")) def test_negated_flags(self): with tempfile.TemporaryDirectory() as tmp: opts = resolve_options( make_args(no_scaffold=True, quiet=2, user="root"), environ={}, cwd=Path(tmp), platform="linux", tty=False, selinux=False, ids=(0, 0)) self.assertFalse(opts.scaffold) self.assertTrue(opts.quiet) self.assertEqual(opts.user_mode, "root") class TestScaffold(unittest.TestCase): def test_creates_everything(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) written, kept = ensure_scaffold(make_opts(root)) self.assertEqual(sorted(written), sorted(SCAFFOLD_FILES)) self.assertEqual(kept, []) for name in SCAFFOLD_FILES: self.assertTrue((root / "dockerized" / name).is_file()) entry = root / "dockerized" / "entrypoint.sh" self.assertEqual(entry.stat().st_mode & 0o777, 0o755) def test_second_call_keeps_all(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) opts = make_opts(root) ensure_scaffold(opts) written, kept = ensure_scaffold(opts) self.assertEqual(written, []) self.assertEqual(sorted(kept), sorted(SCAFFOLD_FILES)) def test_edited_file_is_kept_without_force(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) opts = make_opts(root) ensure_scaffold(opts) target = root / "dockerized" / "Dockerfile" target.write_text("FROM scratch\n") written, kept = ensure_scaffold(opts) self.assertNotIn("Dockerfile", written) self.assertIn("Dockerfile", kept) self.assertEqual(target.read_text(), "FROM scratch\n") def test_force_rewrites(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) ensure_scaffold(make_opts(root)) target = root / "dockerized" / "Dockerfile" target.write_text("FROM scratch\n") written, _ = ensure_scaffold(make_opts(root, force=True)) self.assertIn("Dockerfile", written) self.assertEqual(target.read_bytes(), template_bytes("Dockerfile")) def test_no_scaffold_writes_nothing(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) written, kept = ensure_scaffold(make_opts(root, scaffold=False)) self.assertEqual((written, kept), ([], [])) self.assertFalse((root / "dockerized").exists()) def test_dry_run_touches_nothing(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) written, _ = ensure_scaffold(make_opts(root), dry_run=True) self.assertEqual(sorted(written), sorted(SCAFFOLD_FILES)) self.assertFalse((root / "dockerized").exists()) def test_dockerized_as_file_raises(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) (root / "dockerized").write_text("not a dir") with self.assertRaises(DockerizeError): ensure_scaffold(make_opts(root)) class TestFingerprint(unittest.TestCase): def setUp(self): self.tmp = tempfile.TemporaryDirectory() self.addCleanup(self.tmp.cleanup) self.root = make_project(Path(self.tmp.name)) self.opts = make_opts(self.root) ensure_scaffold(self.opts) def test_stable(self): self.assertEqual(fingerprint(self.opts), fingerprint(self.opts)) def test_dockerfile_change(self): before = fingerprint(self.opts) dockerfile = self.root / "dockerized" / "Dockerfile" dockerfile.write_bytes(dockerfile.read_bytes() + b"# edit\n") self.assertNotEqual(before, fingerprint(self.opts)) def test_pyproject_change(self): before = fingerprint(self.opts) pyproject = self.root / "pyproject.toml" pyproject.write_text(pyproject.read_text() + "\n") self.assertNotEqual(before, fingerprint(self.opts)) def test_browser_toggle(self): before = fingerprint(self.opts) after = fingerprint(make_opts(self.root, browser=True)) self.assertNotEqual(before, after) def test_context_toggle(self): before = fingerprint(self.opts) after = fingerprint(make_opts(self.root, context="project")) self.assertNotEqual(before, after) def test_minimal_context_ignores_source(self): before = fingerprint(self.opts) (self.root / "notes.md").write_text("research\n") self.assertEqual(before, fingerprint(self.opts)) def test_project_context_tracks_source(self): opts = make_opts(self.root, context="project") before = fingerprint(opts) (self.root / "notes.md").write_text("research\n") self.assertNotEqual(before, fingerprint(opts)) def test_hash_tree_skips_host_artifacts(self): before = hash_tree(self.root) for name in (".git/objects/x", ".venv/lib/y", "__pycache__/z.pyc"): path = self.root / name path.parent.mkdir(parents=True, exist_ok=True) path.write_text("junk") self.assertEqual(before, hash_tree(self.root)) (self.root / "real.py").write_text("x = 1\n") self.assertNotEqual(before, hash_tree(self.root)) class TestRuntimeDetection(unittest.TestCase): def test_prefers_podman(self): runtime = detect_runtime("auto", environ={}, which=which_all, probe=lambda n, p: ContainerRuntime(n, p)) self.assertEqual(runtime.name, "podman") def test_falls_back_to_docker(self): calls = [] def probe(name, path): calls.append(name) return ContainerRuntime(name, path) if name == "docker" else None runtime = detect_runtime("auto", environ={}, which=which_all, probe=probe) self.assertEqual(runtime.name, "docker") self.assertEqual(calls, ["podman", "docker"]) def test_env_selects_runtime(self): runtime = detect_runtime( "auto", environ={"BLACKCAT_CONTAINER_RUNTIME": "docker"}, which=which_all, probe=lambda n, p: ContainerRuntime(n, p)) self.assertEqual(runtime.name, "docker") def test_flag_beats_env(self): runtime = detect_runtime( "podman", environ={"BLACKCAT_CONTAINER_RUNTIME": "docker"}, which=which_all, probe=lambda n, p: ContainerRuntime(n, p)) self.assertEqual(runtime.name, "podman") def test_no_runtime_raises_with_hint(self): with self.assertRaises(DockerizeError) as caught: detect_runtime("auto", environ={}, which=lambda name: None) message = str(caught.exception) self.assertIn("podman", message) self.assertIn("docker", message) self.assertIn("BLACKCAT_CONTAINER_RUNTIME", message) def test_unknown_runtime_raises(self): with self.assertRaises(DockerizeError): detect_runtime("lxc", environ={}, which=which_all) def fallback_ok(name, path): return FallbackRuntime(name=name, path=path) class TestDetectBackend(unittest.TestCase): def test_chain_order(self): self.assertEqual(FALLBACKS, ("bwrap", "unshare", "proot", "local")) self.assertEqual(BACKENDS, ("podman", "docker") + FALLBACKS) def test_auto_prefers_podman(self): backend = detect_backend( "auto", environ={}, which=which_all, probe=lambda n, p: ContainerRuntime(n, p), fallback_probe=fallback_ok) self.assertIsInstance(backend, ContainerRuntime) self.assertEqual(backend.name, "podman") def test_auto_skips_dead_engines_for_bwrap(self): backend = detect_backend( "auto", environ={}, which=which_every, probe=lambda n, p: None, fallback_probe=fallback_ok) self.assertIsInstance(backend, FallbackRuntime) self.assertEqual(backend.name, "bwrap") def test_auto_skips_missing_binaries(self): backend = detect_backend( "auto", environ={}, which=which_only({"unshare": "/u/unshare"}), probe=lambda n, p: None, fallback_probe=fallback_ok) self.assertEqual(backend.name, "unshare") def test_auto_skips_broken_userns(self): def probe(name, path): return None if name == "unshare" else fallback_ok(name, path) backend = detect_backend( "auto", environ={}, which=which_only({"unshare": "/u/unshare", "proot": "/u/proot"}), probe=lambda n, p: None, fallback_probe=probe) self.assertEqual(backend.name, "proot") def test_auto_ends_at_local(self): backend = detect_backend( "auto", environ={}, which=lambda name: None, probe=lambda n, p: None, fallback_probe=lambda n, p: None) self.assertIsInstance(backend, FallbackRuntime) self.assertEqual(backend.name, "local") self.assertTrue(backend.is_local) def test_local_needs_no_binary(self): backend = detect_backend("local", environ={}, which=lambda name: None) self.assertEqual(backend.name, "local") self.assertTrue(backend.is_local) def test_explicit_bwrap_resolves(self): backend = detect_backend( "bwrap", environ={}, which=which_every, fallback_probe=fallback_ok) self.assertEqual((backend.name, backend.path), ("bwrap", "/usr/bin/bwrap")) def test_explicit_container_missing_errors(self): with self.assertRaises(DockerizeError) as caught: detect_backend("podman", environ={}, which=lambda name: None) self.assertIn("podman", str(caught.exception)) self.assertIn("auto", str(caught.exception)) def test_explicit_fallback_missing_errors(self): with self.assertRaises(DockerizeError) as caught: detect_backend("bwrap", environ={}, which=lambda name: None, fallback_probe=fallback_ok) self.assertIn("bwrap", str(caught.exception)) def test_explicit_fallback_broken_errors(self): with self.assertRaises(DockerizeError): detect_backend("bwrap", environ={}, which=which_all, fallback_probe=lambda n, p: None) def test_unknown_backend_raises(self): with self.assertRaises(DockerizeError): detect_backend("lxc", environ={}, which=which_all) def test_env_selects_backend(self): backend = detect_backend( "auto", environ={"BLACKCAT_CONTAINER_RUNTIME": "proot"}, which=which_every, fallback_probe=fallback_ok) self.assertEqual(backend.name, "proot") def test_flag_beats_env(self): backend = detect_backend( "unshare", environ={"BLACKCAT_CONTAINER_RUNTIME": "docker"}, which=which_every, fallback_probe=fallback_ok) self.assertEqual(backend.name, "unshare") class TestFallbackCommands(unittest.TestCase): def opts(self, root, **overrides): return make_opts(root, **overrides) def test_local_runs_host_python(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() command = local_command(self.opts(root)) self.assertEqual(command[:2], ["env", f"PYTHONPATH={root}"]) self.assertEqual(command[2:], [sys.executable, "-m", "blackcat", "--yolo", "tui"]) def test_local_passthrough(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() opts = self.opts(root, args=("--provider", "echo", "tui")) command = local_command(opts) self.assertEqual(command[-3:], ["--provider", "echo", "tui"]) def test_local_shell_and_entrypoint(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() shell = local_command(self.opts(root, shell=True)) self.assertIn("/bin/bash", shell) custom = local_command(self.opts(root, shell=True, entrypoint="/bin/sh")) self.assertIn("/bin/sh", custom) self.assertNotIn("/bin/bash", custom) def test_bwrap_binds_and_isolates(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() command = bwrap_command(BWRAP, self.opts(root)) self.assertEqual(command[0], "/usr/bin/bwrap") self.assertIn("--unshare-pid", command) self.assertNotIn("--unshare-net", command) self.assertIn("--bind", command) self.assertIn(str(root), command) self.assertIn("--chdir", command) self.assertEqual(command[command.index("--chdir") + 1], str(root)) self.assertIn("--setenv", command) self.assertIn("PYTHONPATH", command) self.assertIn(str(root), command) self.assertEqual(command[-5:], [sys.executable, "-m", "blackcat", "--yolo", "tui"]) def test_bwrap_binds_outside_venv(self): home = Path(sys.prefix) root = home / "proj" command = bwrap_command(BWRAP, self.opts(root)) self.assertIn(str(home), command) self.assertIn("--bind", command) def test_bwrap_skips_venv_inside_project(self): root = Path(sys.prefix).parent command = bwrap_command(BWRAP, self.opts(root)) self.assertEqual(command.count("--bind"), 1) def test_unshare_maps_root_user(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() command = unshare_command(UNSHARE, self.opts(root)) self.assertEqual(command[:3], ["/usr/bin/unshare", "--map-root-user", "--mount"]) for flag in ("--uts", "--ipc", "--pid", "--fork", "--mount-proc"): self.assertIn(flag, command) self.assertNotIn("--net", command) self.assertEqual(command[command.index("--wd") + 1], str(root)) self.assertIn(f"PYTHONPATH={root}", command) self.assertEqual(command[-2:], ["--yolo", "tui"]) self.assertIn(sys.executable, command) def test_proot_mounts_app(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() command = proot_command(PROOT, self.opts(root)) self.assertEqual(command[:2], ["/usr/bin/proot", "-b"]) self.assertIn(f"{root}:/app", command) self.assertEqual(command[command.index("-w") + 1], "/app") self.assertIn("PYTHONPATH=/app", command) self.assertEqual(command[-2:], ["--yolo", "tui"]) def test_dispatcher_matches_builders(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() opts = self.opts(root) self.assertEqual(fallback_command(BWRAP, opts), bwrap_command(BWRAP, opts)) self.assertEqual(fallback_command(UNSHARE, opts), unshare_command(UNSHARE, opts)) self.assertEqual(fallback_command(PROOT, opts), proot_command(PROOT, opts)) self.assertEqual(fallback_command(LOCAL, opts), local_command(opts)) def test_fallback_inner_defaults(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() inner = fallback_inner(self.opts(root)) self.assertEqual(inner, [sys.executable, "-m", "blackcat", "--yolo", "tui"]) class TestImageInspection(unittest.TestCase): def test_labels_parsed(self): runtime = PODMAN labels = read_image_labels( runtime, "img", capture=lambda cmd: labels_result( {"org.blackcat.fingerprint": "abc"})) self.assertEqual(labels, {"org.blackcat.fingerprint": "abc"}) def test_null_labels(self): labels = read_image_labels( PODMAN, "img", capture=lambda cmd: labels_result("null")) self.assertEqual(labels, {}) def test_missing_image(self): labels = read_image_labels( PODMAN, "img", capture=lambda cmd: subprocess.CompletedProcess([], 1, "", "no")) self.assertIsNone(labels) def test_malformed_json(self): labels = read_image_labels( PODMAN, "img", capture=lambda cmd: labels_result("{not json")) self.assertIsNone(labels) def test_non_dict_labels(self): labels = read_image_labels( PODMAN, "img", capture=lambda cmd: labels_result("[]")) self.assertIsNone(labels) def test_current_matching(self): digest = "a" * 64 self.assertTrue(image_is_current({FINGERPRINT_LABEL: digest}, digest)) self.assertFalse(image_is_current({FINGERPRINT_LABEL: digest}, "b")) self.assertFalse(image_is_current(None, digest)) def test_argv_is_inspect_never_exists(self): seen = [] def capture(command): seen.append(list(command)) return labels_result("{}") read_image_labels(DOCKER, "img:1", capture=capture) self.assertEqual(seen[0][:4], ["/usr/bin/docker", "image", "inspect", "--format"]) self.assertNotIn("exists", seen[0]) class TestBuild(unittest.TestCase): def test_minimal_context_contents_and_cleanup(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) opts = make_opts(root) ensure_scaffold(opts) with build_context(opts) as context: names = sorted(path.name for path in context.iterdir()) self.assertEqual(names, ["Dockerfile", "README.md", "entrypoint.sh", "pyproject.toml"]) entry = context / "entrypoint.sh" self.assertEqual(entry.stat().st_mode & 0o777, 0o755) captured = context self.assertFalse(captured.exists()) def test_user_dockerfile_wins(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) opts = make_opts(root) ensure_scaffold(opts) (root / "dockerized" / "Dockerfile").write_text("FROM scratch\n") with build_context(opts) as context: self.assertEqual((context / "Dockerfile").read_text(), "FROM scratch\n") def test_context_cleaned_up_on_error(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) opts = make_opts(root) ensure_scaffold(opts) with self.assertRaises(RuntimeError): with build_context(opts) as context: captured = context raise RuntimeError("boom") self.assertFalse(captured.exists()) def test_minimal_argv(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) opts = make_opts(root) ensure_scaffold(opts) ensure_scaffold(opts, dry_run=False) with build_context(opts) as context: command = build_command(PODMAN, opts, context, "d" * 64) self.assertEqual(command[:2], ["/usr/bin/podman", "build"]) self.assertEqual(command[command.index("-t") + 1], DEFAULT_IMAGE) self.assertEqual(command[command.index("--label") + 1], f"{FINGERPRINT_LABEL}={'d' * 64}") self.assertEqual(command[command.index("--build-arg") + 1], "WITH_BROWSER=0") self.assertEqual(command[-1], str(context)) def test_argv_upgrades(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) opts = make_opts(root, rebuild=True, pull=True, browser=True) ensure_scaffold(opts) with build_context(opts) as context: command = build_command(PODMAN, opts, context, "d") self.assertIn("--no-cache", command) self.assertIn("--pull", command) self.assertIn("WITH_BROWSER=1", command) def test_no_ignorefile_or_layers(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) opts = make_opts(root) ensure_scaffold(opts) with build_context(opts) as context: command = build_command(DOCKER, opts, context, "d") joined = " ".join(command) self.assertNotIn("ignorefile", joined) self.assertNotIn("--layers", joined) def test_project_context_argv(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) opts = make_opts(root, context="project") ensure_scaffold(opts) command = build_command(DOCKER, opts, root, "d") self.assertEqual(command[command.index("-f") + 1], str(root / "dockerized" / "Dockerfile")) self.assertEqual(command[-1], str(root)) def test_build_files_shape(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) opts = make_opts(root) ensure_scaffold(opts) files = build_files(opts) self.assertEqual(sorted(files), ["Dockerfile", "README.md", "entrypoint.sh", "pyproject.toml"]) class TestRun(unittest.TestCase): def command(self, runtime=PODMAN, **overrides): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() opts = make_opts(root, **overrides) return run_command(runtime, opts), opts def test_podman_mapping(self): command, opts = self.command() self.assertIn("--userns=keep-id", command) self.assertNotIn("--user", command) self.assertIn("HOME=/tmp", command) self.assertIn(f"{opts.root}:/app", command) def test_docker_mapping(self): command, _ = self.command(runtime=DOCKER) self.assertIn("--user", command) self.assertIn("1000:1000", command) self.assertNotIn("--userns=keep-id", command) self.assertIn("HOME=/tmp", command) def test_root_needs_no_mapping(self): command, _ = self.command(uid=0, gid=0) self.assertNotIn("--userns=keep-id", command) self.assertNotIn("--user", command) self.assertNotIn("HOME=/tmp", command) def test_user_root_disables_mapping(self): command, _ = self.command(user_mode="root") self.assertNotIn("--userns=keep-id", command) self.assertNotIn("HOME=/tmp", command) def test_darwin_has_no_mapping(self): command, _ = self.command(platform="darwin", uid=501, gid=20) self.assertNotIn("--userns=keep-id", command) self.assertNotIn("--user", command) def test_user_host_forces_mapping(self): command, _ = self.command(platform="darwin", uid=501, gid=20, user_mode="host") self.assertIn("--userns=keep-id", command) def test_selinux_suffix(self): command, opts = self.command(selinux=True) self.assertIn(f"{opts.root}:/app:z", command) def test_tty_variants(self): command, _ = self.command(tty=True) self.assertIn("-i", command) self.assertIn("-t", command) command, _ = self.command(tty=False) self.assertIn("-i", command) self.assertNotIn("-t", command) def test_keep_drops_rm(self): command, _ = self.command(keep=True) self.assertNotIn("--rm", command) command, _ = self.command() self.assertIn("--rm", command) def test_shell_and_entrypoint(self): command, _ = self.command(shell=True) self.assertEqual(command[command.index("--entrypoint") + 1], "/bin/bash") command, _ = self.command(shell=True, entrypoint="/bin/sh") self.assertEqual(command[command.index("--entrypoint") + 1], "/bin/sh") def test_default_command_and_passthrough(self): command, _ = self.command() self.assertEqual(command[-2:], ["--yolo", "tui"]) command, _ = self.command(args=("--provider", "echo", "tui")) self.assertEqual(command[-3:], ["--provider", "echo", "tui"]) def test_always_init_pull_name_workdir(self): command, _ = self.command() for flag in ("--init", "--pull=never"): self.assertIn(flag, command) self.assertEqual(command[command.index("--name") + 1], DEFAULT_CONTAINER) self.assertEqual(command[command.index("--workdir") + 1], "/app") def test_stop_and_rmi_commands(self): self.assertEqual(stop_command(PODMAN, "box"), ["/usr/bin/podman", "rm", "-f", "box"]) self.assertEqual(rmi_command(DOCKER, "img:1"), ["/usr/bin/docker", "rmi", "-f", "img:1"]) def test_uses_host_user_rules(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)) self.assertTrue(uses_host_user(make_opts(root))) self.assertFalse(uses_host_user(make_opts(root, uid=0))) self.assertFalse(uses_host_user(make_opts(root, user_mode="root"))) self.assertFalse(uses_host_user(make_opts(root, platform="darwin"))) self.assertTrue(uses_host_user(make_opts(root, platform="darwin", user_mode="host"))) class TestValidate(unittest.TestCase): def test_accepts_checkout(self): with tempfile.TemporaryDirectory() as tmp: validate_project(make_opts(make_project(Path(tmp)))) def test_missing_markers(self): with tempfile.TemporaryDirectory() as tmp: root = Path(tmp) / "empty" root.mkdir() with self.assertRaises(DockerizeError) as caught: validate_project(make_opts(root)) self.assertIn("pyproject.toml", str(caught.exception)) (root / "pyproject.toml").write_text("") with self.assertRaises(DockerizeError) as caught: validate_project(make_opts(root)) self.assertIn("blackcat/__init__.py", str(caught.exception)) class TestCommand(unittest.TestCase): def build(self, tmp, recorder, **arg_overrides): root = make_project(Path(tmp)).resolve() args = make_args(path=str(root), **arg_overrides) command = DockerizeCommand( args, capture=recorder.capture, stream=recorder.stream, environ={}, cwd=root, platform="linux", tty=True, selinux=False, ids=(1000, 1000), which=which_all, probe=lambda name, path: ContainerRuntime(name, path, "9.9")) return command, root def current_labels(self, root): opts = make_opts(root) ensure_scaffold(opts) return {FINGERPRINT_LABEL: fingerprint(opts)} def test_full_flow_builds_then_runs(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(results={"inspect": labels_result("", 1)}) command, root = self.build(tmp, recorder) with contextlib.redirect_stderr(io.StringIO()): code = command.run() self.assertEqual(code, 0) self.assertEqual(len(recorder.stream_calls), 2) self.assertIn("build", recorder.stream_calls[0]) self.assertIn("run", recorder.stream_calls[1]) self.assertTrue((root / "dockerized" / "Dockerfile").is_file()) self.assertEqual( recorder.stream_calls[0][recorder.stream_calls[0].index( "--label") + 1].split("=")[0], FINGERPRINT_LABEL) def test_current_image_skips_build(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() labels = self.current_labels(root) recorder = Recorder(results={"inspect": labels_result(labels)}) args = make_args(path=str(root)) command = DockerizeCommand( args, capture=recorder.capture, stream=recorder.stream, environ={}, cwd=root, platform="linux", tty=True, selinux=False, ids=(1000, 1000), which=which_all, probe=lambda name, path: ContainerRuntime(name, path)) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 0) self.assertEqual(len(recorder.stream_calls), 1) self.assertIn("is current", err.getvalue()) def test_stale_image_rebuilds(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(results={ "inspect": labels_result({FINGERPRINT_LABEL: "old"})}) command, _ = self.build(tmp, recorder) with contextlib.redirect_stderr(io.StringIO()) as err: command.run() self.assertEqual(len(recorder.stream_calls), 2) self.assertIn("stale", err.getvalue()) def test_rebuild_forces_build_even_when_current(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() labels = self.current_labels(root) recorder = Recorder(results={"inspect": labels_result(labels)}) args = make_args(path=str(root), rebuild=True) command = DockerizeCommand( args, capture=recorder.capture, stream=recorder.stream, environ={}, cwd=root, platform="linux", tty=True, selinux=False, ids=(1000, 1000), which=which_all, probe=lambda name, path: ContainerRuntime(name, path)) with contextlib.redirect_stderr(io.StringIO()): command.run() self.assertIn("--no-cache", recorder.stream_calls[0]) def test_build_only_does_not_run(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(results={"inspect": labels_result("", 1)}) command, _ = self.build(tmp, recorder, build_only=True) with contextlib.redirect_stderr(io.StringIO()): code = command.run() self.assertEqual(code, 0) self.assertEqual(len(recorder.stream_calls), 1) self.assertIn("build", recorder.stream_calls[0]) def test_build_failure_is_exit_two(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(results={"inspect": labels_result("", 1)}, stream_codes={"build": 3}) command, _ = self.build(tmp, recorder) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 2) self.assertIn("build failed", err.getvalue()) def test_stop_action(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(results={ "rm": subprocess.CompletedProcess([], 0, "", "")}) command, _ = self.build(tmp, recorder, stop=True) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 0) self.assertEqual(recorder.stream_calls, []) self.assertIn("removed container", err.getvalue()) def test_stop_missing_container_is_fine(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(results={ "rm": subprocess.CompletedProcess([], 1, "", "no such")}) command, _ = self.build(tmp, recorder, stop=True) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 0) self.assertIn("nothing to remove", err.getvalue()) def test_rm_image_failure_is_exit_two(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(results={ "rmi": subprocess.CompletedProcess([], 1, "", "in use")}) command, _ = self.build(tmp, recorder, rm_image=True) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 2) self.assertIn("rmi failed", err.getvalue()) def test_dry_run_executes_nothing(self): with tempfile.TemporaryDirectory() as tmp: def boom(*args, **kwargs): raise AssertionError("dry run executed a command") recorder = Recorder() recorder.capture = boom recorder.stream = boom command, root = self.build(tmp, recorder, dry_run=True) with contextlib.redirect_stderr(io.StringIO()): with contextlib.redirect_stdout(io.StringIO()) as out: code = command.run() self.assertEqual(code, 0) self.assertFalse((root / "dockerized").exists()) self.assertIn("build", out.getvalue()) self.assertIn("run", out.getvalue()) def test_no_runtime_falls_back_to_local(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() args = make_args(path=str(root)) recorder = Recorder() command = DockerizeCommand( args, capture=recorder.capture, stream=recorder.stream, environ={}, cwd=root, platform="linux", tty=True, selinux=False, ids=(1000, 1000), which=lambda name: None) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 0) self.assertEqual(len(recorder.stream_calls), 1) argv = recorder.stream_calls[0] self.assertIn("-m", argv) self.assertIn("blackcat", argv) self.assertNotIn("build", argv) self.assertIn("backend local", err.getvalue()) def test_explicit_podman_missing_is_exit_two(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() args = make_args(path=str(root), runtime="podman") command = DockerizeCommand( args, capture=Recorder().capture, stream=Recorder().stream, environ={}, cwd=root, platform="linux", tty=True, selinux=False, ids=(1000, 1000), which=lambda name: None) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 2) self.assertIn("no podman runtime", err.getvalue()) def test_explicit_bwrap_missing_is_exit_two(self): with tempfile.TemporaryDirectory() as tmp: root = make_project(Path(tmp)).resolve() args = make_args(path=str(root), runtime="bwrap") command = DockerizeCommand( args, capture=Recorder().capture, stream=Recorder().stream, environ={}, cwd=root, platform="linux", tty=True, selinux=False, ids=(1000, 1000), which=lambda name: None) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 2) self.assertIn("no bwrap backend", err.getvalue()) def test_not_a_checkout_is_exit_two(self): with tempfile.TemporaryDirectory() as tmp: root = Path(tmp) / "empty" root.mkdir() recorder = Recorder() command = DockerizeCommand( make_args(path=str(root)), capture=recorder.capture, stream=recorder.stream, environ={}, cwd=root, platform="linux", tty=True, selinux=False, ids=(0, 0), which=which_all, probe=lambda name, path: ContainerRuntime(name, path)) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 2) self.assertIn("not a blackcat checkout", err.getvalue()) self.assertEqual(recorder.calls, []) def test_container_exit_code_propagates(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(results={"inspect": labels_result("", 1)}, stream_codes={"run": 7}) command, _ = self.build(tmp, recorder) with contextlib.redirect_stderr(io.StringIO()): code = command.run() self.assertEqual(code, 7) def test_quiet_suppresses_progress(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(results={"inspect": labels_result("", 1)}) command, _ = self.build(tmp, recorder, quiet=2) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 0) self.assertEqual(err.getvalue(), "") def test_passthrough_reaches_run_command(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(results={"inspect": labels_result("", 1)}) command, _ = self.build( tmp, recorder, args=["--", "--provider", "echo", "tui"]) with contextlib.redirect_stderr(io.StringIO()): command.run() run_argv = recorder.stream_calls[1] self.assertEqual(run_argv[-3:], ["--provider", "echo", "tui"]) def test_dry_run_stop_prints_only(self): with tempfile.TemporaryDirectory() as tmp: def boom(*args, **kwargs): raise AssertionError("dry run executed a command") recorder = Recorder() recorder.capture = boom command, _ = self.build(tmp, recorder, dry_run=True, stop=True) with contextlib.redirect_stderr(io.StringIO()): with contextlib.redirect_stdout(io.StringIO()) as out: code = command.run() self.assertEqual(code, 0) self.assertIn("rm -f", out.getvalue()) class TestFallbackRun(unittest.TestCase): def build(self, tmp, recorder, **overrides): root = make_project(Path(tmp)).resolve() which = overrides.pop("which", lambda name: None) probe = overrides.pop("probe", lambda n, p: None) fallback_probe = overrides.pop("fallback_probe", None) args = make_args(path=str(root), **overrides) command = DockerizeCommand( args, capture=recorder.capture, stream=recorder.stream, environ={}, cwd=root, platform="linux", tty=True, selinux=False, ids=(1000, 1000), which=which, probe=probe, fallback_probe=fallback_probe) return command, root def test_unshare_skips_build(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder() command, _ = self.build( tmp, recorder, which=which_only({"unshare": "/usr/bin/unshare"}), fallback_probe=fallback_ok) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 0) self.assertEqual(len(recorder.stream_calls), 1) self.assertEqual(recorder.stream_calls[0][0], "/usr/bin/unshare") self.assertEqual(recorder.calls, []) self.assertIn("backend unshare", err.getvalue()) def test_passthrough_reaches_fallback(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder() command, _ = self.build( tmp, recorder, args=["--", "--provider", "echo", "tui"]) with contextlib.redirect_stderr(io.StringIO()): command.run() argv = recorder.stream_calls[0] self.assertEqual(argv[-3:], ["--provider", "echo", "tui"]) self.assertIn(sys.executable, argv) def test_build_only_does_nothing(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder() command, _ = self.build(tmp, recorder, build_only=True) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() self.assertEqual(code, 0) self.assertEqual(recorder.stream_calls, []) self.assertIn("builds no image", err.getvalue()) def test_stop_and_rmi_are_noops(self): for flag in ("stop", "rm_image"): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder() command, _ = self.build(tmp, recorder, **{flag: True}) with contextlib.redirect_stderr(io.StringIO()) as err: code = command.run() with self.subTest(flag=flag): self.assertEqual(code, 0) self.assertEqual(recorder.stream_calls, []) self.assertIn("nothing to remove", err.getvalue()) def test_fallback_exit_code_propagates(self): with tempfile.TemporaryDirectory() as tmp: recorder = Recorder(stream_codes={"blackcat": 7}) command, _ = self.build(tmp, recorder) with contextlib.redirect_stderr(io.StringIO()): code = command.run() self.assertEqual(code, 7) def test_fallback_dry_run_prints_only(self): with tempfile.TemporaryDirectory() as tmp: def boom(*args, **kwargs): raise AssertionError("dry run executed a command") recorder = Recorder() recorder.capture = boom recorder.stream = boom command, _ = self.build(tmp, recorder, dry_run=True) with contextlib.redirect_stderr(io.StringIO()): with contextlib.redirect_stdout(io.StringIO()) as out: code = command.run() self.assertEqual(code, 0) self.assertIn("blackcat", out.getvalue()) if __name__ == "__main__": unittest.main()