solidus_six_saferpay 0.1.3 → 0.1.8.1

data/spec/controllers/spree/solidus_six_saferpay/transaction/checkout_controller_spec.rb

@@ -0,0 +1,228 @@
+require 'rails_helper'
+
+RSpec.describe Spree::SolidusSixSaferpay::Transaction::CheckoutController, type: :controller do
+  routes { Spree::Core::Engine.routes }
+
+  let(:user) { create(:user) }
+  let(:order) { create(:order) }
+  let(:payment_method) { create(:saferpay_payment_method_transaction) }
+
+  let(:subject) { described_class.new }
+
+  before do
+    allow(controller).to receive_messages try_spree_current_user: user
+    allow(controller).to receive_messages current_order: order
+  end
+
+  describe 'GET init' do
+    let(:success) { false }
+    let(:redirect_url) { '/saferpay/redirect/url' }
+    let(:initialized_payment) { instance_double("Spree::SolidusSixSaferpay::InitializeTransaction", success?: success, redirect_url: redirect_url) }
+
+    it 'tries to the saferpay payment' do
+      expect(Spree::SolidusSixSaferpay::InitializeTransaction).to receive(:call).with(order, payment_method).and_return(initialized_payment)
+
+      get :init, params: { payment_method_id: payment_method.id }
+    end
+
+
+    context 'when payment initialize succeeds' do
+      let(:success) { true }
+
+      before do
+        allow(Spree::SolidusSixSaferpay::InitializeTransaction).to receive(:call).with(order, payment_method).and_return(initialized_payment)
+      end
+
+      it 'returns the redirect_url' do
+        get :init, params: { payment_method_id: payment_method.id }
+
+        body = JSON.parse(response.body)
+        expect(body["redirect_url"]).to eq(redirect_url)
+      end
+    end
+
+    context 'when payment initialize fails' do
+      let(:success) { false }
+
+      before do
+        allow(Spree::SolidusSixSaferpay::InitializeTransaction).to receive(:call).with(order, payment_method).and_return(initialized_payment)
+      end
+
+      it 'returns an error' do
+        get :init, params: { payment_method_id: payment_method.id }
+
+        expect(response.body).to match(/errors/)
+        expect(response.status).to eq(422)
+      end
+    end
+
+  end
+
+  describe 'GET success' do
+    context 'when the order is not found' do
+      let(:order) { nil }
+
+      it 'redirects to the cart page via iframe breakout' do
+        get :success
+        expect(assigns(:redirect_path)).to eq(routes.cart_path)
+        expect(response).to render_template :iframe_breakout_redirect
+      end
+    end
+
+    context 'when the order is already completed' do
+      let(:order) { create(:order_ready_to_ship) }
+
+      it 'redirects to the cart page via iframe breakout' do
+        get :success
+        expect(assigns(:redirect_path)).to eq(routes.cart_path)
+        expect(response).to render_template :iframe_breakout_redirect
+      end
+    end
+
+    context 'when payment could not be created' do
+      let!(:payment) { nil }
+
+      it 'raises an error because no payment exists' do
+        expect{ get(:success) }.to raise_error(Spree::Core::GatewayError)
+      end
+    end
+
+    context 'when payment create was successful' do
+      let!(:payment) { create(:six_saferpay_payment, order: order) }
+      let(:assert_success) { false }
+      let(:payment_assert) { instance_double("Spree::SolidusSixSaferpay::AuthorizeTransaction", success?: assert_success) }
+      let(:payment_inquiry) { instance_double("Spree::SolidusSixSaferpay::InquireTransactionPayment", user_message: "payment inquiry message") }
+
+      it 'asserts the payment' do
+        expect(Spree::SolidusSixSaferpay::AuthorizeTransaction).to receive(:call).with(payment).and_return(payment_assert)
+        expect(Spree::SolidusSixSaferpay::InquireTransactionPayment).to receive(:call).with(payment).and_return(payment_inquiry)
+
+        get :success
+      end
+
+      context 'when the payment assert is successful' do
+        let(:assert_success) { true }
+        let(:process_success) { false }
+        let(:processed_payment) { instance_double("Spree::SolidusSixSaferpay::ProcessTransactionPayment", success?: process_success, user_message: "payment processing message") }
+
+        before do
+          allow(Spree::SolidusSixSaferpay::AuthorizeTransaction).to receive(:call).with(payment).and_return(payment_assert)
+        end
+
+        it 'processes the asserted payment' do
+          expect(Spree::SolidusSixSaferpay::ProcessTransactionPayment).to receive(:call).with(payment).and_return(processed_payment)
+
+          get :success
+        end
+
+        context 'when the processing is successful' do
+          let(:process_success) { true }
+
+          before do
+            allow(Spree::SolidusSixSaferpay::ProcessTransactionPayment).to receive(:call).with(payment).and_return(processed_payment)
+          end
+
+          context 'when the default success handling is applied' do
+            context 'when order is in payment state' do
+              let(:order) { create(:order, state: :payment) }
+
+              it 'moves order to next state' do
+                expect(order).to receive(:next!)
+
+                get :success
+              end
+            end
+
+            context 'when order is already in complete state' do
+              let(:order) { create(:order, state: :complete) }
+
+              it 'does not modify the order state' do
+                expect(order).not_to receive(:next!)
+
+                get :success
+              end
+            end
+          end
+
+          context 'when a custom success handling is applied' do
+            let(:custom_handler) do
+              Proc.new { |context, order| order.email }
+            end
+
+            before do
+              allow(::SolidusSixSaferpay.config).to receive(:payment_processing_success_handler).and_return(custom_handler)
+            end
+
+            it 'does not modify the order state' do
+              expect(order).not_to receive(:next!)
+
+              get :success
+            end
+
+            it 'executes the custom handler' do
+              expect(order).to receive(:email)
+
+              get :success
+            end
+          end
+        end
+
+        context 'when the processing fails' do
+          let(:process_success) { false }
+
+          before do
+            allow(Spree::SolidusSixSaferpay::ProcessTransactionPayment).to receive(:call).with(payment).and_return(processed_payment)
+          end
+
+          it 'displays an error message' do
+            get :success
+
+            expect(flash[:error]).to eq("payment processing message")
+          end
+        end
+
+      end
+
+      context 'when the payment assert fails' do
+        let(:assert_success) { false }
+
+        before do
+          allow(Spree::SolidusSixSaferpay::AuthorizeTransaction).to receive(:call).with(payment).and_return(payment_assert)
+        end
+
+        it 'inquires the payment' do
+          expect(Spree::SolidusSixSaferpay::InquireTransactionPayment).to receive(:call).with(payment).and_return(payment_inquiry)
+
+          get :success
+        end
+
+        it 'displays an error message' do
+          expect(Spree::SolidusSixSaferpay::InquireTransactionPayment).to receive(:call).with(payment).and_return(payment_inquiry)
+          get :success
+
+          expect(flash[:error]).to eq("payment inquiry message")
+        end
+      end
+    end
+  end
+
+  describe 'GET fail' do
+    let!(:payment) { create(:six_saferpay_payment, order: order) }
+    let(:payment_inquiry) { instance_double("Spree::SolidusSixSaferpay::InquireTransactionPayment", user_message: "payment inquiry message") }
+
+    it 'inquires the payment' do
+      expect(Spree::SolidusSixSaferpay::InquireTransactionPayment).to receive(:call).with(payment).and_return(payment_inquiry)
+
+      get :fail
+    end
+
+    it 'displays an error message' do
+      expect(Spree::SolidusSixSaferpay::InquireTransactionPayment).to receive(:call).with(payment).and_return(payment_inquiry)
+
+      get :fail
+      
+      expect(flash[:error]).to eq("payment inquiry message")
+    end
+
+  end
+end

data/spec/factories/payment_methods.rb

@@ -0,0 +1,23 @@
+FactoryBot.define do
+
+  factory :saferpay_payment_method, class: Spree::PaymentMethod::SaferpayPaymentMethod do
+    name  { "saferpay_payment_method" }
+    preferred_require_liability_shift { true }
+
+    trait :no_require_liability_shift do
+      preferred_require_liability_shift { false }
+    end
+
+    trait :no_as_iframe do
+      preferred_as_iframe { false }
+    end
+  end
+
+  factory :saferpay_payment_method_payment_page, class: Spree::PaymentMethod::SaferpayPaymentPage, parent: :saferpay_payment_method do
+    name { "saferpay_payment_page" }
+  end
+
+  factory :saferpay_payment_method_transaction, class: Spree::PaymentMethod::SaferpayTransaction, parent: :saferpay_payment_method do
+    name { "saferpay_transaction" }
+  end
+end

data/spec/factories/payments.rb

@@ -0,0 +1,11 @@
+FactoryBot.define do
+
+  factory :payment_using_saferpay, class: Spree::Payment do
+    association(:payment_method, factory: :saferpay_payment_method)
+    source { create(:six_saferpay_payment, :authorized, order: order, payment_method: payment_method) }
+    order
+    state { 'checkout' }
+    response_code { '12345' }
+  end
+
+end

data/spec/factories/spree/six_saferpay_payments.rb

@@ -0,0 +1,118 @@
+FactoryBot.define do
+  factory :six_saferpay_payment, class: Spree::SixSaferpayPayment do
+    order
+    association :payment_method, factory: :saferpay_payment_method
+    expiration { Time.current + 2.hours }
+    sequence(:token, (1..100000).to_a.shuffle.to_enum)
+
+    trait :authorized do
+      sequence(:transaction_id) { |n| "TRANSACTION_ID_#{n}" }
+      transaction_status { "AUTHORIZED" }
+      transaction_date { DateTime.parse("2019-07-25T13:34:44.677+02:00") }
+      sequence(:six_transaction_reference) { |n| "SIX_TRANSACTION_REFERENCE_#{n}" }
+      display_text { "xxxx xxxx xxxx 1234" }
+
+      response_hash do
+        {
+          response_header: {
+            request_id: "request-id",
+            spec_version: "1.12"
+          },
+          transaction: {
+            type: "PAYMENT",
+            status: "AUTHORIZED",
+            id: "0QKl2GAnEK0OvA90vClhAESYEGYb",
+            date: "2019-07-25T13:34:44.677+02:00",
+            amount: {
+              value: "20000",
+              currency_code: "CHF"
+            },
+            order_id: "ORDER_ID",
+            acquirer_name: "ACQUIRER_NAME",
+            acquirer_reference: "ACQUIRER_REFERENCE",
+            six_transaction_reference: "SIX_TRANASACTION_REFERENCE",
+            approval_code: "APPROVAL CODE"
+          },
+          payment_means: {
+            brand: {
+              payment_method: "MASTERCARD",
+              name: "MasterCard"
+            },
+            display_text: "xxxx xxxx xxxx 1234",
+            card: {
+              masked_number: "xxxxxxxxxxxx1234",
+              exp_year: 2019,
+              exp_month: 7,
+              holder_name: "John Doe",
+              country_code: "US"
+            }
+          },
+          payer: {
+            ip_address: "IP ADDRESS",
+            ip_location: "CH",
+            delivery_address: {
+              first_name: "Simon",
+              last_name: "Knorrli",
+              street: "STREET",
+              zip: "ZIP",
+              city: "CITY",
+              country_code: "CH"
+            },
+            billing_address: {
+              first_name: "Simon",
+              last_name: "Knorrli",
+              street: "STREET",
+              zip: "ZIP",
+              city: "CITY",
+              country_code: "CH"
+            }
+          },
+          liability: {
+            liability_shift: true,
+            liable_entity: "ThreeDs",
+            three_ds: {
+              authenticated: true,
+              liability_shift: true,
+              xid: "3DS-XID"
+            }
+          }
+        }
+      end
+
+    end
+
+    trait :without_liability_shift do
+      authorized
+
+      after(:build) do |payment|
+        payment.response_hash.merge!(
+          liability: {
+            liability_shift: false,
+            liable_entity: "ThreeDs",
+            three_ds: {
+              authenticated: false,
+              liability_shift: false,
+              xid: "3DS-XID"
+            }
+          }
+        )
+      end
+    end
+
+    trait :dcc do
+      authorized
+
+      after(:build) do |payment|
+        payment.response_hash.merge!(
+          dcc: {
+            payer_amount: {
+              value: "18972",
+              currency_code: "USD"
+            }
+          }
+        )
+      end
+    end
+
+  end
+end

data/spec/models/spree/six_saferpay_payment_spec.rb

@@ -0,0 +1,203 @@
+require 'rails_helper'
+
+module Spree
+  RSpec.describe SixSaferpayPayment, type: :model do
+    let(:payment) { FactoryBot.create(:six_saferpay_payment) }
+    describe 'associations' do
+      it { is_expected.to belong_to :order }
+      it { is_expected.to belong_to :payment_method }
+    end
+
+    describe 'validations' do
+      it { is_expected.to validate_presence_of :token }
+      it { is_expected.to validate_presence_of :expiration }
+    end
+
+    describe "#create_solidus_payment!" do
+      it 'creates a Solidus::Payment with the correct information' do
+        expect(Spree::Payment.count).to eq(0)
+        solidus_payment = payment.create_solidus_payment!
+        expect(Spree::Payment.count).to eq(1)
+        expect(solidus_payment.order).to eq(payment.order)
+        expect(solidus_payment.payment_method).to eq(payment.payment_method)
+        expect(solidus_payment.response_code).to eq(payment.transaction_id)
+        expect(solidus_payment.amount).to eq(payment.order.total)
+        expect(solidus_payment.source).to eq(payment)
+      end
+    end
+
+    describe '#address' do
+      it "returns the order's billing address" do
+        expect(payment.address).to eq(payment.order.bill_address)
+      end
+    end
+
+    describe '#payment_means' do
+      context 'when the payment is still unprocessed' do
+        it 'returns nil' do
+          expect(payment.payment_means).to be_nil
+        end
+      end
+
+      context 'when the payment is authorized' do
+        let(:payment) { FactoryBot.create(:six_saferpay_payment, :authorized) }
+
+        it 'returns a SixSaferpay::ResponsePaymentMeans' do
+          expect(payment.payment_means).to be_a(SixSaferpay::ResponsePaymentMeans)
+        end
+
+        it 'sets the API response attributes correctly' do
+          expect(payment.payment_means.brand.payment_method).to eq("MASTERCARD")
+          expect(payment.payment_means.brand.name).to eq("MasterCard")
+          expect(payment.payment_means.display_text).to eq("xxxx xxxx xxxx 1234")
+          expect(payment.payment_means.card.masked_number).to eq("xxxxxxxxxxxx1234")
+          expect(payment.payment_means.card.exp_year).to eq(2019)
+          expect(payment.payment_means.card.exp_month).to eq(7)
+          expect(payment.payment_means.card.holder_name).to eq("John Doe")
+          expect(payment.payment_means.card.country_code).to eq("US")
+        end
+      end
+    end
+
+    describe '#transaction' do
+      context 'when the payment is still unprocessed' do
+        it 'returns nil' do
+          expect(payment.transaction).to be_nil
+        end
+      end
+
+      context 'when the payment is authorized' do
+        let(:payment) { FactoryBot.create(:six_saferpay_payment, :authorized) }
+
+        it 'returns a SixSaferpay::Transaction' do
+          expect(payment.transaction).to be_a(SixSaferpay::Transaction)
+        end
+
+        it 'sets the API response attributes correctly' do
+          expect(payment.transaction.type).to eq("PAYMENT")
+          expect(payment.transaction.status).to eq("AUTHORIZED")
+          expect(payment.transaction.amount.value).to eq('20000')
+          expect(payment.transaction.amount.currency_code).to eq("CHF")
+        end
+      end
+    end
+
+    describe '#liability' do
+      context 'when the payment is still unprocessed' do
+        it 'returns nil' do
+          expect(payment.liability).to be_nil
+        end
+      end
+
+      context 'when the payment is authorized' do
+        let(:payment) { FactoryBot.create(:six_saferpay_payment, :authorized) }
+        it 'returns a SixSaferpay::Liability' do
+          expect(payment.liability).to be_a(SixSaferpay::Liability)
+        end
+
+        it 'sets the API response attributes correctly' do
+          expect(payment.liability.liability_shift).to be true
+          expect(payment.liability.liable_entity).to eq("ThreeDs")
+        end
+      end
+    end
+
+    describe '#card' do
+      context 'when the payment is still unprocessed' do
+        it 'returns nil' do
+          expect(payment.card).to be_nil
+        end
+      end
+
+      context 'when the payment is authorized' do
+        let(:payment) { FactoryBot.create(:six_saferpay_payment, :authorized) }
+
+        it 'returns a SixSaferpay::ResponseCard' do
+          expect(payment.card).to be_a(SixSaferpay::ResponseCard)
+        end
+      end
+    end
+
+    describe '#name' do
+      context 'when the payment is still unprocessed' do
+        it 'returns nil' do
+          expect(payment.name).to be_nil
+        end
+      end
+
+      context 'when the payment is authorized' do
+        let(:payment) { FactoryBot.create(:six_saferpay_payment, :authorized) }
+
+        it 'returns the card holder name' do
+          expect(payment.name).to eq("John Doe")
+        end
+      end
+    end
+
+    describe '#brand_name' do
+      context 'when the payment is still unprocessed' do
+        it 'returns nil' do
+          expect(payment.brand_name).to be_nil
+        end
+      end
+
+      context 'when the payment is authorized' do
+        let(:payment) { FactoryBot.create(:six_saferpay_payment, :authorized) }
+
+        it 'returns the brand name' do
+          expect(payment.brand_name).to eq("MasterCard")
+        end
+      end
+    end
+
+    describe '#month' do
+      context 'when the payment is still unprocessed' do
+        it 'returns nil' do
+          expect(payment.month).to be_nil
+        end
+      end
+
+      context 'when the payment is authorized' do
+        let(:payment) { FactoryBot.create(:six_saferpay_payment, :authorized) }
+
+        it 'returns the card expiration month' do
+          expect(payment.month).to eq(7)
+        end
+      end
+    end
+
+    describe '#year' do
+      context 'when the payment is still unprocessed' do
+        it 'returns nil' do
+          expect(payment.year).to be_nil
+        end
+      end
+
+      context 'when the payment is authorized' do
+        let(:payment) { FactoryBot.create(:six_saferpay_payment, :authorized) }
+
+        it 'returns the card expiration year' do
+          expect(payment.year).to eq(2019)
+        end
+      end
+    end
+
+    describe '#icon_name' do
+      context 'when the payment is still unprocessed' do
+        it 'returns nil' do
+          expect(payment.icon_name).to be_nil
+        end
+      end
+
+      context 'when the payment is authorized' do
+        let(:payment) { FactoryBot.create(:six_saferpay_payment, :authorized) }
+
+        it 'returns a downcased brand name' do
+          expect(payment.icon_name).to eq("mastercard")
+        end
+      end
+    end
+  end
+
+end
+