def test_format(self): req = MagicMock() resp = MagicMock() resp.body = {"example": "JSON"} resp.content_type = None hook_format(req, resp) resp.body = '{"example": "JSON"}' resp.content_type = 'application/json'
def test_parseRequestBody(self): req = MagicMock() req.body = '{"key":"value"}' data = self.rest_app._parseRequestBody(req) self.assertEqual(data, {'key': 'value'}) self.assertEqual(data.keys(), ['key']) self.assertEqual(type(data.keys()[0]), str) # test some bad data req.body = '{aaaaaaa}' self.assertRaises(HTTPBadRequest, self.rest_app._parseRequestBody, req)
def remove_public_id(self, last_public_id, original_id, HTTPCallbackGroup, get_associated_privates, get_associated_publics, _delete_number): # Setup HTTPCallbackGroup.return_value = MagicMock() on_success_handler = MagicMock() on_failure_handler = MagicMock() self.handler.forward_error = MagicMock() if original_id: sip_uri = SIP_URI else: sip_uri = SIP_URI2 # Test numbers.remove_public_id(self.db_sess, sip_uri, on_success_handler, on_failure_handler, False) # Asserts get_associated_privates.assert_called_once_with(sip_uri, ANY) HTTPCallbackGroup.assert_called_once_with(ANY, ANY) # Extract inner function and can call it with response on_get_privates_success = HTTPCallbackGroup.call_args[0][0] response = MagicMock() response.body = '{"public_id": "%s", "private_ids": ["%s"]}' % (sip_uri, PRIVATE_ID) on_get_privates_success([response]) # Response should have been parsed now and a new call invoked get_associated_publics.assert_called_once_with(PRIVATE_ID, ANY) on_get_publics_success = HTTPCallbackGroup.call_args[0][0] response = MagicMock() if last_public_id: response.body = '{"associated_public_ids": ["%s"]}' % (sip_uri) else: response.body = '{"associated_public_ids": ["*****@*****.**", "%s"]}' % (sip_uri) on_get_publics_success([response]) if original_id and not last_public_id: # When deleting the originally created public identity we want the request to fail # if other public identities are associated with the private id on_failure_handler.assert_called_once_with(response) else: _delete_number.assert_called_once_with(self.db_sess, sip_uri, PRIVATE_ID, last_public_id, on_success_handler, on_failure_handler, False)
def testHandleBatchSingle(self, mockEngine, addMetricMock): # Create mocks metric_storer.gCustomMetrics = {} metricMock = MagicMock() def addMetricSideEffect(*_args, **_kwargs): metric_storer.gCustomMetrics["test.metric"] = [ metricMock, datetime.datetime.utcnow() ] addMetricMock.side_effect = addMetricSideEffect modelSwapperMock = MagicMock() metricStreamerMock = MagicMock() body = '{"protocol": "plain", "data": ["test.metric 4.0 1386792175"]}' message = MagicMock() message.body = body # Call the function under test metric_storer._handleBatch(mockEngine, [message], [], metricStreamerMock, modelSwapperMock) # Check the results addMetricMock.assert_called_once_with(mockEngine, "test.metric") metricStreamerMock.streamMetricData.assert_called_once() data, _uid, modelSwapper = metricStreamerMock.streamMetricData.call_args[ 0] self.assertIs(modelSwapper, modelSwapperMock) self.assertEqual(len(data), 1) self.assertEqual(len(data[0]), 2) self.assertEqual(repr(data[0][0]), "datetime.datetime(2013, 12, 11, 20, 2, 55)") self.assertAlmostEqual(data[0][1], 4.0)
def test__validate_body_no_body(): request = MagicMock() request.body = None with pytest.raises(exceptions.HTTPError) as exc: _validate_body(request) assert exc.value.status_code == 400 assert exc.value.errors == 'No Data in Body'
def test__validate_body_empty_body(): request = MagicMock() request.body = '' with pytest.raises(exceptions.HTTPError) as exc: _validate_body(request) assert exc.value.status_code == 400 assert exc.value.errors == 'Body is empty string'
def test_sauthc1signer_query(self): # The plus sign in a url query must be replaced with %20 r = MagicMock() r.headers = {} r.url = 'https://api.stormpath.com/v1/directories?orderBy=name+asc' r.method = 'GET' r.body = None mock_dt = MagicMock() mock_dt.utcnow.return_value = datetime.datetime(2013, 7, 1, 0, 0, 0, 0) mock_uuid4 = MagicMock( return_value='a43a9d25-ab06-421e-8605-33fd1e760825') s = Sauthc1Signer(id='MyId', secret='Shush!') with patch('stormpath.auth.datetime', mock_dt): with patch('stormpath.auth.uuid4', mock_uuid4): r2 = s(r) self.assertEqual(r, r2) self.assertEqual( r.headers['Authorization'], 'SAuthc1 sauthc1Id=MyId/20130701/a43a9d25-ab06-421e-8605-33fd1e760825/sauthc1_request, ' + # noqa 'sauthc1SignedHeaders=host;x-stormpath-date, ' + 'sauthc1Signature=fc04c5187cc017bbdf9c0bb743a52a9487ccb91c0996267988ceae3f10314176' ) # noqa
def a_request(): request = MagicMock() request.method = "post" request.url = "http://{}.com".format(a_string()) request.headers = {a_string(): a_string()} request.body = a_string() return request
def test_HTMLHandler(self): req = MagicMock() req.body = '' x = HTMLHandler(self.app, req, template='404.html') x._transforms = [] x.get_current_user = lambda: False x.template = '404.html' try: with patch.object(x, 'get_secure_cookie') as mget: mget.return_value = self.login_code x.get() assert False except HTTPError: pass x = HTMLHandler(self.app, req, template=None) x._transforms = [] x.get_current_user = lambda: True with patch.object(x, 'get_secure_cookie') as mget: mget.return_value = self.login_code x.get() x = HTMLHandler(self.app, req, template='404.html') x._transforms = [] x.get_current_user = lambda: b'test' with patch.object(x, 'get_secure_cookie') as mget: mget.return_value = self.login_code x.get()
def test_competitions2(self): req = MagicMock() req.body = '' x = { 0: MagicMock(), 1: MagicMock(), 2: MagicMock(), 3: MagicMock(), 4: MagicMock(), 5: MagicMock() } x[0].id = 0 x[1].id = 1 x[2].id = 1 x[3].id = 2 x[4].id = 2 x[5].id = 2 x[0].clientId = 0 x[1].clientId = 0 x[2].clientId = 1 x[3].clientId = 2 x[4].clientId = 2 x[5].clientId = 2 x[0].spec.type = CompetitionType.PREDICT x[1].spec.type = CompetitionType.PREDICT x[2].spec.type = CompetitionType.PREDICT x[3].spec.type = CompetitionType.CLASSIFY x[4].spec.type = CompetitionType.CLASSIFY x[5].spec.type = CompetitionType.CLASSIFY x[0].expiration = datetime(2019, 1, 1) x[1].expiration = datetime(2019, 1, 1) x[2].expiration = datetime(2019, 1, 1) x[3].expiration = datetime(2019, 1, 1) x[4].expiration = datetime(2017, 1, 1) x[5].expiration = datetime(2019, 1, 1) context = { 'clients': { 1234: '' }, 'competitions': x, 'leaderboards': {}, 'submissions': {}, 'stash': [], 'sessionmaker': MagicMock() } x = CompetitionHandler(self.app, req, **context) x._transforms = [] x.get_current_user = lambda: True x.get_argument = lambda *args: True x._validate = lambda *args: { 'id': (1, 2), 'client_id': (1, 2), 'type': [CompetitionType.CLASSIFY] } x.get()
def test_ping_fail(self, settings, AsyncHTTPClient): self.standard_setup(settings, AsyncHTTPClient) homestead.ping() self.mock_httpclient.fetch.assert_called_once_with("http://homestead/ping", ANY) mock_response = MagicMock() mock_response.body = "Failure" self.mock_httpclient.fetch.call_args[0][1](mock_response)
def test_send_mail_failure_unable_to_send(self): instance = MagicMock() instance.resource_status = 'to-send' instance.subject = 'subject' instance.body = 'body' instance.created_by = 'sender' send_email_pre_save(sender='', instance=instance)
def TestCommandParsing(self): request = MagicMock() request.path = "/test" request.query = "item1=value1" request.remote_ip = "1.2.3.4" request.method = "PUT" request.headers = { 'User': '******', 'Creation-Time': 'test_time', 'User-Agent': 'test_user_agent' } request.body="item2=value2&item2=value3&item2=value4" self.command = Command(request) self.assertEqual(self.command.command_name, 'test') self.assertEqual(self.command.command_type, 'PUT') self.assertEqual(self.command.has_param('item1'), True) self.assertEqual(self.command.has_param('item2'), True) self.assertEqual(self.command.has_param('item3'), False) self.assertEqual(self.command.get_param('item1'), 'value1') self.assertEqual('value2' in self.command.get_param('item2'), True) self.assertEqual('value3' in self.command.get_param('item2'), True) self.assertEqual('value4' in self.command.get_param('item2'), True) data = self.command.format_trace self.assertEqual(data['Username'], 'test_user') self.assertEqual(data['Created'], 'test_time') self.assertEqual(data['Source_Address'], '1.2.3.4') self.assertEqual(data['Source_ID'], 'test_user_agent')
def _setup(): global reconnect_handler, session_manager, session_list, path, kernel_id, kernel_manager,\ individual_kernel_manager, response_id, good_msg, client, spark_events, request # Mock kernel manager client = MagicMock() client.execute = MagicMock(return_value=response_id) client.get_shell_msg = MagicMock(return_value=good_msg) individual_kernel_manager = MagicMock() individual_kernel_manager.client = MagicMock(return_value=client) kernel_manager = MagicMock() kernel_manager.get_kernel = MagicMock(return_value=individual_kernel_manager) # Mock session manager session_list = [create_session_dict(path, kernel_id)] session_manager = MagicMock() session_manager.list_sessions = MagicMock(return_value=session_list) # Mock spark events spark_events = MagicMock() # Mock request request = MagicMock() request.body = json.dumps({"path": path, "username": username, "password": password, "endpoint": endpoint}) # Create mocked reconnect_handler ReconnectHandler.__bases__ = (SimpleObject,) reconnect_handler = ReconnectHandler() reconnect_handler.spark_events = spark_events reconnect_handler.session_manager = session_manager reconnect_handler.kernel_manager = kernel_manager reconnect_handler.set_status = MagicMock() reconnect_handler.finish = MagicMock() reconnect_handler.current_user = '******' reconnect_handler.request = request
def test_ping_http(self, settings, AsyncHTTPClient): self.standard_setup(settings, AsyncHTTPClient) mock_response = MagicMock() mock_response.body = "OK" self.mock_httpclient.fetch.return_value = mock_response homestead.ping() self.mock_httpclient.fetch.assert_called_once_with("http://homestead/ping", ANY)
def test_process_notification_refund_not_finalized(self): """Test processing PayU partial refund notification""" self.set_up_provider(True, True) mocked_request = MagicMock() mocked_request.body = json.dumps({ "order": { "status": "COMPLETED" }, "refund": { "amount": "11000", "currencyCode": "USD", "status": "FOO", "reasonDescription": "BlenderKit refund", }, }).encode("utf8") mocked_request.META = { "CONTENT_TYPE": "application/json", "HTTP_OPENPAYU_SIGNATURE": "signature=0af4d2830ed40ec2cea5249a172bf6d9;algorithm=MD5", } mocked_request.status_code = 200 with self.assertRaisesRegex(Exception, "Refund was not finelized"): self.provider.process_data(payment=self.payment, request=mocked_request)
def test_process_notification_refund(self): """Test processing PayU refund notification""" self.set_up_provider(True, True) mocked_request = MagicMock() mocked_request.body = json.dumps({ "order": { "status": "COMPLETED" }, "refund": { "amount": "22000", "currencyCode": "USD", "status": "FINALIZED", "reasonDescription": "BlenderKit refund", }, }).encode("utf8") mocked_request.META = { "CONTENT_TYPE": "application/json", "HTTP_OPENPAYU_SIGNATURE": "signature=dd8cdddaa98438e7a76f5e830395d7e8;algorithm=MD5", } mocked_request.status_code = 200 ret_val = self.provider.process_data(payment=self.payment, request=mocked_request) self.assertEqual(ret_val.__class__.__name__, "HttpResponse") self.assertEqual(ret_val.status_code, 200) self.assertEqual(ret_val.content, b"ok") self.assertEqual(self.payment.status, PaymentStatus.REFUNDED) self.assertEqual(self.payment.captured_amount, Decimal("0"))
def test_ServerMessagesMixin(self): req = MagicMock() req.body = '' x = ServerMessagesMixin() x._transforms = [] x.te = MagicMock() x.te._ex = MagicMock() x.te._ex.messages = MagicMock() x.te._ex.messages.return_value = [MagicMock()] x.te._ex.messages.return_value[0].to_dict = MagicMock() x.te._ex.messages.return_value[0].to_dict.return_value = {'test': 1, 'instrument': {'underlying': 'test'}} x.get_data() x.get_data('test') x.get_data(None, 0, 'BTCUSD') x.te._ex.messages.return_value = {'TRADE': [MagicMock()]} x.te._ex.messages.return_value['TRADE'][0].to_dict = MagicMock() x.te._ex.messages.return_value['TRADE'][0].to_dict.return_value = {'test': 1} x.get_data('TRADE') x.get_data('TRADE', 0, 'test') x.get_data('TRADE', 0, 'BTCUSD') x.get_data('TRADE', 0, 'BTCUSD')
def test_process_notification_partial_refund(self): """Test processing PayU partial refund notification""" self.payment.change_status(PaymentStatus.CONFIRMED) self.payment.total = 220 self.payment.save() self.payment.refresh_from_db() self.set_up_provider(True, True) mocked_request = MagicMock() mocked_request.body = json.dumps({ "order": { "status": "COMPLETED" }, "refund": { "amount": "11000", "currencyCode": "USD", "status": "FINALIZED", "reasonDescription": "BlenderKit refund", }, }).encode("utf8") mocked_request.META = { "CONTENT_TYPE": "application/json", "HTTP_OPENPAYU_SIGNATURE": "signature=6f1076d9d2fa7dc58a87f20f2c69ebf8;algorithm=MD5", } mocked_request.status_code = 200 ret_val = self.provider.process_data(payment=self.payment, request=mocked_request) self.assertEqual(ret_val.__class__.__name__, "HttpResponse") self.assertEqual(ret_val.status_code, 200) self.assertEqual(ret_val.content, b"ok") self.payment.refresh_from_db() self.assertEqual(self.payment.total, Decimal("110")) self.assertEqual(self.payment.status, PaymentStatus.CONFIRMED)
def test_process_notification_total_amount(self): """ Test processing PayU notification if it captures correct amount """ self.set_up_provider(True, True) mocked_request = MagicMock() mocked_request.body = json.dumps( { "order": { "status": "COMPLETED", "totalAmount": 200, "currencyCode": "USD" } }, ).encode("utf8") mocked_request.META = { 'CONTENT_TYPE': 'application/json', "HTTP_OPENPAYU_SIGNATURE": "signature=01a0e768ab1f762da4b955585aa4e59e;algorithm=MD5", } mocked_request.status_code = 200 ret_val = self.provider.process_data(payment=self.payment, request=mocked_request) self.assertEqual(ret_val.__class__.__name__, "HttpResponse") self.assertEqual(ret_val.status_code, 200) self.assertEqual(ret_val.content, b"ok") self.assertEqual(self.payment.status, PaymentStatus.CONFIRMED) self.assertEqual(self.payment.captured_amount, Decimal('2'))
def test_ServerMessagesMixin(self): req = MagicMock() req.body = '' x = TradesHandler(self.app, req, trading_engine=MagicMock(), psp_kwargs={}) x._transforms = [] x.te = MagicMock() x.te._ex = MagicMock() x.te._ex.messages = MagicMock() x.te._ex.messages.return_value = [MagicMock()] x.te._ex.messages.return_value[0].to_dict = MagicMock() x.te._ex.messages.return_value[0].to_dict.return_value = { 'test': 1, 'instrument': { 'underlying': 'test' } } x.get_data() x.get_data('test') x.get_data(None, 'BTCUSD') x.te._ex.messages.return_value = {'TRADE': [MagicMock()]} x.te._ex.messages.return_value['TRADE'][0].to_dict = MagicMock() x.te._ex.messages.return_value['TRADE'][0].to_dict.return_value = { 'test': 1 } x.get_data() x.get_data(pair='test') x.get_data(pair='BTCUSD')
def testHandleBatchSingle(self, mockEngine, addMetricMock): # Create mocks metric_storer.gCustomMetrics = {} metricMock = MagicMock() def addMetricSideEffect(*_args, **_kwargs): metric_storer.gCustomMetrics["test.metric"] = [metricMock, datetime.datetime.utcnow()] addMetricMock.side_effect = addMetricSideEffect modelSwapperMock = MagicMock() metricStreamerMock = MagicMock() body = '{"protocol": "plain", "data": ["test.metric 4.0 1386792175"]}' message = MagicMock() message.body = body # Call the function under test metric_storer._handleBatch(mockEngine, [message], [], metricStreamerMock, modelSwapperMock) # Check the results addMetricMock.assert_called_once_with(mockEngine, "test.metric") metricStreamerMock.streamMetricData.assert_called_once() data, _uid, modelSwapper = metricStreamerMock.streamMetricData.call_args[0] self.assertIs(modelSwapper, modelSwapperMock) self.assertEqual(len(data), 1) self.assertEqual(len(data[0]), 2) self.assertEqual(repr(data[0][0]), "datetime.datetime(2013, 12, 11, 20, 2, 55)") self.assertAlmostEqual(data[0][1], 4.0)
def test_get_one_number(self, get_numbers, HTTPCallbackGroup, get_associated_privates): self.handler.get_and_check_user_id = MagicMock(return_value=USER_ID) get_numbers.return_value = [{"number": SIP_URI, "number_id": NUMBER_ID, "gab_listed": GAB_LISTED}] HTTPCallbackGroup.return_value = MagicMock() self.handler.get("foobar") # Assert that we kick off asynchronous GET at homestead self.handler.get_and_check_user_id.assert_called_once_with("foobar") HTTPCallbackGroup.assert_called_once_with(ANY, # functools.partial object self.handler._on_get_failure) get_associated_privates.assert_called_once_with(SIP_URI, ANY # function # argument ) # Simulate success of all requests. response = MagicMock() response.body = '{"private_ids": ["*****@*****.**"]}' self.handler._on_get_success(SIP_URI, [response]) self.handler.finish.assert_called_once_with( { "numbers": [ {"number_id": NUMBER_ID_HEX, "number": "5555550123", "sip_username": "******", "domain": REALM, "gab_listed": GAB_LISTED, "formatted_number": "(555) 555-0123", "sip_uri": SIP_URI, "private_id": "*****@*****.**", } ] })
def test_LoginHandler(self): req = MagicMock() req.body = '' context = { 'clients': { 1234: '' }, 'competitions': {}, 'leaderboards': {}, 'submissions': {}, 'stash': [], 'sessionmaker': MagicMock() } x = LoginHandler(self.app, req, **context) x._transforms = [] x._validate = lambda *args: True x.current_user = True x.get() x = LoginHandler(self.app, req, **context) x._transforms = [] x._validate = lambda *args: True x.current_user = False x.get()
def get_two_numbers(self, shared_private_id, get_numbers, HTTPCallbackGroup, get_associated_privates): self.handler.get_and_check_user_id = MagicMock(return_value=USER_ID) get_numbers.return_value = [{"number": "sip:[email protected]", "number_id": NUMBER_ID, "gab_listed": 0}, {"number": "sip:[email protected]", "number_id": NUMBER_ID2, "gab_listed": 1}] HTTPCallbackGroup.return_value = MagicMock() self.handler.get("foobar") # Simulate success of all requests. response1 = MagicMock() response1.body = '{"public_id": "sip:[email protected]", "private_ids": ["*****@*****.**"]}' response2 = MagicMock() if shared_private_id: response2.body = '{"public_id": "sip:[email protected]", "private_ids": ["*****@*****.**"]}' else: response2.body = '{"public_id": "sip:[email protected]", "private_ids": ["*****@*****.**"]}' self.handler._on_get_success("sip:[email protected]", [response1]) self.handler._on_get_success("sip:[email protected]", [response2]) self.handler.finish.assert_called_once_with( { "numbers": [ { "number_id": NUMBER_ID_HEX, "number": "4155551234", "sip_username": "******", "domain": "sip.com", "gab_listed": 0, "formatted_number": "(415) 555-1234", "sip_uri": "sip:[email protected]", "private_id": "*****@*****.**", }, { "number_id": NUMBER_ID2_HEX, "number": "4155555678", "sip_username": "******", "domain": "sip.com", "gab_listed": 1, "formatted_number": "(415) 555-5678", "sip_uri": "sip:[email protected]", "private_id": (shared_private_id and "*****@*****.**" or "*****@*****.**"), } ] })
def create_email_message(): sent_email = MagicMock(spec=Message) sent_email.subject = "Example Subject" sent_email.body = "<html><body>Testing</body></html>" sent_email.attachments = [] sent_email.to_recipients = ["*****@*****.**"] sent_email.send_and_save = MagicMock() return sent_email
def test_ping_fail(self, settings, AsyncHTTPClient): self.standard_setup(settings, AsyncHTTPClient) homestead.ping() self.mock_httpclient.fetch.assert_called_once_with( "http://homestead/ping", ANY) mock_response = MagicMock() mock_response.body = "Failure" self.mock_httpclient.fetch.call_args[0][1](mock_response)
def testHandleDataInvalidBody(self, mockEngine, loggingMock): """Make sure _handleData doesn't throw an exception for invalid data.""" # Call the function under test body = '{"protocol": "plain", "data": ["test.metric 4.0 12:30PM"]}' message = MagicMock() message.body = body metric_storer._handleBatch(mockEngine, [message], [], MagicMock(), MagicMock()) # Check the results self.assertTrue(loggingMock.warn.called)
def testHandleDataInvalidProtocol(self, mockEngine, loggingMock): """Ensure _handleData doesn't throw an exception for unknown protocol.""" # Call the function under test body = '{"protocol": "unknown_protocol",' ' "data": ["test.metric 4.0 1386792175"]}' message = MagicMock() message.body = body metric_storer._handleBatch(mockEngine, [message], [], MagicMock(), MagicMock()) # Check the results self.assertTrue(loggingMock.warn.called)
def test_invalid_xml(): spider = create_spider() response = MagicMock() response.url = "https://s3.cern.ch/incoming-bucket/invalid_record.xml" response.body = "This is not actually XML" result = list(spider.parse(response)) assert result[0].exception.startswith('XMLSyntaxError') assert result[0].traceback is not None assert result[0].source_data == "This is not actually XML"
def test_bsso_msg_generation(self, mock_bsso_alert): from pybossa.view.account import generate_bsso_account_notification mock_alert = MagicMock() mock_alert.body = None mock_alert.html = None mock_bsso_alert = mock_alert user = {'fullname': "test test", "email": "*****@*****.**"} assert generate_bsso_account_notification(user, "*****@*****.**", "test") != None
def phonable_task(func, url): number = '+12103004000' if url.endswith('abc') else '+13103004000' reply = MagicMock() reply.code = 200 reply.body = json.dumps({"number": number}) task = MagicMock(spec=YieldPoint) task.get_result.return_value = reply return task
def test_assets_url_is_generated_with_final_filename_when_debug_is_false(self): context = MagicMock() context['caller'] = MagicMock() context['caller'].body = MagicMock() configure(MOCK_CONF_PROD_MODE) tag(context, 'final-js-bundle') context['caller'].body.assert_called_with(ASSETS_URL='my-url/final-js-bundle.js')
def create_meeting(): meeting = MagicMock(spec=CalendarItem) meeting.subject = "Test" meeting.body = "Just a test" meeting.attachments = [] meeting.start = EWSDateTime(2020, 11, 10, 14, 0, tzinfo=TEST_TZ) meeting.end = EWSDateTime(2020, 11, 10, 15, 0, tzinfo=TEST_TZ) meeting.required_attendees = ['*****@*****.**'] return meeting
def test_process_data(self): """ CoinbaseProvider.process_data() returns a correct HTTP response """ request = MagicMock() request.body = json.dumps(COINBASE_REQUEST) response = self.provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponse) self.assertEqual(self.payment.status, "confirmed")
def test_submit(self, render, loads, user, thread, question): """ This function tests **submit()**. """ loads.return_value = "return" request = MagicMock() request.body = "body of the request" views.submit(request) self.assertTrue(render.called)
def test_process_notification_error_malformed_post(self): """ Test processing PayU notification with malformed POST """ self.set_up_provider(True, True) mocked_request = MagicMock() mocked_request.body = b'{}' mocked_request.META = {'CONTENT_TYPE': 'application/json'} with self.assertRaises(PayuApiError) as context: self.provider.process_data(payment=self.payment, request=mocked_request) self.assertEqual(context.exception.args[0], "Malformed POST")
def test_process_data(self): """ CoinbaseProvider.process_data() returns a correct HTTP response """ request = MagicMock() request.body = json.dumps(COINBASE_REQUEST) response = self.provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponse) self.assertEqual(self.payment.status, 'confirmed')
def generate_dummy_email(kind, to_addr, body, uid): email = MagicMock() email.kind = kind email.body = body email.uid = uid email.to_MIMEText = lambda: FakeMIMEText(body) email.fr_addr = "*****@*****.**" email.to_addr = to_addr return email
def test_verify_body_size_okay(): errors = [] request = MagicMock() request.headers = {'Content-Length': options.max_post_body_size} request.body = " " * (options.max_post_body_size) # MUT verify_body_size(request, errors) assert len(errors) == 0
def test_incorrect_custom_token_process_data(self): """ CoinbaseProvider.process_data() checks request custom token """ data = dict(COINBASE_REQUEST) data.update({'order': {'custom': 'fake'}}) request = MagicMock() request.body = json.dumps(data) response = self.provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponseForbidden)
def test_assets_url_is_generated_for_each_file_when_debug_is_true(self): context = MagicMock() context['caller'] = MagicMock() context['caller'].body = MagicMock() configure(MOCK_CONF_DEBUG_MODE) tag(context, 'final-js-bundle') context['caller'].body.assert_any_call(ASSETS_URL='my-url/file1.js') context['caller'].body.assert_any_call(ASSETS_URL='my-url/file2.js')
def test_incorrect_custom_token_process_data(self): """ CoinbaseProvider.process_data() checks request custom token """ data = dict(COINBASE_REQUEST) data.update({"order": {"custom": "fake"}}) request = MagicMock() request.body = json.dumps(data) response = self.provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponseForbidden)
def test_helpscout_user(self): request = MagicMock() request.method = 'POST' request.body = json.dumps({'customer': {'email': '*****@*****.**'}}) # User does not exist response = helpscout_user(request) self.assertTemplateUsed(response, 'django_helpscout/404.html') # User found user = User.objects.create(username='******', email='*****@*****.**', password='******') response = helpscout_user(request) self.assertTemplateUsed(response, 'django_helpscout/helpscout.html')
def test_create_member(self): collection_handler = webservice.CollectionHandler(r'/', '') collection_handler.model = webservice.SimpleDataModel("test") request = MagicMock() request.body = '{"key": "value"}' request.path = "/" response = collection_handler.create_member(request, id_='123') self.assertEqual('application/json', response.content_type) self.assertEqual(str(httplib.CREATED) + " Created", response.status) self.assertEqual("%s/%s" % (request.path, '123'), response.location) actual_response = json.loads(response.body) actual_id = actual_response.get("id") actual_value = actual_response.get("key") self.assertEqual('123', actual_id) self.assertEqual('value', actual_value)
def test_list_members(self): collection_handler = webservice.CollectionHandler(r'/', '') collection_handler.model = webservice.SimpleDataModel("test") request = MagicMock() request.body = '{"key": "value"}' request.params = MagicMock() request.path = "/" response = collection_handler.list_members(request) items = collection_handler.model.get_items( request.params, context=collection_handler._get_context(request)) expected_body = "%s\n" % json.dumps(items, indent=2) self.assertEqual('application/json', response.content_type) self.assertEqual(expected_body, response.body) self.assertEqual('application/json', response.content_type) self.assertEqual(str(httplib.OK) + " OK", response.status)
def test_regular(self): suggestions = MagicMock() sender = MagicMock() target = Target(suggestions, sender) target.bson_json_decode_and_load = MagicMock(return_value="decoded_response") target.suggest_responder.suggestion_items = MagicMock() response = MagicMock() response.body = "response_body" response.headers = {"next_offset": "next_offset_value"} target.get_suggestion_items_callback(response, "handler", {'offset': "offset_value"}) target.bson_json_decode_and_load.assert_called_once_with('response_body') suggestions.write_suggestion_items.assert_called_once_with('handler', 'decoded_response', "offset_value", "next_offset_value") target.suggest_responder.suggestion_items.assert_called_once_with('handler', {'offset': 'offset_value'}, 'decoded_response')
def test_post_mainline(self, get_number, allocate_number, gen_sip_pass, HTTPCallbackGroup, get_associated_privates, put_password): # Setup self.handler.get_and_check_user_id = MagicMock(return_value=USER_ID) self.handler.check_number_ownership = Mock() gen_sip_pass.return_value = "sip_pass" HTTPCallbackGroup.return_value = MagicMock() self.handler.finish = MagicMock() # Test self.handler.post("foobar", SIP_URI) # Assert HTTPCallbackGroup.assert_called_once_with(self.handler.on_get_privates_success, self.handler.on_get_privates_failure) get_associated_privates.assert_called_once_with(SIP_URI, self.handler._request_group.callback()) # Reset http callback group HTTPCallbackGroup.reset_mock() HTTPCallbackGroup.return_value = MagicMock() # Invoke callback for returned private IDs and assert password is created response = MagicMock() response.body = '{"public_id": "%s", "private_ids": ["*****@*****.**"]}' % SIP_URI self.handler.on_get_privates_success([response]) HTTPCallbackGroup.assert_called_once_with(self.handler.on_put_password_success, self.handler.on_put_password_failure) put_password.assert_called_once_with("*****@*****.**", REALM, "sip_pass", self.handler._request_group.callback()) # Invoke call for password PUT response = MagicMock() response.code = 200 self.handler.on_put_password_success(response) self.handler.finish.assert_called_once_with({"sip_password": "******"})
def test_regular_has_entities(self): sender = MagicMock() context = MagicMock() suggest = Mock() target = Target(sender, context, suggest) target.json_decode = MagicMock( return_value={ "entities": [ { "source": "non_detection" } ], "_rev": "_context_rev_value" } ) handler = MagicMock() handler.user_id = "user_id_value" handler.application_id = "application_id_value" handler.session_id = "session_id_value" handler.locale = "locale_value" response = MagicMock() response.body = "response_value" target.get_context_callback(response, handler, "message_value") self.assertEqual(1, suggest.post_suggest.call_count) self.assertEqual("user_id_value", suggest.post_suggest.call_args_list[0][0][0]) self.assertEqual("application_id_value", suggest.post_suggest.call_args_list[0][0][1]) self.assertEqual("session_id_value", suggest.post_suggest.call_args_list[0][0][2]) self.assertEqual("locale_value", suggest.post_suggest.call_args_list[0][0][3]) self.assertDictEqual({'_rev': '_context_rev_value', 'entities': [{'source': 'non_detection'}]}, suggest.post_suggest.call_args_list[0][0][4]) target.json_decode.assert_called_once_with('response_value') self.assertDictEqual({'_rev': '_context_rev_value', 'entities': [{'source': 'non_detection'}]}, handler.context) self.assertEqual("_context_rev_value", handler.context_rev)
def test_sauthc1signer(self): r = MagicMock() r.headers = {} r.url = 'https://api.stormpath.com/v1/' r.method = 'GET' r.body = None mock_dt = MagicMock() mock_dt.utcnow.return_value = datetime.datetime(2013, 7, 1, 0, 0, 0, 0) mock_uuid4 = MagicMock( return_value='a43a9d25-ab06-421e-8605-33fd1e760825') s = Sauthc1Signer(id='MyId', secret='Shush!') with patch('stormpath.auth.datetime', mock_dt): with patch('stormpath.auth.uuid4', mock_uuid4): r2 = s(r) self.assertEqual(r, r2) self.assertEqual(r.headers['Authorization'], 'SAuthc1 sauthc1Id=MyId/20130701/a43a9d25-ab06-421e-8605-33fd1e760825/sauthc1_request, ' + # noqa 'sauthc1SignedHeaders=host;x-stormpath-date, ' + 'sauthc1Signature=990a95aabbcbeb53e48fb721f73b75bd3ae025a2e86ad359d08558e1bbb9411c') # noqa
def test_sauthc1signer_query(self): # The plus sign in a url query must be replaced with %20 r = MagicMock() r.headers = {} r.url = 'https://api.stormpath.com/v1/directories?orderBy=name+asc' r.method = 'GET' r.body = None mock_dt = MagicMock() mock_dt.utcnow.return_value = datetime.datetime(2013, 7, 1, 0, 0, 0, 0) mock_uuid4 = MagicMock( return_value='a43a9d25-ab06-421e-8605-33fd1e760825') s = Sauthc1Signer(id='MyId', secret='Shush!') with patch('stormpath.auth.datetime', mock_dt): with patch('stormpath.auth.uuid4', mock_uuid4): r2 = s(r) self.assertEqual(r, r2) self.assertEqual(r.headers['Authorization'], 'SAuthc1 sauthc1Id=MyId/20130701/a43a9d25-ab06-421e-8605-33fd1e760825/sauthc1_request, ' + # noqa 'sauthc1SignedHeaders=host;x-stormpath-date, ' + 'sauthc1Signature=fc04c5187cc017bbdf9c0bb743a52a9487ccb91c0996267988ceae3f10314176') # noqa