remove unused methods on DependencyAnalyzer and DependencySet

The CLI stays the same, although this is an API break for anybody who
was calling these methods through the Python API directly.

Deleting them now gives us less to document and commit to, and less to
port over to libsolv.

Change-Id: I4cf62cb561022caf468bec424c57870ec6f12129

rpmdeplint/__init__.py

@@ -51,16 +51,10 @@ def __init__(self):
         self._packagedeps = defaultdict(lambda: dict(dependencies=[],problems=[]))
         self._packages_with_problems = set()
         self._overall_problems = set()
-        self._repodeps = defaultdict(lambda: set())
-        self._repo_packages = defaultdict(lambda: set())
-        self._package_repo = {}
 
-    def add_package(self, pkg, reponame, dependencies, problems):
+    def add_package(self, pkg, dependencies, problems):
         nevra = str(pkg)
         self._packagedeps[nevra]['dependencies'].extend(map(str, dependencies))
-        self._repodeps[reponame].update([d.reponame for d in dependencies])
-        self._repo_packages[reponame].add(nevra)
-        self._package_repo[nevra] = reponame
         if len(problems) != 0:
             self._packagedeps[nevra]['problems'].extend(problems)
             self._packages_with_problems.add(nevra)
@@ -82,19 +76,6 @@ def packages_with_problems(self):
     def package_dependencies(self):
         return dict(self._packagedeps)
 
-    @property
-    def repository_dependencies(self):
-        return {key: sorted(value) for key, value in self._repodeps.items()}
-
-    def repository_for_package(self, pkg):
-        return self._package_repo[pkg]
-
-    def dependencies_for_repository(self, reponame):
-        return sorted(self._repodeps[reponame])
-
-    def dependencies_for_package(self, nevra):
-        return sorted(self._packagedeps[nevra]['dependencies'])
-
 
 class DependencyAnalyzer(object):
     """Context manager which checks packages against provided repos
@@ -135,29 +116,6 @@ def __exit__(self, type, value, tb):
         """ Perform NOP on exit of analyzer to maintain the state of repodata
         cache """
 
-    def find_packages_that_require(self, name):
-        pkgs = hawkey.Query(self._sack).filter(requires=name, latest_per_arch=True)
-        return pkgs
-
-    def find_packages_named(self, name):
-        return hawkey.Query(self._sack).filter(name=name, latest_per_arch=True)
-
-    def find_package_with_nevra(self, nevra):
-        result = hawkey.Query(self._sack).filter(nevra=nevra)
-        if result.count() == 0:
-            return None
-        else:
-            return hawkey.Query(self._sack).filter(nevra=nevra)[0]
-
-    def list_latest_packages(self):
-        query = hawkey.Query(self._sack).filter(latest_per_arch=True)
-        return [pkg for pkg in query]
-
-    def find_packages_for_repos(self, repos):
-        pkgs = self.list_latest_packages()
-        s = set(repos)
-        return [x for x in pkgs if x.reponame in s]
-
     def download_package(self, package):
         if package in self.packages:
             # It's a package under test, nothing to download
@@ -168,31 +126,21 @@ def download_package(self, package):
         return repo.download_package(package.location, package.baseurl,
                 checksum_type=checksum_type, checksum=checksum)
 
-    def try_to_install(self, *packages):
+    def try_to_install_all(self):
         """
-        Try to solve the goal of installing the given package,
+        Try to solve the goal of installing each of the packages under test,
         starting from an empty package set.
         """
-        g = hawkey.Goal(self._sack)
-        for package in packages:
-            g.install(package)
-        results = dict(installs = [], upgrades = [], erasures = [], problems = [])
-        install_succeeded = g.run()
-        if install_succeeded:
-            results['installs'] = g.list_installs()
-            results['upgrades'] = g.list_upgrades()
-            results['erasures'] = g.list_erasures()
-        else:
-            results['problems'] = g.problems
-
-        return install_succeeded, results
-
-    def try_to_install_all(self):
         ds = DependencySet()
         for pkg in self.packages:
             logger.debug('Solving install goal for %s', pkg)
-            ok, results = self.try_to_install(pkg)
-            ds.add_package(pkg, pkg.reponame, results['installs'], results['problems'])
+            g = hawkey.Goal(self._sack)
+            g.install(pkg)
+            install_succeeded = g.run()
+            if install_succeeded:
+                ds.add_package(pkg, g.list_installs(), [])
+            else:
+                ds.add_package(pkg, [], g.problems)
 
         ok = len(ds.overall_problems) == 0
         return ok, ds

rpmdeplint/tests/test_dependency_analyzer.py

@@ -34,40 +34,27 @@ def test_repos(self):
         apple.add_provides('apple-lib')
         apple.add_requires('peeler')
         apple.add_requires('lemon-juice')
+        apple.make()
         self.addCleanup(shutil.rmtree, apple.get_base_dir())
         lemon_meringue_pie = rpmfluff.SimpleRpmBuild('lemon-meringue-pie', '1', '0', ['x86_64'])
         lemon_meringue_pie.add_requires('lemon-zest')
         lemon_meringue_pie.add_requires('lemon-juice')
         lemon_meringue_pie.add_requires('egg-whites')
         lemon_meringue_pie.add_requires('egg-yolks')
         lemon_meringue_pie.add_requires('sugar')
+        lemon_meringue_pie.make()
         self.addCleanup(shutil.rmtree, lemon_meringue_pie.get_base_dir())
-        test_repo = rpmfluff.YumRepoBuild([apple, lemon_meringue_pie])
-        test_repo.make('x86_64', 'noarch')
-        self.addCleanup(shutil.rmtree, test_repo.repoDir)
 
-        da = DependencyAnalyzer(repos=[
-                Repo(repo_name='base_1', baseurl=base_1_repo.repoDir),
-                Repo(repo_name='test', baseurl=test_repo.repoDir)],
-                packages=[])
+        da = DependencyAnalyzer(
+                repos=[Repo(repo_name='base_1', baseurl=base_1_repo.repoDir)],
+                packages=[apple.get_built_rpm('x86_64'),
+                          lemon_meringue_pie.get_built_rpm('x86_64')])
 
-        pkgs = da.list_latest_packages()
-        self.assertEqual(6, len(pkgs))
-        self.assertIs(type(pkgs), list)
-
-        want_cinnamon = da.find_packages_that_require('cinnamon')
-        self.assertEqual(1, len(want_cinnamon))
-        apple_pie = want_cinnamon[0]
-        self.assertEqual('apple-pie-1.9-1.x86_64', str(apple_pie))
-
-        ok, result = da.try_to_install(apple_pie)
-        self.assertEqual(True, ok)
-        self.assertEqual(5, len(result['installs']))
-
-        ok, result = da.try_to_install(*pkgs)
+        ok, dependency_set = da.try_to_install_all()
         self.assertEqual(False, ok)
-        self.assertEqual(1, len(result['problems']))
-        self.assertEqual('nothing provides egg-whites needed by lemon-meringue-pie-1-0.x86_64', result['problems'][0])
+        self.assertEqual(1, len(dependency_set.overall_problems))
+        self.assertEqual(['nothing provides egg-whites needed by lemon-meringue-pie-1-0.x86_64'],
+                dependency_set.package_dependencies['lemon-meringue-pie-1-0.x86_64']['problems'])
 
         eggs = rpmfluff.SimpleRpmBuild('eggs', '1', '3', ['noarch'])
         eggs.add_provides('egg-whites')
@@ -79,13 +66,13 @@ def test_repos(self):
         base_2_repo.make('x86_64', 'noarch')
         self.addCleanup(shutil.rmtree, base_2_repo.repoDir)
 
-        da = DependencyAnalyzer(repos=[
-                Repo(repo_name='base_1', baseurl=base_1_repo.repoDir),
-                Repo(repo_name='base_2', baseurl=base_2_repo.repoDir),
-                Repo(repo_name='test', baseurl=test_repo.repoDir)],
-                packages=[])
+        da = DependencyAnalyzer(
+                repos=[Repo(repo_name='base_1', baseurl=base_1_repo.repoDir),
+                       Repo(repo_name='base_2', baseurl=base_2_repo.repoDir)],
+                packages=[apple.get_built_rpm('x86_64'),
+                          lemon_meringue_pie.get_built_rpm('x86_64')])
 
-        pkgs = da.list_latest_packages()
-        ok, result = da.try_to_install(*pkgs)
+        ok, dependency_set = da.try_to_install_all()
         self.assertEqual(True, ok)
-        self.assertEqual(8, len(result['installs']))
+        self.assertEqual(4, len(dependency_set.package_dependencies['lemon-meringue-pie-1-0.x86_64']['dependencies']))
+        self.assertEqual(3, len(dependency_set.package_dependencies['apple-4.9-3.x86_64']['dependencies']))

rpmdeplint/tests/test_dependency_set.py

@@ -73,10 +73,9 @@ def test_simple(self):
         ds = DependencySet()
         beaker_common = 'beaker-common-22.1-1.fc22.noarch'
         ds.add_package(beaker_common,
-                       'beaker-client',
                        map(lambda x: test_pkg(x, 'fedora_23'), self._beaker_client_deps),
                        [])
 
         self.assertEqual(1, len(ds.packages))
         self.assertEqual(beaker_common, ds.packages[0])
-        self.assertEqual(len(self._beaker_client_deps), len(ds.dependencies_for_package(beaker_common)))
+        self.assertEqual(len(self._beaker_client_deps), len(ds.package_dependencies[beaker_common]['dependencies']))