"""Static-review follow-up regressions. Execution is deferred by user request."""
import contextlib
import io
import json
import sys
import unittest
from types import SimpleNamespace
from unittest.mock import Mock, patch

from app.common.validation import PayloadError, parse_payload, validate_structure
from app.worker.consumer import ProcessingWorker
from scripts import generate_traffic
from tests.test_api_delivery import payload


class TestVerifierContract(unittest.TestCase):
    def test_missing_kafka_evidence_fails_before_sending_traffic(self):
        unavailable = SimpleNamespace(KafkaEvidence=Mock(side_effect=ConnectionError("offline")))
        with patch.dict(sys.modules, {"verification_kafka": unavailable}), \
                patch.object(generate_traffic, "send_http_request") as request, \
                contextlib.redirect_stdout(io.StringIO()):
            result = generate_traffic.run_verification("http://unused", "http://unused", "http://unused", 1, 1)
        self.assertEqual(result, 1)
        request.assert_not_called()

    def test_worker_unavailable_is_not_a_zero_stats_snapshot(self):
        with patch.object(generate_traffic, "fetch_json", return_value={"pipeline": {"worker_status": "unreachable"}}):
            self.assertIsNone(generate_traffic.stats_snapshot("http://unused"))

    def test_overflowing_json_float_is_rejected_even_in_extra_fields(self):
        with self.assertRaises(PayloadError):
            parse_payload(b'{"extra":1e400}')

    def test_unpaired_surrogate_is_not_an_encodable_record_identity(self):
        data = payload() | {"raw_id": "\ud800"}
        with self.assertRaises(PayloadError):
            validate_structure(parse_payload(json.dumps(data).encode()))

    def test_deeply_nested_bad_json_can_be_preserved_for_dlq(self):
        body = b"[" * 2000 + b"0" + b"]" * 2000
        self.assertEqual(ProcessingWorker._original(SimpleNamespace(value=lambda: body)), body.decode())