solidus_six_saferpay 0.1.3 → 0.2.0

data/app/services/spree/solidus_six_saferpay/inquire_payment.rb

@@ -21,6 +21,7 @@ module Spree
         if inquiry.success?
           saferpay_payment.update_attributes(response_hash: inquiry.api_response.to_h)
         else
+          saferpay_payment.update_attributes(response_hash: saferpay_payment.response_hash.merge(error: "#{inquiry.error_name}"))
           general_error = I18n.t(:general_error, scope: [:solidus_six_saferpay, :errors])
           specific_error = I18n.t(inquiry.error_name, scope: [:six_saferpay, :error_names])
           @user_message = "#{general_error}: #{specific_error}"

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,17 +1,17 @@
-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 }
-      get :success, controller: :checkout
-      get :fail, controller: :checkout
+      get 'success/:order_number', to: 'checkout#success', as: :success
+      get 'fail/:order_number', to: 'checkout#fail', as: :fail
     end
 
     namespace :transaction do
       get :init, controller: :checkout, defaults: { format: :json }
-      get :success, controller: :checkout
-      get :fail, controller: :checkout
+      get 'success/:order_number', to: 'checkout#success', as: :success
+      get 'fail/:order_number', to: 'checkout#fail', as: :fail
     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

@@ -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') }
@@ -156,7 +153,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 +161,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.3'
+  VERSION = '0.2.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/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,206 @@
+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, params: { order_number: "not_found" }
+        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, params: { order_number: order.number }
+        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, params: { order_number: order.number }) }.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, params: { order_number: order.number }
+      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, params: { order_number: order.number }
+        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)
+            allow(Spree::Order).to receive(:find_by).with(number: order.number).and_return(order)
+          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, params: { order_number: order.number }
+            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, params: { order_number: order.number }
+            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, params: { order_number: order.number }
+
+            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, params: { order_number: order.number }
+        end
+
+        it 'displays an error message' do
+          expect(Spree::SolidusSixSaferpay::InquirePaymentPagePayment).to receive(:call).with(payment).and_return(payment_inquiry)
+          get :success, params: { order_number: order.number }
+
+          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, params: { order_number: order.number }
+    end
+
+    it 'displays an error message' do
+      expect(Spree::SolidusSixSaferpay::InquirePaymentPagePayment).to receive(:call).with(payment).and_return(payment_inquiry)
+
+      get :fail, params: { order_number: order.number }
+
+      expect(flash[:error]).to eq("payment inquiry message")
+    end
+
+  end
+end