"""One fast end-to-end check: the workflow lane runs a real recipe against git.

This is the smoke wire from instruments to rows: fixture, command semantics,

timed execution, row contract, results store. Skipped when git is unavailable.

"""

from __future__ import annotations

import sys

from pathlib import Path

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

import json

import shutil

import tempfile

import unittest

from pathlib import Path

import workflow_ab

from oakbench.rows import validate_rows

from oakbench.subjects import Subject

@unittest.skipIf(shutil.which("git") is None, "git not installed")

class WorkflowLaneIntegrationTest(unittest.TestCase):

    def setUp(self) -> None:

        self.tmp = Path(tempfile.mkdtemp(prefix="oakbench-test-"))

    def tearDown(self) -> None:

        shutil.rmtree(self.tmp, ignore_errors=True)

    def test_every_workflow_fixture_prepares(self) -> None:

        """Every defined workflow must at least build its fixture.

        Catches import/codepath breaks in workflows the end-to-end test does

        not run (a missing json import once crashed large_asset_manifest only).

        """

        for name, workflow in workflow_ab.WORKFLOWS.items():

            with self.subTest(workflow=name):

                fixture = workflow_ab.prepare_fixture(self.tmp / name, workflow)

                self.assertTrue(fixture.exists())

    def test_error_recovery_workflow_end_to_end(self) -> None:

        subject = Subject(name="git", kind="git", label="Git", bin=Path(shutil.which("git")))

        workflow = workflow_ab.WORKFLOWS["vcs_error_recovery"]

        fixture = workflow_ab.prepare_fixture(self.tmp, workflow)

        metadata = {

            "bench_id": "test",

            "profile": "workflow-ab",

            "benchmark_track": "agent-default",

            "command_semantics_version": workflow_ab.COMMAND_SEMANTICS_VERSION,

            "timestamp_utc": "test",

        }

        rows = workflow_ab.run_subject_workflow(

            subject,

            workflow,

            fixture,

            run_index=0,

            run_root=self.tmp / "runs",

            metadata=metadata,

            admitted_output_chars=20_000,

            track="agent-default",

        )

        self.assertEqual(validate_rows(rows, "workflow"), [])

        totals = [row for row in rows if row["operation"] == "workflow.total"]

        self.assertEqual(len(totals), 1)

        self.assertEqual(totals[0]["returncode"], 0)

        # The induced failure must be recorded, not skipped: the empty commit

        # fails at the process level while staying a tolerated step.

        commit_nothing = next(row for row in rows if row["operation"] == "error.commit_nothing")

        self.assertEqual(commit_nothing["returncode"], 0)

        self.assertNotEqual(commit_nothing["process_returncode"], 0)

        # Snapshot accounting: git pays two calls.

        operations = [row["operation"] for row in rows]

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

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

        # Rows are JSON-serializable as-is (the durable format).

        for row in rows:

            json.dumps(row)

class WorkflowFailurePolicyTest(unittest.TestCase):

    def test_lane_failure_predicate_ignores_skips_but_flags_failures(self) -> None:

        self.assertFalse(workflow_ab.has_lane_failures([{"returncode": workflow_ab.SKIP_RETURNCODE, "skipped": True}]))

        self.assertTrue(workflow_ab.has_lane_failures([{"returncode": 1}]))

if __name__ == "__main__":

    unittest.main()