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