Пример #1
0
    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')
Пример #2
0
    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)
Пример #3
0
 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)
Пример #4
0
 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)
Пример #5
0
 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)
Пример #6
0
 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)
Пример #7
0
 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)
Пример #8
0
    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)
Пример #10
0
 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)
Пример #11
0
    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)
Пример #12
0
 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.")
Пример #13
0
    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)
Пример #14
0
    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)
Пример #15
0
    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)
Пример #16
0
 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.")
Пример #17
0
    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)
Пример #18
0
    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)
Пример #19
0
 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)
Пример #20
0
 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)
Пример #21
0
    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, [])
Пример #22
0
    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)
Пример #23
0
    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)
Пример #24
0
 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)
Пример #26
0
 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')
Пример #27
0
 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
Пример #28
0
    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)
Пример #30
0
 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')
Пример #31
0
 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
Пример #32
0
    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)
Пример #33
0
 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')
Пример #34
0
    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_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)
Пример #36
0
 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')
Пример #37
0
 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)
Пример #38
0
 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)
Пример #39
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)
Пример #40
0
 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)
Пример #41
0
 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)
Пример #42
0
 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)
Пример #43
0
 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)
Пример #44
0
 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)
Пример #45
0
 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)
Пример #46
0
 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')
Пример #47
0
 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')
Пример #48
0
 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
Пример #49
0
 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
Пример #50
0
 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
Пример #51
0
 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)
Пример #52
0
 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')
Пример #53
0
 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)
Пример #54
0
 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
Пример #55
0
    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)