def register_password_missing_test(self, get_proxy, thread_mgr_wait,
run_task, switch_source):
"""Test the register_and_subscribe() helper method - password missing."""
payload = Mock()
progress_callback = Mock()
error_callback = Mock()
subscription_proxy = get_proxy.return_value
# simulate the system not being registered
subscription_proxy.IsRegistered = False
# simulate subscription request
subscription_proxy.SubscriptionRequest = self.PASSWORD_MISSING_REQUEST
# run the function
register_and_subscribe(payload=payload,
progress_callback=progress_callback,
error_callback=error_callback)
# we should have waited on network
thread_mgr_wait.assert_called_once_with(THREAD_WAIT_FOR_CONNECTING_NM)
# there should be only the registration phase
progress_callback.assert_has_calls([call(SubscriptionPhase.REGISTER)])
# and the error callback should have been triggered
error_callback.assert_called_once()
# in this case we fail before requesting any other task than
# the config one
subscription_proxy.SetRHSMConfigWithTask.assert_called_once()
run_task.assert_called()
# setting CDN as installation source does not make sense
# when we were not able to attach a subscription
switch_source.assert_not_called()
def register_username_password_test(self, get_proxy, thread_mgr_wait, run_task, set_cdn):
"""Test the register_and_subscribe() helper method - username & password."""
payload = Mock()
progress_callback = Mock()
error_callback = Mock()
subscription_proxy = get_proxy.return_value
# simulate the system not being registered
subscription_proxy.IsRegistered = False
# simulate subscription request
subscription_proxy.SubscriptionRequest = self.PASSWORD_REQUEST
# run the function
register_and_subscribe(payload=payload,
progress_callback=progress_callback,
error_callback=error_callback)
# we should have waited on network
thread_mgr_wait.assert_called_once_with(THREAD_WAIT_FOR_CONNECTING_NM)
# system was no registered, so no unregistration phase
print(error_callback.mock_calls)
progress_callback.assert_has_calls(
[call(SubscriptionPhase.REGISTER),
call(SubscriptionPhase.ATTACH_SUBSCRIPTION),
call(SubscriptionPhase.DONE)]
)
# we were successful, so no error callback calls
error_callback.assert_not_called()
# we should have requested the appropriate tasks
subscription_proxy.SetRHSMConfigWithTask.assert_called_once()
subscription_proxy.RegisterUsernamePasswordWithTask.assert_called_once()
subscription_proxy.AttachSubscriptionWithTask.assert_called_once()
subscription_proxy.ParseAttachedSubscriptionsWithTask.assert_called_once()
# tried to set the CDN source
set_cdn.assert_called_once()
# and tried to run them
run_task.assert_called()
def register_username_password_task_failed_test(self, get_proxy,
thread_mgr_wait, run_task,
switch_source):
"""Test the register_and_subscribe() helper method - username & password failed."""
payload = Mock()
progress_callback = Mock()
error_callback = Mock()
subscription_proxy = get_proxy.return_value
# simulate the system not being registered
subscription_proxy.IsRegistered = False
# simulate subscription request
subscription_proxy.SubscriptionRequest = self.PASSWORD_REQUEST
# make the first (registration) task fail
run_task.side_effect = [True, RegistrationError("registration failed")]
# run the function
register_and_subscribe(payload=payload,
progress_callback=progress_callback,
error_callback=error_callback)
# we should have waited on network
thread_mgr_wait.assert_called_once_with(THREAD_WAIT_FOR_CONNECTING_NM)
# there should be only the registration phase
progress_callback.assert_has_calls([call(SubscriptionPhase.REGISTER)])
# and the error callback should have been triggered
error_callback.assert_called_once_with("registration failed")
# we should have requested the appropriate tasks
subscription_proxy.SetRHSMConfigWithTask.assert_called_once()
subscription_proxy.RegisterUsernamePasswordWithTask.assert_called_once(
)
# and tried to run them
run_task.assert_called()
# setting CDN as installation source does not make sense
# when we were not able to attach a subscription
switch_source.assert_not_called()
def attach_subscription_task_failed_test(self, get_proxy, thread_mgr_wait,
run_task):
"""Test the register_and_subscribe() helper method - failed to attach subscription."""
progress_callback = Mock()
error_callback = Mock()
subscription_proxy = get_proxy.return_value
# simulate the system not being registered
subscription_proxy.IsRegistered = False
# simulate subscription request
subscription_proxy.SubscriptionRequest = self.PASSWORD_REQUEST
# make the second (subscription) task fail
run_task.side_effect = [
True, SubscriptionError("failed to attach subscription")
]
# run the function
register_and_subscribe(progress_callback=progress_callback,
error_callback=error_callback)
# we should have waited on network
thread_mgr_wait.assert_called_once_with(THREAD_WAIT_FOR_CONNECTING_NM)
# there should be only the registration & subscription phase
progress_callback.assert_has_calls([
call(SubscriptionPhase.REGISTER),
call(SubscriptionPhase.ATTACH_SUBSCRIPTION)
])
# and the error callback should have been triggered
error_callback.assert_called_once_with("failed to attach subscription")
# we should have requested the appropriate tasks
subscription_proxy.RegisterUsernamePasswordWithTask.assert_called_once(
)
subscription_proxy.AttachSubscriptionWithTask.assert_called_once()
# and tried to run them
run_task.assert_called()
def register_org_key_task_failed_test(self, get_proxy, thread_mgr_wait,
run_task):
"""Test the register_and_subscribe() helper method - org & key failed."""
progress_callback = Mock()
error_callback = Mock()
subscription_proxy = get_proxy.return_value
# simulate the system not being registered
subscription_proxy.IsRegistered = False
# simulate subscription request
subscription_proxy.SubscriptionRequest = self.KEY_REQUEST
# make the first (registration) task fail
run_task.side_effect = [RegistrationError("registration failed")]
# run the function
register_and_subscribe(progress_callback=progress_callback,
error_callback=error_callback)
# we should have waited on network
thread_mgr_wait.assert_called_once_with(THREAD_WAIT_FOR_CONNECTING_NM)
# there should be only the registration phase
progress_callback.assert_has_calls([call(SubscriptionPhase.REGISTER)])
# and the error callback should have been triggered
error_callback.assert_called_once_with("registration failed")
# we should have requested the appropriate tasks
subscription_proxy.RegisterOrganizationKeyWithTask.assert_called_once()
# and tried to run them
run_task.assert_called()
def unregister_register_test(self, get_proxy, thread_mgr_wait, run_task):
"""Test the register_and_subscribe() helper method - registered system."""
progress_callback = Mock()
error_callback = Mock()
subscription_proxy = get_proxy.return_value
# simulate the system being registered,
# - this should add additional unregister phase and task
subscription_proxy.IsRegistered = True
# simulate subscription request
subscription_proxy.SubscriptionRequest = self.KEY_REQUEST
# run the function
register_and_subscribe(progress_callback=progress_callback,
error_callback=error_callback)
# we should have waited on network
thread_mgr_wait.assert_called_once_with(THREAD_WAIT_FOR_CONNECTING_NM)
# check the phases and their order
progress_callback.assert_has_calls([
call(SubscriptionPhase.UNREGISTER),
call(SubscriptionPhase.REGISTER),
call(SubscriptionPhase.ATTACH_SUBSCRIPTION),
call(SubscriptionPhase.DONE)
])
# we were successful, so no error callback calls
error_callback.assert_not_called()
# we should have requested the appropriate tasks
subscription_proxy.UnregisterWithTask.assert_called_once()
subscription_proxy.RegisterOrganizationKeyWithTask.assert_called_once()
subscription_proxy.AttachSubscriptionWithTask.assert_called_once()
subscription_proxy.ParseAttachedSubscriptionsTask.assert_called_once()
# and tried to run them
run_task.assert_called()
def register_key_missing_test(self, get_proxy, thread_mgr_wait, run_task):
"""Test the register_and_subscribe() helper method - key missing."""
progress_callback = Mock()
error_callback = Mock()
subscription_proxy = get_proxy.return_value
# simulate the system not being registered
subscription_proxy.IsRegistered = False
# simulate subscription request
subscription_proxy.SubscriptionRequest = self.KEY_MISSING_REQUEST
# run the function
register_and_subscribe(progress_callback=progress_callback,
error_callback=error_callback)
# we should have waited on network
thread_mgr_wait.assert_called_once_with(THREAD_WAIT_FOR_CONNECTING_NM)
# there should be only the registration phase
progress_callback.assert_has_calls([call(SubscriptionPhase.REGISTER)])
# and the error callback should have been triggered
error_callback.assert_called_once()
# int this case we fails before requesting any task and we should not
# attempt to run any
run_task.assert_not_called()
def register_override_cdrom_test(self, get_proxy, thread_mgr_wait,
run_task, switch_source):
"""Test the register_and_subscribe() helper method - override CDROM source."""
payload = Mock()
payload.type = PAYLOAD_TYPE_DNF
payload.data.repo.dataList = MagicMock(return_value=[])
source_proxy = payload.get_source_proxy.return_value
source_proxy.Type = SOURCE_TYPE_CDROM
progress_callback = Mock()
error_callback = Mock()
subscription_proxy = get_proxy.return_value
# simulate the system not being registered
subscription_proxy.IsRegistered = False
# simulate subscription request
subscription_proxy.SubscriptionRequest = self.KEY_REQUEST
# run the function
register_and_subscribe(payload=payload,
progress_callback=progress_callback,
error_callback=error_callback)
# we should have waited on network
thread_mgr_wait.assert_called_once_with(THREAD_WAIT_FOR_CONNECTING_NM)
# system was no registered, so no unregistration phase
progress_callback.assert_has_calls([
call(SubscriptionPhase.REGISTER),
call(SubscriptionPhase.ATTACH_SUBSCRIPTION),
call(SubscriptionPhase.DONE)
])
# we were successful, so no error callback calls
error_callback.assert_not_called()
# we should have requested the appropriate tasks
subscription_proxy.SetRHSMConfigWithTask.assert_called_once()
subscription_proxy.RegisterOrganizationKeyWithTask.assert_called_once()
subscription_proxy.AttachSubscriptionWithTask.assert_called_once()
subscription_proxy.ParseAttachedSubscriptionsWithTask.assert_called_once(
)
# and tried to override the CDROM source, as it is on a list of sources
# that are appropriate to be overriden by the CDN source
switch_source.assert_called_once_with(payload, SOURCE_TYPE_CDN)
# and tried to run them
run_task.assert_called()
def register_org_key_test(self, get_proxy, thread_mgr_wait, run_task,
switch_source):
"""Test the register_and_subscribe() helper method - org & key."""
payload = Mock()
source_proxy = payload.get_source_proxy.return_value
source_proxy.Type = SOURCE_TYPE_CLOSEST_MIRROR
progress_callback = Mock()
error_callback = Mock()
subscription_proxy = get_proxy.return_value
# simulate the system not being registered
subscription_proxy.IsRegistered = False
# simulate subscription request
subscription_proxy.SubscriptionRequest = self.KEY_REQUEST
# run the function
register_and_subscribe(payload=payload,
progress_callback=progress_callback,
error_callback=error_callback)
# we should have waited on network
thread_mgr_wait.assert_called_once_with(THREAD_WAIT_FOR_CONNECTING_NM)
# system was no registered, so no unregistration phase
progress_callback.assert_has_calls([
call(SubscriptionPhase.REGISTER),
call(SubscriptionPhase.ATTACH_SUBSCRIPTION),
call(SubscriptionPhase.DONE)
])
# we were successful, so no error callback calls
error_callback.assert_not_called()
# we should have requested the appropriate tasks
subscription_proxy.SetRHSMConfigWithTask.assert_called_once()
subscription_proxy.RegisterOrganizationKeyWithTask.assert_called_once()
subscription_proxy.AttachSubscriptionWithTask.assert_called_once()
subscription_proxy.ParseAttachedSubscriptionsWithTask.assert_called_once(
)
# not tried to set the CDN source
switch_source.assert_not_called()
# and tried to run them
run_task.assert_called()