def test_update_when_repo_modified_on_mutable(self, mock_file): self._inject_mock_invalid_consumer() mock_file = mock_file.return_value modified_repo = Repo('x', [('gpgcheck', 'unoriginal'), ('gpgkey', 'some_key')]) server_repo = Repo('x', [('gpgcheck', 'original')]) mock_file.section = MagicMock(side_effect=[modified_repo, server_repo]) def stub_content(): return [ Repo('x', [('gpgcheck', 'new'), ('gpgkey', 'new_key'), ('name', 'test')]) ] update_action = RepoUpdateActionCommand() update_action.get_unique_content = stub_content current = update_action.perform() # confirming that the assessed value does not change when repo file # is different from the server value file. self.assertEqual('unoriginal', current.repo_updates[0]['gpgcheck']) # this is the ending server value file written_repo = mock_file.update.call_args[0][0] self.assertEqual('new', written_repo['gpgcheck']) self.assertEqual(None, written_repo['gpgkey'])
def test_set_repo_status_enable_all_disable_all(self, mock_repolib): repolib_instance = mock_repolib.return_value self._inject_mock_valid_consumer('fake_id') repos = [Repo('zoo'), Repo('zebra'), Repo('zip')] items = [('1', '*'), ('0', '*')] self.cc.use_overrides = True self.cc._set_repo_status(repos, repolib_instance, items) expected_overrides = [{ 'contentLabel': 'zebra', 'name': 'enabled', 'value': '0' }, { 'contentLabel': 'zoo', 'name': 'enabled', 'value': '0' }, { 'contentLabel': 'zip', 'name': 'enabled', 'value': '0' }] match_dict_list = Matcher(self.assert_items_equals, expected_overrides) self.cc.cp.setContentOverrides.assert_called_once_with( 'fake_id', match_dict_list) repolib_instance.update.assert_called()
def test_set_immutable_property_now_empty(self): self._inject_mock_invalid_consumer() update_action = RepoUpdateActionCommand() existing_repo = Repo('testrepo') existing_repo['proxy_username'] = "******" incoming_repo = {} update_action.update_repo(existing_repo, incoming_repo) self.assertFalse("proxy_username" in existing_repo.keys())
def test_set_immutable_property_now_empty(self): self._inject_mock_invalid_consumer() update_action = RepoUpdateActionCommand() existing_repo = Repo('testrepo') existing_repo['proxy_username'] = "******" incoming_repo = {} update_action.update_repo(existing_repo, incoming_repo) self.assertFalse("proxy_username" in list(existing_repo.keys()))
def test_set_immutable_property_now_not_in_cert(self): existing_repo = Repo('testrepo') existing_repo['proxy_username'] = "******" incoming_repo = {} existing_repo.update(incoming_repo) # Immutable properties should be always be added/updated, # and removed if undefined in the new repo definition. self.assertFalse("proxy_username" in existing_repo.keys())
def test_set_mutable_property_now_empty_value(self): existing_repo = Repo('testrepo') existing_repo['metadata_expire'] = "blah" incoming_repo = {'metadata_expire': ''} existing_repo.update(incoming_repo) # re comments in repolib # Mutable properties should be added if not currently defined, # otherwise left alone. self.assertTrue("metadata_expire" in existing_repo.keys())
def test_set_immutable_property_now_not_in_cert(self): self._inject_mock_invalid_consumer() update_action = RepoUpdateActionCommand() existing_repo = Repo('testrepo') existing_repo['proxy_username'] = "******" incoming_repo = {} update_action.update_repo(existing_repo, incoming_repo) # Immutable properties should be always be added/updated, # and removed if undefined in the new repo definition. self.assertFalse("proxy_username" in existing_repo.keys())
def test_set_immutable_property_now_not_in_cert(self): self._inject_mock_invalid_consumer() update_action = RepoUpdateActionCommand() existing_repo = Repo('testrepo') existing_repo['proxy_username'] = "******" incoming_repo = {} update_action.update_repo(existing_repo, incoming_repo) # Immutable properties should be always be added/updated, # and removed if undefined in the new repo definition. self.assertFalse("proxy_username" in list(existing_repo.keys()))
def test_mutable_property_is_server(self): update_action = RepoUpdateActionCommand() self._inject_mock_invalid_consumer() existing_repo = Repo('testrepo') server_val_repo = Repo('servertestrepo') existing_repo['metadata_expire'] = 1000 server_val_repo['metadata_expire'] = 1000 incoming_repo = {'metadata_expire': 2000} update_action.update_repo(existing_repo, incoming_repo, server_val_repo) self.assertEqual(2000, existing_repo['metadata_expire'])
def test_set_mutable_property_now_not_in_cert(self): self._inject_mock_invalid_consumer() update_action = RepoUpdateActionCommand() existing_repo = Repo('testrepo') existing_repo['metadata_expire'] = "blah" incoming_repo = {} update_action.update_repo(existing_repo, incoming_repo) # re comments in repolib # Mutable properties should be added if not currently defined, # otherwise left alone. self.assertTrue("metadata_expire" in existing_repo.keys())
def test_set_mutable_property_now_not_in_cert(self): self._inject_mock_invalid_consumer() update_action = RepoUpdateActionCommand() existing_repo = Repo('testrepo') existing_repo['metadata_expire'] = "blah" incoming_repo = {} update_action.update_repo(existing_repo, incoming_repo) # re comments in repolib # Mutable properties should be added if not currently defined, # otherwise left alone. self.assertTrue("metadata_expire" in list(existing_repo.keys()))
def test_overrides_trump_existing(self): update_action = RepoUpdateActionCommand() update_action.overrides = {'x': {'gpgcheck': 'blah'}} values = [('gpgcheck', 'original'), ('gpgkey', 'some_key')] old_repo = Repo('x', values) new_repo = Repo(old_repo.id, values) update_action._set_override_info(new_repo) self.assertEquals('original', old_repo['gpgcheck']) update_action.update_repo(old_repo, new_repo) self.assertEquals('blah', old_repo['gpgcheck']) self.assertEquals('some_key', old_repo['gpgkey'])
def test_list_with_enabled_and_disabled(self, mock_invoker): self.cc.main(["--list", "--list-disabled", "--list-disabled"]) self.cc._validate_options() repos = [Repo("x", [("enabled", "1")]), Repo("y", [("enabled", "0")]), Repo("z", [("enabled", "0")])] mock_invoker.return_value.get_repos.return_value = repos with Capture() as cap: self.cc._do_command() result = self.check_output_for_repos(cap.out, repos) self.assertEqual((True, True, True), result)
def test_overrides_removed_and_edited(self): update_action = RepoUpdateActionCommand() update_action.written_overrides.overrides = {'x': {'gpgcheck': 'override_value'}} update_action.overrides = {} old_repo = Repo('x', [('gpgcheck', 'hand_edit'), ('gpgkey', 'some_key')]) new_repo = Repo(old_repo.id, [('gpgcheck', 'original'), ('gpgkey', 'some_key')]) update_action._set_override_info(new_repo) # The value from the current repo file (with the old hand edit) should exist pre-update self.assertEquals('hand_edit', old_repo['gpgcheck']) update_action.update_repo(old_repo, new_repo) # Because the current value doesn't match the override, we don't modify it self.assertEquals('hand_edit', old_repo['gpgcheck']) self.assertEquals('some_key', old_repo['gpgkey'])
def test_non_default_overrides_added_to_existing(self): ''' Test that overrides for values that aren't found in Repo.PROPERTIES are written to existing repos ''' update_action = RepoUpdateActionCommand() update_action.written_overrides.overrides = {} update_action.overrides = {'x': {'somekey': 'someval'}} old_repo = Repo('x', []) new_repo = Repo(old_repo.id, []) update_action._set_override_info(new_repo) update_action.update_repo(old_repo, new_repo) self.assertEquals('someval', old_repo['somekey'])
def test_non_default_override_removed_deleted(self): ''' Test that overrides for values that aren't found in Repo.PROPERTIES are removed from redhat.repo once the override is removed ''' update_action = RepoUpdateActionCommand() update_action.written_overrides.overrides = {'x': {'somekey': 'someval'}} update_action.overrides = {} old_repo = Repo('x', [('somekey', 'someval')]) new_repo = Repo(old_repo.id, []) update_action._set_override_info(new_repo) update_action.update_repo(old_repo, new_repo) self.assertFalse('somekey' in old_repo)
def test_overrides_removed_revert_to_default(self): update_action = RepoUpdateActionCommand() update_action.written_overrides.overrides = {'x': {'gpgcheck': 'blah'}} update_action.overrides = {} old_repo = Repo('x', [('gpgcheck', 'blah'), ('gpgkey', 'some_key')]) new_repo = Repo(old_repo.id, [('gpgcheck', 'original'), ('gpgkey', 'some_key')]) update_action._set_override_info(new_repo) # The value from the current repo file (with the old override) should exist pre-update self.assertEquals('blah', old_repo['gpgcheck']) update_action.update_repo(old_repo, new_repo) # Because the override has been removed, the value is reset to the default self.assertEquals('original', old_repo['gpgcheck']) self.assertEquals('some_key', old_repo['gpgkey'])
def test_enable_repo_wildcard(self): repo_settings = { "enabled": "0", } self.invoker.return_value.get_repos.return_value = [ Repo("hello", list(repo_settings.copy().items())), Repo("helium", list(repo_settings.copy().items())), ] self.repo_file.items.return_value = list(repo_settings.copy().items()) result = api.enable_yum_repositories("he*") self.repo_file.return_value.write.assert_called_with() self.assertEqual(2, result)
def test_set_repo_status_with_wildcards(self, mock_repolib): repolib_instance = mock_repolib.return_value self._inject_mock_valid_consumer('fake_id') repos = [Repo('zoo'), Repo('zebra'), Repo('zip')] items = [('0', 'z*')] self.cc.use_overrides = True self.cc._set_repo_status(repos, repolib_instance, items) expected_overrides = [{'contentLabel': i.id, 'name': 'enabled', 'value': '0'} for i in repos] metadata_overrides = [{'contentLabel': i.id, 'name': 'enabled_metadata', 'value': '0'} for i in repos] expected_overrides.extend(metadata_overrides) match_dict_list = Matcher(self.assert_items_equals, expected_overrides) self.cc.cp.setContentOverrides.assert_called_once_with('fake_id', match_dict_list) self.assertTrue(repolib_instance.update.called)
def test_enable_repo_wildcard(self): repo_settings = { 'enabled': '0', } self.invoker.get_repos.return_value = [ Repo('hello', repo_settings.copy().items()), Repo('helium', repo_settings.copy().items()), ] self.repo_file.items.return_value = repo_settings.copy().items() result = api.enable_yum_repositories('he*') self.assertTrue(call.write() in self.repo_file.mock_calls) self.assertEquals(2, result)
def test_update_overrides_cache(self, mock_set, mock_supports): mock_supports.return_value = True repo_settings = { 'enabled': '0', } self.invoker.get_repos.return_value = [ Repo('hello', repo_settings.items()), ] self.repo_file.items.return_value = repo_settings.items() @api.request_injection def munge_injection(): self._inject_mock_valid_consumer("123") return api.enable_yum_repositories('hello') result = munge_injection() expected_overrides = [{ 'contentLabel': 'hello', 'name': 'enabled', 'value': '1', }] self.assertTrue(call("123", expected_overrides) in mock_set.mock_calls) self.assertTrue(call.update() in self.invoker.mock_calls) self.assertEquals(1, result)
def test_unset_immutable_property(self): self._inject_mock_invalid_consumer() update_action = RepoUpdateActionCommand() existing_repo = Repo('testrepo') incoming_repo = {'name': "woof"} update_action.update_repo(existing_repo, incoming_repo) self.assertEqual("woof", existing_repo['name'])
def test_unset_mutable_property(self): self._inject_mock_invalid_consumer() update_action = RepoUpdateActionCommand() existing_repo = Repo('testrepo') incoming_repo = {'metadata_expire': 2000} update_action.update_repo(existing_repo, incoming_repo) self.assertEqual(2000, existing_repo['metadata_expire'])
def test_update_overrides_cache(self): with patch("rhsm.connection.UEPConnection") as mock_uep: self.stub_cp_provider.consumer_auth_cp = mock_uep mock_uep.supports_resource = Mock(return_value=True) mock_uep.setContentOverrides = Mock() repo_settings = { "enabled": "0", } self.invoker.return_value.get_repos.return_value = [ Repo("hello", list(repo_settings.items())), ] self.repo_file.items.return_value = list(repo_settings.items()) self._inject_mock_valid_consumer("123") # The API methods try to bootstrap injection themselves so we want # to avoid that here. with patch("subscription_manager.api.injected") as injected: injected.return_value = True result = api.enable_yum_repositories("hello") expected_overrides = [{ "contentLabel": "hello", "name": "enabled", "value": "1", }] self.assertTrue( call("123", expected_overrides) in mock_uep.setContentOverrides.mock_calls) self.invoker.return_value.update.assert_called_with() self.assertEqual(1, result)
def test_overrides_trump_ent_cert(self): update_action = RepoUpdateActionCommand() update_action.overrides = {'x': {'gpgcheck': 'blah'}} r = Repo('x', [('gpgcheck', 'original'), ('gpgkey', 'some_key')]) self.assertEquals('original', r['gpgcheck']) update_action._set_override_info(r) self.assertEquals('blah', r['gpgcheck']) self.assertEquals('some_key', r['gpgkey'])
def test_gpgcheck_is_mutable(self): update_action = RepoUpdateActionCommand() self._inject_mock_invalid_consumer() existing_repo = Repo('testrepo') existing_repo['gpgcheck'] = "0" incoming_repo = {'gpgcheck': "1"} update_action.update_repo(existing_repo, incoming_repo) self.assertEqual("0", existing_repo['gpgcheck'])
def test_mutable_property_in_repo_but_not_in_cert(self): self._inject_mock_invalid_consumer() update_action = RepoUpdateActionCommand() existing_repo = Repo('testrepo') existing_repo['metadata_expire'] = 1000 incoming_repo = {} update_action.update_repo(existing_repo, incoming_repo) self.assertEqual(1000, existing_repo['metadata_expire'])
def test_repo_update_forbidden_when_registered(self): existing_repo = Repo('testrepo') existing_repo['proxy_username'] = "******" incoming_repo = {'proxy_username': '******'} update_action = RepoUpdateActionCommand() update_action.override_supported = True self.assertRaises(UnsupportedOperationException, update_action.update_repo, existing_repo, incoming_repo)
def test_set_repo_status_when_disconnected(self, mock_repofile): self._inject_mock_invalid_consumer() mock_repofile_inst = mock_repofile.return_value enabled = list({'enabled': '1'}.items()) disabled = list({'enabled': '0'}.items()) zoo = Repo('zoo', enabled) zebra = Repo('zebra', disabled) zippy = Repo('zippy', enabled) zero = Repo('zero', disabled) repos = [zoo, zebra, zippy, zero] items = [('0', 'z*')] self.cc._set_repo_status(repos, None, items) calls = [call(r) for r in repos if r['enabled'] == 1] mock_repofile_inst.update.assert_has_calls(calls) for r in repos: self.assertEqual('0', r['enabled']) mock_repofile_inst.write.assert_called_once_with()
def test_does_not_enable_nonmatching_repos(self): repo_settings = { 'enabled': '0', } self.invoker.get_repos.return_value = [ Repo('x', repo_settings.items()), ] self.repo_file.items.return_value = repo_settings.items() result = api.enable_yum_repositories('hello') self.assertFalse(call.write() in self.repo_file.mock_calls) self.assertEquals(0, result)
def test_disable_repo(self): repo_settings = { 'enabled': '1', } self.invoker.get_repos.return_value = [ Repo('hello', repo_settings.items()), ] self.repo_file.items.return_value = repo_settings.items() result = api.disable_yum_repositories('hello') self.assertTrue(call.write() in self.repo_file.mock_calls) self.assertEquals(1, result)
def test_does_not_enable_nonmatching_repos(self): repo_settings = { "enabled": "0", } self.invoker.return_value.get_repos.return_value = [ Repo("x", list(repo_settings.items())), ] self.repo_file.items.return_value = list(repo_settings.items()) result = api.enable_yum_repositories("hello") self.assertEqual(0, len(self.repo_file.return_value.write.mock_calls)) self.assertEqual(0, result)
def test_disable_repo(self): repo_settings = { "enabled": "1", } self.invoker.return_value.get_repos.return_value = [ Repo("hello", list(repo_settings.items())), ] self.repo_file.items.return_value = list(repo_settings.items()) result = api.disable_yum_repositories("hello") self.repo_file.return_value.write.assert_called_with() self.assertEqual(1, result)
def test_set_immutable_property_now_empty(self): existing_repo = Repo('testrepo') existing_repo['proxy_username'] = "******" incoming_repo = {} existing_repo.update(incoming_repo) self.assertFalse("proxy_username" in existing_repo.keys())
def test_unset_immutable_property(self): existing_repo = Repo('testrepo') incoming_repo = {'name': "woof"} existing_repo.update(incoming_repo) self.assertEqual("woof", existing_repo['name'])
def test_gpgcheck_is_mutable(self): existing_repo = Repo('testrepo') existing_repo['gpgcheck'] = "0" incoming_repo = {'gpgcheck': "1"} existing_repo.update(incoming_repo) self.assertEqual("0", existing_repo['gpgcheck'])
def test_empty_strings_not_set_in_file(self): r = Repo("testrepo", (("proxy", ""),)) r["proxy"] = "" self.assertFalse(("proxy", "") in r.items())
def test_unknown_property_is_preserved(self): existing_repo = Repo('testrepo') existing_repo['fake_prop'] = 'fake' self.assertTrue(('fake_prop', 'fake') in list(existing_repo.items()))
def test_empty_strings_not_set_in_file(self): r = Repo('testrepo', (('proxy', ""),)) r['proxy'] = "" self.assertFalse(("proxy", "") in list(r.items()))
def test_existing_order_is_preserved(self): config = (('key 1', 'value 1'), ('key b', 'value b'), ('key 3', 'value 3')) repo = Repo('testrepo', config) self.assertEqual(config, tuple(repo.items())[:3])
def test_unset_mutable_property(self): existing_repo = Repo('testrepo') incoming_repo = {'metadata_expire': 2000} existing_repo.update(incoming_repo) self.assertEqual(2000, existing_repo['metadata_expire'])
def test_unknown_property_is_preserved(self): existing_repo = Repo("testrepo") existing_repo["fake_prop"] = "fake" self.assertTrue(("fake_prop", "fake") in existing_repo.items())
def test_existing_order_is_preserved(self): config = (("key 1", "value 1"), ("key b", "value b"), ("key 3", "value 3")) repo = Repo("testrepo", config) self.assertEquals(config, repo.items()[:3])
def test_mutable_property_in_repo_but_not_in_cert(self): existing_repo = Repo('testrepo') existing_repo['metadata_expire'] = 1000 incoming_repo = {} existing_repo.update(incoming_repo) self.assertEqual(1000, existing_repo['metadata_expire'])