solidus_six_saferpay 0.1.7 → 0.4.0

data/spec/solidus_six_saferpay/transaction_gateway_spec.rb

@@ -0,0 +1,390 @@
+require 'rails_helper'
+
+module SolidusSixSaferpay
+  RSpec.describe TransactionGateway do
+
+    # config options
+    let(:customer_id) { 'CUSTOMER_ID' }
+    let(:terminal_id) { 'TERMINAL_ID' }
+    let(:username) { 'USERNAME' }
+    let(:password) { 'PASSWORD' }
+    let(:base_url) { 'https://test.saferpay-api-host.test' }
+    let(:css_url) { '/custom/css/url' }
+
+    let(:gateway) do
+      described_class.new(
+        customer_id: customer_id,
+        terminal_id: terminal_id,
+        username: username,
+        password: password,
+        base_url: base_url,
+        css_url: css_url
+      )
+    end
+
+    let(:order) { create(:order, total: 100) }
+    let(:payment_method) { create(:saferpay_payment_method) }
+
+    let(:payment) { create(:six_saferpay_payment, order: order, payment_method: payment_method) }
+
+    before do
+      allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_CUSTOMER_ID').and_return(customer_id)
+      allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_TERMINAL_ID').and_return(terminal_id)
+      allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_USERNAME').and_return(username)
+      allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_PASSWORD').and_return(password)
+      allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_BASE_URL').and_return(base_url)
+      allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_CSS_URL').and_return(css_url)
+    end
+
+    describe '#initialize_payment' do
+
+      let(:saferpay_billing_address) do
+        instance_double("SixSaferpay::Address",
+          first_name: order.billing_address.first_name,
+          last_name: order.billing_address.last_name,
+          date_of_birth: nil,
+          company: nil,
+          gender: nil,
+          legal_form: nil,
+          street: order.billing_address.address1,
+          street2: order.billing_address.address2,
+          zip: order.billing_address.zipcode,
+          city: order.billing_address.city,
+          country_subdevision_code: nil,
+          country_code: order.billing_address.country.iso,
+          phone: nil,
+          email: nil,
+        )
+      end
+
+      let(:saferpay_shipping_address) do
+        instance_double("SixSaferpay::Address",
+          first_name: order.shipping_address.first_name,
+          last_name: order.shipping_address.last_name,
+          date_of_birth: nil,
+          company: nil,
+          gender: nil,
+          legal_form: nil,
+          street: order.shipping_address.address1,
+          street2: order.shipping_address.address2,
+          zip: order.shipping_address.zipcode,
+          city: order.shipping_address.city,
+          country_subdevision_code: nil,
+          country_code: order.shipping_address.country.iso,
+          phone: nil,
+          email: nil,
+        )
+      end
+
+      let(:saferpay_amount) do
+        instance_double("SixSaferpay::Amount",
+            value: (order.total * 100),
+            currency_code: order.currency
+          )
+      end
+
+      let(:saferpay_payment) do
+        instance_double("SixSaferpay::Payment",
+          amount: saferpay_amount,
+          order_id: order.number,
+          description: order.number
+        )
+      end
+
+      let(:saferpay_payer) do
+        instance_double("SixSaferpay::Payer",
+          language_code: I18n.locale,
+          billing_address: saferpay_billing_address,
+          delivery_address: saferpay_shipping_address
+        )
+      end
+
+      let(:return_urls) do
+        instance_double("SixSaferpay::ReturnUrls",
+          success: solidus_six_saferpay_transaction_success_url(order),
+          fd_fail: solidus_six_saferpay_transaction_fail_url(order),
+          fd_abort: solidus_six_saferpay_transaction_fail_url(order),
+         )
+      end
+
+      let(:initialize_params) do
+        {
+          payment: saferpay_payment,
+          payer: saferpay_payer,
+          return_urls: return_urls
+        }
+      end
+
+      let(:saferpay_initialize) do
+        instance_double("SixSaferpay::SixTransaction::Initialize")
+      end
+
+      let(:api_initialize_response) do
+        SixSaferpay::SixTransaction::InitializeResponse.new(
+          response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+          token: 'TOKEN',
+          expiration: '2015-01-30T12:45:22.258+01:00',
+          redirect_required: true,
+          redirect: SixSaferpay::Redirect.new(
+            redirect_url: '/redirect/url',
+            payment_means_required: true
+          )
+        )
+      end
+
+
+      it 'initializes a payment page payment' do
+        # mock payment
+        expect(SixSaferpay::Amount).to receive(:new).with(
+          value: (order.total * 100),
+          currency_code: order.currency
+        ).and_return(saferpay_amount)
+        expect(SixSaferpay::Payment).to receive(:new).with(
+          amount: saferpay_amount,
+          order_id: order.number,
+          description: order.number
+        ).and_return(saferpay_payment)
+
+
+        # mock payer
+        expect(SixSaferpay::Address).to receive(:new).with(
+          first_name: order.billing_address.first_name,
+          last_name: order.billing_address.last_name,
+          date_of_birth: nil,
+          company: nil,
+          gender: nil,
+          legal_form: nil,
+          street: order.billing_address.address1,
+          street2: order.billing_address.address2,
+          zip: order.billing_address.zipcode,
+          city: order.billing_address.city,
+          country_subdevision_code: nil,
+          country_code: order.billing_address.country.iso,
+          phone: nil,
+          email: nil,
+        ).and_return(saferpay_billing_address)
+        expect(SixSaferpay::Address).to receive(:new).with(
+          first_name: order.shipping_address.first_name,
+          last_name: order.shipping_address.last_name,
+          date_of_birth: nil,
+          company: nil,
+          gender: nil,
+          legal_form: nil,
+          street: order.shipping_address.address1,
+          street2: order.shipping_address.address2,
+          zip: order.shipping_address.zipcode,
+          city: order.shipping_address.city,
+          country_subdevision_code: nil,
+          country_code: order.shipping_address.country.iso,
+          phone: nil,
+          email: nil,
+        ).and_return(saferpay_shipping_address)
+        expect(SixSaferpay::Payer).to receive(:new).with(
+          language_code: I18n.locale,
+          billing_address: saferpay_billing_address,
+          delivery_address: saferpay_shipping_address
+        ).and_return(saferpay_payer)
+
+        # mock return_urls
+        expect(SixSaferpay::ReturnUrls).to receive(:new).with(
+          success: solidus_six_saferpay_transaction_success_url(order),
+          fd_fail: solidus_six_saferpay_transaction_fail_url(order),
+          fd_abort: solidus_six_saferpay_transaction_fail_url(order),
+        ).and_return(return_urls)
+
+        expect(SixSaferpay::SixTransaction::Initialize).to receive(:new).with(initialize_params).and_return(saferpay_initialize)
+
+        expect(SixSaferpay::Client).to receive(:post).with(saferpay_initialize).and_return(api_initialize_response)
+
+        gateway.initialize_payment(order, payment_method)
+      end
+
+      context 'when the payment initialization is successful' do
+        before do
+          expect(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Initialize)).and_return(api_initialize_response)
+        end
+
+        it 'returns a success gateway response' do
+          expect(GatewayResponse).to receive(:new).with(true, instance_of(String), api_initialize_response, {})
+          gateway.initialize_payment(order, payment_method)
+        end
+      end
+
+      context 'when the API raises an error' do
+        let(:six_saferpay_error) do
+          SixSaferpay::Error.new(
+            response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+            behavior: 'ABORT',
+            error_name: 'INVALID_TRANSACTION',
+            error_message: 'error_message'
+          )
+        end
+
+        before do
+          expect(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Initialize)).and_raise(six_saferpay_error)
+        end
+
+        it 'handles the error gracefully' do
+          expect(GatewayResponse).to receive(:new).with(false, six_saferpay_error.error_message, nil, error_name: six_saferpay_error.error_name)
+
+          gateway.initialize_payment(order, payment_method)
+        end
+      end
+    end
+
+    describe '#inquire' do
+
+      let(:saferpay_inquire) do
+        instance_double("SixSaferpay::SixTransaction::Inquire")
+      end
+
+      let(:transaction_status) { "AUTHORIZED" }
+      let(:transaction_id) { "723n4MAjMdhjSAhAKEUdA8jtl9jb" }
+      let(:transaction_date) { "2015-01-30T12:45:22.258+01:00" }
+      let(:amount_value) { "100" }
+      let(:amount_currency) { "USD" }
+      let(:brand_name) { 'PaymentBrand' }
+      let(:display_text) { "xxxx xxxx xxxx 1234" }
+      let(:six_transaction_reference) { "0:0:3:723n4MAjMdhjSAhAKEUdA8jtl9jb" }
+
+      let(:payment_means) do
+        SixSaferpay::ResponsePaymentMeans.new(
+          brand: SixSaferpay::Brand.new(name: brand_name),
+          display_text: display_text
+        )
+      end
+
+      let(:api_inquire_response) do
+        SixSaferpay::SixTransaction::InquireResponse.new(
+          response_header: SixSaferpay::ResponseHeader.new(request_id: 'test', spec_version: 'test'),
+          transaction: SixSaferpay::Transaction.new(
+            type: "PAYMENT",
+            status: transaction_status,
+            id: transaction_id,
+            date: transaction_date,
+            amount: SixSaferpay::Amount.new(value: amount_value, currency_code: amount_currency),
+            six_transaction_reference: six_transaction_reference,
+          ),
+          payment_means: payment_means
+        )
+      end
+
+      it 'performs an inquire request' do
+        expect(SixSaferpay::SixTransaction::Inquire).to receive(:new).with(transaction_reference: payment.transaction_id).and_return(saferpay_inquire)
+        expect(SixSaferpay::Client).to receive(:post).and_return(api_inquire_response)
+
+        gateway.inquire(payment)
+      end
+
+      context 'when the payment inquiry is successful' do
+        before do
+          allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Inquire)).and_return(api_inquire_response)
+        end
+
+        it 'returns a successful gateway response' do
+          expect(GatewayResponse).to receive(:new).with(true, instance_of(String), api_inquire_response, {})
+
+          gateway.inquire(payment)
+        end
+      end
+
+      context 'when the API returns an error' do
+        let(:six_saferpay_error) do
+          SixSaferpay::Error.new(
+            response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+            behavior: 'ABORT',
+            error_name: 'INVALID_TRANSACTION',
+            error_message: 'error_message'
+          )
+        end
+
+        before do
+          allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Inquire)).and_raise(six_saferpay_error)
+        end
+
+        it 'handles the error gracefully' do
+          expect(GatewayResponse).to receive(:new).with(false, six_saferpay_error.error_message, nil, error_name: six_saferpay_error.error_name)
+
+          gateway.inquire(payment)
+        end
+      end
+    end
+
+    describe '#authorize' do
+      let(:saferpay_authorize) do
+        instance_double("SixSaferpay::Transaction::Authorize")
+      end
+
+      let(:transaction_status) { "AUTHORIZED" }
+      let(:transaction_id) { "723n4MAjMdhjSAhAKEUdA8jtl9jb" }
+      let(:transaction_date) { "2015-01-30T12:45:22.258+01:00" }
+      let(:amount_value) { "100" }
+      let(:amount_currency) { "USD" }
+      let(:brand_name) { 'PaymentBrand' }
+      let(:display_text) { "xxxx xxxx xxxx 1234" }
+      let(:six_transaction_reference) { "0:0:3:723n4MAjMdhjSAhAKEUdA8jtl9jb" }
+
+      let(:payment_means) do
+        SixSaferpay::ResponsePaymentMeans.new(
+          brand: SixSaferpay::Brand.new(name: brand_name),
+          display_text: display_text
+        )
+      end
+
+      let(:api_authorize_response) do
+        SixSaferpay::SixTransaction::AuthorizeResponse.new(
+          response_header: SixSaferpay::ResponseHeader.new(request_id: 'test', spec_version: 'test'),
+          transaction: SixSaferpay::Transaction.new(
+            type: "PAYMENT",
+            status: transaction_status,
+            id: transaction_id,
+            date: transaction_date,
+            amount: SixSaferpay::Amount.new(value: amount_value, currency_code: amount_currency),
+            six_transaction_reference: six_transaction_reference,
+          ),
+          payment_means: payment_means
+        )
+      end
+      
+      it 'performs an authorize request' do
+        expect(SixSaferpay::SixTransaction::Authorize).to receive(:new).with(token: payment.token).and_return(saferpay_authorize)
+        expect(SixSaferpay::Client).to receive(:post).and_return(api_authorize_response)
+
+        gateway.authorize(payment.order.total, payment)
+      end
+
+      context 'when the payment authorize is successful' do
+        before do
+          allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Authorize)).and_return(api_authorize_response)
+        end
+
+        it 'returns a successful gateway response' do
+          expect(GatewayResponse).to receive(:new).with(true, instance_of(String), api_authorize_response, {})
+
+          gateway.authorize(payment.order.total, payment)
+        end
+      end
+
+      context 'when the API returns an error' do
+        let(:six_saferpay_error) do
+          SixSaferpay::Error.new(
+            response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+            behavior: 'ABORT',
+            error_name: 'INVALID_TRANSACTION',
+            error_message: 'error_message'
+          )
+        end
+
+        before do
+          allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Authorize)).and_raise(six_saferpay_error)
+        end
+
+        it 'handles the error gracefully' do
+          expect(GatewayResponse).to receive(:new).with(false, six_saferpay_error.error_message, nil, error_name: six_saferpay_error.error_name)
+
+          gateway.authorize(payment.order.total, payment)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
+# Run Coverage report
+require 'solidus_dev_support/rspec/coverage'
+
+require File.expand_path('dummy/config/environment.rb', __dir__)
+
+# Requires factories and other useful helpers defined in spree_core.
+require 'solidus_dev_support/rspec/feature_helper'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.infer_spec_type_from_file_location!
+  config.use_transactional_fixtures = false
+end

data/spec/support/route_access.rb

@@ -0,0 +1,6 @@
+RSpec.shared_examples "it has route access" do
+
+  it 'has access to routes' do
+    expect(subject).to respond_to(:url_helpers)
+  end
+end

data/spec/support/shared_examples/authorize_payment.rb

@@ -0,0 +1,132 @@
+RSpec.shared_examples 'authorize_payment' do
+
+  let(:transaction_status) { "AUTHORIZED" }
+  let(:transaction_id) { "723n4MAjMdhjSAhAKEUdA8jtl9jb" }
+  let(:transaction_date) { "2015-01-30T12:45:22.258+01:00" }
+  let(:amount_value) { "100" }
+  let(:amount_currency) { "USD" }
+  let(:brand_name) { 'PaymentBrand' }
+  let(:display_text) { "xxxx xxxx xxxx 1234" }
+  let(:six_transaction_reference) { "0:0:3:723n4MAjMdhjSAhAKEUdA8jtl9jb" }
+
+  let(:payment_means) do
+    SixSaferpay::ResponsePaymentMeans.new(
+      brand: SixSaferpay::Brand.new(name: brand_name),
+      display_text: display_text
+    )
+  end
+
+  # https://saferpay.github.io/jsonapi/#Payment_v1_PaymentPage_Assert
+  # https://saferpay.github.io/jsonapi/#Payment_v1_Transaction_Authorize
+  let(:api_response) do
+    api_response_class.new(
+      response_header: SixSaferpay::ResponseHeader.new(request_id: 'test', spec_version: 'test'),
+      transaction: SixSaferpay::Transaction.new(
+        type: "PAYMENT",
+        status: transaction_status,
+        id: transaction_id,
+        date: transaction_date,
+        amount: SixSaferpay::Amount.new(value: amount_value, currency_code: amount_currency),
+        six_transaction_reference: six_transaction_reference,
+      ),
+      payment_means: payment_means
+    )
+  end
+
+  let(:gateway_response) do
+    ::SolidusSixSaferpay::GatewayResponse.new(
+      gateway_success,
+      "initialize success: #{gateway_success}",
+      api_response
+    )
+  end
+
+  # stub gateway to return our mock response
+  before do
+    allow(subject).to receive(:gateway).
+      and_return(double('gateway', authorize: gateway_response))
+  end
+
+  context 'when not successful' do
+    let(:gateway_success) { false }
+
+    it 'indicates failure' do
+      subject.call
+
+      expect(subject).not_to be_success
+    end
+
+    it 'does not update the payment attributes' do
+      expect { subject.call }.not_to change { payment.transaction_id }
+      expect { subject.call }.not_to change { payment.transaction_status }
+      expect { subject.call }.not_to change { payment.transaction_date }
+      expect { subject.call }.not_to change { payment.six_transaction_reference }
+      expect { subject.call }.not_to change { payment.display_text }
+      expect { subject.call }.not_to change { payment.response_hash }
+    end
+  end
+
+  context 'when successful' do
+    let(:gateway_success) { true }
+
+    it 'updates the transaction_id' do
+      expect { subject.call }.to change { payment.transaction_id }.from(nil).to(transaction_id)
+    end
+
+    it 'updates the transaction status' do
+      expect { subject.call }.to change { payment.transaction_status }.from(nil).to(transaction_status)
+    end
+
+    it 'updates the transaction date' do
+      expect { subject.call }.to change { payment.transaction_date }.from(nil).to(DateTime.parse(transaction_date))
+    end
+
+    it 'updates the six_transaction_reference' do
+      expect { subject.call }.to change { payment.six_transaction_reference }.from(nil).to(six_transaction_reference)
+    end
+
+    it 'updates the display_text' do
+      expect { subject.call }.to change { payment.display_text }.from(nil).to(display_text)
+    end
+
+    it 'updates the response hash' do
+      expect { subject.call }.to change { payment.response_hash }.from(payment.response_hash).to(api_response.to_h)
+    end
+
+    context 'when the payment was made with a card' do
+      let(:masked_number) { "xxxx xxxx xxxx 5555" }
+      let(:exp_year) { "19" }
+      let(:exp_month) { "5" }
+      let(:payment_means) do
+        SixSaferpay::ResponsePaymentMeans.new(
+          brand: SixSaferpay::Brand.new(name: brand_name),
+          display_text: display_text,
+          card: SixSaferpay::ResponseCard.new(
+            masked_number: masked_number,
+            exp_year: exp_year,
+            exp_month: exp_month
+          )
+        )
+      end
+
+      it 'updates the masked number' do
+        expect { subject.call }.to change { payment.masked_number }.from(nil).to(masked_number)
+      end
+
+      it 'updates the expiry year' do
+        expect { subject.call }.to change { payment.expiration_year }.from(nil).to(exp_year)
+      end
+
+      it 'updates the expiry month' do
+        expect { subject.call }.to change { payment.expiration_month }.from(nil).to(exp_month)
+      end
+    end
+
+    it 'indicates success' do
+      subject.call
+
+      expect(subject).to be_success
+    end
+  end
+
+end