components/cronet/tools/breakages_unittest.py

# Copyright 2026 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import unittest
import json
import os
import re
import sys

REPOSITORY_ROOT = os.path.abspath(
    os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, os.pardir))

sys.path.insert(0, REPOSITORY_ROOT)

import components.cronet.tools.breakages_constants as breakages_constants  # pylint: disable=wrong-import-position
import components.cronet.tools.utils as cronet_utils  # pylint: disable=wrong-import-position

FILE_PATH = os.path.join(REPOSITORY_ROOT, 'components', 'cronet', 'android',
                         'breakages.json')


class TestBreakagesJson(unittest.TestCase):

  parsed_breakages = []

  @classmethod
  def createFromBreakagesJson(cls):
    """Loads the JSON file once before tests run."""
    if not os.path.exists(FILE_PATH):
      raise FileNotFoundError(
          f"CRITICAL: The file '{FILE_PATH}' could not be found.")

    content = json.loads(cronet_utils.read_file(FILE_PATH))
    if "breakages" not in content:
      raise ValueError("CRITICAL: Root of JSON must contain a 'breakages' key.")

    if not isinstance(content["breakages"], list):
      raise ValueError("CRITICAL: 'breakages' key must contain a list.")

    cls.parsed_breakages = content["breakages"]

  def _is_valid_change_id(self, change_id):
    if not isinstance(change_id, str):
      return False
    pattern = r'^I[0-9a-fA-F]{40}$'
    zeros_pattern = r'^I00*$'
    return bool(
        re.fullmatch(pattern, change_id)
        and not re.fullmatch(zeros_pattern, change_id))

  def _format_error(self, entry, message):
    entry_str = json.dumps(entry, indent=2)
    return f"\n{message}\n\nFailing Entry:\n{entry_str}\n"

  def test_id_validation_logic(self):
    self.assertTrue(self._is_valid_change_id("I" + "a" * 40))
    self.assertFalse(self._is_valid_change_id("I" + "a" * 39))  # Too short
    self.assertFalse(self._is_valid_change_id("a" * 40))  # Missing 'I'
    self.assertFalse(self._is_valid_change_id("I" + "z" * 40))  # Non-hex
    self.assertFalse(self._is_valid_change_id("I" + "0" * 40))  # All zeros

  def test_missing_mandatory_keys(self):
    required_keys = [
        breakages_constants.BUG_TXT, breakages_constants.BAD_CHANGE_ID_TXT,
        breakages_constants.GOOD_CHANGE_IDS_TXT, breakages_constants.COMMENT_TXT
    ]

    for entry in self.parsed_breakages:
      for key in required_keys:
        self.assertIn(
            key, entry,
            self._format_error(entry, f"Missing mandatory key: '{key}'"))

  def test_unknown_keys(self):
    allowed_keys = {
        breakages_constants.GOOD_CHANGE_IDS_TXT,
        breakages_constants.BAD_CHANGE_ID_TXT, breakages_constants.BUG_TXT,
        breakages_constants.COMMENT_TXT
    }

    for entry in self.parsed_breakages:
      for key in entry:
        if key.startswith('_'):
          continue  # comments are allowed
        self.assertIn(
            key, allowed_keys,
            self._format_error(
                entry, f"Unknown key found: '{key}'. Allowed: {allowed_keys}"))

  def test_bad_change_id_format_in_file(self):
    """Test that 'bad_change_id' entries in the file follow the regex."""
    for entry in self.parsed_breakages:
      val = entry[breakages_constants.BAD_CHANGE_ID_TXT]
      self.assertTrue(
          self._is_valid_change_id(val),
          self._format_error(
              entry,
              f"Invalid '{breakages_constants.BAD_CHANGE_ID_TXT}' format: '{val}'"
          ))

  def test_good_change_ids_is_list(self):
    for entry in self.parsed_breakages:
      val = entry[breakages_constants.GOOD_CHANGE_IDS_TXT]
      self.assertIsInstance(
          val, list,
          self._format_error(
              entry,
              f"'{breakages_constants.GOOD_CHANGE_IDS_TXT}' must be a list. Found {type(val)}"
          ))

  def test_good_change_ids_format_in_file(self):
    for entry in self.parsed_breakages:
      for val in entry[breakages_constants.GOOD_CHANGE_IDS_TXT]:
        self.assertTrue(
            self._is_valid_change_id(val),
            self._format_error(
                entry,
                f"Invalid ID in '{breakages_constants.GOOD_CHANGE_IDS_TXT}': '{val}'"
            ))


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