solidus_six_saferpay 0.1.3 → 0.1.8.1

data/app/views/spree/checkout/payment/_saferpay_payment.html.erb

@@ -1,6 +1,6 @@
 <% payment_container_id = "saferpay-payment-container-#{payment_method.id}" %>
 <% if payment_method.preferred_as_iframe %>
-  <iframe class="loading-animation saferpay-iframe" width='100%' height='550px' id="<%= payment_container_id %>" src="" frameborder="0">
+  <iframe class="saferpay-iframe" width='100%' height='550px' id="<%= payment_container_id %>" src="" frameborder="0">
   </iframe>
   <script charset="utf-8">
     SaferpayPayment.registerIframePaymentMethod({id: "<%= payment_method.id %>", initUrl: "<%= payment_method.init_path %>", containerId: "#<%= payment_container_id %>"})

data/app/views/spree/six_saferpay_payments/_six_saferpay_payment.html.erb

@@ -2,8 +2,8 @@
 <% container_class = "saferpay-payment #{payment.state}" %>
 <div class="<%= container_class %>">
   <div class="credit-card">
-    <span><%= image_tag "solidus_six_saferpay/credit_cards/icons/#{saferpay_payment.icon_name}.png" %></span>
-    <span><%= saferpay_payment.display_text %></span>
+    <div class="cc-image-container"><%= image_tag "solidus_six_saferpay/credit_cards/icons/#{saferpay_payment.icon_name}.png", class: "cc-img" %></div>
+    <div class="cc-number"><%= saferpay_payment.display_text %></div>
   </div>
   <div>
     <div class="amount">

data/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "solidus_six_saferpay"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+$LOAD_PATH.unshift(*Dir["#{__dir__}/../app/*"])
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/rails

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+app_root = 'sandbox'
+
+unless File.exist? "#{app_root}/bin/rails"
+  warn 'Creating the sandbox app...'
+  Dir.chdir "#{__dir__}/.." do
+    system "#{__dir__}/sandbox" or begin # rubocop:disable Style/AndOr
+      warn 'Automatic creation of the sandbox app failed'
+      exit 1
+    end
+  end
+end
+
+Dir.chdir app_root
+exec 'bin/rails', *ARGV

data/bin/rake

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+gem install bundler --conservative
+bundle update
+bin/rake clobber

data/config/initializers/assets.rb

@@ -0,0 +1,3 @@
+if Rails.application.config.respond_to?(:assets)
+  Rails.application.config.assets.precompile << 'solidus_six_saferpay_manifest.js'
+end

data/config/locales/de.yml

@@ -6,7 +6,7 @@ de:
         init:
           checkout_not_initialized: Zahlung konnte nicht gestartet werden.
         success:
-          payment_source_not_created: Six Saferpay Zahlungsquelle konnte nicht erstellt werden.
+          saferpay_payment_not_found: Six Saferpay Zahlung kann nicht gefunden werden.
         fail:
           payment_failed: Die Zahlung konnte nicht abgeschlossen werden.
       payment_page:

data/config/locales/en.yml

@@ -6,7 +6,7 @@ en:
         init:
           checkout_not_initialized: Payment could not be initialized.
         success:
-          payment_source_not_created: Six Saferpay payment source could not be created.
+          saferpay_payment_not_found: Six Saferpay payment can not be found.
         fail:
           payment_failed: The payment could not be completed.
       payment_page:

data/config/locales/fr.yml

@@ -6,7 +6,7 @@ fr:
         init:
           checkout_not_initialized: Le paiement n'a pas pu être initialisé.
         success:
-          payment_source_not_created: La source de paiement Six Saferpay n'a pas pu être créée.
+          saferpay_payment_not_found: Paiement Six Saferpay est introuvable.
         fail:
           payment_failed: Le paiement n'a pas pu être complété.
       payment_page:

data/config/routes.rb

@@ -1,5 +1,6 @@
-Spree::Core::Engine.routes.draw do
+# frozen_string_literal: true
 
+Spree::Core::Engine.routes.draw do
   namespace :solidus_six_saferpay do
     namespace :payment_page do
       get :init, controller: :checkout, defaults: { format: :json }
@@ -13,5 +14,4 @@ Spree::Core::Engine.routes.draw do
       get :fail, controller: :checkout
     end
   end
-
 end

data/lib/generators/solidus_six_saferpay/install/install_generator.rb

@@ -1,18 +1,30 @@
+# frozen_string_literal: true
+
 module SolidusSixSaferpay
   module Generators
     class InstallGenerator < Rails::Generators::Base
       class_option :auto_run_migrations, type: :boolean, default: false
 
+      def add_javascripts
+        append_file 'vendor/assets/javascripts/spree/frontend/all.js', "//= require spree/frontend/solidus_six_saferpay\n"
+        append_file 'vendor/assets/javascripts/spree/backend/all.js', "//= require spree/backend/solidus_six_saferpay\n"
+      end
+
+      def add_stylesheets
+        inject_into_file 'vendor/assets/stylesheets/spree/frontend/all.css', " *= require spree/frontend/solidus_six_saferpay\n", before: %r{\*/}, verbose: true
+        inject_into_file 'vendor/assets/stylesheets/spree/backend/all.css', " *= require spree/backend/solidus_six_saferpay\n", before: %r{\*/}, verbose: true
+      end
+
       def add_migrations
-        run 'bundle exec rake railties:install:migrations FROM=solidus_six_saferpay'
+        run 'bin/rails railties:install:migrations FROM=solidus_six_saferpay'
       end
 
       def run_migrations
         run_migrations = options[:auto_run_migrations] || ['', 'y', 'Y'].include?(ask('Would you like to run the migrations now? [Y/n]'))
         if run_migrations
-          run 'bundle exec rake db:migrate'
+          run 'bin/rails db:migrate'
         else
-          puts 'Skipping rake db:migrate, don\'t forget to run it!'
+          puts 'Skipping bin/rails db:migrate, don\'t forget to run it!' # rubocop:disable Rails/Output
         end
       end
     end

data/lib/solidus_six_saferpay.rb

@@ -1,5 +1,8 @@
-require 'solidus_core'
-require "solidus_support"
+# frozen_string_literal: true
 
-require "solidus_six_saferpay/engine"
+require 'solidus_core'
+require 'solidus_support'
 require 'six_saferpay'
+
+require 'solidus_six_saferpay/version'
+require 'solidus_six_saferpay/engine'

data/lib/solidus_six_saferpay/configuration.rb

@@ -1,12 +1,9 @@
 module SolidusSixSaferpay
-
   class Configuration
-    def self.config
-      yield(self)
-    end
+    include ActiveSupport::Configurable
+
 
-    def self.error_handlers
-      @error_handlers ||= []
-    end
+    config_accessor(:payment_processing_success_handler)
+    config_accessor(:error_handlers) { [] }
   end
 end

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

@@ -87,23 +87,24 @@ module SolidusSixSaferpay
     end
 
     def refund(amount, transaction_id, options = {})
-      payment = Spree::Payment.find_by!(response_code: transaction_id)
-      refund_amount = Spree::Money.new(amount, currency: payment.currency)
+      Rollbar.error("Disabled Refund for: #{transaction_id}")
+      # 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_refund = SixSaferpay::Refund.new(amount: saferpay_amount, order_id: payment.order.number)
-      capture_reference = SixSaferpay::CaptureReference.new(capture_id: payment.transaction_id)
+      # saferpay_amount = SixSaferpay::Amount.new(value: refund_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)
 
-      payment_refund = SixSaferpay::SixTransaction::Refund.new(refund: saferpay_refund, capture_reference: capture_reference)
+      # payment_refund = SixSaferpay::SixTransaction::Refund.new(refund: saferpay_refund, capture_reference: capture_reference)
 
-      if refund_response = SixSaferpay::Client.post(payment_refund)
+      # if refund_response = SixSaferpay::Client.post(payment_refund)
 
-        # actually capture the refund
-        capture(amount, refund_response.transaction.id, options)
-      end
+      #   # actually capture the refund
+      #   capture(amount, refund_response.transaction.id, options)
+      # end
 
-    rescue SixSaferpay::Error => e
-      handle_error(e, refund_response)
+    # rescue SixSaferpay::Error => e
+      # handle_error(e, refund_response)
     end
 
     private

data/lib/solidus_six_saferpay/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidusSixSaferpay
-  VERSION = '0.1.3'
+  VERSION = '0.1.8.1'
 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/checkout_controller_spec.rb

@@ -0,0 +1,41 @@
+require 'rails_helper'
+
+RSpec.describe Spree::SolidusSixSaferpay::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(:payment) { create(:six_saferpay_payment) }
+
+  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 '#initialize_payment' do
+    it 'is not implemented in this superclass' do
+      expect { subject.send(:initialize_payment, order, payment_method) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#authorize_payment' do
+    it 'is not implemented in this superclass' do
+      expect { subject.send(:authorize_payment, payment) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#process_authorization' do
+    it 'is not implemented in this superclass' do
+      expect { subject.send(:process_authorization, payment) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#inquire_payment' do
+    it 'is not implemented in this superclass' do
+      expect { subject.send(:inquire_payment, payment) }.to raise_error(NotImplementedError)
+    end
+  end
+end

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

@@ -0,0 +1,205 @@
+require 'rails_helper'
+
+RSpec.describe Spree::SolidusSixSaferpay::PaymentPage::CheckoutController, type: :controller do
+  routes { Spree::Core::Engine.routes }
+
+  let(:user) { create(:user) }
+  let(:order) { create(:order) }
+  let(:payment_method) { create(:saferpay_payment_method_payment_page) }
+
+  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::InitializePaymentPage", success?: success, redirect_url: redirect_url) }
+
+    it 'tries to the saferpay payment' do
+      expect(Spree::SolidusSixSaferpay::InitializePaymentPage).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::InitializePaymentPage).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::InitializePaymentPage).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::AssertPaymentPage", success?: assert_success) }
+      let(:payment_inquiry) { instance_double("Spree::SolidusSixSaferpay::InquirePaymentPagePayment", user_message: "payment inquiry message") }
+
+      it 'asserts the payment' do
+        expect(Spree::SolidusSixSaferpay::AssertPaymentPage).to receive(:call).with(payment).and_return(payment_assert)
+        expect(Spree::SolidusSixSaferpay::InquirePaymentPagePayment).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::ProcessPaymentPagePayment", success?: process_success, user_message: "payment processing message") }
+
+        before do
+          allow(Spree::SolidusSixSaferpay::AssertPaymentPage).to receive(:call).with(payment).and_return(payment_assert)
+        end
+
+        it 'processes the asserted payment' do
+          expect(Spree::SolidusSixSaferpay::ProcessPaymentPagePayment).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::ProcessPaymentPagePayment).to receive(:call).with(payment).and_return(processed_payment)
+          end
+
+
+          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 the processing fails' do
+          let(:process_success) { false }
+
+          before do
+            allow(Spree::SolidusSixSaferpay::ProcessPaymentPagePayment).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::AssertPaymentPage).to receive(:call).with(payment).and_return(payment_assert)
+        end
+
+        it 'inquires the payment' do
+          expect(Spree::SolidusSixSaferpay::InquirePaymentPagePayment).to receive(:call).with(payment).and_return(payment_inquiry)
+
+          get :success
+        end
+
+        it 'displays an error message' do
+          expect(Spree::SolidusSixSaferpay::InquirePaymentPagePayment).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::InquirePaymentPagePayment", user_message: "payment inquiry message") }
+
+    it 'inquires the payment' do
+      expect(Spree::SolidusSixSaferpay::InquirePaymentPagePayment).to receive(:call).with(payment).and_return(payment_inquiry)
+
+      get :fail
+    end
+
+    it 'displays an error message' do
+      expect(Spree::SolidusSixSaferpay::InquirePaymentPagePayment).to receive(:call).with(payment).and_return(payment_inquiry)
+
+      get :fail
+
+      expect(flash[:error]).to eq("payment inquiry message")
+    end
+
+  end
+end