solidus_six_saferpay 0.1.3 → 0.2.0

data/spec/services/spree/solidus_six_saferpay/initialize_payment_spec.rb

@@ -0,0 +1,40 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe InitializePayment do
+
+      let(:order) { create(:order) }
+      let(:payment_method) { create(:saferpay_payment_method) }
+
+      let(:service) { described_class.new(order, payment_method) }
+
+      describe '.call' do
+        it 'calls an initialized service with given order and payment method' do
+          expect(described_class).to receive(:new).with(order, payment_method).and_return(service)
+          expect(service).to receive(:call)
+
+          described_class.call(order, payment_method)
+        end
+      end
+
+      describe '#call' do
+        it 'fails because gateway raises an error' do
+          expect { service.call }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe '#gateway' do
+        it 'raises an error because the gateway must be defined in subclasses' do
+          expect { service.gateway }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe '#success?' do
+        it 'is initially false' do
+          expect(service.success).to be false
+        end
+      end
+    end
+  end
+end

data/spec/services/spree/solidus_six_saferpay/initialize_transaction_spec.rb

@@ -0,0 +1,85 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe InitializeTransaction do
+
+      let(:order) { create(:order) }
+      let(:payment_method) { create(:saferpay_payment_method) }
+
+      subject { described_class.new(order, payment_method) }
+
+
+      describe '#gateway' do
+        it_behaves_like "it uses the transaction gateway"
+      end
+
+      describe '#call' do
+        let(:token) {  '234uhfh78234hlasdfh8234e1234' }
+        let(:expiration) { '2015-01-30T12:45:22.258+01:00' }
+        let(:redirect_url) { '/saferpay/redirect/url' }
+
+        # https://saferpay.github.io/jsonapi/#Payment_v1_Transaction_Initialize
+        let(:api_response) do
+          SixSaferpay::SixTransaction::InitializeResponse.new(
+            response_header: SixSaferpay::ResponseHeader.new(request_id: 'test', spec_version: 'test'),
+            token: token,
+            expiration: expiration,
+            liability_shift: nil, # this is empty because we don't submit PaymentMeans on initialize already
+            redirect_required: true, 
+            redirect: SixSaferpay::Redirect.new(redirect_url: redirect_url, payment_means_required: true) # since we don't provide PaymentMeans on initialize, we must always redirect
+          )
+        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', initialize_payment: 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 create a saferpay payment' do
+            expect { subject.call }.not_to change { Spree::SixSaferpayPayment.count }
+          end
+        end
+
+        context 'when successful' do
+          let(:gateway_success) { true }
+
+          it 'creates a new saferpay payment' do
+            expect { subject.call }.to change { Spree::SixSaferpayPayment.count }.from(0).to(1)
+          end
+
+          it 'sets the redirect_url' do
+            subject.call
+
+            expect(subject.redirect_url).to eq(redirect_url)
+          end
+
+          it 'indicates success' do
+            subject.call
+
+            expect(subject).to be_success
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/services/spree/solidus_six_saferpay/inquire_payment_page_payment_spec.rb

@@ -0,0 +1,116 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe InquirePaymentPagePayment do
+
+      let(:payment) { create(:six_saferpay_payment) }
+
+      subject { described_class.new(payment) }
+
+
+      describe '#gateway' do
+        it_behaves_like "it uses the payment page gateway"
+      end
+
+
+      describe '#call' do
+
+        before do
+          allow(subject).to receive(:gateway).and_return(double('gateway', inquire: gateway_response))
+        end
+        
+        context 'when gateway response is not successful' do
+          let(:gateway_success) { false }
+          let(:error_behaviour) { "ABORT" }
+          let(:error_name) { "VALIDATION_FAILED" }
+          let(:error_message) { "Request validation failed" }
+          let(:api_response) { nil }
+          let(:translated_general_error) { "General Error" }
+          let(:translated_user_message) { "User Message" }
+
+          let(:gateway_response) do
+            ::SolidusSixSaferpay::GatewayResponse.new(
+              gateway_success,
+              "initialize success: #{gateway_success}",
+              api_response,
+              error_name: error_name,
+            )
+          end
+
+          it 'still indicates success' do
+            subject.call
+
+            expect(subject).to be_success
+          end
+
+          it 'adds the error message to the response hash' do
+            expect { subject.call }.to change { payment.response_hash }.from({}).to({error: error_name})
+          end
+
+          it 'sets the user message according to the api error code' do
+            expect(I18n).to receive(:t).with(:general_error, scope: [:solidus_six_saferpay, :errors]).and_return(translated_general_error)
+            expect(I18n).to receive(:t).with(error_name, scope: [:six_saferpay, :error_names]).and_return(translated_user_message)
+            subject.call
+
+            expect(subject.user_message).to eq("#{translated_general_error}: #{translated_user_message}")
+          end
+        end
+
+        context 'when successful' 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
+          let(:api_response) do
+            SixSaferpay::SixPaymentPage::AssertResponse.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_success) { true }
+          let(:gateway_response) do
+            ::SolidusSixSaferpay::GatewayResponse.new(
+              gateway_success,
+              "initialize success: #{gateway_success}",
+              api_response
+            )
+          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
+
+          it 'indicates success' do
+            subject.call
+
+            expect(subject).to be_success
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/services/spree/solidus_six_saferpay/inquire_payment_spec.rb

@@ -0,0 +1,39 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe InquirePayment do
+
+      let(:payment) { create(:six_saferpay_payment, :authorized) }
+
+      let(:service) { described_class.new(payment) }
+
+      describe '.call' do
+        it 'calls an initialized service with given order and payment method' do
+          expect(described_class).to receive(:new).with(payment).and_return(service)
+          expect(service).to receive(:call)
+
+          described_class.call(payment)
+        end
+      end
+
+      describe '#call' do
+        it 'fails because gateway raises an error' do
+          expect { service.call }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe '#gateway' do
+        it 'raises an error because the gateway must be defined in subclasses' do
+          expect { service.gateway }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe '#success?' do
+        it 'is initially false' do
+          expect(service).not_to be_success
+        end
+      end
+    end
+  end
+end

data/spec/services/spree/solidus_six_saferpay/inquire_transaction_payment_spec.rb

@@ -0,0 +1,117 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe InquireTransactionPayment do
+
+      let(:payment) { create(:six_saferpay_payment) }
+
+      subject { described_class.new(payment) }
+
+
+      describe '#gateway' do
+        it_behaves_like "it uses the transaction gateway"
+      end
+
+
+      describe '#call' do
+
+        before do
+          allow(subject).to receive(:gateway).and_return(double('gateway', inquire: gateway_response))
+        end
+        
+        context 'when gateway response is not successful' do
+          let(:gateway_success) { false }
+          let(:error_behaviour) { "ABORT" }
+          let(:error_name) { "VALIDATION_FAILED" }
+          let(:error_message) { "Request validation failed" }
+          let(:api_response) { nil }
+          let(:translated_general_error) { "General Error" }
+          let(:translated_user_message) { "User Message" }
+
+          let(:gateway_response) do
+            ::SolidusSixSaferpay::GatewayResponse.new(
+              gateway_success,
+              "initialize success: #{gateway_success}",
+              api_response,
+              error_name: error_name,
+            )
+          end
+
+          it 'still indicates success' do
+            subject.call
+
+            expect(subject).to be_success
+          end
+
+          it 'adds the error message to the response hash' do
+            expect { subject.call }.to change { payment.response_hash }.from({}).to({error: error_name})
+          end
+
+          it 'sets the user message according to the api error code' do
+            expect(I18n).to receive(:t).with(:general_error, scope: [:solidus_six_saferpay, :errors]).once.and_return(translated_general_error)
+            expect(I18n).to receive(:t).with(error_name, scope: [:six_saferpay, :error_names]).once.and_return(translated_user_message)
+
+            subject.call
+
+            expect(subject.user_message).to eq("#{translated_general_error}: #{translated_user_message}")
+          end
+        end
+
+        context 'when successful' 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
+          let(:api_response) do
+            SixSaferpay::SixPaymentPage::AssertResponse.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_success) { true }
+          let(:gateway_response) do
+            ::SolidusSixSaferpay::GatewayResponse.new(
+              gateway_success,
+              "initialize success: #{gateway_success}",
+              api_response
+            )
+          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
+
+          it 'indicates success' do
+            subject.call
+
+            expect(subject).to be_success
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/services/spree/solidus_six_saferpay/payment_validator_spec.rb

@@ -0,0 +1,100 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe PaymentValidator do
+
+      let(:payment) { create(:six_saferpay_payment, :authorized) }
+
+      let(:service) { described_class.new(payment) }
+
+      describe '.call' do
+        it 'calls an initialized service with given saferpay payment' do
+          expect(described_class).to receive(:new).with(payment).and_return(service)
+          expect(service).to receive(:call)
+
+          described_class.call(payment)
+        end
+      end
+
+      describe '#call' do
+        it 'performs multiple validations on the payment' do
+          expect(service).to receive(:validate_payment_authorized).with(payment.transaction)
+          expect(service).to receive(:validate_order_reference).with(payment.transaction)
+          expect(service).to receive(:validate_order_amount).with(payment.transaction)
+
+          service.call
+        end
+      end
+
+      describe '#validate_payment_authorized' do
+        let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", status: "AUTHORIZED") }
+
+        context 'when the saferpay status is AUTHORIZED' do
+          it 'passes validation' do
+            expect(service.validate_payment_authorized(saferpay_transaction)).to be true
+          end
+        end
+
+        context 'when the saferpay status is CAPTURED' do
+          let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", status: "CAPTURED") }
+          it 'raises an error' do
+            expect{ service.validate_payment_authorized(saferpay_transaction) }.to raise_error(::SolidusSixSaferpay::InvalidSaferpayPayment)
+          end
+        end
+
+        context 'when the saferpay status is PENDING' do
+          let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", status: "PENDING") }
+          it 'raises an error' do
+            expect{ service.validate_payment_authorized(saferpay_transaction) }.to raise_error(::SolidusSixSaferpay::InvalidSaferpayPayment)
+          end
+        end
+      end
+
+      describe '#validate_order_reference' do
+        context 'when the saferpay order reference matches the solidus order' do
+          let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", order_id: payment.order.number) }
+
+          it 'passes validation' do
+            expect(service.validate_order_reference(saferpay_transaction)).to be true
+          end
+        end
+
+        context 'when the saferpay order reference does not match the solidus order' do
+          let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", order_id: "OTHER") }
+
+          it 'raises an error' do
+            expect{ service.validate_order_reference(saferpay_transaction) }.to raise_error(::SolidusSixSaferpay::InvalidSaferpayPayment)
+          end
+        end
+      end
+
+      describe '#validate_order_amount' do
+          let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", amount: saferpay_amount) }
+        context 'when the saferpay payment values match the solidus order values' do
+          let(:saferpay_amount) { instance_double("SixSaferpay::Amount", value: (payment.order.amount * 100).to_s, currency_code: payment.order.currency) }
+
+          it 'passes validation' do
+            expect(service.validate_order_amount(saferpay_transaction)).to be true
+          end
+        end
+
+        context 'when the saferpay payment currency does not match the solidus order currency' do
+          let(:saferpay_amount) { instance_double("SixSaferpay::Amount", value: (payment.order.amount * 100).to_s, currency_code: "OTHER") }
+          
+          it 'raises an error' do
+            expect{ service.validate_order_amount(saferpay_transaction) }.to raise_error(::SolidusSixSaferpay::InvalidSaferpayPayment)
+          end
+        end
+
+        context 'when the saferpay payment value does not match the solidus order value' do
+          let(:saferpay_amount) { instance_double("SixSaferpay::Amount", value: ((payment.order.amount + 5) * 100).to_s, currency_code: payment.order.currency) }
+          
+          it 'raises an error' do
+            expect{ service.validate_order_amount(saferpay_transaction) }.to raise_error(::SolidusSixSaferpay::InvalidSaferpayPayment)
+          end
+        end
+      end
+    end
+  end
+end