Use TestCase.subTest in tests that test multiple values (#523)

Author: benkonrath

tests/test_bg.py

@@ -65,25 +65,29 @@ class BGLocalFlavorValidatorsTests(TestCase):
 
     def test_egn_validator_with_valid_egns(self):
         for egn in VALID_EGNS:
-            try:
-                egn_validator(egn)
-            except ValidationError:
-                self.fail('egn_validator said that valid EGN %s is invalid' % egn)
+            with self.subTest(egn=egn):
+                try:
+                    egn_validator(egn)
+                except ValidationError:
+                    self.fail('egn_validator said that valid EGN %s is invalid' % egn)
 
     def test_egn_validator_with_invalid_egns(self):
         for egn in INVALID_EGNS:
-            self.assertRaises(ValidationError, egn_validator, egn)
+            with self.subTest(egn=egn):
+                self.assertRaises(ValidationError, egn_validator, egn)
 
     def test_eik_validator_with_valid_eiks(self):
         for eik in VALID_EIKS:
-            try:
-                eik_validator(eik)
-            except ValidationError:
-                self.fail('eik_validator fails for %s' % eik)
+            with self.subTest(eik=eik):
+                try:
+                    eik_validator(eik)
+                except ValidationError:
+                    self.fail('eik_validator fails for %s' % eik)
 
     def test_eik_validator_with_invalid_eiks(self):
         for eik in INVALID_EIKS:
-            self.assertRaises(ValidationError, eik_validator, eik)
+            with self.subTest(eik=eik):
+                self.assertRaises(ValidationError, eik_validator, eik)
 
 
 class BGLocalFlavorEGNFieldTests(TestCase):
@@ -105,13 +109,15 @@ class Meta:
 
     def test_egn_form_with_valid_egns(self):
         for egn in VALID_EGNS:
-            form = self.EGNForm({'egn': egn})
-            self.assertTrue(form.is_valid())
+            with self.subTest(egn=egn):
+                form = self.EGNForm({'egn': egn})
+                self.assertTrue(form.is_valid())
 
     def test_egn_form_with_invalid_egns(self):
         for egn in INVALID_EGNS:
-            form = self.EGNForm({'egn': egn})
-            self.assertFalse(form.is_valid())
+            with self.subTest(egn=egn):
+                form = self.EGNForm({'egn': egn})
+                self.assertFalse(form.is_valid())
 
 
 class BGLocalFlavorEIKFieldTest(TestCase):
@@ -133,13 +139,15 @@ class Meta:
 
     def test_eik_form_with_valid_eiks(self):
         for eik in VALID_EIKS:
-            form = self.EIKForm({'eik': eik})
-            self.assertTrue(form.is_valid())
+            with self.subTest(eik=eik):
+                form = self.EIKForm({'eik': eik})
+                self.assertTrue(form.is_valid())
 
     def test_eik_form_with_invalid_eiks(self):
         for eik in INVALID_EIKS:
-            form = self.EIKForm({'eik': eik})
-            self.assertFalse(form.is_valid())
+            with self.subTest(eik=eik):
+                form = self.EIKForm({'eik': eik})
+                self.assertFalse(form.is_valid())
 
 
 class BGLocaFlavorUtilsTest(TestCase):

tests/test_br/test_br.py

@@ -22,12 +22,13 @@ def test_BRZipCodeField(self):
         self.assertFieldOutput(BRZipCodeField, valid, invalid)
 
         for postal_code, error in invalid.items():
-            form = BRPersonProfileForm({
-                'postal_code': postal_code
-            })
+            with self.subTest(postal_code=postal_code, error=error):
+                form = BRPersonProfileForm({
+                    'postal_code': postal_code
+                })
 
-            self.assertFalse(form.is_valid())
-            self.assertEqual(form.errors['postal_code'], error)
+                self.assertFalse(form.is_valid())
+                self.assertEqual(form.errors['postal_code'], error)
 
     def test_BRCNPJField(self):
         error_format = {
@@ -67,12 +68,13 @@ def test_BRCNPJField(self):
         self.assertFieldOutput(BRCNPJField, short_version_valid, invalid_long, field_kwargs={'max_length': 14})
 
         for cnpj, invalid_msg in invalid.items():
-            form = BRPersonProfileForm({
-                'cnpj': cnpj
-            })
+            with self.subTest(cnpj=cnpj, invalid_msg=invalid_msg):
+                form = BRPersonProfileForm({
+                    'cnpj': cnpj
+                })
 
-            self.assertFalse(form.is_valid())
-            self.assertEqual(form.errors['cnpj'], invalid_msg)
+                self.assertFalse(form.is_valid())
+                self.assertEqual(form.errors['cnpj'], invalid_msg)
 
     def test_BRCPFField(self):
         error_format = ['Invalid CPF number.']
@@ -102,12 +104,13 @@ def test_BRCPFField(self):
         self.assertFieldOutput(BRCPFField, valid, invalid)
 
         for cpf, invalid_msg in invalid.items():
-            form = BRPersonProfileForm({
-                'cpf': cpf
-            })
+            with self.subTest(cpf=cpf, invalid_msg=invalid_msg):
+                form = BRPersonProfileForm({
+                    'cpf': cpf
+                })
 
-            self.assertFalse(form.is_valid())
-            self.assertIn(form.errors['cpf'][0], invalid_msg)
+                self.assertFalse(form.is_valid())
+                self.assertIn(form.errors['cpf'][0], invalid_msg)
 
     def test_BRProcessoField(self):
         error_format = ['Invalid Process number.']
@@ -221,8 +224,9 @@ def test_model_form_valid(self):
         ]
 
         for case in data_to_test:
-            form = BRPersonProfileForm(case)
-            self.assertTrue(form.is_valid())
+            with self.subTest(case=case):
+                form = BRPersonProfileForm(case)
+                self.assertTrue(form.is_valid())
 
 class BRLocalFlavorModelFormTests (TestCase):
     def setUp(self):

tests/test_general.py

@@ -39,29 +39,31 @@ def test_model_field_deconstruct_methods_with_default_options(self):
         self.assertTrue(len(model_classes) > 0, 'No localflavor models.Field classes were found.')
 
         for cls in model_classes:
-            test_instance = cls()
-            name, path, args, kwargs = test_instance.deconstruct()
+            with self.subTest(cls=cls):
+                test_instance = cls()
+                name, path, args, kwargs = test_instance.deconstruct()
 
-            # 'choices' should not be in the kwargs output of deconstruct because storing choices changes to the
-            # migrations doesn't add value to the migration. Any data changes will use a data migration management
-            # command.
-            self.assertNotIn('choices', kwargs,
-                             '\'choices\' should not be returned by {}.deconstruct().'.format(cls.__name__))
+                # 'choices' should not be in the kwargs output of deconstruct because storing choices changes to the
+                # migrations doesn't add value to the migration. Any data changes will use a data migration management
+                # command.
+                self.assertNotIn('choices', kwargs,
+                                 '\'choices\' should not be returned by {}.deconstruct().'.format(cls.__name__))
 
-            # 'max_length' should be in the kwargs output of deconstruct so that a schema migration will be generated if
-            # the max_length field changes.
-            self.assertIn('max_length', kwargs, '\'max_length\' not returned by {}.deconstruct().'.format(cls.__name__))
+                # 'max_length' should be in the kwargs output of deconstruct so that a schema migration will be generated if
+                # the max_length field changes.
+                self.assertIn('max_length', kwargs, '\'max_length\' not returned by {}.deconstruct().'.format(cls.__name__))
 
-            # The attribute values should match an instance created with the args and kwargs output of deconstruct.
-            new_instance = cls(*args, **kwargs)
-            for attr in ('choices', 'max_length'):
-                self.assertEqual(getattr(test_instance, attr), getattr(new_instance, attr))
+                # The attribute values should match an instance created with the args and kwargs output of deconstruct.
+                new_instance = cls(*args, **kwargs)
+                for attr in ('choices', 'max_length'):
+                    self.assertEqual(getattr(test_instance, attr), getattr(new_instance, attr))
 
     def test_forms_char_field_empty_value_allows_none(self):
         form_classes = self._find_localflavor_subclasses(forms.CharField)
         self.assertTrue(len(form_classes) > 0, 'No localflavor forms.CharField classes were found.')
 
         for cls in form_classes:
-            failure_message = '{} does not handle does not properly handle values that are None.'.format(cls.__name__)
-            field = cls(required=False, empty_value=None)
-            self.assertIsNone(field.clean(None), failure_message)
+            with self.subTest(cls=cls):
+                failure_message = '{} does not handle does not properly handle values that are None.'.format(cls.__name__)
+                field = cls(required=False, empty_value=None)
+                self.assertIsNone(field.clean(None), failure_message)

tests/test_generic/tests.py

@@ -127,10 +127,12 @@ def test_iban_validator(self):
 
         iban_validator = IBANValidator()
         for iban in valid:
-            iban_validator(iban)
+            with self.subTest(iban=iban):
+                iban_validator(iban)
 
         for iban in invalid:
-            self.assertRaisesMessage(ValidationError, invalid[iban], IBANValidator(), iban)
+            with self.subTest(iban=iban):
+                self.assertRaisesMessage(ValidationError, invalid[iban], IBANValidator(), iban)
 
     def test_iban_validator_deconstruct(self):
         # Call to the required deconstruct method to see if it exists and
@@ -145,9 +147,10 @@ def test_iban_validator_deconstruct(self):
         ]
 
         for test_case in test_cases:
-            iban1 = IBANValidator(**test_case)
-            iban2 = IBANValidator(**test_case)
-            self.assertEqual(iban1, iban2, msg="IBAN validators with equal parameters are not equal.")
+            with self.subTest(test_case=test_case):
+                iban1 = IBANValidator(**test_case)
+                iban2 = IBANValidator(**test_case)
+                self.assertEqual(iban1, iban2, msg="IBAN validators with equal parameters are not equal.")
 
     def test_iban_fields(self):
         """Test the IBAN model and form field."""
@@ -194,17 +197,19 @@ def test_iban_fields(self):
         # Test valid inputs for model field.
         iban_model_field = IBANField()
         for input, output in valid.items():
-            self.assertEqual(iban_model_field.clean(input, None), output)
+            with self.subTest(input=input, output=output):
+                self.assertEqual(iban_model_field.clean(input, None), output)
 
         self.assertIsNone(iban_model_field.to_python(None))
 
         # Invalid inputs for model field.
         for input, errors in invalid.items():
-            with self.assertRaises(ValidationError) as context_manager:
-                iban_model_field.clean(input, None)
-            # The error messages for models are in a different order.
-            errors.reverse()
-            self.assertEqual(context_manager.exception.messages, errors)
+            with self.subTest(input=input, errors=errors):
+                with self.assertRaises(ValidationError) as context_manager:
+                    iban_model_field.clean(input, None)
+                # The error messages for models are in a different order.
+                errors.reverse()
+                self.assertEqual(context_manager.exception.messages, errors)
 
     def test_nordea_extensions(self):
         """Test a valid IBAN in the Nordea extensions."""
@@ -249,15 +254,17 @@ def test_include_countries(self):
         # Test valid inputs for model field.
         iban_model_field = IBANField(include_countries=include_countries)
         for input, output in valid.items():
-            self.assertEqual(iban_model_field.clean(input, None), output)
+            with self.subTest(input=input, output=output):
+                self.assertEqual(iban_model_field.clean(input, None), output)
 
         # Invalid inputs for model field.
         for input, errors in invalid.items():
-            with self.assertRaises(ValidationError) as context_manager:
-                iban_model_field.clean(input, None)
-            # The error messages for models are in a different order.
-            errors.reverse()
-            self.assertEqual(context_manager.exception.messages, errors)
+            with self.subTest(input=input, errors=errors):
+                with self.assertRaises(ValidationError) as context_manager:
+                    iban_model_field.clean(input, None)
+                # The error messages for models are in a different order.
+                errors.reverse()
+                self.assertEqual(context_manager.exception.messages, errors)
 
     def test_misconfigured_include_countries(self):
         """Test that an IBAN field or model raises an error when asked to validate a country not part of IBAN."""
@@ -297,7 +304,8 @@ def test_model_field_deconstruct(self):
         name, path, args, kwargs = test_instance.deconstruct()
         new_instance = IBANField(*args, **kwargs)
         for attr in ('include_countries', 'use_nordea_extensions'):
-            self.assertEqual(getattr(test_instance, attr), getattr(new_instance, attr))
+            with self.subTest(attr=attr):
+                self.assertEqual(getattr(test_instance, attr), getattr(new_instance, attr))
 
 
 class BICTests(TestCase):
@@ -370,15 +378,17 @@ def test_bic_model_field(self):
 
         # Test valid inputs for model field.
         for input, output in valid.items():
-            self.assertEqual(bic_model_field.clean(input, None), output)
+            with self.subTest(input=input, output=output):
+                self.assertEqual(bic_model_field.clean(input, None), output)
 
         self.assertIsNone(bic_model_field.to_python(None))
 
         # Invalid inputs for model field.
         for input, errors in invalid.items():
-            with self.assertRaises(ValidationError) as context_manager:
-                bic_model_field.clean(input, None)
-            self.assertEqual(errors, context_manager.exception.messages)
+            with self.subTest(input=input, errors=errors):
+                with self.assertRaises(ValidationError) as context_manager:
+                    bic_model_field.clean(input, None)
+                self.assertEqual(errors, context_manager.exception.messages)
 
     def test_default_form(self):
         bic_model_field = BICField()
@@ -408,10 +418,12 @@ def test_ean_validator(self):
 
         validator = EANValidator()
         for value in valid:
-            validator(value)
+            with self.subTest(value=value):
+                validator(value)
 
         for value in invalid:
-            self.assertRaisesMessage(ValidationError,  error_message, validator, value)
+            with self.subTest(value=value):
+                self.assertRaisesMessage(ValidationError,  error_message, validator, value)
 
     def test_ean_validator_deconstruct(self):
         # Call to the required deconstruct method to see if it exists and
@@ -426,9 +438,10 @@ def test_ean_validator_deconstruct(self):
         ]
 
         for test_case in test_cases:
-            ean1 = EANValidator(**test_case)
-            ean2 = EANValidator(**test_case)
-            self.assertEqual(ean1, ean2, msg="EAN validators with equal parameters are not equal.")
+            with self.subTest(test_case=test_case):
+                ean1 = EANValidator(**test_case)
+                ean2 = EANValidator(**test_case)
+                self.assertEqual(ean1, ean2, msg="EAN validators with equal parameters are not equal.")
 
     def test_ean_validator_strip_nondigits(self):
         valid = [
@@ -456,7 +469,9 @@ def test_ean_validator_strip_nondigits(self):
 
         validator = EANValidator(strip_nondigits=True)
         for value in valid:
-            validator(value)
+            with self.subTest(value=value):
+                validator(value)
 
         for value in invalid:
-            self.assertRaisesMessage(ValidationError,  error_message, validator, value)
+            with self.subTest(value=value):
+                self.assertRaisesMessage(ValidationError,  error_message, validator, value)

tests/test_nl/tests.py

@@ -10,10 +10,12 @@
 class NLLocalFlavorValidatorTests(SimpleTestCase):
     def assert_validator(self, validator, valid=(), invalid=()):
         for item in valid:
-            validator(item)
+            with self.subTest(item=item):
+                validator(item)
 
         for item in invalid:
-            self.assertRaises(ValidationError, lambda: validator(item))
+            with self.subTest(item=item):
+                self.assertRaises(ValidationError, lambda: validator(item))
 
     def test_NLZipCodeValidator(self):
         valid = [

tests/test_si.py

@@ -51,9 +51,10 @@ def test_SIEMSOField_info_dict(self):
             '1010985505402': {'nationality': 50, 'gender': 'female', 'birthdate': date(1985, 10, 10)},
         }
         for input, info in valid.items():
-            f = SIEMSOField()
-            f.clean(input)
-            self.assertEqual(f.info, info)
+            with self.subTest(input=input, info=info):
+                f = SIEMSOField()
+                f.clean(input)
+                self.assertEqual(f.info, info)
 
     def test_SIPostalCodeField(self):
         valid = {