[tests]: reintroduce dropped unit tests

Author: Eduard Čuba

tests/README

@@ -6,10 +6,7 @@ What will not be tested:
 * rpm transactions themselves (tested in RPM)
 * depsolving (the core depsolving algorithms are tested in libsolv, correctly
   setting up libsolv is hawkey's job)
-* Swdb functions - tested in libdnf
-
-Missing
-* SwdbInterface tests
+* SWDB functions (tested in libdnf)
 
 == The repos/ directory ==
 

tests/support.py

@@ -18,6 +18,7 @@
 from __future__ import absolute_import
 from __future__ import unicode_literals
 from functools import reduce
+from dnf.db.types import SwdbReason, SwdbPkgData
 import contextlib
 import dnf
 import dnf.conf
@@ -151,6 +152,17 @@ def command_run(cmd, args):
     command_configure(cmd, args)
     return cmd.run()
 
+
+def mockSwdbPkg(history, pkg, state="Installed", repo="unknown", reason=SwdbReason.USER):
+    """ Add DnfPackage into database """
+    hpkg = history.ipkg_to_pkg(pkg)
+    pid = history.add_package(hpkg)
+    pkg_data = SwdbPkgData()
+    history.swdb.trans_data_beg(0, pid, reason, state, False)
+    history.update_package_data(pid, 0, pkg_data)
+    history.set_repo(hpkg, repo)
+
+
 class Base(dnf.Base):
     def __init__(self, *args, **kwargs):
         with mock.patch('dnf.rpm.detect_releasever', return_value=69):

tests/test_commands.py

@@ -18,7 +18,7 @@
 from __future__ import absolute_import
 from __future__ import unicode_literals
 from tests import support
-from tests.support import mock
+from tests.support import mock, mockSwdbPkg
 
 import dnf.cli.commands
 import dnf.cli.commands.group
@@ -192,6 +192,26 @@ def test_run_notinstalled(self):
         self.assertResult(self._cmd.cli.base,
                           self._cmd.cli.base.sack.query().installed())
 
+    @mock.patch('dnf.cli.commands.reinstall._', dnf.pycomp.NullTranslations().ugettext)
+    def test_run_notavailable(self):
+        """ Test whether it fails if the package is not available. """
+        base = self._cmd.cli.base
+        holes_query = dnf.subject.Subject('hole').get_best_query(base.sack)
+        history = self._cmd.base.history
+        for pkg in holes_query.installed():
+            mockSwdbPkg(history, pkg)
+
+        stdout = dnf.pycomp.StringIO()
+
+        with support.wiretap_logs('dnf', logging.INFO, stdout):
+            self.assertRaises(dnf.exceptions.Error, support.command_run, self._cmd, ['hole'])
+
+        self.assertEqual(
+            stdout.getvalue(),
+            'Installed package hole-1-1.x86_64 (from unknown) not available.\n')
+        self.assertResult(base, base.sack.query().installed())
+
+
 class RepoPkgsCommandTest(unittest.TestCase):
 
     """Tests of ``dnf.cli.commands.RepoPkgsCommand`` class."""
@@ -214,6 +234,34 @@ class RepoPkgsCheckUpdateSubCommandTest(unittest.TestCase):
 
     """Tests of ``dnf.cli.commands.RepoPkgsCommand.CheckUpdateSubCommand`` class."""
 
+    def test(self):
+        """ Test whether only upgrades in the repository are listed. """
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed().filter(name='tour'):
+            mockSwdbPkg(history, pkg, repo='updates')
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        with support.patch_std_streams() as (stdout, _):
+            support.command_run(cmd, ['updates', 'check-update'])
+
+        self.assertEqual(
+            stdout.getvalue(),
+            u'\n'
+            u'hole.x86_64                              2-1'
+            u'                            updates \n'
+            u'pepper.x86_64                            20-1'
+            u'                           updates \n'
+            u'Obsoleting Packages\n'
+            u'hole.i686                                2-1'
+            u'                            updates \n'
+            u'    tour.noarch                          5-0'
+            u'                            @updates\n'
+            u'hole.x86_64                              2-1'
+            u'                            updates \n'
+            u'    tour.noarch                          5-0'
+            u'                            @updates\n')
+        self.assertEqual(self.cli.demands.success_exit_status, 100)
+
     def setUp(self):
         """Prepare the test fixture."""
         super(RepoPkgsCheckUpdateSubCommandTest, self).setUp()
@@ -287,6 +335,45 @@ def setUp(self):
         base.conf.recent = 7
         self.cli = base.mock_cli()
 
+    def test_info_all(self):
+        """Test whether only packages related to the repository are listed."""
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed().filter(name='pepper'):
+            mockSwdbPkg(history, pkg, repo='main')
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        with support.patch_std_streams() as (stdout, _):
+            support.command_run(cmd, ['main', 'info', 'all', '*p*'])
+
+        self.assertEqual(
+            stdout.getvalue(),
+            ''.join((
+                self.INSTALLED_TITLE,
+                self.PEPPER_SYSTEM_INFO,
+                self.AVAILABLE_TITLE,
+                u'Name         : pepper\n'
+                u'Version      : 20\n'
+                u'Release      : 0\n'
+                u'Arch         : src\n'
+                u'Size         : 0.0  \n'
+                u'Source       : None\n'
+                u'Repo         : main\n'
+                u'Summary      : \n'
+                u'License      : \n'
+                u'Description  : \n'
+                u'\n',
+                u'Name         : trampoline\n'
+                u'Version      : 2.1\n'
+                u'Release      : 1\n'
+                u'Arch         : noarch\n'
+                u'Size         : 0.0  \n'
+                u'Source       : None\n'
+                u'Repo         : main\n'
+                u'Summary      : \n'
+                u'License      : \n'
+                u'Description  : \n'
+                u'\n')))
+
     def test_info_available(self):
         """Test whether only packages in the repository are listed."""
         cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
@@ -301,6 +388,45 @@ def test_info_available(self):
                 self.HOLE_X86_64_INFO,
                 self.PEPPER_UPDATES_INFO)))
 
+    def test_info_extras(self):
+        """Test whether only extras installed from the repository are listed."""
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed().filter(name='tour'):
+            mockSwdbPkg(history, pkg, repo='main')
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        with support.patch_std_streams() as (stdout, _):
+            support.command_run(cmd, ['main', 'info', 'extras'])
+
+        self.assertEqual(
+            stdout.getvalue(),
+            u'Extra Packages\n'
+            u'Name         : tour\n'
+            u'Version      : 5\n'
+            u'Release      : 0\n'
+            u'Arch         : noarch\n'
+            u'Size         : 0.0  \n'
+            u'Source       : None\n'
+            u'Repo         : @System\n'
+            u'From repo    : main\n'
+            u'Summary      : \n'
+            u'License      : \n'
+            u'Description  : \n\n')
+
+    def test_info_installed(self):
+        """Test whether only packages installed from the repository are listed."""
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed().filter(name='pepper'):
+            mockSwdbPkg(history, pkg, repo='main')
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        with support.patch_std_streams() as (stdout, _):
+            support.command_run(cmd, ['main', 'info', 'installed'])
+
+        self.assertEqual(
+            stdout.getvalue(),
+            ''.join((self.INSTALLED_TITLE, self.PEPPER_SYSTEM_INFO)))
+
     def test_info_obsoletes(self):
         """Test whether only obsoletes in the repository are listed."""
         cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
@@ -381,6 +507,34 @@ def test_all(self):
             dnf.subject.Subject('tour-5-0').get_best_query(self.cli.base.sack)
             .available()))
 
+class RepoPkgsReinstallOldSubCommandTest(support.ResultTestCase):
+
+    """Tests of ``dnf.cli.commands.RepoPkgsCommand.ReinstallOldSubCommand`` class."""
+
+    def setUp(self):
+        """Prepare the test fixture."""
+        super(RepoPkgsReinstallOldSubCommandTest, self).setUp()
+        base = support.BaseCliStub('main')
+        base.init_sack()
+        self.cli = base.mock_cli()
+
+    def test_all(self):
+        """Test whether all packages from the repository are reinstalled."""
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed():
+            reponame = 'main' if pkg.name != 'pepper' else 'non-main'
+            mockSwdbPkg(history, pkg, repo=reponame)
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        support.command_run(cmd, ['main', 'reinstall-old'])
+
+        self.assertResult(self.cli.base, itertools.chain(
+              self.cli.base.sack.query().installed().filter(name__neq='librita'),
+              dnf.subject.Subject('librita.i686').get_best_query(self.cli.base.sack)
+              .installed(),
+              dnf.subject.Subject('librita').get_best_query(self.cli.base.sack)
+              .available()))
+
 
 class RepoPkgsReinstallSubCommandTest(unittest.TestCase):
 
@@ -445,6 +599,52 @@ def setUp(self):
         self.cli = support.BaseCliStub('distro').mock_cli()
         self.cli.base.init_sack()
 
+    def test_run_on_repo_spec_sync(self):
+        """Test running with a package which can be synchronized."""
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed():
+            reponame = 'non-distro' if pkg.name == 'pepper' else 'distro'
+            mockSwdbPkg(history, pkg, repo=reponame)
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        support.command_run(cmd, ['non-distro', 'remove-or-distro-sync', 'pepper'])
+
+        self.assertResult(self.cli.base, itertools.chain(
+            self.cli.base.sack.query().installed().filter(name__neq='pepper'),
+            dnf.subject.Subject('pepper').get_best_query(self.cli.base.sack)
+            .available()))
+
+    def test_run_on_repo_spec_remove(self):
+        """Test running with a package which must be removed."""
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed():
+            reponame = 'non-distro' if pkg.name == 'hole' else 'distro'
+            mockSwdbPkg(history, pkg, repo=reponame)
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        support.command_run(cmd, ['non-distro', 'remove-or-distro-sync', 'hole'])
+
+        self.assertResult(
+            self.cli.base,
+            self.cli.base.sack.query().installed().filter(name__neq='hole'))
+
+    def test_run_on_repo_all(self):
+        """Test running without a package specification."""
+        nondist = {'pepper', 'hole'}
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed():
+            reponame = 'non-distro' if pkg.name in nondist else 'distro'
+            mockSwdbPkg(history, pkg, repo=reponame)
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        support.command_run(cmd, ['non-distro', 'remove-or-distro-sync'])
+
+        self.assertResult(self.cli.base, itertools.chain(
+            self.cli.base.sack.query().installed().filter(name__neq='pepper')
+            .filter(name__neq='hole'),
+            dnf.subject.Subject('pepper').get_best_query(self.cli.base.sack)
+            .available()))
+
     @mock.patch('dnf.cli.commands._', dnf.pycomp.NullTranslations().ugettext)
     def test_run_on_repo_spec_notinstalled(self):
         """Test running with a package which is not installed."""
@@ -484,6 +684,70 @@ def setUp(self):
         base.init_sack()
         self.cli = base.mock_cli()
 
+    def test_all_not_installed(self):
+        """Test whether it fails if no package is installed from the repository."""
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        self.assertRaises(dnf.exceptions.Error,
+                          support.command_run, cmd,
+                          ['non-distro', 'remove-or-distro-sync'])
+
+        self.assertResult(self.cli.base, self.cli.base.sack.query().installed())
+
+    def test_all_reinstall(self):
+        """Test whether all packages from the repository are reinstalled."""
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed():
+            reponame = 'distro' if pkg.name != 'tour' else 'non-distro'
+            mockSwdbPkg(history, pkg, repo=reponame)
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        support.command_run(cmd, ['non-distro', 'remove-or-reinstall'])
+
+        self.assertResult(self.cli.base, itertools.chain(
+              self.cli.base.sack.query().installed().filter(name__neq='tour'),
+              dnf.subject.Subject('tour').get_best_query(self.cli.base.sack)
+              .available()))
+
+    def test_all_remove(self):
+        """Test whether all packages from the repository are removed."""
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed():
+            reponame = 'distro' if pkg.name != 'hole' else 'non-distro'
+            mockSwdbPkg(history, pkg, repo=reponame)
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        support.command_run(cmd, ['non-distro', 'remove-or-reinstall'])
+
+        self.assertResult(
+            self.cli.base,
+            self.cli.base.sack.query().installed().filter(name__neq='hole'))
+
+
+class RepoPkgsRemoveSubCommandTest(support.ResultTestCase):
+
+    """Tests of ``dnf.cli.commands.RepoPkgsCommand.RemoveSubCommand`` class."""
+
+    def setUp(self):
+        """Prepare the test fixture."""
+        super(RepoPkgsRemoveSubCommandTest, self).setUp()
+        base = support.BaseCliStub('main')
+        base.init_sack()
+        self.cli = base.mock_cli()
+
+    def test_all(self):
+        """Test whether only packages from the repository are removed."""
+        history = self.cli.base.history
+        for pkg in self.cli.base.sack.query().installed():
+            reponame = 'main' if pkg.name == 'pepper' else 'non-main'
+            mockSwdbPkg(history, pkg, repo=reponame)
+
+        cmd = dnf.cli.commands.RepoPkgsCommand(self.cli)
+        support.command_run(cmd, ['main', 'remove'])
+
+        self.assertResult(
+            self.cli.base,
+            self.cli.base.sack.query().installed().filter(name__neq='pepper'))
+
 
 class RepoPkgsUpgradeSubCommandTest(support.ResultTestCase):
 

tests/test_list.py

@@ -40,6 +40,19 @@ def test_list_installed(self):
         ypl = base._do_package_lists('installed')
         self.assertEqual(len(ypl.installed), support.TOTAL_RPMDB_COUNT)
 
+    def test_list_installed_reponame(self):
+        """Test whether only packages installed from the repository are listed."""
+        base = support.MockBase()
+        expected = base.sack.query().installed().filter(name={'pepper',
+                                                              'librita'})
+        history = base.history
+        for pkg in expected:
+            support.mockSwdbPkg(history, pkg, repo='main')
+
+        lists = base._do_package_lists('installed', reponame='main')
+
+        self.assertCountEqual(lists.installed, expected)
+
     def test_list_updates(self):
         base = support.MockBase("updates", "main")
         ypl = base._do_package_lists('upgrades')