tests/test_world.py

from __future__ import annotations

import json
import tempfile
import unittest
from pathlib import Path

from salesbench.generation import TASK_SPINES, generate_task, verification_token
from salesbench.runtime.world import SalesWorld


class WorldTests(unittest.TestCase):
    def setUp(self) -> None:
        self.temporary = tempfile.TemporaryDirectory()
        self.root = Path(self.temporary.name)
        self.task = generate_task(TASK_SPINES[0], 1)
        self.documents = self.root / "documents"
        for relative, content in self.task.documents.items():
            path = self.documents / relative
            path.parent.mkdir(parents=True, exist_ok=True)
            if isinstance(content, bytes):
                path.write_bytes(content)
            else:
                path.write_text(content, encoding="utf-8")
        self.spec_path = self.root / "spec.json"
        self.seed_path = self.root / "seed.json"
        self.spec_path.write_text(json.dumps(self.task.spec), encoding="utf-8")
        self.seed_path.write_text(json.dumps(self.task.seed), encoding="utf-8")

    def tearDown(self) -> None:
        self.temporary.cleanup()

    def world(self, suffix: str) -> SalesWorld:
        return SalesWorld(
            self.documents,
            self.root / f"output-{suffix}",
            self.root / f"state-{suffix}",
            self.spec_path,
            self.seed_path,
        )

    def test_reference_trajectory_passes_and_replays_exactly(self) -> None:
        reports = []
        for suffix in ("one", "two"):
            world = self.world(suffix)
            for call in self.task.reference["calls"]:
                result = world.call_tool(call["server"], call["name"], call["arguments"])
                self.assertFalse(result["isError"])
                self.assertEqual(
                    result["structuredContent"]["content"], result["content"][0]["text"]
                )
            reports.append(world.verify(verification_token(self.task.task_id)))
        self.assertTrue(reports[0]["passed"])
        self.assertEqual(reports[0]["reward"], 1.0)
        self.assertEqual(len(reports[0]["semantic_checks"]), 15)
        self.assertEqual(
            sum(check["weight"] for check in reports[0]["semantic_checks"]),
            100.0,
        )
        self.assertTrue(all(check["passed"] for check in reports[0]["semantic_checks"]))
        self.assertEqual(reports[0], reports[1])
        executed = {
            f"{component}.{criterion_id}"
            for component in ("procedure", "state", "changes", "brief")
            for criterion_id in (
                reports[0]["criteria"][component]
                if component == "procedure"
                else reports[0]["criteria"][component]["criteria"]
            )
        }
        self.assertEqual(
            executed, {row["id"] for row in self.task.spec["rubric_criteria"]}
        )

    def test_keyword_stuffing_cannot_replace_a_human_brief(self) -> None:
        world = self.world("keyword-stuffing")
        replaced = False
        for call in self.task.reference["calls"]:
            arguments = call["arguments"]
            if (
                call["server"] == "filesystem"
                and call["name"] == "write_file"
                and arguments["path"].endswith("brief.md")
            ):
                arguments = {
                    **arguments,
                    "content": " ".join(arguments["content"].split()),
                }
                replaced = True
            result = world.call_tool(call["server"], call["name"], arguments)
            self.assertFalse(result["isError"])
        self.assertTrue(replaced)
        report = world.verify(verification_token(self.task.task_id))
        criteria = report["criteria"]["brief"]["criteria"]
        self.assertFalse(report["passed"])
        self.assertFalse(criteria["natural_narrative"])
        self.assertTrue(
            all(passed for name, passed in criteria.items() if name != "natural_narrative")
        )

    def _run_with_changes(self, suffix: str, mutate) -> dict:
        world = self.world(suffix)
        for call in self.task.reference["calls"]:
            arguments = call["arguments"]
            if (
                call["server"] == "filesystem"
                and call["name"] == "write_file"
                and arguments["path"].endswith("changes.json")
            ):
                payload = json.loads(arguments["content"])
                mutate(payload)
                arguments = {
                    **arguments,
                    "content": json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
                }
            result = world.call_tool(call["server"], call["name"], arguments)
            self.assertFalse(result["isError"])
        return world.verify(verification_token(self.task.task_id))

    def test_misreported_alternative_timing_is_rejected(self) -> None:
        def flip_timing(payload: dict) -> None:
            model = payload["decision_model"]
            model["decision_timing_status"] = (
                "LATE" if model["decision_timing_status"] == "ON_TIME" else "ON_TIME"
            )

        report = self._run_with_changes("wrong-timing", flip_timing)
        self.assertFalse(report["passed"])
        self.assertFalse(
            report["criteria"]["changes"]["criteria"][
                "decision_model.decision_timing_status"
            ]
        )
        failed = [check["id"] for check in report["semantic_checks"] if not check["passed"]]
        self.assertEqual(failed, ["decision.alternatives"])

    def test_relabelled_unauthorized_alternative_is_rejected(self) -> None:
        expedite_id = next(
            option["id"]
            for option in self.task.spec["decision_options"]
            if option["approval"] == "ADDITIONAL_APPROVAL_REQUIRED"
        )

        def approve_expedite(payload: dict) -> None:
            option = payload["decision_model"]["options"][expedite_id]
            option["approval"] = "APPROVED"
            option["incremental_cost"] = 0

        report = self._run_with_changes("approved-expedite", approve_expedite)
        self.assertFalse(report["passed"])
        criteria = report["criteria"]["changes"]["criteria"]
        self.assertFalse(criteria[f"decision_model.options.{expedite_id}.approval"])
        self.assertFalse(criteria[f"decision_model.options.{expedite_id}.incremental_cost"])

    def test_reference_can_skip_surrounding_sources_and_queries(self) -> None:
        world = self.world("material-only")
        required_investigations = {
            (
                call["server"],
                call["name"],
                json.dumps(call["arguments"], sort_keys=True, separators=(",", ":")),
            )
            for call in self.task.spec["required_investigation_calls"]
        }
        skipped = 0
        for call in self.task.reference["calls"]:
            arguments = call["arguments"]
            if (
                call["server"] == "filesystem"
                and call["name"] == "read_text_file"
                and arguments.get("path") not in self.task.spec["required_document_paths"]
            ):
                skipped += 1
                continue
            if (
                call["server"] == "filesystem"
                and call["name"] == "get_file_info"
                and arguments.get("path") not in self.task.spec["metadata_check_paths"]
            ):
                skipped += 1
                continue
            signature = (
                call["server"],
                call["name"],
                json.dumps(arguments, sort_keys=True, separators=(",", ":")),
            )
            if call.get("purpose") and signature not in required_investigations:
                skipped += 1
                continue
            result = world.call_tool(call["server"], call["name"], arguments)
            self.assertFalse(result["isError"])

        report = world.verify(verification_token(self.task.task_id))
        self.assertGreaterEqual(skipped, 10)
        self.assertTrue(report["passed"])
        self.assertEqual(report["reward"], 1.0)

    def test_material_investigation_accepts_a_semantically_equivalent_query(self) -> None:
        world = self.world("flexible-investigation")
        target = self.task.spec["required_investigation_calls"][0]
        replaced = False
        for call in self.task.reference["calls"]:
            arguments = call["arguments"]
            if (
                not replaced
                and call["server"] == target["server"]
                and call["name"] == target["name"]
                and arguments == target["arguments"]
            ):
                arguments = {
                    **arguments,
                    "limit": 50,
                    "properties": ["salesbench_key", "forecast_status"],
                }
                replaced = True
            result = world.call_tool(call["server"], call["name"], arguments)
            self.assertFalse(result["isError"])
        self.assertTrue(replaced)
        report = world.verify(verification_token(self.task.task_id))
        self.assertTrue(report["passed"])
        self.assertTrue(
            report["criteria"]["procedure"]["task_specific_investigation_completed"]
        )

    def test_outputs_only_are_rejected(self) -> None:
        world = self.world("shortcut")
        for call in self.task.reference["calls"][-2:]:
            world.call_tool(call["server"], call["name"], call["arguments"])
        report = world.verify(verification_token(self.task.task_id))
        self.assertFalse(report["passed"])
        self.assertLessEqual(report["reward"], 0.49)

    def test_correct_result_with_task_specific_evidence_omitted_is_rejected(self) -> None:
        world = self.world("missing-task-investigation")
        required = self.task.spec["required_investigation_calls"][0]
        skipped = False
        for call in self.task.reference["calls"]:
            if (
                not skipped
                and call["server"] == required["server"]
                and call["name"] == required["name"]
                and call["arguments"] == required["arguments"]
            ):
                skipped = True
                continue
            result = world.call_tool(call["server"], call["name"], call["arguments"])
            self.assertFalse(result["isError"])
        self.assertTrue(skipped)
        report = world.verify(verification_token(self.task.task_id))
        self.assertFalse(report["passed"])
        self.assertFalse(
            report["criteria"]["procedure"]["task_specific_investigation_completed"]
        )

    def test_correct_writes_followed_by_late_reads_are_rejected(self) -> None:
        world = self.world("write-first")
        calls = self.task.reference["calls"]
        crm_mutations = [
            call
            for call in calls
            if call["server"] in {"salesforce", "hubspot"}
            and call["name"] in {"updateSobjectRecord", "hubspot_update_object"}
        ]
        outputs = [
            call
            for call in calls
            if call["server"] == "filesystem" and call["name"] == "write_file"
        ]
        investigation = [
            call for call in calls if call not in crm_mutations and call not in outputs
        ]
        for call in [*crm_mutations, *investigation, *outputs]:
            result = world.call_tool(call["server"], call["name"], call["arguments"])
            self.assertFalse(result["isError"])
        report = world.verify(verification_token(self.task.task_id))
        self.assertFalse(report["passed"])
        self.assertFalse(
            report["criteria"]["procedure"]["all_required_evidence_precedes_mutation"]
        )
        self.assertFalse(
            report["criteria"]["procedure"]["all_provider_evidence_precedes_mutation"]
        )

    def test_mutation_acknowledgement_without_postwrite_readback_is_rejected(self) -> None:
        world = self.world("missing-readback")
        skipped_change_id = None
        for call in self.task.reference["calls"]:
            if skipped_change_id is None and call.get("phase") == "postwrite_readback":
                skipped_change_id = call["change_id"]
                continue
            result = world.call_tool(call["server"], call["name"], call["arguments"])
            self.assertFalse(result["isError"])
        self.assertIsNotNone(skipped_change_id)
        report = world.verify(verification_token(self.task.task_id))
        self.assertFalse(report["passed"])
        self.assertFalse(
            report["criteria"]["procedure"]["all_mutations_verified_by_readback"]
        )
        self.assertFalse(
            report["criteria"]["state"]["criteria"][
                f"{skipped_change_id}.postwrite_readback"
            ]
        )

    def test_pristine_noop_world_scores_exactly_zero(self) -> None:
        world = self.world("noop")
        report = world.verify(verification_token(self.task.task_id))
        self.assertFalse(report["passed"])
        self.assertEqual(report["reward"], 0.0)
        self.assertEqual(report["reward_cap_reason"], "no_mcp_interaction")

    def test_failed_read_is_recoverable_but_rejected_mutation_is_not(self) -> None:
        read_world = self.world("recover-read")
        invalid_read = read_world.call_tool("salesforce", "soqlQuery", {})
        self.assertTrue(invalid_read["isError"])
        for call in self.task.reference["calls"]:
            read_world.call_tool(call["server"], call["name"], call["arguments"])
        read_report = read_world.verify(verification_token(self.task.task_id))
        self.assertTrue(read_report["passed"])
        self.assertTrue(read_report["criteria"]["procedure"]["no_rejected_mutation"])

        mutation_world = self.world("reject-mutation")
        change = self.task.spec["expected_changes"][0]
        invalid_arguments = {
            **change["arguments"],
            "id": f"{change['record_id']}-OUT-OF-SCOPE",
        }
        invalid_mutation = mutation_world.call_tool(
            change["system"], change["tool"], invalid_arguments
        )
        self.assertTrue(invalid_mutation["isError"])
        for call in self.task.reference["calls"]:
            mutation_world.call_tool(call["server"], call["name"], call["arguments"])
        mutation_report = mutation_world.verify(verification_token(self.task.task_id))
        self.assertFalse(mutation_report["passed"])
        self.assertFalse(
            mutation_report["criteria"]["procedure"]["no_rejected_mutation"]
        )
        execution = next(
            check
            for check in mutation_report["semantic_checks"]
            if check["id"] == "execution.delivery"
        )
        self.assertFalse(execution["passed"])

    def test_unauthorized_delete_fails_verification(self) -> None:
        world = self.world("delete")
        for call in self.task.reference["calls"]:
            world.call_tool(call["server"], call["name"], call["arguments"])
        target = next(
            row
            for row in world.state["salesforce"]["objects"]["Account"]
            if str(row.get("SalesBenchKey__c", "")).startswith("CTRL-")
        )
        result = world.call_tool(
            "salesforce",
            "deleteSobjectRecord",
            {"sobject-name": "Account", "id": target["Id"]},
        )
        self.assertFalse(result["isError"])
        report = world.verify(verification_token(self.task.task_id))
        self.assertFalse(report["passed"])
        state_criteria = report["criteria"]["state"]["criteria"]
        self.assertFalse(state_criteria["no_delete_tool_succeeded"])
        self.assertFalse(state_criteria["entire_business_state_exact"])

    def test_verifier_capability_is_not_public(self) -> None:
        world = self.world("token")
        with self.assertRaises(PermissionError):
            world.verify(None)
        with self.assertRaises(PermissionError):
            world.verify("wrong")


if __name__ == "__main__":
    unittest.main()