def test_should_update_email_address_for_data_sender_and_send_mail(self): dbm = Mock(spec=DatabaseManager) request = MagicMock() request.POST = { 'post_data': json.dumps([{ 'email': 'data_sender_email', 'reporter_id': 'rep_id' }]) } request.method = 'POST' request.LANGUAGE_CODE = 'en' expected_contact_id_map = {'rep_id': 'data_sender_email'} contact = MagicMock(spec=Contact) contact.is_contact = False with patch('datawinners.entity.views.create_web_users' ) as create_web_users_mock: with patch('datawinners.entity.views.contact_by_short_code' ) as contact_by_short_code_mock: with patch('datawinners.entity.views.set_email_for_contact' ) as set_email_for_contact_mock: contact_by_short_code_mock.return_value = contact _set_email_for_contacts(dbm, 'org_id', request) self.assertFalse(set_email_for_contact_mock.called) create_web_users_mock.assert_called_with( 'org_id', expected_contact_id_map, 'en')
def test_provider_redirects_on_success_preauth_payment( self, mocked_request, mocked_redirect): provider = CyberSourceProvider(merchant_id=MERCHANT_ID, password=PASSWORD, org_id=ORG_ID, capture=False) transaction_id = 1234 xid = 'abc' self.payment.attrs.xid = xid response = MagicMock() response.requestID = transaction_id response.reasonCode = ACCEPTED mocked_request.return_value = response request = MagicMock() request.POST = {'MD': xid} request.GET = { 'token': signing.dumps({ 'expiration': { 'year': 2020, 'month': 9 }, 'name': 'John Doe', 'number': '371449635398431', 'cvv2': '123' }) } provider.process_data(self.payment, request) self.assertEqual(self.payment.status, PaymentStatus.PREAUTH) self.assertEqual(self.payment.captured_amount, 0) self.assertEqual(self.payment.transaction_id, transaction_id)
def test_provider_invalid_request(self): request = MagicMock() request.POST = {'jwt': 'wrong jwt data'} provider = GoogleWalletProvider(payment=None, seller_id=SELLER_ID, seller_secret=SELLER_SECRET) token = provider.get_token_from_request(request) self.assertFalse(token)
def test_provider_request_payment_token(self): request = MagicMock() request.POST = {'jwt': jwt.encode(JWT_DATA, SELLER_SECRET)} provider = GoogleWalletProvider(payment=None, seller_id=SELLER_ID, seller_secret=SELLER_SECRET) token = provider.get_token_from_request(request) self.assertEqual(token, PAYMENT_TOKEN)
def test_process_data(self): """DotpayProvider.process_data() returns a correct HTTP response""" request = MagicMock() request.POST = get_post_with_md5(PROCESS_POST) provider = DotpayProvider(self.payment, seller_id='123', pin=PIN) response = provider.process_data(request) self.assertEqual(type(response), HttpResponse)
def test_incorrect_process_data(self): """DotpayProvider.process_data() checks POST signature""" request = MagicMock() request.POST = PROCESS_POST provider = DotpayProvider(self.payment, seller_id='123', pin=PIN) response = provider.process_data(request) self.assertEqual(type(response), HttpResponseForbidden)
def test_should_get_contact_details_when_recipients_name_are_given(self): dbm = MagicMock(spec=DatabaseManager) request = MagicMock() request.POST = { 'recipient': 'poll_recipients', 'my_poll_recipients': ['contact_short_code'] } failed_numbers = ['some_number'] contact_display_list = [{'contact_short_code': 'contact_name'}] mobile_numbers = ['some_number'] short_codes = ['contact_short_code'] with patch( 'datawinners.entity.view.send_sms.get_name_short_code_mobile_numbers_for_contacts' ) as get_name_short_code_mobile_numbers_for_contacts_mock: get_name_short_code_mobile_numbers_for_contacts_mock.return_value = mobile_numbers, contact_display_list, short_codes mobile_numbers, contact_display_list, short_codes = get_contact_details( dbm, request, failed_numbers) expected_contact_display_list = [{ 'contact_short_code': 'contact_name' }] expected_mobile_numbers = ['some_number'] expected_short_codes = ['contact_short_code'] self.assertEquals(contact_display_list, expected_contact_display_list) self.assertListEqual(mobile_numbers, expected_mobile_numbers) self.assertListEqual(short_codes, expected_short_codes)
def test_provider_redirects_on_success_preauth_payment( self, mocked_request, mocked_redirect): provider = CyberSourceProvider( merchant_id=MERCHANT_ID, password=PASSWORD, org_id=ORG_ID, capture=False) transaction_id = 1234 xid = 'abc' self.payment.attrs.xid = xid response = MagicMock() response.requestID = transaction_id response.reasonCode = ACCEPTED mocked_request.return_value = response request = MagicMock() request.POST = {'MD': xid} request.GET = {'token': signing.dumps({ 'expiration': {'year': 2020, 'month': 9}, 'name': 'John Doe', 'number': '371449635398431', 'cvv2': '123' })} provider.process_data(self.payment, request) self.assertEqual(self.payment.status, 'preauth') self.assertEqual(self.payment.captured_amount, 0) self.assertEqual(self.payment.transaction_id, transaction_id)
def test_should_construct_questionnaire(self): project_name = 'test_poll' days_active = 3 question = "What poll questionnaire?" request = MagicMock() request.user = MagicMock(spec=User) request.POST = { 'poll_name': project_name, 'active_days': days_active, 'question': question, 'end_date': "2015-4-28T9:45:31" } manager = MagicMock(spec=DatabaseManager) questionnaire_code = 'poll_' with patch('datawinners.project.create_poll.get_database_manager') as get_database_manager_mock: with patch('datawinners.project.create_poll.helper.generate_questionnaire_code') as generate_questionnaire_code_mock: generate_questionnaire_code_mock.return_value = questionnaire_code get_database_manager_mock.return_value = manager manager, questionnaire = _construct_questionnaire(request) self.assertEquals(questionnaire.name, project_name) self.assertIn(questionnaire_code, questionnaire.form_code)
def test_address_save_with_address_in_checkout(self): request = MagicMock() request.user.is_authenticated.return_value = False request.POST = dict(NEW_ADDRESS, email='*****@*****.**') storage = {'address': {}} step = BillingAddressStep(request, storage) self.assertTrue(step.forms_are_valid(), "Forms don't validate.")
def test_unit_register_with_invalidPOST(self): """ This function tests the **register()** function with invalid post data. we should mock 1. request 2. RegisterForm - is_valid() 3. args """ with patch('user_auth.views.RegisterForm') as reg: request = MagicMock() request.method = "POST" request.POST = "some input" # make input to RegisterForm reg.return_value = Mock() reg.return_value.is_valid = Mock(return_value=False) # make it pass the if part. reg.return_value.register_form = Mock(return_value=None) with patch('user_auth.views.render_to_response') as render: render.return_value = "some value" register(request) # asserts reg.assert_called_with("some input") self.assertTrue(not reg.return_value.register_form.called) self.assertTrue(render.called)
def test_unit_register_with_POST(self): """ We need to mock several things to make this unittest. 1. request 2. register_form() : For this, make seperate test. - request has **method** attribute that specifies the method of the form. 3. Need to mock RegisterForm because we are not testing the register function. - RegisterForm instance should have is_valid() method that returns boolean. 4. We need to mock HttpResponseRedirect. """ with patch('user_auth.views.RegisterForm') as form: with patch('user_auth.views.HttpResponseRedirect') as redir: request = MagicMock() request.method = "POST" ## this will pass if request.POST == "POST" part. request.POST = "some_input" form.return_value = Mock() form.return_value.is_valid = Mock(return_value=True) # mock register_form form.return_value.register_form = Mock(return_value=None) register(request) # make function call form.assert_called_with("some_input") # redir.assert_called_with('/') self.assertTrue(form.return_value.register_form.called)
def test_unit_login_user_with_post(self): """ This function tests **login_user()** with post data. We need to mock 1. request 2. LogInForm - is_valid - cleaned_data 3. authenticate - is_active 4. render_to_response """ with patch('user_auth.views.LogInForm') as form: request = MagicMock() request.method = "POST" request.POST = "some data" form.return_value = Mock() form.return_value.is_valid = Mock(return_value=True) form.return_value.login_process = Mock() with patch('user_auth.views.render_to_response') as render: login_user(request) form.return_value.login_process.assert_called_with(request) form.assert_called_with("some data") self.assertTrue(render.called)
def test_provider_redirects_on_failure(self, mocked_request, mocked_redirect): transaction_id = 1234 xid = 'abc' self.payment.attrs.xid = xid response = MagicMock() response.requestID = transaction_id response.reasonCode = 'test code' mocked_request.return_value = response request = MagicMock() request.POST = {'MD': xid} request.GET = { 'token': signing.dumps({ 'expiration': { 'year': 2020, 'month': 9 }, 'name': 'John Doe', 'number': '371449635398431', 'cvv2': '123' }) } self.provider.process_data(self.payment, request) self.assertEqual(self.payment.status, PaymentStatus.ERROR) self.assertEqual(self.payment.captured_amount, 0) self.assertEqual(self.payment.transaction_id, transaction_id)
def test_should_get_contact_details_when_questionnaire_name_are_given( self): dbm = MagicMock(spec=DatabaseManager) request = MagicMock() request.POST = { 'recipient': 'linked', 'questionnaire_names': 'question1_name' } failed_numbers = ['some_number'] contact_display_list = [{'contact_short_code': 'contact_name'}] mobile_numbers = ['some_number'] short_codes = ['contact_short_code'] with patch( 'datawinners.entity.view.send_sms._get_contact_details_for_questionnaire' ) as _get_contact_details_for_questionnaire_mock: _get_contact_details_for_questionnaire_mock.return_value = contact_display_list, mobile_numbers, short_codes mobile_numbers, contact_display_list, short_code = get_contact_details( dbm, request, failed_numbers) expected_contact_display_list = [{ 'contact_short_code': 'contact_name' }] expected_mobile_numbers = ['some_number'] expected_short_code = ['contact_short_code'] self.assertEquals(contact_display_list, expected_contact_display_list) self.assertListEqual(mobile_numbers, expected_mobile_numbers) self.assertListEqual(short_codes, expected_short_code)
def test_incorrect_data_process_data(self): """ CoinbaseProvider.process_data() checks request body """ request = MagicMock() request.POST = {'id': '1234'} response = self.provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponseForbidden)
def test_incorrect_data_process_data(self): """ CoinbaseProvider.process_data() checks request body """ request = MagicMock() request.POST = {"id": "1234"} response = self.provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponseForbidden)
def test_should_fetch_no_mobile_numbers_when_recipient_is_others(self): dbm = MagicMock(spec=DatabaseManager) request = MagicMock() request.POST = {'recipient': "others"} mobile_numbers = SendSMS( )._get_mobile_numbers_for_registered_data_senders(dbm, request) self.assertListEqual(mobile_numbers, [])
def test_given_request_then_pass_to_correct_method(self): request = MagicMock() request.POST = "Post" request.type_ = "Post" request.endpoint = ["TestBlock", "device", "get_things"] self.block.handle_request(request) self.method.handle_request.assert_called_once_with(request)
def test_address_save_without_address(self): request = MagicMock() request.user.is_authenticated.return_value = False request.POST = dict(NEW_ADDRESS, email='*****@*****.**') storage = {} step = BillingAddressStep(request, storage) self.assertEquals(step.process(), None) self.assertEqual(type(storage['address']), dict) self.assertEqual(storage['address']['name'], 'Test')
def test_process_data_payment_rejected(self): """BorgunProvider.process_data() returns a correct HTTP response""" self.assertEqual(self.payment2.status, PaymentStatus.WAITING) request = MagicMock() request.POST = get_postdata_with_sha256(self.payment2, status='ERROR') provider = BorgunProvider(sandbox=True) response = provider.process_data(self.payment2, request) self.assertEqual(type(response), HttpResponse) self.assertEqual(self.payment2.status, PaymentStatus.REJECTED)
def test_address_save_without_address(self): request = MagicMock() request.user.is_authenticated.return_value = False request.POST = dict(NEW_ADDRESS, email='*****@*****.**') storage = {} step = BillingAddressStep(request, storage) self.assertEquals(step.process(), None) self.assertEqual(type(storage['address']), dict) self.assertEqual(storage['address']['first_name'], 'Test')
def mock_request(self, authed, path='/'): mock_request = MagicMock() mock_request.method = 'GET' mock_request.user.is_authenticated.return_value = authed mock_request.POST = {} mock_request.META = {} mock_request.session = {} mock_request.build_absolute_uri.return_value = path mock_request.get_full_path.return_value = path return mock_request
def test_should_return_unique_mobile_numbers(self): mock_request = MagicMock() mock_request.POST = { "others": "87687687,9879879, 9879879", "recipient": "others" } actual_numbers = SendSMS()._other_numbers(mock_request) expected_numbers = list(set(["87687687", "9879879"])) self.assertListEqual(actual_numbers, expected_numbers)
def test_incorrect_process_data(self): """BorgunProvider.process_data() checks POST signature""" self.assertEqual(self.payment3.status, PaymentStatus.WAITING) request = MagicMock() request.POST = get_postdata_with_sha256(self.payment3, orderid='00000000', status='OK') provider = BorgunProvider(sandbox=True) response = provider.process_data(self.payment3, request) self.assertEqual(type(response), HttpResponseForbidden)
def test_new_method(self): ''' Test the BaseAddressStep managment form when method is set to 'new' and user isn't authenticated. ''' request = MagicMock() request.user.is_authenticated.return_value = False request.POST = NEW_ADDRESS.copy() step = BaseAddressStep(request, {}, Address(**NEW_ADDRESS)) self.assertTrue(step.forms_are_valid(), "Forms don't validate.") self.assertEqual(step.address.name, 'Test')
def _get_mock_request(self, twofactor_required=False, devices=None): devices = devices or [] mock_request = MagicMock() mock_request.user.is_authenticated.return_value = True mock_request.user.preferredemail.email = '*****@*****.**' mock_request.user.twofactor_required = twofactor_required mock_request.method = 'GET' mock_request.POST = {} mock_request.META = {} mock_request.user.devices.all.return_value = devices return mock_request
def test_get_form_kwargs_get(self, get_initial_data_mock): request = MagicMock() request.method = 'GET' request.POST = 'foo' request.FILES = 'bar' self.mixin.request = request result = self.mixin.get_form_kwargs() self.assertIn('initial', result) self.assertIn('data', result)
def test_new_method(self): ''' Test the BaseAddressStep managment form when method is set to 'new' and user isn't authenticated. ''' request = MagicMock() request.user.is_authenticated.return_value = False request.POST = NEW_ADDRESS.copy() step = BaseAddressStep(request, {}, Address(**NEW_ADDRESS)) self.assertTrue(step.forms_are_valid(), "Forms don't validate.") self.assertEqual(step.address.first_name, 'Test')
def test_process_data_payment_accepted(self): """BorgunProvider.process_data() returns a correct HTTP response""" self.assertEqual(self.payment.status, PaymentStatus.WAITING) request = MagicMock() request.POST = get_postdata_with_sha256(self.payment, status='OK', step='Payment') provider = BorgunProvider(sandbox=True) response = provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponse) self.assertEqual(self.payment.status, PaymentStatus.CONFIRMED)
def test_process_data(self): """ GoogleWalletProvider.process_data() returns a correct HTTP response """ payment = Payment() request = MagicMock() request.POST = {'jwt': jwt.encode(JWT_DATA, SELLER_SECRET)} provider = GoogleWalletProvider(payment, seller_id=SELLER_ID, seller_secret=SELLER_SECRET) response = provider.process_data(request) self.assertEqual(type(response), HttpResponse) self.assertEqual(payment.status, 'confirmed')
def test_address_save_with_address_in_group(self, mock_save): request = MagicMock() request.user.is_authenticated.return_value = False request.session = {} request.POST = dict(NEW_ADDRESS, method='dummy_shipping') group = MagicMock() group.address = NEW_ADDRESS storage = {'address': NEW_ADDRESS} step = ShippingStep(request, storage, group) self.assertTrue(step.forms_are_valid(), "Forms don't validate.") step.save() self.assertEqual(mock_save.call_count, 0)
def test_incorrect_process_data(self): """ECPayProvider.process_data() checks signature (CheckMacValue)""" data = dict(INPUT_POST) data.update({'TradeAmt': 10000}) request = MagicMock() request.POST = data provider = ECPayProvider( merchand_id=MERCHAND_ID, merchand_name=MERCHAND_NAME, hash_key=HASH_KEY, hash_iv=HASH_IV) response = provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponseForbidden)
def test_process_data_payment_input_barcode(self): """ ECPayProvider.process_data() returns a correct HTTP response when payment initiated """ request = MagicMock() request.POST = BARCODE_POST provider = ECPayProvider( merchand_id=MERCHAND_ID, merchand_name=MERCHAND_NAME, hash_key=HASH_KEY, hash_iv=HASH_IV) response = provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponse) self.assertEqual(self.payment.status, PaymentStatus.INPUT)
def test_process_data_payment_success(self): """ ECPayProvider.process_data() returns a correct HTTP response when payment succeful """ request = MagicMock() request.POST = SUCCESS_POST provider = ECPayProvider( merchand_id=MERCHAND_ID, merchand_name=MERCHAND_NAME, hash_key=HASH_KEY, hash_iv=HASH_IV) response = provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponse) self.assertEqual(self.payment.status, PaymentStatus.CONFIRMED)
def test_incorrect_process_data(self): """ GoogleWalletProvider.process_data() checks POST data """ data = dict(JWT_DATA, aud='wrong seller id') payment = Payment() request = MagicMock() payload = jwt.encode(data, SELLER_SECRET) request.POST = {'jwt': payload} provider = GoogleWalletProvider(payment, seller_id=SELLER_ID, seller_secret=SELLER_SECRET) response = provider.process_data(request) self.assertEqual(type(response), HttpResponseForbidden)
def test_address_save_with_address_in_checkout(self, mock_save): request = MagicMock() request.user.is_authenticated.return_value = False request.session = {} request.POST = dict(NEW_ADDRESS, method='dummy_shipping') original_billing_address = {'name': 'Change Me', 'id': 10} group = MagicMock() group.address = None storage = {'address': original_billing_address} step = ShippingStep(request, storage, group) self.assertTrue(step.forms_are_valid(), "Forms don't validate.") step.save() self.assertEqual(mock_save.call_count, 0) self.assertEqual(storage['address'], NEW_ADDRESS)
def test_process_data(self): """DotpayProvider.process_data() returns a correct HTTP response""" request = MagicMock() request.POST = get_post_with_md5(PROCESS_POST) params = { 'seller_id': 123, 'pin': PIN, 'endpoint': 'test.endpoint.com', 'channel': 1, 'lang': 'en', 'lock': True} provider = DotpayProvider(self.payment, **params) response = provider.process_data(request) self.assertEqual(type(response), HttpResponse)
def test_address_save_without_address(self, mock_save): request = MagicMock() request.user.is_authenticated.return_value = False request.session = {} request.POST = dict(NEW_ADDRESS, method='dummy_shipping') request.session = {STORAGE_SESSION_KEY: {}} group = MagicMock() group.address = None storage = {'address': NEW_ADDRESS} step = ShippingStep(request, storage, group) self.assertTrue(step.forms_are_valid(), "Forms don't validate.") step.save() self.assertEqual(mock_save.call_count, 0) self.assertTrue(isinstance(storage['address'], dict), 'dict expected')
def _build_mock_request(self, user=None, get=None, post=None): request = MagicMock() if user: request.user = user request.user.is_authenticated = MagicMock(return_value=True) else: request.user = AnonymousUser() request.GET = {} request.POST = {} request.resolver_match.kwargs = {} if get is not None: request.GET.update(get) if post is not None: request.POST.update(post) return request
def get_test_request(self): """ Sets up a mock request object """ request = MagicMock() request.LTI = dict(DEFAULT_LTI_PARAMS) request.method = "POST" request.lti_initial_request = True request.lti_authentication_successful = True request.POST = { "lti_message_type": "basic-lti-launch-request", "custom_component_display_name": "Not Scored Assignment" } request.session = {} request.user = self.get_test_user() return request
def test_process_data_payment_accepted(self): """DotpayProvider.process_data() returns a correct HTTP response""" request = MagicMock() request.POST = get_post_with_sha256(PROCESS_POST) params = { 'seller_id': 123, 'pin': PIN, 'endpoint': 'test.endpoint.com', 'channel': 1, 'lang': 'en', 'lock': True } provider = DotpayProvider(**params) response = provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponse) self.assertEqual(self.payment.status, PaymentStatus.CONFIRMED)
def test_process_data_payment_rejected(self): """DotpayProvider.process_data() returns a correct HTTP response""" data = dict(PROCESS_POST) data.update({'t_status': str(REJECTED)}) request = MagicMock() request.POST = get_post_with_md5(data) params = { 'seller_id': 123, 'pin': PIN, 'endpoint': 'test.endpoint.com', 'channel': 1, 'lang': 'en', 'lock': True} provider = DotpayProvider(**params) response = provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponse) self.assertEqual(self.payment.status, 'rejected')
def test_process_data_payment_rejected(self): """DotpayProvider.process_data() returns a correct HTTP response""" data = dict(PROCESS_POST) data.update({'operation_status': REJECTED}) request = MagicMock() request.POST = get_post_with_sha256(data) params = { 'seller_id': 123, 'pin': PIN, 'endpoint': 'test.endpoint.com', 'channel': 1, 'lang': 'en', 'lock': True } provider = DotpayProvider(**params) response = provider.process_data(self.payment, request) self.assertEqual(type(response), HttpResponse) self.assertEqual(self.payment.status, PaymentStatus.REJECTED)
def _build_mock_request(self, user=None, get=None, post=None): request = MagicMock() if user: request.user = user if django.VERSION[:2] >= (1, 10): # Django 1.10 made `User.is_authenticated` into a property for # some reason. request.user.is_authenticated.__get__ = MagicMock(return_value=True) # nopep8 else: request.user.is_authenticated = MagicMock(return_value=True) else: request.user = AnonymousUser() request.GET = {} request.POST = {} request.resolver_match.kwargs = {} if get is not None: request.GET.update(get) if post is not None: request.POST.update(post) return request
def test_provider_redirects_on_failure( self, mocked_request, mocked_redirect): transaction_id = 1234 xid = 'abc' self.payment.attrs.xid = xid response = MagicMock() response.requestID = transaction_id response.reasonCode = 'test code' mocked_request.return_value = response request = MagicMock() request.POST = {'MD': xid} request.GET = {'token': signing.dumps({ 'expiration': {'year': 2020, 'month': 9}, 'name': 'John Doe', 'number': '371449635398431', 'cvv2': '123' })} self.provider.process_data(self.payment, request) self.assertEqual(self.payment.status, 'error') self.assertEqual(self.payment.captured_amount, 0) self.assertEqual(self.payment.transaction_id, transaction_id)