solidus_six_saferpay 0.2.0 → 0.3.0

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 '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
+        let(:api_response_class) { SixSaferpay::SixTransaction::InquireResponse }
+        it_behaves_like "inquire_payment"
       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

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

@@ -13,206 +13,7 @@ module Spree
       end
 
       describe '#call' do
-        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