solidus_afterpay 0.1.0 → 0.3.0

data/spec/models/solidus_afterpay/gateway_spec.rb

@@ -1,418 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusAfterpay::Gateway do
-  let(:gateway) { described_class.new(options) }
-  let(:options) do
-    {
-      merchant_id: ENV.fetch('AFTERPAY_MERCHANT_ID', 'dummy_merchant_id'),
-      secret_key: ENV.fetch('AFTERPAY_SECRET_KEY', 'dummy_secret_key'),
-      test_mode: true
-    }
-  end
-
-  describe '#authorize' do
-    subject(:response) { gateway.authorize(amount, payment_source, gateway_options) }
-
-    let(:order_token) { '002.m6d9jkrtv1p0j4jqslklhfq9k4nl54jo2530d58kf6snpqq1' }
-    let(:deferred?) { false }
-    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
-
-    let(:amount) { 1000 }
-    let(:payment_source) { build(:afterpay_payment_source, token: order_token, payment_method: payment_method) }
-    let(:gateway_options) { {} }
-
-    context 'with the immediate flow' do
-      it 'returns a successful response' do
-        is_expected.to be_success
-      end
-    end
-
-    context 'with the deferred flow' do
-      let(:deferred?) { true }
-
-      context 'with valid params', vcr: 'deferred/authorize/valid' do
-        it 'authorize the afterpay payment with the order_token' do
-          is_expected.to be_success
-        end
-      end
-
-      context 'with an invalid token', vcr: 'deferred/authorize/invalid' do
-        let(:order_token) { 'INVALID_TOKEN' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Cannot complete payment, expired or invalid token.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('invalid_token')
-        end
-      end
-
-      context 'with an invalid credit card', vcr: 'deferred/authorize/declined_payment' do
-        let(:order_token) { '002.ijlqnvko1o4ou45uabplrl9pqao8u2v52njs2972r24hje65' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq(
-            'Payment declined. Please contact the Afterpay Customer Service team for more information.'
-          )
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('payment_declined')
-        end
-      end
-    end
-  end
-
-  describe '#capture' do
-    subject(:response) { gateway.capture(amount, response_code, gateway_options) }
-
-    let(:order_token) { '002.nt7e0ioqj00fh0ua1nbqcj6vcn9obtfsglqvrj9ijpo3edfc' }
-    let(:deferred?) { false }
-    let(:payment_source) { build(:afterpay_payment_source, token: order_token) }
-    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
-    let(:payment) { build(:afterpay_payment, source: payment_source, payment_method: payment_method) }
-
-    let(:amount) { 1000 }
-    let(:response_code) { '100101782114' }
-    let(:gateway_options) { { originator: payment, currency: 'USD' } }
-
-    context 'with the immediate flow' do
-      context 'with valid params', vcr: 'immediate/capture/valid' do
-        it 'captures the afterpay payment with the order_token' do
-          is_expected.to be_success
-        end
-      end
-
-      context 'with an invalid token', vcr: 'immediate/capture/invalid' do
-        let(:order_token) { 'INVALID_TOKEN' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Cannot complete payment, expired or invalid token.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('invalid_token')
-        end
-      end
-
-      context 'with an invalid credit card', vcr: 'immediate/capture/declined_payment' do
-        let(:order_token) { '002.kj16plsn63eqfacueg767cp7l34e9ph5tms4ql14o2iid7l1' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq(
-            'Payment declined. Please contact the Afterpay Customer Service team for more information.'
-          )
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('payment_declined')
-        end
-      end
-    end
-
-    context 'with the deferred flow' do
-      let(:deferred?) { true }
-
-      context 'with valid params', vcr: 'deferred/capture/valid' do
-        it 'captures the afterpay payment with the order_id' do
-          is_expected.to be_success
-        end
-      end
-
-      context 'with an invalid payment ID', vcr: 'deferred/capture/invalid' do
-        let(:response_code) { 'INVALID_RESPONSE_CODE' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Afterpay payment ID not found.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('not_found')
-        end
-      end
-    end
-  end
-
-  describe '#purchase' do
-    subject(:response) { gateway.purchase(amount, payment_source, gateway_options) }
-
-    let(:order_token) { '002.nt7e0ioqj00fh0ua1nbqcj6vcn9obtfsglqvrj9ijpo3edfc' }
-    let(:deferred?) { false }
-    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
-    let(:payment) { build(:afterpay_payment, source: payment_source, payment_method: payment_method) }
-
-    let(:amount) { 1000 }
-    let(:payment_source) { build(:afterpay_payment_source, token: order_token, payment_method: payment_method) }
-    let(:gateway_options) { { originator: payment, currency: 'USD' } }
-
-    context 'with the immediate flow' do
-      context 'with valid params', vcr: 'immediate/capture/valid' do
-        it 'authorize and captures the afterpay payment with the order_token' do
-          is_expected.to be_success
-        end
-      end
-
-      context 'with an invalid token', vcr: 'immediate/capture/invalid' do
-        let(:order_token) { 'INVALID_TOKEN' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Cannot complete payment, expired or invalid token.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('invalid_token')
-        end
-      end
-
-      context 'with an invalid credit card', vcr: 'immediate/capture/declined_payment' do
-        let(:order_token) { '002.kj16plsn63eqfacueg767cp7l34e9ph5tms4ql14o2iid7l1' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq(
-            'Payment declined. Please contact the Afterpay Customer Service team for more information.'
-          )
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('payment_declined')
-        end
-      end
-    end
-
-    context 'with the deferred flow' do
-      let(:deferred?) { true }
-
-      context 'with valid params', vcr: 'deferred/authorize/valid' do
-        it 'authorize and captures the afterpay payment with the order_token' do
-          VCR.use_cassette('deferred/capture/valid') do
-            is_expected.to be_success
-          end
-        end
-      end
-
-      context 'with an invalid token', vcr: 'deferred/authorize/invalid' do
-        let(:order_token) { 'INVALID_TOKEN' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Cannot complete payment, expired or invalid token.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('invalid_token')
-        end
-      end
-
-      context 'with an invalid credit card', vcr: 'deferred/authorize/declined_payment' do
-        let(:order_token) { '002.kj16plsn63eqfacueg767cp7l34e9ph5tms4ql14o2iid7l1' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq(
-            'Payment declined. Please contact the Afterpay Customer Service team for more information.'
-          )
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('payment_declined')
-        end
-      end
-    end
-  end
-
-  describe '#credit' do
-    subject(:response) { gateway.credit(amount, response_code, gateway_options) }
-
-    let(:payment) { build(:afterpay_payment) }
-    let(:refund) { build(:refund, payment: payment) }
-
-    let(:amount) { 1000 }
-    let(:response_code) { '100101768366' }
-    let(:gateway_options) { { originator: refund } }
-
-    context 'with valid params', vcr: 'credit/valid' do
-      it 'refunds the amount using the response_code' do
-        is_expected.to be_success
-      end
-    end
-
-    context 'with an invalid response_code', vcr: 'credit/invalid' do
-      let(:response_code) { 'INVALID_RESPONSE_CODE' }
-
-      it 'returns an unsuccesfull response' do
-        is_expected.not_to be_success
-      end
-
-      it 'returns the error message from Afterpay in the response' do
-        expect(response.message).to eq('Afterpay payment ID not found.')
-      end
-
-      it 'returns the error_code from Afterpay in the response' do
-        expect(response.error_code).to eq('not_found')
-      end
-    end
-  end
-
-  describe '#void' do
-    subject(:response) { gateway.void(response_code, gateway_options) }
-
-    let(:deferred?) { false }
-    let(:amount) { 10 }
-    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
-    let(:payment) { build(:afterpay_payment, payment_method: payment_method, amount: amount) }
-
-    let(:response_code) { '100101785223' }
-    let(:gateway_options) { { originator: payment, currency: 'USD' } }
-
-    context 'with the immediate flow' do
-      it 'returns an unsuccessful response' do
-        is_expected.not_to be_success
-      end
-
-      it 'returns the error message from Afterpay in the response' do
-        expect(response.message).to eq("Transaction can't be voided")
-      end
-
-      it 'returns the error_code from Afterpay in the response' do
-        expect(response.error_code).to eq('void_not_allowed')
-      end
-    end
-
-    context 'with the deferred flow' do
-      let(:deferred?) { true }
-
-      context 'with valid params', vcr: 'deferred/void/valid' do
-        it 'voids the payment using the response_code' do
-          is_expected.to be_success
-        end
-      end
-
-      context 'with an invalid response_code', vcr: 'deferred/void/invalid' do
-        let(:response_code) { 'INVALID_RESPONSE_CODE' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Afterpay payment ID not found.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('not_found')
-        end
-      end
-    end
-  end
-
-  describe '#create_checkout' do
-    subject(:response) { gateway.create_checkout(order, gateway_options) }
-
-    let(:redirect_confirm_url) { 'https://merchantsite.com/confirm' }
-    let(:redirect_cancel_url) { 'https://merchantsite.com/cancel' }
-
-    let(:order) { build(:order_with_line_items) }
-    let(:gateway_options) { { redirect_confirm_url: redirect_confirm_url, redirect_cancel_url: redirect_cancel_url } }
-
-    context 'with valid params', vcr: 'create_checkout/valid' do
-      it 'creates the checkout' do
-        is_expected.to be_success
-      end
-
-      it 'returns the order_token' do
-        expect(response.params).to include('token')
-      end
-    end
-
-    context 'with an invalid params', vcr: 'create_checkout/invalid' do
-      let(:redirect_confirm_url) { 'INVALID_URL' }
-
-      it 'returns an unsuccesfull response' do
-        is_expected.not_to be_success
-      end
-
-      it 'returns the error message from Afterpay in the response' do
-        expect(response.message).to eq('merchant.redirectConfirmUrl must be a valid URL')
-      end
-
-      it 'returns the error_code from Afterpay in the response' do
-        expect(response.error_code).to eq('invalid_object')
-      end
-    end
-  end
-
-  describe '#find_payment' do
-    subject(:response) { gateway.find_payment(order_id: order_id) }
-
-    let(:order_id) { '100101785223' }
-
-    context 'with valid params', vcr: 'find_payment/valid' do
-      it 'retrieves the Afterpay payment' do
-        expect(response).to include('id' => order_id)
-      end
-    end
-
-    context 'with an invalid params', vcr: 'find_payment/invalid' do
-      let(:order_id) { 'INVALID_ORDER_ID' }
-
-      it 'returns nil' do
-        is_expected.to be_nil
-      end
-    end
-  end
-
-  describe '#retrieve_configuration' do
-    subject(:response) { gateway.retrieve_configuration }
-
-    context 'with valid response', vcr: 'retrieve_configuration/valid' do
-      it 'retrieves the afterpay configuration' do
-        expect(response).to include('minimumAmount', 'maximumAmount')
-      end
-    end
-
-    context 'with invalid response' do
-      before do
-        allow(::Afterpay::API::Configuration::Retrieve).to receive(:call).and_raise(::Afterpay::BaseError.new(nil))
-      end
-
-      it 'retrieves the afterpay configuration' do
-        expect(response).to be_nil
-      end
-    end
-  end
-end

data/spec/models/solidus_afterpay/order_component_builder_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusAfterpay::OrderComponentBuilder do
-  let(:order) { build(:order_with_line_items) }
-  let(:redirect_confirm_url) { 'https://merchantsite.com/confirm' }
-  let(:redirect_cancel_url) { 'https://merchantsite.com/cancel' }
-
-  let(:builder) do
-    described_class.new(
-      order: order,
-      redirect_confirm_url: redirect_confirm_url,
-      redirect_cancel_url: redirect_cancel_url
-    )
-  end
-
-  describe '#call' do
-    subject(:result) { builder.call }
-
-    let(:expected_result_not_combined) do
-      Afterpay::Components::Order.new(
-        amount: Afterpay::Components::Money.new(amount: '110.0', currency: 'USD'),
-        billing: Afterpay::Components::Contact.new(
-          area1: 'Herndon',
-          area2: nil,
-          country_code: nil,
-          line1: 'PO Box 1337',
-          line2: 'Northwest',
-          name: 'John',
-          phone_number: '555-555-0199',
-          postcode: order.billing_address.zipcode,
-          region: 'AL'
-        ),
-        consumer: Afterpay::Components::Consumer.new(
-          email: order.user.email,
-          given_names: 'John',
-          phone_number: nil,
-          surname: nil
-        ),
-        courier: nil,
-        discounts: nil,
-        items: [
-          Afterpay::Components::Item.new(
-            name: order.line_items.first.name,
-            price: Afterpay::Components::Money.new(
-              amount: '10.0',
-              currency: 'USD'
-            ),
-            quantity: 1,
-            sku: order.line_items.first.sku
-          )
-        ],
-        merchant: Afterpay::Components::Merchant.new(
-          redirect_confirm_url: 'https://merchantsite.com/confirm',
-          redirect_cancel_url: 'https://merchantsite.com/cancel'
-        ),
-        merchant_reference: order.number,
-        payment_type: nil,
-        shipping: Afterpay::Components::Contact.new(
-          area1: 'Herndon',
-          area2: nil,
-          country_code: nil,
-          line1: 'A Different Road',
-          line2: 'Northwest',
-          name: 'John',
-          phone_number: '555-555-0199',
-          postcode: order.shipping_address.zipcode,
-          region: 'AL'
-        ),
-        shipping_amount: nil,
-        tax_amount: nil
-      )
-    end
-
-    let(:expected_result_combined) do
-      Afterpay::Components::Order.new(
-        amount: Afterpay::Components::Money.new(amount: '110.0', currency: 'USD'),
-        billing: Afterpay::Components::Contact.new(
-          area1: 'Herndon',
-          area2: nil,
-          country_code: nil,
-          line1: 'PO Box 1337',
-          line2: 'Northwest',
-          name: 'John Von Doe',
-          phone_number: '555-555-0199',
-          postcode: order.billing_address.zipcode,
-          region: 'AL'
-        ),
-        consumer: Afterpay::Components::Consumer.new(
-          email: order.user.email,
-          given_names: 'John',
-          phone_number: nil,
-          surname: 'Von Doe'
-        ),
-        courier: nil,
-        discounts: nil,
-        items: [
-          Afterpay::Components::Item.new(
-            name: order.line_items.first.name,
-            price: Afterpay::Components::Money.new(
-              amount: '10.0',
-              currency: 'USD'
-            ),
-            quantity: 1,
-            sku: order.line_items.first.sku
-          )
-        ],
-        merchant: Afterpay::Components::Merchant.new(
-          redirect_confirm_url: 'https://merchantsite.com/confirm',
-          redirect_cancel_url: 'https://merchantsite.com/cancel'
-        ),
-        merchant_reference: order.number,
-        payment_type: nil,
-        shipping: Afterpay::Components::Contact.new(
-          area1: 'Herndon',
-          area2: nil,
-          country_code: nil,
-          line1: 'A Different Road',
-          line2: 'Northwest',
-          name: 'John Von Doe',
-          phone_number: '555-555-0199',
-          postcode: order.shipping_address.zipcode,
-          region: 'AL'
-        ),
-        shipping_amount: nil,
-        tax_amount: nil
-      )
-    end
-
-    let(:expected_result) do
-      SolidusSupport.combined_first_and_last_name_in_address? ? expected_result_combined : expected_result_not_combined
-    end
-
-    it 'returns the correct payload' do
-      expect(result.as_json).to eq(expected_result.as_json)
-    end
-  end
-end

data/spec/models/solidus_afterpay/payment_method_spec.rb

@@ -1,143 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusAfterpay::PaymentMethod, type: :model do
-  let(:payment_method) { described_class.new }
-
-  describe "#gateway_class" do
-    subject { payment_method.gateway_class }
-
-    it { is_expected.to eq(SolidusAfterpay::Gateway) }
-  end
-
-  describe "#payment_source_class" do
-    subject { payment_method.payment_source_class }
-
-    it { is_expected.to eq(SolidusAfterpay::PaymentSource) }
-  end
-
-  describe "#partial_name" do
-    subject { payment_method.partial_name }
-
-    it { is_expected.to eq('afterpay') }
-  end
-
-  describe "#try_void" do
-    subject { payment_method.try_void(payment) }
-
-    let(:response_code) { 'RESPONSE_CODE' }
-    let(:payment_source) { build(:afterpay_payment_source) }
-    let(:payment) { build(:afterpay_payment, response_code: response_code, source: payment_source) }
-
-    let(:can_void?) { true }
-    let(:gateway_response_success?) { true }
-    let(:gateway_response) { ActiveMerchant::Billing::Response.new(gateway_response_success?, '') }
-
-    let(:gateway_options) { { originator: payment, currency: 'USD' } }
-
-    before do
-      allow(payment_source).to receive(:can_void?).and_return(can_void?)
-      allow(payment_method).to receive(:void).with(response_code, gateway_options).and_return(gateway_response)
-    end
-
-    context 'when the void completes successful' do
-      it 'returns the void response' do
-        is_expected.to eq(gateway_response)
-      end
-    end
-
-    context 'when the void throws an error' do
-      let(:gateway_response_success?) { false }
-
-      it { is_expected.to be(false) }
-    end
-
-    context "when the payment can't be voided" do
-      let(:can_void?) { false }
-
-      it { is_expected.to be(false) }
-    end
-  end
-
-  describe "#available_for_order?" do
-    subject { payment_method.available_for_order?(order) }
-
-    let(:preferred_minimum_amount) { nil }
-    let(:preferred_maximum_amount) { nil }
-    let(:preferred_currency) { nil }
-
-    let(:payment_method) do
-      described_class.new(
-        preferred_minimum_amount: preferred_minimum_amount,
-        preferred_maximum_amount: preferred_maximum_amount,
-        preferred_currency: preferred_currency
-      )
-    end
-
-    let(:order) { build(:order, currency: order_currency, total: order_total) }
-    let(:order_total) { 5 }
-    let(:order_currency) { 'USD' }
-
-    let(:configuration) do
-      require 'hashie'
-
-      Hashie::Mash.new({
-        minimumAmount: { amount: '1', currency: 'USD' },
-        maximumAmount: { amount: '10', currency: 'USD' }
-      })
-    end
-
-    before do
-      allow(payment_method.gateway).to receive(:retrieve_configuration).and_return(configuration)
-    end
-
-    context 'when preference settings are nil' do
-      context 'when order total is inside the range' do
-        it { is_expected.to be(true) }
-      end
-
-      context 'when order total is outside the range' do
-        let(:order_total) { 11 }
-
-        it { is_expected.to be(false) }
-      end
-
-      context 'when order currency is different from afterpay configuration' do
-        let(:order_currency) { 'EUR' }
-
-        it { is_expected.to be(false) }
-      end
-
-      context "when afterpay configuration doesn't include the minumumAmount" do
-        let(:configuration) do
-          require 'hashie'
-
-          Hashie::Mash.new({ maximumAmount: { amount: '10', currency: 'USD' } })
-        end
-
-        it { is_expected.to be(true) }
-      end
-    end
-
-    context 'when preference settings are not nil' do
-      let(:preferred_minimum_amount) { 1 }
-      let(:preferred_maximum_amount) { 10 }
-      let(:preferred_currency) { 'USD' }
-
-      context 'when order total is inside the range' do
-        it { is_expected.to be(true) }
-      end
-
-      context 'when order total is outside the range' do
-        let(:order_total) { 11 }
-
-        it { is_expected.to be(false) }
-      end
-
-      context 'when order currency is different from afterpay configuration' do
-        let(:order_currency) { 'EUR' }
-
-        it { is_expected.to be(false) }
-      end
-    end
-  end
-end