solidus_six_saferpay 0.1.5 → 0.3.0

data/spec/services/spree/solidus_six_saferpay/inquire_payment_spec.rb

@@ -0,0 +1,39 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe InquirePayment do
+
+      let(:payment) { create(:six_saferpay_payment, :authorized) }
+
+      let(:service) { described_class.new(payment) }
+
+      describe '.call' do
+        it 'calls an initialized service with given order and payment method' do
+          expect(described_class).to receive(:new).with(payment).and_return(service)
+          expect(service).to receive(:call)
+
+          described_class.call(payment)
+        end
+      end
+
+      describe '#call' do
+        it 'fails because gateway raises an error' do
+          expect { service.call }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe '#gateway' do
+        it 'raises an error because the gateway must be defined in subclasses' do
+          expect { service.gateway }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe '#success?' do
+        it 'is initially false' do
+          expect(service).not_to be_success
+        end
+      end
+    end
+  end
+end

data/spec/services/spree/solidus_six_saferpay/inquire_transaction_payment_spec.rb

@@ -0,0 +1,21 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe InquireTransactionPayment do
+
+      let(:payment) { create(:six_saferpay_payment) }
+      subject { described_class.new(payment) }
+
+      describe '#gateway' do
+        it_behaves_like "it uses the transaction gateway"
+      end
+
+      describe '#call' do
+        let(:api_response_class) { SixSaferpay::SixTransaction::InquireResponse }
+        it_behaves_like "inquire_payment"
+      end
+
+    end
+  end
+end

data/spec/services/spree/solidus_six_saferpay/payment_validator_spec.rb

@@ -0,0 +1,100 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe PaymentValidator do
+
+      let(:payment) { create(:six_saferpay_payment, :authorized) }
+
+      let(:service) { described_class.new(payment) }
+
+      describe '.call' do
+        it 'calls an initialized service with given saferpay payment' do
+          expect(described_class).to receive(:new).with(payment).and_return(service)
+          expect(service).to receive(:call)
+
+          described_class.call(payment)
+        end
+      end
+
+      describe '#call' do
+        it 'performs multiple validations on the payment' do
+          expect(service).to receive(:validate_payment_authorized).with(payment.transaction)
+          expect(service).to receive(:validate_order_reference).with(payment.transaction)
+          expect(service).to receive(:validate_order_amount).with(payment.transaction)
+
+          service.call
+        end
+      end
+
+      describe '#validate_payment_authorized' do
+        let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", status: "AUTHORIZED") }
+
+        context 'when the saferpay status is AUTHORIZED' do
+          it 'passes validation' do
+            expect(service.validate_payment_authorized(saferpay_transaction)).to be true
+          end
+        end
+
+        context 'when the saferpay status is CAPTURED' do
+          let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", status: "CAPTURED") }
+          it 'raises an error' do
+            expect{ service.validate_payment_authorized(saferpay_transaction) }.to raise_error(::SolidusSixSaferpay::InvalidSaferpayPayment)
+          end
+        end
+
+        context 'when the saferpay status is PENDING' do
+          let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", status: "PENDING") }
+          it 'raises an error' do
+            expect{ service.validate_payment_authorized(saferpay_transaction) }.to raise_error(::SolidusSixSaferpay::InvalidSaferpayPayment)
+          end
+        end
+      end
+
+      describe '#validate_order_reference' do
+        context 'when the saferpay order reference matches the solidus order' do
+          let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", order_id: payment.order.number) }
+
+          it 'passes validation' do
+            expect(service.validate_order_reference(saferpay_transaction)).to be true
+          end
+        end
+
+        context 'when the saferpay order reference does not match the solidus order' do
+          let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", order_id: "OTHER") }
+
+          it 'raises an error' do
+            expect{ service.validate_order_reference(saferpay_transaction) }.to raise_error(::SolidusSixSaferpay::InvalidSaferpayPayment)
+          end
+        end
+      end
+
+      describe '#validate_order_amount' do
+          let(:saferpay_transaction) { instance_double("SixSaferpay::Transaction", amount: saferpay_amount) }
+        context 'when the saferpay payment values match the solidus order values' do
+          let(:saferpay_amount) { instance_double("SixSaferpay::Amount", value: (payment.order.amount * 100).to_s, currency_code: payment.order.currency) }
+
+          it 'passes validation' do
+            expect(service.validate_order_amount(saferpay_transaction)).to be true
+          end
+        end
+
+        context 'when the saferpay payment currency does not match the solidus order currency' do
+          let(:saferpay_amount) { instance_double("SixSaferpay::Amount", value: (payment.order.amount * 100).to_s, currency_code: "OTHER") }
+          
+          it 'raises an error' do
+            expect{ service.validate_order_amount(saferpay_transaction) }.to raise_error(::SolidusSixSaferpay::InvalidSaferpayPayment)
+          end
+        end
+
+        context 'when the saferpay payment value does not match the solidus order value' do
+          let(:saferpay_amount) { instance_double("SixSaferpay::Amount", value: ((payment.order.amount + 5) * 100).to_s, currency_code: payment.order.currency) }
+          
+          it 'raises an error' do
+            expect{ service.validate_order_amount(saferpay_transaction) }.to raise_error(::SolidusSixSaferpay::InvalidSaferpayPayment)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/services/spree/solidus_six_saferpay/process_authorized_payment_spec.rb

@@ -0,0 +1,39 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe ProcessAuthorizedPayment do
+
+      let(:payment) { create(:six_saferpay_payment, :authorized) }
+
+      let(:service) { described_class.new(payment) }
+
+      describe '.call' do
+        it 'calls an initialized service with given order and payment method' do
+          expect(described_class).to receive(:new).with(payment).and_return(service)
+          expect(service).to receive(:call)
+
+          described_class.call(payment)
+        end
+      end
+
+      describe '#call' do
+        it 'fails because gateway raises an error' do
+          expect { service.call }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe '#gateway' do
+        it 'raises an error because the gateway must be defined in subclasses' do
+          expect { service.gateway }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe '#success?' do
+        it 'is initially false' do
+          expect(service).not_to be_success
+        end
+      end
+    end
+  end
+end

data/spec/services/spree/solidus_six_saferpay/process_payment_page_payment_spec.rb

@@ -0,0 +1,20 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe ProcessPaymentPagePayment do
+
+      let(:payment) { create(:six_saferpay_payment, :authorized) }
+
+      subject { described_class.new(payment) }
+
+      describe '#gateway' do
+        it_behaves_like "it uses the payment page gateway"
+      end
+
+      describe '#call' do
+        it_behaves_like 'process_authorized_payment'
+      end
+    end
+  end
+end

data/spec/services/spree/solidus_six_saferpay/process_transaction_payment_spec.rb

@@ -0,0 +1,20 @@
+require 'rails_helper'
+
+module Spree
+  module SolidusSixSaferpay
+    RSpec.describe ProcessTransactionPayment do
+
+      let(:payment) { create(:six_saferpay_payment, :authorized) }
+
+      subject { described_class.new(payment) }
+
+      describe '#gateway' do
+        it_behaves_like "it uses the transaction gateway"
+      end
+
+      describe '#call' do
+        it_behaves_like 'process_authorized_payment'
+      end
+    end
+  end
+end

data/spec/solidus_six_saferpay/configuration_spec.rb

@@ -0,0 +1,15 @@
+require 'rails_helper'
+
+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
+    end
+  end
+end

data/spec/solidus_six_saferpay/error_handler_spec.rb

@@ -0,0 +1,65 @@
+require 'rails_helper'
+
+module SolidusSixSaferpay
+  RSpec.describe ErrorHandler do
+
+    let(:error) { StandardError.new }
+    let(:error_handlers) { [] }
+
+    before do
+      allow(Configuration).to receive(:error_handlers).and_return(error_handlers)
+    end
+
+    describe '.handle' do
+
+      it 'defaults to level :error' do
+        expect(Rails.logger).to receive(:error).with(error)
+        described_class.handle(error)
+      end
+
+      it 'allows for configuring the error level' do
+        expect(Rails.logger).to receive(:info).with(error)
+        described_class.handle(error, level: :info)
+      end
+
+      context 'when any attached handler can not receive our error messages' do
+        let(:error_handler1) { double("Handler1", to_s: 'handler1', call: true) }
+        let(:error_handler2) { double("Handler2", to_s: 'handler2') }
+        let(:error_handler3) { double("Handler3", to_s: 'handler3', call: true) }
+
+        let(:error_handlers) { [error_handler1, error_handler2, error_handler3] }
+
+        before do
+          allow(error_handler1).to receive(:respond_to?).with(:call).and_return(true)
+          allow(error_handler2).to receive(:respond_to?).with(:call).and_return(false)
+          allow(error_handler3).to receive(:respond_to?).with(:call).and_return(true)
+        end
+
+        it 'informs about the misconfiguration via Rails logger' do
+          expect(Rails.logger).to receive(:warn).with(/ERROR:.*handler2.*/)
+
+          described_class.handle(error)
+        end
+
+        it 'skips to the next error handler' do
+          expect(error_handler1).to receive(:call).with(error, level: :error)
+          expect(error_handler2).not_to receive(:call)
+          expect(error_handler3).to receive(:call).with(error, level: :error)
+
+          described_class.handle(error)
+        end
+      end
+
+      context 'when an attached handler can receive our error messages' do
+        let(:error_handler) { double("CustomErrorHandler", call: true) }
+        let(:error_handlers) { [error_handler] }
+
+        it 'forwards the error to the error handler' do
+          expect(error_handler).to receive(:call).with(error, level: :error)
+
+          described_class.handle(error)
+        end
+      end
+    end
+  end
+end

data/spec/solidus_six_saferpay/gateway_response_spec.rb

@@ -0,0 +1,70 @@
+require 'rails_helper'
+
+module SolidusSixSaferpay
+  RSpec.describe GatewayResponse do
+    let(:success) { true }
+    let(:message) { double('message') }
+    let(:api_response) { double('API response') }
+    let(:options) { {} }
+
+    subject { described_class.new(success, message, api_response, options) }
+
+    describe '#initialize' do
+      let(:error_name) { double("error_name") }
+      let(:authorization) { double("authorization") }
+
+      describe 'when given option :error_name' do
+        let(:options) { { error_name: error_name } }
+
+        it 'sets the error name' do
+          expect(subject.error_name).to eq(error_name)
+        end
+      end
+
+      describe 'when given option :authorization' do
+        let(:options) { { authorization: authorization } }
+
+        it 'sets the authorization' do
+          expect(subject.authorization).to eq(authorization)
+        end
+        
+      end
+    end
+
+    describe '#success?' do
+      context 'when initialized as a success' do
+        let(:success) { true }
+
+        it 'is true' do
+          expect(subject).to be_success
+        end
+      end
+
+      context 'when initialized as failure' do
+        let(:success) { false }
+
+        it 'is false' do
+          expect(subject).not_to be_success
+        end
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns the message' do
+        expect(subject.to_s).to eq(message)
+      end
+    end
+
+    describe '#avs_result' do
+      it 'should be an empty hash' do
+        expect(subject.avs_result).to eq({})
+      end
+    end
+
+    describe '#cvv_result' do
+      it 'should be nil' do
+        expect(subject.cvv_result).to be_nil
+      end
+    end
+  end
+end

data/spec/solidus_six_saferpay/gateway_spec.rb

@@ -0,0 +1,365 @@
+require 'rails_helper'
+
+module SolidusSixSaferpay
+  RSpec.describe Gateway do
+    # config options
+    let(:customer_id) { 'CUSTOMER_ID' }
+    let(:terminal_id) { 'TERMINAL_ID' }
+    let(:username) { 'USERNAME' }
+    let(:password) { 'PASSWORD' }
+    let(:base_url) { 'https://test.saferpay-api-host.test' }
+    let(:css_url) { '/custom/css/url' }
+
+    let(:gateway) do
+      described_class.new(
+        customer_id: customer_id,
+        terminal_id: terminal_id,
+        username: username,
+        password: password,
+        base_url: base_url,
+        css_url: css_url
+      )
+    end
+
+    describe '#new' do
+      
+      it 'configures the API client' do
+        gateway = described_class.new(
+          customer_id: customer_id,
+          terminal_id: terminal_id,
+          username: username,
+          password: password,
+          base_url: base_url,
+          css_url: css_url
+        )
+
+        config = SixSaferpay.config
+
+        expect(config.customer_id).to eq(customer_id)
+        expect(config.terminal_id).to eq(terminal_id)
+        expect(config.username).to eq(username)
+        expect(config.password).to eq(password)
+        expect(config.base_url).to eq(base_url)
+        expect(config.css_url).to eq(css_url)
+      end
+
+      context 'when global options are not passed' do
+
+        before do
+          allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_CUSTOMER_ID').and_return(customer_id)
+          allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_TERMINAL_ID').and_return(terminal_id)
+          allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_USERNAME').and_return(username)
+          allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_PASSWORD').and_return(password)
+          allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_BASE_URL').and_return(base_url)
+          allow(ENV).to receive(:fetch).with('SIX_SAFERPAY_CSS_URL').and_return(css_url)
+        end
+        
+        it 'falls back to ENV vars' do
+          gateway = described_class.new
+
+          config = SixSaferpay.config
+
+          expect(config.customer_id).to eq(customer_id)
+          expect(config.terminal_id).to eq(terminal_id)
+          expect(config.username).to eq(username)
+          expect(config.password).to eq(password)
+          expect(config.base_url).to eq(base_url)
+          expect(config.css_url).to eq(css_url)
+        end
+      end
+    end
+
+    describe '#initialize_payment' do
+
+      let(:order) { create(:order) }
+      let(:payment_method) { create(:saferpay_payment_method) }
+
+      it 'fails because it does not know which interface to use' do
+        expect { gateway.initialize_payment(order, payment_method) }.to raise_error(NotImplementedError)
+      end
+    end
+
+    describe '#authorize' do
+
+      let(:payment) { create(:six_saferpay_payment) }
+      let(:amount) { payment.order.total }
+
+      it 'fails because authorize must be defined in a subclass' do
+        expect { gateway.authorize(amount, payment) }.to raise_error(NotImplementedError)
+      end
+    end
+
+    describe '#inquire' do
+
+      let(:payment) { create(:six_saferpay_payment) }
+
+      it 'fails because inquire must be defined in a subclass' do
+        expect { gateway.inquire(payment) }.to raise_error(NotImplementedError)
+      end
+    end
+
+    describe '#purchase' do
+      let(:payment) { create(:six_saferpay_payment) }
+      let(:amount) { payment.order.total }
+
+      it 'delegates to capture (with a different signature)' do
+        expect(gateway).to receive(:capture).with(amount, payment.transaction_id, {})
+
+        gateway.purchase(amount, payment)
+      end
+      
+    end
+
+    describe '#capture' do
+      let(:amount) { 500 }
+      let(:transaction_id) { "TRANSACTION_ID" }
+
+      let(:api_capture_response) do
+        SixSaferpay::SixTransaction::CaptureResponse.new(
+          response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+          capture_id: 'CAPTURE_ID',
+          status: 'CAPTURED',
+          date: '2015-01-30T12:45:22.258+01:00'
+        )
+      end
+
+      let(:transaction_reference) { instance_double("SixSaferpay::TransactionReference", transaction_id: transaction_id) }
+      let(:saferpay_capture) { instance_double("SixSaferpay::SixTransaction::Capture") }
+
+      it 'captures the given transaction via the Saferpay API' do
+        expect(SixSaferpay::TransactionReference).to receive(:new).with(transaction_id: transaction_id).and_return(transaction_reference)
+        expect(SixSaferpay::SixTransaction::Capture).to receive(:new).with(transaction_reference: transaction_reference).and_return(saferpay_capture)
+        expect(SixSaferpay::Client).to receive(:post).with(saferpay_capture).and_return(api_capture_response)
+
+        gateway.capture(amount, transaction_id)
+      end
+
+      context 'when the capture is successful' do
+        before do
+          allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Capture)).and_return(api_capture_response)
+        end
+
+        it 'returns a success gateway response' do
+          expect(GatewayResponse).to receive(:new).with(true, instance_of(String), api_capture_response, { authorization: api_capture_response.capture_id } )
+
+          gateway.capture(amount, transaction_id)
+        end
+      end
+
+      context 'when the API raises an error' do
+        let(:six_saferpay_error) do
+          SixSaferpay::Error.new(
+            response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+            behavior: 'ABORT',
+            error_name: 'INVALID_TRANSACTION',
+            error_message: 'error_message'
+          )
+        end
+
+        before do
+          allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Capture)).and_raise(six_saferpay_error)
+        end
+
+        it 'handles the error gracefully' do
+          expect(GatewayResponse).to receive(:new).with(false, six_saferpay_error.error_message, nil, error_name: six_saferpay_error.error_name)
+
+          gateway.capture(amount, transaction_id)
+        end
+      end
+    end
+
+    describe '#void' do
+      let(:transaction_id) { 'TRANSACTION_ID' }
+
+      let(:transaction_reference) { instance_double("SixSaferpay::TransactionReference") }
+      let(:saferpay_cancel) { instance_double("SixSaferpay::SixTransaction::Cancel") }
+
+      let(:api_cancel_response) do
+        SixSaferpay::SixTransaction::CancelResponse.new(
+          response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+          transaction_id: transaction_id,
+        )
+      end
+
+      it 'cancels the payment' do
+        expect(SixSaferpay::TransactionReference).to receive(:new).with(transaction_id: transaction_id).and_return(transaction_reference)
+        expect(SixSaferpay::SixTransaction::Cancel).to receive(:new).with(transaction_reference: transaction_reference).and_return(saferpay_cancel)
+        expect(SixSaferpay::Client).to receive(:post).with(saferpay_cancel).and_return(api_cancel_response)
+
+        gateway.void(transaction_id)
+      end
+
+      context 'when the cancellation is successful' do
+        before do
+          allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Cancel)).and_return(api_cancel_response)
+        end
+
+        it 'returns a success gateway response' do
+          expect(GatewayResponse).to receive(:new).with(true, instance_of(String), api_cancel_response, {})
+
+          gateway.void(transaction_id)
+        end
+      end
+
+      context 'when the API raises an error' do
+        let(:six_saferpay_error) do
+          SixSaferpay::Error.new(
+            response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+            behavior: 'ABORT',
+            error_name: 'INVALID_TRANSACTION',
+            error_message: 'error_message'
+          )
+        end
+
+        before do
+          allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Cancel)).and_raise(six_saferpay_error)
+        end
+
+        it 'handles the error gracefully' do
+          expect(GatewayResponse).to receive(:new).with(false, six_saferpay_error.error_message, nil, error_name: six_saferpay_error.error_name)
+
+          gateway.void(transaction_id)
+        end
+      end
+    end
+
+    describe '#try_void' do
+      let(:transaction_id) { "TRANSACTION_ID" }
+      let(:payment) { create(:payment, response_code: transaction_id) }
+
+      context 'if payment is in checkout state and has transaction_id' do
+        it 'voids the payment' do
+          expect(gateway).to receive(:void).with(transaction_id, originator: gateway)
+
+          gateway.try_void(payment)
+        end
+      end
+    end
+
+    describe '#credit' do
+      let(:amount) { 400 }
+      let(:transaction_id) { 'TRANSACTION_ID' }
+      let(:options) { {a: 'a', b: 'b'} }
+
+      it 'is aliased to #refund' do
+        expect(gateway).to receive(:refund).with(amount, transaction_id, options)
+
+        gateway.credit(amount, transaction_id, options)
+      end
+    end
+
+    describe '#refund' do
+      let(:transaction_amount) { 400 }
+      let(:refund_amount) { 300 }
+      let(:transaction_id) { 'TRANSACTION_ID' }
+      let(:refund_id) { 'REFUND_ID' }
+
+      let!(:payment) { create(:payment_using_saferpay, response_code: transaction_id, amount: transaction_amount) }
+
+      let(:saferpay_refund) do
+        amount = SixSaferpay::Amount.new(value: (refund_amount * 100), currency_code: payment.order.currency)
+        refund = SixSaferpay::Refund.new(amount: amount, order_id: payment.order.number)
+        capture_reference = SixSaferpay::CaptureReference.new(capture_id: transaction_id)
+
+        SixSaferpay::SixTransaction::Refund.new(
+          refund: refund,
+          capture_reference: capture_reference
+        )
+      end
+
+      let(:api_refund_response) do
+        transaction = SixSaferpay::Transaction.new(
+          type: 'REFUND',
+          status: 'AUTHORIZED',
+          id: refund_id,
+          date: '2015-01-30T12:45:22.258+01:00',
+          amount: SixSaferpay::Amount.new(
+            value: refund_amount,
+            currency_code: payment.order.currency
+          ),
+          six_transaction_reference: 'SIX_TRANSACTION_REFERENCE'
+        )
+
+        payment_means = SixSaferpay::ResponsePaymentMeans.new(
+          brand: SixSaferpay::Brand.new(name: 'BrandName'),
+          display_text: 'xxxxxxxxxxxx1234'
+        )
+
+        SixSaferpay::SixTransaction::RefundResponse.new(
+          response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+          transaction: transaction,
+          payment_means: payment_means
+        )
+      end
+
+      it 'refunds and directly captures the payment' do
+        expect(SixSaferpay::SixTransaction::Refund).to receive(:new).with(refund: instance_of(SixSaferpay::Refund), capture_reference: instance_of(SixSaferpay::CaptureReference)).and_return(saferpay_refund)
+
+        expect(SixSaferpay::Client).to receive(:post).with(saferpay_refund).and_return(api_refund_response)
+
+        expect(gateway).to receive(:capture).with(refund_amount, refund_id, {})
+
+        gateway.refund(refund_amount, transaction_id)
+      end
+
+      context 'when the refund is successful' do
+        let(:api_capture_response) do
+          SixSaferpay::SixTransaction::CaptureResponse.new(
+            response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+            capture_id: 'CAPTURE_ID',
+            status: 'CAPTURED',
+            date: '2015-01-30T12:45:22.258+01:00'
+          )
+        end
+
+        before do
+          allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Refund)).and_return(api_refund_response)
+          allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Capture)).and_return(api_capture_response)
+        end
+
+        it 'returns a success gateway response' do
+          expect(GatewayResponse).to receive(:new).with(true, instance_of(String), api_capture_response, { authorization: 'CAPTURE_ID' })
+
+          gateway.refund(refund_amount, transaction_id)
+        end
+      end
+
+      context 'when the API raises an error' do
+        let(:six_saferpay_error) do
+          SixSaferpay::Error.new(
+            response_header: SixSaferpay::ResponseHeader.new(request_id: 'request_id', spec_version: 'test'),
+            behavior: 'ABORT',
+            error_name: 'INVALID_TRANSACTION',
+            error_message: 'error_message'
+          )
+        end
+
+        context 'during refunding' do
+          before do
+            allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Refund)).and_raise(six_saferpay_error)
+          end
+
+          it 'handles the error gracefully' do
+            expect(GatewayResponse).to receive(:new).with(false, six_saferpay_error.error_message, nil, error_name: six_saferpay_error.error_name)
+
+            gateway.refund(refund_amount, transaction_id)
+          end
+        end
+
+        context 'during capture' do
+          before do
+            allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Refund)).and_return(api_refund_response)
+            allow(SixSaferpay::Client).to receive(:post).with(instance_of(SixSaferpay::SixTransaction::Capture)).and_raise(six_saferpay_error)
+          end
+
+          it 'handles the error gracefully' do
+            expect(GatewayResponse).to receive(:new).with(false, six_saferpay_error.error_message, nil, error_name: six_saferpay_error.error_name)
+
+            gateway.refund(refund_amount, transaction_id)
+          end
+        end
+        
+      end
+    end
+  end
+end