buckaruby 1.2.0 → 1.6.0

data/lib/buckaruby/ideal.rb

@@ -8,12 +8,13 @@ module Buckaruby
       "BUNQNL2A" => "bunq",
       "HANDNL2A" => "Handelsbanken",
       "INGBNL2A" => "ING",
-      "KNABNL2H" => "Knab bank",
+      "KNABNL2H" => "Knab",
       "MOYONL21" => "Moneyou",
       "RABONL2U" => "Rabobank",
-      "RBRBNL21" => "RegioBank",
+      "RBRBNL21" => "Regiobank",
+      "REVOLT21" => "Revolut",
       "SNSBNL2A" => "SNS Bank",
-      "TRIONL2U" => "Triodos Bank",
+      "TRIONL2U" => "Triodos",
       "FVLBNL22" => "Van Lanschot"
     }.freeze
   end

data/lib/buckaruby/operation.rb

@@ -4,6 +4,7 @@ module Buckaruby
   module Operation
     TRANSACTION_REQUEST = "TransactionRequest"
     TRANSACTION_STATUS = "TransactionStatus"
+    TRANSACTION_REQUEST_SPECIFICATION = "TransactionRequestSpecification"
     REFUND_INFO = "RefundInfo"
     CANCEL_TRANSACTION = "CancelTransaction"
   end

data/lib/buckaruby/payment_method.rb

@@ -8,11 +8,13 @@ module Buckaruby
     SEPA_DIRECT_DEBIT = "sepadirectdebit"
     PAYPAL = "paypal"
     BANCONTACT_MISTER_CASH = "bancontactmrcash"
+    SOFORT = "sofortueberweisung"
     TRANSFER = "transfer"
 
     # Credit cards
     VISA = "visa"
     MASTER_CARD = "mastercard"
     MAESTRO = "maestro"
+    AMERICAN_EXPRESS = "amex"
   end
 end

data/lib/buckaruby/request.rb

@@ -159,6 +159,30 @@ module Buckaruby
     end
   end
 
+  # Request for a creating a transaction specification.
+  class TransactionSpecificationRequest < Request
+    def execute(options)
+      super(options.merge(operation: Operation::TRANSACTION_REQUEST_SPECIFICATION))
+    end
+
+    def build_request_params(options)
+      params = {}
+
+      if options[:payment_method]
+        if options[:payment_method].respond_to?(:join)
+          params[:brq_services] = options[:payment_method].join(",")
+        else
+          params[:brq_services] = options[:payment_method]
+        end
+      end
+
+      params[:brq_latestversiononly] = "true"
+      params[:brq_culture] = options[:culture] || Language::DUTCH
+
+      params
+    end
+  end
+
   # Request for a creating a recurrent transaction.
   class RecurrentTransactionRequest < TransactionRequest
     def build_transaction_request_params(options)

data/lib/buckaruby/response.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'support/case_insensitive_hash'
+
 require 'cgi'
 require 'date'
 
@@ -20,19 +22,7 @@ module Buckaruby
     end
 
     def status
-      # See http://support.buckaroo.nl/index.php/Statuscodes
-      case params[:brq_statuscode]
-      when '190'
-        TransactionStatus::SUCCESS
-      when '490', '491', '492'
-        TransactionStatus::FAILED
-      when '690'
-        TransactionStatus::REJECTED
-      when '790', '791', '792', '793'
-        TransactionStatus::PENDING
-      when '890', '891'
-        TransactionStatus::CANCELLED
-      end
+      TransactionStatus.parse(params[:brq_statuscode])
     end
 
     def timestamp
@@ -83,7 +73,7 @@ module Buckaruby
     end
 
     def verify_signature!(response, config)
-      if params[:brq_apiresult] != "Fail"
+      if params[:brq_apiresult].nil? || params[:brq_apiresult].casecmp("fail") != 0
         sent_signature = params[:brq_signature]
         generated_signature = Signature.generate_signature(response, config)
 
@@ -174,27 +164,7 @@ module Buckaruby
     end
 
     def transaction_type
-      if params[:brq_transaction_type] && !params[:brq_transaction_type].empty?
-        # See http://support.buckaroo.nl/index.php/Transactietypes
-        case params[:brq_transaction_type]
-        when 'C001', 'C002', 'C004', 'C021', 'C043', 'C044', 'C046', 'C089', 'C090', 'C192', 'C251', 'V001', 'V002', 'V010', 'V021', 'V032', 'V034', 'V043', 'V044', 'V046', 'V089', 'V090', 'V192', 'V245'
-          # Check the recurring flag to detect a normal or recurring transaction.
-          if params[:brq_recurring] && params[:brq_recurring].casecmp("true").zero?
-            TransactionType::PAYMENT_RECURRENT
-          else
-            TransactionType::PAYMENT
-          end
-        when 'C005', 'V014', 'V031', 'V094'
-          TransactionType::PAYMENT_RECURRENT
-        when 'C079', 'C080', 'C082', 'C092', 'C101', 'C102', 'C121', 'C194', 'C197', 'C252', 'C500', 'V067', 'V068', 'V070', 'V079', 'V080', 'V082', 'V092', 'V101', 'V102', 'V110', 'V149', 'V194', 'V197', 'V246'
-          TransactionType::REFUND
-        when 'C501', 'C502', 'C546', 'C551', 'C553', 'C554', 'C562', 'C589', 'C593', 'V111', 'V131', 'V132', 'V134', 'V143', 'V144', 'V146', 'V543', 'V544', 'V545', 'V546', 'V589', 'V592'
-          TransactionType::REVERSAL
-        end
-      else
-        # Fallback when transaction type is not known (cancelling credit card)
-        TransactionType::PAYMENT
-      end
+      TransactionType.parse(params[:brq_transaction_type], params[:brq_recurring])
     end
 
     def transaction_status
@@ -299,4 +269,19 @@ module Buckaruby
   class CallbackResponse < Response
     include TransactionResponse
   end
+
+  # Response when retrieving the specification for a transaction.
+  class TransactionSpecificationResponse < ApiResponse
+    def services
+      @services ||= FieldMapper.map_fields(params, :brq_services)
+    end
+
+    def basic_fields
+      @basic_fields ||= FieldMapper.map_fields(params, :brq_basicfields)
+    end
+
+    def custom_parameters
+      @custom_parameters ||= FieldMapper.map_fields(params, :brq_customparameters)
+    end
+  end
 end

data/lib/buckaruby/signature.rb

@@ -5,8 +5,10 @@ require 'digest'
 module Buckaruby
   # Calculate a signature based on the parameters of the payment request or response.
   # -> see BPE 3.0 Gateway NVP, chapter 4 'Digital Signature'
-  class Signature
-    def self.generate_signature(params, config)
+  module Signature
+    module_function
+
+    def generate_signature(params, config)
       case config.hash_method
       when :sha1
         Digest::SHA1.hexdigest(generate_signature_string(params, config.secret))
@@ -19,11 +21,27 @@ module Buckaruby
       end
     end
 
-    def self.generate_signature_string(params, secret)
+    def generate_signature_string(params, secret)
       sign_params = params.select { |key, _value| key.to_s.upcase.start_with?("BRQ_", "ADD_", "CUST_") && key.to_s.casecmp("BRQ_SIGNATURE").nonzero? }
-      string = sign_params.sort_by { |p| p.first.downcase }.map { |param| "#{param[0]}=#{param[1]}" }.join
+      sign_params = order_signature_params(sign_params)
+
+      string = sign_params.map { |param| "#{param[0]}=#{param[1]}" }.join
       string << secret
       string
     end
+
+    # Excerpt from the Buckaroo documentation, chapter 4 'Digital Signature':
+    #   In the payment engine, the used lexical sort algorithm uses the following order:
+    #   symbols first, then numbers, then case insensitive letters. Also, a shorter string
+    #   that is identical to the beginning of a longer string, comes before the longer string.
+    #   Take for example the following, comma separated, list which has been sorted:
+    #     a_a, a0, a0a, a1a, aaA, aab, aba, aCa
+    CHAR_ORDER = "_01234567890abcdefghijklmnopqrstuvwxyz"
+
+    def order_signature_params(params)
+      params.sort_by do |key, _value|
+        key.to_s.downcase.each_char.map { |c| CHAR_ORDER.index(c) }
+      end
+    end
   end
 end

data/lib/buckaruby/transaction_status.rb

@@ -1,11 +1,30 @@
 # frozen_string_literal: true
 
 module Buckaruby
+  # Parses the transaction status code from Buckaroo.
   module TransactionStatus
     SUCCESS = 1
     FAILED = 2
     REJECTED = 3
     CANCELLED = 4
     PENDING = 5
+
+    module_function
+
+    # See https://support.buckaroo.nl/categorie%C3%ABn/transacties/status
+    def parse(brq_statuscode)
+      case brq_statuscode
+      when '190'
+        TransactionStatus::SUCCESS
+      when '490', '491', '492'
+        TransactionStatus::FAILED
+      when '690'
+        TransactionStatus::REJECTED
+      when '790', '791', '792', '793'
+        TransactionStatus::PENDING
+      when '890', '891'
+        TransactionStatus::CANCELLED
+      end
+    end
   end
 end

data/lib/buckaruby/transaction_type.rb

@@ -1,10 +1,89 @@
 # frozen_string_literal: true
 
 module Buckaruby
+  # Parses the transaction type from Buckaroo.
   module TransactionType
     PAYMENT = 1
     PAYMENT_RECURRENT = 2
     REFUND = 3
     REVERSAL = 4
+
+    module_function
+
+    # See https://support.buckaroo.nl/categorie%C3%ABn/integratie/transactietypes-overzicht
+    def parse(brq_transaction_type, brq_recurring)
+      if brq_transaction_type && !brq_transaction_type.empty?
+        case brq_transaction_type
+        when 'C021', 'V021',                                  # iDEAL
+             'C002', 'C004', 'C005',                          # (SEPA) Direct Debit
+             'V010', 'V014',                                  # PayPal
+             'C090', 'V090',                                  # Bancontact
+             'N074', 'C075',                                  # Sofort
+             'C001',                                          # Transfer
+
+             'C044', 'C192', 'C283', 'C293', 'C318', 'C345',
+             'C880', 'C963', 'V002', 'V032', 'V038', 'V044',
+             'V192', 'V283', 'V293', 'V313', 'V318', 'V345',
+             'V696',                                          # Visa
+
+             'C043', 'C089', 'C273', 'C303', 'C328', 'C355',
+             'C876', 'C969', 'V001', 'V031', 'V037', 'V043',
+             'V089', 'V273', 'V303', 'V328', 'V355', 'V702',  # MasterCard
+
+             'C046', 'C251', 'C288', 'C308', 'C333', 'C872',
+             'C972', 'V034', 'V040', 'V046', 'V094', 'V245',
+             'V288', 'V308', 'V333', 'V705',                  # Maestro
+
+             'V003', 'V030', 'V036', 'V042'                   # American Express
+
+          # Check the recurring flag to detect a normal or recurring transaction.
+          if brq_recurring && brq_recurring.casecmp("true").zero?
+            TransactionType::PAYMENT_RECURRENT
+          else
+            TransactionType::PAYMENT
+          end
+        when 'C121',                                          # iDEAL
+             'C102', 'C500',                                  # (SEPA) Direct Debit
+             'V110',                                          # PayPal
+             'C092', 'V092',                                  # Bancontact
+             'N540', 'C543',                                  # Sofort
+             'C101',                                          # Transfer
+
+             'C080', 'C194', 'C281', 'C290', 'C315', 'C342',
+             'C881', 'C961', 'V068', 'V074', 'V080', 'V102',
+             'V194', 'V281', 'V290', 'V315', 'V342', 'V694',  # Visa
+
+             'C079', 'C197', 'C300', 'C325', 'C352', 'C371',
+             'C877', 'C967', 'V067', 'V073', 'V079', 'V101',
+             'V149', 'V197', 'V300', 'V325', 'V352', 'V371',
+             'V700',                                          # MasterCard
+
+             'C082', 'C252', 'C286', 'C305', 'C330', 'C873',
+             'C970', 'V070', 'V076', 'V082', 'V246', 'V286',
+             'V305', 'V330', 'V703',                          # Maestro
+
+             'V066', 'V072', 'V078', 'V103'                   # American Express
+          TransactionType::REFUND
+        when 'C501', 'C502', 'C562',                          # (SEPA) Direct Debit
+             'V111',                                          # PayPal
+             'C544',                                          # Sofort
+
+             'C554', 'C593', 'C882', 'V132', 'V138', 'V144',
+             'V544', 'V592',                                  # Visa
+
+             'C553', 'C589', 'C878', 'V131', 'V137', 'V143',
+             'V543', 'V589',                                  # MasterCard
+
+             'C546', 'C551', 'C874', 'V134', 'V140', 'V146',
+             'V545', 'V546',                                  # Maestro
+
+             'V130', 'V136', 'V142'                           # American Express
+          TransactionType::REVERSAL
+        end
+      else
+        # Fallback when transaction type is not known (e.g. cancelling credit card)
+        TransactionType::PAYMENT
+      end
+    end
   end
 end

data/lib/buckaruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Buckaruby
-  VERSION = "1.2.0"
+  VERSION = "1.6.0"
 end

data/spec/buckaruby/field_mapper_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Buckaruby::FieldMapper do
+  describe '.map_fields' do
+    let(:fields) do
+      {
+        brq_services_1_description: "iDEAL",
+        brq_services_1_name: "ideal",
+        brq_services_1_version: "2",
+        brq_services_1_supportedcurrencies_1_code: "EUR",
+        brq_services_1_supportedcurrencies_1_isonumber: "978",
+        brq_services_1_supportedcurrencies_1_name: "Euro",
+        brq_services_2_description: "Visa",
+        brq_services_2_name: "visa",
+        brq_services_2_version: "1",
+        brq_services_2_supportedcurrencies_1_code: "GBP",
+        brq_services_2_supportedcurrencies_1_isonumber: "826",
+        brq_services_2_supportedcurrencies_1_name: "Pond",
+        brq_services_2_supportedcurrencies_2_code: "USD",
+        brq_services_2_supportedcurrencies_2_isonumber: "840",
+        brq_services_2_supportedcurrencies_2_name: "US Dollar"
+      }
+    end
+
+    it 'maps NVP fields to arrays and hashes' do
+      services = Buckaruby::FieldMapper.map_fields(fields, :brq_services)
+      expect(services).to be_an_instance_of(Array)
+      expect(services.count).to eq(2)
+
+      ideal = services.first
+      expect(ideal).to be_an_instance_of(Buckaruby::Support::CaseInsensitiveHash)
+      expect(ideal[:description]).to eq("iDEAL")
+      expect(ideal[:name]).to eq("ideal")
+      expect(ideal[:version]).to eq("2")
+
+      visa = services.last
+      expect(visa).to be_an_instance_of(Buckaruby::Support::CaseInsensitiveHash)
+      expect(visa[:description]).to eq("Visa")
+      expect(visa[:name]).to eq("visa")
+      expect(visa[:version]).to eq("1")
+    end
+
+    it 'maps NVP subfields to arrays and hashes' do
+      services = Buckaruby::FieldMapper.map_fields(fields, :brq_services)
+
+      currencies = services.first[:supportedcurrencies]
+      expect(currencies).to be_an_instance_of(Array)
+      expect(currencies.count).to eq(1)
+
+      currency = currencies.first
+      expect(currency).to be_an_instance_of(Buckaruby::Support::CaseInsensitiveHash)
+      expect(currency[:code]).to eq("EUR")
+      expect(currency[:isonumber]).to eq("978")
+      expect(currency[:name]).to eq("Euro")
+
+      currencies = services.last[:supportedcurrencies]
+      expect(currencies).to be_an_instance_of(Array)
+      expect(currencies.count).to eq(2)
+
+      currency = currencies.first
+      expect(currency).to be_an_instance_of(Buckaruby::Support::CaseInsensitiveHash)
+      expect(currency[:code]).to eq("GBP")
+      expect(currency[:isonumber]).to eq("826")
+      expect(currency[:name]).to eq("Pond")
+    end
+  end
+end

data/spec/buckaruby/gateway_spec.rb

@@ -29,6 +29,17 @@ RSpec.describe Buckaruby::Gateway do
 
   it { expect(subject).to be_an_instance_of(Buckaruby::Gateway) }
 
+  describe '#payment_methods' do
+    before do
+      stub_request(:post, "https://testcheckout.buckaroo.nl/nvp/?op=TransactionRequestSpecification").to_return(body: File.read("spec/fixtures/responses/specify_transaction_success.txt"))
+    end
+
+    it 'returns the payment methods enabled by Buckaroo and supported by this library' do
+      payment_methods = subject.payment_methods
+      expect(payment_methods).to eq([Buckaruby::PaymentMethod::IDEAL, Buckaruby::PaymentMethod::VISA])
+    end
+  end
+
   describe '#issuers' do
     context 'when no or false parameters are passed' do
       it 'raises an ArgumentError' do
@@ -207,6 +218,16 @@ RSpec.describe Buckaruby::Gateway do
       expect(response.to_h).to be_an_instance_of(Hash)
     end
 
+    it 'initiates a transaction for payment method sofort' do
+      response = subject.setup_transaction(amount: 10, payment_method: Buckaruby::PaymentMethod::SOFORT, invoicenumber: "12345", return_url: "http://www.return.url/")
+      expect(response).to be_an_instance_of(Buckaruby::SetupTransactionResponse)
+      expect(response.transaction_id).to eq("41C48B55FA9164E123CC73B1157459E840BE5D24")
+      expect(response.transaction_status).to eq(Buckaruby::TransactionStatus::PENDING)
+      expect(response.redirect_url).not_to be nil
+      expect(response.timestamp).to be_an_instance_of(Time)
+      expect(response.to_h).to be_an_instance_of(Hash)
+    end
+
     context 'with custom variables' do
       it 'sends the custom variables with the request' do
         response = subject.setup_transaction(amount: 10, payment_method: Buckaruby::PaymentMethod::IDEAL, payment_issuer: "ABNANL2A", invoicenumber: "12345", return_url: "http://www.return.url/", custom: { foo: :bar, quux: "42" })
@@ -215,7 +236,7 @@ RSpec.describe Buckaruby::Gateway do
         expect(response.custom[:quux]).to eq("42")
 
         expect(WebMock).to have_requested(:post, "https://testcheckout.buckaroo.nl/nvp/?op=TransactionRequest")
-          .with(body: "brq_websitekey=12345678&brq_payment_method=ideal&brq_culture=nl-NL&brq_currency=EUR&brq_amount=10.0&brq_invoicenumber=12345&brq_service_ideal_action=Pay&brq_service_ideal_issuer=ABNANL2A&brq_service_ideal_version=2&brq_return=http%3A%2F%2Fwww.return.url%2F&cust_foo=bar&cust_quux=42&add_buckaruby=Buckaruby+#{Buckaruby::VERSION}&brq_signature=0fb3ff3c1f140b5aede33a0fdacbc5675830120d")
+          .with(body: "brq_websitekey=12345678&brq_payment_method=ideal&brq_culture=nl-NL&brq_currency=EUR&brq_amount=10.0&brq_invoicenumber=12345&brq_service_ideal_action=Pay&brq_service_ideal_issuer=ABNANL2A&brq_service_ideal_version=2&brq_return=http%3A%2F%2Fwww.return.url%2F&cust_foo=bar&cust_quux=42&add_buckaruby=Buckaruby+#{Buckaruby::VERSION}&brq_signature=f2c060e624faf02aabf8958d2a1898e2cbcfeac7")
       end
     end
 
@@ -227,7 +248,7 @@ RSpec.describe Buckaruby::Gateway do
         expect(response.additional[:myreference]).to eq("12345")
 
         expect(WebMock).to have_requested(:post, "https://testcheckout.buckaroo.nl/nvp/?op=TransactionRequest")
-          .with(body: "brq_websitekey=12345678&brq_payment_method=ideal&brq_culture=nl-NL&brq_currency=EUR&brq_amount=10.0&brq_invoicenumber=12345&brq_service_ideal_action=Pay&brq_service_ideal_issuer=ABNANL2A&brq_service_ideal_version=2&brq_return=http%3A%2F%2Fwww.return.url%2F&add_myreference=12345&add_buckaruby=Buckaruby+#{Buckaruby::VERSION}&brq_signature=f7996840436bdd55dada28b80c62ed88af10cd23")
+          .with(body: "brq_websitekey=12345678&brq_payment_method=ideal&brq_culture=nl-NL&brq_currency=EUR&brq_amount=10.0&brq_invoicenumber=12345&brq_service_ideal_action=Pay&brq_service_ideal_issuer=ABNANL2A&brq_service_ideal_version=2&brq_return=http%3A%2F%2Fwww.return.url%2F&add_myreference=12345&add_buckaruby=Buckaruby+#{Buckaruby::VERSION}&brq_signature=d9f8aebb207f8694ce819b6a84b557839cdbc69f")
       end
     end
   end
@@ -402,6 +423,36 @@ RSpec.describe Buckaruby::Gateway do
     end
   end
 
+  describe '#specify_transaction' do
+    before do
+      stub_request(:post, "https://testcheckout.buckaroo.nl/nvp/?op=TransactionRequestSpecification").to_return(body: File.read("spec/fixtures/responses/specify_transaction_success.txt"))
+    end
+
+    it 'retrieves the specification for setting up a transaction' do
+      response = subject.specify_transaction
+      expect(response).to be_an_instance_of(Buckaruby::TransactionSpecificationResponse)
+
+      services = response.services
+      expect(services).to be_an_instance_of(Array)
+      expect(services.length).to eq(2)
+
+      service = services.last
+      expect(service).to be_an_instance_of(Buckaruby::Support::CaseInsensitiveHash)
+      expect(service[:name]).to eq(Buckaruby::PaymentMethod::VISA)
+      expect(service[:description]).to eq("Visa")
+      expect(service[:version]).to eq("1")
+
+      currencies = service[:supportedcurrencies]
+      expect(currencies).to be_an_instance_of(Array)
+      expect(currencies.length).to eq(21)
+
+      currency = currencies.last
+      expect(currency).to be_an_instance_of(Buckaruby::Support::CaseInsensitiveHash)
+      expect(currency[:name]).to eq("US Dollar")
+      expect(currency[:code]).to eq(Buckaruby::Currency::US_DOLLAR)
+    end
+  end
+
   describe '#callback' do
     it 'raises an exception when parameters are missing' do
       expect {
@@ -573,6 +624,48 @@ RSpec.describe Buckaruby::Gateway do
         expect(response.timestamp).to be_an_instance_of(Time)
         expect(response.to_h).to be_an_instance_of(Hash)
       end
+
+      it 'sets the transaction type to payment and payment method to VISA for visa callback' do
+        params = File.read("spec/fixtures/responses/callback_payment_visa.txt")
+
+        response = subject.callback(params)
+        expect(response.transaction_status).to eq(Buckaruby::TransactionStatus::SUCCESS)
+        expect(response.transaction_type).to eq(Buckaruby::TransactionType::PAYMENT)
+        expect(response.payment_method).to eq(Buckaruby::PaymentMethod::VISA)
+        expect(response.transaction_id).to eq("41C48B55FA9164E123CC73B1157459E840BE5D24")
+        expect(response.payment_id).to eq("E86256B2787EE7FF0C33D0D4C6159CD922227B79")
+        expect(response.invoicenumber).to eq("12345")
+        expect(response.timestamp).to be_an_instance_of(Time)
+        expect(response.to_h).to be_an_instance_of(Hash)
+      end
+
+      it 'sets the transaction type to payment and payment method to American Express for amex callback' do
+        params = File.read("spec/fixtures/responses/callback_payment_amex.txt")
+
+        response = subject.callback(params)
+        expect(response.transaction_status).to eq(Buckaruby::TransactionStatus::SUCCESS)
+        expect(response.transaction_type).to eq(Buckaruby::TransactionType::PAYMENT)
+        expect(response.payment_method).to eq(Buckaruby::PaymentMethod::AMERICAN_EXPRESS)
+        expect(response.transaction_id).to eq("41C48B55FA9164E123CC73B1157459E840BE5D24")
+        expect(response.payment_id).to eq("E86256B2787EE7FF0C33D0D4C6159CD922227B79")
+        expect(response.invoicenumber).to eq("12345")
+        expect(response.timestamp).to be_an_instance_of(Time)
+        expect(response.to_h).to be_an_instance_of(Hash)
+      end
+
+      it 'sets the transaction type to payment and payment method to Sofrt for sort callback' do
+        params = File.read("spec/fixtures/responses/callback_payment_sofort.txt")
+
+        response = subject.callback(params)
+        expect(response.transaction_status).to eq(Buckaruby::TransactionStatus::PENDING)
+        expect(response.transaction_type).to eq(Buckaruby::TransactionType::PAYMENT)
+        expect(response.payment_method).to eq(Buckaruby::PaymentMethod::SOFORT)
+        expect(response.transaction_id).to eq("41C48B55FA9164E123CC73B1157459E840BE5D24")
+        expect(response.payment_id).to eq("E86256B2787EE7FF0C33D0D4C6159CD922227B79")
+        expect(response.invoicenumber).to eq("12345")
+        expect(response.timestamp).to be_an_instance_of(Time)
+        expect(response.to_h).to be_an_instance_of(Hash)
+      end
     end
 
     context 'when callback is a payment recurrent response' do
@@ -635,6 +728,21 @@ RSpec.describe Buckaruby::Gateway do
         expect(response.timestamp).to be_an_instance_of(Time)
         expect(response.to_h).to be_an_instance_of(Hash)
       end
+
+      it 'recognizes an amex refund response' do
+        params = File.read("spec/fixtures/responses/callback_refund_amex.txt")
+
+        response = subject.callback(params)
+        expect(response.transaction_status).to eq(Buckaruby::TransactionStatus::SUCCESS)
+        expect(response.transaction_type).to eq(Buckaruby::TransactionType::REFUND)
+        expect(response.payment_method).to eq(Buckaruby::PaymentMethod::AMERICAN_EXPRESS)
+        expect(response.transaction_id).to eq("B51118F58785274E117EFE1BF99D4D50CCB96949")
+        expect(response.payment_id).to be nil
+        expect(response.invoicenumber).to eq("12345")
+        expect(response.refund_transaction_id).to eq("41C48B55FA9164E123CC73B1157459E840BE5D24")
+        expect(response.timestamp).to be_an_instance_of(Time)
+        expect(response.to_h).to be_an_instance_of(Hash)
+      end
     end
 
     context 'when callback is a reversal response' do