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 _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_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_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 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_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_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):
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_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_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_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_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_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_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_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):
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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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)
