def test_reviving_baseurl_404(self, new_remote_m):
url = 'http://meh'
self.repo._md_expire_cache()
self.repo.baseurl = url
lr_exc = librepo.LibrepoException(
librepo.LRE_CURL, 'Error HTTP/FTP status code: 404', 'Curl error.')
exc = dnf.repo._DetailedLibrepoError(lr_exc, url)
new_remote_m()._perform = mock.Mock(side_effect=exc)
with mock.patch('dnf.repo.Repo._cachedir', REPOS + "/rpm"):
self.assertRaises(dnf.exceptions.RepoError, self.repo.load)
def test_reviving_404(self, new_remote_m):
url = 'http://meh'
self.repo.md_expire_cache()
self.repo.metalink = url
lr_exc = librepo.LibrepoException(librepo.LRE_CURL,
'Error HTTP/FTP status code: 404',
'Curl error.')
exc = dnf.repo._DetailedLibrepoError(lr_exc, url)
new_remote_m().perform = mock.Mock(side_effect=exc)
self.assertRaises(dnf.exceptions.RepoError, self.repo.load)
def test_update_saving_with_err(self):
progress = dnf.callback.NullDownloadProgress()
pkg = support.MockPackage("magical-4-4.noarch")
pkg.downloadsize = 8
pload = dnf.drpm.DeltaPayload(None, mock.Mock(downloadsize=5), pkg,
progress)
saving = (5, 10)
saving = dnf.repo.update_saving(saving, (pload, ), {pkg: 'failed'})
self.assertEqual(saving, (10, 10))
def setUp(self):
cli = mock.MagicMock()
self.cmd = repodiff.RepoDiffCommand(cli)
self.cmd.cli.base = dnf.cli.cli.BaseCli()
self.cmd.cli.base._sack = dnf.sack.Sack()
self.cmd.opts = mock.Mock()
self.cmd.opts.compare_arch = False
self.repodiff = self.cmd._repodiff(QueryStub(PACKAGES_OLD),
QueryStub(PACKAGES_NEW))
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 test_make_lists(self):
TSI = dnf.transaction.TransactionItem
goal = mock.Mock(get_reason=lambda x: SwdbReason.USER)
ts = dnf.transaction.Transaction()
ts.add_install('pepper-3', [])
ts.add_install('pepper-2', [])
lists = dnf.cli.output._make_lists(ts, goal)
self.assertEmpty(lists.erased)
self.assertEqual([tsi._active for tsi in lists.installed],
['pepper-2', 'pepper-3'])
def test_setup_from_dnf_conf(self, setup_m):
conf = mock.Mock(debuglevel=2,
errorlevel=3,
logdir=self.logdir,
log_size=self.log_size,
log_rotate=self.log_rotate)
self.logging._setup_from_dnf_conf(conf)
self.assertEqual(
setup_m.call_args,
mock.call(dnf.logging.INFO, dnf.logging.WARNING, self.logdir,
self.log_size, self.log_rotate))
conf = mock.Mock(debuglevel=6,
errorlevel=6,
logdir=self.logdir,
log_size=self.log_size,
log_rotate=self.log_rotate)
self.logging._setup_from_dnf_conf(conf)
self.assertEqual(
setup_m.call_args,
mock.call(dnf.logging.DEBUG, dnf.logging.WARNING, self.logdir,
self.log_size, self.log_rotate))
def test_wait_for_connection(self, mock_time, mock_hdb_connector):
mock_hdb_instance = mock.Mock()
mock_hdb_connector.return_value = mock_hdb_instance
mock_time.return_value = 0
hanamod.wait_for_connection('192.168.10.15', 30015, 'SYSTEM', 'pass')
mock_time.assert_called_once_with()
mock_hdb_instance.connect.assert_called_once_with('192.168.10.15',
30015,
user='******',
password='******')
mock_hdb_instance.disconnect.assert_called_once_with()
def test_propagated_reason(self):
yumdb = mock.Mock()
yumdb.get_package().get = lambda s: 'dep'
tsi = dnf.transaction.TransactionItem(dnf.transaction.INSTALL,
installed=self.newpkg,
reason='user')
self.assertEqual(tsi.propagated_reason(yumdb, []), 'user')
tsi = dnf.transaction.TransactionItem(dnf.transaction.UPGRADE,
installed=self.newpkg,
erased=self.oldpkg)
self.assertEqual(tsi.propagated_reason(yumdb, []), 'dep')
tsi = dnf.transaction.TransactionItem(dnf.transaction.DOWNGRADE,
installed=self.newpkg,
erased=self.oldpkg)
self.assertEqual(tsi.propagated_reason(yumdb, []), 'dep')
# test the call can survive if no reason is known:
yumdb = mock.Mock()
yumdb.get_package().get = lambda s: None
self.assertEqual(tsi.propagated_reason(yumdb, []), 'unknown')
def test_populate_rpm_ts(self):
ts = dnf.transaction.Transaction()
repo = dnf.repo.Repo('r', '/tmp')
inst = tests.support.MockPackage("ago-20.0-1.x86_64.fc69", repo)
upg = tests.support.MockPackage("billy-1.2-1.x86_64.fc69", repo)
old = tests.support.MockPackage("billy-1.1-1.x86_64.fc69", repo)
ts.add_install(inst, [])
ts.add_upgrade(upg, old, [])
rpm_ts = ts.populate_rpm_ts(mock.Mock())
rpm_ts.assert_has_calls([mock.call.addInstall(None, ts._tsis[0], 'i'),
mock.call.addInstall(None, ts._tsis[1], 'u')])
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.')
def test_update_saving(self):
progress = dnf.callback.NullDownloadProgress()
pkg = support.MockPackage("tour-4-4.noarch")
pkg.downloadsize = 5
pload1 = dnf.repo.RPMPayload(pkg, progress)
pkg = support.MockPackage("magical-4-4.noarch")
pkg.downloadsize = 8
pload2 = dnf.drpm.DeltaPayload(None, mock.Mock(downloadsize=5), pkg,
progress)
saving = (5, 10)
saving = dnf.repo._update_saving(saving, (pload1, pload2), {})
self.assertEqual(saving, (15, 23))
def test_fill_sack(self):
def raiser():
raise dnf.exceptions.RepoError()
r = tests.support.MockRepo('bag', self.base.conf)
r.enable()
self.base._repos.add(r)
r.load = mock.Mock(side_effect=raiser)
r.skip_if_unavailable = False
self.assertRaises(dnf.exceptions.RepoError,
self.base.fill_sack, load_system_repo=False)
self.assertTrue(r.enabled)
self.assertTrue(r._check_config_file_age)
def test_configure_repos_expired(self, _):
"""Ensure that --cacheonly beats the expired status."""
opts = Namespace()
opts.repos_ed = []
opts.cacheonly = True
pers = self.base._persistor
pers.get_expired_repos = mock.Mock(return_value=('one', ))
self.base._repos = dnf.repodict.RepoDict()
self.base._repos.add(support.MockRepo('one', None))
self.cli._configure_repos(opts)
self.assertEqual(self.base.repos['one'].sync_strategy,
dnf.repo.SYNC_ONLY_CACHE)
def setUp(self):
cli = mock.MagicMock()
self.cmd = download.DownloadCommand(cli)
self.cmd.cli.base = dnf.cli.cli.BaseCli()
self.cmd.cli.base.add_remote_rpms = mock.MagicMock()
self.cmd.cli.base.download_packages = mock.Mock()
# point the Sack and Subject to out stubs
# b/c these are used in the _get_query methods
self.orig_sack = self.cmd.cli.base.sack
self.cmd.cli.base._sack = SackStub()
self.orig_subject = dnf.subject.Subject
dnf.subject.Subject = SubjectStub
self.cmd.opts = mock.Mock()
self.cmd.opts.resolve = False
self.cmd.opts.arches = []
repo = dnf.repo.Repo(name='foo')
repo.baseurl = ["file:///dev/null"]
repo.enable()
self.cmd.base.repos.add(repo)
repo = dnf.repo.Repo(name='foo-source')
repo.baseurl = ["file:///dev/null"]
repo.disable()
self.cmd.base.repos.add(repo)
repo = dnf.repo.Repo(name='bar')
repo.baseurl = ["file:///dev/null"]
repo.enable()
self.cmd.base.repos.add(repo)
repo = dnf.repo.Repo(name='foobar-source')
repo.baseurl = ["file:///dev/null"]
repo.disable()
self.cmd.base.repos.add(repo)
repo = dnf.repo.Repo(name='foo-debuginfo')
repo.baseurl = ["file:///dev/null"]
repo.disable()
self.cmd.base.repos.add(repo)
def test_get_ensa_version(self, mock_netweaver):
'''
Test install method - raise
'''
mock_netweaver_instance = mock.Mock()
mock_netweaver_instance.get_ensa_version.return_value = 1
mock_netweaver.return_value = mock_netweaver_instance
with patch.object(netweavermod, '_init', mock_netweaver):
version = netweavermod.get_ensa_version('ascs', 'prd', '00',
'pass')
assert version == 1
mock_netweaver.assert_called_once_with('prd', '00', 'pass')
mock_netweaver_instance.get_ensa_version.assert_called_once_with(
'ascs')
def test_find_sap_folder_contain_units(self, mock_debug):
mock_pattern = mock.Mock(pattern='my_pattern')
mock_pattern.match.side_effect = [False, True]
with patch('salt.utils.files.fopen',
mock_open(read_data=['data\n', 'DATA_UNITS\n', 'data_2\n'
])) as mock_file:
folder = hanamod._find_sap_folder(['1234', '5678'], mock_pattern)
mock_pattern.match.assert_has_calls(
[mock.call('data'), mock.call('data_2')])
mock_debug.assert_has_calls([
mock.call('%s folder does not contain %s pattern', '1234',
'my_pattern')
])
assert folder in '1234/DATA_UNITS'
def test_ensa_version_grains_present(self):
'''
Test ensa_version_grains_present with correct execution
'''
ret = {
'name': 'ascs',
'changes': {
'ensa_version_prd_00': 1
},
'result': True,
'comment': 'ENSA version grain set'
}
mock_get_ensa_version = mock.Mock(return_value=1)
mock_grains_set = mock.Mock()
with patch.dict(
netweavermod.__salt__, {
'netweaver.get_ensa_version': mock_get_ensa_version,
'grains.set': mock_grains_set
}):
assert netweavermod.ensa_version_grains_present(
'ascs', 'prd', '00', 'pass') == ret
mock_grains_set.assert_called_once_with('ensa_version_prd_00', 1)
mock_grains_set.reset_mock()
with patch.dict(
netweavermod.__salt__, {
'netweaver.get_ensa_version': mock_get_ensa_version,
'grains.set': mock_grains_set
}):
assert netweavermod.ensa_version_grains_present(
'ascs', 'prd', 0, 'pass') == ret
mock_grains_set.assert_called_once_with('ensa_version_prd_00', 1)
def setUp(self):
"""Prepare the test fixture."""
super(RepoPkgsReinstallSubCommandTest, self).setUp()
self.mock = mock.Mock()
old_run_patcher = mock.patch(
'dnf.cli.commands.RepoPkgsCommand.ReinstallOldSubCommand.run_on_repo',
self.mock.reinstall_old_run)
move_run_patcher = mock.patch(
'dnf.cli.commands.RepoPkgsCommand.MoveToSubCommand.run_on_repo',
self.mock.move_to_run)
old_run_patcher.start()
self.addCleanup(old_run_patcher.stop)
move_run_patcher.start()
self.addCleanup(move_run_patcher.stop)
def test_add_repo_to_sack(self):
def raiser():
raise dnf.exceptions.RepoError()
base = support.MockBase()
r = support.MockRepo('bag', None)
r.enable()
base._repos.add(r)
r.load = mock.Mock(side_effect=raiser)
r.skip_if_unavailable = False
self.assertRaises(dnf.exceptions.RepoError, base._add_repo_to_sack,
"bag")
self.assertTrue(r.enabled)
r.skip_if_unavailable = True
base._add_repo_to_sack("bag")
self.assertFalse(r.enabled)
def test_configure_repos_expired(self, _):
"""Ensure that --cacheonly beats the expired status."""
opts = Namespace()
opts.repos_ed = []
opts.cacheonly = True
pers = self.base._persistor
pers.get_expired_repos = mock.Mock(return_value=('one', ))
self.base._repos = dnf.repodict.RepoDict()
self.base._repos.add(support.MockRepo('one', None))
self.cli._configure_repos(opts)
# _process_demands() should respect --cacheonly in spite of modified demands
self.cli.demands.fresh_metadata = False
self.cli._process_demands()
self.assertEqual(self.base.repos['one'].sync_strategy,
dnf.repo.SYNC_ONLY_CACHE)
def test_push_userinstalled(self):
base = support.MockBase()
# setup:
base.conf.clean_requirements_on_remove = True
goal = mock.Mock(spec=["userinstalled"])
for pkg in base.sack.query().installed():
base.yumdb.get_package(pkg).reason = 'dep'
pkg1 = base.sack.query().installed().filter(name="pepper")[0]
base.yumdb.get_package(pkg1).reason = "user"
pkg2 = base.sack.query().installed().filter(name="hole")[0]
base.yumdb.get_package(pkg2).reason = "unknown"
# test:
base.push_userinstalled(goal)
calls = [c[0][0].name for c in goal.userinstalled.call_args_list]
self.assertItemsEqual(calls, ('hole', 'pepper'))
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)
r.skip_if_unavailable = True
base.fill_sack(load_system_repo=False)
self.assertFalse(r.enabled)
def test_find_sap_folder_error(self, mock_fopen, mock_debug):
mock_pattern = mock.Mock(pattern='my_pattern')
mock_fopen.side_effect = [IOError, IOError, IOError, IOError]
with pytest.raises(hanamod.SapFolderNotFoundError) as err:
hanamod._find_sap_folder(['1234', '5678'], mock_pattern)
assert 'SAP folder with my_pattern pattern not found' in str(err.value)
mock_debug.assert_has_calls([
mock.call('%s file not found in %s. Skipping folder', 'LABEL.ASC',
'1234'),
mock.call('%s file not found in %s. Skipping folder',
'LABELIDX.ASC', '1234'),
mock.call('%s file not found in %s. Skipping folder', 'LABEL.ASC',
'5678'),
mock.call('%s file not found in %s. Skipping folder',
'LABELIDX.ASC', '5678')
])
def test_extract_pydbapi_error(self, mock_get_platform,
mock_find_sap_folders, mock_compile):
mock_get_platform.return_value = 'LINUX_X86_64'
compile_mocked = mock.Mock()
mock_compile.return_value = compile_mocked
mock_find_sap_folders.side_effect = hanamod.SapFolderNotFoundError
with pytest.raises(exceptions.CommandExecutionError) as err:
pydbapi_file = hanamod.extract_pydbapi(
'PYDBAPI.tar.gz', ['1234', '5678'],
'/tmp/output',
additional_extract_options='-l')
mock_compile.assert_called_once_with(
'^HDB_CLIENT:20.*:LINUX_X86_64:.*')
mock_find_sap_folders.assert_called_once_with(['1234', '5678'],
compile_mocked,
recursion_level=1)
assert 'HANA client not found' in str(err.value)
def test_find_sap_folder_contain_units_error(self, mock_debug):
mock_pattern = mock.Mock(pattern='my_pattern')
mock_pattern.match.side_effect = [False, False]
with patch(
'salt.utils.files.fopen',
mock_open(
read_data=['data\n', 'DATA_UNITS\n', 'data_2\n', IOError
])) as mock_file:
with pytest.raises(hanamod.SapFolderNotFoundError) as err:
hanamod._find_sap_folder(['1234'], mock_pattern)
mock_pattern.match.assert_has_calls(
[mock.call('data'), mock.call('data_2')])
mock_debug.assert_has_calls([
mock.call('%s folder does not contain %s pattern', '1234',
'my_pattern')
])
assert 'SAP folder with my_pattern pattern not found' in str(err.value)
def setUp(self):
"""Prepare the test fixture."""
super(RepoPkgsReinstallSubCommandTest, self).setUp()
base = support.BaseCliStub('main')
self.cmd = dnf.cli.commands.RepoPkgsCommand.ReinstallSubCommand(
base.mock_cli())
self.mock = mock.Mock()
old_run_patcher = mock.patch(
'dnf.cli.commands.RepoPkgsCommand.ReinstallOldSubCommand.run',
self.mock.reinstall_old_run)
move_run_patcher = mock.patch(
'dnf.cli.commands.RepoPkgsCommand.MoveToSubCommand.run',
self.mock.move_to_run)
old_run_patcher.start()
self.addCleanup(old_run_patcher.stop)
move_run_patcher.start()
self.addCleanup(move_run_patcher.stop)
def test_upgrade_reponame(self):
"""Test whether only packages in selected repo are upgraded."""
base = support.MockBase('updates', 'broken_deps')
base.logger = mock.Mock()
base.upgrade('*e*', 'broken_deps')
installed, removed = self.installed_removed(base)
# Sack contains two upgrades with the same version. Because of that
# test whether the installed package is one of those packages.
self.assertLength(installed, 1)
self.assertIn(dnf.util.first(installed),
base.sack.query().upgrades().filter(name='pepper'))
self.assertCountEqual(
removed,
base.sack.query().installed().filter(name='pepper'))
assert dnf.subject.Subject('*e*').get_best_query(base.sack).upgrades().filter(name__neq='pepper', reponame__neq='broken_deps'), \
('in another repo, there must be another update matching the '
'pattern, otherwise the test makes no sense')
def test_fill_sack(self):
def raiser():
raise dnf.exceptions.RepoError()
base = support.MockBase()
base.conf.installroot = "/tmp/dnf-test-fill-sack"
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 test_ensa_version_grains_present_error(self):
'''
Test ensa_version_grains_present with the error
'''
ret = {
'name': 'ascs',
'changes': {},
'result': False,
'comment': 'err'
}
mock_get_ensa_version = mock.Mock(
side_effect=exceptions.CommandExecutionError('err'))
with patch.dict(netweavermod.__salt__,
{'netweaver.get_ensa_version': mock_get_ensa_version}):
assert netweavermod.ensa_version_grains_present(
'ascs', 'prd', 00, 'pass') == ret
