solidus_six_saferpay 0.1.8 → 0.5.0

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

@@ -0,0 +1,58 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe CancelAuthorizedPayment do
+
+
+      let(:service) { described_class.new(payment) }
+
+      describe '.call' do
+        let(:payment) { create(:six_saferpay_payment) }
+
+        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
+        let(:gateway) { instance_double(::SolidusSixSaferpay::Gateway) }
+
+        before do
+          allow(service).to receive(:gateway).and_return(gateway)
+        end
+
+        context 'when the payment has not been authorized yet' do
+          let(:payment) { create(:six_saferpay_payment) }
+
+          it 'does not cancel the payment' do
+            expect(gateway).not_to receive(:void)
+
+            service.call
+          end
+
+          it 'is treated as an error' do
+            expect(::SolidusSixSaferpay::ErrorHandler).to receive(:handle).with(instance_of(::SolidusSixSaferpay::InvalidSaferpayPayment))
+
+            service.call
+          end
+        end
+
+        context 'when the payment has been authorized already' do
+          let(:payment) { create(:six_saferpay_payment, :authorized) }
+
+          it 'voids the payment' do
+            expect(gateway).to receive(:void).with(payment.transaction_id)
+
+            service.call
+          end
+
+        end
+      end
+
+    end
+  end
+end

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

@@ -9,7 +9,6 @@ module Spree
 
       subject { described_class.new(order, payment_method) }
 
-
       describe '#gateway' do
         it_behaves_like "it uses the payment page gateway"
       end
@@ -37,7 +36,6 @@ module Spree
           )
         end
 
-        # stub gateway to return our mock response
         before do
           allow(subject).to receive(:gateway).
             and_return(double('gateway', initialize_payment: gateway_response))

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

@@ -39,7 +39,6 @@ module Spree
           )
         end
 
-        # stub gateway to return our mock response
         before do
           allow(subject).to receive(:gateway).
             and_return(double('gateway', initialize_payment: gateway_response))

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

@@ -5,112 +5,16 @@ module Spree
     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 'does not update the response hash' do
-            expect { subject.call }.not_to change { payment.response_hash }
-          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
+        let(:api_response_class) { SixSaferpay::SixPaymentPage::AssertResponse }
+        it_behaves_like "inquire_payment"
       end
-
     end
   end
 end

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

@@ -5,111 +5,15 @@ module Spree
     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 'does not update the response hash' do
-            expect { subject.call }.not_to change { payment.response_hash }
-          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
+        let(:api_response_class) { SixSaferpay::SixTransaction::InquireResponse }
+        it_behaves_like "inquire_payment"
       end
 
     end

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

@@ -0,0 +1,30 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe OrderNotFoundHandler do
+
+      let(:controller) { instance_double(SolidusSixSaferpay::CheckoutController) }
+      let(:order_number) { "R123445678" }
+
+      subject { described_class.new(controller_context: controller, order_number: order_number) }
+
+      describe '.call' do
+        it 'calls a new instance with given parameters' do
+          expect(described_class).to receive(:new).with(controller_context: controller, order_number: order_number).and_return(subject)
+          expect(subject).to receive(:call)
+
+          described_class.call(controller_context: controller, order_number: order_number)
+        end
+      end
+
+      describe '#call' do
+        it 'informs about the error' do
+          expect(::SolidusSixSaferpay::ErrorHandler).to receive(:handle).with(instance_of(StandardError))
+
+          subject.call
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe PaymentNotFoundHandler do
+
+      let(:controller) { instance_double(SolidusSixSaferpay::CheckoutController) }
+      let(:order) { instance_double(Spree::Order, number: "R12345678") }
+
+      subject { described_class.new(controller_context: controller, order: order) }
+
+      describe '.call' do
+        it 'calls a new instance with given parameters' do
+          expect(described_class).to receive(:new).with(controller_context: controller, order: order).and_return(subject)
+          expect(subject).to receive(:call)
+
+          described_class.call(controller_context: controller, order: order)
+        end
+      end
+
+      describe '#call' do
+        it 'informs about the error' do
+          expect(::SolidusSixSaferpay::ErrorHandler).to receive(:handle).with(instance_of(StandardError))
+
+          subject.call
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe PaymentProcessingSuccessHandler do
+
+      let(:controller) { instance_double(SolidusSixSaferpay::CheckoutController) }
+      let(:order) { instance_double(Spree::Order, number: "R12345678") }
+
+      subject { described_class.new(controller_context: controller, order: order) }
+
+      describe '.call' do
+        it 'calls a new instance with given parameters' do
+          expect(described_class).to receive(:new).with(controller_context: controller, order: order).and_return(subject)
+          expect(subject).to receive(:call)
+
+          described_class.call(controller_context: controller, order: order)
+        end
+      end
+
+      describe '#call' do
+        context 'when the order is in payment state' do
+          let(:order) { instance_double(Spree::Order, number: "R12345678", payment?: true) }
+
+          it 'advances the order to the next state' do
+            expect(order).to receive(:next!)
+
+            subject.call
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,213 +13,8 @@ module Spree
       end
 
       describe '#call' do
-
-        before do
-          allow(subject).to receive(:gateway).and_return(double('gateway'))
-        end
-
-        context 'liability_shift check' do
-
-          before do
-            allow(subject).to receive(:gateway).and_return(double('gateway'))
-
-
-            # ensure other methods don't modify outcome
-            allow(subject).to receive(:validate_payment!)
-            allow(subject).to receive(:cancel_old_solidus_payments)
-            allow(payment).to receive(:create_solidus_payment!)
-          end
-
-          context 'when liability shift is required' do
-            context 'and liability shift is not granted' do
-
-              let(:payment) { create(:six_saferpay_payment, :authorized, :without_liability_shift) }
-
-              it 'cancels the payment' do
-                expect(payment.payment_method.preferred_require_liability_shift).to be true
-                expect(payment.liability.liability_shift).to be false
-
-                expect(subject.gateway).to receive(:void).with(payment.transaction_id)
-
-                subject.call
-              end
-
-              it 'indicates failure' do
-                expect(payment.payment_method.preferred_require_liability_shift).to be true
-                expect(payment.liability.liability_shift).to be false
-
-                expect(subject.gateway).to receive(:void).with(payment.transaction_id)
-
-                subject.call
-
-                expect(subject).not_to be_success
-              end
-
-            end
-
-            context 'and liability shift is granted' do
-              it "doesn't cancel the payment" do
-                expect(payment.payment_method.preferred_require_liability_shift).to be true
-                expect(payment.liability.liability_shift).to be true
-
-                expect(subject.gateway).not_to receive(:void)
-
-                subject.call
-              end
-
-              it 'passes the liability shift check' do
-                expect(payment.payment_method.preferred_require_liability_shift).to be true
-                expect(payment.liability.liability_shift).to be true
-
-                subject.call
-
-                expect(subject).to be_success
-              end
-            end
-          end
-
-          context 'when liability shift is not required' do
-            let(:payment_method) { create(:saferpay_payment_method, :no_require_liability_shift) }
-
-            context 'and liability shift is not granted' do
-              let(:payment) { create(:six_saferpay_payment, :authorized, :without_liability_shift, payment_method: payment_method) }
-
-              it "doesn't cancel the payment" do
-                expect(payment.payment_method.preferred_require_liability_shift).to be false
-                expect(payment.liability.liability_shift).to be false
-
-                expect(subject.gateway).not_to receive(:void)
-
-                subject.call
-              end
-
-              it 'passes the liability shift check' do
-                expect(payment.payment_method.preferred_require_liability_shift).to be false
-                expect(payment.liability.liability_shift).to be false
-                subject.call
-
-                expect(subject).to be_success
-              end
-            end
-
-            context 'and liability shift is granted' do
-              let(:payment) { create(:six_saferpay_payment, :authorized, payment_method: payment_method) }
-              it "doesn't cancel the payment" do
-                expect(payment.payment_method.preferred_require_liability_shift).to be false
-                expect(payment.liability.liability_shift).to be true
-
-                expect(subject.gateway).not_to receive(:void)
-
-                subject.call
-              end
-
-              it 'passes the liability shift check' do
-                expect(payment.payment_method.preferred_require_liability_shift).to be false
-                expect(payment.liability.liability_shift).to be true
-                subject.call
-
-                expect(subject).to be_success
-              end
-            end
-          end
-        end
-
-        context 'payment validation' do
-          before do
-            allow(subject).to receive(:gateway).and_return(double('gateway'))
-
-
-            # ensure other methods don't modify outcome
-            allow(subject).to receive(:check_liability_shift_requirements!)
-            allow(subject).to receive(:cancel_old_solidus_payments)
-            allow(payment).to receive(:create_solidus_payment!)
-          end
-
-          it 'validates the payment' do
-            expect(PaymentValidator).to receive(:call).with(payment)
-            subject.call
-          end
-
-          context 'when the payment is invalid' do
-            it 'cancels the payment' do
-              expect(subject.gateway).to receive(:void).with(payment.transaction_id)
-
-              subject.call
-            end
-
-            it 'indicates failure' do
-              allow(subject.gateway).to receive(:void).with(payment.transaction_id)
-
-              subject.call
-
-              expect(subject).not_to be_success
-            end
-          end
-
-          context 'when the payment is valid' do
-            before do
-              allow(PaymentValidator).to receive(:call).with(payment).and_return(true)
-            end
-
-            it "doesn't cancel the payment" do
-              expect(subject.gateway).not_to receive(:void)
-
-              subject.call
-            end
-
-            it 'indicates success' do
-              subject.call
-
-              expect(subject).to be_success
-            end
-          end
-        end
-
-        context 'when the payment has passed all validations' do
-          before do
-            allow(subject).to receive(:check_liability_shift_requirements!).and_return(true)
-            allow(subject).to receive(:validate_payment!).and_return(true)
-          end
-
-          context 'when previous solidus payments exist for this order' do
-            let(:order) { payment.order }
-            let!(:previous_payment_invalid) { create(:payment_using_saferpay, order: order) }
-            let!(:previous_payment_checkout) { create(:payment_using_saferpay, order: order) }
-
-            before do
-              # This is bad practice because we mock which payments are invalidated here.
-              # The reason is that you can't stub methods on AR objects that
-              # are loaded from the DB and because #solidus_payments_to_cancel
-              # is just AR scopes, I prefer this test over using stuff like
-              # #expect_any_instance_of
-              allow(subject).to receive(:solidus_payments_to_cancel).and_return([previous_payment_checkout])
-            end
-
-            it 'cancels old solidus payments' do
-              expect(previous_payment_invalid).not_to receive(:cancel!)
-              expect(previous_payment_checkout).to receive(:cancel!)
-
-              subject.call
-            end
-          end
-
-          it 'creates a new solidus payment' do
-            expect(payment).to receive(:create_solidus_payment!)
-
-            subject.call
-          end
-
-          it 'indicates success' do
-            allow(payment).to receive(:create_solidus_payment!)
-
-            subject.call
-
-            expect(subject).to be_success
-          end
-        end
-
+        it_behaves_like 'process_authorized_payment'
       end
-
     end
   end
 end