Python support.mock_sack函数代码示例

 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)