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_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_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_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_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_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_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_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_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_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_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_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_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_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(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)