"""Tests for the agent-fleet (workspace_per_task) lane plumbing."""

from __future__ import annotations

import sys

import subprocess

import tempfile

import unittest

from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))

import parallel_contention as lane

class VirtualBranchParseTest(unittest.TestCase):

    def test_parses_mount_status_line(self) -> None:

        text = "Mount: oak/bench-fleet-tmp@cafb68ba0b1e (virtual branch fleet-mnt-0--fe49717c)\n\nWorking tree clean.\n"

        match = lane.VIRTUAL_BRANCH_RE.search(text)

        self.assertIsNotNone(match)

        self.assertEqual(match.group(1), "fleet-mnt-0--fe49717c")

    def test_no_match_on_plain_status(self) -> None:

        self.assertIsNone(lane.VIRTUAL_BRANCH_RE.search("On branch main\nWorking tree clean.\n"))

class WorkerPayloadPrefixTest(unittest.TestCase):

    def test_default_prefix_preserves_legacy_path_shape(self) -> None:

        # ADR-0005: the git path's payload location must not move.

        result = lane.WorkerResult(worker=0)

        class FailFast(Exception):

            pass

        # Exercise only the path construction: a missing workspace makes the

        # first write raise, recorded as a worker error, never an exception.

        lane.worker_loop(

            _subject_stub(), Path("/nonexistent-oakbench-test"), 7, 1, result

        )

        self.assertTrue(result.errors)

    def test_run_scoped_prefix_lands_in_rel_path(self) -> None:

        # The oak path namespaces payloads per run so merges into the

        # accumulating disposable main stay file-disjoint across runs.

        prefix = "workers/20260611T000000Z-r0"

        rel = f"{prefix}/w{3:03d}/f{1:03d}.txt"

        self.assertEqual(rel, "workers/20260611T000000Z-r0/w003/f001.txt")

class WorkerFailureContextTest(unittest.TestCase):

    def test_failed_worker_row_fields_include_command_stderr_and_path(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            root = Path(tmp)

            fake_git = root / "fake-git"

            fake_git.write_text("#!/bin/sh\necho fake-git-boom >&2\nexit 2\n")

            fake_git.chmod(0o755)

            workspace = root / "workspace"

            workspace.mkdir()

            result = lane.WorkerResult(worker=4)

            lane.worker_loop(_subject_stub(fake_git), workspace, 4, 1, result)

            fields = lane.worker_failure_fields(result, workspace)

        self.assertEqual(result.commits_attempted, 1)

        self.assertEqual(result.commits_succeeded, 0)

        self.assertEqual(fields["failure_reason"], "snapshot_command_failed")

        self.assertEqual(fields["worker_id"], 4)

        self.assertIn("workers/w004/f000.txt", fields["affected_paths"])

        self.assertIn("fake-git-boom", fields["stderr"])

        self.assertTrue(fields["command"])

        self.assertTrue(fields["failure_contexts"])

    def test_terminal_failure_context_marks_worker_failed_without_missing_commits(self) -> None:

        result = lane.WorkerResult(worker=2, commits_attempted=1, commits_succeeded=1)

        proc = subprocess.CompletedProcess(

            ["git", "merge", "--no-edit", "train-002"],

            1,

            stdout="",

            stderr="merge conflict",

        )

        lane.record_worker_failure(

            result,

            "train_merge_failed",

            command=["git", "merge", "--no-edit", "train-002"],

            proc=proc,

            workspace=Path("/tmp/workspace"),

        )

        fields = lane.worker_failure_fields(result, Path("/tmp/workspace"))

        self.assertTrue(lane.worker_result_failed(result))

        self.assertEqual(fields["failure_reason"], "train_merge_failed")

        self.assertIn("merge conflict", fields["stderr"])

        self.assertEqual(fields["command"], ["git", "merge", "--no-edit", "train-002"])

    def test_worktree_merge_failure_matches_oak_workspace_merge_semantics(self) -> None:

        result = lane.WorkerResult(worker=1, commits_attempted=1, commits_succeeded=1)

        proc = subprocess.CompletedProcess(

            ["git", "merge", "--no-edit", "task-001"],

            1,

            stdout="",

            stderr="worktree merge conflict",

        )

        lane.record_worker_failure(

            result,

            "worktree_merge_failed",

            command=["git", "merge", "--no-edit", "task-001"],

            proc=proc,

            workspace=Path("/tmp/workspace"),

        )

        fields = lane.worker_failure_fields(result, Path("/tmp/workspace"))

        self.assertTrue(lane.worker_result_failed(result))

        self.assertEqual(fields["failure_reason"], "worktree_merge_failed")

        self.assertIn("worktree merge conflict", fields["stderr"])

        self.assertEqual(fields["command"], ["git", "merge", "--no-edit", "task-001"])

    def test_recovered_snapshot_failure_context_is_not_fatal(self) -> None:

        result = lane.WorkerResult(worker=3, commits_attempted=1, commits_succeeded=1)

        proc = subprocess.CompletedProcess(

            ["git", "commit", "-m", "retry"],

            1,

            stdout="transient stdout",

            stderr="transient stderr",

        )

        lane.record_worker_failure(

            result,

            "snapshot_command_failed",

            command=["git", "commit", "-m", "retry"],

            proc=proc,

            workspace=Path("/tmp/workspace"),

            affected_path="workers/w003/f000.txt",

        )

        fields = lane.worker_failure_fields(result, Path("/tmp/workspace"))

        self.assertFalse(lane.worker_result_failed(result))

        self.assertNotIn("failure_reason", fields)

        self.assertTrue(fields["failure_contexts"])

def _subject_stub(bin_path: Path = Path("/usr/bin/false")) -> object:

    class Stub:

        name = "stub"

        kind = "git"

        label = "stub"

        bin = bin_path

        git_mode = None

    return Stub()

class SkipReasonTest(unittest.TestCase):

    def test_unresolved_fleet_remote_yields_structured_skip(self) -> None:

        import os

        from unittest import mock

        with mock.patch.dict(os.environ, {}, clear=False):

            os.environ.pop("OAK_BENCH_FLEET_REPO", None)

            os.environ.pop("OAK_BENCH_REMOTE", None)

            rows = lane.run_workspace_per_task_oak(

                _oak_subject_stub(),

                Path("/nonexistent"),

                2,

                1,

                Path("/tmp"),

                0,

                {"bench_id": "t"},

            )

        self.assertEqual(len(rows), 1)

        self.assertEqual(rows[0]["returncode"], lane.SKIP_RETURNCODE)

        self.assertTrue(rows[0]["skipped"])

        self.assertIn("OAK_BENCH_FLEET_REPO", rows[0]["skip_reason"])

def _oak_subject_stub() -> object:

    class Stub:

        name = "oak_installed"

        kind = "oak"

        label = "oak (installed)"

        bin = Path("/usr/bin/false")

        git_mode = None

    return Stub()

if __name__ == "__main__":

    unittest.main()