solidus_six_saferpay 0.1.7 → 0.4.0

data/lib/solidus_six_saferpay/engine.rb

@@ -1,6 +1,22 @@
+# frozen_string_literal: true
+
+require 'spree/core'
 module SolidusSixSaferpay
-  class Engine < ::Rails::Engine
-    isolate_namespace SolidusSixSaferpay
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure
+    yield config
+  end
+
+  class Engine < Rails::Engine
+    include SolidusSupport::EngineExtensions::Decorators
+
+    isolate_namespace ::Spree
+
+    engine_name 'solidus_six_saferpay'
 
     config.autoload_paths += Dir["#{config.root}/lib/**/"]
     config.eager_load_paths += Dir["#{config.root}/lib/**/"]
@@ -10,16 +26,9 @@ module SolidusSixSaferpay
       app.config.spree.payment_methods << Spree::PaymentMethod::SaferpayTransaction
     end
 
-    initializer "solidus_six_payments.assets.precompile" do |app|
-      app.config.assets.precompile += %w( solidus_six_saferpay/application.css )
-      app.config.assets.precompile += %w( solidus_six_saferpay/saferpay_payment.js )
-      app.config.assets.precompile += %w( solidus_six_saferpay/credit_cards/**/*.png )
-    end
-
+    # use rspec for tests
     config.generators do |g|
       g.test_framework :rspec
-      g.fixture_replacement :factory_bot
-      g.factory_bot dir: 'spec/factories'
     end
   end
 end

data/lib/solidus_six_saferpay/gateway.rb

@@ -5,9 +5,6 @@ module SolidusSixSaferpay
 
     def initialize(options = {})
       SixSaferpay.configure do |config|
-        config.success_url = options.fetch(:success_url)
-        config.fail_url = options.fetch(:fail_url)
-
         # Allow config via ENV for static values
         config.customer_id = options.fetch(:customer_id) { ENV.fetch('SIX_SAFERPAY_CUSTOMER_ID') }
         config.terminal_id = options.fetch(:terminal_id) { ENV.fetch('SIX_SAFERPAY_TERMINAL_ID') }
@@ -43,7 +40,7 @@ module SolidusSixSaferpay
       capture(amount, saferpay_payment.transaction_id, options)
     end
 
-    def capture(amount, transaction_id, options={})
+    def capture(_amount, transaction_id, options={})
       transaction_reference = SixSaferpay::TransactionReference.new(transaction_id: transaction_id)
       payment_capture = SixSaferpay::SixTransaction::Capture.new(transaction_reference: transaction_reference)
 
@@ -82,15 +79,14 @@ module SolidusSixSaferpay
     end
 
     # aliased to #refund for compatibility with solidus internals
-    def credit(amount, transaction_id, options = {})
-      refund(amount, transaction_id, options)
+    def credit(amount_cents, transaction_id, options = {})
+      refund(amount_cents, transaction_id, options)
     end
 
-    def refund(amount, transaction_id, options = {})
+    def refund(amount_cents, transaction_id, options = {})
       payment = Spree::Payment.find_by!(response_code: transaction_id)
-      refund_amount = Spree::Money.new(amount, currency: payment.currency)
 
-      saferpay_amount = SixSaferpay::Amount.new(value: refund_amount.cents, currency_code: payment.currency)
+      saferpay_amount = SixSaferpay::Amount.new(value: amount_cents, currency_code: payment.currency)
       saferpay_refund = SixSaferpay::Refund.new(amount: saferpay_amount, order_id: payment.order.number)
       capture_reference = SixSaferpay::CaptureReference.new(capture_id: payment.transaction_id)
 
@@ -99,7 +95,7 @@ module SolidusSixSaferpay
       if refund_response = SixSaferpay::Client.post(payment_refund)
 
         # actually capture the refund
-        capture(amount, refund_response.transaction.id, options)
+        capture(amount_cents, refund_response.transaction.id, options)
       end
 
     rescue SixSaferpay::Error => e
@@ -156,7 +152,7 @@ module SolidusSixSaferpay
       )
       payer = SixSaferpay::Payer.new(language_code: I18n.locale, billing_address: billing_address, delivery_address: delivery_address)
 
-      params = { payment: payment, payer: payer }
+      params = { payment: payment, payer: payer, return_urls: return_urls(order) }
 
       six_payment_methods = payment_method.enabled_payment_methods
       params.merge!(payment_methods: six_payment_methods) unless six_payment_methods.blank?
@@ -164,6 +160,10 @@ module SolidusSixSaferpay
       params
     end
 
+    def return_urls(order)
+      raise NotImplementedError, "Must be implemented in PaymentPageGateway or TransactionGateway"
+    end
+
     def response(success, message, api_response, options = {})
       GatewayResponse.new(success, message, api_response, options)
     end

data/lib/solidus_six_saferpay/payment_page_gateway.rb

@@ -1,15 +1,6 @@
 module SolidusSixSaferpay
   class PaymentPageGateway < Gateway
 
-    def initialize(options = {})
-      super(
-        options.merge(
-          success_url: url_helpers.solidus_six_saferpay_payment_page_success_url,
-          fail_url: url_helpers.solidus_six_saferpay_payment_page_fail_url
-        )
-      )
-    end
-
     def inquire(saferpay_payment, options = {})
       inquire_response = perform_assert_request(saferpay_payment, options)
 
@@ -47,6 +38,14 @@ module SolidusSixSaferpay
       SixSaferpay::SixPaymentPage::Initialize.new(interface_initialize_params(order, payment_method))
     end
 
+    def return_urls(order)
+      SixSaferpay::ReturnUrls.new(
+        success: url_helpers.solidus_six_saferpay_payment_page_success_url(order.number),
+        fd_fail: url_helpers.solidus_six_saferpay_payment_page_fail_url(order.number),
+        fd_abort: url_helpers.solidus_six_saferpay_payment_page_fail_url(order.number)
+      )
+    end
+
     def perform_assert_request(saferpay_payment, options = {})
       payment_page_assert = SixSaferpay::SixPaymentPage::Assert.new(token: saferpay_payment.token)
       SixSaferpay::Client.post(payment_page_assert)

data/lib/solidus_six_saferpay/transaction_gateway.rb

@@ -1,15 +1,6 @@
 module SolidusSixSaferpay
   class TransactionGateway < Gateway
 
-    def initialize(options = {})
-      super(
-        options.merge(
-          success_url: url_helpers.solidus_six_saferpay_transaction_success_url,
-          fail_url: url_helpers.solidus_six_saferpay_transaction_fail_url
-        )
-      )
-    end
-
     def inquire(saferpay_payment, options = {})
       transaction_inquire = SixSaferpay::SixTransaction::Inquire.new(transaction_reference: saferpay_payment.transaction_id)
       inquire_response = SixSaferpay::Client.post(transaction_inquire)
@@ -43,5 +34,13 @@ module SolidusSixSaferpay
     def interface_initialize_object(order, payment_method)
       SixSaferpay::SixTransaction::Initialize.new(interface_initialize_params(order, payment_method))
     end
+
+    def return_urls(order)
+      SixSaferpay::ReturnUrls.new(
+        success: url_helpers.solidus_six_saferpay_transaction_success_url(order.number),
+        fd_fail: url_helpers.solidus_six_saferpay_transaction_fail_url(order.number),
+        fd_abort: url_helpers.solidus_six_saferpay_transaction_fail_url(order.number)
+      )
+    end
   end
 end

data/lib/solidus_six_saferpay/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidusSixSaferpay
-  VERSION = '0.1.7'
+  VERSION = '0.4.0'
 end

data/solidus_six_saferpay.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'lib/solidus_six_saferpay/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'solidus_six_saferpay'
+  spec.version = SolidusSixSaferpay::VERSION
+  spec.authors = ['Simon Kiener']
+  spec.email = ['jugglinghobo@gmail.com']
+
+  spec.summary = 'Saferpay Payment Page and Transaction payment methods for Solidus'
+  spec.description = 'Adds Saferpay Payment Page and Transaction payment methods to your Solidus application'
+  spec.homepage = 'https://github.com/fadendaten/solidus_six_saferpay'
+  spec.license = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/fadendaten/solidus_six_saferpay'
+
+  spec.required_ruby_version = Gem::Requirement.new('~> 2.4')
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  files = Dir.chdir(__dir__) { `git ls-files -z`.split("\x0") }
+
+  spec.files = files.grep_v(%r{^(test|spec|features)/})
+  spec.test_files = files.grep(%r{^(test|spec|features)/})
+  spec.bindir = "exe"
+  spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'solidus_core', ['>= 2.0.0', '< 3']
+  spec.add_dependency 'solidus_support', '~> 0.4.0'
+  spec.add_dependency "six_saferpay", "~> 2.2"
+  spec.add_dependency "rails-i18n", "~> 5.1"
+
+  spec.add_development_dependency 'solidus_dev_support'
+
+  spec.add_development_dependency "shoulda-matchers", "~> 4.1"
+  spec.add_development_dependency "rails-controller-testing", "~> 1.0", ">= 1.0.4"
+  spec.add_development_dependency "pry", "~> 0.12"
+  spec.add_development_dependency "pry-rails", "~> 0.3"
+end

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

@@ -0,0 +1,16 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe PaymentPage::CheckoutController do
+
+      let(:initialize_payment_service_class) { InitializePaymentPage }
+      let(:authorize_payment_service_class) { AssertPaymentPage }
+      let(:process_authorization_service_class) { ProcessPaymentPagePayment }
+      let(:inquire_payment_service_class) { InquirePaymentPagePayment }
+
+      it_behaves_like "checkout_controller"
+
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe Transaction::CheckoutController do
+
+      let(:initialize_payment_service_class) { InitializeTransaction }
+      let(:authorize_payment_service_class) { AuthorizeTransaction }
+      let(:process_authorization_service_class) { ProcessTransactionPayment }
+      let(:inquire_payment_service_class) { InquireTransactionPayment }
+
+      it_behaves_like "checkout_controller"
+
+    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
+