pensio_api 0.2.3 → 0.3.4

data/lib/pensio_api/responses/base.rb

@@ -9,24 +9,28 @@ module PensioAPI
         @raw = request.body
         @headers = request.headers
         unless success?
-          raise PensioAPI::Errors::BadRequest.new(request) unless header_ok
-          raise PensioAPI::Errors::GatewayError.new(request) unless body_ok
+          raise PensioAPI::Errors::BadRequest.new(request) unless header_ok?
+          raise PensioAPI::Errors::GatewayError.new(request) unless body_ok? || chargeback?
         end
       end
 
       def success?
-        header_ok && body_ok
+        header_ok? && (body_ok? || chargeback?)
       end
 
       private
 
-      def header_ok
+      def header_ok?
         @headers['ErrorCode'].to_i == 0
       end
 
-      def body_ok
+      def body_ok?
         !@raw.has_key?('Result') || ['Success', 'OK', nil].include?(@raw['Result'])
       end
+
+      def chargeback?
+        @raw['Result'] == 'ChargebackEvent'
+      end
     end
   end
 end

data/lib/pensio_api/responses/chargeback_callback.rb

@@ -0,0 +1,6 @@
+module PensioAPI
+  module Responses
+    class ChargebackCallback < Transaction
+    end
+  end
+end

data/lib/pensio_api/responses/refund.rb

@@ -9,7 +9,7 @@ module PensioAPI
         @transaction = PensioAPI::Transaction.new(
           transactions['Transaction']
         )
-        @refund_amount = BigDecimal.new(@raw['RefundedAmount'])
+        @refund_amount = BigDecimal(@raw['RefundedAmount'])
         @refund_currency = @raw['RefundCurrency'].to_i
       end
     end

data/lib/pensio_api/responses/reservation.rb

@@ -1,15 +1,19 @@
 module PensioAPI
   module Responses
-    class Reservation < Base
-      attr_reader :transaction
+    class Reservation < Transaction
 
-      def initialize(request)
-        super(request)
+      def each
+        [reservation, charge].each { |t| yield t }
+      end
+
+      def reservation
+        @transactions.first
+      end
 
-        @transaction = PensioAPI::Transaction.new(
-          transactions['Transaction']
-        )
+      def charge
+        @transactions.last
       end
+      
     end
   end
 end

data/lib/pensio_api/responses/reservation_capture.rb

@@ -1,12 +1,15 @@
 module PensioAPI
   module Responses
-    class ReservationCapture < Responses::Reservation
-      attr_reader :capture_amount, :capture_currency
+    class ReservationCapture < Base
+      attr_reader :transaction, :capture_amount, :capture_currency
 
       def initialize(request)
         super(request)
 
-        @capture_amount = BigDecimal.new(@raw['CaptureAmount'])
+        @transaction = PensioAPI::Transaction.new(
+          transactions['Transaction']
+        )
+        @capture_amount = BigDecimal(@raw['CaptureAmount'])
         @capture_currency = @raw['CaptureCurrency'].to_i
       end
     end

data/lib/pensio_api/responses/reservation_release.rb

@@ -1,6 +1,15 @@
 module PensioAPI
   module Responses
-    class ReservationRelease < Responses::Reservation
+    class ReservationRelease < Base
+      attr_reader :transaction
+
+      def initialize(request)
+        super(request)
+
+        @transaction = PensioAPI::Transaction.new(
+          transactions['Transaction']
+        )
+      end
     end
   end
 end

data/lib/pensio_api/transaction.rb

@@ -15,6 +15,8 @@ module PensioAPI
     attr_reader :order_id
     attr_reader :merchant_currency
     attr_reader :card_holder_currency
+    attr_reader :payment_source
+    attr_reader :chargeback_events
 
     # constants for transaction statuses
     STATUS_RECURRING_CONFIRMED = 'recurring_confirmed'
@@ -30,10 +32,10 @@ module PensioAPI
 
       @status = @raw['TransactionStatus']
 
-      @captured_amount = BigDecimal.new(@raw['CapturedAmount'])
-      @reserved_amount = BigDecimal.new(@raw['ReservedAmount'])
-      @refunded_amount = BigDecimal.new(@raw['RefundedAmount'])
-      @recurring_default_amount = BigDecimal.new(@raw['RecurringDefaultAmount'])
+      @captured_amount = BigDecimal(@raw['CapturedAmount'])
+      @reserved_amount = BigDecimal(@raw['ReservedAmount'])
+      @refunded_amount = BigDecimal(@raw['RefundedAmount'])
+      @recurring_default_amount = BigDecimal(@raw['RecurringDefaultAmount'])
 
       @card_status = @raw['CardStatus']
       @card_token = @raw['CreditCardToken']
@@ -43,6 +45,10 @@ module PensioAPI
 
       @merchant_currency = @raw['MerchantCurrency'].to_i
       @card_holder_currency = @raw['CardHolderCurrency'].to_i
+
+      @payment_source = @raw['PaymentSource']
+
+      map_chargeback_events
     end
 
     def self.find(options={})
@@ -80,5 +86,23 @@ module PensioAPI
         BillingAddress.new(@raw['CustomerInfo']['BillingAddress'])
       end
     end
+
+    private
+      
+    def map_chargeback_events
+      @chargeback_events = if raw_chargeback_events.is_a?(Array)
+        raw_chargeback_events.map { |c| PensioAPI::ChargebackEvent.new(c) }
+      else
+        [PensioAPI::ChargebackEvent.new(raw_chargeback_events)]
+      end
+    end
+
+    def raw_chargeback_events
+      @raw_chargeback_events ||= if @raw['ChargebackEvents']
+        @raw['ChargebackEvents']['ChargebackEvent']
+      else
+        []
+      end
+    end
   end
 end

data/lib/pensio_api/version.rb

@@ -0,0 +1,3 @@
+module PensioAPI
+  VERSION = '0.3.4'.freeze
+end

data/pensio_api.gemspec

@@ -1,6 +1,10 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pensio_api/version'
+
 Gem::Specification.new do |s|
   s.name = 'pensio_api'
-  s.version = '0.2.3'
+  s.version = PensioAPI::VERSION
   s.license = 'BSD-3-Clause'
   s.summary = "Provides integration for the Pensio Merchant API"
   s.authors = ['Michael Sell', 'Rory Sinclair']

data/spec/lib/pensio_api/callback_spec.rb

@@ -6,7 +6,7 @@ describe PensioAPI::Callback do
     let(:response) { PensioAPI::Callback.parse_success(file_fixture("success_callback.xml")) }
     it "should return a SuccessCallback response" do
       expect(response).to be_an_instance_of(PensioAPI::Responses::SuccessCallback)
-      expect(response.success?).to be_true
+      expect(response.success?).to be true
     end
   end
   
@@ -14,7 +14,15 @@ describe PensioAPI::Callback do
     let(:response) { PensioAPI::Callback.parse_failure(file_fixture("subscription_failure_callback.xml")) }
     it "should return a SubscriptionFailureCallback response" do
       expect(response).to be_an_instance_of(PensioAPI::Responses::SubscriptionFailureCallback)
-      expect(response.success?).to be_true
+      expect(response.success?).to be true
+    end
+  end
+
+  describe ".parse_chargeback" do
+    let(:response) { PensioAPI::Callback.parse_chargeback(file_fixture("chargeback_callback.xml")) }
+    it "should return a ChargebackCallback response" do
+      expect(response).to be_an_instance_of(PensioAPI::Responses::ChargebackCallback)
+      expect(response.success?).to be true
     end
   end
 end

data/spec/lib/pensio_api/chargeback_event_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe PensioAPI::ChargebackEvent do
+  let(:response) { PensioAPI::Callback.parse_chargeback(file_fixture("chargeback_callback.xml")) }
+  let(:transaction) { response.transactions.last }
+  let(:chargeback_event) { transaction.chargeback_events.last }
+
+  describe 'reader attributes' do
+    describe 'type' do
+      specify { expect(chargeback_event.type).to be_an_instance_of(String) }
+    end
+
+    describe 'reason_code' do
+      specify { expect(chargeback_event.reason_code).to be_an_instance_of(Integer) }
+    end
+
+    describe 'reason' do
+      specify { expect(chargeback_event.reason).to be_an_instance_of(String) }
+    end
+
+    describe 'amount' do
+      specify { expect(chargeback_event.amount).to be_an_instance_of(BigDecimal) }
+    end
+
+    describe 'currency' do
+      specify { expect(chargeback_event.currency).to be_an_instance_of(String) }
+    end
+
+    describe 'acquirer_transaction_id' do
+      specify { expect(chargeback_event.acquirer_transaction_id).to be_an_instance_of(String) }
+    end
+  end
+
+  describe 'created_at' do
+    specify { expect(chargeback_event.created_at).to be_an_instance_of(Time) }
+  end
+end

data/spec/lib/pensio_api/ecommerce_spec.rb

@@ -7,14 +7,25 @@ describe PensioAPI::Ecommerce do
   end
 
   describe '.create_payment_request' do
-    let(:response) { PensioAPI::Ecommerce.create_payment_request(reservation_arguments) }
+    let(:response) {PensioAPI::Ecommerce.create_payment_request(reservation_arguments.merge({timeout: 10}))}
     it 'returns an instance of PensioAPI::Responses::GatewayURL' do
+      expect(PensioAPI::Request).to receive(:post).with("/merchant/API/createPaymentRequest",
+                                                        {:basic_auth => {:username => "test_user", :password => "password"},
+                                                         :headers => {
+                                                             "Content-Type" => "application/x-www-form-urlencoded; charset=utf-8",
+                                                             'x-altapay-client-version' => "RUBYSDK/#{PensioAPI::VERSION}"
+                                                         },
+                                                         :body => {:terminal => "Pensio Test Terminal",
+                                                                   :shop_orderid => "Test Payment",
+                                                                   :amount => 123.45,
+                                                                   :currency => "eur"},
+                                                         :timeout => 10}).and_call_original
       expect(response).to be_an_instance_of(PensioAPI::Responses::GatewayURL)
     end
   end
 
   describe '.create_multi_payment_request' do
-    let(:response) { PensioAPI::Ecommerce.create_multi_payment_request(reservation_arguments) }
+    let(:response) {PensioAPI::Ecommerce.create_multi_payment_request(reservation_arguments)}
     it 'returns an instance of PensioAPI::Responses::GatewayURL' do
       expect(response).to be_an_instance_of(PensioAPI::Responses::GatewayURL)
     end

data/spec/lib/pensio_api/errors/bad_request_spec.rb

@@ -25,7 +25,7 @@ describe PensioAPI::Errors::BadRequest do
     end
 
     describe '.error_code' do
-      specify { expect(error.error_code).to be_an_instance_of(Fixnum) }
+      specify { expect(error.error_code).to be_an_instance_of(Integer) }
     end
   end
 end

data/spec/lib/pensio_api/errors/gateway_error_spec.rb

@@ -31,7 +31,7 @@ describe PensioAPI::Errors::GatewayError do
 
   describe 'object mapping' do
     it 'maps transactions to transaction objects' do
-      expect(error.transactions.all? { |r| r.class == PensioAPI::Transaction }).to be_true
+      expect(error.transactions.all? { |r| r.class == PensioAPI::Transaction }).to be true
     end
   end
 end

data/spec/lib/pensio_api/request_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe PensioAPI::Request do
   describe '.new' do
     before :each do
-      PensioAPI::Request.stub(:post).and_return(construct_response(nil))
+      allow(PensioAPI::Request).to receive(:post).and_return(construct_response(nil))
     end
 
     it 'POSTs to the given API path and passes in request options' do
       request_options = PensioAPI::Request.new('/test').send(:request_options, {})
-      PensioAPI::Request.should_receive(:post).with('/test', request_options)
+      expect(PensioAPI::Request).to receive(:post).with('/test', request_options)
       PensioAPI::Request.new('/test')
     end
   end
@@ -16,10 +16,10 @@ describe PensioAPI::Request do
   describe '.response_contains' do
     context 'with a populated response body' do
       before :each do
-        PensioAPI::Request.stub(:post).and_return(
+        allow(PensioAPI::Request).to receive(:post).and_return(
           construct_response({
-            'Test' => 'true'
-          })
+              'Test' => 'true'
+            })
         )
       end
 
@@ -27,33 +27,33 @@ describe PensioAPI::Request do
 
       context 'given a valid key' do
         it 'returns true' do
-          expect(request.response_contains?('Test')).to be_true
+          expect(request.response_contains?('Test')).to be true
         end
       end
 
       context 'given an invalid key' do
         it 'returns false' do
-          expect(request.response_contains?('OtherTest')).to be_false
+          expect(request.response_contains?('OtherTest')).to be false
         end
       end
     end
 
     context 'with an empty response body' do
       before :each do
-        PensioAPI::Request.stub(:post).and_return(construct_response(nil))
+        allow(PensioAPI::Request).to receive(:post).and_return(construct_response(nil))
       end
 
       let(:request) { PensioAPI::Request.new('/test') }
 
       it 'returns false' do
-        expect(request.response_contains?('Test')).to be_false
+        expect(request.response_contains?('Test')).to be false
       end
     end
   end
 
   describe '.request_options' do
     before :each do
-      PensioAPI::Request.stub(:post).and_return(construct_response(nil))
+      allow(PensioAPI::Request).to receive(:post).and_return(construct_response(nil))
     end
 
     let(:p) { PensioAPI::Request.new('/test') }
@@ -82,6 +82,27 @@ describe PensioAPI::Request do
         expect(p.send(:request_options, {transaction_id: 5432})[:body][:transaction_id]).to eq(5432)
       end
     end
+    
+    context 'with alternative credentials' do
+      it 'sends the correct credentials' do
+        creds = PensioAPI::Credentials.for(:ticketing)
+        creds.base_uri = 'https://www.test.com'
+        creds.username = 'ticketing_username'
+        creds.password = 'ticketing_password'
+        
+        # pass credentials instance
+        req1 = PensioAPI::Request.new('/test', credentials: creds) 
+        
+        # or pass credentials set name
+        req2 = PensioAPI::Request.new('/test', credentials: :ticketing)
+        
+        expect(req1.send(:request_options, {})[:basic_auth]).to_not be_nil
+        expect(req1.send(:request_options, {})[:basic_auth]).to eq({ username: creds.username, password: creds.password})
+        
+        expect(req2.send(:request_options, {})[:basic_auth]).to_not be_nil
+        expect(req2.send(:request_options, {})[:basic_auth]).to eq({ username: creds.username, password: creds.password})
+      end
+    end
   end
 
   describe 'error handling' do
@@ -107,11 +128,7 @@ describe PensioAPI::Request do
 
     context 'with incomplete credentials' do
       before :each do
-        PensioAPI::Credentials = OpenStruct.new({
-          base_uri: nil,
-          username: nil,
-          password: nil
-        })
+        PensioAPI::Credentials.base_uri = nil
       end
 
       it 'raises a PensioAPI::Errors::NoCredentials error' do

data/spec/lib/pensio_api/responses/base_spec.rb

@@ -40,7 +40,7 @@ describe PensioAPI::Responses::Base do
     context 'with a successful response' do
       context 'with success specified in the response body' do
         it 'returns true' do
-          expect(response_object.success?).to be_true
+          expect(response_object.success?).to be true
         end
       end
 
@@ -60,7 +60,7 @@ describe PensioAPI::Responses::Base do
         let(:response_object) { PensioAPI::Responses::Base.new(test_data) }
 
         it 'returns true' do
-          expect(response_object.success?).to be_true
+          expect(response_object.success?).to be true
         end
       end
     end

data/spec/lib/pensio_api/responses/chargeback_callback_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::ChargebackCallback do
+  let(:response) { PensioAPI::Callback.parse_chargeback(file_fixture("chargeback_callback.xml")) }
+
+  it "succeeds" do
+    expect(response.success?).to be true
+  end
+end

data/spec/lib/pensio_api/responses/funding_list_spec.rb

@@ -16,7 +16,7 @@ describe PensioAPI::Responses::FundingList do
 
     describe '.page_count' do
       it 'returns a number of pages' do
-        expect(funding_list.page_count).to be_an_instance_of(Fixnum)
+        expect(funding_list.page_count).to be_an_instance_of(Integer)
       end
     end
   end