예제 #1
0
 def test_per_nevra_dict(self):
     sack = support.mock_sack("main")
     pkgs = sack.query().filter(name="lotus")
     dct = dnf.query.per_nevra_dict(pkgs)
     self.assertCountEqual(dct.keys(),
                           ["lotus-3-16.x86_64", "lotus-3-16.i686"])
     self.assertCountEqual(dct.values(), pkgs)
예제 #2
0
 def test_recent(self):
     sack = support.mock_sack("main")
     now = time.time()
     installed = support.MockQuery(sack.query().installed())
     installed[0].buildtime = now - 86400/2
     pkgs = installed.recent(1)
     self.assertEqual(len(pkgs), 1)
예제 #3
0
파일: test_queries.py 프로젝트: lmacken/dnf
 def test_per_nevra_dict(self):
     sack = support.mock_sack("main")
     pkgs = dnf.queries.by_name(sack, "lotus")
     dct = dnf.queries.per_nevra_dict(pkgs)
     self.assertItemsEqual(dct.keys(),
                           ["lotus-3-16.x86_64", "lotus-3-16.i686"])
     self.assertItemsEqual(dct.values(), pkgs)
예제 #4
0
파일: test_update.py 프로젝트: lmacken/dnf
    def test_update_not_found(self):
        base = dnf.Base()
        base._sack = support.mock_sack('updates')
        base._goal = goal = mock.create_autospec(hawkey.Goal)

        self.assertRaises(dnf.exceptions.PackageNotFoundError,
                          base.update, 'non-existent')
        self.assertEqual(goal.mock_calls, [])
예제 #5
0
파일: test_queries.py 프로젝트: lmacken/dnf
 def test_installed_exact(self):
     sack = support.mock_sack()
     pkgs = dnf.queries.installed_exact(sack, "tour", "4.9-0", "noarch")
     self.assertEqual(len(pkgs), 0)
     pkgs = dnf.queries.installed_exact(sack, "tour", "5-0", "x86_64")
     self.assertEqual(len(pkgs), 0)
     pkgs = dnf.queries.installed_exact(sack, "tour", "5-0", "noarch")
     self.assertEqual(len(pkgs), 1)
예제 #6
0
 def test_installed_exact(self):
     sack = support.mock_sack()
     pkgs = sack.query().installed().nevra("tour-4.9-0.noarch")
     self.assertEqual(len(pkgs), 0)
     pkgs = sack.query().installed().nevra("tour-5-0.x86_64")
     self.assertEqual(len(pkgs), 0)
     pkgs = sack.query().installed().nevra("tour-5-0.noarch")
     self.assertEqual(len(pkgs), 1)
예제 #7
0
파일: test_history.py 프로젝트: pnemade/dnf
    def test_find_available_na(self):
        """Test finding with an unavailable NEVRA."""
        sack = support.mock_sack("main")
        converter = dnf.history.TransactionConverter(sack)
        with self.assertRaises(dnf.exceptions.PackagesNotAvailableError) as ctx:
            converter._find_available("none-1-0.noarch")

        self.assertEqual(ctx.exception.pkg_spec, "none-1-0.noarch")
예제 #8
0
    def test_find_installed_ni(self):
        """Test finding with an unistalled NEVRA."""
        sack = support.mock_sack('main')
        converter = dnf.history.TransactionConverter(sack)
        with self.assertRaises(dnf.exceptions.PackagesNotInstalledError) as ctx:
            converter._find_installed('none-1-0.noarch')

        self.assertEqual(ctx.exception.pkg_spec, 'none-1-0.noarch')
예제 #9
0
    def test_sanity(self):
        assert (os.access(support.repo("@System.repo"), os.R_OK))
        sack = support.mock_sack()
        assert (sack)
        self.assertEqual(len(sack), support.SYSTEM_NSOLVABLES)

        sack2 = support.MockBase("main", "updates").sack
        self.assertEqual(len(sack2), support.TOTAL_NSOLVABLES)
예제 #10
0
 def test_recent_pkgs(self):
     sack = support.mock_sack("main")
     now = time.time()
     installed = [support.MockPackage(str(p))
                  for p in sack.query().installed().run()]
     installed[0].buildtime = now - 86400/2
     pkgs = dnf.query.recent_pkgs(installed, 1)
     self.assertEqual(len(pkgs), 1)
예제 #11
0
    def test_sanity(self):
        assert(os.access(support.repo("@System.repo"), os.R_OK))
        sack = support.mock_sack()
        assert(sack)
        self.assertEqual(len(sack), support.SYSTEM_NSOLVABLES)

        sack2 = support.MockBase("main", "updates").sack
        self.assertEqual(len(sack2), support.TOTAL_NSOLVABLES)
예제 #12
0
    def test_update_not_found(self):
        base = support.Base()
        base._sack = support.mock_sack('updates')
        base._goal = goal = mock.create_autospec(dnf.goal.Goal)

        with self.assertRaises(dnf.exceptions.MarkingError) as context:
            base.upgrade('non-existent')
        self.assertEqual(context.exception.pkg_spec, 'non-existent')
        self.assertEqual(goal.mock_calls, [])
예제 #13
0
 def test_duplicities(self):
     sack = support.mock_sack()
     pepper = sack.query().installed().filter(name="pepper")
     # make sure 'pepper' package exists:
     self.assertEqual(len(pepper), 1)
     # we shouldn't see it more than once with a tricky query below:
     res = sack.query().installed().filter(name=["pep*", "*per"])
     res_set = set(res)
     self.assertEqual(len(res), len(res_set))
예제 #14
0
파일: test_update.py 프로젝트: IMFTC/dnf
    def test_update_not_found(self):
        base = dnf.Base()
        base._sack = support.mock_sack('updates')
        base._goal = goal = mock.create_autospec(dnf.goal.Goal)

        with self.assertRaises(dnf.exceptions.MarkingError) as context:
            base.upgrade('non-existent')
        self.assertEqual(context.exception.pkg_spec, 'non-existent')
        self.assertEqual(goal.mock_calls, [])
예제 #15
0
    def test_find_installed_ni(self):
        """Test finding with an unistalled NEVRA."""
        sack = support.mock_sack('main')
        converter = dnf.history.TransactionConverter(sack)
        with self.assertRaises(
                dnf.exceptions.PackagesNotInstalledError) as ctx:
            converter._find_installed('none-1-0.noarch')

        self.assertEqual(ctx.exception.pkg_spec, 'none-1-0.noarch')
예제 #16
0
파일: test_base.py 프로젝트: edynox/dnf
 def test_iter_userinstalled(self):
     """Test iter_userinstalled with a package installed by the user."""
     base = support.MockBase()
     self._setup_packages(base.history)
     base._sack = support.mock_sack('main')
     pkg, = base.sack.query().installed().filter(name='pepper')
     base.history.set_repo(pkg, "main")
     base.history.set_reason(pkg, SwdbReason.USER)
     self.assertEqual(base.history.user_installed(pkg), True)
     self.assertEqual(base.history.repo(pkg), 'main')
예제 #17
0
파일: test_base.py 프로젝트: jsgh/dnf
 def test_iter_userinstalled_badfromrepo(self):
     """Test iter_userinstalled with a package installed from a bad repository."""
     base = support.MockBase()
     base._sack = support.mock_sack('main')
     self._setup_packages(base.history)
     pkg, = base.sack.query().installed().filter(name='pepper')
     base.history.set_repo(pkg, "anakonda")
     base.history.set_reason(pkg, SwdbReason.USER)
     self.assertEqual(base.history.user_installed(pkg), False)
     self.assertEqual(base.history.repo(pkg), 'anakonda')
예제 #18
0
파일: test_base.py 프로젝트: jsgh/dnf
 def test_iter_userinstalled_badreason(self):
     """Test iter_userinstalled with a package installed for a wrong reason."""
     base = support.MockBase()
     base._sack = support.mock_sack('main')
     self._setup_packages(base.history)
     pkg, = base.sack.query().installed().filter(name='pepper')
     base.history.set_reason(pkg, SwdbReason.DEP)
     base.history.set_repo(pkg, "main")
     self.assertEqual(base.history.user_installed(pkg), False)
     self.assertEqual(base.history.repo(pkg), 'main')
예제 #19
0
 def test_recent_pkgs(self):
     sack = support.mock_sack("main")
     now = time.time()
     installed = [
         support.MockPackage(str(p))
         for p in sack.query().installed().run()
     ]
     installed[0].buildtime = now - 86400 / 2
     pkgs = dnf.query.recent_pkgs(installed, 1)
     self.assertEqual(len(pkgs), 1)
예제 #20
0
파일: test_base.py 프로젝트: jsgh/dnf
 def test_iter_userinstalled(self):
     """Test iter_userinstalled with a package installed by the user."""
     base = support.MockBase()
     self._setup_packages(base.history)
     base._sack = support.mock_sack('main')
     pkg, = base.sack.query().installed().filter(name='pepper')
     base.history.set_repo(pkg, "main")
     base.history.set_reason(pkg, SwdbReason.USER)
     self.assertEqual(base.history.user_installed(pkg), True)
     self.assertEqual(base.history.repo(pkg), 'main')
예제 #21
0
 def test_autoremove(self):
     sack = support.mock_sack("main")
     base = support.MockBase("main")
     installed = sack.query().installed()
     for pkg in installed:
         base.yumdb.get_package(pkg).reason = "dep"
     hole = installed.filter(name="hole")[0]
     base.yumdb.get_package(hole).reason = "user"
     pkgs = installed.unneeded(sack, base.yumdb)
     self.assertEqual(len(pkgs), support.TOTAL_RPMDB_COUNT-1)
예제 #22
0
파일: test_base.py 프로젝트: edynox/dnf
 def test_iter_userinstalled_badfromrepo(self):
     """Test iter_userinstalled with a package installed from a bad repository."""
     base = support.MockBase()
     base._sack = support.mock_sack('main')
     self._setup_packages(base.history)
     pkg, = base.sack.query().installed().filter(name='pepper')
     base.history.set_repo(pkg, "anakonda")
     base.history.set_reason(pkg, SwdbReason.USER)
     self.assertEqual(base.history.user_installed(pkg), False)
     self.assertEqual(base.history.repo(pkg), 'anakonda')
예제 #23
0
파일: test_base.py 프로젝트: edynox/dnf
 def test_iter_userinstalled_badreason(self):
     """Test iter_userinstalled with a package installed for a wrong reason."""
     base = support.MockBase()
     base._sack = support.mock_sack('main')
     self._setup_packages(base.history)
     pkg, = base.sack.query().installed().filter(name='pepper')
     base.history.set_reason(pkg, SwdbReason.DEP)
     base.history.set_repo(pkg, "main")
     self.assertEqual(base.history.user_installed(pkg), False)
     self.assertEqual(base.history.repo(pkg), 'main')
예제 #24
0
 def test_latest(self):
     sack = support.mock_sack("old_versions")
     tours = sack.query().filter(name="tour")
     all_tours = sorted(tours.run(), reverse=True)
     head2 = all_tours[0:2]
     tail2 = all_tours[2:]
     pkgs = tours.latest(2).run()
     self.assertEqual(pkgs, head2)
     pkgs = tours.latest(-2).run()
     self.assertEqual(pkgs, tail2)
예제 #25
0
파일: test_queries.py 프로젝트: lmacken/dnf
    def test_by_file(self):
        # check sanity first:
        sack = support.mock_sack()
        q = sack.query().filter(file__eq="/raised/smile")
        self.assertEqual(len(q.run()), 1)
        pkg = q.result[0]

        # now the query:
        res = dnf.queries.by_file(sack, "/raised/smile")
        self.assertEqual(len(res), 1)
        self.assertEqual(pkg, res[0])
예제 #26
0
    def setUp(self):
        self._base = dnf.cli.cli.BaseCli()
        self._base._sack = support.mock_sack('main', 'updates')
        self._base._goal = dnf.goal.Goal(self._base.sack)

        main_repo = support.MockRepo('main', None)
        main_repo.metadata = mock.Mock(comps_fn=support.COMPS_PATH)
        main_repo.enable()
        self._base.repos.add(main_repo)

        self._base.output.term = support.MockTerminal()
        self._base.downgrade = mock.Mock(wraps=self._base.downgrade)
예제 #27
0
    def test_iter_userinstalled_badfromrepo(self):
        """Test iter_userinstalled with a package installed from a bad repository."""
        base = dnf.Base()
        base._sack = support.mock_sack('main')
        base._yumdb = support.MockYumDB()

        pkg, = base.sack.query().installed().filter(name='pepper')
        base.yumdb.get_package(pkg).get = {'reason': 'user', 'from_repo': 'anakonda'}.get

        iterator = base.iter_userinstalled()

        self.assertRaises(StopIteration, next, iterator)
예제 #28
0
    def test_iter_userinstalled(self):
        """Test iter_userinstalled with a package installed by the user."""
        base = support.Base()
        base._sack = support.mock_sack('main')
        base._priv_yumdb = support.MockYumDB()
        pkg, = base.sack.query().installed().filter(name='pepper')
        base._yumdb.get_package(pkg).get = {'reason': 'user', 'from_repo': 'main'}.get

        iterator = base.iter_userinstalled()

        self.assertEqual(next(iterator), pkg)
        self.assertRaises(StopIteration, next, iterator)
예제 #29
0
파일: test_base.py 프로젝트: Conan-Kudo/dnf
    def test_iter_userinstalled_badreason(self):
        """Test iter_userinstalled with a package installed for a wrong reason."""
        base = support.Base()
        base._sack = support.mock_sack('main')
        base._priv_yumdb = support.MockYumDB()

        pkg, = base.sack.query().installed().filter(name='pepper')
        base._yumdb.get_package(pkg).get = {'reason': 'dep', 'from_repo': 'main'}.get

        iterator = base.iter_userinstalled()

        self.assertRaises(StopIteration, next, iterator)
예제 #30
0
    def test_iter_userinstalled(self):
        """Test iter_userinstalled with a package installed by the user."""
        base = dnf.Base()
        base._sack = support.mock_sack('main')
        base._priv_yumdb = support.MockYumDB()
        pkg, = base.sack.query().installed().filter(name='pepper')
        base._yumdb.get_package(pkg).get = {'reason': 'user', 'from_repo': 'main'}.get

        iterator = base.iter_userinstalled()

        self.assertEqual(next(iterator), pkg)
        self.assertRaises(StopIteration, next, iterator)
예제 #31
0
파일: test_cli.py 프로젝트: IMFTC/dnf
    def setUp(self):
        self._base = dnf.cli.cli.BaseCli()
        self._base._sack = support.mock_sack('main', 'updates')
        self._base._goal = dnf.goal.Goal(self._base.sack)

        main_repo = support.MockRepo('main', None)
        main_repo.metadata = mock.Mock(comps_fn=support.COMPS_PATH)
        main_repo.enable()
        self._base.repos.add(main_repo)

        self._base.output.term = support.MockTerminal()
        self._base.downgrade = mock.Mock(wraps=self._base.downgrade)
예제 #32
0
파일: test_history.py 프로젝트: pnemade/dnf
    def test_convert_erase(self):
        """Test conversion with an erasure."""
        operations = dnf.history.NEVRAOperations()
        operations.add("Erase", "pepper-20-0.x86_64")

        sack = support.mock_sack()
        converter = dnf.history.TransactionConverter(sack)
        actual = converter.convert(operations)

        expected = dnf.transaction.Transaction()
        expected.add_erase(next(iter(sack.query().installed()._nevra("pepper-20-0.x86_64"))))
        self.assert_transaction_equal(actual, expected)
예제 #33
0
    def test_iter_userinstalled_badfromrepo(self):
        """Test iter_userinstalled with a package installed from a bad repository."""
        base = dnf.Base()
        base._sack = support.mock_sack('main')
        base._yumdb = support.MockYumDB()

        pkg, = base.sack.query().installed().filter(name='pepper')
        base.yumdb.get_package(pkg).get = {'reason': 'user', 'from_repo': 'anakonda'}.get

        iterator = base.iter_userinstalled()

        self.assertRaises(StopIteration, next, iterator)
예제 #34
0
파일: test_cli.py 프로젝트: lmacken/dnf
 def setUp(self):
     self._yumbase = dnf.cli.cli.BaseCli()
     self._yumbase._sack = support.mock_sack('main')
     self._yumbase._goal = hawkey.Goal(self._yumbase.sack)
     self._yumbase.logger = mock.create_autospec(self._yumbase.logger)
     self._yumbase.term = support.FakeTerm()
     self._yumbase._checkMaybeYouMeant = mock.create_autospec(self._yumbase._checkMaybeYouMeant)
     self._yumbase._maybeYouMeant = mock.create_autospec(self._yumbase._maybeYouMeant)
     self._yumbase.downgrade = mock.Mock(wraps=self._yumbase.downgrade)
     self._yumbase.install = mock.Mock(wraps=self._yumbase.install)
     self._yumbase.reinstall = mock.Mock(wraps=self._yumbase.reinstall)
     self._yumbase.remove = mock.Mock(wraps=self._yumbase.remove)
     self._yumbase.update = mock.Mock(wraps=self._yumbase.update)
예제 #35
0
파일: test_cli.py 프로젝트: hutarova/dnf
    def setUp(self):
        self._base = dnf.cli.cli.BaseCli()
        self._base._sack = support.mock_sack("main", "updates")
        self._base._goal = dnf.goal.Goal(self._base.sack)

        main_repo = support.MockRepo("main", None)
        main_repo.metadata = mock.Mock(comps_fn=support.COMPS_PATH)
        main_repo.enable()
        self._base.repos.add(main_repo)

        self._base.logger = mock.create_autospec(self._base.logger)
        self._base.output.term = support.MockTerminal()
        self._base.downgrade = mock.Mock(wraps=self._base.downgrade)
예제 #36
0
    def test_convert_erase(self):
        """Test conversion with an erasure."""
        operations = dnf.history.NEVRAOperations()
        operations.add('Erase', 'pepper-20-0.x86_64')

        sack = support.mock_sack()
        converter = dnf.history.TransactionConverter(sack)
        actual = converter.convert(operations)

        expected = dnf.transaction.Transaction()
        expected.add_erase(
            next(iter(sack.query().installed().nevra('pepper-20-0.x86_64'))))
        self.assert_transaction_equal(actual, expected)
예제 #37
0
    def test_history_undo_operations_erase_twoavailable(self):
        """Test history_undo_operations with an erase available in two repos."""
        base = MockBase()
        base._sack = mock_sack('main', 'search')
        operations = NEVRAOperations()
        operations.add('Erase', 'lotus-3-16.x86_64')

        with base:
            base._history_undo_operations(operations, 0)

            transaction_it = iter(base.transaction)
            self.assertEqual(next(transaction_it), self._create_item_matcher(
                INSTALL, installed='lotus-3-16.x86_64', reason=SwdbReason.USER))
            self.assertRaises(StopIteration, next, transaction_it)
예제 #38
0
    def test_convert_reinstall(self):
        """Test conversion with a reinstallation."""
        operations = dnf.history.NEVRAOperations()
        operations.add('Reinstall', 'pepper-20-0.x86_64', 'pepper-20-0.x86_64',
                       ['hole-1-1.x86_64'])

        sack = support.mock_sack('main')
        converter = dnf.history.TransactionConverter(sack)
        actual = converter.convert(operations)

        expected = dnf.transaction.Transaction()
        expected.add_reinstall(
            next(iter(sack.query().available().nevra('pepper-20-0.x86_64'))),
            next(iter(sack.query().installed().nevra('pepper-20-0.x86_64'))),
            [next(iter(sack.query().installed().nevra('hole-1-1.x86_64')))])
        self.assert_transaction_equal(actual, expected)
예제 #39
0
    def test_upgrade(self):
        """Test repeating with an upgrade."""
        operations = dnf.history.NEVRAOperations()
        operations.add('Update', 'pepper-20-1.x86_64', 'pepper-20-0.x86_64',
                       ['hole-1-1.x86_64'])

        sack = support.mock_sack('updates')
        converter = dnf.history.TransactionConverter(sack)
        actual = converter.convert(operations)

        expected = dnf.transaction.Transaction()
        expected.add_upgrade(
            next(iter(sack.query().available().nevra('pepper-20-1.x86_64'))),
            next(iter(sack.query().installed().nevra('pepper-20-0.x86_64'))),
            [next(iter(sack.query().installed().nevra('hole-1-1.x86_64')))])
        self.assert_transaction_equal(actual, expected)
예제 #40
0
    def test_convert_install(self):
        """Test conversion with an installation."""
        operations = dnf.history.NEVRAOperations()
        operations.add('Install', 'lotus-3-16.x86_64',
                       obsoleted_nevras=['hole-1-1.x86_64'])

        sack = support.mock_sack('main')
        converter = dnf.history.TransactionConverter(sack)
        actual = converter.convert(operations, 'reason')

        expected = dnf.transaction.Transaction()
        expected.add_install(
            next(iter(sack.query().available().nevra('lotus-3-16.x86_64'))),
            [next(iter(sack.query().installed().nevra('hole-1-1.x86_64')))],
            'reason')
        self.assert_transaction_equal(actual, expected)
예제 #41
0
    def test_convert_downgrade(self):
        """Test conversion with a downgrade."""
        operations = dnf.history.NEVRAOperations()
        operations.add('Downgrade', 'tour-4.6-1.noarch', 'tour-5-0.noarch',
                       ['hole-1-1.x86_64'])

        sack = support.mock_sack('main')
        converter = dnf.history.TransactionConverter(sack)
        actual = converter.convert(operations)

        expected = dnf.transaction.Transaction()
        expected.add_downgrade(
            next(iter(sack.query().available().nevra('tour-4.6-1.noarch'))),
            next(iter(sack.query().installed().nevra('tour-5-0.noarch'))),
            [next(iter(sack.query().installed().nevra('hole-1-1.x86_64')))])
        self.assert_transaction_equal(actual, expected)
예제 #42
0
    def test_history_undo_operations_erase_twoavailable(self):
        """Test history_undo_operations with an erase available in two repos."""
        base = Base()
        base._sack = mock_sack('main', 'search')
        operations = NEVRAOperations()
        operations.add('Erase', 'lotus-3-16.x86_64')

        with base:
            base.history_undo_operations(operations)

        transaction_it = iter(base.transaction)
        self.assertEqual(next(transaction_it),
                         self._create_item_matcher(
                             INSTALL, installed='lotus-3-16.x86_64',
                             reason='history'))
        self.assertRaises(StopIteration, next, transaction_it)
예제 #43
0
    def test_upgrade(self):
        """Test repeating with an upgrade."""
        operations = dnf.history.NEVRAOperations()
        operations.add('Update', 'pepper-20-1.x86_64', 'pepper-20-0.x86_64',
                       ['hole-1-1.x86_64'])

        sack = support.mock_sack('updates')
        converter = dnf.history.TransactionConverter(sack)
        actual = converter.convert(operations)

        expected = dnf.transaction.Transaction()
        expected.add_upgrade(
            next(iter(sack.query().available().nevra('pepper-20-1.x86_64'))),
            next(iter(sack.query().installed().nevra('pepper-20-0.x86_64'))),
            [next(iter(sack.query().installed().nevra('hole-1-1.x86_64')))])
        self.assert_transaction_equal(actual, expected)
예제 #44
0
    def test_convert_reinstall(self):
        """Test conversion with a reinstallation."""
        operations = dnf.history.NEVRAOperations()
        operations.add('Reinstall', 'pepper-20-0.x86_64', 'pepper-20-0.x86_64',
                       ['hole-1-1.x86_64'])

        sack = support.mock_sack('main')
        converter = dnf.history.TransactionConverter(sack)
        actual = converter.convert(operations)

        expected = dnf.transaction.Transaction()
        expected.add_reinstall(
            next(iter(sack.query().available().nevra('pepper-20-0.x86_64'))),
            next(iter(sack.query().installed().nevra('pepper-20-0.x86_64'))),
            [next(iter(sack.query().installed().nevra('hole-1-1.x86_64')))])
        self.assert_transaction_equal(actual, expected)
예제 #45
0
    def test_convert_downgrade(self):
        """Test conversion with a downgrade."""
        operations = dnf.history.NEVRAOperations()
        operations.add('Downgrade', 'tour-4.6-1.noarch', 'tour-5-0.noarch',
                       ['hole-1-1.x86_64'])

        sack = support.mock_sack('main')
        converter = dnf.history.TransactionConverter(sack)
        actual = converter.convert(operations)

        expected = dnf.transaction.Transaction()
        expected.add_downgrade(
            next(iter(sack.query().available().nevra('tour-4.6-1.noarch'))),
            next(iter(sack.query().installed().nevra('tour-5-0.noarch'))),
            [next(iter(sack.query().installed().nevra('hole-1-1.x86_64')))])
        self.assert_transaction_equal(actual, expected)
예제 #46
0
    def test_convert_install(self):
        """Test conversion with an installation."""
        operations = dnf.history.NEVRAOperations()
        operations.add('Install',
                       'lotus-3-16.x86_64',
                       obsoleted_nevras=['hole-1-1.x86_64'])

        sack = support.mock_sack('main')
        converter = dnf.history.TransactionConverter(sack)
        actual = converter.convert(operations, 'reason')

        expected = dnf.transaction.Transaction()
        expected.add_install(
            next(iter(sack.query().available().nevra('lotus-3-16.x86_64'))),
            [next(iter(sack.query().installed().nevra('hole-1-1.x86_64')))],
            'reason')
        self.assert_transaction_equal(actual, expected)
예제 #47
0
 def test_duplicated(self):
     sack = support.mock_sack()
     pkgs = sack.query().duplicated()
     self.assertEqual(len(pkgs), 3)
예제 #48
0
 def setUp(self):
     self.sack = support.mock_sack("main", "updates")
예제 #49
0
 def setUp(self):
     """Prepare the test fixture."""
     self._base = Base()
     self._base._sack = mock_sack('main', 'updates')
예제 #50
0
파일: test_cli.py 프로젝트: sourcejedi/dnf
 def setUp(self):
     self._base = dnf.cli.cli.BaseCli()
     self._base._sack = support.mock_sack('main', 'updates')
     self._base._goal = dnf.goal.Goal(self._base.sack)
     self._base.output.term = support.MockTerminal()
     self._base.downgrade_to = mock.Mock(wraps=self._base.downgrade_to)
예제 #51
0
 def test_by_repo(self):
     sack = support.mock_sack("updates", "main")
     pkgs = sack.query().filter(reponame__eq="updates")
     self.assertEqual(len(pkgs), support.UPDATES_NSOLVABLES)
     pkgs = sack.query().filter(reponame__eq="main")
     self.assertEqual(len(pkgs), support.MAIN_NSOLVABLES)
예제 #52
0
 def test_by_file(self):
     # check sanity first:
     sack = support.mock_sack()
     q = sack.query().filter(file__eq="/raised/smile")
     self.assertEqual(len(q.run()), 1)
     pkg = q.result[0]
예제 #53
0
 def test_extras(self):
     sack = support.mock_sack("main")
     pkgs = sack.query().extras()
     self.assertEqual(len(pkgs), support.TOTAL_RPMDB_COUNT-2)
예제 #54
0
파일: test_downgrade.py 프로젝트: jsgh/dnf
 def setUp(self):
     self._base = support.MockBase()
     self._base._sack = support.mock_sack('main')
     self._base._goal = self._goal = mock.create_autospec(dnf.goal.Goal)