def test_oauth_authentication(mocked_authenticate, webserver):
"""Test oauth_authentication."""
fake_url = Mock()
storage = Mock(BasicStorage)
storage.grant_url = Mock(return_value=fake_url)
mocked_server = Mock(OAuthHTTPServer)
mocked_server.shutdown = Mock(side_effect=OSError)
mocked_server.socket = Mock(return_value='bla')
mocked_server.done_event = Mock()
if webserver:
mocked_server.result = 'fake_result'
else:
mocked_server.result = None
credentials = 'fake_credentials'
identifier = 'fake_identifier'
auth_return = (None, credentials, identifier)
storage.authenticate = Mock(return_value=auth_return)
mocked_authenticate.storage = storage
with patch('cc.client.OAuthHTTPServer', return_value=mocked_server) as mock_oauth, \
patch('cc.client.webbrowser') as mocked_webbrowser:
StorageAuthenticator._oauth_authentication(mocked_authenticate, False)
mock_oauth.assert_called_with(fake_url.check_function)
mocked_webbrowser.open.assert_called_with(fake_url.grant_url)
assert mocked_server.shutdown.called_once()
assert mocked_server.socket.close.called_once()
assert mocked_server.socket.shutdown.called_once()
if webserver:
assert mocked_authenticate.auth_data['credentials'] == credentials
assert mocked_authenticate.auth_data['identifier'] == identifier
else:
assert mocked_authenticate.auth_data == {}
def test_is_success(self):
self.task.query_extra_data_for_test_task = Mock()
tt = TaskTester(self.task, self.path, Mock(), Mock())
task_thread = Mock()
# Proper task
task_thread.error = None
task_thread.result = ({"data": True}, 123)
assert tt.is_success(task_thread)
# Task thead result first arg is not tuple
task_thread.result = {"data": True}
assert not tt.is_success(task_thread)
assert task_thread.error == "Wrong result format"
def test_success(self, UrlFetchClassMock):
# Mocking pagseguro Fetch
UrlFetchClassMock.return_value = _build_mock()
# Mocking previous command
data_cmd_mock = Mock()
data_cmd_mock.access_data.email = '*****@*****.**'
data_cmd_mock.access_data.token = '4567890oiuytfgh'
reference0 = ItemReferenceMock()
reference1 = ItemReferenceMock()
items = [PagSegItem(description='Python Course', price=Decimal('120'), quantity=1, reference=reference0.key),
PagSegItem(description='Another Python Course', price=Decimal('240'), quantity=2,
reference=reference1.key)]
ndb.put_multi(items)
data_cmd_mock.items = items
data_cmd_mock.client_form = ValidateClientCmd(email='*****@*****.**', name='Jhon Doe').form
data_cmd_mock.address_form = pagseguro_facade.validate_address_cmd('Rua 1', '2', 'meu bairro', '12345678',
'São Paulo', 'SP', 'apto 4').form
payment = PagSegPayment()
payment.put()
data_cmd_mock.result = payment
contact_pagseguro_cmd = ContactPagseguro('https://store.com/pagseguro')
CommandSequential(data_cmd_mock, contact_pagseguro_cmd).execute()
self.assertEqual(payment, contact_pagseguro_cmd.result)
self.assertEqual(payment.status, STATUS_SENT_TO_PAGSEGURO)
self.assertEqual(contact_pagseguro_cmd.checkout_code, _SUCCESS_PAGSEGURO_CODE,
'Should have the code extracted from xml _PAGSEGURO_DETAIL_XML')
self.assertIsNone(payment.code)
def test_get_user_stack_status_resume_after_suspend(self):
self.init_block()
now = int(time.time())
suspend_timeout = self.block.configuration.get("suspend_timeout")
suspend_timestamp = now - suspend_timeout
self.block.stacks = {
self.block.stack_name: {
"suspend_timestamp": suspend_timestamp,
"status": {"status": "CREATE_COMPLETE"}
}
}
mock_result = Mock()
mock_result.ready.return_value = True
mock_result.successful.return_value = True
mock_result.result = {"status": "RESUME_COMPLETE"}
mock_launch_stack_task=Mock(return_value=mock_result)
mock_suspend_user_stack=Mock()
with patch.multiple(self.block,
launch_stack_task=mock_launch_stack_task,
suspend_user_stack=mock_suspend_user_stack
):
data = {
"initialize": True,
"reset": False
}
result = self.call_handler("get_user_stack_status", data)
self.assertEqual(result, mock_result.result)
self.assertTrue(mock_launch_stack_task.called)
self.assertTrue(mock_suspend_user_stack.called)
def test_run_interactive(capfd):
"""Ensure the calls to run a command on a list of hosts interactively."""
runner = Bladerunner({"threads": 14})
fake_result = Mock()
fake_result.result = Mock(return_value="fake results")
mock_con = Mock()
runner.interactive_hosts = {"fake host": mock_con}
fake_thread = Mock()
fake_thread.__enter__ = fake_context
fake_thread.__exit__ = fake_context
fake_thread.submit = Mock(return_value=fake_result)
threadpool_mock = patch.object(
base,
"ThreadPoolExecutor",
return_value=fake_thread,
)
with patch.object(runner, "setup_interactive") as mock_setup:
with threadpool_mock as mock_threadpool:
runner.run_interactive("fake cmd", "fake host")
mock_setup.assert_called_once_with("fake host")
mock_threadpool.assert_called_once_with(max_workers=14)
stdout, stderr = capfd.readouterr()
assert stdout == "fake host: fake results\n"
assert stderr == ""
def test_no_logged_user(self, cookie_facade):
cmd_mock = Mock()
cmd_mock.execute = Mock(return_value=cmd_mock)
cmd_mock.result = None
cookie_facade.retrive_cookie_data = Mock(return_value=cmd_mock)
result = facade.logged_user(None).execute().result
self.assertIsNone(result)
def test_run_interactive_returns():
"""Confirm the dict return when print_results is False."""
runner = Bladerunner({"threads": 17})
fake_result = Mock()
fake_result.result = Mock(return_value="some result")
mock_con = Mock()
runner.interactive_hosts = {"host": mock_con}
fake_thread = Mock()
fake_thread.__enter__ = fake_context
fake_thread.__exit__ = fake_context
fake_thread.submit = Mock(return_value=fake_result)
threadpool_mock = patch.object(
base,
"ThreadPoolExecutor",
return_value=fake_thread,
)
with patch.object(runner, "setup_interactive") as mock_setup:
with threadpool_mock as mock_threadpool:
results = runner.run_interactive("ok", "host", print_results=False)
mock_setup.assert_called_once_with("host")
mock_threadpool.assert_called_once_with(max_workers=17)
assert results == {"host": "some result"}
def test_get_user_stack_status_reset_before_suspend(self):
self.init_block()
suspend_timeout = self.block.configuration.get("suspend_timeout")
timedelta = timezone.timedelta(seconds=(suspend_timeout - 1))
suspend_timestamp = timezone.now() - timedelta
course_id, student_id = self.block.get_block_ids()
stack, _ = hastexo.models.Stack.objects.get_or_create(
student_id=student_id,
course_id=course_id,
name=self.block.stack_name,
suspend_timestamp=suspend_timestamp,
status='RESUME_COMPLETE'
)
mock_result = Mock()
mock_result.id = 'bogus_task_id'
mock_result.ready.return_value = True
mock_result.successful.return_value = True
mock_result.result = {"status": "CREATE_COMPLETE"}
mock_launch_stack_task = Mock(return_value=mock_result)
mock_get_stack_template = Mock(return_value=('bogus_stack_template'))
with patch.multiple(self.block,
launch_stack_task=mock_launch_stack_task,
get_stack_template=mock_get_stack_template):
data = {
"initialize": True,
"reset": True
}
result = self.call_handler("get_user_stack_status", data)
self.assertEqual(result, mock_result.result)
self.assertTrue(mock_launch_stack_task.called)
def test_scheduler_requeues_on_rwc_failure(in_memory_queue_connection,
default_in_memory_producer,
consume_queue):
"""Test scheduler requeues requests if RWC fails to start workflows."""
scheduler = WorkflowExecutionScheduler(
connection=in_memory_queue_connection)
in_memory_wsp = WorkflowSubmissionPublisher(
connection=in_memory_queue_connection)
in_memory_wsp.publish_workflow_submission("1", "workflow.1", {})
mock_rwc_api_client = Mock()
mock_result_obj = Mock()
mock_response = Mock()
mock_response.status_code = 502
mock_result_obj.result = Mock(side_effect=HTTPError(
mock_response, message="DB connection timed out."))
mock_rwc_api_client.api.set_workflow_status.return_value = mock_result_obj
with patch.multiple(
"reana_server.scheduler",
reana_ready=Mock(return_value=True),
current_rwc_api_client=mock_rwc_api_client,
current_workflow_submission_publisher=in_memory_wsp,
):
consume_queue(scheduler, limit=1)
assert (not in_memory_queue_connection.channel().
queues["workflow-submission"].empty())
def test_save_payment_arcs_command_mocked(self):
command_with_item_forms = Mock()
items = [
PagSegItem(description='Python Birds',
price=Decimal('18.99'),
quantity=3),
PagSegItem(description='Objetos Pythônicos',
price=Decimal('24.99'),
quantity=2,
reference=ndb.Key(PagSegItem, 10))
]
command_with_item_forms.items = items
ndb.put_multi(items)
payment = mommy.save_one(PagSegPayment)
command_with_item_forms.result = payment
payment_owner = mommy.save_one(Node)
save_payment_arcs_cmd = SavePaymentArcsCmd(payment_owner)
CommandSequential(command_with_item_forms,
save_payment_arcs_cmd).execute()
self.assertEqual(payment,
pagseguro_facade.search_payments(payment_owner)()[0])
logs = SearchLogs(payment)()
self.assertEqual(1, len(logs))
self.assertEqual(STATUS_CREATED, logs[0].status)
self.assertListEqual(items, SearchItems(payment)())
def test_run_interactive_returns():
"""Confirm the dict return when print_results is False."""
runner = Bladerunner({"threads": 17})
fake_result = Mock()
fake_result.result = Mock(return_value="some result")
mock_con = Mock()
runner.interactive_hosts = {"host": mock_con}
fake_thread = Mock()
fake_thread.__enter__ = fake_context
fake_thread.__exit__ = fake_context
fake_thread.submit = Mock(return_value=fake_result)
threadpool_mock = patch.object(
base,
"ThreadPoolExecutor",
return_value=fake_thread,
)
with patch.object(runner, "setup_interactive") as mock_setup:
with threadpool_mock as mock_threadpool:
results = runner.run_interactive("ok", "host", print_results=False)
mock_setup.assert_called_once_with("host")
mock_threadpool.assert_called_once_with(max_workers=17)
assert results == {"host": "some result"}
def test_save_item_arcs_command(self):
command_with_item_forms = Mock()
access_data = CreateOrUpdateAccessData('*****@*****.**', 'abc1234')()
items = [PagSegItem(description='Python Birds', price=Decimal('18.99'), quantity=3),
PagSegItem(description='Objetos Pythônicos', price=Decimal('24.99'), quantity=2,
reference=ndb.Key(PagSegItem, 10))]
command_with_item_forms.items = items
address_form_mock = Mock()
client_form_mock = Mock()
command_with_item_forms.address_form = address_form_mock
command_with_item_forms.client_form = client_form_mock
command_with_item_forms.access_data = access_data
ndb.put_multi(items)
payment = mommy.save_one(PagSegPayment)
command_with_item_forms.result = payment
save_payment_to_items_arcs_cmd = SavePaymentToItemsArcs()
CommandSequential(command_with_item_forms, save_payment_to_items_arcs_cmd).execute()
self.assertListEqual(items, SearchItems(payment)())
self.assertListEqual(items, save_payment_to_items_arcs_cmd.items)
# Data used for sequential commands
self.assertEqual('*****@*****.**', save_payment_to_items_arcs_cmd.access_data.email)
self.assertEqual('abc1234', save_payment_to_items_arcs_cmd.access_data.token)
self.assertEqual(save_payment_to_items_arcs_cmd.address_form, address_form_mock)
self.assertEqual(save_payment_to_items_arcs_cmd.client_form, client_form_mock)
def test_run_interactive(capfd):
"""Ensure the calls to run a command on a list of hosts interactively."""
runner = Bladerunner({"threads": 14})
fake_result = Mock()
fake_result.result = Mock(return_value="fake results")
mock_con = Mock()
runner.interactive_hosts = {"fake host": mock_con}
fake_thread = Mock()
fake_thread.__enter__ = fake_context
fake_thread.__exit__ = fake_context
fake_thread.submit = Mock(return_value=fake_result)
threadpool_mock = patch.object(
base,
"ThreadPoolExecutor",
return_value=fake_thread,
)
with patch.object(runner, "setup_interactive") as mock_setup:
with threadpool_mock as mock_threadpool:
runner.run_interactive("fake cmd", "fake host")
mock_setup.assert_called_once_with("fake host")
mock_threadpool.assert_called_once_with(max_workers=14)
stdout, stderr = capfd.readouterr()
assert stdout == "fake host: fake results\n"
assert stderr == ""
def test_logged_user(self, cookie_facade):
user = mommy.save_one(MainUser)
cmd_mock = Mock()
cmd_mock.execute = Mock(return_value=cmd_mock)
cmd_mock.result = {'id': user.key.id()}
cookie_facade.retrive_cookie_data = Mock(return_value=cmd_mock)
result = facade.logged_user(None).execute().result
self.assertEqual(user, result)
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or (["{}"], "", 0)
conn = Mock()
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.result = Mock(return_value=conn)
return conn
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or (['{}'], '', 0)
conn = Mock()
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.result = Mock(return_value=conn)
return conn
def mock_protocol():
mproto = Mock(RPCProtocol)
foo = Mock(RPCResponse)
foo.result = None
mproto.parse_reply = Mock(return_value=foo)
return mproto
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 make_fake_conn(receive_returns=None):
receive_returns = receive_returns or (['{}'], '', 0)
conn = Mock()
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.gateway.remote_exec = conn.receive
conn.result = Mock(return_value=conn)
return conn
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 mock_protocol():
mproto = Mock(RPCProtocol)
foo = Mock(RPCResponse)
foo.result = None
mproto.parse_reply = Mock(return_value=foo)
return mproto
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or ([b'{}'], [], 0)
conn = Mock()
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.gateway.remote_exec = conn.receive
conn.result = Mock(return_value=conn)
return conn
def test_no_logged_user(self, facade):
cmd_mock = Mock()
cmd_mock.execute = Mock(return_value=cmd_mock)
cmd_mock.result = None
facade.logged_user = Mock(return_value=cmd_mock)
dependency = {}
middleware.LoggedUserMiddleware(Mock(), dependency, Mock()).set_up()
self.assertEqual({'_login_path': '/login',
'_logout_path': '/logout',
'_logged_user': None}, dependency)
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or ([b'{}'], [], 0)
conn = Mock()
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.gateway.remote_exec = conn.receive
conn.result = Mock(return_value=conn)
conn.cmd = lambda x: x
return conn
def test_save_payment_to_log_command(self):
command_with_item_forms = Mock()
payment = mommy.save_one(PagSegPayment)
command_with_item_forms.result = payment
save_payment_to_log_cmd = SavePaymentToLog()
CommandSequential(command_with_item_forms, save_payment_to_log_cmd).execute()
logs = SearchLogs(payment)()
self.assertEqual(1, len(logs))
self.assertEqual(STATUS_CREATED, logs[0].status)
def make_fake_conn(receive_returns=None):
receive_returns = receive_returns or (['{}'], [], 0)
conn = Mock()
conn.cmd = lambda x: x
conn.sudo = ''
conn.return_value = conn
conn.execute = conn
conn.receive = Mock(return_value=receive_returns)
conn.gateway.remote_exec = conn.receive
conn.result = Mock(return_value=conn)
conn.cmd = lambda x: x
return conn
def test_logged_user(self, facade):
user = mommy.save_one(MainUser)
user.put()
cmd_mock = Mock()
cmd_mock.execute = Mock(return_value=cmd_mock)
cmd_mock.result = user
facade.logged_user = Mock(return_value=cmd_mock)
dependency = {}
middleware.LoggedUserMiddleware(Mock(), dependency, Mock()).set_up()
self.assertEqual({'_login_path': None,
'_logout_path': '/logout',
'_logged_user': user}, dependency)
def test_no_logged_user(self, facade):
cmd_mock = Mock()
cmd_mock.execute = Mock(return_value=cmd_mock)
cmd_mock.result = None
facade.logged_user = Mock(return_value=cmd_mock)
dependency = {}
handler = Mock()
handler.request.path_qs='/foo?param1=1¶m2=2'
middleware.LoggedUserMiddleware(handler, dependency, Mock()).set_up()
self.assertEqual({'_login_path': '/login?ret_path=%2Ffoo%3Fparam1%3D1%26param2%3D2',
'_logout_path': None,
'_logged_user': None}, dependency)
def create_mock_status_query_result(cls, scheduleStatus):
mock_query_result = Mock(spec=Response)
mock_query_result.result = Mock(spec=Result)
mock_query_result.result.scheduleStatusResult = Mock(spec=ScheduleStatusResult)
if scheduleStatus == ScheduleStatus.INIT:
# status query result for before job is launched.
mock_query_result.result.scheduleStatusResult.tasks = []
else:
mock_task_one = cls.create_mock_task('hello', 0, 1000, scheduleStatus)
mock_task_two = cls.create_mock_task('hello', 1, 1004, scheduleStatus)
mock_query_result.result.scheduleStatusResult.tasks = [mock_task_one, mock_task_two]
return mock_query_result
def test_buildsetFinished_sends_email(self):
fakeBuildMessage = Mock()
mn = MailNotifier('*****@*****.**',
buildSetSummary=True,
mode="all",
builders=["Builder"])
mn.buildMessage = fakeBuildMessage
def fakeGetBuild(number):
return build
def fakeGetBuilder(buildername):
if buildername == builder.name:
return builder
return None
def fakeGetBuildRequests(self, bsid):
return defer.succeed([{"buildername":"Builder", "brid":1}])
builder = Mock()
builder.getBuild = fakeGetBuild
builder.name = "Builder"
build = Mock()
build.result = FAILURE
build.finished = True
build.reason = "testReason"
build.builder = builder
build.getBuilder = Mock()
build.getBuilder.return_value = builder
self.db = fakedb.FakeDBConnector(self)
self.db.insertTestData([fakedb.Buildset(id=99, sourcestampid=127,
results=SUCCESS,
reason="testReason"),
fakedb.BuildRequest(id=11, buildsetid=99,
buildername='Builder'),
fakedb.Build(number=0, brid=11, results=SUCCESS)
])
mn.master = self # FIXME: Should be FakeMaster
self.status = Mock()
mn.master_status = Mock()
mn.master_status.getBuilder = fakeGetBuilder
mn.buildMessageDict = Mock()
mn.buildMessageDict.return_value = {"body":"body", "type":"text",
"subject":"subject"}
mn.buildsetFinished(99, FAILURE)
fakeBuildMessage.assert_called_with("Buildset Complete: testReason",
[build], SUCCESS)
def test_save_payment_to_log_command(self):
command_with_item_forms = Mock()
payment = mommy.save_one(PagSegPayment)
command_with_item_forms.result = payment
save_payment_to_log_cmd = SavePaymentToLog()
CommandSequential(command_with_item_forms,
save_payment_to_log_cmd).execute()
logs = SearchLogs(payment)()
self.assertEqual(1, len(logs))
self.assertEqual(STATUS_CREATED, logs[0].status)
def create_mock_status_query_result(cls, scheduleStatus):
mock_query_result = Mock(spec=Response)
mock_query_result.result = Mock(spec=Result)
mock_query_result.result.scheduleStatusResult = Mock(spec=ScheduleStatusResult)
if scheduleStatus == ScheduleStatus.INIT:
# status query result for before job is launched.
mock_query_result.result.scheduleStatusResult.tasks = []
else:
mock_task_one = cls.create_mock_task('hello', 0, 1000, scheduleStatus)
mock_task_two = cls.create_mock_task('hello', 1, 1004, scheduleStatus)
mock_query_result.result.scheduleStatusResult.tasks = [mock_task_one, mock_task_two]
return mock_query_result
def test_buildsetFinished_sends_email(self):
fakeBuildMessage = Mock()
mn = MailNotifier('*****@*****.**',
buildSetSummary=True,
mode="all",
builders=["Builder"])
mn.buildMessage = fakeBuildMessage
def fakeGetBuild(number):
return build
def fakeGetBuilder(buildername):
if buildername == builder.name:
return builder
return None
def fakeGetBuildRequests(self, bsid):
return defer.succeed([{"buildername":"Builder", "brid":1}])
builder = Mock()
builder.getBuild = fakeGetBuild
builder.name = "Builder"
build = Mock()
build.result = FAILURE
build.finished = True
build.reason = "testReason"
build.builder = builder
build.getBuilder = Mock()
build.getBuilder.return_value = builder
self.db = fakedb.FakeDBConnector(self)
self.db.insertTestData([fakedb.Buildset(id=99, sourcestampid=127,
results=SUCCESS,
reason="testReason"),
fakedb.BuildRequest(id=11, buildsetid=99,
buildername='Builder'),
fakedb.Build(number=0, brid=11, results=SUCCESS)
])
mn.parent = self
self.status = Mock()
mn.master_status = Mock()
mn.master_status.getBuilder = fakeGetBuilder
mn.buildMessageDict = Mock()
mn.buildMessageDict.return_value = {"body":"body", "type":"text",
"subject":"subject"}
mn.buildsetFinished(99, FAILURE)
fakeBuildMessage.assert_called_with("Buildset Complete: testReason",
[build], SUCCESS)
def test_execute(self, timeseries_mock):
response = Mock()
response.result = SAMPLE_DRUID_RESPONSE
self.test_druid_check = DRUID_CHECK.copy()
timeseries_mock.return_value = response
with patch('alamo_worker.plugins.druid.DruidPlugin.process') as proc:
self.druid.execute(self.test_druid_check)
self.assertTrue(proc.called)
proc.assert_called_once_with(
self.test_druid_check, SAMPLE_DRUID_RESPONSE
)
def test_autodetect_import_csv_raises_on_failure_to_detect_encoding(
self, mock_UniversalDetector):
mock_detector = Mock()
mock_UniversalDetector.return_value = mock_detector
mock_detector.result = {'encoding': None}
mock_file = StringIO()
mock_file.write("\xFF\x00\xFF")
mock_file.name = 'filename'
mock_file.size = 10
self.assertRaises(
DirigibleImportError,
lambda: worksheet_from_csv(Worksheet(), mock_file, 1, 1, False))
def _get_output_for_task_success(self, attempted, updated, total, student=None):
"""returns the task_id and the result returned by instructor_task_status()."""
# view task entry for task in progress
instructor_task = self._create_progress_entry(student)
task_id = instructor_task.task_id
mock_result = Mock()
mock_result.task_id = task_id
mock_result.state = SUCCESS
mock_result.result = {'attempted': attempted,
'updated': updated,
'total': total,
'action_name': 'rescored'}
output = self._test_get_status_from_result(task_id, mock_result)
return output
def test_autodetect_import_csv_raises_on_failure_to_detect_encoding(
self, mock_UniversalDetector
):
mock_detector = Mock()
mock_UniversalDetector.return_value = mock_detector
mock_detector.result = {'encoding':None}
mock_file = StringIO()
mock_file.write("\xFF\x00\xFF")
mock_file.name = 'filename'
mock_file.size = 10
self.assertRaises(DirigibleImportError,
lambda : worksheet_from_csv(Worksheet(), mock_file, 1, 1, False)
)
def test_update_payment_and_save_log_command(self):
command_with_item_forms = Mock()
payment = mommy.save_one(PagSegPayment, status=STATUS_CREATED)
command_with_item_forms.result = payment
payment.status = STATUS_SENT_TO_PAGSEGURO
save_payment_to_log_cmd = UpdatePaymentAndSaveLog()
CommandSequential(command_with_item_forms, save_payment_to_log_cmd).execute()
search = SearchLogs(payment)
logs = search()
self.assertEqual(1, len(logs))
self.assertEqual(STATUS_SENT_TO_PAGSEGURO, logs[0].status)
self.assertEqual(STATUS_SENT_TO_PAGSEGURO, payment.key.get().status)
self.assertEqual(save_payment_to_log_cmd.result, payment)
def test_update_payment_and_save_log_command(self):
command_with_item_forms = Mock()
payment = mommy.save_one(PagSegPayment, status=STATUS_CREATED)
command_with_item_forms.result = payment
payment.status = STATUS_SENT_TO_PAGSEGURO
save_payment_to_log_cmd = UpdatePaymentAndSaveLog()
CommandSequential(command_with_item_forms,
save_payment_to_log_cmd).execute()
search = SearchLogs(payment)
logs = search()
self.assertEqual(1, len(logs))
self.assertEqual(STATUS_SENT_TO_PAGSEGURO, logs[0].status)
self.assertEqual(STATUS_SENT_TO_PAGSEGURO, payment.key.get().status)
self.assertEqual(save_payment_to_log_cmd.result, payment)
def decorated(self, *args, **kwargs):
conn = Mock(name='conn')
tmp = Mock(name='tmp')
inject = Mock(name='inject')
if em_side_effect is None:
return_value = Mock(name='return_value')
return_value.is_successful = Mock(return_value=em_successful)
return_value.result = em_result
e_m = Mock(name='execute_module', return_value=return_value)
else:
e_m = Mock(side_effect=em_side_effect)
runner = Mock()
runner._execute_module = e_m
connection = self.connection_class(conn, tmp, inject, runner)
return method(self, connection, conn, tmp, inject, runner, e_m,
*args, **kwargs)
def create_getjobs_response(cls): result = Mock(spec=Response) result.responseCode = ResponseCode.OK result.result = Mock(spec=Result) result.result.getJobsResult = Mock(spec=GetJobsResult) mock_job_one = Mock(spec=JobConfiguration) mock_job_one.key = Mock(spec=JobKey) mock_job_one.key.role = 'RoleA' mock_job_one.key.environment = 'test' mock_job_one.key.name = 'hithere' mock_job_two = Mock(spec=JobConfiguration) mock_job_two.key = Mock(spec=JobKey) mock_job_two.key.role = 'bozo' mock_job_two.key.environment = 'test' mock_job_two.key.name = 'hello' result.result.getJobsResult.configs = [mock_job_one, mock_job_two] return result
def test_update_progress_to_progress(self):
# view task entry for task in progress
instructor_task = self._create_progress_entry()
task_id = instructor_task.task_id
mock_result = Mock()
mock_result.task_id = task_id
mock_result.state = PROGRESS
mock_result.result = {'attempted': 5,
'updated': 4,
'total': 10,
'action_name': 'rescored'}
output = self._test_get_status_from_result(task_id, mock_result)
self.assertEquals(output['message'], "Progress: rescored 4 of 5 so far (out of 10)")
self.assertEquals(output['succeeded'], False)
self.assertEquals(output['task_state'], PROGRESS)
self.assertTrue(output['in_progress'])
self.assertEquals(output['task_progress'], mock_result.result)
def create_getjobs_response(cls):
result = Mock()
result.responseCode = ResponseCode.OK
result.result = Mock()
result.result.getJobsResult = Mock()
mock_job_one = Mock()
mock_job_one.key = Mock()
mock_job_one.key.role = 'RoleA'
mock_job_one.key.environment = 'test'
mock_job_one.key.name = 'hithere'
mock_job_two = Mock()
mock_job_two.key = Mock()
mock_job_two.key.role = 'bozo'
mock_job_two.key.environment = 'test'
mock_job_two.key.name = 'hello'
result.result.getJobsResult.configs = [mock_job_one, mock_job_two]
return result
def test_update_progress_to_failure(self):
# view task entry for task in progress that later fails
instructor_task = self._create_progress_entry()
task_id = instructor_task.task_id
mock_result = Mock()
mock_result.task_id = task_id
mock_result.state = FAILURE
mock_result.result = NotImplementedError("This task later failed.")
mock_result.traceback = "random traceback"
output = self._test_get_status_from_result(task_id, mock_result)
self.assertEquals(output['message'], "This task later failed.")
self.assertEquals(output['succeeded'], False)
self.assertEquals(output['task_state'], FAILURE)
self.assertFalse(output['in_progress'])
expected_progress = {'exception': 'NotImplementedError',
'message': "This task later failed.",
'traceback': "random traceback"}
self.assertEquals(output['task_progress'], expected_progress)
def test_render_result(self, mako_template):
task = tasks.PythonTask()
task.result_template = 'result.mak'
task.task_dir = Mock(return_value='/tmp/task')
result = Mock(AsyncResult)
result.successful.return_value = True
result.result = {'query': 'myquery'}
from mako.template import Template
tpl = Mock(Template)
tpl.render.return_value = 'mytemplate'
mako_template.return_value = tpl
files = ['result.csv']
html = task.render_result(result, files)
self.assertEquals(html, 'mytemplate')
mako_template.assert_called_with(filename='/tmp/task/result.mak', output_encoding='utf-8')
tpl.render.assert_called_with(query='myquery', files=files)
def test_save_item_arcs_command(self):
command_with_item_forms = Mock()
access_data = CreateOrUpdateAccessData('*****@*****.**', 'abc1234')()
items = [
PagSegItem(description='Python Birds',
price=Decimal('18.99'),
quantity=3),
PagSegItem(description='Objetos Pythônicos',
price=Decimal('24.99'),
quantity=2,
reference=ndb.Key(PagSegItem, 10))
]
command_with_item_forms.items = items
address_form_mock = Mock()
client_form_mock = Mock()
command_with_item_forms.address_form = address_form_mock
command_with_item_forms.client_form = client_form_mock
command_with_item_forms.access_data = access_data
ndb.put_multi(items)
payment = mommy.save_one(PagSegPayment)
command_with_item_forms.result = payment
save_payment_to_items_arcs_cmd = SavePaymentToItemsArcs()
CommandSequential(command_with_item_forms,
save_payment_to_items_arcs_cmd).execute()
self.assertListEqual(items, SearchItems(payment)())
self.assertListEqual(items, save_payment_to_items_arcs_cmd.items)
# Data used for sequential commands
self.assertEqual('*****@*****.**',
save_payment_to_items_arcs_cmd.access_data.email)
self.assertEqual('abc1234',
save_payment_to_items_arcs_cmd.access_data.token)
self.assertEqual(save_payment_to_items_arcs_cmd.address_form,
address_form_mock)
self.assertEqual(save_payment_to_items_arcs_cmd.client_form,
client_form_mock)
def _get_output_for_task_success(self,
attempted,
succeeded,
total,
student=None):
"""returns the task_id and the result returned by instructor_task_status()."""
# view task entry for task in progress
instructor_task = self._create_progress_entry(student)
task_id = instructor_task.task_id
mock_result = Mock()
mock_result.task_id = task_id
mock_result.state = SUCCESS
mock_result.result = {
'attempted': attempted,
'succeeded': succeeded,
'total': total,
'action_name': 'rescored',
}
output = self._test_get_status_from_result(task_id, mock_result)
return output
def test_update_progress_to_failure(self):
# view task entry for task in progress that later fails
instructor_task = self._create_progress_entry()
task_id = instructor_task.task_id
mock_result = Mock()
mock_result.task_id = task_id
mock_result.state = FAILURE
mock_result.result = NotImplementedError("This task later failed.")
mock_result.traceback = "random traceback"
output = self._test_get_status_from_result(task_id, mock_result)
self.assertEquals(output['message'], "This task later failed.")
self.assertEquals(output['succeeded'], False)
self.assertEquals(output['task_state'], FAILURE)
self.assertFalse(output['in_progress'])
expected_progress = {
'exception': 'NotImplementedError',
'message': "This task later failed.",
'traceback': "random traceback",
}
self.assertEquals(output['task_progress'], expected_progress)
def test_update_progress_to_progress(self):
# view task entry for task in progress
instructor_task = self._create_progress_entry()
task_id = instructor_task.task_id
mock_result = Mock()
mock_result.task_id = task_id
mock_result.state = PROGRESS
mock_result.result = {
'attempted': 5,
'succeeded': 4,
'total': 10,
'action_name': 'rescored',
}
output = self._test_get_status_from_result(task_id, mock_result)
self.assertEquals(output['message'],
"Progress: rescored 4 of 5 so far (out of 10)")
self.assertEquals(output['succeeded'], False)
self.assertEquals(output['task_state'], PROGRESS)
self.assertTrue(output['in_progress'])
self.assertEquals(output['task_progress'], mock_result.result)
def test_display_valid_syspurpose_role(self, mock_syspurpose_sync, mock_syspurpose):
mock_syspurpose.read = Mock()
mock_syspurpose.read.return_value = Mock()
instance_syspurpose_store = mock_syspurpose.read.return_value
instance_syspurpose_store.contents = {"role": "Foo"}
self.cc.options = Mock(spec=["set", "unset"])
self.cc.options.set = None
self.cc.options.unset = False
mock_syspurpose_sync.return_value = Mock()
instance_mock_syspurpose_sync = mock_syspurpose_sync.return_value
mock_sync_result = Mock()
mock_sync_result.result = {"role": "Foo"}
instance_mock_syspurpose_sync.perform = Mock(return_value=({}, mock_sync_result))
with Capture() as cap:
self.cc._do_command()
self.assertIn("Current Role: Foo", cap.out)
def test_success(self, UrlFetchClassMock):
# Mocking pagseguro Fetch
UrlFetchClassMock.return_value = _build_mock()
# Mocking previous command
data_cmd_mock = Mock()
data_cmd_mock.access_data.email = '*****@*****.**'
data_cmd_mock.access_data.token = '4567890oiuytfgh'
reference0 = ItemReferenceMock()
reference1 = ItemReferenceMock()
items = [
PagSegItem(description='Python Course',
price=Decimal('120'),
quantity=1,
reference=reference0.key),
PagSegItem(description='Another Python Course',
price=Decimal('240'),
quantity=2,
reference=reference1.key)
]
ndb.put_multi(items)
data_cmd_mock.items = items
data_cmd_mock.client_form = ValidateClientCmd(email='*****@*****.**',
name='Jhon Doe').form
data_cmd_mock.address_form = pagseguro_facade.validate_address_cmd(
'Rua 1', '2', 'meu bairro', '12345678', 'São Paulo', 'SP',
'apto 4').form
payment = PagSegPayment()
payment.put()
data_cmd_mock.result = payment
contact_pagseguro_cmd = ContactPagseguro('https://store.com/pagseguro')
CommandSequential(data_cmd_mock, contact_pagseguro_cmd).execute()
self.assertEqual(payment, contact_pagseguro_cmd.result)
self.assertEqual(payment.status, STATUS_SENT_TO_PAGSEGURO)
self.assertEqual(
contact_pagseguro_cmd.checkout_code, _SUCCESS_PAGSEGURO_CODE,
'Should have the code extracted from xml _PAGSEGURO_DETAIL_XML')
self.assertIsNone(payment.code)
def test_get_check_status(self):
self.init_block()
mock_result = Mock()
mock_result.id = 'bogus_task_id'
mock_result.ready.return_value = True
mock_result.successful.return_value = True
mock_result.result = {
"status": 'CHECK_PROGRESS_COMPLETE',
"pass": 1,
"total": 1
}
with patch.object(self.block, 'check_progress_task') as mock_task:
with patch.object(self.block.runtime, 'publish') as mock_publish:
mock_task.return_value = mock_result
result = self.call_handler("get_check_status", {})
self.assertEqual(result, mock_result.result)
self.assertTrue(mock_task.called)
mock_publish.assert_called_once_with(self.block, 'grade', {
'value': 1,
'max_value': 1
})
def test_get_user_stack_status_first_time(self):
self.init_block()
mock_result = Mock()
mock_result.id = 'bogus_task_id'
mock_result.ready.return_value = True
mock_result.successful.return_value = True
mock_result.result = {"status": "CREATE_COMPLETE"}
mock_launch_stack_task = Mock(return_value=mock_result)
mock_get_stack_template = Mock(return_value=('bogus_stack_template'))
with patch.multiple(self.block,
launch_stack_task=mock_launch_stack_task,
get_stack_template=mock_get_stack_template):
data = {
"initialize": True,
"reset": False
}
result = self.call_handler("get_user_stack_status", data)
self.assertEqual(result, mock_result.result)
self.assertTrue(mock_launch_stack_task.called)
def test_save_payment_arcs_command_mocked(self):
command_with_item_forms = Mock()
items = [PagSegItem(description='Python Birds', price=Decimal('18.99'), quantity=3),
PagSegItem(description='Objetos Pythônicos', price=Decimal('24.99'), quantity=2,
reference=ndb.Key(PagSegItem, 10))]
command_with_item_forms.items = items
ndb.put_multi(items)
payment = mommy.save_one(PagSegPayment)
command_with_item_forms.result = payment
payment_owner = mommy.save_one(Node)
save_payment_arcs_cmd = SavePaymentArcsCmd(payment_owner)
CommandSequential(command_with_item_forms, save_payment_arcs_cmd).execute()
self.assertEqual(payment, pagseguro_facade.search_payments(payment_owner)()[0])
logs = SearchLogs(payment)()
self.assertEqual(1, len(logs))
self.assertEqual(STATUS_CREATED, logs[0].status)
self.assertListEqual(items, SearchItems(payment)())
def test_get_user_stack_status_first_time(self):
self.init_block()
mock_result = Mock()
mock_result.ready.return_value = True
mock_result.successful.return_value = True
mock_result.result = {"status": "CREATE_COMPLETE"}
mock_launch_stack_task=Mock(return_value=mock_result)
mock_suspend_user_stack=Mock()
with patch.multiple(self.block,
launch_stack_task=mock_launch_stack_task,
suspend_user_stack=mock_suspend_user_stack
):
data = {
"initialize": True,
"reset": False
}
result = self.call_handler("get_user_stack_status", data)
self.assertEqual(result, mock_result.result)
self.assertTrue(mock_launch_stack_task.called)
self.assertTrue(mock_suspend_user_stack.called)
def create_status_call_result(cls):
"""Set up the mock status call that will be used to get a task list for
a batched kill command.
"""
status_response = Mock(spec=Response)
status_response.responseCode = ResponseCode.OK
status_response.messageDEPRECATED = "Ok"
status_response.result = Mock(spec=Result)
schedule_status = Mock(spec=ScheduleStatusResult)
status_response.result.scheduleStatusResult = schedule_status
mock_task_config = Mock()
# This should be a list of ScheduledTask's.
schedule_status.tasks = []
for i in range(20):
task_status = Mock(spec=ScheduledTask)
task_status.assignedTask = Mock(spec=AssignedTask)
task_status.assignedTask.instanceId = i
task_status.assignedTask.taskId = "Task%s" % i
task_status.assignedTask.slaveId = "Slave%s" % i
task_status.slaveHost = "Slave%s" % i
task_status.assignedTask.task = mock_task_config
schedule_status.tasks.append(task_status)
return status_response
def create_status_call_result(cls):
"""Set up the mock status call that will be used to get a task list for
a batched kill command.
"""
status_response = Mock(spec=Response)
status_response.responseCode = ResponseCode.OK
status_response.messageDEPRECATED = "Ok"
status_response.result = Mock(spec=Result)
schedule_status = Mock(spec=ScheduleStatusResult)
status_response.result.scheduleStatusResult = schedule_status
mock_task_config = Mock()
# This should be a list of ScheduledTask's.
schedule_status.tasks = []
for i in range(20):
task_status = Mock(spec=ScheduledTask)
task_status.assignedTask = Mock(spec=AssignedTask)
task_status.assignedTask.instanceId = i
task_status.assignedTask.taskId = "Task%s" % i
task_status.assignedTask.slaveId = "Slave%s" % i
task_status.slaveHost = "Slave%s" % i
task_status.assignedTask.task = mock_task_config
schedule_status.tasks.append(task_status)
return status_response
from mock import Mock
from celery import Task
from celery.result import AsyncResult, states as CeleryState
MockTaskChain = Mock(spec=Task, id="result-id")
MockTask = Mock(spec=Task, id="result-id", return_value=MockTaskChain)
MockTask.attach_mock(MockTask, "s")
MockTask.attach_mock(MockTask, "delay")
MockAsyncResultPartial = Mock(spec=AsyncResult)
MockAsyncResultPartial.attach_mock(Mock(return_value=True), "ready")
MockAsyncResultPartial.status = CeleryState.SUCCESS
MockAsyncResultPartial.result = (
[1, 2, 3],
[4, 5],
)
MockAsyncResultSuccess = Mock(spec=AsyncResult)
MockAsyncResultSuccess.attach_mock(Mock(return_value=True), "ready")
MockAsyncResultSuccess.status = CeleryState.SUCCESS
MockAsyncResultSuccess.result = (
[1, 2, 3],
[],
)
MockAsyncResultError = Mock(spec=AsyncResult)
MockAsyncResultError.attach_mock(Mock(return_value=True), "ready")
MockAsyncResultError.status = CeleryState.FAILURE
MockAsyncResultWaiting = Mock(spec=AsyncResult)
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 mock_job_result(result):
job_result = Mock(spec=JobResult)
job_result.is_done.return_value = True
job_result.result = {'result': [result]}
return job_result
