From 36f5b30d2fb6ad535b322a875c8bfb297e97aacc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Barrois?= Date: Tue, 20 Aug 2019 22:54:07 +0200 Subject: Use unittest.subTest in tests. This provides more helpful error messages when a test fails. --- tests/test_base.py | 197 +++++++++++++++++++++++++++++--------------------- tests/test_match.py | 29 ++++---- tests/test_parsing.py | 66 +++++++++-------- 3 files changed, 168 insertions(+), 124 deletions(-) diff --git a/tests/test_base.py b/tests/test_base.py index 7ab3fba..6470e90 100755 --- a/tests/test_base.py +++ b/tests/test_base.py @@ -31,10 +31,12 @@ class ComparisonTestCase(unittest.TestCase): ] for a, b, expected in cases: - result = base.identifier_cmp(a, b) - self.assertEqual(expected, result, - "identifier_cmp(%r, %r) returned %d instead of %d" % ( - a, b, result, expected)) + with self.subTest(a=a, b=b): + result = base.identifier_cmp(a, b) + self.assertEqual( + expected, result, + "identifier_cmp(%r, %r) returned %d instead of %d" % ( + a, b, result, expected)) def test_identifier_list_cmp(self): cases = [ @@ -50,10 +52,12 @@ class ComparisonTestCase(unittest.TestCase): ] for a, b, expected in cases: - result = base.identifier_list_cmp(a, b) - self.assertEqual(expected, result, - "identifier_list_cmp(%r, %r) returned %d instead of %d" % ( - a, b, result, expected)) + with self.subTest(a=a, b=b): + result = base.identifier_list_cmp(a, b) + self.assertEqual( + expected, result, + "identifier_list_cmp(%r, %r) returned %d instead of %d" % ( + a, b, result, expected)) class TopLevelTestCase(unittest.TestCase): @@ -69,9 +73,11 @@ class TopLevelTestCase(unittest.TestCase): def test_compare(self): for a, b, expected in self.versions: - result = base.compare(a, b) - self.assertEqual(expected, result, - "compare(%r, %r) should be %r instead of %r" % (a, b, expected, result)) + with self.subTest(a=a, b=b): + result = base.compare(a, b) + self.assertEqual( + expected, result, + "compare(%r, %r) should be %r instead of %r" % (a, b, expected, result)) matches = ( ('>=0.1.1', '0.1.2'), @@ -82,8 +88,10 @@ class TopLevelTestCase(unittest.TestCase): def test_match(self): for spec, version in self.matches: - self.assertTrue(base.match(spec, version), - "%r should accept %r" % (spec, version)) + with self.subTest(spec=spec, version=version): + self.assertTrue( + base.match(spec, version), + "%r should accept %r" % (spec, version)) valid_strings = ( '1.0.0-alpha', @@ -106,8 +114,10 @@ class TopLevelTestCase(unittest.TestCase): def test_validate_valid(self): for version in self.valid_strings: - self.assertTrue(base.validate(version), - "%r should be a valid version" % (version,)) + with self.subTest(version=version): + self.assertTrue( + base.validate(version), + "%r should be a valid version" % (version,)) invalid_strings = ( '1', @@ -122,8 +132,10 @@ class TopLevelTestCase(unittest.TestCase): def test_validate_invalid(self): for version in self.invalid_strings: - self.assertFalse(base.validate(version), - "%r should not be a valid version" % (version,)) + with self.subTest(version=version): + self.assertFalse( + base.validate(version), + "%r should not be a valid version" % (version,)) class VersionTestCase(unittest.TestCase): @@ -150,21 +162,25 @@ class VersionTestCase(unittest.TestCase): def test_parsing(self): for text, expected_fields in self.versions.items(): - version = base.Version(text) - actual_fields = (version.major, version.minor, version.patch, - version.prerelease, version.build) - self.assertEqual(expected_fields, actual_fields) + with self.subTest(text=text): + version = base.Version(text) + actual_fields = ( + version.major, version.minor, version.patch, + version.prerelease, version.build) + self.assertEqual(expected_fields, actual_fields) def test_str(self): for text in self.versions: - version = base.Version(text) - self.assertEqual(text, str(version)) - self.assertEqual("Version('%s')" % text, repr(version)) + with self.subTest(text=text): + version = base.Version(text) + self.assertEqual(text, str(version)) + self.assertEqual("Version('%s')" % text, repr(version)) def test_compare_to_self(self): for text in self.versions: - self.assertEqual(base.Version(text), base.Version(text)) - self.assertNotEqual(text, base.Version(text)) + with self.subTest(text=text): + self.assertEqual(base.Version(text), base.Version(text)) + self.assertNotEqual(text, base.Version(text)) partial_versions = { '1.1': (1, 1, None, None, None), @@ -192,24 +208,28 @@ class VersionTestCase(unittest.TestCase): def test_parsing_partials(self): for text, expected_fields in self.partial_versions.items(): - version = base.Version(text, partial=True) - actual_fields = (version.major, version.minor, version.patch, - version.prerelease, version.build) - self.assertEqual(expected_fields, actual_fields) - self.assertTrue(version.partial, "%r should have partial=True" % version) + with self.subTest(text=text): + version = base.Version(text, partial=True) + actual_fields = ( + version.major, version.minor, version.patch, + version.prerelease, version.build) + self.assertEqual(expected_fields, actual_fields) + self.assertTrue(version.partial, "%r should have partial=True" % version) def test_str_partials(self): for text in self.partial_versions: - version = base.Version(text, partial=True) - self.assertEqual(text, str(version)) - self.assertEqual("Version('%s', partial=True)" % text, repr(version)) + with self.subTest(text=text): + version = base.Version(text, partial=True) + self.assertEqual(text, str(version)) + self.assertEqual("Version('%s', partial=True)" % text, repr(version)) def test_compare_partial_to_self(self): for text in self.partial_versions: - self.assertEqual( - base.Version(text, partial=True), - base.Version(text, partial=True)) - self.assertNotEqual(text, base.Version(text, partial=True)) + with self.subTest(text=text): + self.assertEqual( + base.Version(text, partial=True), + base.Version(text, partial=True)) + self.assertNotEqual(text, base.Version(text, partial=True)) def test_hash(self): self.assertEqual(1, @@ -402,8 +422,9 @@ class SpecItemTestCase(unittest.TestCase): def test_invalids(self): for invalid in self.invalids: - with self.assertRaises(ValueError, msg="SpecItem(%r) should be invalid" % invalid): - _v = base.SpecItem(invalid) + with self.subTest(invalid=invalid): + with self.assertRaises(ValueError, msg="SpecItem(%r) should be invalid" % invalid): + base.SpecItem(invalid) components = { '==0.1.0': (base.SpecItem.KIND_EQUAL, 0, 1, 0, None, None), @@ -426,15 +447,16 @@ class SpecItemTestCase(unittest.TestCase): def test_components(self): for spec_text, components in self.components.items(): - kind, major, minor, patch, prerelease, build = components - spec = base.SpecItem(spec_text) + with self.subTest(spec_text=spec_text): + kind, major, minor, patch, prerelease, build = components + spec = base.SpecItem(spec_text) - self.assertEqual(kind, spec.kind) - self.assertEqual(major, spec.spec.major) - self.assertEqual(minor, spec.spec.minor) - self.assertEqual(patch, spec.spec.patch) - self.assertEqual(prerelease, spec.spec.prerelease) - self.assertEqual(build, spec.spec.build) + self.assertEqual(kind, spec.kind) + self.assertEqual(major, spec.spec.major) + self.assertEqual(minor, spec.spec.minor) + self.assertEqual(patch, spec.spec.patch) + self.assertEqual(prerelease, spec.spec.prerelease) + self.assertEqual(build, spec.spec.build) matches = { '==0.1.0': ( @@ -533,13 +555,16 @@ class SpecItemTestCase(unittest.TestCase): matching, failing = versions for version_text in matching: - version = base.Version(version_text) - self.assertTrue(spec.match(version), "%r should match %r" % (version, spec)) + with self.subTest(spec=spec_text, version=version_text): + version = base.Version(version_text) + self.assertTrue(spec.match(version), "%r should match %r" % (version, spec)) for version_text in failing: - version = base.Version(version_text) - self.assertFalse(spec.match(version), - "%r should not match %r" % (version, spec)) + with self.subTest(spec=spec_text, excluded=version_text): + version = base.Version(version_text) + self.assertFalse( + spec.match(version), + "%r should not match %r" % (version, spec)) def test_equality(self): spec1 = base.SpecItem('==0.1.0') @@ -573,8 +598,9 @@ class CoerceTestCase(unittest.TestCase): for equivalent, samples in self.examples.items(): target = base.Version(equivalent) for sample in samples: - v_sample = base.Version.coerce(sample) - self.assertEqual(target, v_sample) + with self.subTest(target=equivalent, sample=sample): + v_sample = base.Version.coerce(sample) + self.assertEqual(target, v_sample) def test_invalid(self): self.assertRaises(ValueError, base.Version.coerce, 'v1') @@ -588,14 +614,15 @@ class SpecTestCase(unittest.TestCase): def test_parsing(self): for spec_list_text, specs in self.examples.items(): - spec_list = base.Spec(spec_list_text) + with self.subTest(spec=spec_list_text): + spec_list = base.Spec(spec_list_text) - self.assertEqual(spec_list_text, str(spec_list)) - self.assertNotEqual(spec_list_text, spec_list) - self.assertEqual(specs, [str(spec) for spec in spec_list]) + self.assertEqual(spec_list_text, str(spec_list)) + self.assertNotEqual(spec_list_text, spec_list) + self.assertCountEqual(specs, [str(spec) for spec in spec_list]) - for spec_text in specs: - self.assertTrue(repr(base.SpecItem(spec_text)) in repr(spec_list)) + for spec_text in specs: + self.assertIn(str(base.SpecItem(spec_text)), repr(spec_list)) split_examples = { ('>=0.1.1', '<0.1.2', '!=0.1.1+build1'): ['>=0.1.1', '<0.1.2', '!=0.1.1+build1'], @@ -604,14 +631,15 @@ class SpecTestCase(unittest.TestCase): def test_parsing_split(self): for spec_list_texts, specs in self.split_examples.items(): - spec_list = base.Spec(*spec_list_texts) + with self.subTest(spec=spec_list_texts): + spec_list = base.Spec(*spec_list_texts) - self.assertEqual(','.join(spec_list_texts), str(spec_list)) - self.assertEqual(specs, [str(spec) for spec in spec_list]) - self.assertEqual(spec_list, base.Spec(','.join(spec_list_texts))) + self.assertEqual(','.join(spec_list_texts), str(spec_list)) + self.assertCountEqual(specs, [str(spec) for spec in spec_list]) + self.assertEqual(spec_list, base.Spec(','.join(spec_list_texts))) - for spec_text in specs: - self.assertTrue(repr(base.SpecItem(spec_text)) in repr(spec_list)) + for spec_text in specs: + self.assertIn(str(base.SpecItem(spec_text)), repr(spec_list)) matches = { # At least 0.1.1 including pre-releases, less than 0.1.2 excluding pre-releases @@ -635,25 +663,32 @@ class SpecTestCase(unittest.TestCase): matching, failing = versions for version_text in matching: - version = base.Version(version_text) - self.assertTrue(version in spec_list, - "%r should be in %r" % (version, spec_list)) - self.assertTrue(spec_list.match(version), - "%r should match %r" % (version, spec_list)) + with self.subTest(spec=spec_list_text, matching=version_text): + version = base.Version(version_text) + self.assertTrue( + version in spec_list, + "%r should be in %r" % (version, spec_list)) + self.assertTrue( + spec_list.match(version), + "%r should match %r" % (version, spec_list)) for version_text in failing: - version = base.Version(version_text) - self.assertFalse(version in spec_list, - "%r should not be in %r" % (version, spec_list)) - self.assertFalse(spec_list.match(version), - "%r should not match %r" % (version, spec_list)) + with self.subTest(spec=spec_list_text, excluded=version_text): + version = base.Version(version_text) + self.assertFalse( + version in spec_list, + "%r should not be in %r" % (version, spec_list)) + self.assertFalse( + spec_list.match(version), + "%r should not match %r" % (version, spec_list)) def test_equality(self): for spec_list_text in self.examples: - slist1 = base.Spec(spec_list_text) - slist2 = base.Spec(spec_list_text) - self.assertEqual(slist1, slist2) - self.assertFalse(slist1 == spec_list_text) + with self.subTest(spec=spec_list_text): + slist1 = base.Spec(spec_list_text) + slist2 = base.Spec(spec_list_text) + self.assertEqual(slist1, slist2) + self.assertFalse(slist1 == spec_list_text) def test_filter_empty(self): s = base.Spec('>=0.1.1') diff --git a/tests/test_match.py b/tests/test_match.py index 4d1a96f..10a9c8a 100755 --- a/tests/test_match.py +++ b/tests/test_match.py @@ -128,24 +128,27 @@ class MatchTestCase(unittest.TestCase): def test_invalid(self): for invalid in self.invalid_specs: - with self.assertRaises(ValueError, msg="Spec(%r) should be invalid" % invalid): - semantic_version.Spec(invalid) + with self.subTest(spec=invalid): + with self.assertRaises(ValueError, msg="Spec(%r) should be invalid" % invalid): + semantic_version.Spec(invalid) def test_simple(self): for valid in self.valid_specs: - spec = semantic_version.SpecItem(valid) - normalized = str(spec) - self.assertEqual(spec, semantic_version.SpecItem(normalized)) + with self.subTest(spec=valid): + spec = semantic_version.SpecItem(valid) + normalized = str(spec) + self.assertEqual(spec, semantic_version.SpecItem(normalized)) def test_match(self): - for spec_txt, versions in self.matches.items(): - spec = semantic_version.Spec(spec_txt) - self.assertNotEqual(spec, spec_txt) - for version_txt in versions: - version = semantic_version.Version(version_txt) - self.assertTrue(spec.match(version), "%r does not match %r" % (version, spec)) - self.assertTrue(semantic_version.match(spec_txt, version_txt)) - self.assertTrue(version in spec, "%r not in %r" % (version, spec)) + for spec_text, versions in self.matches.items(): + for version_text in versions: + with self.subTest(spec=spec_text, version=version_text): + spec = semantic_version.Spec(spec_text) + self.assertNotEqual(spec, spec_text) + version = semantic_version.Version(version_text) + self.assertTrue(spec.match(version), "%r does not match %r" % (version, spec)) + self.assertTrue(semantic_version.match(spec_text, version_text)) + self.assertTrue(version in spec, "%r not in %r" % (version, spec)) def test_contains(self): spec = semantic_version.Spec('<=0.1.1') diff --git a/tests/test_parsing.py b/tests/test_parsing.py index af99d05..548826a 100755 --- a/tests/test_parsing.py +++ b/tests/test_parsing.py @@ -39,24 +39,27 @@ class ParsingTestCase(unittest.TestCase): def test_invalid(self): for invalid in self.invalids: - self.assertRaises(ValueError, semantic_version.Version, invalid) + with self.subTest(version=invalid): + self.assertRaises(ValueError, semantic_version.Version, invalid) def test_simple(self): for valid in self.valids: - version = semantic_version.Version(valid) - self.assertEqual(valid, str(version)) + with self.subTest(version=valid): + version = semantic_version.Version(valid) + self.assertEqual(valid, str(version)) def test_kwargs(self): for text, fields in self.valid_fields: - major, minor, patch, prerelease, build = fields - version = semantic_version.Version( - major=major, - minor=minor, - patch=patch, - prerelease=prerelease, - build=build, - ) - self.assertEqual(text, str(version)) + with self.subTest(version=text): + major, minor, patch, prerelease, build = fields + version = semantic_version.Version( + major=major, + minor=minor, + patch=patch, + prerelease=prerelease, + build=build, + ) + self.assertEqual(text, str(version)) class ComparisonTestCase(unittest.TestCase): @@ -75,15 +78,16 @@ class ComparisonTestCase(unittest.TestCase): first_ver = semantic_version.Version(first) for j, second in enumerate(self.order): second_ver = semantic_version.Version(second) - if i < j: - self.assertTrue(first_ver < second_ver, '%r !< %r' % (first_ver, second_ver)) - elif i == j: - self.assertTrue(first_ver == second_ver, '%r != %r' % (first_ver, second_ver)) - else: - self.assertTrue(first_ver > second_ver, '%r !> %r' % (first_ver, second_ver)) + with self.subTest(first=first, second=second): + if i < j: + self.assertTrue(first_ver < second_ver, '%r !< %r' % (first_ver, second_ver)) + elif i == j: + self.assertTrue(first_ver == second_ver, '%r != %r' % (first_ver, second_ver)) + else: + self.assertTrue(first_ver > second_ver, '%r !> %r' % (first_ver, second_ver)) - cmp_res = -1 if i < j else (1 if i > j else 0) - self.assertEqual(cmp_res, semantic_version.compare(first, second)) + cmp_res = -1 if i < j else (1 if i > j else 0) + self.assertEqual(cmp_res, semantic_version.compare(first, second)) unordered = [ [ @@ -105,16 +109,18 @@ class ComparisonTestCase(unittest.TestCase): def test_unordered(self): for group in self.unordered: for a, b in itertools.combinations(group, 2): - v1 = semantic_version.Version(a) - v2 = semantic_version.Version(b) - self.assertTrue(v1 == v1, "%r != %r" % (v1, v1)) - self.assertFalse(v1 != v1, "%r != %r" % (v1, v1)) - self.assertFalse(v1 == v2, "%r == %r" % (v1, v2)) - self.assertTrue(v1 != v2, "%r !!= %r" % (v1, v2)) - self.assertFalse(v1 < v2, "%r !< %r" % (v1, v2)) - self.assertFalse(v1 <= v2, "%r !<= %r" % (v1, v2)) - self.assertFalse(v2 > v1, "%r !> %r" % (v2, v1)) - self.assertFalse(v2 >= v1, "%r !>= %r" % (v2, v1)) + with self.subTest(a=a, b=b): + v1 = semantic_version.Version(a) + v2 = semantic_version.Version(b) + self.assertTrue(v1 == v1, "%r != %r" % (v1, v1)) + self.assertFalse(v1 != v1, "%r != %r" % (v1, v1)) + self.assertFalse(v1 == v2, "%r == %r" % (v1, v2)) + self.assertTrue(v1 != v2, "%r !!= %r" % (v1, v2)) + self.assertFalse(v1 < v2, "%r !< %r" % (v1, v2)) + self.assertFalse(v1 <= v2, "%r !<= %r" % (v1, v2)) + self.assertFalse(v2 > v1, "%r !> %r" % (v2, v1)) + self.assertFalse(v2 >= v1, "%r !>= %r" % (v2, v1)) + if __name__ == '__main__': # pragma: no cover unittest.main() -- cgit v1.2.1