Test package name uniqueness for everything

Things that now fail:
- Name used as previous_names and general package name
- Name used twice in either previous_names or as package name
- All the above (+ dependencies) for ALL repositories checked, including
  external if desired.

tests/test.py

@@ -134,6 +134,12 @@ class TestContainer(object):
     Does not contain tests itself, must be used as mixin with unittest.TestCase.
     """
 
+    @classmethod
+    def setUpClass(cls):
+        cls.package_names = dict()
+        cls.previous_package_names = dict()
+        cls.dependency_names = dict()
+
     rel_b_reg = r'''^ (https:// github\.com/ [^/]+/ [^/]+
                       |https:// bitbucket\.org/ [^/]+/ [^/]+
                       ) $'''
@@ -165,42 +171,51 @@ class TestContainer(object):
         for k in data:
             self.assertIn(k, keys, "Unexpected key")
 
-    def _test_dependency_order(self, include, data):
+    def _test_dependency_names(self, include, data):
         m = re.search(r"(?:^|/)(0-9|[a-z]|dependencies)\.json$", include)
         if not m:
             self.fail("Include filename does not match")
 
-        dependencies = []
+        repo_dependency_names = []
         for pdata in data['dependencies']:
-            pname = get_package_name(pdata)
-            if pname in dependencies:
-                self.fail("Dependency names must be unique: " + pname)
+            name = get_package_name(pdata)
+            if name in self.dependency_names:
+                self.fail("Dependency names must be unique: " + name)
             else:
-                dependencies.append(pname)
+                self.dependency_names[name] = include
+                repo_dependency_names.append(name)
 
         # Check package order
-        self.assertEqual(dependencies, sorted(dependencies, key=str_cls.lower),
+        self.assertEqual(repo_dependency_names,
+                         sorted(repo_dependency_names, key=str_cls.lower),
                          "Dependencies must be sorted alphabetically")
 
-    def _test_repository_package_order(self, include, data):
+    def _test_repository_package_names(self, include, data):
         m = re.search(r"(?:^|/)(0-9|[a-z]|dependencies)\.json$", include)
         if not m:
             self.fail("Include filename does not match")
-
-        # letter = include[-6]
         letter = m.group(1)
-        packages = []
+
+        repo_package_names = []
+        # Collect package names and check if they are unique,
+        # including occurences in previous_names.
         for pdata in data['packages']:
             pname = get_package_name(pdata)
-            if pname in packages:
-                self.fail("Package names must be unique: " + pname)
+            if pname in self.package_names:
+                self.fail("Package names must be unique: %s, previously "
+                          "occured in %s"
+                          % (pname, self.package_names[pname]))
+            elif pname in self.previous_package_names:
+                self.fail("Package names can not occur as a name and as a "
+                          "previous_name: %s, previously occured as "
+                          "previous_name in %s"
+                          % (pname, self.previous_package_names[pname]))
             else:
-                packages.append(pname)
-
-            # TODO?: Test for *all* "previous_names"
+                self.package_names[pname] = include
+                repo_package_names.append(pname)
 
         # Check if in the correct file
-        for package_name in packages:
+        for package_name in repo_package_names:
             if letter == '0-9':
                 self.assertTrue(package_name[0].isdigit(),
                                 "Package inserted in wrong file")
@@ -209,7 +224,8 @@ class TestContainer(object):
                                  "Package inserted in wrong file")
 
         # Check package order
-        self.assertEqual(packages, sorted(packages, key=str_cls.lower),
+        self.assertEqual(repo_package_names,
+                         sorted(repo_package_names, key=str_cls.lower),
                          "Packages must be sorted alphabetically (by name)")
 
     def _test_indentation(self, filename, contents):
@@ -233,6 +249,8 @@ class TestContainer(object):
     }
 
     def _test_package(self, include, data):
+        name = get_package_name(data)
+
         for k, v in data.items():
             self.enforce_key_types_map(k, v, self.package_key_types_map)
 
@@ -247,8 +265,25 @@ class TestContainer(object):
                                  'The details url is badly formatted or '
                                  'invalid')
 
+            elif k == 'previous_names':
+                # Test if name is unique, against names and previous_names.
+                for prev_name in v:
+                    if prev_name in self.previous_package_names:
+                        self.fail("Previous package names must be unique: %s, "
+                                  "previously occured in %s"
+                                  % (prev_name,
+                                     self.previous_package_names[prev_name]))
+                    elif prev_name in self.package_names:
+                        self.fail("Package names can not occur as a name and "
+                                  "as a previous_name: %s, previously occured "
+                                  "as name in %s"
+                                  % (prev_name, self.package_names[prev_name]))
+                    else:
+                        self.previous_package_names[prev_name] = (
+                            "%s: %s" % (include, name)  # include package hint
+                        )
+
         # Test for invalid characters (on file systems)
-        name = get_package_name(data)
         # Invalid on Windows (and sometimes problematic on UNIX)
         self.assertNotRegex(name, r'[/?<>\\:*|"\x00-\x19]',
                             'Package names must be valid folder names on all '
@@ -593,6 +628,11 @@ class DefaultChannelTests(TestContainer, unittest.TestCase):
             cls.source = f.read().decode('utf-8', 'replace')
             cls.j = json.loads(cls.source)
 
+    @classmethod
+    def tearDownClass(cls):
+        cls.source = None
+        cls.j = None
+
     def test_channel_keys(self):
         keys = sorted(self.j.keys())
         self.assertEqual(keys, ['repositories', 'schema_version'])
@@ -671,7 +711,7 @@ class DefaultRepositoryTests(TestContainer, unittest.TestCase):
             # `include` is for output during tests only
             yield cls._test_indentation, (include, contents)
             yield cls._test_repository_keys, (include, data)
-            yield cls._test_repository_package_order, (include, data)
+            yield cls._test_repository_package_names, (include, data)
 
             for package in data['packages']:
                 yield cls._test_package, (include, package)
@@ -686,7 +726,7 @@ class DefaultRepositoryTests(TestContainer, unittest.TestCase):
                              False))
 
             if 'dependencies' in data:
-                yield cls._test_dependency_order, (include, data)
+                yield cls._test_dependency_names, (include, data)
 
                 for dependency in data['dependencies']:
                     yield cls._test_dependency, (include, dependency)