Chrome DevTools MCP：从报错到可复查的前端诊断

"""Offline synthetic-data exercise; never connects to Chrome or a network."""
import argparse
import hashlib
import json
from pathlib import Path
from urllib.parse import urlsplit


def require(condition, message):
    if not condition:
        raise ValueError(message)


def exact(obj, keys):
    require(type(obj) is dict and set(obj) == set(keys), 'invalid fields')


def integer(value, minimum=0):
    require(type(value) is int and value >= minimum, 'invalid integer')


def text(value):
    require(type(value) is str and bool(value), 'invalid text')


def no_duplicates(pairs):
    result = {}
    for key, value in pairs:
        require(key not in result, 'duplicate JSON key')
        result[key] = value
    return result


def read_json(path):
    return json.loads(Path(path).read_text(encoding='utf-8'),
                      object_pairs_hook=no_duplicates)


def digest(data):
    raw = json.dumps(data, sort_keys=True, separators=(',', ':'),
                     ensure_ascii=True, allow_nan=False)
    return hashlib.sha256(raw.encode()).hexdigest()


def diagnose(data):
    exact(data, ['schema', 'synthetic', 'navigation', 'console', 'network',
                 'button_disabled'])
    require(type(data['schema']) is int and data['schema'] == 1, 'schema')
    require(data['synthetic'] is True, 'only synthetic fixtures are accepted')
    text(data['navigation'])
    require(type(data['button_disabled']) is bool, 'invalid button state')
    findings = []
    counts = {'console_errors': 0, 'http_errors': 0, 'transport_errors': 0}
    evidence = []
    export_seen = False
    for group, key in [('console', 'msgid'), ('network', 'reqid')]:
        rows = data[group]
        require(type(rows) is list, 'invalid collection')
        seen = set()
        for row in rows:
            fields = [key, 'navigation']
            fields += ['type', 'text'] if group == 'console' else ['url', 'status']
            exact(row, fields)
            integer(row[key], 1)
            require(row[key] not in seen, 'duplicate record id')
            seen.add(row[key])
            require(row['navigation'] == data['navigation'], 'mixed navigation')
            ref = ('C' if group == 'console' else 'N') + str(row[key])
            evidence.append(ref)
            if group == 'console':
                require(row['type'] in ['log', 'info', 'warn', 'error'], 'type')
                text(row['text'])
                if row['type'] == 'error':
                    counts['console_errors'] += 1
                    findings.append({'kind': 'js_error', 'evidence': ref})
            else:
                text(row['url'])
                url = urlsplit(row['url'])
                require(url.scheme == 'https' and url.netloc == 'demo.invalid',
                        'fixture origin must be https://demo.invalid')
                integer(row['status'])
                status = row['status']
                require(status == 0 or 100 <= status <= 599, 'status range')
                is_export = url.path == '/api/export'
                export_seen |= is_export
                if is_export and 100 <= status < 400 and not 200 <= status < 300:
                    findings.append({'kind': 'export_not_2xx', 'evidence': ref})
                if status == 0 or status >= 400:
                    kind = 'transport_error' if status == 0 else 'http_error'
                    counts['transport_errors' if status == 0 else 'http_errors'] += 1
                    findings.append({'kind': kind, 'evidence': ref,
                                     'status': status, 'path': url.path})
    if data['button_disabled']:
        findings.append({'kind': 'button_disabled', 'evidence': 'UI:export'})
    evidence.append('UI:export')
    complete = export_seen
    verdict = 'inconclusive' if not complete else ('fail' if findings else 'pass')
    return {'schema': 1, 'synthetic': True, 'input_sha256': digest(data),
            'navigation': data['navigation'], 'verdict': verdict,
            'complete': complete, 'counts': counts, 'findings': findings,
            'evidence': evidence, 'real_browser_verified': False}


def verify(data, report):
    expected = diagnose(data)
    require(digest(expected) == digest(report), 'report differs from input')
    return True


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('fixture')
    parser.add_argument('--verify', metavar='REPORT')
    args = parser.parse_args()
    try:
        data = read_json(args.fixture)
        report = diagnose(data)
        if args.verify:
            verify(data, read_json(args.verify))
        print(json.dumps(report, indent=2, ensure_ascii=False))
        return 0 if report['verdict'] == 'pass' else 1
    except (ValueError, TypeError, OSError) as exc:
        parser.exit(2, 'invalid input or report: ' + str(exc) + '\n')


if __name__ == '__main__':
    raise SystemExit(main())

{
  "schema": 1,
  "synthetic": true,
  "navigation": "demo-before",
  "console": [
    {
      "msgid": 1,
      "navigation": "demo-before",
      "type": "error",
      "text": "TypeError: export configuration is missing"
    }
  ],
  "network": [
    {
      "reqid": 1,
      "navigation": "demo-before",
      "url": "https://demo.invalid/api/export?token=synthetic-only#debug",
      "status": 404
    }
  ],
  "button_disabled": true
}

{
  "schema": 1,
  "synthetic": true,
  "navigation": "demo-before",
  "console": [],
  "network": [
    {
      "reqid": 1,
      "navigation": "demo-before",
      "url": "https://demo.invalid/api/export?token=synthetic-only#debug",
      "status": 200
    }
  ],
  "button_disabled": false
}

import copy
import json
from pathlib import Path
import tempfile
import unittest
from diagnose import diagnose, read_json, verify


FIXTURE = Path(__file__).with_name('fixtures.json')


def sample():
    return read_json(FIXTURE)


def good():
    data = sample()
    data['console'] = []
    data['network'][0]['status'] = 200
    data['button_disabled'] = False
    return data


class DiagnosticTests(unittest.TestCase):
    def test_before_has_three_findings(self):
        report = diagnose(sample())
        self.assertEqual(report['verdict'], 'fail')
        self.assertEqual(len(report['findings']), 3)

    def test_after_passes_only_synthetic_checks(self):
        report = diagnose(good())
        self.assertEqual(report['verdict'], 'pass')
        self.assertIs(report['real_browser_verified'], False)

    def test_report_verifies(self):
        data = sample()
        self.assertTrue(verify(data, diagnose(data)))

    def test_tampered_report_rejected(self):
        data = sample()
        report = diagnose(data)
        report['verdict'] = 'pass'
        with self.assertRaises(ValueError):
            verify(data, report)

    def test_changed_input_rejected(self):
        data = sample()
        report = diagnose(data)
        data['network'][0]['status'] = 200
        with self.assertRaises(ValueError):
            verify(data, report)

    def test_missing_export_is_inconclusive(self):
        data = good()
        data['network'] = []
        self.assertEqual(diagnose(data)['verdict'], 'inconclusive')

    def test_query_and_fragment_not_in_report(self):
        result = json.dumps(diagnose(sample()))
        self.assertNotIn('synthetic-only', result)
        self.assertNotIn('#debug', result)

    def test_console_text_not_in_report(self):
        self.assertNotIn('TypeError', json.dumps(diagnose(sample())))

    def test_transport_failure_counted(self):
        data = good()
        data['network'][0]['status'] = 0
        self.assertEqual(diagnose(data)['counts']['transport_errors'], 1)

    def test_500_is_http_error(self):
        data = good()
        data['network'][0]['status'] = 500
        self.assertEqual(diagnose(data)['counts']['http_errors'], 1)

    def test_warning_does_not_fail(self):
        data = good()
        row = sample()['console'][0]
        row['type'] = 'warn'
        data['console'] = [row]
        self.assertEqual(diagnose(data)['verdict'], 'pass')

    def test_mixed_navigation_rejected(self):
        data = sample()
        data['console'][0]['navigation'] = 'older'
        with self.assertRaises(ValueError):
            diagnose(data)

    def test_duplicate_ids_rejected(self):
        data = sample()
        data['network'].append(copy.deepcopy(data['network'][0]))
        with self.assertRaises(ValueError):
            diagnose(data)

    def test_unknown_field_rejected(self):
        data = sample()
        data['cookie'] = 'synthetic'
        with self.assertRaises(ValueError):
            diagnose(data)

    def test_real_capture_rejected(self):
        data = sample()
        data['synthetic'] = False
        with self.assertRaises(ValueError):
            diagnose(data)

    def test_bool_status_rejected(self):
        data = sample()
        data['network'][0]['status'] = True
        with self.assertRaises(ValueError):
            diagnose(data)

    def test_status_range_rejected(self):
        for status in [-1, 42, 600]:
            with self.subTest(status=status):
                data = sample()
                data['network'][0]['status'] = status
                with self.assertRaises(ValueError):
                    diagnose(data)

    def test_other_origin_rejected(self):
        for url in ['https://other.invalid/api/export',
                    'https://user@demo.invalid/api/export',
                    'https://demo.invalid.evil.invalid/api/export']:
            data = sample()
            data['network'][0]['url'] = url
            with self.assertRaises(ValueError):
                diagnose(data)

    def test_duplicate_json_key_rejected(self):
        with tempfile.TemporaryDirectory() as directory:
            path = Path(directory) / 'duplicate.json'
            path.write_text('{"schema": 1, "schema": 1}', encoding='utf-8')
            with self.assertRaises(ValueError):
                read_json(path)

    def test_export_redirect_does_not_pass(self):
        data = good()
        data['network'][0]['status'] = 302
        self.assertEqual(diagnose(data)['verdict'], 'fail')

    def test_informational_status_does_not_pass(self):
        data = good()
        data['network'][0]['status'] = 103
        self.assertEqual(diagnose(data)['verdict'], 'fail')

    def test_boolean_report_schema_rejected(self):
        data = sample()
        report = diagnose(data)
        report['schema'] = True
        with self.assertRaises(ValueError):
            verify(data, report)


if __name__ == '__main__':
    unittest.main(verbosity=2)