add unit tests

Author: uh-oh-monteiro

openhtf/util/validators.py

@@ -446,10 +446,9 @@ def __init__(self, regex_list: list[str], compiled_list: list[re.Pattern]) -> No
         self.regex_list = regex_list
         self._compiled_list = compiled_list
 
-    def __call__(self, value: str) -> bool:
-        str_value = str(value)
+    def __call__(self, candidate_str: str) -> bool:
         for compiled_pattern in self._compiled_list:
-            if compiled_pattern.match(str_value) is not None:
+            if compiled_pattern.match(candidate_str):
                 return True
         return False
 
@@ -467,22 +466,19 @@ def __ne__(self, other) -> bool:
         return not self == other
 
 @register
-def matches_any_regex(*regex_lists: list[list[str]]):
+def matches_any_regex(*regex_lists: tuple[list[str]]):
     """
     Creates a validator that checks if a value matches ANY of the provided regex patterns.
-
-    Accepts one or more lists of regex strings.
-    Example: matches_any_regex(['a.*'], ['b.*', 'c.*'])
     """
-    # 1. Amalgamate all lists into a single flat list of regex strings
+
     flat_regex_list = []
     for regex_list in regex_lists:
+        if not isinstance(regex_list, list) or not regex_list:
+            raise ValueError("Each argument must be a list of regex patterns.")
         flat_regex_list.extend(regex_list)
 
-    # 2. Compile the flat list of regex strings
     compiled_list = [re.compile(regex) for regex in flat_regex_list]
 
-    # 3. Pass both the original flat list and the compiled list to the matcher
     return MultiRegexMatcher(flat_regex_list, compiled_list)
 
 class WithinPercent(RangeValidatorBase):

test/util/validators_test.py

@@ -78,6 +78,42 @@ def test_with_custom_type(self):
     self.assertEqual(test_validator.maximum, 0x12)
 
 
+class TestSingleRegex(unittest.TestCase):
+  def test_single_regex(self):
+    pattern = r'^[A-Z]{3}\d{3}$'
+    validator = validators.matches_regex(pattern)
+    self.assertTrue(validator('ABC123'))
+    self.assertFalse(validator('abc123'))
+    self.assertFalse(validator('AB1234'))
+    self.assertFalse(validator('ABCD12'))
+
+
+class TestMultipleRegex(unittest.TestCase):
+  patterns_1 = [r'^[A-Z]{1}\d{1}$', r'^[A-Z]{2}\d{2}$', r'^[A-Z]{3}\d{3}$']
+  patterns_2 = [r'^\d{1}[A-Z]{1}$']
+  def test_multiple_regex_lists(self):
+
+    validator_1 = validators.matches_any_regex(TestMultipleRegex.patterns_1, TestMultipleRegex.patterns_2)
+    self.assertTrue(validator_1('ABC123'))
+    self.assertTrue(validator_1('A1'))
+    self.assertTrue(validator_1('1A'))
+    self.assertFalse(validator_1('123-ABCD'))
+  
+  def test_single_regex_list(self):
+    validator_2 = validators.matches_any_regex(TestMultipleRegex.patterns_2)
+    self.assertTrue(validator_2('1A'))
+    self.assertFalse(validator_2('A1'))
+
+  def test_invalid_arguments(self):
+    with self.assertRaisesRegex(ValueError, "Each argument must be a list of regex patterns."):
+      validators.matches_any_regex(r'^[A-Z]{3}\d{3}$')
+
+    with self.assertRaisesRegex(ValueError, "Each argument must be a list of regex patterns."):
+      validators.matches_any_regex([])
+
+    with self.assertRaisesRegex(ValueError, "Each argument must be a list of regex patterns."):
+      validators.matches_any_regex(r'd{3}', r'd{4}')
+
 class TestAllInRange(unittest.TestCase):
 
   def setUp(self):
@@ -395,3 +431,7 @@ def phase(test):
 
     phase_record = yield phase
     self.assertMeasurementFail(phase_record, 'pivot')
+
+if __name__ == '__main__':
+  from unittest import main
+  main()