def test_should_return_reminders_in_the_required_format(self): reminder1 = Mock(spec=Reminder) reminder1.message = '' reminder1.id = '1' reminder1.remind_to = RemindTo.DATASENDERS_WITHOUT_SUBMISSIONS reminder1.reminder_mode = ReminderMode.ON_DEADLINE reminder1.day = 0 reminder2 = Mock(spec=Reminder) reminder2.message = '' reminder2.id = '2' reminder2.remind_to = RemindTo.ALL_DATASENDERS reminder2.reminder_mode = ReminderMode.BEFORE_DEADLINE reminder2.day = 2 reminders = [reminder1, reminder2] formated_reminders = _format_reminders(reminders, 'test_project') self.assertEqual(2, len(formated_reminders)) # self.assertEqnual('/project/delete_reminder/test_project/1/', formated_reminders[0]['delete_link']) self.assertEqual('On Deadline', formated_reminders[0]['when']) self.assertEqual('Datasenders Without Submissions', formated_reminders[0]['to']) self.assertEqual('2 day(s) Before Deadline', formated_reminders[1]['when']) self.assertEqual('All Datasenders', formated_reminders[1]['to'])
async def test_handle_push_tag(monkeypatch): listener = Mock() listener.message = Mock( return_value=coroutine(lambda *args, **kwargs: 345)()) relay_push_discord = Mock(return_value=coroutine(lambda: True)()) relay_push = Mock(return_value=coroutine(lambda: True)()) monkeypatch.setattr('chitanda.modules.github_relay._relay_push_discord', relay_push_discord) monkeypatch.setattr('chitanda.modules.github_relay._relay_push', relay_push) await handle_push( listener, payload={ 'ref': 'refs/tags/master', 'before': 'abcdefghi', 'repository': { 'name': 'chitanda' }, }, cfg={ 'branches': ['master'], 'channel': 'hi' }, ) listener.message.assert_called() relay_push_discord.assert_not_called() relay_push.assert_not_called()
def create_mock_scheduled_tasks(cls): jobs = [] for name in ['foo', 'bar', 'baz']: job = Mock() job.key = JobKey(role=cls.TEST_ROLE, environment=cls.TEST_ENV, name=name) job.failure_count = 0 job.assignedTask = Mock(spec=AssignedTask) job.assignedTask.slaveHost = 'slavehost' job.assignedTask.task = Mock(spec=TaskConfig) job.assignedTask.task.maxTaskFailures = 1 job.assignedTask.task.packagesDEPRECATED = [] job.assignedTask.task.owner = Identity(role='mchucarroll') job.assignedTask.task.environment = 'test' job.assignedTask.task.jobName = 'woops' job.assignedTask.task.numCpus = 2 job.assignedTask.task.ramMb = 2 job.assignedTask.task.diskMb = 2 job.assignedTask.instanceId = 4237894 job.assignedTask.assignedPorts = None job.status = ScheduleStatus.RUNNING mockEvent = Mock(spec=TaskEvent) mockEvent.timestamp = 28234726395 mockEvent.status = ScheduleStatus.RUNNING mockEvent.message = "Hi there" job.taskEvents = [mockEvent] jobs.append(job) return jobs
def create_mock_scheduled_tasks(cls): jobs = [] for name in ["foo", "bar", "baz"]: job = Mock() job.key = JobKey(role=cls.TEST_ROLE, environment=cls.TEST_ENV, name=name) job.failure_count = 0 job.assignedTask = Mock(spec=AssignedTask) job.assignedTask.slaveHost = "slavehost" job.assignedTask.task = Mock(spec=TaskConfig) job.assignedTask.task.maxTaskFailures = 1 job.assignedTask.task.executorConfig = Mock(spec=ExecutorConfig) job.assignedTask.task.executorConfig.data = Mock() job.assignedTask.task.metadata = [] job.assignedTask.task.owner = Identity(role="mchucarroll") job.assignedTask.task.environment = "test" job.assignedTask.task.jobName = "woops" job.assignedTask.task.numCpus = 2 job.assignedTask.task.ramMb = 2 job.assignedTask.task.diskMb = 2 job.assignedTask.instanceId = 4237894 job.assignedTask.assignedPorts = None job.status = ScheduleStatus.RUNNING mockEvent = Mock(spec=TaskEvent) mockEvent.timestamp = 28234726395 mockEvent.status = ScheduleStatus.RUNNING mockEvent.message = "Hi there" job.taskEvents = [mockEvent] jobs.append(job) return jobs
def test_agent_policies(self): # set up data gc = Mock() service_key = "service_key" resource_id = "resource_id" pdpm = PolicyDecisionPointManager(gc) invocation = Mock() mock_header = Mock() invocation.message_annotations = {} invocation.message = {"argument1": 0} invocation.headers = { "op": "op", "process": "process", "request": "request", "ion-actor-id": "ion-actor-id", "receiver": "resource-registry", "sender-type": "sender-type", "sender-service": "Unknown", "ion-actor-roles": {"org_name": ["SUPERUSER"]}, } invocation.get_message_receiver.return_value = "service_key" invocation.get_service_name.return_value = "Unknown" invocation.get_message_sender.return_value = ["Unknown", "Unknown"] def get_header_value(key, default): return invocation.headers.get(key, default) mock_header.side_effect = get_header_value invocation.get_header_value = mock_header mock_args = Mock() process = Mock() process.org_governance_name = "org_name" process.resource_id = "resource_id" invocation.args = {"process": process} def get_arg_value(key, default="Unknown"): return invocation.args.get(key, default) mock_args.side_effect = get_arg_value invocation.get_arg_value = mock_args gc.system_root_org_name = "sys_org_name" # check that service policies result in denying the request pdpm.set_service_policy_rules(service_key, self.deny_SUPERUSER_rule) pdpm.set_resource_policy_rules(resource_id, self.permit_SUPERUSER_rule) response = pdpm.check_agent_request_policies(invocation) self.assertEqual(response.value, "Deny") # check that resource policies result in denying the request pdpm.set_service_policy_rules(service_key, self.permit_SUPERUSER_rule) pdpm.set_resource_policy_rules(resource_id, self.deny_SUPERUSER_rule) response = pdpm.check_agent_request_policies(invocation) self.assertEqual(response.value, "Deny") # check that both service and resource policies need to allow a request pdpm.set_service_policy_rules(service_key, self.permit_SUPERUSER_rule) pdpm.set_resource_policy_rules(resource_id, self.permit_SUPERUSER_rule) response = pdpm.check_agent_request_policies(invocation) self.assertEqual(response.value, "Permit")
def create_mock_scheduled_tasks(cls): jobs = [] for name in ['foo', 'bar', 'baz']: job = Mock() job.key = JobKey(role=cls.TEST_ROLE, environment=cls.TEST_ENV, name=name) job.failure_count = 0 job.assignedTask = Mock(spec=AssignedTask) job.assignedTask.slaveHost = 'slavehost' job.assignedTask.task = Mock(spec=TaskConfig) job.assignedTask.task.maxTaskFailures = 1 job.assignedTask.task.executorConfig = Mock(spec=ExecutorConfig) job.assignedTask.task.executorConfig.data = Mock() job.assignedTask.task.metadata = [] job.assignedTask.task.owner = Identity(role='bozo') job.assignedTask.task.environment = 'test' job.assignedTask.task.jobName = 'woops' job.assignedTask.task.numCpus = 2 job.assignedTask.task.ramMb = 2 job.assignedTask.task.diskMb = 2 job.assignedTask.instanceId = 4237894 job.assignedTask.assignedPorts = None job.status = ScheduleStatus.RUNNING mockEvent = Mock(spec=TaskEvent) mockEvent.timestamp = 28234726395 mockEvent.status = ScheduleStatus.RUNNING mockEvent.message = "Hi there" job.taskEvents = [mockEvent] jobs.append(job) return jobs
def create_mock_scheduled_tasks(cls): jobs = [] for name in ['foo', 'bar', 'baz']: job_key = JobKey(role=cls.TEST_ROLE, environment=cls.TEST_ENV, name=name) job = Mock() job.key = job_key job.failure_count = 0 job.assignedTask = Mock(spec=AssignedTask) job.assignedTask.taskId = 1287391823 job.assignedTask.slaveHost = 'slavehost' job.assignedTask.task = Mock(spec=TaskConfig) job.assignedTask.task.executorConfig = Mock() job.assignedTask.task.maxTaskFailures = 1 job.assignedTask.task.metadata = [] job.assignedTask.task.job = job_key job.assignedTask.task.owner = Identity(role=cls.TEST_ROLE) job.assignedTask.task.environment = cls.TEST_ENV job.assignedTask.task.jobName = name job.assignedTask.task.numCpus = 2 job.assignedTask.task.ramMb = 2 job.assignedTask.task.diskMb = 2 job.assignedTask.instanceId = 4237894 job.assignedTask.assignedPorts = {} job.status = ScheduleStatus.RUNNING mockEvent = Mock(spec=TaskEvent) mockEvent.timestamp = 28234726395 mockEvent.status = ScheduleStatus.RUNNING mockEvent.message = "Hi there" job.taskEvents = [mockEvent] jobs.append(job) return jobs
def test_should_not_exit_when_command_is_ignore_and_message_is_given(self, mock_exit): options = Mock() options.message = 'ignore message' validate_command_line_options( 'ignore', options, self.fake_show_help_callback) mock_exit.assert_not_called()
def test_should_execute_show_help_callback_when_no_ignore_message_is_given(self, _): options = Mock() options.message = None validate_command_line_options( 'ignore', options, self.fake_show_help_callback) self.assertTrue(self._show_help_callback_has_been_called)
def test_should_exit_with_appropriate_code_when_command_is_ignore_and_no_message_was_given(self, mock_exit): options = Mock() options.message = None validate_command_line_options( 'ignore', options, self.fake_show_help_callback) mock_exit.assert_called_with(EXIT_CODE_MISSING_MESSAGE_OPTION)
def event(): result = Mock() for k, v in DEFAULT_PLUGIN_CONFIGURATION.items(): setattr(result.project, k, v) result.message = 'An error has occured' result.error.return_value = result.message return result
def create_blank_response(cls, code, msg): response = Mock(spec=Response) response.responseCode = code mock_msg = Mock() mock_msg.message = msg response.details = [mock_msg] response.messageDEPRECATED = msg response.result = Mock(spec=Result) return response
def test_service_policies(self): gc = Mock() service_key = 'service_key' pdpm = PolicyDecisionPointManager(gc) # see that the PDP for service is the default self.assertEqual(pdpm.get_service_pdp(service_key), pdpm.load_common_service_pdp) pdpm.load_service_policy_rules(service_key, self.permit_ION_MANAGER_rule) # see that the PDP for service is not the default anymore self.assertNotEqual(pdpm.get_service_pdp(service_key), pdpm.load_common_service_pdp) # check request without a service_key raises NotFound error invocation = Mock() invocation.message_annotations = {} invocation.get_message_receiver.return_value = None with self.assertRaises(NotFound) as chk_res: pdpm.check_service_request_policies(invocation) self.assertIn(chk_res.exception.message, 'No receiver for this message') # check that, because actor does not have ION_MANAGER role, policy evaluates to a denial # (really Not Applicable, because of the inelegant hack of a policy we are setting up our pdp with) mock_header = Mock() invocation.message_annotations = {} invocation.message = {'argument1': 0} invocation.headers = {'op': 'op', 'process': 'process', 'request': 'request', 'ion-actor-id': 'ion-actor-id', 'receiver': 'resource-registry', 'sender-type': 'sender-type', 'sender-service': 'Unknown', 'ion-actor-roles': {'org_name': ['ion-actor-roles']}} invocation.get_message_receiver.return_value = 'service_key' invocation.get_service_name.return_value = 'Unknown' invocation.get_message_sender.return_value = ['Unknown','Unknown'] def get_header_value(key, default): return invocation.headers.get(key, default) mock_header.side_effect = get_header_value invocation.get_header_value = mock_header mock_args = Mock() process = Mock() process.org_governance_name = 'org_name' invocation.args = {'process': process} def get_arg_value(key, default): return invocation.args.get(key, default) mock_args.side_effect = get_arg_value invocation.get_arg_value = mock_args gc.system_root_org_name = 'sys_org_name' response = pdpm.check_service_request_policies(invocation) self.assertEqual(response.value, "NotApplicable") # check that policy evaluates to Permit because actor has ION_MANAGER role invocation.message_annotations = {} invocation.headers = {'op': 'op', 'process': 'process', 'request': 'request', 'ion-actor-id': 'ion-actor-id', 'receiver': 'resource-registry', 'sender-type': 'sender-type', 'sender-service': 'sender-service', 'ion-actor-roles': {'sys_org_name': ['ION_MANAGER']}} response = pdpm.check_service_request_policies(invocation) self.assertEqual(response.value, "Permit")
def test_validate_input_success(self, _): """ Test: The attribute value is returned When: validate_input is called with an attribute which is not None """ mock_self = Mock() mock_self.message = self.message actual = PostProcessAdmin.validate_input(mock_self, 'facility') self.assertEqual(actual, self.message.facility)
def setUp(self): # pylint: disable=C0103 """Test setup.""" os.mkdir(TMP) self.queuename = os.path.join(TMP, "wq") ctrl = Mock() ctrl.message = "start" ctrl.config = ConfigParser() ctrl.config.add_section("obsticket") ctrl.config.set("obsticket", "prjdir", TMP) self.participant = obsticket.ParticipantHandler() self.participant.handle_lifecycle_control(ctrl)
def test_validate_input_failure(self, _): """ Test: A ValueError is raised When: validate_input is called with an attribute who's value is None """ mock_self = Mock() mock_self.message = self.message mock_self.message.facility = None with self.assertRaises(ValueError): PostProcessAdmin.validate_input(mock_self, 'facility')
def test_update_job_error(self): job = Job('driver', 1).save() worker = DriverWorker(None, None, None) response_mock = Mock() response_mock.message = '{"message": "error"}' response_mock.status_code = 400 worker.update_job_error(job.uuid, {}, response_mock) job = Job.find_by_uuid(job.uuid) self.assertTrue(job.completed) self.assertEquals(1, job.error_count)
def event(): result = Mock() for k, v in DEFAULT_PLUGIN_CONFIGURATION.items(): setattr(result.project, k, v) result.get_level_display = Mock() result.get_level_display.return_value = 'ERROR' result.message = 'An error has occured' return result
def test_handle_lifecycle_control(self): ctrl = Mock() ctrl.message = "start" ctrl.config = ConfigParser() self.assertRaises(RuntimeError, self.participant.handle_lifecycle_control, ctrl) ctrl.config.add_section("obs") ctrl.config.set("obs", "oscrc", "oscrc_file") self.participant.handle_lifecycle_control(ctrl) ctrl.config.add_section("check_yaml") ctrl.config.set("check_yaml", "spec_pattern", "test") self.participant.handle_lifecycle_control(ctrl)
def setUp(self): """Set up the tests.""" BaseTestParticipantHandler.setUp(self) os.mkdir(TEMP_DIR) config = ConfigParser() config.add_section("obs") config.set("obs", "oscrc", "oscrc_file") config.add_section("getbuildlog") config.set("getbuildlog", "logdir", "test_tmp") ctrl = Mock() ctrl.message = "start" ctrl.config = config self.participant.handle_lifecycle_control(ctrl)
def test_new_reduction_data_only_root_path_exists(self): """ Test: The given path is returned with a 0 directory appended When: _new_reduction_data_path is called on a path without version sub-directories """ self.setup_test_dir_structure([self.test_root]) mock_self = Mock() mock_self.message = Message(overwrite=None) expected = append_path(self.test_root, "0") actual = PostProcessAdmin._new_reduction_data_path( mock_self, self.test_root) self.assertEqual(expected, actual)
def test_new_reduction_data_path_overwrite_paths_exist(self, _): """ Test: The given path is returned with a 0 directory appended When: _new_reduction_data_path is called on an existing path with overwrite: True """ self.setup_test_dir_structure(self.test_paths) mock_self = Mock() mock_self.message = Message(overwrite=True) expected = append_path(self.test_root, "0") actual = PostProcessAdmin._new_reduction_data_path( mock_self, self.test_root) self.assertEqual(expected, actual)
def test_new_reduction_data_path_no_overwrite_paths_exist(self, _): """ Test: A path is returned with a final directory one higher than the current highest When: _new_reduction_data_path is called on an existing path with overwrite: None """ self.setup_test_dir_structure(self.test_paths) mock_self = Mock() mock_self.message = Message(overwrite=None) expected = append_path(self.test_root, "3") actual = PostProcessAdmin._new_reduction_data_path( mock_self, self.test_root) self.assertEqual(expected, actual)
def setUp(self): # pylint: disable=C0103 """Test setup.""" BaseTestParticipantHandler.setUp(self) ctrl = Mock() ctrl.message = "start" ctrl.config = ConfigParser() ctrl.config.add_section("obs") ctrl.config.add_section("defineimage") ctrl.config.add_section("testing") ctrl.config.set("obs", "oscrc", "oscrc_file") ctrl.config.set("defineimage", "imagetypes", "testing") ctrl.config.set("testing", "always_include", "base-tests") self.ctrl = ctrl
def test_agent_policies(self): # set up data gc = Mock() service_key = 'service_key' resource_id = 'resource_id' pdpm = PolicyDecisionPointManager(gc) invocation = Mock() mock_header = Mock() invocation.message_annotations = {} invocation.message = {'argument1': 0 } invocation.headers = {'op': 'op', 'process': 'process', 'request': 'request', 'ion-actor-id': 'ion-actor-id', 'receiver': 'resource-registry', 'sender-type': 'sender-type', 'sender-service': 'Unknown', 'ion-actor-roles': {'org_name': ['ION_MANAGER']}} invocation.get_message_receiver.return_value = 'service_key' invocation.get_service_name.return_value = 'Unknown' invocation.get_message_sender.return_value = ['Unknown','Unknown'] def get_header_value(key, default): return invocation.headers.get(key, default) mock_header.side_effect = get_header_value invocation.get_header_value = mock_header mock_args = Mock() process = Mock() process.org_governance_name = 'org_name' process.resource_id = 'resource_id' invocation.args = {'process': process} def get_arg_value(key, default='Unknown'): return invocation.args.get(key, default) mock_args.side_effect = get_arg_value invocation.get_arg_value = mock_args gc.system_root_org_name = 'sys_org_name' # check that service policies result in denying the request pdpm.load_service_policy_rules(service_key, self.deny_ION_MANAGER_rule) pdpm.load_resource_policy_rules(resource_id, self.permit_ION_MANAGER_rule) response = pdpm.check_agent_request_policies(invocation) self.assertEqual(response.value, "Deny") # check that resource policies result in denying the request pdpm.load_service_policy_rules(service_key, self.permit_ION_MANAGER_rule) pdpm.load_resource_policy_rules(resource_id, self.deny_ION_MANAGER_rule) response = pdpm.check_agent_request_policies(invocation) self.assertEqual(response.value, "Deny") # check that both service and resource policies need to allow a request pdpm.load_service_policy_rules(service_key, self.permit_ION_MANAGER_rule) pdpm.load_resource_policy_rules(resource_id, self.permit_ION_MANAGER_rule) response = pdpm.check_agent_request_policies(invocation) self.assertEqual(response.value, "Permit")
def test_fault(self): fault_message = 'Error' fault_details = 'details' fault_date = 'now' temp_fault = Mock() temp_fault.message = fault_message temp_fault.details = fault_details temp_fault.updated = fault_date fault_mock = Mock(return_value=temp_fault) with patch.object(DBInstanceFault, 'find_by', fault_mock): fault = self.instance.fault self.assertEqual(fault_message, fault.message) self.assertEqual(fault_details, fault.details) self.assertEqual(fault_date, fault.updated)
def test_handle_lifecycle_control(self): """Test participant.handle_lifecycle_control()""" config = ConfigParser() ctrl = Mock() ctrl.message = "start" ctrl.config = config self.assertRaises(RuntimeError, self.participant.handle_lifecycle_control, ctrl) config.add_section("obs") config.set("obs", "oscrc", "oscrc_file") self.assertRaises(RuntimeError, self.participant.handle_lifecycle_control, ctrl) config.add_section("getbuildlog") config.set("getbuildlog", "logdir", "test_tmp")
def mock_put(_self, _endpoint, _request_payload): """ Mock a response from the Analytics service """ payload = json.dumps({ 'course_id': 'edX/DemoX/Demo_Course', 'student_id': '50cf92f9a3d8489df95e583549b919df', 'result': False, 'resource_id': 'i4x://edX/DemoX/problem/c554538a57664fac80783b99d9d6da7c', }) mock_response = Mock() mock_response.status_code = 200 mock_response.message = 'OK' mock_response.payload = payload return mock_response
def test_handle_http_exception(): e = Mock(HttpExceptionBase) e.status = 1234 e.message = 'message' request = mock_http_request() with patch.multiple('http.handle_requests', has_error_handler=DEFAULT, get_error_handler=DEFAULT) as values: values['has_error_handler'].return_value = False resp = handle_http_exception(request, e) values['has_error_handler'].assert_called_once() values['get_error_handler'].assert_has_calls([]) assert isinstance(resp, HTTPResponse) assert resp.status == 1234 assert resp.code == 'message' assert resp.content_type == 'text/html'
def configure_participant(self): ctrl = Mock() ctrl.message = "start" ctrl.config = ConfigParser() ctrl.config.add_section("obs") ctrl.config.set("obs", "oscrc", "oscrc_file") self.participant.handle_lifecycle_control(ctrl) self.mut.subprocess = Mock() self.mut.subprocess.Popen.side_effect = self.mock_specify self.participant.obs.getFile.return_value = TEST_SPEC self.specify_out = TEST_SPEC self.wid = Workitem(WI_TEMPLATE) self.wid.fields.msg = None self.wid.fields.ev.actions = self.fake_actions self.wid.fields.ev.namespace = "test"
def test_message_admins(self, mock_add_timestamp): mock_logger = Mock() mock_config = Mock() mock_config.colors = {'moderator': 'moderator colors'} mock_message = Mock() mock_message.message = '##test' mock_add_timestamp.return_value = 'with add_normalizer' mock_just_player = Mock() mock_just_player.player.access_level = UserLevels.GUEST mock_player_moderator = Mock() mock_player_moderator.player.access_level = UserLevels.MODERATOR mock_factory = Mock() mock_factory.protocols = { 'normal player': mock_just_player, 'moderator': mock_player_moderator } mock_protocol = Mock() mock_protocol.player.colored_name.return_value = 'player colors' plugin = AdminMessenger() plugin.factory = mock_factory plugin.config = mock_config plugin.logger = mock_logger plugin.protocol = mock_protocol plugin.message_admins(mock_message) mock_player_moderator.send_chat_message.assert_called_with( '{}{}ADMIN: ^yellow;<{}^yellow;> {}{}'.format( 'with add_normalizer', 'moderator colors', 'player colors', 'moderator colors', 'test' ) ) mock_logger.info.assert_called_with( 'Received an admin message from %s. Message: %s', mock_protocol.player.name, 'test' ) self.assertFalse(mock_just_player.send_chat_message.called) mock_add_timestamp.assert_called_with(add_normalizer=True)
def test_broadcast_message(self, mock_add_timestamp): mock_logger = Mock() mock_config = Mock() mock_config.colors = { 'admin': 'admin colors', 'default': 'default colors' } mock_message = Mock() mock_message.message = '###test' mock_add_timestamp.return_value = 'without add_normalizer' mock_just_player = Mock() mock_player_moderator = Mock() mock_factory = Mock() mock_factory.protocols = { 'normal player': mock_just_player, 'moderator': mock_player_moderator } mock_protocol = Mock() mock_protocol.player.access_level = UserLevels.ADMIN plugin = AdminMessenger() plugin.factory = mock_factory plugin.config = mock_config plugin.logger = mock_logger plugin.protocol = mock_protocol expected_message = '{}{}BROADCAST: ^red;{}{}'.format( 'without add_normalizer', 'admin colors', 'TEST', 'default colors' ) plugin.broadcast_message(mock_message) mock_player_moderator.send_chat_message.assert_called_with( expected_message ) mock_just_player.send_chat_message.assert_called_with(expected_message) mock_logger.info.assert_called_with( 'Broadcast from %s. Message: %s', mock_protocol.player.name, 'TEST' ) self.assertFalse(mock_protocol.send_chat_message.called)
def test_Engine_set_result_as_runtime_properties(self): engine, _client, _ctx, _instances_ctx = self._get_engine() engine.rsm_ctx._result_instance_ids = ["first"] _client.node_instances.update = Mock() _client.node_instances.get = Mock(return_value={ 'version': 11, 'runtime_properties': { 'a': 'b' } }) _error = Mock() _error.message = "NoNeOfSuCh" engine._set_result_as_runtime_properties([_error]) _client.node_instances.get.assert_called_with('first') _client.node_instances.update.assert_called_with('first', runtime_properties={ 'a': 'b', 'errors': ['NoNeOfSuCh'] }, version=11)
def test_handle_wi_control(self): """Test participant.handle_wi_control()""" ctrl = Mock() ctrl.message = "start" self.participant.handle_wi_control(ctrl)
def create_blank_response(cls, code, msg): response = Mock(spec=Response) response.responseCode = code response.message = msg response.result = Mock(spec=Result) return response
def test_is_boto_stack_does_not_exist_exception_returns_false_with_other_exception(self): exception = Mock(spec=Exception) exception.message = "No updates are to be performed." self.assertFalse(CloudFormation.is_boto_stack_does_not_exist_exception(exception))
def test_is_boto_no_update_required_exception_returns_true_for_message(self): exception = Mock(spec=BotoServerError) exception.message = "No updates are to be performed." self.assertTrue(CloudFormation.is_boto_no_update_required_exception(exception))
def test_service_policies(self): gc = Mock() service_key = "service_key" pdpm = PolicyDecisionPointManager(gc) # see that the PDP for service is the default self.assertEqual(pdpm.get_service_pdp(service_key), pdpm.load_common_service_pdp) pdpm.set_service_policy_rules(service_key, self.permit_SUPERUSER_rule) # see that the PDP for service is not the default anymore self.assertNotEqual(pdpm.get_service_pdp(service_key), pdpm.load_common_service_pdp) # check request without a service_key raises NotFound error invocation = Mock() invocation.message_annotations = {} invocation.get_message_receiver.return_value = None with self.assertRaises(NotFound) as chk_res: pdpm.check_service_request_policies(invocation) self.assertIn(chk_res.exception.message, "No receiver for this message") # check that, because actor does not have SUPERUSER role, policy evaluates to a denial # (really Not Applicable, because of the inelegant hack of a policy we are setting up our pdp with) mock_header = Mock() invocation.message_annotations = {} invocation.message = {"argument1": 0} invocation.headers = { "op": "op", "process": "process", "request": "request", "ion-actor-id": "ion-actor-id", "receiver": "resource-registry", "sender-type": "sender-type", "sender-service": "Unknown", "ion-actor-roles": {"org_name": ["ion-actor-roles"]}, } invocation.get_message_receiver.return_value = "service_key" invocation.get_service_name.return_value = "Unknown" invocation.get_message_sender.return_value = ["Unknown", "Unknown"] def get_header_value(key, default): return invocation.headers.get(key, default) mock_header.side_effect = get_header_value invocation.get_header_value = mock_header mock_args = Mock() process = Mock() process.org_governance_name = "org_name" invocation.args = {"process": process} def get_arg_value(key, default): return invocation.args.get(key, default) mock_args.side_effect = get_arg_value invocation.get_arg_value = mock_args gc.system_root_org_name = "sys_org_name" response = pdpm.check_service_request_policies(invocation) self.assertEqual(response.value, "NotApplicable") # check that policy evaluates to Permit because actor has SUPERUSER role invocation.message_annotations = {} invocation.headers = { "op": "op", "process": "process", "request": "request", "ion-actor-id": "ion-actor-id", "receiver": "resource-registry", "sender-type": "sender-type", "sender-service": "sender-service", "ion-actor-roles": {"sys_org_name": ["SUPERUSER"]}, } response = pdpm.check_service_request_policies(invocation) self.assertEqual(response.value, "Permit")
def test_remove_duplicates(self): self.assertEqual([], remove_duplicates([])) issue1 = Mock() issue2 = Mock() issue1.path = '/filename' issue2.path = '/filename' issue1.severity = 10 issue2.severity = 10 issue1.line_number_start = None issue2.line_number_start = None issue1.line_position = None issue2.line_position = None issue1.message = 'foo' issue2.message = 'bar' self.assertEqual([issue1, issue2], remove_duplicates([issue1, issue2])) issue1.line_number_start = 42 issue2.line_number_start = 42 issue1.message = 'line too long' issue2.message = 'unused import foo' self.assertEqual([issue1, issue2], remove_duplicates([issue1, issue2])) issue1.line_number_start = 42 issue2.line_number_start = 42 issue1.line_position = -1 issue2.line_position = -1 issue1.message = 'unused import bar' issue2.message = 'module bar not used' self.assertEqual([issue1], remove_duplicates([issue1, issue2])) issue1.line_number_start = 42 issue2.line_number_start = 42 issue1.line_position = 12 issue2.line_position = 28 issue1.message = 'unused import bar' issue2.message = 'module foo not used' self.assertEqual([issue1, issue2], remove_duplicates([issue1, issue2])) issue1.line_number_start = 32 issue2.line_number_start = 32 issue1.line_position = 80 issue2.line_position = -1 issue1.message = 'line too long (92 characters)' issue2.message = 'Line too long (92/80)' self.assertEqual([issue1], remove_duplicates([issue1, issue2])) issue1.line_number_start = 32 issue2.line_number_start = 33 issue1.line_position = 80 issue2.line_position = -1 issue1.message = 'line too long (92 characters)' issue2.message = 'Line too long (92/80)' self.assertEqual([issue1, issue2], remove_duplicates([issue1, issue2]))
def test_agent_policies(self): # set up data gc = Mock() service_key = 'service_key' resource_id = 'resource_id' pdpm = PolicyDecisionPointManager(gc) invocation = Mock() mock_header = Mock() invocation.message_annotations = {} invocation.message = {'argument1': 0} invocation.headers = { 'op': 'op', 'process': 'process', 'request': 'request', 'ion-actor-id': 'ion-actor-id', 'receiver': 'resource-registry', 'sender-type': 'sender-type', 'sender-service': 'Unknown', 'ion-actor-roles': { 'org_name': ['SUPERUSER'] } } invocation.get_message_receiver.return_value = 'service_key' invocation.get_service_name.return_value = 'Unknown' invocation.get_message_sender.return_value = ['Unknown', 'Unknown'] def get_header_value(key, default): return invocation.headers.get(key, default) mock_header.side_effect = get_header_value invocation.get_header_value = mock_header mock_args = Mock() process = Mock() process.org_governance_name = 'org_name' process.resource_id = 'resource_id' invocation.args = {'process': process} def get_arg_value(key, default='Unknown'): return invocation.args.get(key, default) mock_args.side_effect = get_arg_value invocation.get_arg_value = mock_args gc.system_root_org_name = 'sys_org_name' # check that service policies result in denying the request pdpm.set_service_policy_rules(service_key, self.deny_SUPERUSER_rule) pdpm.set_resource_policy_rules(resource_id, self.permit_SUPERUSER_rule) response = pdpm.check_agent_request_policies(invocation) self.assertEqual(response.value, "Deny") # check that resource policies result in denying the request pdpm.set_service_policy_rules(service_key, self.permit_SUPERUSER_rule) pdpm.set_resource_policy_rules(resource_id, self.deny_SUPERUSER_rule) response = pdpm.check_agent_request_policies(invocation) self.assertEqual(response.value, "Deny") # check that both service and resource policies need to allow a request pdpm.set_service_policy_rules(service_key, self.permit_SUPERUSER_rule) pdpm.set_resource_policy_rules(resource_id, self.permit_SUPERUSER_rule) response = pdpm.check_agent_request_policies(invocation) self.assertEqual(response.value, "Permit")
def test_service_policies(self): gc = Mock() service_key = 'service_key' pdpm = PolicyDecisionPointManager(gc) # see that the PDP for service is the default self.assertEqual(pdpm.get_service_pdp(service_key), pdpm.load_common_service_pdp) pdpm.set_service_policy_rules(service_key, self.permit_SUPERUSER_rule) # see that the PDP for service is not the default anymore self.assertNotEqual(pdpm.get_service_pdp(service_key), pdpm.load_common_service_pdp) # check request without a service_key raises NotFound error invocation = Mock() invocation.message_annotations = {} invocation.get_message_receiver.return_value = None with self.assertRaises(NotFound) as chk_res: pdpm.check_service_request_policies(invocation) self.assertIn(chk_res.exception.message, 'No receiver for this message') # check that, because actor does not have SUPERUSER role, policy evaluates to a denial # (really Not Applicable, because of the inelegant hack of a policy we are setting up our pdp with) mock_header = Mock() invocation.message_annotations = {} invocation.message = {'argument1': 0} invocation.headers = { 'op': 'op', 'process': 'process', 'request': 'request', 'ion-actor-id': 'ion-actor-id', 'receiver': 'resource-registry', 'sender-type': 'sender-type', 'sender-service': 'Unknown', 'ion-actor-roles': { 'org_name': ['ion-actor-roles'] } } invocation.get_message_receiver.return_value = 'service_key' invocation.get_service_name.return_value = 'Unknown' invocation.get_message_sender.return_value = ['Unknown', 'Unknown'] def get_header_value(key, default): return invocation.headers.get(key, default) mock_header.side_effect = get_header_value invocation.get_header_value = mock_header mock_args = Mock() process = Mock() process.org_governance_name = 'org_name' invocation.args = {'process': process} def get_arg_value(key, default): return invocation.args.get(key, default) mock_args.side_effect = get_arg_value invocation.get_arg_value = mock_args gc.system_root_org_name = 'sys_org_name' response = pdpm.check_service_request_policies(invocation) self.assertEqual(response.value, "NotApplicable") # check that policy evaluates to Permit because actor has SUPERUSER role invocation.message_annotations = {} invocation.headers = { 'op': 'op', 'process': 'process', 'request': 'request', 'ion-actor-id': 'ion-actor-id', 'receiver': 'resource-registry', 'sender-type': 'sender-type', 'sender-service': 'sender-service', 'ion-actor-roles': { 'sys_org_name': ['SUPERUSER'] } } response = pdpm.check_service_request_policies(invocation) self.assertEqual(response.value, "Permit")
def test_handle_lifecycle_control(self): ctrl = Mock() ctrl.message = "start" self.participant.handle_lifecycle_control(ctrl)