s/SemanticVersion/Version/

Signed-off-by: Raphaël Barrois <raphael.barrois@polytechnique.org>

4 files changed, 19 insertions, 19 deletions

diff --git a/tests/test_base.py b/tests/test_base.py
index 7d34878..28bfc7a 100755
--- a/tests/test_base.py
+++ b/tests/test_base.py
@@ -59,7 +59,7 @@ class ComparisonTestCase(unittest.TestCase):
                     a, b, result, expected))
 
 
-class SemanticVersionTestCase(unittest.TestCase):
+class VersionTestCase(unittest.TestCase):
     versions = {
         '1.0.0-alpha': (1, 0, 0, ['alpha'], []),
         '1.0.0-alpha.1': (1, 0, 0, ['alpha', '1'], []),
@@ -83,22 +83,22 @@ class SemanticVersionTestCase(unittest.TestCase):
 
     def test_parsing(self):
         for text, expected_fields in self.versions.items():
-            version = base.SemanticVersion(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, fields in self.versions.items():
-            version = base.SemanticVersion(text)
+            version = base.Version(text)
             self.assertEqual(text, str(version))
             for field in fields:
                 self.assertIn(repr(field), repr(version))
 
     def test_compare_to_self(self):
         for text in self.versions:
-            self.assertEqual(base.SemanticVersion(text), base.SemanticVersion(text))
-            self.assertNotEqual(text, base.SemanticVersion(text))
+            self.assertEqual(base.Version(text), base.Version(text))
+            self.assertNotEqual(text, base.Version(text))
 
     partial_versions = {
         '1.0': (1, 0, None, None, None),
@@ -125,14 +125,14 @@ class SemanticVersionTestCase(unittest.TestCase):
 
     def test_parsing_partials(self):
         for text, expected_fields in self.partial_versions.items():
-            version = base.SemanticVersion(text, partial=True)
+            version = base.Version(text, partial=True)
             actual_fields = (version.major, version.minor, version.patch,
                 version.prerelease, version.build)
             self.assertEqual(expected_fields, actual_fields)
 
     def test_str_partials(self):
         for text, fields in self.partial_versions.items():
-            version = base.SemanticVersion(text, partial=True)
+            version = base.Version(text, partial=True)
             self.assertEqual(text, str(version))
             for field in fields:
                 self.assertIn(repr(field), repr(version))
@@ -140,9 +140,9 @@ class SemanticVersionTestCase(unittest.TestCase):
     def test_compare_partial_to_self(self):
         for text in self.partial_versions:
             self.assertEqual(
-                base.SemanticVersion(text, partial=True),
-                base.SemanticVersion(text, partial=True))
-            self.assertNotEqual(text, base.SemanticVersion(text, partial=True))
+                base.Version(text, partial=True),
+                base.Version(text, partial=True))
+            self.assertNotEqual(text, base.Version(text, partial=True))
 
 
 if __name__ == '__main__':  # pragma: no cover
diff --git a/tests/test_django.py b/tests/test_django.py
index 72f7964..712bd39 100644
--- a/tests/test_django.py
+++ b/tests/test_django.py
@@ -37,12 +37,12 @@ class DjangoFieldTestCase(unittest.TestCase):
     def test_version(self):
         obj = models.VersionModel(version='0.1.1', spec='>0.1.0')
 
-        self.assertEqual(semantic_version.SemanticVersion('0.1.1'), obj.version)
+        self.assertEqual(semantic_version.Version('0.1.1'), obj.version)
         self.assertEqual(semantic_version.Spec('>0.1.0'), obj.spec)
 
         alt_obj = models.VersionModel(version=obj.version, spec=obj.spec)
 
-        self.assertEqual(semantic_version.SemanticVersion('0.1.1'), alt_obj.version)
+        self.assertEqual(semantic_version.Version('0.1.1'), alt_obj.version)
         self.assertEqual(semantic_version.Spec('>0.1.0'), alt_obj.spec)
         self.assertEqual(obj.spec, alt_obj.spec)
         self.assertEqual(obj.version, alt_obj.version)
@@ -54,13 +54,13 @@ class DjangoFieldTestCase(unittest.TestCase):
     def test_partial(self):
         obj = models.PartialVersionModel(partial='0.1')
 
-        self.assertEqual(semantic_version.SemanticVersion('0.1', partial=True), obj.partial)
+        self.assertEqual(semantic_version.Version('0.1', partial=True), obj.partial)
         self.assertIsNone(obj.optional)
         self.assertIsNone(obj.optional_spec)
 
         alt_obj = models.PartialVersionModel(partial=obj.partial, optional=obj.optional,
             optional_spec=obj.optional_spec)
-        self.assertEqual(semantic_version.SemanticVersion('0.1', partial=True), alt_obj.partial)
+        self.assertEqual(semantic_version.Version('0.1', partial=True), alt_obj.partial)
         self.assertEqual(obj.partial, alt_obj.partial)
         self.assertIsNone(obj.optional)
         self.assertIsNone(obj.optional_spec)
diff --git a/tests/test_match.py b/tests/test_match.py
index efd29e0..cd3acea 100755
--- a/tests/test_match.py
+++ b/tests/test_match.py
@@ -80,7 +80,7 @@ class MatchTestCase(unittest.TestCase):
             spec = semantic_version.Spec(spec_txt)
             self.assertNotEqual(spec, spec_txt)
             for version_txt in versions:
-                version = semantic_version.SemanticVersion(version_txt)
+                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))
 
diff --git a/tests/test_parsing.py b/tests/test_parsing.py
index b59b8a3..bf8a461 100755
--- a/tests/test_parsing.py
+++ b/tests/test_parsing.py
@@ -27,11 +27,11 @@ class ParsingTestCase(unittest.TestCase):
 
     def test_invalid(self):
         for invalid in self.invalids:
-            self.assertRaises(ValueError, semantic_version.SemanticVersion, invalid)
+            self.assertRaises(ValueError, semantic_version.Version, invalid)
 
     def test_simple(self):
         for valid in self.valids:
-            version = semantic_version.SemanticVersion(valid)
+            version = semantic_version.Version(valid)
             self.assertEqual(valid, str(version))
 
 
@@ -52,9 +52,9 @@ class ComparisonTestCase(unittest.TestCase):
 
     def test_comparisons(self):
         for i, first in enumerate(self.order):
-            first_ver = semantic_version.SemanticVersion(first)
+            first_ver = semantic_version.Version(first)
             for j, second in enumerate(self.order):
-                second_ver = semantic_version.SemanticVersion(second)
+                second_ver = semantic_version.Version(second)
                 if i < j:
                     self.assertTrue(first_ver < second_ver, '%r !< %r' % (first_ver, second_ver))
                 elif i == j: