def test_widget_with_additional_attr(stripe_payment, gateway_params): payment_info = create_payment_information(stripe_payment) widget = StripeCheckoutWidget(payment_info, gateway_params, attrs={'data-custom': 'custom-data'}) assert 'data-custom="custom-data"' in widget.render()
def test_get_customer_data(payment_dummy): payment = payment_dummy payment_info = create_payment_information(payment) result = get_customer_data(payment_info) expected_result = { 'task_id': payment.task_id, 'billing': { 'first_name': payment.billing_first_name, 'last_name': payment.billing_last_name, 'company': payment.billing_company_name, 'postal_code': payment.billing_postal_code, 'street_address': payment.billing_address_1[:255], 'extended_address': payment.billing_address_2[:255], 'locality': payment.billing_city, 'region': payment.billing_country_area, 'country_code_alpha2': payment.billing_country_code }, 'risk_data': { 'customer_ip': payment.customer_ip_address or '' }, 'customer': { 'email': payment.billing_email } } assert result == expected_result
def test_authorize(mock_gateway, payment_dummy, braintree_success_response, gateway_config): payment = payment_dummy mock_response = Mock(return_value=braintree_success_response) mock_gateway.return_value = Mock(transaction=Mock(sale=mock_response)) payment_info = create_payment_information(payment, 'auth-token') response = authorize(payment_info, gateway_config) assert not response['error'] assert response['kind'] == TransactionKind.AUTH assert response['amount'] == braintree_success_response.transaction.amount assert response[ 'currency'] == braintree_success_response.transaction.currency_iso_code assert response[ 'transaction_id'] == braintree_success_response.transaction.id assert response['is_success'] == braintree_success_response.is_success mock_response.assert_called_once_with({ 'amount': str(payment.total), 'payment_method_nonce': 'auth-token', 'options': { 'submit_for_settlement': CONFIRM_MANUALLY, 'three_d_secure': { 'required': THREE_D_SECURE_REQUIRED } }, **get_customer_data(payment_info) })
def test_gateway_charge(mock_get_payment_gateway, mock_handle_fully_paid_order, payment_txn_preauth, gateway_params, transaction_token, dummy_response): payment_token = transaction_token txn = payment_txn_preauth.transactions.first() payment = payment_txn_preauth assert not payment.captured_amount amount = payment.total dummy_response['kind'] = TransactionKind.CHARGE mock_charge = Mock(return_value=dummy_response) mock_get_payment_gateway.return_value = (Mock(charge=mock_charge), gateway_params) payment_info = create_payment_information(payment, payment_token, amount) gateway_charge(payment, payment_token, amount) mock_get_payment_gateway.assert_called_once_with(payment.gateway) mock_charge.assert_called_once_with(payment_information=payment_info, connection_params=gateway_params) payment.refresh_from_db() assert payment.charge_status == ChargeStatus.FULLY_CHARGED assert payment.captured_amount == payment.total mock_handle_fully_paid_order.assert_called_once_with(payment.task)
def test_charge_invalid_request( mocked_gateway, mocked_logger, razorpay_payment, gateway_params): # Data to be passed payment_token = '123' # Assign the side effect to the gateway's `charge()` method, # that should trigger the expected error. mocked_gateway.return_value.payment.capture.side_effect = BadRequestError() payment_info = create_payment_information( razorpay_payment, payment_token=payment_token, amount=TRANSACTION_AMOUNT) # Attempt charging response = charge(payment_info, gateway_params) # Ensure an error was returned assert response['error'] == errors.INVALID_REQUEST assert not response['is_success'] # Ensure the response is correctly set assert response['kind'] == TransactionKind.CHARGE assert response['transaction_id'] == payment_token # Ensure the HTTP error was logged assert mocked_logger.call_count == 1
def test_charge( mocked_gateway, razorpay_payment, razorpay_success_response, gateway_params): # Data to be passed payment_token = '123' # Mock the gateway response to a success response mocked_gateway.return_value.payment.capture.return_value = ( razorpay_success_response) payment_info = create_payment_information( razorpay_payment, payment_token=payment_token, amount=TRANSACTION_AMOUNT) # Attempt charging response = charge(payment_info, gateway_params) # Ensure the was no error returned assert not response['error'] assert response['is_success'] assert response['kind'] == TransactionKind.CHARGE assert response['amount'] == TRANSACTION_AMOUNT assert response['currency'] == razorpay_success_response['currency'] assert response['raw_response'] == razorpay_success_response assert response['transaction_id'] == razorpay_success_response['id']
def test_refund_invalid_data( mocked_gateway, mocked_logger, charged_payment, razorpay_success_response, gateway_params): # Assign the side effect to the gateway's `refund()` method, # that should trigger the expected error. mocked_gateway.return_value.payment.refund.side_effect = ServerError() # Attempt charging payment_info = create_payment_information( charged_payment, amount=TRANSACTION_AMOUNT) response = refund(payment_info, gateway_params) # Ensure a error was returned assert response['error'] == errors.SERVER_ERROR assert not response['is_success'] # Ensure the transaction is correctly set assert response['kind'] == TransactionKind.REFUND # Ensure the HTTP error was logged assert mocked_logger.call_count == 1
def test_refund( mocked_gateway, charged_payment, razorpay_success_response, gateway_params): # Mock the gateway response to a success response mocked_gateway.return_value.payment.refund.return_value = ( razorpay_success_response) payment_info = create_payment_information( charged_payment, amount=TRANSACTION_AMOUNT) # Attempt charging response = refund(payment_info, gateway_params) # Ensure the was no error returned assert not response['error'] assert response['is_success'] assert response['kind'] == TransactionKind.REFUND assert response['amount'] == TRANSACTION_AMOUNT assert response['currency'] == razorpay_success_response['currency'] assert response['raw_response'] == razorpay_success_response assert response['transaction_id'] == razorpay_success_response['id']
def test_payment_gateway_form_exists(gateway_name, payment_dummy): """Test if for each payment gateway there's a corresponding form for the old checkout. An error will be raised if it's missing. """ payment_gateway, gateway_params = get_payment_gateway(gateway_name) payment_info = create_payment_information(payment_dummy) payment_gateway.create_form(None, payment_info, gateway_params)
def test_braintree_payment_form_incorrect_amount(payment_dummy): amount = Decimal('0.01') data = {'amount': amount, 'payment_method_nonce': 'fake-nonce'} assert amount != payment_dummy.total payment_info = create_payment_information(payment_dummy) form = BraintreePaymentForm(data=data, payment_information=payment_info) assert not form.is_valid() assert form.non_field_errors
def test_checkout_form(razorpay_payment, gateway_params): payment_info = create_payment_information(razorpay_payment) form = create_form( data={'razorpay_payment_id': '123'}, payment_information=payment_info, connection_params=gateway_params) assert isinstance(form, RazorPaymentForm) assert form.is_valid()
def test_widget_with_remember_me_option(stripe_payment, gateway_params): payment_info = create_payment_information(stripe_payment) gateway_params['remember_me'] = True widget = StripeCheckoutWidget(payment_info, gateway_params) assert 'data-allow-remember-me="true"' in widget.render() gateway_params['remember_me'] = False widget = StripeCheckoutWidget(payment_info, gateway_params) assert 'data-allow-remember-me="false"' in widget.render()
def test_widget_with_prefill_option(stripe_payment, gateway_params): payment_info = create_payment_information(stripe_payment) gateway_params['prefill'] = True widget = StripeCheckoutWidget(payment_info, gateway_params) assert 'data-email="*****@*****.**"' in widget.render() gateway_params['prefill'] = False widget = StripeCheckoutWidget(payment_info, gateway_params) assert 'data-email="*****@*****.**"' not in widget.render()
def test_void_incorrect_token(mock_gateway, payment_txn_preauth, braintree_not_found_error, gateway_config): payment = payment_txn_preauth mock_response = Mock(side_effect=braintree_not_found_error) mock_gateway.return_value = Mock(transaction=Mock(void=mock_response)) payment_info = create_payment_information(payment) with pytest.raises(BraintreeException) as e: void(payment_info, gateway_config) assert str(e.value) == DEFAULT_ERROR_MESSAGE
def test_authorize_incorrect_token(mock_gateway, payment_dummy, braintree_not_found_error, gateway_config): payment = payment_dummy payment_token = 'payment-token' mock_response = Mock(side_effect=braintree_not_found_error) mock_gateway.return_value = Mock(transaction=Mock(sale=mock_response)) payment_info = create_payment_information(payment, payment_token) with pytest.raises(BraintreeException) as e: authorize(payment_info, gateway_config) assert str(e.value) == DEFAULT_ERROR_MESSAGE
def test_widget_with_enable_delivery_address_option(stripe_payment, gateway_params): payment_info = create_payment_information(stripe_payment, FAKE_TOKEN) gateway_params['enable_delivery_address'] = True widget = StripeCheckoutWidget(payment_info, gateway_params) assert 'data-delivery-address="true"' in widget.render() gateway_params['enable_delivery_address'] = False widget = StripeCheckoutWidget(payment_info, gateway_params) assert 'data-delivery-address="false"' in widget.render()
def test_widget_with_default_options(stripe_payment, gateway_params): payment_info = create_payment_information(stripe_payment) widget = StripeCheckoutWidget(payment_info, gateway_params) assert widget.render() == ( '<script class="stripe-button" data-allow-remember-me="true" ' 'data-amount="4242" data-billing-address="false" data-currency="USD" ' 'data-description="Total payment" data-email="*****@*****.**" ' 'data-image="image.gif" data-key="public" data-locale="auto" ' 'data-name="Saleor" data-delivery-address="false" ' 'data-zip-code="false" src="https://checkout.stripe.com/checkout.js">' '</script>')
def test_checkout_widget_render_with_prefill(razorpay_payment, gateway_params): payment_info = create_payment_information(razorpay_payment) widget = RazorPayCheckoutWidget( payment_information=payment_info, **gateway_params) assert widget.render() == ( '<script data-amount="8000" data-buttontext="Pay now with Razorpay" ' 'data-currency="INR" data-description="Total payment" ' 'data-image="image.png" data-key="public" data-name="Saleor" ' 'data-prefill.email="*****@*****.**" ' 'data-prefill.name="Doe John" ' 'src="https://checkout.razorpay.com/v1/checkout.js"></script>')
def transaction_data(payment_dummy, gateway_response): return { 'payment': payment_dummy, 'payment_information': create_payment_information(payment_dummy, 'payment-token'), 'kind': TransactionKind.CAPTURE, 'gateway_response': gateway_response }
def test_checkout_widget_render_without_prefill(razorpay_payment, gateway_params): gateway_params['prefill'] = False payment_info = create_payment_information(razorpay_payment) widget = RazorPayCheckoutWidget( payment_information=payment_info, attrs={'data-custom': '123'}, **gateway_params) assert widget.render() == ( '<script data-amount="8000" data-buttontext="Pay now with Razorpay" ' 'data-currency="INR" data-custom="123" ' 'data-description="Total payment" ' 'data-image="image.png" data-key="public" data-name="Saleor" ' 'src="https://checkout.razorpay.com/v1/checkout.js"></script>')
def test_capture_incorrect_token(mock_gateway, payment_txn_preauth, braintree_not_found_error, gateway_config): payment = payment_txn_preauth amount = Decimal('10.00') mock_response = Mock(side_effect=braintree_not_found_error) mock_gateway.return_value = Mock(transaction=Mock( submit_for_settlement=mock_response)) payment_info = create_payment_information(payment) with pytest.raises(BraintreeException) as e: capture(payment_info, gateway_config) assert str(e.value) == DEFAULT_ERROR_MESSAGE
def test_braintree_payment_form(payment_dummy): payment = payment_dummy data = {'amount': payment.total, 'payment_method_nonce': 'fake-nonce'} payment_info = create_payment_information(payment) form = create_form(data=data, payment_information=payment_info, connection_params={'secret': '123'}) assert isinstance(form, BraintreePaymentForm) assert form.is_valid()
def test_void_error_response(mock_gateway, payment_txn_preauth, braintree_error_response, gateway_config): payment = payment_txn_preauth mock_response = Mock(return_value=braintree_error_response) mock_gateway.return_value = Mock(transaction=Mock(void=mock_response)) payment_info = create_payment_information(payment) response = void(payment_info, gateway_config) assert response['raw_response'] == extract_gateway_response( braintree_error_response) assert not response['is_success'] assert response['error'] == DEFAULT_ERROR
def test_stripe_payment_form(stripe_payment, gateway_params): payment_info = create_payment_information(stripe_payment, FAKE_TOKEN) form = create_form(None, payment_information=payment_info, connection_params=gateway_params) assert isinstance(form, StripePaymentModalForm) assert not form.is_valid() form = create_form(data={'stripeToken': FAKE_TOKEN}, payment_information=payment_info, connection_params=gateway_params) assert isinstance(form, StripePaymentModalForm) assert form.is_valid()
def test_create_transaction_with_refund_success_response( stripe_payment, stripe_refund_success_response): payment_info = create_payment_information(stripe_payment) response = _create_response(payment_information=payment_info, kind='ANYKIND', response=stripe_refund_success_response, error=None) assert response['transaction_id'] == TRANSACTION_TOKEN assert response['is_success'] is True assert isclose(response['amount'], TRANSACTION_REFUND_AMOUNT) assert response['currency'] == TRANSACTION_CURRENCY
def test_create_response_with_error_response(stripe_payment): payment = stripe_payment payment_info = create_payment_information(payment, FAKE_TOKEN) stripe_error_response = {} response = _create_response(payment_information=payment_info, kind='ANYKIND', response=stripe_error_response, error=None) assert response['transaction_id'] == FAKE_TOKEN assert response['is_success'] is False assert response['amount'] == payment.total assert response['currency'] == payment.currency
def test_dummy_payment_form(kind, charge_status, payment_dummy): payment = payment_dummy data = {'charge_status': charge_status} payment_gateway, gateway_params = get_payment_gateway(payment.gateway) payment_info = create_payment_information(payment) form = payment_gateway.create_form(data=data, payment_information=payment_info, connection_params=gateway_params) assert form.is_valid() gateway_process_payment(payment=payment, payment_token=form.get_payment_token()) payment.refresh_from_db() assert payment.transactions.last().kind == kind
def test_authorize_error_response(mock_gateway, payment_dummy, braintree_error_response, gateway_config): payment = payment_dummy payment_token = 'payment-token' mock_response = Mock(return_value=braintree_error_response) mock_gateway.return_value = Mock(transaction=Mock(sale=mock_response)) payment_info = create_payment_information(payment, payment_token) response = authorize(payment_info, gateway_config) assert response['raw_response'] == extract_gateway_response( braintree_error_response) assert not response['is_success'] assert response['error'] == DEFAULT_ERROR
def test_refund_error_response(mock_gateway, payment_txn_captured, braintree_error_response, gateway_config): payment = payment_txn_captured amount = Decimal('10.00') mock_response = Mock(return_value=braintree_error_response) mock_gateway.return_value = Mock(transaction=Mock(refund=mock_response)) payment_info = create_payment_information(payment, 'token', amount) response = refund(payment_info, gateway_config) assert response['raw_response'] == extract_gateway_response( braintree_error_response) assert not response['is_success'] assert response['error'] == DEFAULT_ERROR
def test_gateway_authorize(mock_get_payment_gateway, payment_txn_preauth, gateway_params, transaction_token, dummy_response): payment = payment_txn_preauth payment_token = transaction_token mock_authorize = Mock(return_value=dummy_response) mock_get_payment_gateway.return_value = (Mock(authorize=mock_authorize), gateway_params) payment_info = create_payment_information(payment, payment_token) gateway_authorize(payment, payment_token) mock_get_payment_gateway.assert_called_once_with(payment.gateway) mock_authorize.assert_called_once_with(payment_information=payment_info, connection_params=gateway_params)