def test_progress_no_progress(self):
"""
Test the progress() method when the Task does not have any progress_report.
"""
task = responses.Task({})
spinner = mock.MagicMock()
self.command.progress(task, spinner)
self.assertEqual(self.mock_renderer.display_report.call_count, 0)
def test_progress(self):
"""
Test the progress() method with a progress_report.
"""
progress_report = {'some': 'data'}
task = responses.Task({'progress_report': progress_report})
spinner = mock.MagicMock()
self.command.progress(task, spinner)
self.mock_renderer.display_report.assert_called_once_with(
progress_report)
def create_fake_task_response():
"""
Returns a Response object that can be used as a mock return from a bindings call
that is expected to return a task. The values for the task will be the same as
those found in TASK_TEMPLATE.
:return: response object with the parsed Task object in its response_body
:rtype: Response
"""
task = responses.Task(TASK_TEMPLATE)
response = responses.Response('202', task)
return response
def test_progress_failed_task(self):
"""
Test the progress() method when the Task failed. In this case, the
error will be rendered by the generic failure handler.
"""
progress_report = {'some': 'data'}
task = responses.Task({'progress_report': progress_report})
task.state = responses.STATE_ERROR
spinner = mock.MagicMock()
self.command.progress(task, spinner)
self.assertEqual(self.mock_renderer.display_report.call_count, 0)
def test_progress(self):
"""
Test the progress() method with a progress_report.
"""
task = responses.Task(
{'progress_report': {
'Refresh Content Sources': self.step
}})
spinner = MagicMock()
self.renderer.display_report = MagicMock()
self.command.progress(task, spinner)
self.renderer.display_report.assert_called_once_with(
{'Refresh Content Sources': self.step})
def test___str__(self):
"""
Test the __str__() method.
"""
some_typical_data = {
u'_href':
u'/pulp/api/v2/tasks/9efb5da2-ff42-4633-9355-81385bd43310',
u'task_id':
u'9efb5da2-ff42-4633-9355-81385bd43310',
u'tags': [u'pulp:repository:zoo', u'pulp:action:sync'],
u'finish_time':
1392054742,
u'_ns':
u'task_status',
u'start_time':
1392054740,
u'spawned_tasks': [{
u'_href':
u'/pulp/api/v2/tasks/37506910-dc71-46c4-809e-48cf385b803f/',
u'task_id':
u'37506910-dc71-46c4-809e-48cf385b803f'
}],
u'progress_report': {
u'some': u'data'
},
u'queue':
u'*****@*****.**',
u'state':
u'finished',
u'result': {
u'some': u'return data'
},
u'_id': {
u'$oid': u'52f911d4b8b0edc2462f61a2'
}
}
a_task = responses.Task(some_typical_data)
representation = str(a_task)
expected_representation = u'Task: 9efb5da2-ff42-4633-9355-81385bd43310 State: finished'
self.assertEqual(representation, expected_representation)
def test___init___with_exception(self):
"""
Test __init__() when there is an exception.
"""
some_typical_data = {
u'task_id': u'9efb5da2-ff42-4633-9355-81385bd43310',
u'exception': u'TheWorldIsEndingException',
u'traceback': u'deprecated traceback here',
u'error': u'Some error message',
u'tags': [u'pulp:repository:zoo', u'pulp:action:sync'],
u'finish_time': 1392054742,
u'_ns': u'task_status',
u'start_time': 1392054740,
u'progress_report': {
u'some': u'data'
},
u'queue': u'*****@*****.**',
u'state': responses.STATE_ERROR,
u'_id': {
u'$oid': u'52f911d4b8b0edc2462f61a2'
}
}
a_task = responses.Task(some_typical_data)
# href should default to None when it wasn't in the response data
self.assertEqual(a_task.href, None)
self.assertEqual(a_task.task_id, some_typical_data['task_id'])
self.assertEqual(a_task.tags, some_typical_data['tags'])
self.assertEqual(a_task.start_time, some_typical_data['start_time'])
self.assertEqual(a_task.finish_time, some_typical_data['finish_time'])
self.assertEqual(a_task.state, some_typical_data['state'])
self.assertEqual(a_task.progress_report,
some_typical_data['progress_report'])
self.assertEqual(a_task.result, None)
# exception, traceback and error default to None when it isn't provided in the response data
self.assertEqual(a_task.exception, some_typical_data['exception'])
self.assertEqual(a_task.traceback, some_typical_data['traceback'])
self.assertEqual(a_task.error, some_typical_data['error'])
# Spawned tasks defaults to [] if None are in the response_body
self.assertEqual(a_task.spawned_tasks, [])
def test_calls_poll(self, poll):
"""
Make sure that perform_upload() hands off the import task to be polled.
"""
response_body = {
'task_id': '123456', 'tags': [], 'start_time': datetime.datetime.now(),
'finish_time': datetime.datetime.now() + datetime.timedelta(seconds=10),
'state': responses.STATE_ERROR, 'progress_report': {}, 'result': None,
'exception': None, 'traceback': None, 'error': 'An error message.', 'spawned_tasks': []}
response = mock.MagicMock()
response.response_body = responses.Task(response_body)
response.is_async = mock.MagicMock(return_value=False)
upload_manager = mock.MagicMock()
upload_manager.import_upload = mock.MagicMock(return_value=response)
upload_ids = ['an_id']
method = mock.MagicMock()
user_input = {}
command = upload.PerformUploadCommand('name', 'description', method, self.context)
command.perform_upload(self.context, upload_manager, upload_ids, user_input)
poll.assert_called_once_with([response.response_body], user_input)
def test_import_upload_step_succeeded(self, write, render_failure_message):
"""
Assert that the CLI properly informs the user when an importer reports success upon
importing a unit to the repository.
"""
response_body = {
'task_id': '123456',
'tags': [],
'start_time': datetime.datetime.now(),
'finish_time':
datetime.datetime.now() + datetime.timedelta(seconds=10),
'state': responses.STATE_FINISHED,
'progress_report': {},
'result': None,
'exception': None,
'traceback': None,
'error': None,
'spawned_tasks': []
}
response = mock.MagicMock()
response.response_body = responses.Task(response_body)
response.is_async = mock.MagicMock(return_value=False)
upload_manager = mock.MagicMock()
upload_manager.import_upload = mock.MagicMock(return_value=response)
upload_ids = ['an_id']
method = mock.MagicMock()
user_input = {}
command = upload.PerformUploadCommand('name', 'description', method,
self.context)
command.perform_upload(self.context, upload_manager, upload_ids,
user_input)
write.assert_any_call('... completed')
write.assert_any_call('Task Succeeded',
color='\x1b[92m',
tag='succeeded')
# No errors should have been rendered
self.assertEqual(render_failure_message.call_count, 0)
def test_run_already_in_progress(self, mock_publish, mock_search,
mock_poll):
"""
Test the run() method when thre is already an incomplete publish operation.
"""
repo_id = 'test-repo'
data = {
options.OPTION_REPO_ID.keyword: repo_id,
polling.FLAG_BACKGROUND.keyword: False,
sp.FLAG_FORCE_FULL.keyword: False
}
# Simulate a task already running
task_data = copy.copy(CALL_REPORT_TEMPLATE)
task_data['state'] = 'running'
task = responses.Task(task_data)
mock_search.return_value = [task]
self.command.run(**data)
# Publish shouldn't get called again since it's already running
self.assertEqual(mock_publish.call_count, 0)
expected_search_query = {
'state': {
'$nin': responses.COMPLETED_STATES
},
'tags': {
'$all': [
tags.resource_tag(tags.RESOURCE_REPOSITORY_TYPE, repo_id),
tags.action_tag(tags.ACTION_PUBLISH_TYPE)
]
}
}
mock_search.assert_called_once_with(filters=expected_search_query)
mock_poll.assert_called_once_with([task], data)
write_tags = self.prompt.get_write_tags()
self.assertEqual(2, len(write_tags))
self.assertEqual(write_tags[1], 'in-progress')
def test_run_already_in_progress(self, mock_sync, mock_search, poll):
"""
Test the run() method when there is an existing sync Task on the server.
"""
repo_id = 'test-repo'
data = {
options.OPTION_REPO_ID.keyword: repo_id,
polling.FLAG_BACKGROUND.keyword: False,
sp.FLAG_FORCE_FULL_SYNC.keyword: False
}
# Simulate a task already running
task_data = copy.copy(CALL_REPORT_TEMPLATE)
task_data['state'] = 'running'
task = responses.Task(task_data)
mock_search.return_value = [task]
self.command.run(**data)
self.assertEqual(mock_sync.call_count, 0)
sync_tasks = poll.mock_calls[0][1][0]
expected_search_query = {
'state': {
'$nin': responses.COMPLETED_STATES
},
'tags': {
'$all': [
tags.resource_tag(tags.RESOURCE_REPOSITORY_TYPE, repo_id),
tags.action_tag(tags.ACTION_SYNC_TYPE)
]
}
}
mock_search.assert_called_once_with(filters=expected_search_query)
poll.assert_called_once_with(sync_tasks, data)
write_tags = self.prompt.get_write_tags()
self.assertEqual(2, len(write_tags))
self.assertEqual(write_tags[1], 'in-progress')
def test___init___with_href(self):
"""
There isn't always an _href in the response data. Assert that we handle it when it is
present.
"""
some_typical_data = {
u'_href':
u'/pulp/api/v2/tasks/9efb5da2-ff42-4633-9355-81385bd43310',
u'task_id':
u'9efb5da2-ff42-4633-9355-81385bd43310',
u'tags': [u'pulp:repository:zoo', u'pulp:action:sync'],
u'finish_time':
1392054742,
u'_ns':
u'task_status',
u'start_time':
1392054740,
u'spawned_tasks': [{
u'_href':
u'/pulp/api/v2/tasks/37506910-dc71-46c4-809e-48cf385b803f/',
u'task_id':
u'37506910-dc71-46c4-809e-48cf385b803f'
}],
u'progress_report': {
u'some': u'data'
},
u'queue':
u'*****@*****.**',
u'state':
u'finished',
u'result': {
u'some': u'return data'
},
u'_id': {
u'$oid': u'52f911d4b8b0edc2462f61a2'
}
}
a_task = responses.Task(some_typical_data)
self.assertEqual(a_task.href, some_typical_data['_href'])
self.assertEqual(a_task.task_id, some_typical_data['task_id'])
self.assertEqual(a_task.tags, some_typical_data['tags'])
self.assertEqual(a_task.start_time, some_typical_data['start_time'])
self.assertEqual(a_task.finish_time, some_typical_data['finish_time'])
self.assertEqual(a_task.state, some_typical_data['state'])
self.assertEqual(a_task.progress_report,
some_typical_data['progress_report'])
self.assertEqual(a_task.result, some_typical_data['result'])
# exception, traceback and error default to None when it isn't provided in the response data
self.assertEqual(a_task.exception, None)
self.assertEqual(a_task.traceback, None)
self.assertEqual(a_task.error, None)
# Spawned tasks end up being Task objects, so we'll need to inspect more manually
self.assertEqual(len(a_task.spawned_tasks), 1)
self.assertEqual(type(a_task.spawned_tasks), list)
self.assertEqual(type(a_task.spawned_tasks[0]), responses.Task)
self.assertEqual(a_task.spawned_tasks[0].href,
some_typical_data['spawned_tasks'][0]['_href'])
self.assertEqual(a_task.spawned_tasks[0].task_id,
some_typical_data['spawned_tasks'][0]['task_id'])
