code/tests/test_quality_v2.py

from __future__ import annotations

import json
import pickle
import unittest
from copy import deepcopy
from pathlib import Path
from typing import Any, Callable

from barbet_bgd.generation_v2 import GenerationPlanV2, generate_record_v2
from barbet_bgd.quality_v2 import (
    EXPECTED_TASK_FAMILIES_V2,
    PromotionAccumulator,
    expected_source_hash_v2,
    validate_record_quality_v2,
)


ROOT = Path(__file__).resolve().parents[1]


def _rehash(record: dict[str, Any]) -> None:
    record["provenance"]["source_hash"] = expected_source_hash_v2(record)


def _replace_strings(value: Any, replacements: dict[str, str]) -> Any:
    if isinstance(value, str):
        return replacements.get(value, value)
    if isinstance(value, list):
        return [_replace_strings(item, replacements) for item in value]
    if isinstance(value, dict):
        return {
            replacements.get(key, key): _replace_strings(item, replacements)
            for key, item in value.items()
        }
    return value


class QualityV2Tests(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        cls.config = json.loads(
            (ROOT / "configs/selected_sft_1m_v2.json").read_text(encoding="utf-8")
        )
        cls.plan = GenerationPlanV2(cls.config)
        cls.records = [generate_record_v2(cls.config, cls.plan, index) for index in range(1_200)]

    @classmethod
    def one(cls, predicate: Callable[[dict[str, Any]], bool]) -> dict[str, Any]:
        return deepcopy(next(record for record in cls.records if predicate(record)))

    def assert_rejected(self, record: dict[str, Any], failure: str) -> dict[str, Any]:
        verdict = validate_record_quality_v2(record)
        self.assertEqual(verdict["disposition"], "REJECT")
        self.assertFalse(verdict["training_ready"])
        self.assertIn(failure, verdict["hard_failures"])
        return verdict

    def test_positive_one_record_from_every_family(self):
        by_family = {}
        for record in self.records:
            by_family.setdefault(record["task_family"], record)
        self.assertEqual(set(by_family), set(EXPECTED_TASK_FAMILIES_V2))
        for family, record in by_family.items():
            with self.subTest(family=family):
                verdict = validate_record_quality_v2(record)
                self.assertEqual(verdict["hard_failures"], [])
                self.assertEqual(verdict["disposition"], "KEEP")

    def test_visible_query_and_schema_are_hard_gates(self):
        record = self.one(lambda row: row["primitive"] == "EXTRACT")
        del record["task_spec"]["query"]
        del record["task_spec"]["requested_schema"]
        _rehash(record)
        verdict = self.assert_rejected(record, "MODEL_VISIBLE_QUERY_FIELD_MISSING_OR_INVALID")
        self.assertIn("MODEL_VISIBLE_REQUESTED_SCHEMA_MISSING", verdict["hard_failures"])

    def test_family_input_signature_mutation_is_rejected(self):
        record = self.one(lambda row: row["task_family"] == "ASR_NBEST_RANKING")
        record["inputs"][0]["type"] = "generic_retrieval_query"
        _rehash(record)
        self.assert_rejected(record, "TASK_FAMILY_INPUT_SIGNATURE_MISMATCH")

    def test_locate_found_wrong_valid_unit_is_rejected(self):
        record = self.one(
            lambda row: row["primitive"] == "LOCATE"
            and row["target"]["decision"] == "FOUND"
            and not row["task_family"].startswith("LONG_CONTEXT")
        )
        correct = record["target"]["locations"][0]
        wrong = next(
            unit["id"]
            for item in record["inputs"]
            for unit in item["units"]
            if unit["id"] != correct
        )
        record["target"]["locations"] = [wrong]
        record["target"]["evidence"] = [wrong]
        record["target"]["action"]["arguments"]["unit_ids"] = [wrong]
        self.assert_rejected(
            record, "LOCATE_GOLD_NOT_REPRODUCIBLE_FROM_VISIBLE_ATTRIBUTES"
        )

    def test_locate_contradictory_abstention_is_rejected(self):
        record = self.one(
            lambda row: row["primitive"] == "LOCATE"
            and row["target"]["decision"] == "ABSTAIN"
            and not row["task_family"].startswith("LONG_CONTEXT")
        )
        required = record["task_spec"]["constraints"]["required_attributes"]
        unit = record["inputs"][0]["units"][0]
        unit.setdefault("attributes", {}).update(required)
        unit["text"] += "；" + "；".join(str(value) for value in required.values())
        _rehash(record)
        self.assert_rejected(
            record, "LOCATE_ABSTAIN_CONTRADICTED_BY_VISIBLE_INPUT"
        )

    def test_rank_synchronised_winner_tamper_is_rejected(self):
        record = self.one(lambda row: row["primitive"] == "RANK")
        ranking = record["target"]["ranking"]
        ranking[0], ranking[1] = ranking[1], ranking[0]
        # Make every target field internally agree with the false winner.
        descending = sorted(record["target"]["graded_relevance"].values(), reverse=True)
        record["target"]["graded_relevance"] = dict(zip(ranking, descending))
        record["target"]["evidence"] = [ranking[0]]
        record["target"]["action"]["arguments"]["ordered_ids"] = list(ranking)
        self.assert_rejected(
            record, "RANK_GRADES_NOT_REPRODUCIBLE_FROM_VISIBLE_ATTRIBUTES"
        )

    def test_rank_relevance_leak_is_rejected(self):
        record = self.one(lambda row: row["primitive"] == "RANK")
        candidates = next(item for item in record["inputs"] if "candidate" in item["type"])
        candidates["units"][0]["relevance"] = 3
        _rehash(record)
        self.assert_rejected(record, "GOLD_SIGNAL_EXPOSED_IN_CANDIDATE_INPUT")

    def test_match_synchronised_id_tamper_is_rejected(self):
        record = self.one(lambda row: row["primitive"] == "MATCH")
        candidates = next(item for item in record["inputs"] if "candidate" in item["type"])
        winner = record["target"]["canonical_id"]
        wrong = next(unit["id"] for unit in candidates["units"] if unit["id"] != winner)
        record["target"]["decision"] = wrong
        record["target"]["canonical_id"] = wrong
        record["target"]["matches"] = [wrong]
        record["target"]["action"]["arguments"]["candidate_id"] = wrong
        record["target"]["evidence"] = [record["inputs"][0]["units"][0]["id"], wrong]
        self.assert_rejected(
            record, "MATCH_GOLD_NOT_REPRODUCIBLE_FROM_VISIBLE_ATTRIBUTES"
        )

    def test_align_suffix_shortcut_is_rejected(self):
        record = self.one(lambda row: row["primitive"] == "ALIGN")
        replacements = {}
        for index, alignment in enumerate(record["target"]["alignments"], 1):
            replacements[alignment["source"][0]] = f"src:u{index:02d}"
            replacements[alignment["target"][0]] = f"tgt:u{index:02d}"
        mutated = _replace_strings(record, replacements)
        _rehash(mutated)
        verdict = self.assert_rejected(mutated, "ALIGNMENT_IDS_NOT_OPAQUE")
        self.assertIn("ALIGNMENT_ID_SUFFIX_LEAKS_GOLD", verdict["hard_failures"])

    def test_align_opaque_destination_swap_is_rejected(self):
        record = self.one(lambda row: row["primitive"] == "ALIGN")
        alignments = record["target"]["alignments"]
        alignments[0]["target"], alignments[1]["target"] = (
            alignments[1]["target"],
            alignments[0]["target"],
        )
        self.assert_rejected(
            record, "ALIGN_GOLD_NOT_REPRODUCIBLE_FROM_VISIBLE_CONTENT"
        )

    def test_edit_replacement_and_output_tamper_is_rejected(self):
        record = self.one(
            lambda row: row["primitive"] == "EDIT"
            and row["target"]["action"]["arguments"].get("op") == "REPLACE"
        )
        operation = record["target"]["edit_operations"][0]
        operation["replacement"] = "這是同步竄改後的錯誤內容。"
        record["target"]["action"]["arguments"] = deepcopy(operation)
        hypothesis = next(item for item in record["inputs"] if item["id"] == "hyp")
        record["target"]["output_text"] = "".join(
            operation["replacement"] if unit["id"] == operation["target"] else unit["text"]
            for unit in hypothesis["units"]
        )
        self.assert_rejected(record, "EDIT_OPERATION_NOT_EXECUTABLE_TO_GOLD_OUTPUT")

    def test_classify_synchronised_label_tamper_is_rejected(self):
        record = self.one(lambda row: row["primitive"] == "CLASSIFY")
        old = record["target"]["decision"]
        wrong = next(label for label in record["task_spec"]["allowed_labels"] if label != old)
        record["target"]["decision"] = wrong
        record["target"]["label"] = wrong
        record["target"]["action"]["arguments"]["label"] = wrong
        self.assert_rejected(record, "CLASSIFY_GOLD_DIFFERS_FROM_VISIBLE_CONTENT_RULE")

    def test_domain_cue_ignores_domain_words_inside_organisation_name(self):
        record = generate_record_v2(self.config, self.plan, 30_033)
        self.assertEqual(record["task_family"], "DOMAIN_CLASSIFICATION")
        self.assertIn("南風教育科技室", record["inputs"][0]["units"][0]["text"])
        self.assertIn("文化典藏領域", record["inputs"][0]["units"][0]["text"])
        self.assertEqual(record["target"]["decision"], "CULTURE")
        self.assertEqual(validate_record_quality_v2(record)["hard_failures"], [])

    def test_extract_alternate_substring_tamper_is_rejected(self):
        record = self.one(lambda row: row["primitive"] == "EXTRACT")
        field = record["target"]["fields"][0]
        evidence_text = next(
            unit["text"]
            for item in record["inputs"]
            for unit in item["units"]
            if unit["id"] == field["evidence"][0]
        )
        field["value"] = evidence_text[:2]
        self.assert_rejected(
            record, "EXTRACT_GOLD_NOT_REPRODUCIBLE_FROM_FIELD_ORACLE"
        )

    def test_extract_swapped_field_values_are_rejected(self):
        record = self.one(lambda row: row["primitive"] == "EXTRACT")
        fields = record["target"]["fields"]
        fields[0]["value"], fields[1]["value"] = fields[1]["value"], fields[0]["value"]
        self.assert_rejected(
            record, "EXTRACT_GOLD_NOT_REPRODUCIBLE_FROM_FIELD_ORACLE"
        )

    def test_verify_pass_candidate_tamper_is_rejected(self):
        record = self.one(
            lambda row: row["primitive"] == "VERIFY"
            and row["target"]["decision"] == "PASS"
            and not row["task_family"].startswith("LONG_CONTEXT")
        )
        candidate = next(item for item in record["inputs"] if "candidate" in item["type"] or "hypothesis" in item["type"])
        candidate["units"][0]["text"] += "錯誤增補"
        _rehash(record)
        self.assert_rejected(record, "VERIFY_PASS_REFERENCE_CANDIDATE_NOT_EQUAL")

    def test_verify_false_pass_target_tamper_is_rejected(self):
        record = self.one(
            lambda row: row["primitive"] == "VERIFY"
            and row["target"]["decision"] == "FAIL"
            and not row["task_family"].startswith("LONG_CONTEXT")
        )
        candidate = next(item for item in record["inputs"] if "candidate" in item["type"] or "hypothesis" in item["type"])
        record["target"].update(
            {
                "decision": "PASS",
                "quality_score": 1.0,
                "errors": [],
                "action": {"tool": "ACCEPT", "arguments": {"candidate_id": candidate["units"][0]["id"]}},
            }
        )
        self.assert_rejected(record, "VERIFY_PASS_REFERENCE_CANDIDATE_NOT_EQUAL")

    def test_verify_repair_tamper_is_rejected(self):
        record = self.one(
            lambda row: row["primitive"] == "VERIFY"
            and row["target"]["decision"] == "FAIL"
            and not row["task_family"].startswith("LONG_CONTEXT")
        )
        record["target"]["action"]["arguments"]["replacement"] = "錯誤修復結果。"
        self.assert_rejected(record, "VERIFY_REPAIR_DOES_NOT_REACH_REFERENCE")

    def test_long_context_verify_all_three_outcomes_are_executable(self):
        outcomes = {}
        for record in self.records:
            if record["task_family"] == "LONG_CONTEXT_CONTRADICTION":
                outcomes.setdefault(record["target"]["decision"], record)
        self.assertEqual(set(outcomes), {"PASS", "FAIL", "UNCERTAIN"})
        for outcome, record in outcomes.items():
            with self.subTest(outcome=outcome):
                self.assertEqual(validate_record_quality_v2(record)["disposition"], "KEEP")

    def test_long_context_uncertainty_without_two_conflicts_is_rejected(self):
        record = self.one(
            lambda row: row["task_family"] == "LONG_CONTEXT_CONTRADICTION"
            and row["target"]["decision"] == "UNCERTAIN"
        )
        conflict = next(
            unit
            for item in record["inputs"]
            for unit in item["units"]
            if unit.get("attributes", {}).get("status") == "active_conflict"
        )
        conflict["attributes"]["status"] = "context"
        _rehash(record)
        self.assert_rejected(record, "VERIFY_UNCERTAIN_LEDGER_CONFLICT_NOT_REPRODUCIBLE")

    def test_route_synchronised_action_tamper_is_rejected(self):
        record = self.one(
            lambda row: row["primitive"] == "ROUTE"
            and row["task_family"] == "TOOL_ROUTING"
            and row["target"]["decision"] == "EDIT"
        )
        record["target"]["decision"] = "RETRIEVE"
        record["target"]["action"] = {
            "tool": "RETRIEVE",
            "arguments": {"query": "查詢另一份紀錄"},
        }
        self.assert_rejected(record, "ROUTE_GOLD_NOT_REPRODUCIBLE_FROM_VISIBLE_ATTRIBUTES")

    def test_verify_uncertainty_is_rejected_when_any_authority_restores_date(self):
        for family in ("ASR_QUALITY", "OCR_QUALITY", "MT_QUALITY"):
            record = self.one(lambda row: row["task_family"] == family and row["target"]["decision"] == "UNCERTAIN")
            candidate = next(item for item in record["inputs"] if item["id"] == "hyp")
            dated_text = next(unit["text"] for unit in candidate["units"] if " 年 " in unit["text"])
            authority = next(item for item in record["inputs"] if item["id"] == ("source" if family == "MT_QUALITY" else "ref"))
            authority["units"].append({"id": "ref:restored", "text": dated_text})
            _rehash(record)
            self.assert_rejected(record, "VERIFY_UNCERTAIN_DECISIVE_DATE_STILL_VISIBLE")

    def test_candidate_state_gold_leak_is_rejected(self):
        for primitive in ("VERIFY", "ROUTE"):
            record = self.one(lambda row: row["primitive"] == primitive)
            record["inputs"][0]["units"][0].setdefault("attributes", {})["candidate_state"] = "consistent"
            _rehash(record)
            self.assert_rejected(record, "GOLD_ANNOTATION_EXPOSED_IN_INPUT")

    def test_character_confusion_is_not_a_numeric_value_error(self):
        for family in ("ASR_CORRECTION", "OCR_CORRECTION"):
            record = self.one(lambda row: row["task_family"] == family)
            record["target"]["errors"][0]["type"] = "VALUE_CORRUPTION"
            self.assert_rejected(record, "VALUE_CORRUPTION_WITHOUT_NUMERIC_CHANGE")

    def test_rank_error_sentinel_is_rejected(self):
        record = self.one(lambda row: row["primitive"] == "RANK")
        record["inputs"][1]["units"][0]["text"] += " 不符-location-1-9"
        _rehash(record)
        self.assert_rejected(record, "GOLD_SIGNAL_EXPOSED_IN_CANDIDATE_TEXT")

    def test_route_edit_must_modify_candidate_not_observation(self):
        record = self.one(lambda row: row["task_family"] == "TOOL_ROUTING" and row["target"]["decision"] == "EDIT")
        record["target"]["action"]["arguments"]["target"] = "obs:u01"
        self.assert_rejected(record, "ROUTE_EDIT_TARGET_NOT_CANDIDATE")

    def test_route_pointer_must_address_matching_coordinate_unit(self):
        record = self.one(lambda row: row["task_family"] == "MODALITY_ROUTING" and row["target"]["decision"] == "POINT_TIME")
        record["target"]["action"]["arguments"]["unit_ids"] = ["modality:u01"]
        self.assert_rejected(record, "ROUTE_POINTER_COORDINATE_TYPE_MISMATCH")

    def test_classifier_corpus_gate_detects_missing_labels(self):
        record = self.one(lambda row: row["task_family"] == "EMOTION_CLASSIFICATION")
        accumulator = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1)
        for split in ("train", "validation", "test"):
            example = deepcopy(record)
            example["split"] = split
            accumulator.add(example, {"disposition": "KEEP", "hard_failures": []})
        gate = accumulator.finalize()["gates"]["classification_label_coverage:EMOTION_CLASSIFICATION"]
        self.assertFalse(gate["passed"])
        self.assertEqual(len(gate["missing_by_split"]["train"]), 3)

    def test_provenance_source_content_hash_tamper_is_rejected(self):
        record = deepcopy(self.records[0])
        record["provenance"]["source_hash"] = "0" * 64
        self.assert_rejected(record, "PROVENANCE_SOURCE_CONTENT_HASH_MISMATCH")

    def test_serializer_target_non_json_tamper_is_rejected(self):
        record = deepcopy(self.records[0])
        record["target"]["non_json_probe"] = ("tuple", "is", "not", "canonical-json")
        self.assert_rejected(record, "SERIALIZER_SEMANTIC_ROUNDTRIP_FAILED")

    def test_confidence_cannot_claim_calibration_gold(self):
        record = deepcopy(self.records[0])
        record["target"]["confidence_semantics"] = "calibration_gold"
        self.assert_rejected(record, "TARGET_CONFIDENCE_SEMANTICS_MISLABELLED")

    def test_traditional_chinese_term_gate(self):
        record = deepcopy(self.records[0])
        record["inputs"][0]["units"][0]["text"] += "软件與服務器"
        _rehash(record)
        self.assert_rejected(record, "SIMPLIFIED_OR_NON_TW_TERM_DETECTED")

    def test_long_ledger_repetition_gate(self):
        record = self.one(lambda row: row["task_family"] == "LONG_CONTEXT_ACTIVE_VALUE")
        repeated = "更新：同一段填充內容反覆出現。"
        for unit in record["inputs"][0]["units"]:
            unit["text"] = repeated
        _rehash(record)
        verdict = validate_record_quality_v2(record)
        self.assertIn("WITHIN_RECORD_TEMPLATE_REPETITION_HIGH", verdict["hard_failures"])
        self.assertIn("LONG_LEDGER_TEMPLATE_DIVERSITY_TOO_LOW", verdict["hard_failures"])

    def test_ledger_event_type_must_agree_with_visible_sentence(self):
        record = self.one(lambda row: row["task_family"] == "LONG_CONTEXT_ACTIVE_VALUE")
        event = record["inputs"][0]["units"][0]
        event["attributes"]["event_type"] = "not_the_visible_event"
        _rehash(record)
        self.assert_rejected(record, "LEDGER_EVENT_TYPE_CONTRADICTS_VISIBLE_TEXT")

    def test_context_bucket_and_measure_tamper_are_rejected(self):
        record = self.one(lambda row: row["quality"]["context_length_bucket"] == "SHORT_LT_0.5K")
        record["quality"]["context_length_bucket"] = "64K-128K"
        record["quality"]["context_length_measure"] = "pangolin_tokens"
        verdict = self.assert_rejected(
            record, "CONTEXT_LENGTH_BUCKET_DOES_NOT_MATCH_VISIBLE_TEXT_CHARS"
        )
        self.assertIn("CONTEXT_LENGTH_MEASURE_MISSING_OR_MISLABELLED", verdict["hard_failures"])

    def test_accumulator_merge_matches_single_pass_and_is_pickle_safe(self):
        records = self.records[:120]
        single = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1)
        left = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1)
        right = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1)
        for index, record in enumerate(records):
            verdict = validate_record_quality_v2(record)
            single.add(record, verdict)
            (left if index < 60 else right).add(record, verdict)
        pickle.loads(pickle.dumps(left))
        left.merge(right)
        self.assertEqual(left.finalize(), single.finalize())

    def test_accumulator_fails_closed_for_missing_families_and_splits(self):
        accumulator = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1)
        record = self.records[0]
        accumulator.add(record, validate_record_quality_v2(record))
        report = accumulator.finalize()
        self.assertFalse(report["promotion_passed"])
        self.assertFalse(report["gates"]["task_family_coverage"]["passed"])
        self.assertFalse(report["gates"]["split_coverage"]["passed"])

    def test_accumulator_detects_source_group_split_conflict(self):
        accumulator = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1)
        first = deepcopy(self.records[0])
        second = deepcopy(first)
        second["split"] = "validation"
        second["presentation"]["template_profile"] = "heldout_validation"
        accumulator.add(first, {"disposition": "KEEP", "hard_failures": []})
        accumulator.add(second, {"disposition": "KEEP", "hard_failures": []})
        gate = accumulator.finalize()["gates"]["source_group_split_lock"]
        self.assertFalse(gate["passed"])
        self.assertEqual(gate["conflict_count"], 1)

    def test_accumulator_detects_heldout_template_overlap_and_profile_mismatch(self):
        accumulator = PromotionAccumulator(minimum_family_records=1, minimum_template_variants=1)
        base = deepcopy(self.records[0])
        for split, profile in (
            ("train", "train_core"),
            ("validation", "heldout_validation"),
            ("test", "wrong_profile"),
        ):
            record = deepcopy(base)
            record["record_id"] = f"bgd_tw_v2_{len(accumulator.family_counts):07d}"
            record["source_group"] = f"template-overlap:{split}"
            record["split"] = split
            record["presentation"]["template_profile"] = profile
            record["presentation"]["template_id"] = "deliberately-shared-template"
            accumulator.add(record, {"disposition": "KEEP", "hard_failures": []})
        report = accumulator.finalize()
        self.assertFalse(report["gates"]["heldout_template_isolation"]["passed"])
        self.assertFalse(report["gates"]["template_profile_split_contract"]["passed"])
        self.assertFalse(report["gates"]["context_bucket_distribution"]["passed"])

    def test_accumulator_rejects_skewed_winner_position(self):
        record = self.one(lambda row: row["primitive"] == "RANK")
        family = record["task_family"]
        accumulator = PromotionAccumulator(minimum_family_records=40, minimum_template_variants=1)
        verdict = validate_record_quality_v2(record)
        for _ in range(40):
            accumulator.add(record, verdict)
        gate = accumulator.finalize()["gates"][f"winner_position_balance:{family}"]
        self.assertFalse(gate["passed"])
        self.assertGreater(gate["max_relative_deviation"], 0.25)

    def test_accumulator_verify_outcome_distribution(self):
        family = "ASR_QUALITY"
        outcomes = {}
        for record in self.records:
            if record["task_family"] == family:
                outcomes.setdefault(record["target"]["decision"], record)
        self.assertEqual(set(outcomes), {"PASS", "FAIL", "UNCERTAIN"})
        accumulator = PromotionAccumulator(minimum_family_records=3, minimum_template_variants=1)
        for record in outcomes.values():
            accumulator.add(record, validate_record_quality_v2(record))
        report = accumulator.finalize()
        gate = report["gates"][f"verify_outcome_balance:{family}"]
        self.assertTrue(gate["passed"])
        self.assertEqual(gate["decisions"], {"FAIL": 1, "PASS": 1, "UNCERTAIN": 1})
        self.assertIn(family, report["family_confidence_distribution"])
        self.assertIn(family, report["family_normalized_template_counts"])


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