solidus_six_saferpay 0.1.8 → 0.5.0

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

data/spec/solidus_six_saferpay/configuration_spec.rb

@@ -4,9 +4,6 @@ module SolidusSixSaferpay
   RSpec.describe Configuration do
 
     describe '.config' do
-      it 'exposes a configurable payment success handler' do
-        expect(described_class).to respond_to(:payment_processing_success_handler)
-      end
       it 'exposes a configurable list of error handlers' do
         expect(described_class).to respond_to(:error_handlers)
       end

data/spec/solidus_six_saferpay/gateway_spec.rb

@@ -7,15 +7,11 @@ module SolidusSixSaferpay
     let(:terminal_id) { 'TERMINAL_ID' }
     let(:username) { 'USERNAME' }
     let(:password) { 'PASSWORD' }
-    let(:success_url) { '/api/endpoints/success' }
-    let(:fail_url) { '/api/endpoints/fail' }
     let(:base_url) { 'https://test.saferpay-api-host.test' }
     let(:css_url) { '/custom/css/url' }
 
     let(:gateway) do
       described_class.new(
-        success_url: success_url,
-        fail_url: fail_url,
         customer_id: customer_id,
         terminal_id: terminal_id,
         username: username,
@@ -29,8 +25,6 @@ module SolidusSixSaferpay
       
       it 'configures the API client' do
         gateway = described_class.new(
-          success_url: success_url,
-          fail_url: fail_url,
           customer_id: customer_id,
           terminal_id: terminal_id,
           username: username,
@@ -45,8 +39,6 @@ module SolidusSixSaferpay
         expect(config.terminal_id).to eq(terminal_id)
         expect(config.username).to eq(username)
         expect(config.password).to eq(password)
-        expect(config.success_url).to eq(success_url)
-        expect(config.fail_url).to eq(fail_url)
         expect(config.base_url).to eq(base_url)
         expect(config.css_url).to eq(css_url)
       end
@@ -63,10 +55,7 @@ module SolidusSixSaferpay
         end
         
         it 'falls back to ENV vars' do
-          gateway = described_class.new(
-            success_url: success_url,
-            fail_url: fail_url
-          )
+          gateway = described_class.new
 
           config = SixSaferpay.config
 
@@ -74,8 +63,6 @@ module SolidusSixSaferpay
           expect(config.terminal_id).to eq(terminal_id)
           expect(config.username).to eq(username)
           expect(config.password).to eq(password)
-          expect(config.success_url).to eq(success_url)
-          expect(config.fail_url).to eq(fail_url)
           expect(config.base_url).to eq(base_url)
           expect(config.css_url).to eq(css_url)
         end

data/spec/solidus_six_saferpay/payment_page_gateway_spec.rb

@@ -8,8 +8,6 @@ module SolidusSixSaferpay
     let(:terminal_id) { 'TERMINAL_ID' }
     let(:username) { 'USERNAME' }
     let(:password) { 'PASSWORD' }
-    let(:success_url) { '/api/endpoints/success' }
-    let(:fail_url) { '/api/endpoints/fail' }
     let(:base_url) { 'https://test.saferpay-api-host.test' }
     let(:css_url) { '/custom/css/url' }
 
@@ -38,17 +36,6 @@ module SolidusSixSaferpay
       allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_CSS_URL').and_return(css_url)
     end
 
-    describe '#initialize' do
-      it 'configures the API client with correct urls by default' do
-        described_class.new
-
-        config = SixSaferpay.config
-
-        expect(config.success_url).to eq(solidus_six_saferpay_payment_page_success_url)
-        expect(config.fail_url).to eq(solidus_six_saferpay_payment_page_fail_url)
-      end
-    end
-
     describe '#initialize_payment' do
 
       let(:saferpay_billing_address) do
@@ -111,11 +98,19 @@ module SolidusSixSaferpay
           delivery_address: saferpay_shipping_address
         )
       end
+      let(:return_urls) do
+        instance_double("SixSaferpay::ReturnUrls",
+          success: solidus_six_saferpay_payment_page_success_url(order),
+          fd_fail: solidus_six_saferpay_payment_page_fail_url(order),
+          fd_abort: solidus_six_saferpay_payment_page_fail_url(order),
+         )
+      end
 
       let(:initialize_params) do
         {
           payment: saferpay_payment,
-          payer: saferpay_payer
+          payer: saferpay_payer,
+          return_urls: return_urls
         }
       end
 
@@ -185,6 +180,13 @@ module SolidusSixSaferpay
           delivery_address: saferpay_shipping_address
         ).and_return(saferpay_payer)
 
+        # mock return_urls
+        expect(SixSaferpay::ReturnUrls).to receive(:new).with(
+          success: solidus_six_saferpay_payment_page_success_url(order),
+          fd_fail: solidus_six_saferpay_payment_page_fail_url(order),
+          fd_abort: solidus_six_saferpay_payment_page_fail_url(order),
+        ).and_return(return_urls)
+
         expect(SixSaferpay::SixPaymentPage::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)

data/spec/solidus_six_saferpay/transaction_gateway_spec.rb

@@ -8,8 +8,6 @@ module SolidusSixSaferpay
     let(:terminal_id) { 'TERMINAL_ID' }
     let(:username) { 'USERNAME' }
     let(:password) { 'PASSWORD' }
-    let(:success_url) { '/api/endpoints/success' }
-    let(:fail_url) { '/api/endpoints/fail' }
     let(:base_url) { 'https://test.saferpay-api-host.test' }
     let(:css_url) { '/custom/css/url' }
 
@@ -38,17 +36,6 @@ module SolidusSixSaferpay
       allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_CSS_URL').and_return(css_url)
     end
 
-    describe '#initialize' do
-      it 'configures the API client with correct urls by default' do
-        described_class.new
-
-        config = SixSaferpay.config
-
-        expect(config.success_url).to eq(solidus_six_saferpay_transaction_success_url)
-        expect(config.fail_url).to eq(solidus_six_saferpay_transaction_fail_url)
-      end
-    end
-
     describe '#initialize_payment' do
 
       let(:saferpay_billing_address) do
@@ -112,10 +99,19 @@ module SolidusSixSaferpay
         )
       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
+          payer: saferpay_payer,
+          return_urls: return_urls
         }
       end
 
@@ -189,6 +185,13 @@ module SolidusSixSaferpay
           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)

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