def test_run_already_in_progress(self, mock_sync, mock_get, mock_status): # Setup data = { options.OPTION_REPO_ID.keyword: 'test-repo', sp.NAME_BACKGROUND: False, } # Simulate a task already running task_data = copy.copy(CALL_REPORT_TEMPLATE) task_data['response'] = 'accepted' task_data['state'] = 'running' task = Task(task_data) mock_get.return_value = Response(200, [task]) # Response from the sync call task_data = copy.copy(CALL_REPORT_TEMPLATE) task = Task(task_data) mock_sync.return_value = Response(202, [task]) # Test self.command.run(**data) # Verify self.assertEqual(1, mock_status.call_count) tags = self.prompt.get_write_tags() self.assertEqual(2, len(tags)) self.assertEqual(tags[1], 'in-progress')
def test_rpm_group_export_missing_distributor(self, mock_distributors, mock_create, mock_publish): """ Test that when there is no distributor attached to the repository group, one is added """ # Setup mock_distributors.return_value = Response(200, []) mock_publish.return_value = Response(200, []) expected_distributor_config = { constants.PUBLISH_HTTP_KEYWORD: True, constants.PUBLISH_HTTPS_KEYWORD: True, } # Test command = export.RpmGroupExportCommand( self.context, mock.MagicMock(), ids.TYPE_ID_DISTRIBUTOR_GROUP_EXPORT) command.run(**self.kwargs) # Assert that the call get get the distributor was made correctly self.assertEqual(1, mock_distributors.call_count) self.assertEqual('test-group', mock_distributors.call_args[0][1]) # Assert that when the NonFoundException is raised, a call to create a distributor is made self.assertEqual(1, mock_create.call_count) self.assertEqual('test-group', mock_create.call_args[0][1]) self.assertEqual(ids.TYPE_ID_DISTRIBUTOR_GROUP_EXPORT, mock_create.call_args[0][2]) self.assertEqual(expected_distributor_config, mock_create.call_args[0][3])
def test_rpm_group_export_run(self, mock_distributors, mock_create, mock_publish): """ Test to make sure the publish binding is called correctly with an existing distributor. """ # Setup mock_distributor = { 'distributor_type_id': ids.TYPE_ID_DISTRIBUTOR_GROUP_EXPORT, 'id': 'foo-distributor' } mock_distributors.return_value = Response(200, [mock_distributor]) mock_publish.return_value = Response(200, []) expected_publish_config = { constants.PUBLISH_HTTP_KEYWORD: True, constants.PUBLISH_HTTPS_KEYWORD: True, } # Test command = export.RpmGroupExportCommand( self.context, mock.MagicMock(), ids.TYPE_ID_DISTRIBUTOR_GROUP_EXPORT) command.run(**self.kwargs) # Assert that the call get get the distributor was made correctly self.assertEqual(1, mock_distributors.call_count) self.assertEqual('test-group', mock_distributors.call_args[0][1]) mock_publish.assert_called_once_with(mock.ANY, 'test-group', mock.ANY, expected_publish_config)
def test_run_search_errata_details(self, mock_search): """ Test that when the --erratum-id argument is used, the custom output function write_erratum_detail is called instead of render_document_list """ # Setup mock_out = mock.MagicMock() units = [{'a': 'a', 'metadata': 'm'}] mock_search.return_value = Response(200, units) user_input = { 'repo-id': 'repo-1', 'erratum-id': 'RHEA-0000:0000', DisplayUnitAssociationsCommand.ASSOCIATION_FLAG.keyword: False } # Test command = contents.SearchErrataCommand(self.context) command.write_erratum_detail = mock_out command.errata(**user_input) # Verify expected = { 'type_ids': [contents.TYPE_ERRATUM], 'filters': {'id': 'RHEA-0000:0000'}, } mock_search.assert_called_once_with('repo-1', **expected) # Because there's only one type_id and contents.FIELDS_BY_TYPE[FIELDS_ERRATA] is # defined, the write_erratum_detail should be called with the metadata and FIELDS_ERRATA mock_out.assert_called_once_with(['m'], contents.FIELDS_ERRATA)
def test_run_search_errata(self, mock_search): """ Test that when the --erratum-id argument isn't used, the default render_document_list output function is called """ # Setup mock_out = mock.MagicMock() units = [{'a': 'a', 'metadata': 'm'}] mock_search.return_value = Response(200, units) user_input = { 'repo-id': 'repo-1', 'erratum-id': None, DisplayUnitAssociationsCommand.ASSOCIATION_FLAG.keyword: False, } # Test self.context.prompt.render_document_list = mock_out command = contents.SearchErrataCommand(self.context) command.errata(**user_input) # Verify expected = { 'type_ids': [contents.TYPE_ERRATUM], 'erratum-id': None, DisplayUnitAssociationsCommand.ASSOCIATION_FLAG.keyword: False, } mock_search.assert_called_once_with('repo-1', **expected) # Because there's only one type_id and contents.FIELDS_BY_TYPE[FIELDS_ERRATA] is # defined, the output function should be called with the metadata and FIELDS_ERRATA mock_out.assert_called_once_with(['m'], contents.FIELDS_ERRATA)
def test_run_search_with_field_filters(self, mock_search): # Setup mock_out = mock.MagicMock() units = [{'a': 'a', 'metadata': 'm'}] mock_search.return_value = Response(200, units) user_input = { 'repo-id': 'repo-1', DisplayUnitAssociationsCommand.ASSOCIATION_FLAG.keyword: False, } # Test command = contents.BaseSearchCommand(None, self.context) command.run_search([contents.TYPE_RPM], out_func=mock_out, **user_input) # Verify expected = { 'type_ids': [contents.TYPE_RPM], DisplayUnitAssociationsCommand.ASSOCIATION_FLAG.keyword: False, } mock_search.assert_called_once_with('repo-1', **expected) mock_out.assert_called_once_with( ['m'], contents.FIELDS_BY_TYPE[contents.TYPE_RPM])
def test_update(self): # Setup strategy = mock.Mock() strategy.update_schedule.return_value = Response(200, {}) update_command = commands.UpdateScheduleCommand( self.context, strategy, 'update', 'update') update_command.create_option('--extra', 'extra') self.cli.add_command(update_command) # Test self.cli.run( 'update --schedule-id foo --schedule 2012-05-22T00:00:00/P1D --failure-threshold 1 --enabled true --extra bar' .split()) # Verify args = strategy.update_schedule.call_args[0] self.assertEqual(1, len(args)) self.assertEqual('foo', args[0]) kwargs = strategy.update_schedule.call_args[1] self.assertTrue('schedule' in kwargs) self.assertEqual('2012-05-22T00:00:00/P1D', kwargs['schedule']) self.assertTrue('failure_threshold' in kwargs) self.assertEqual('1', kwargs['failure_threshold']) self.assertTrue('enabled' in kwargs) self.assertEqual(True, kwargs['enabled']) self.assertEqual(1, len(self.prompt.get_write_tags())) self.assertEqual(TAG_SUCCESS, self.prompt.get_write_tags()[0])
def test_list(self): # Setup strategy = mock.Mock() strategy.retrieve_schedules.return_value = Response( 200, copy.deepcopy(EXAMPLE_SCHEDULE_LIST)) list_command = commands.ListScheduleCommand(self.context, strategy, 'list', 'list') list_command.create_option('--extra', 'extra') self.cli.add_command(list_command) # Test self.cli.run('list --extra foo'.split()) # Verify self.assertEqual(strategy.retrieve_schedules.call_count, 1) self.assertEqual(strategy.retrieve_schedules.call_args[0][0]['extra'], 'foo') # Spot check the ID lines in the displayed list id_lines = [l for l in self.recorder.lines if l.startswith('Id')] self.assertEqual(3, len(id_lines)) ids = [l.split()[1] for l in id_lines] self.assertTrue(EXAMPLE_SCHEDULE_LIST[0]['_id'] in ids) self.assertTrue(EXAMPLE_SCHEDULE_LIST[1]['_id'] in ids) self.assertTrue(EXAMPLE_SCHEDULE_LIST[2]['_id'] in ids)
def test_list_details(self): # Setup strategy = mock.Mock() strategy.retrieve_schedules.return_value = Response( 200, copy.deepcopy(EXAMPLE_SCHEDULE_LIST)) list_command = commands.ListScheduleCommand(self.context, strategy, 'list', 'list') self.cli.add_command(list_command) # Test self.cli.run('list --details'.split()) # Verify self.assertEqual(strategy.retrieve_schedules.call_count, 1) # Spot check the ID lines in the displayed list fr_lines = [ l for l in self.recorder.lines if l.startswith('First Run') ] self.assertEqual(3, len(fr_lines)) first_runs = [l.split()[2] for l in fr_lines] self.assertTrue(EXAMPLE_SCHEDULE_LIST[0]['first_run'] in first_runs) self.assertTrue(EXAMPLE_SCHEDULE_LIST[1]['first_run'] in first_runs) self.assertTrue(EXAMPLE_SCHEDULE_LIST[2]['first_run'] in first_runs)
def _mock_initialize_upload(self): """ Configures the mock bindings to return a valid upload ID. """ body = { 'upload_id': MOCK_UPLOAD_ID, '_href': MOCK_LOCATION, } self.mock_upload_bindings.initialize_upload.return_value = Response(201, body)
def _request(self, method, path, queries=(), body=None, ensure_encoding=True): """ make a HTTP request to the pulp server and return the response :param method: name of an HTTP method such as GET, POST, PUT, HEAD or DELETE :type method: basestring :param path: URL for this request :type path: basestring :param queries: mapping object or a sequence of 2-element tuples, in either case representing key-value pairs to be used as query parameters on the URL. :type queries: mapping object or sequence of 2-element tuples :param body: Data structure that will be JSON serialized and send as the request's body. :type body: Anything that is JSON-serializable. :param ensure_encoding: toggle proper string encoding for the body :type ensure_encoding: bool :return: Response object :rtype: pulp.bindings.responses.Response :raises: ConnectionException or one of the RequestExceptions (depending on response codes) in case of unsuccessful request """ url = self._build_url(path, queries) if ensure_encoding: body = self._process_body(body) if not isinstance(body, (NoneType, basestring)): body = json.dumps(body) self.log.debug('sending %s request to %s' % (method, url)) response_code, response_body = self.server_wrapper.request(method, url, body) if self.api_responses_logger: self.api_responses_logger.info('%s request to %s with parameters %s' % (method, url, body)) self.api_responses_logger.info("Response status : %s \n" % response_code) self.api_responses_logger.info("Response body :\n %s\n" % json.dumps(response_body, indent=2)) if response_code >= 300: self._handle_exceptions(response_code, response_body) elif response_code == 200 or response_code == 201: body = response_body elif response_code == 202: if isinstance(response_body, list): body = [Task(t) for t in response_body] else: body = Task(response_body) return Response(response_code, body)
def test_run(self, mock_sync, mock_get, mock_status): # Setup data = { options.OPTION_REPO_ID.keyword: 'test-repo', sp.NAME_BACKGROUND: False, } # No tasks are running mock_get.return_value = Response(200, []) # Response from the sync call task_data = copy.copy(CALL_REPORT_TEMPLATE) task = Task(task_data) mock_sync.return_value = Response(202, [task]) # Test self.command.run(**data) # Verify self.assertEqual(1, mock_status.call_count)
def test_next_run_no_schedules(self): # Setup strategy = mock.Mock() strategy.retrieve_schedules.return_value = Response(200, {}) next_command = commands.NextRunCommand(self.context, strategy, 'next', 'next') self.cli.add_command(next_command) # Test self.cli.run('next'.split()) # Verify self.assertTrue('no schedules' in self.recorder.lines[0])
def test_run_background(self, mock_publish, mock_get, mock_status): # Setup data = { options.OPTION_REPO_ID.keyword: 'test-repo', sp.NAME_BACKGROUND: True, } # No tasks are running mock_get.return_value = Response(200, []) # Response from the sync call task_data = copy.copy(CALL_REPORT_TEMPLATE) task = Task(task_data) mock_publish.return_value = Response(202, task) # Test self.command.run(**data) # Verify self.assertEqual(0, mock_status.call_count) # since its background tags = self.prompt.get_write_tags() self.assertEqual(2, len(tags)) self.assertEqual(tags[1], 'background')
def poll(task_id): task = Task(TASK_TEMPLATE) # Wait for the first 2 polls if mock_get.call_count < 3: task.state = STATE_WAITING # Running for the next 10 elif mock_get.call_count < 13: task.state = STATE_RUNNING # Finally finish else: task.state = STATE_ERROR return Response(200, task)
def test_run_no_status(self, mock_get, mock_status): # Setup data = { options.OPTION_REPO_ID.keyword: 'test-repo', } # No tasks are running mock_get.return_value = Response(200, []) # Test self.command.run(**data) # Verify self.assertEqual(1, mock_get.call_count) self.assertEqual(0, mock_status.call_count) self.assertEqual(self.prompt.get_write_tags(), [TAG_TITLE, 'no-tasks'])
def test_next_run_quiet(self): # Setup strategy = mock.Mock() strategy.retrieve_schedules.return_value = Response( 200, copy.copy(EXAMPLE_SCHEDULE_LIST)) next_command = commands.NextRunCommand(self.context, strategy, 'next', 'next') self.cli.add_command(next_command) # Test self.cli.run('next --quiet'.split()) # Verify self.assertEqual(1, len(self.prompt.get_write_tags())) self.assertEqual(TAG_PARAGRAPH, self.prompt.get_write_tags()[0]) self.assertEqual('2012-05-22T00:00:00Z\n', self.recorder.lines[0])
def test_run(self, mock_get, mock_status): # Setup data = { options.OPTION_REPO_ID.keyword: 'test-repo', } # Simulate a task already running task_data = copy.copy(CALL_REPORT_TEMPLATE) task_data['response'] = 'accepted' task_data['state'] = 'running' task = Task(task_data) mock_get.return_value = Response(200, [task]) # Test self.command.run(**data) # Verify self.assertEqual(1, mock_get.call_count) self.assertEqual(1, mock_status.call_count)
def test_delete(self): # Setup strategy = mock.Mock() strategy.create_schedule.return_value = Response(200, {}) delete_command = commands.DeleteScheduleCommand( self.context, strategy, 'delete', 'delete') delete_command.create_option('--extra', 'extra stuff') self.cli.add_command(delete_command) # Test self.cli.run('delete --schedule-id foo --extra e1'.split()) # Verify args = strategy.delete_schedule.call_args[0] self.assertEqual('foo', args[0]) self.assertTrue('extra' in args[1]) self.assertEqual('e1', args[1]['extra']) self.assertEqual(1, len(self.prompt.get_write_tags())) self.assertEqual(TAG_SUCCESS, self.prompt.get_write_tags()[0])
def test_run_search(self, mock_search): # Setup mock_out = mock.MagicMock() units = [{'a': 'a', 'metadata': 'm'}] mock_search.return_value = Response(200, units) user_input = { 'repo-id': 'repo-1', DisplayUnitAssociationsCommand.ASSOCIATION_FLAG.keyword: True, } # Test command = contents.BaseSearchCommand(self.context) command.run_search(['fake-type'], out_func=mock_out, **user_input) # Verify expected = { 'type_ids': ['fake-type'], DisplayUnitAssociationsCommand.ASSOCIATION_FLAG.keyword: True, } mock_search.assert_called_once_with('repo-1', **expected) mock_out.assert_called_once_with(units)
def test_next_run(self): # Setup strategy = mock.Mock() strategy.retrieve_schedules.return_value = Response( 200, copy.copy(EXAMPLE_SCHEDULE_LIST)) next_command = commands.NextRunCommand(self.context, strategy, 'next', 'next') next_command.create_option('--extra', 'extra') self.cli.add_command(next_command) # Test self.cli.run('next --extra foo'.split()) # Verify self.assertEqual(1, strategy.retrieve_schedules.call_count) self.assertEqual(strategy.retrieve_schedules.call_args[0][0]['extra'], 'foo') self.assertEqual(1, len(self.prompt.get_write_tags())) self.assertEqual(TAG_PARAGRAPH, self.prompt.get_write_tags()[0]) self.assertTrue('2012-05-22T00:00:00Z' in self.recorder.lines[0]) self.assertTrue('2012-05-15T00:00:00Z/P1W' in self.recorder.lines[0])
def test_add(self): # Setup strategy = mock.Mock() strategy.create_schedule.return_value = Response(201, {}) create_command = commands.CreateScheduleCommand( self.context, strategy, 'add', 'add') create_command.create_option('--extra', 'extra') self.cli.add_command(create_command) # Test self.cli.run( 'add --schedule 2012-05-22T00:00:00/P1D --failure-threshold 10 --extra foo' .split()) # Verify args = strategy.create_schedule.call_args[0] self.assertEqual('2012-05-22T00:00:00/P1D', args[0]) self.assertEqual('10', args[1]) self.assertEqual(True, args[2]) self.assertEqual('foo', args[3]['extra']) self.assertEqual(1, len(self.prompt.get_write_tags())) self.assertEqual(TAG_SUCCESS, self.prompt.get_write_tags()[0])
def search_simulator(repo_id, **criteria): response = Response(200, copy.copy(search_results)) if len(search_results): search_results.pop(0) return response
def _mock_import_upload(self): """ Configures the mock bindings to return a valid response on importing an upload. """ self.mock_upload_bindings.import_upload.return_value = Response(200, {})
def _mock_delete_upload(self): """ Configures the mock bindings to return a valid response to deleting an upload. """ self.mock_upload_bindings.delete_upload.return_value = Response(200, {})
def _mock_upload_segment(self): """ Configures the mock bindings to return a valid response to uploading a segment. """ self.mock_upload_bindings.upload_segment.return_value = Response(200, {})