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)
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)
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)
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, [])
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)
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)
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")
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')
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)
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)
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)
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, [])
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))
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, [])
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')
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')
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')
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')
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)
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')
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)
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')
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')
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)
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])
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
def test_duplicated(self):
sack = support.mock_sack()
pkgs = sack.query().duplicated()
self.assertEqual(len(pkgs), 3)
def setUp(self):
self.sack = support.mock_sack("main", "updates")
def setUp(self):
"""Prepare the test fixture."""
self._base = Base()
self._base._sack = mock_sack('main', 'updates')
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)
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)
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]
def test_extras(self):
sack = support.mock_sack("main")
pkgs = sack.query().extras()
self.assertEqual(len(pkgs), support.TOTAL_RPMDB_COUNT-2)
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)
