def test_get_environment_id_multi_available_bad_name(self, mock_sys_exit):
def env_list(*args, **kwargs):
return [{
"id": "1234",
"name": "somename"
}, {
"id": "5678",
"name": "othername"
}]
# Avoid writing to stderr
mock_sys_exit.side_effect = SystemExit(-1)
StubUEP.getEnvironmentList = env_list
cp = StubUEP()
cp.supports_resource = Mock(return_value=True)
rc = RegisterCommand()
rc.options = Mock()
rc.options.activation_keys = None
rc._prompt_for_environment = Mock(return_value="not_an_env")
try:
rc._get_environment_id(cp, 'owner', None)
self.fail("No Exception Raised")
except SystemExit:
pass
def test_consumerid_with_distributor_id(self):
def get_consumer(self, *args, **kwargs):
pass
with patch('rhsm.connection.UEPConnection',
new_callable=StubUEP) as mock_uep:
mock_uep.getConsumer = get_consumer
self.stub_cp_provider.basic_auth_cp = mock_uep
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
mock_uep.getConsumer = Mock(
return_value={
'uuid': '123123',
'type': {
'manifest': True
},
'idCert': {
'key': ''
}
})
self._inject_ipm()
with nested(Capture(silent=True),
self.assertRaises(SystemExit)) as e:
cmd.main([
'register', '--consumerid=TaylorSwift',
'--username=testuser1', '--password=password',
'--org=test_org'
])
self.assertEquals(e.code, os.EX_USAGE)
def test_consumerid_with_distributor_id(self):
def get_consumer(self, *args, **kwargs):
pass
StubUEP.getConsumer = get_consumer
connection.UEPConnection = StubUEP
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
connection.UEPConnection.getConsumer = Mock(return_value={
'uuid': '123123',
'type': {
'manifest': True
}
})
self._inject_ipm()
sys.stderr = MockStderr()
try:
cmd.main([
'register', '--consumerid=TaylorSwift', '--username=testuser1',
'--password=password', '--org=test_org'
])
self.fail("No Exception Raised")
except SystemExit, e:
self.assertEquals(e.code, os.EX_USAGE)
def test_consumerid_updates_certs_and_repos(self, mock_entcertlib):
def get_consumer(self, *args, **kwargs):
pass
with patch('rhsm.connection.UEPConnection',
new_callable=StubUEP) as mock_uep:
mock_uep.getConsumer = get_consumer
self.stub_cp_provider.basic_auth_cp = mock_uep
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
cmd._persist_identity_cert = self.stub_persist
mock_entcertlib_instance = mock_entcertlib.return_value
mock_uep.getConsumer = Mock(return_value={
'uuid': '123123',
'type': {
'manifest': False
}
})
self._inject_ipm()
cmd.main([
'register', '--consumerid=123456', '--username=testuser1',
'--password=password', '--org=test_org'
])
self.assertTrue(mock_entcertlib_instance.update.called)
def test_registration_with_failed_profile_upload(self):
with patch('rhsm.connection.UEPConnection',
new_callable=StubUEP) as mock_uep:
profile_mgr = inj.require(inj.PROFILE_MANAGER)
def raise_remote_server_exception(*args, **kwargs):
"""Raise remote server exception (uploading of profile failed)"""
from rhsm.connection import RemoteServerException
raise RemoteServerException(
502,
request_type="PUT",
handler=
"/subscription/consumers/xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/profiles"
)
profile_mgr.update_check = Mock(
side_effect=raise_remote_server_exception)
self.stub_cp_provider.basic_auth_cp = mock_uep
cmd = RegisterCommand()
with Capture() as cap:
cmd.main([
'register', '--force', '--username', 'admin', '--password',
'admin', '--org', 'admin'
])
output = cap.out
self.assertTrue(
"The system has been registered with ID" in output)
self.assertTrue("The registered system name is:" in output)
def _assert_no_insights_is(self,
expected_no_insights,
extra_cli_args=None):
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
self._inject_ipm()
owner_key = 'test_org'
with Capture(silent=True):
cli_args_list = [
'register', '--username=testuser1', '--password=password',
'--org=%s' % owner_key
]
if extra_cli_args is not None:
cli_args_list.extend(extra_cli_args)
cmd.main(cli_args_list)
self.mock_register.register.assert_called_once_with(
owner_key,
activation_keys=ANY,
environment=ANY,
force=ANY,
name=ANY,
type=ANY,
service_level=ANY,
no_insights=expected_no_insights)
def test_consumerid_updates_certs_and_repos(self, mock_entcertlib):
def get_consumer(self, *args, **kwargs):
pass
StubUEP.getConsumer = get_consumer
connection.UEPConnection = StubUEP
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
cmd._persist_identity_cert = self.stub_persist
mock_entcertlib_instance = mock_entcertlib.return_value
connection.UEPConnection.getConsumer = Mock(return_value={
'uuid': '123123',
'type': {
'manifest': False
}
})
self._inject_ipm()
cmd.main([
'register', '--consumerid=123456', '--username=testuser1',
'--password=password', '--org=test_org'
])
#self.assertTrue(mock_ipm.write_cache.call_count > 0)
self.assertTrue(mock_entcertlib_instance.update.called)
def test_installed_products_cache_written(self):
connection.UEPConnection = StubUEP
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
cmd._persist_identity_cert = self.stub_persist
self._inject_ipm()
cmd.main(['register', '--username=testuser1', '--password=password'])
def test_installed_products_cache_written(self):
with patch('rhsm.connection.UEPConnection',
new_callable=StubUEP) as mock_uep:
self.stub_cp_provider.basic_auth_cp = mock_uep
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
cmd._persist_identity_cert = self.stub_persist
self._inject_ipm()
cmd.main(
['register', '--username=testuser1', '--password=password'])
def test_registration(self):
"""
Test normal registration (test of proper patching)
"""
with patch('rhsm.connection.UEPConnection',
new_callable=StubUEP) as mock_uep:
self.stub_cp_provider.basic_auth_cp = mock_uep
cmd = RegisterCommand()
cmd.main([
'register', '--force', '--username', 'admin', '--password',
'admin', '--org', 'admin'
])
def test_deprecate_consumer_type(self):
with patch('rhsm.connection.UEPConnection',
new_callable=StubUEP) as mock_uep:
self.stub_cp_provider.basic_auth_cp = mock_uep
cmd = RegisterCommand()
self._inject_mock_invalid_consumer()
with Capture(silent=True):
with self.assertRaises(SystemExit) as e:
cmd.main(['register', '--type=candlepin'])
self.assertEqual(e.code, os.EX_USAGE)
def test_activation_keys_updates_certs_and_repos(self, mock_entcertlib):
self.stub_cp_provider.basic_auth_cp = Mock(
'rhsm.connection.UEPConnection', new_callable=StubUEP)
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
mock_entcertlib = mock_entcertlib.return_value
self._inject_ipm()
cmd.main(['register', '--activationkey=test_key', '--org=test_org'])
self.mock_register.register.assert_called_once()
mock_entcertlib.update.assert_called_once()
def test_register_persists_consumer_cert(self):
with patch('rhsm.connection.UEPConnection',
new_callable=StubUEP) as mock_uep:
self.stub_cp_provider.basic_auth_cp = mock_uep
cmd = RegisterCommand()
self._inject_mock_invalid_consumer()
cmd._persist_identity_cert = self.stub_persist
cmd.main(
['register', '--username=testuser1', '--password=password'])
self.assertEqual('dummy-consumer-uuid',
self.persisted_consumer["uuid"])
def test_register_persists_consumer_cert(self):
connection.UEPConnection = StubUEP
# When
cmd = RegisterCommand()
self._inject_mock_invalid_consumer()
cmd._persist_identity_cert = self.stub_persist
cmd.main(['register', '--username=testuser1', '--password=password'])
# Then
self.assertEqual('dummy-consumer-uuid', self.persisted_consumer["uuid"])
def test_installed_products_cache_written(self, mock_exists, mock_ipm_wc):
connection.UEPConnection = StubUEP
cmd = RegisterCommand()
cmd._persist_identity_cert = self.stub_persist
mock_exists.return_value = False
# Mock out facts and installed products:
cmd.facts.get_facts = Mock(return_value={'fact1': 'val1', 'fact2': 'val2'})
cmd.facts.write_cache = Mock()
cmd.main(['register', '--username=testuser1', '--password=password'])
self.assertTrue(mock_ipm_wc.call_count > 0)
def test_activation_keys_updates_certs_and_repos(self, mock_entcertlib):
with patch('rhsm.connection.UEPConnection',
new_callable=StubUEP) as mock_uep:
self.stub_cp_provider.basic_auth_cp = mock_uep
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
cmd._persist_identity_cert = self.stub_persist
mock_entcertlib_instance = mock_entcertlib.return_value
self._inject_ipm()
cmd.main(
['register', '--activationkey=test_key', '--org=test_org'])
self.assertTrue(mock_entcertlib_instance.update.called)
def test_activation_keys_updates_certs_and_repos(self, mock_entcertlib):
connection.UEPConnection = StubUEP
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
cmd._persist_identity_cert = self.stub_persist
mock_entcertlib_instance = mock_entcertlib.return_value
self._inject_ipm()
cmd.main(['register', '--activationkey=test_key', '--org=test_org'])
# self.assertTrue(mock_ipm_wc.call_count > 0)
self.assertTrue(mock_entcertlib_instance.update.called)
def test_register_persists_consumer_cert(self, mock_exists, mock_ipm_wc):
connection.UEPConnection = StubUEP
# When
cmd = RegisterCommand()
mock_exists.return_value = False
cmd._persist_identity_cert = self.stub_persist
cmd.facts.get_facts = Mock(return_value={'fact1': 'val1', 'fact2': 'val2'})
cmd.facts.write_cache = Mock()
cmd.main(['register', '--username=testuser1', '--password=password'])
# Then
self.assertEqual('dummy-consumer-uuid', self.persisted_consumer["uuid"])
def test_get_environment_id_one_available(self):
def env_list(*args, **kwargs):
return [{"id": "1234", "name": "somename"}]
StubUEP.getEnvironmentList = env_list
cp = StubUEP()
cp.supports_resource = Mock(return_value=True)
rc = RegisterCommand()
rc.options = Mock()
rc.options.activation_keys = None
env_id = rc._get_environment_id(cp, 'owner', None)
expected = "1234"
self.assertEquals(expected, env_id)
def test_consumerid_updates_certs_and_repos(self, mock_entcertlib):
self.stub_cp_provider.basic_auth_cp = Mock(
'rhsm.connection.UEPConnection', new_callable=StubUEP)
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
mock_entcertlib = mock_entcertlib.return_value
self._inject_ipm()
cmd.main([
'register', '--consumerid=123456', '--username=testuser1',
'--password=password', '--org=test_org'
])
self.mock_register.register.assert_called_once_with(
None, consumerid='123456')
mock_entcertlib.update.assert_called_once()
def test_get_environment_id_one_available(self):
def env_list(*args, **kwargs):
return [{"id": "1234", "name": "somename"}]
with patch('rhsm.connection.UEPConnection',
new_callable=StubUEP) as mock_uep:
mock_uep.getEnvironmentList = env_list
mock_uep.supports_resource = Mock(return_value=True)
self.stub_cp_provider.basic_auth_cp = mock_uep
rc = RegisterCommand()
rc.options = Mock()
rc.options.activation_keys = None
env_id = rc._get_environment_id(mock_uep, 'owner', None)
expected = "1234"
self.assertEqual(expected, env_id)
def test_consumerid_with_distributor_id(self):
self.stub_cp_provider.basic_auth_cp = Mock(
'rhsm.connection.UEPConnection', new_callable=StubUEP)
self._inject_mock_invalid_consumer()
cmd = RegisterCommand()
self._inject_ipm()
self.mock_register.register.side_effect = exceptions.ServiceError()
with Capture(silent=True):
with self.assertRaises(SystemExit) as e:
cmd.main([
'register', '--consumerid=TaylorSwift',
'--username=testuser1', '--password=password',
'--org=test_org'
])
self.assertEqual(e.code, os.EX_USAGE)
def test_installed_products_cache_written(self):
connection.UEPConnection = StubUEP
cmd = RegisterCommand(ent_dir=StubEntitlementDirectory([]),
prod_dir=StubProductDirectory([]))
cmd._persist_identity_cert = self.stub_persist
ConsumerIdentity.exists = classmethod(lambda cls: False)
# Mock out facts and installed products:
cmd.facts.get_facts = Mock(return_value={
'fact1': 'val1',
'fact2': 'val2'
})
cmd.facts.write_cache = Mock()
cmd.installed_mgr.write_cache = Mock()
cmd.main(['register', '--username=testuser1', '--password=password'])
self.assertEquals(1, cmd.installed_mgr.write_cache.call_count)
def test_register_persists_consumer_cert(self):
connection.UEPConnection = StubUEP
# When
cmd = RegisterCommand(ent_dir=StubEntitlementDirectory([]),
prod_dir=StubProductDirectory([]))
ConsumerIdentity.exists = classmethod(lambda cls: False)
cmd._persist_identity_cert = self.stub_persist
cmd.facts.get_facts = Mock(return_value={
'fact1': 'val1',
'fact2': 'val2'
})
cmd.facts.write_cache = Mock()
cmd.installed_mgr.write_cache = Mock()
cmd.main(['register', '--username=testuser1', '--password=password'])
# Then
self.assertEqual('dummy-consumer-uuid',
self.persisted_consumer["uuid"])
def test_get_environment_id_multi_available_bad_name(self):
def env_list(*args, **kwargs):
return [{
"id": "1234",
"name": "somename"
}, {
"id": "5678",
"name": "othername"
}]
with patch('rhsm.connection.UEPConnection',
new_callable=StubUEP) as mock_uep:
mock_uep.getEnvironmentList = env_list
mock_uep.supports_resource = Mock(return_value=True)
self.stub_cp_provider.basic_auth_cp = mock_uep
rc = RegisterCommand()
rc.options = Mock()
rc.options.activation_keys = None
rc._prompt_for_environment = Mock(return_value="not_an_env")
with nested(Capture(silent=True), self.assertRaises(SystemExit)):
rc._get_environment_id(mock_uep, 'owner', None)
