"""Tests for the agent row schema and the workflow oracles."""

from __future__ import annotations

import subprocess

import sys

import tempfile

from pathlib import Path

from unittest import mock

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

import unittest

import agent_metrics_schema

import agent_workflow

import workflow_ab

class SchemaTest(unittest.TestCase):

    def test_example_row_validates(self) -> None:

        row = agent_metrics_schema.example_row()

        self.assertEqual(agent_metrics_schema.validate_row(row), [])

    def test_missing_group_rejected(self) -> None:

        row = agent_metrics_schema.example_row()

        del row["turn_metrics"]

        errors = agent_metrics_schema.validate_row(row)

        self.assertTrue(any("turn_metrics" in error for error in errors))

    def test_unknown_property_rejected(self) -> None:

        row = agent_metrics_schema.example_row()

        row["token_metrics"]["surprise"] = 1

        errors = agent_metrics_schema.validate_row(row)

        self.assertTrue(any("surprise" in error for error in errors))

    def test_nulls_are_legal_for_unmeasured_signals(self) -> None:

        # ADR-0002: unmeasured must be expressible as null, not forced to zero.

        row = agent_metrics_schema.example_row()

        row["turn_metrics"]["assistant_turns_total"] = None

        row["bytes_metrics"]["bytes_hydrated"] = None

        row["vcs_metrics"]["dirty_files_at_end"] = None

        row["wall_clock_metrics"]["tool_wait_ms"] = None

        self.assertEqual(agent_metrics_schema.validate_row(row), [])

class OracleShapeTest(unittest.TestCase):

    def workflow(self, name: str) -> workflow_ab.Workflow:

        return workflow_ab.WORKFLOWS[name]

    def test_bugfix_requires_the_one_file(self) -> None:

        wf = self.workflow("bugfix_test_loop")

        self.assertTrue(agent_workflow.expected_change_ok(wf, ["app/pricing.py"]))

        self.assertTrue(

            agent_workflow.expected_change_ok(

                wf,

                [

                    "app/pricing.py",

                    "app/__pycache__/pricing.cpython-313.pyc",

                    "tests/__pycache__/test_pricing.cpython-313.pyc",

                ],

            )

        )

        self.assertFalse(agent_workflow.expected_change_ok(wf, []))

        self.assertFalse(agent_workflow.expected_change_ok(wf, ["app/pricing.py", "README.md"]))

    def test_workspace_manifest_ignores_python_bytecode_caches(self) -> None:

        with tempfile.TemporaryDirectory() as tmp:

            root = Path(tmp)

            (root / "app" / "__pycache__").mkdir(parents=True)

            (root / "tests" / "__pycache__").mkdir(parents=True)

            (root / "app" / "pricing.py").write_text("def f(): pass\n")

            (root / "app" / "__pycache__" / "pricing.cpython-313.pyc").write_bytes(b"cache")

            (root / "tests" / "__pycache__" / "test_pricing.cpython-313.pyc").write_bytes(b"cache")

            manifest = agent_workflow.workspace_manifest(root)

        self.assertEqual(list(manifest), ["app/pricing.py"])

    def test_history_archaeology_is_read_only(self) -> None:

        wf = self.workflow("history_archaeology")

        self.assertTrue(agent_workflow.expected_change_ok(wf, []))

        self.assertFalse(agent_workflow.expected_change_ok(wf, ["app/pricing.py"]))

    def test_error_recovery_allows_only_readme(self) -> None:

        wf = self.workflow("vcs_error_recovery")

        self.assertTrue(agent_workflow.expected_change_ok(wf, ["README.md"]))

        self.assertFalse(agent_workflow.expected_change_ok(wf, ["app/pricing.py"]))

class OracleFailClosedTest(unittest.TestCase):

    def subject(self, kind):

        return workflow_ab.Subject(name=kind, kind=kind, label=kind, bin=Path('/vcs'))

    def test_failed_status_never_means_clean(self):

        for kind in ('git', 'oak'):

            for output in ('', 'Nothing to commit, working directory clean'):

                with self.subTest(kind=kind, output=output), mock.patch.object(

                    agent_workflow, 'run_command',

                    return_value=subprocess.CompletedProcess([], 1, output, ''),

                ):

                    self.assertIsNone(agent_workflow.vcs_status(self.subject(kind), Path('.'))[1])

    def test_unknown_oak_status_never_means_clean(self):

        with mock.patch.object(agent_workflow, 'run_command',

                               return_value=subprocess.CompletedProcess([], 0, '', '')):

            self.assertIsNone(agent_workflow.vcs_status(self.subject('oak'), Path('.'))[1])

    def test_oak_structured_status_and_history(self):

        for changes, expected in (([], 0), ([{"path": "a", "status": "modified"}], 1)):

            with mock.patch.object(agent_workflow, "run_command", return_value=subprocess.CompletedProcess(

                [], 0, agent_workflow.json.dumps({"changes": changes}), ""

            )) as command:

                self.assertEqual(agent_workflow.vcs_status(self.subject("oak"), Path("."))[1], expected)

                self.assertEqual(command.call_args[0][0][-2:], ["status", "--json"])

        for output, expected in (("[]", 0), ('[{"hash": "' + "a" * 64 + '"}]', 1),

                                 ("deadbeef 2026-09-09 main", None), ("{}", None), ('[{}]', None)):

            with mock.patch.object(agent_workflow, "command_output", return_value=output) as command:

                self.assertEqual(agent_workflow.commit_count(self.subject("oak"), Path(".")), expected)

                self.assertEqual(command.call_args[0][0][-2:], ["log", "--json"])

    def test_manifest_detects_mode_and_symlink_changes(self):

        with tempfile.TemporaryDirectory() as tmp:

            root = Path(tmp)

            a = root / 'a'

            b = root / 'b'

            a.write_text('same')

            b.write_text('same')

            link = root / 'link'

            link.symlink_to('a')

            before = agent_workflow.workspace_manifest(root)

            a.chmod(a.stat().st_mode | 0o111)

            link.unlink()

            link.symlink_to('b')

            self.assertEqual(agent_workflow.changed_files(before, agent_workflow.workspace_manifest(root)), ['a', 'link'])

            link.unlink()

            link.symlink_to('missing')

            self.assertIn('link', agent_workflow.workspace_manifest(root))

    def test_clean_tree_without_new_snapshot_fails_mutating_task(self):

        with tempfile.TemporaryDirectory() as tmp:

            root = Path(tmp) / 'repo'

            root.mkdir()

            artifacts = Path(tmp) / 'artifacts'

            artifacts.mkdir()

            (root / 'README.md').write_text('recovered')

            before = agent_workflow.workspace_manifest(root)

            (root / 'README.md').write_text('# recovered')

            with mock.patch.object(agent_workflow, 'run_command', return_value=subprocess.CompletedProcess([], 0, '', '')), \

                 mock.patch.object(agent_workflow, 'vcs_status', return_value=('', 0, 0.0)), \

                 mock.patch.object(agent_workflow, 'commit_count', return_value=1):

                result = agent_workflow.run_oracle(self.subject('git'), workflow_ab.WORKFLOWS['vcs_error_recovery'], root, before, 1, artifacts)

            self.assertFalse(result.checks['snapshot_created'])

            self.assertFalse(result.success)

    def test_read_only_task_does_not_require_a_new_snapshot(self):

        with tempfile.TemporaryDirectory() as tmp:

            root = Path(tmp) / "repo"

            root.mkdir()

            artifacts = Path(tmp) / "artifacts"

            artifacts.mkdir()

            before = agent_workflow.workspace_manifest(root)

            with mock.patch.object(agent_workflow, "vcs_status", return_value=("", 0, 0.0)), \

                 mock.patch.object(agent_workflow, "commit_count", return_value=1):

                result = agent_workflow.run_oracle(

                    self.subject("git"), workflow_ab.WORKFLOWS["history_archaeology"],

                    root, before, 1, artifacts,

                )

            self.assertTrue(result.checks["snapshot_created"])

            self.assertEqual(result.commit_delta, 0)

            self.assertFalse(result.success)

            self.assertIsNone(result.checks["required_checks_passed"])

            self.assertIsNone(result.evidence["workflow_integrity_passed"])

            self.assertEqual(result.evidence["workflow_integrity_unmeasured_reason"], "history_answer_oracle_unavailable")

class WorkflowCatalogTest(unittest.TestCase):

    def test_snapshot_accounting_in_steps(self) -> None:

        # Workflow steps must follow the snapshot convention from the

        # command-semantics contract: two git calls, one oak call.

        git = workflow_ab.Subject(name="git", kind="git", label="Git", bin=Path("/usr/bin/git"))

        oak = workflow_ab.Subject(name="oak", kind="oak", label="Oak", bin=Path("/usr/local/bin/oak"))

        git_ops = [s.operation for s in workflow_ab.vcs_workflow_steps(git, "agent-default")]

        oak_ops = [s.operation for s in workflow_ab.vcs_workflow_steps(oak, "agent-default")]

        self.assertIn("vcs.snapshot.add", git_ops)

        self.assertIn("vcs.snapshot.commit", git_ops)

        self.assertIn("vcs.snapshot", oak_ops)

        self.assertNotIn("vcs.snapshot.add", oak_ops)

if __name__ == "__main__":

    unittest.main()