def test_fill_sack(self):
def raiser():
raise dnf.exceptions.RepoError()
base = support.MockBase()
r = support.MockRepo('bag', base.conf)
r.enable()
base._repos.add(r)
r.load = mock.Mock(side_effect=raiser)
r.skip_if_unavailable = False
self.assertRaises(dnf.exceptions.RepoError,
base.fill_sack,
load_system_repo=False)
self.assertTrue(r.enabled)
self.assertTrue(r._check_config_file_age)
r.skip_if_unavailable = True
base.fill_sack(load_system_repo=False)
self.assertFalse(r.enabled)
def __init__(self, *args):
support.TestCase.__init__(self, *args)
self.base = support.MockBase()
self.sack = self.base.sack
# load the testing repo
repo = support.MockRepo('drpm', '/tmp/dnf-cache')
self.base.repos[repo.id] = repo
repo.baseurl = ['file://%s/%s' % (support.repo_dir(), repo.id)]
repo.load()
# add it to sack
hrepo = hawkey.Repo(repo.id)
hrepo.repomd_fn = repo.repomd_fn
hrepo.primary_fn = repo.primary_fn
hrepo.filelists_fn = repo.filelists_fn
hrepo.presto_fn = repo.presto_fn
self.sack.load_yum_repo(hrepo, load_filelists=True, load_presto=True)
def test_configure_repos_expired(self, _):
"""Ensure that --cacheonly beats the expired status."""
opts = Namespace()
opts.repo = []
opts.repos_ed = []
opts.cacheonly = True
opts.repofrompath = {}
pers = self.base._repo_persistor
pers.get_expired_repos = mock.Mock(return_value=('one', ))
self.base._repos = dnf.repodict.RepoDict()
self.base._repos.add(support.MockRepo('one', self.base.conf))
self.cli._configure_repos(opts)
# _process_demands() should respect --cacheonly in spite of modified demands
self.cli.demands.fresh_metadata = False
self.cli.demands.cacheonly = True
self.cli._process_demands()
self.assertEqual(self.base.repos['one']._sync_strategy,
dnf.repo.SYNC_ONLY_CACHE)
def test_makecache_timer(self, _on_ac_power, logger):
cmd = makecache.MakeCacheCommand(self.cli)
self.base.conf.metadata_timer_sync = 0
self.assertFalse(self._do_makecache(cmd))
self.assert_last_info(logger, u'Metadata timer caching disabled.')
self.base.conf.metadata_timer_sync = 5 # resync after 5 seconds
self.base._repo_persistor.since_last_makecache = mock.Mock(
return_value=3)
self.assertFalse(self._do_makecache(cmd))
self.assert_last_info(logger, u'Metadata cache refreshed recently.')
self.base._repo_persistor.since_last_makecache = mock.Mock(
return_value=10)
self.base._sack = 'nonempty'
r = support.MockRepo("glimpse", self.base.conf)
self.base.repos.add(r)
# regular case 1: metadata is already expired:
r._metadata_expire_in = mock.Mock(return_value=(False, 0))
r._sync_strategy = dnf.repo.SYNC_TRY_CACHE
self.assertTrue(self._do_makecache(cmd))
self.assert_last_info(logger, u'Metadata cache created.')
self.assertTrue(r._expired)
r._expired = False
# regular case 2: metadata is cached and will expire later than
# metadata_timer_sync:
r._metadata_expire_in = mock.Mock(return_value=(True, 100))
r._sync_strategy = dnf.repo.SYNC_TRY_CACHE
self.assertTrue(self._do_makecache(cmd))
self.assert_last_info(logger, u'Metadata cache created.')
self.assertFalse(r._expired)
# regular case 3: metadata is cached but will eqpire before
# metadata_timer_sync:
r._metadata_expire_in = mock.Mock(return_value=(True, 4))
r._sync_strategy = dnf.repo.SYNC_TRY_CACHE
self.assertTrue(self._do_makecache(cmd))
self.assert_last_info(logger, u'Metadata cache created.')
self.assertTrue(r._expired)
def git():
repo = ClassDouble('accountable.accountable.Repo')
git = InstanceDouble('accountable.accountable.Repo')
git.git = support.MockRepo()
allow_constructor(repo).and_return(git)
accountable.Repo = repo
