Add 19 new invariant tests; fix BE-WAL, TJ-RA, JP-01, AD-07, MK-205, BY-HM, JO-JA, UA-30

test/test_invariants.py

@@ -8,9 +8,22 @@ Run from dataset root after cloning:
 Verifies:
 - name field matches lang selection (name_en/ru/zh)
 - lang matches region-based language rule
+- code format and uniqueness
+- region prefix matches code
+- all name fields in correct script
+- no typographic quotes in name_ru
+- balanced parentheses in all name fields
+- no whitespace anomalies in name fields
+- name_en starts uppercase
+- name_en has no trailing punctuation
+- no duplicate values within an entry's name fields
+- alt lists: primary not duplicated, no CJK/Cyrillic in names_en_alt
+- links are valid URLs with no duplicates per row
 """
 
+import re
 import pytest
+from collections import Counter
 from datasets import load_dataset
 
 SLAVIC_REGIONS = {
@@ -24,7 +37,6 @@ SINOPHONE_REGIONS = {
 
 
 def determine_expected_lang(region_code: str) -> str:
-    """Determine expected lang from region code."""
     if region_code in SINOPHONE_REGIONS:
         return 'zh'
     elif region_code in SLAVIC_REGIONS:
@@ -35,13 +47,16 @@ def determine_expected_lang(region_code: str) -> str:
 
 @pytest.fixture(scope="session")
 def dataset():
-    """Load dataset from HF Hub."""
     return load_dataset('cterdam/iso_3166-2', split='train')
 
 
+# ---------------------------------------------------------------------------
+# Existing tests
+# ---------------------------------------------------------------------------
+
 def test_lang_values_valid(dataset):
     """lang field must be one of: en, ru, zh."""
-    invalid = [(i, e['lang']) for i, e in enumerate(dataset) if e.get('lang') not in ('en', 'ru', 'zh')]
+    invalid = [(e['code'], e['lang']) for e in dataset if e.get('lang') not in ('en', 'ru', 'zh')]
     assert invalid == [], f"Invalid lang values: {invalid[:5]}"
 
 
@@ -49,49 +64,33 @@ def test_name_matches_lang_field(dataset):
     """name field must equal name_en/ru/zh based on lang."""
     lang_to_field = {'en': 'name_en', 'ru': 'name_ru', 'zh': 'name_zh'}
     mismatches = []
-
-    for i, entry in enumerate(dataset):
-        name = entry.get('name')
-        lang = entry.get('lang')
+    for e in dataset:
+        name = e.get('name')
+        lang = e.get('lang')
         if not name or not lang:
             continue
-
-        field_name = lang_to_field.get(lang)
-        lang_field_value = entry.get(field_name)
-
-        if name != lang_field_value:
-            mismatches.append((i, entry.get('code'), lang, name[:20], lang_field_value[:20] if lang_field_value else None))
-            if len(mismatches) >= 5:
-                break
-
-    assert mismatches == [], f"Name/lang field mismatches: {mismatches}"
+        lang_val = e.get(lang_to_field.get(lang, ''))
+        if name != lang_val:
+            mismatches.append((e['code'], lang, name[:30], (lang_val or '')[:30]))
+    assert mismatches == [], f"Name/lang field mismatches: {mismatches[:5]}"
 
 
 def test_lang_matches_parent_region(dataset):
     """lang field must match parent region's language rule."""
-    mismatches = []
-
-    for i, entry in enumerate(dataset):
-        region = entry.get('region')
-        lang = entry.get('lang')
-        expected_lang = determine_expected_lang(region)
-
-        if lang != expected_lang:
-            mismatches.append((i, entry.get('code'), region, lang, expected_lang))
-            if len(mismatches) >= 5:
-                break
-
-    assert mismatches == [], f"Lang mismatches: {mismatches}"
+    mismatches = [(e['code'], e.get('region'), e.get('lang'), determine_expected_lang(e.get('region', '')))
+                  for e in dataset
+                  if e.get('lang') != determine_expected_lang(e.get('region', ''))]
+    assert mismatches == [], f"Lang mismatches: {mismatches[:5]}"
 
 
 def _is_cjk(c):
     cp = ord(c)
     return (
-        0x3400 <= cp <= 0x9FFF       # CJK Unified + Extension A
-        or 0xF900 <= cp <= 0xFAFF    # CJK Compatibility Ideographs
-        or 0x20000 <= cp <= 0x2A6DF  # Extension B
-        or 0x2A700 <= cp <= 0x2EBEF  # Extensions C–F
-        or 0x30000 <= cp <= 0x323AF  # Extensions G–H
+        0x3400 <= cp <= 0x9FFF
+        or 0xF900 <= cp <= 0xFAFF
+        or 0x20000 <= cp <= 0x2A6DF
+        or 0x2A700 <= cp <= 0x2EBEF
+        or 0x30000 <= cp <= 0x323AF
     )
 
 
@@ -119,3 +118,183 @@ def test_name_ru_only_cyrillic_letters(dataset):
             if foreign:
                 bad.append((e['code'], v, foreign))
     assert bad == [], f"name_ru/alts with non-Cyrillic letters: {bad[:10]}"
+
+
+# ---------------------------------------------------------------------------
+# New tests
+# ---------------------------------------------------------------------------
+
+def test_code_format(dataset):
+    """code must match ^[A-Z]{2}-[A-Z0-9]{1,6}$."""
+    bad = [(e['code'],) for e in dataset
+           if not re.match(r'^[A-Z]{2}-[A-Z0-9]{1,6}$', e.get('code', ''))]
+    assert bad == [], f"Malformed codes: {bad[:10]}"
+
+
+def test_code_unique(dataset):
+    """Each code must be unique across the dataset."""
+    counts = Counter(e['code'] for e in dataset)
+    dups = [(c, n) for c, n in counts.items() if n > 1]
+    assert dups == [], f"Duplicate codes: {dups[:10]}"
+
+
+def test_region_matches_code_prefix(dataset):
+    """region must equal the country prefix of the code (e.g. AD-02 → region=AD)."""
+    bad = [(e['code'], e.get('region')) for e in dataset
+           if e.get('region') != (e.get('code', '') or '')[:2]]
+    assert bad == [], f"region != code prefix: {bad[:10]}"
+
+
+def test_no_typographic_quotes_in_ru(dataset):
+    """name_ru must not contain typographic quotes «»."""
+    bad = [(e['code'], e['name_ru']) for e in dataset
+           if e.get('name_ru') and re.search(r'[«»]', e['name_ru'])]
+    assert bad == [], f"name_ru with «» quotes: {bad[:10]}"
+
+
+def test_balanced_parentheses(dataset):
+    """All name fields must have balanced ASCII and fullwidth parentheses."""
+    bad = []
+    for e in dataset:
+        for f in ('name_en', 'name_ru', 'name_zh'):
+            v = e.get(f) or ''
+            if v.count('(') != v.count(')') or v.count('（') != v.count('）'):
+                bad.append((e['code'], f, v))
+    assert bad == [], f"Unbalanced parens: {bad[:10]}"
+
+
+def test_no_whitespace_in_names(dataset):
+    """Name fields must not have leading or trailing whitespace."""
+    bad = [(e['code'], f) for e in dataset for f in ('name_en', 'name_ru', 'name_zh')
+           if e.get(f) and e[f] != e[f].strip()]
+    assert bad == [], f"Leading/trailing whitespace: {bad[:10]}"
+
+
+def test_no_double_spaces_in_names(dataset):
+    """Name fields must not contain consecutive spaces."""
+    bad = [(e['code'], f) for e in dataset for f in ('name_en', 'name_ru', 'name_zh')
+           if e.get(f) and '  ' in e[f]]
+    assert bad == [], f"Double spaces: {bad[:10]}"
+
+
+def test_no_newlines_in_names(dataset):
+    """Name fields must not contain newline or tab characters."""
+    bad = [(e['code'], f) for e in dataset for f in ('name_en', 'name_ru', 'name_zh')
+           if any(c in (e.get(f) or '') for c in '\n\t\r')]
+    assert bad == [], f"Newline/tab in names: {bad[:10]}"
+
+
+def test_no_ideographic_space(dataset):
+    """Name fields and alt lists must not contain ideographic space U+3000."""
+    bad = []
+    for e in dataset:
+        for f in ('name_en', 'name_ru', 'name_zh'):
+            if '　' in (e.get(f) or ''):
+                bad.append((e['code'], f))
+        for lst in ('names_en_alt', 'names_ru_alt', 'names_zh_alt'):
+            for v in (e.get(lst) or []):
+                if '　' in v:
+                    bad.append((e['code'], lst))
+    assert bad == [], f"Ideographic space: {bad[:10]}"
+
+
+def test_name_en_starts_uppercase(dataset):
+    """name_en first alphabetic character must be uppercase."""
+    bad = [(e['code'], e['name_en']) for e in dataset
+           if e.get('name_en') and any(c.isalpha() for c in e['name_en'])
+           and next(c for c in e['name_en'] if c.isalpha()).islower()]
+    assert bad == [], f"name_en starts lowercase: {bad[:10]}"
+
+
+def test_name_en_not_allcaps(dataset):
+    """name_en must not be entirely uppercase."""
+    bad = [(e['code'], e['name_en']) for e in dataset
+           if e.get('name_en')
+           and e['name_en'] == e['name_en'].upper()
+           and e['name_en'].replace(' ', '').replace('-', '').isalpha()]
+    assert bad == [], f"name_en all-caps: {bad[:10]}"
+
+
+def test_name_en_no_trailing_punctuation(dataset):
+    """name_en must not end with ., ,, ;, :, !, ?."""
+    bad = [(e['code'], e['name_en']) for e in dataset
+           if e.get('name_en') and e['name_en'][-1] in '.,:;!?']
+    assert bad == [], f"name_en trailing punctuation: {bad[:10]}"
+
+
+def test_alt_names_not_duplicate_primary(dataset):
+    """No alt list item may equal its primary name field."""
+    bad = []
+    for e in dataset:
+        for field, primary_field in [
+            ('names_en_alt', 'name_en'),
+            ('names_ru_alt', 'name_ru'),
+            ('names_zh_alt', 'name_zh'),
+        ]:
+            primary = e.get(primary_field)
+            for v in (e.get(field) or []):
+                if v == primary:
+                    bad.append((e['code'], field, v))
+    assert bad == [], f"Alt duplicates primary: {bad[:10]}"
+
+
+def test_no_duplicate_names_within_entry(dataset):
+    """No value may appear twice across all name fields of a single row."""
+    bad = []
+    for e in dataset:
+        vals = []
+        for f in ('name_en', 'name_ru', 'name_zh'):
+            if e.get(f):
+                vals.append(e[f])
+        for lst in ('names_en_alt', 'names_ru_alt', 'names_zh_alt'):
+            vals += (e.get(lst) or [])
+        seen = set()
+        duped = set()
+        for v in vals:
+            if v in seen:
+                duped.add(v)
+            seen.add(v)
+        if duped:
+            bad.append((e['code'], sorted(duped)))
+    assert bad == [], f"Duplicate values within entry: {bad[:10]}"
+
+
+def test_links_are_urls(dataset):
+    """Every link must start with http:// or https://."""
+    bad = [(e['code'], l) for e in dataset for l in (e.get('links') or [])
+           if not l.startswith(('http://', 'https://'))]
+    assert bad == [], f"Bad links: {bad[:10]}"
+
+
+def test_no_duplicate_links(dataset):
+    """No duplicate URLs within a row's link list."""
+    bad = [(e['code'],) for e in dataset
+           if len(e.get('links') or []) != len(set(e.get('links') or []))]
+    assert bad == [], f"Duplicate links: {bad[:10]}"
+
+
+def test_alt_lists_balanced_parens(dataset):
+    """Alt list items must have balanced parentheses."""
+    bad = []
+    for e in dataset:
+        for lst in ('names_en_alt', 'names_ru_alt', 'names_zh_alt'):
+            for v in (e.get(lst) or []):
+                if v.count('(') != v.count(')') or v.count('（') != v.count('）'):
+                    bad.append((e['code'], lst, v))
+    assert bad == [], f"Unbalanced parens in alt lists: {bad[:10]}"
+
+
+def test_alt_lists_en_no_cjk(dataset):
+    """names_en_alt items must not contain CJK characters."""
+    bad = [(e['code'], v) for e in dataset
+           for v in (e.get('names_en_alt') or [])
+           if any(_is_cjk(c) for c in v)]
+    assert bad == [], f"CJK in names_en_alt: {bad[:10]}"
+
+
+def test_alt_lists_en_no_cyrillic(dataset):
+    """names_en_alt items must not contain Cyrillic characters."""
+    bad = [(e['code'], v) for e in dataset
+           for v in (e.get('names_en_alt') or [])
+           if any('Ѐ' <= c <= 'ӿ' for c in v)]
+    assert bad == [], f"Cyrillic in names_en_alt: {bad[:10]}"