sort automotive provider tests

Author: fcurella

tests/providers/test_automotive.py

@@ -55,39 +55,6 @@ class TestAzAz(_SimpleAutomotiveTestMixin):
     license_plate_pattern = re.compile(r"\d{2}-[A-Z]{2}-\d{3}")
 
 
-class TestSkSk(_SimpleAutomotiveTestMixin):
-    """Test sk_SK automotive provider methods"""
-
-    license_plate_pattern: Pattern = re.compile(r"(?P<prefix>[A-Z]{2})\d{3}[A-Z]{2}")
-
-    def perform_extra_checks(self, license_plate, match):
-        assert match.group("prefix") in SkSkAutomotiveProvider.license_plate_prefix
-
-
-class TestPtBr(_SimpleAutomotiveTestMixin):
-    """Test pt_BR automotive provider methods"""
-
-    license_plate_pattern: Pattern = re.compile(r"[A-Z]{3}-\d{1}[A-Z]{1}\d{2}")
-
-
-class TestPtPt(_SimpleAutomotiveTestMixin):
-    """Test pt_PT automotive provider methods"""
-
-    license_plate_pattern: Pattern = re.compile(
-        r"\d{2}-\d{2}-[A-Z]{2}|" r"\d{2}-[A-Z]{2}-\d{2}|" r"[A-Z]{2}-\d{2}-\d{2}|" r"[A-Z]{2}-\d{2}-[A-Z]{2}",
-    )
-
-
-class TestHeIl(_SimpleAutomotiveTestMixin):
-    license_plate_pattern: Pattern = re.compile(r"(\d{3}-\d{2}-\d{3})|(\d{2}-\d{3}-\d{2})")
-
-
-class TestHuHu(_SimpleAutomotiveTestMixin):
-    """Test hu_HU automotive provider methods"""
-
-    license_plate_pattern: Pattern = re.compile(r"[A-Z]{3}-\d{3}")
-
-
 class TestDeAt(_SimpleAutomotiveTestMixin):
     """Test de_AT automotive provider methods"""
 
@@ -98,6 +65,12 @@ def perform_extra_checks(self, license_plate, match):
         assert len(license_plate) in (8, 9)
 
 
+class TestDeCh(_SimpleAutomotiveTestMixin):
+    """Test de_CH automotive provider methods"""
+
+    license_plate_pattern: Pattern = re.compile(r"[A-Z]{2}-\d{1,3}\s?\d{0,3}")
+
+
 class TestDeDe(_SimpleAutomotiveTestMixin):
     """Test de_DE automotive provider methods"""
 
@@ -110,18 +83,10 @@ def perform_extra_checks(self, license_plate, match):
         assert match.group("prefix") in DeDeAutomotiveProvider.license_plate_prefix
 
 
-class TestSvSe(_SimpleAutomotiveTestMixin):
-    """Test sv_SE automotive provider methods"""
-
-    license_plate_pattern: Pattern = re.compile(r"[A-Z]{3} \d{2}[\dA-Z]")
-
+class TestElGr(_SimpleAutomotiveTestMixin):
+    """Test el_GR automotive provider methods"""
 
-class TestPlPl:
-    def test_License_plate(self, faker, num_samples):
-        pattern: Pattern = re.compile(r"{patterns}".format(patterns="|".join(faker.license_plate_regex_formats())))
-        for _ in range(num_samples):
-            plate = faker.license_plate()
-            assert pattern.fullmatch(plate)
+    license_plate_pattern = re.compile(r"^(?P<prefix>[A-Z]{2,3}) \d{4}$")
 
 
 class TestEnPh(_SimpleAutomotiveTestMixin):
@@ -145,62 +110,6 @@ def test_protocol_plate(self, faker, num_samples):
             assert int(protocol_plate) != 15 and 1 <= int(protocol_plate) <= 17
 
 
-class TestFilPh(TestEnPh):
-    """Test fil_PH automotive provider methods"""
-
-    pass
-
-
-class TestTlPh(TestEnPh):
-    """Test tl_PH automotive provider methods"""
-
-    pass
-
-
-class TestRuRu(_SimpleAutomotiveTestMixin):
-    """Test ru_RU automotive provider methods"""
-
-    _plate_letters = "".join(RuRuAutomotiveProvider.license_plate_letters)
-    license_plate_pattern: Pattern = re.compile(
-        r"(?:"
-        r"(?P<private_plate_prefix>[{0}]\d\d\d[{0}][{0}])|"
-        r"(?P<public_transport_plate_prefix>[{0}][{0}]\d\d\d)|"
-        r"(?P<trailer_plate_prefix>[{0}][{0}]\d\d\d\d)|"
-        r"(?P<police_plate_prefix>[{0}]\d\d\d\d)|"
-        r"(?P<military_plate_prefix>\d\d\d\d[{0}][{0}])|"
-        r"(?P<plate_number_special>00\dCD\d|00\dD\d\d\d|00\dT\d\d\d)"
-        r") (?P<plate_suffix>.*)".format(_plate_letters),
-    )
-
-    def perform_extra_checks(self, license_plate, match):
-        plate_suffix = match.group("plate_suffix")
-        assert plate_suffix in RuRuAutomotiveProvider.license_plate_suffix
-
-    def test_vehicle_category(self, faker, num_samples):
-        for _ in range(num_samples):
-            vehicle_category = faker.vehicle_category()
-            assert isinstance(vehicle_category, str)
-            assert vehicle_category in RuRuAutomotiveProvider.vehicle_categories
-
-
-class TestFrFr(_SimpleAutomotiveTestMixin):
-    """Test fr_FR automotive provider methods"""
-
-    license_plate_pattern: Pattern = re.compile(r"\d{3}-[A-Z]{3}-\d{2}|[A-Z]{2}-\d{3}-[A-Z]{2}")
-
-
-class TestItIt(_SimpleAutomotiveTestMixin):
-    """Test it_IT automotive provider methods"""
-
-    license_plate_pattern: Pattern = re.compile(r"[A-Z]{2}\d{3}[A-Z]{2}")
-
-
-class TestNoNo(_SimpleAutomotiveTestMixin):
-    """Test no_NO automotive provider methods"""
-
-    license_plate_pattern: Pattern = re.compile(r"[A-Z]{2} \d{5}")
-
-
 class TestEsCo(_SimpleAutomotiveTestMixin):
     """Test es_CO automotive provider methods"""
 
@@ -241,48 +150,50 @@ def test_plate_format(self, faker, num_samples):
             assert self.new_format_pattern.match(plate) or self.old_format_pattern.match(plate)
 
 
-class TestThTh(_SimpleAutomotiveTestMixin):
-    """Test th_TH automotive provider methods"""
+class TestFiFi(_SimpleAutomotiveTestMixin):
+    """Test fi_FI automotive provider methods"""
 
-    license_plate_pattern: Pattern = re.compile(
-        r"(\d [ก-ฮ]{2} \d{1,4})|"  # car
-        r"([ก-ฮ]{2} \d{1,4})|"  # car
-        r"([ก-ฮ]{3} \d{1,3})|"  # motorcycle
-        r"(\d{2}-\d{4})",  # truck
-    )
+    license_plate_pattern: Pattern = re.compile(r"[A-Z]{3}-\d{3}")
 
 
-class TestTrTr(_SimpleAutomotiveTestMixin):
-    """Test tr_TR automotive provider methods"""
+class TestFilPh(TestEnPh):
+    """Test fil_PH automotive provider methods"""
 
-    license_plate_pattern: Pattern = re.compile(
-        r"\d{2} [A-Z] \d{4}|"
-        r"\d{2} [A-Z] \d{5}|"
-        r"\d{2} [A-Z]{2} \d{3}|"
-        r"\d{2} [A-Z]{2} \d{4}|"
-        r"\d{2} [A-Z]{3} \d{2}|"
-        r"\d{2} [A-Z]{3} \d{3}",
-    )
+    pass
 
-    def perform_extra_checks(self, license_plate, match):
-        [city_code, letters, _] = license_plate.split(" ")
-        assert int(city_code) in range(1, 82)
-        assert all(letter in TrTrAutomotiveProvider.ascii_uppercase_turkish for letter in letters)
 
+class TestFrFr(_SimpleAutomotiveTestMixin):
+    """Test fr_FR automotive provider methods"""
 
-class TestRoRo(_SimpleAutomotiveTestMixin):
-    """Test ro_RO automotive provider methods"""
+    license_plate_pattern: Pattern = re.compile(r"\d{3}-[A-Z]{3}-\d{2}|[A-Z]{2}-\d{3}-[A-Z]{2}")
 
-    license_plate_pattern: Pattern = re.compile(r"(?P<prefix>[A-Z]{1,2})-\d{2,3}-[A-Z]{3}")
 
-    def perform_extra_checks(self, license_plate, match):
-        assert match.group("prefix") in RoRoAutomotiveProvider.license_plate_prefix
+class TestHeIl(_SimpleAutomotiveTestMixin):
+    license_plate_pattern: Pattern = re.compile(r"(\d{3}-\d{2}-\d{3})|(\d{2}-\d{3}-\d{2})")
 
 
-class TestElGr(_SimpleAutomotiveTestMixin):
-    """Test el_GR automotive provider methods"""
+class TestHuHu(_SimpleAutomotiveTestMixin):
+    """Test hu_HU automotive provider methods"""
 
-    license_plate_pattern = re.compile(r"^(?P<prefix>[A-Z]{2,3}) \d{4}$")
+    license_plate_pattern: Pattern = re.compile(r"[A-Z]{3}-\d{3}")
+
+
+class TestItIt(_SimpleAutomotiveTestMixin):
+    """Test it_IT automotive provider methods"""
+
+    license_plate_pattern: Pattern = re.compile(r"[A-Z]{2}\d{3}[A-Z]{2}")
+
+
+class TestKoKr(_SimpleAutomotiveTestMixin):
+    license_plate_pattern: Pattern = re.compile(
+        r"^\d{2,3}[가나다라마거너더러머버서어저고노도로모보소오조구누두루무부수우주]\d{4}$"
+    )
+
+
+class TestNlBe(_SimpleAutomotiveTestMixin):
+    """Test nl_BE automotive provider methods"""
+
+    license_plate_pattern: Pattern = re.compile(r"(\d{3}-[A-Z]{3})|" r"([A-Z]{3}-\d{3})|" r"([1-2]-[A-Z]{3}-\d{3})")
 
 
 class TestNlNl(_SimpleAutomotiveTestMixin):
@@ -317,16 +228,76 @@ def test_plate_motorbike(self, faker, num_samples):
             assert self.license_plate_motorbike_pattern.match(plate)
 
 
-class TestViVn(_SimpleAutomotiveTestMixin):
-    """Test vi_VN automotive provider methods"""
+class TestNoNo(_SimpleAutomotiveTestMixin):
+    """Test no_NO automotive provider methods"""
 
-    license_plate_pattern: Pattern = re.compile(r"\d{2}[ABCDĐEFGHKLMNPSTUVXYZ]-\d{5}")
+    license_plate_pattern: Pattern = re.compile(r"[A-Z]{2} \d{5}")
 
 
-class TestFiFi(_SimpleAutomotiveTestMixin):
-    """Test fi_FI automotive provider methods"""
+class TestPlPl:
+    def test_License_plate(self, faker, num_samples):
+        pattern: Pattern = re.compile(r"{patterns}".format(patterns="|".join(faker.license_plate_regex_formats())))
+        for _ in range(num_samples):
+            plate = faker.license_plate()
+            assert pattern.fullmatch(plate)
+
+
+class TestPtBr(_SimpleAutomotiveTestMixin):
+    """Test pt_BR automotive provider methods"""
+
+    license_plate_pattern: Pattern = re.compile(r"[A-Z]{3}-\d{1}[A-Z]{1}\d{2}")
+
+
+class TestPtPt(_SimpleAutomotiveTestMixin):
+    """Test pt_PT automotive provider methods"""
+
+    license_plate_pattern: Pattern = re.compile(
+        r"\d{2}-\d{2}-[A-Z]{2}|" r"\d{2}-[A-Z]{2}-\d{2}|" r"[A-Z]{2}-\d{2}-\d{2}|" r"[A-Z]{2}-\d{2}-[A-Z]{2}",
+    )
+
+
+class TestRoRo(_SimpleAutomotiveTestMixin):
+    """Test ro_RO automotive provider methods"""
+
+    license_plate_pattern: Pattern = re.compile(r"(?P<prefix>[A-Z]{1,2})-\d{2,3}-[A-Z]{3}")
+
+    def perform_extra_checks(self, license_plate, match):
+        assert match.group("prefix") in RoRoAutomotiveProvider.license_plate_prefix
 
-    license_plate_pattern: Pattern = re.compile(r"[A-Z]{3}-\d{3}")
+
+class TestRuRu(_SimpleAutomotiveTestMixin):
+    """Test ru_RU automotive provider methods"""
+
+    _plate_letters = "".join(RuRuAutomotiveProvider.license_plate_letters)
+    license_plate_pattern: Pattern = re.compile(
+        r"(?:"
+        r"(?P<private_plate_prefix>[{0}]\d\d\d[{0}][{0}])|"
+        r"(?P<public_transport_plate_prefix>[{0}][{0}]\d\d\d)|"
+        r"(?P<trailer_plate_prefix>[{0}][{0}]\d\d\d\d)|"
+        r"(?P<police_plate_prefix>[{0}]\d\d\d\d)|"
+        r"(?P<military_plate_prefix>\d\d\d\d[{0}][{0}])|"
+        r"(?P<plate_number_special>00\dCD\d|00\dD\d\d\d|00\dT\d\d\d)"
+        r") (?P<plate_suffix>.*)".format(_plate_letters),
+    )
+
+    def perform_extra_checks(self, license_plate, match):
+        plate_suffix = match.group("plate_suffix")
+        assert plate_suffix in RuRuAutomotiveProvider.license_plate_suffix
+
+    def test_vehicle_category(self, faker, num_samples):
+        for _ in range(num_samples):
+            vehicle_category = faker.vehicle_category()
+            assert isinstance(vehicle_category, str)
+            assert vehicle_category in RuRuAutomotiveProvider.vehicle_categories
+
+
+class TestSkSk(_SimpleAutomotiveTestMixin):
+    """Test sk_SK automotive provider methods"""
+
+    license_plate_pattern: Pattern = re.compile(r"(?P<prefix>[A-Z]{2})\d{3}[A-Z]{2}")
+
+    def perform_extra_checks(self, license_plate, match):
+        assert match.group("prefix") in SkSkAutomotiveProvider.license_plate_prefix
 
 
 class TestSqAl(_SimpleAutomotiveTestMixin):
@@ -335,36 +306,46 @@ class TestSqAl(_SimpleAutomotiveTestMixin):
     license_plate_pattern: Pattern = re.compile(r"[A-Z]{2} \d{3}[A-Z]{2}")
 
 
-class TestDeCh(_SimpleAutomotiveTestMixin):
-    """Test de_CH automotive provider methods"""
+class TestSvSe(_SimpleAutomotiveTestMixin):
+    """Test sv_SE automotive provider methods"""
 
-    license_plate_pattern: Pattern = re.compile(r"[A-Z]{2}-\d{1,3}\s?\d{0,3}")
+    license_plate_pattern: Pattern = re.compile(r"[A-Z]{3} \d{2}[\dA-Z]")
 
 
-class TestNlBe(_SimpleAutomotiveTestMixin):
-    """Test nl_BE automotive provider methods"""
+class TestThTh(_SimpleAutomotiveTestMixin):
+    """Test th_TH automotive provider methods"""
 
-    license_plate_pattern: Pattern = re.compile(r"(\d{3}-[A-Z]{3})|" r"([A-Z]{3}-\d{3})|" r"([1-2]-[A-Z]{3}-\d{3})")
+    license_plate_pattern: Pattern = re.compile(
+        r"(\d [ก-ฮ]{2} \d{1,4})|"  # car
+        r"([ก-ฮ]{2} \d{1,4})|"  # car
+        r"([ก-ฮ]{3} \d{1,3})|"  # motorcycle
+        r"(\d{2}-\d{4})",  # truck
+    )
 
 
-class TestZhCn(_SimpleAutomotiveTestMixin):
-    """Test zh_CN automotive provider methods"""
+class TestTlPh(TestEnPh):
+    """Test tl_PH automotive provider methods"""
 
-    license_plate_pattern: Pattern = re.compile(
-        r"^[京津冀晋蒙辽吉黑沪苏浙皖闽赣鲁豫鄂湘粤桂琼川贵云渝藏陕甘青宁新]{1}[A-Z]{1}-[A-Z0-9]{5}"
-    )
+    pass
 
 
-class TestZhTw(_SimpleAutomotiveTestMixin):
-    """Test zh_TW automotive provider methods"""
+class TestTrTr(_SimpleAutomotiveTestMixin):
+    """Test tr_TR automotive provider methods"""
 
     license_plate_pattern: Pattern = re.compile(
-        r"([A-Z]{2}-\d{4})|"  # prior 2012 v1
-        r"(\d{4}-[A-Z]{2})|"  # prior 2012 v2
-        r"([A-Z]{3}-\d{4})|"  # new format since 2014
-        r"([A-Z]{3}-\d{3})",  # commercial cars since 2012
+        r"\d{2} [A-Z] \d{4}|"
+        r"\d{2} [A-Z] \d{5}|"
+        r"\d{2} [A-Z]{2} \d{3}|"
+        r"\d{2} [A-Z]{2} \d{4}|"
+        r"\d{2} [A-Z]{3} \d{2}|"
+        r"\d{2} [A-Z]{3} \d{3}",
     )
 
+    def perform_extra_checks(self, license_plate, match):
+        [city_code, letters, _] = license_plate.split(" ")
+        assert int(city_code) in range(1, 82)
+        assert all(letter in TrTrAutomotiveProvider.ascii_uppercase_turkish for letter in letters)
+
 
 class TestUkUa(_SimpleAutomotiveTestMixin):
     license_plate_pattern: Pattern = re.compile(r"[A-Z]{2}\d{4}[A-Z]{2}")
@@ -398,7 +379,26 @@ def test_region_code(self, faker):
         assert "14" == faker.plate_region_code(region_name="Lviv")
 
 
-class TestKoKr(_SimpleAutomotiveTestMixin):
+class TestViVn(_SimpleAutomotiveTestMixin):
+    """Test vi_VN automotive provider methods"""
+
+    license_plate_pattern: Pattern = re.compile(r"\d{2}[ABCDĐEFGHKLMNPSTUVXYZ]-\d{5}")
+
+
+class TestZhCn(_SimpleAutomotiveTestMixin):
+    """Test zh_CN automotive provider methods"""
+
     license_plate_pattern: Pattern = re.compile(
-        r"^\d{2,3}[가나다라마거너더러머버서어저고노도로모보소오조구누두루무부수우주]\d{4}$"
+        r"^[京津冀晋蒙辽吉黑沪苏浙皖闽赣鲁豫鄂湘粤桂琼川贵云渝藏陕甘青宁新]{1}[A-Z]{1}-[A-Z0-9]{5}"
+    )
+
+
+class TestZhTw(_SimpleAutomotiveTestMixin):
+    """Test zh_TW automotive provider methods"""
+
+    license_plate_pattern: Pattern = re.compile(
+        r"([A-Z]{2}-\d{4})|"  # prior 2012 v1
+        r"(\d{4}-[A-Z]{2})|"  # prior 2012 v2
+        r"([A-Z]{3}-\d{4})|"  # new format since 2014
+        r"([A-Z]{3}-\d{3})",  # commercial cars since 2012
     )