pensio_api 0.2.1 → 0.2.2

data/spec/lib/pensio_api/request_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe PensioAPI::Request do
+  describe '.new' do
+    before :each do
+      PensioAPI::Request.stub(: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)
+      PensioAPI::Request.new('/test')
+    end
+  end
+
+  describe '.response_contains' do
+    context 'with a populated response body' do
+      before :each do
+        PensioAPI::Request.stub(:post).and_return(
+          construct_response({
+            'Test' => 'true'
+          })
+        )
+      end
+
+      let(:request) { PensioAPI::Request.new('/test') }
+
+      context 'given a valid key' do
+        it 'returns true' do
+          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
+        end
+      end
+    end
+
+    context 'with an empty response body' do
+      before :each do
+        PensioAPI::Request.stub(: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
+      end
+    end
+  end
+
+  describe '.request_options' do
+    before :each do
+      PensioAPI::Request.stub(:post).and_return(construct_response(nil))
+    end
+
+    let(:p) { PensioAPI::Request.new('/test') }
+
+    specify { expect(p.send(:request_options, {})[:basic_auth]).to_not be_nil }
+
+    it 'appends basic auth to the options' do
+      expect(p.send(:request_options, {})[:basic_auth]).to eq(p.send(:auth))
+    end
+
+    specify { expect(p.send(:request_options, {})[:headers]).to_not be_nil }
+
+    it 'appends headers to the options' do
+      expect(p.send(:request_options, {})[:headers]).to eq(PensioAPI::Request::HEADERS)
+    end
+
+    context 'with additional headers' do
+      it 'merges given headers into the defaults' do
+        headers = p.send(:request_options, { headers: {'Test' => '1234'} })[:headers]
+        expect(headers).to eq({'Test' => '1234'}.merge(PensioAPI::Request::HEADERS))
+      end
+    end
+
+    context 'with body parameters' do
+      it 'assigns these to the body parameter' do
+        expect(p.send(:request_options, {transaction_id: 5432})[:body][:transaction_id]).to eq(5432)
+      end
+    end
+  end
+
+  describe 'error handling' do
+    context 'with a bad request' do
+      before :each do
+        stub_pensio_response('/merchant/API/payments', 'bad_request_error')
+      end
+
+      it 'raises a PensioAPI::Errors::BadRequest error' do
+        expect(->{ PensioAPI::Transaction.find }).to raise_error(PensioAPI::Errors::BadRequest)
+      end
+    end
+
+    context 'with a gateway error' do
+      before :each do
+        stub_pensio_response('/merchant/API/payments', 'pensio_error')
+      end
+
+      it 'raises a PensioAPI::Errors::GatewayError' do
+        expect(->{ PensioAPI::Transaction.find }).to raise_error(PensioAPI::Errors::GatewayError)
+      end
+    end
+
+    context 'with incomplete credentials' do
+      before :each do
+        PensioAPI::Credentials = OpenStruct.new({
+          base_uri: nil,
+          username: nil,
+          password: nil
+        })
+      end
+
+      it 'raises a PensioAPI::Errors::NoCredentials error' do
+        expect(->{ PensioAPI::Transaction.find }).to raise_error(PensioAPI::Errors::NoCredentials)
+      end
+    end
+  end
+end

data/spec/lib/pensio_api/reservation_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe PensioAPI::Reservation do
+  before :each do
+    stub_pensio_response('/merchant/API/payments', 'payments')
+    stub_pensio_response('/merchant/API/captureReservation', 'capture_reservation')
+    stub_pensio_response('/merchant/API/releaseReservation', 'release_reservation')
+    stub_pensio_response('/merchant/API/reservationOfFixedAmount', 'reservation_of_fixed_amount')
+  end
+
+  let(:transaction) { PensioAPI::Transaction.find.first }
+
+  describe '.capture' do
+    let(:response) { transaction.to_reservation.capture }
+
+    specify { expect(response).to be_an_instance_of(PensioAPI::Responses::ReservationCapture) }
+  end
+
+  describe '.release' do
+    let(:response) { transaction.to_reservation.release }
+
+    specify { expect(response).to be_an_instance_of(PensioAPI::Responses::ReservationRelease) }
+  end
+
+  describe '.of_fixed_amount' do
+    let(:response) do
+      PensioAPI::Reservation.of_fixed_amount(reservation_arguments)
+    end
+
+    specify { expect(response).to be_an_instance_of(PensioAPI::Responses::Reservation) }
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::Base do
+  let(:test_data) do
+    OpenStruct.new({
+      body: {
+        "Result" => "Success",
+        "TransactionId" => 1234,
+        "Amount" => 543.21
+      },
+      headers: {
+        "ErrorMessage" => nil,
+        "ErrorCode" => "0"
+      }
+    })
+  end
+
+  let(:response_object) { PensioAPI::Responses::Base.new(test_data) }
+  let(:transaction) { PensioAPI::Transaction.new(test_data) }
+
+  describe '.raw' do
+    it 'provides a reader for the response object' do
+      expect(response_object.raw).to eq(test_data.body)
+    end
+  end
+
+  describe 'method calls' do
+    it 'makes the individual response attributes available' do
+      expect(response_object.amount).to eq(test_data.body['Amount'])
+    end
+
+    context 'with a snake_case method name' do
+      it 'converts to CamelCase' do
+        expect(response_object.transaction_id).to eq(1234)
+      end
+    end
+  end
+
+  describe '.success?' 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
+        end
+      end
+
+      context 'with success unspecified in the response body' do
+        let(:test_data) do
+          OpenStruct.new({
+            body: {
+              "TransactionId" => 1234,
+              "Amount" => 543.21
+            },
+            headers: {
+              "ErrorMessage" => nil,
+              "ErrorCode" => "0"
+            }
+          })
+        end
+        let(:response_object) { PensioAPI::Responses::Base.new(test_data) }
+
+        it 'returns true' do
+          expect(response_object.success?).to be_true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::FundingList do
+  let(:funding_list) { PensioAPI::FundingList.all }
+
+  before :each do
+    stub_pensio_response('/merchant/API/fundingList', 'funding_list')
+  end
+
+  describe 'reader attributes' do
+    describe '.funding_lists' do
+      it 'is an array of PensioAPI::FundingList objects' do
+        expect(funding_list.funding_lists.map(&:class).uniq).to eq([PensioAPI::FundingList])
+      end
+    end
+
+    describe '.page_count' do
+      it 'returns a number of pages' do
+        expect(funding_list.page_count).to be_an_instance_of(Fixnum)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::GatewayURL do
+  before :each do
+    stub_pensio_response('/merchant/API/createPaymentRequest', 'create_payment_request')
+  end
+
+  let (:gateway_url_response) { PensioAPI::Ecommerce.create_payment_request(reservation_arguments) }
+
+  describe 'getter attributes' do
+    describe '.url' do
+      it 'exposes the URL' do
+        expect(gateway_url_response.url).to eq(gateway_url_response.raw['Url'])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::Refund do
+  before :each do
+    stub_pensio_response('/merchant/API/payments', 'payments')
+    stub_pensio_response('/merchant/API/refundCapturedReservation', 'refund_captured_reservation')
+  end
+
+  let(:response) { PensioAPI::Transaction.find.first.refund }
+
+  specify { expect(response).to be_an_instance_of(PensioAPI::Responses::Refund) }
+
+  describe 'readable attributes' do
+    specify { expect(response.transaction).to be_an_instance_of(PensioAPI::Transaction) }
+    specify { expect(response.refund_amount).to eq(BigDecimal.new('0.12')) }
+    specify { expect(response.refund_currency).to eq(978) }
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::ReservationCapture do
+  before :each do
+    stub_pensio_response('/merchant/API/payments', 'payments')
+    stub_pensio_response('/merchant/API/captureReservation', 'capture_reservation')
+  end
+
+  let(:response) { PensioAPI::Transaction.find.first.to_reservation.capture }
+
+  specify { expect(response).to be_an_instance_of(PensioAPI::Responses::ReservationCapture) }
+
+  describe 'readable attributes' do
+    specify { expect(response.transaction).to be_an_instance_of(PensioAPI::Transaction) }
+    specify { expect(response.capture_amount).to eq(BigDecimal.new('0.20')) }
+    specify { expect(response.capture_currency).to eq(978) }
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::ReservationRelease do
+  before :each do
+    stub_pensio_response('/merchant/API/payments', 'payments')
+    stub_pensio_response('/merchant/API/releaseReservation', 'release_reservation')
+  end
+
+  let(:response) { PensioAPI::Transaction.find.first.to_reservation.release }
+
+  specify { expect(response).to be_an_instance_of(PensioAPI::Responses::ReservationRelease) }
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::Reservation do
+  before :each do
+    stub_pensio_response('/merchant/API/reservationOfFixedAmount', 'reservation_of_fixed_amount')
+  end
+
+  let(:response) { PensioAPI::Reservation.of_fixed_amount(reservation_arguments) }
+
+  specify { expect(response).to be_an_instance_of(PensioAPI::Responses::Reservation) }
+
+  describe 'readable attributes' do
+    specify { expect(response.transaction).to be_an_instance_of(PensioAPI::Transaction) }
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::SubscriptionCharge do
+  before :each do
+    stub_pensio_response('/merchant/API/payments', 'payments')
+    stub_pensio_response('/merchant/API/chargeSubscription', 'charge_subscription')
+    stub_pensio_response('/merchant/API/reserveSubscriptionCharge', 'reserve_subscription_charge')
+  end
+
+  let(:response) { PensioAPI::Transaction.find.first.to_subscription.charge }
+  let(:uncharged_response) { PensioAPI::Transaction.find.first.to_subscription.reserve_charge }
+
+  specify { expect(response).to be_an_instance_of(PensioAPI::Responses::SubscriptionCharge) }
+
+  describe '.existing' do
+    specify { expect(response.existing).to be_an_instance_of(PensioAPI::Transaction) }
+  end
+
+  describe '.new' do
+    specify { expect(response.new).to be_an_instance_of(PensioAPI::Transaction) }
+  end
+
+  describe '.each' do
+    let(:enumerator) { response.to_enum }
+
+    specify { expect(enumerator.count).to eq(2) }
+
+    it 'yields the existing transaction first' do
+      expect(enumerator.next).to eq(response.existing)
+    end
+
+    it 'yields the new transaction second' do
+      enumerator.next
+      expect(enumerator.next).to eq(response.new)
+    end
+  end
+
+  describe '.captured?' do
+    it 'delegates .captured? to the new transaction' do
+      response.new.should_receive(:captured?)
+      response.captured?
+    end
+
+    context 'with a reserved charge' do
+      it 'returns false' do
+        expect(uncharged_response).to_not be_captured
+      end
+    end
+
+    context 'with a captured charge' do
+      it 'returns true' do
+        expect(response).to be_captured
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::SubscriptionFailureCallback do
+
+  let(:response) { PensioAPI::Callback.parse_failure(file_fixture("subscription_failure_callback.xml")) }
+
+  it "succeeds" do
+    expect(response.success?).to be_true
+  end
+  
+  describe ".reservation" do
+    it "gets a reservation transaction" do
+      expect(response.reservation).to be_an_instance_of(PensioAPI::Transaction)
+    end
+    it "is not reserved" do
+      expect(response.reservation).to_not be_reserved
+    end
+    it "attempted to reserve a non-zero amount" do
+      expect(response.reservation.reserved_amount).to be > 0.0
+    end
+    it "does not capture any amount" do
+      expect(response.reservation.captured_amount).to eq 0.0
+    end
+    it "receives the submitted billing address" do
+      expect(response.reservation.billing_address).to be_an_instance_of PensioAPI::BillingAddress
+    end
+  end
+  
+  describe ".charge" do
+    it "gets a charge transaction" do
+      expect(response.charge).to be_an_instance_of(PensioAPI::Transaction)
+    end
+    it "is not captured" do
+      expect(response.reservation).to_not be_captured
+    end
+    it "does not reserve any amount" do
+      expect(response.charge.reserved_amount).to eq 0.0
+    end
+    it "does not capture any amount" do
+      expect(response.charge.captured_amount).to eq 0.0
+    end
+    it "receives the submitted billing address" do
+      expect(response.charge.billing_address).to be_an_instance_of PensioAPI::BillingAddress
+    end
+  end
+  
+end
+

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::SuccessCallback do
+
+  let(:response) { PensioAPI::Callback.parse_success(file_fixture("success_callback.xml")) }
+
+  it "succeeds" do
+    expect(response.success?).to be_true
+  end
+  
+  describe ".reservation" do
+    it "gets a reservation transaction" do
+      expect(response.reservation).to be_an_instance_of(PensioAPI::Transaction)
+    end
+    it "is reserved" do
+      expect(response.reservation).to be_reserved
+    end
+    it "reserves a non-zero amount" do
+      expect(response.reservation.reserved_amount).to be > 0.0
+    end
+    it "does not capture any amount" do
+      expect(response.reservation.captured_amount).to eq 0.0
+    end
+  end
+  
+  describe ".charge" do
+    it "gets a charge transaction" do
+      expect(response.charge).to be_an_instance_of(PensioAPI::Transaction)
+    end
+    it "is captured" do
+      expect(response.charge).to be_captured
+    end
+    it "reserves a non-zero amount" do
+      expect(response.charge.reserved_amount).to be > 0.0
+    end
+    it "captures a non-zero amount" do
+      expect(response.charge.captured_amount).to be > 0.0
+    end
+    it "captures the same amount as was reserved" do
+      expect(response.charge.reserved_amount).to eq(response.charge.captured_amount)
+    end
+  end
+  
+end
+

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::Terminal do
+  before :each do
+    stub_pensio_response('/merchant/API/getTerminals', 'get_terminals')
+  end
+
+  let(:response) { PensioAPI::Terminal.all }
+
+  describe 'object mapping' do
+    it 'maps terminals to terminal objects' do
+      expect(response.terminals.all? { |r| r.class == PensioAPI::Terminal }).to be_true
+    end
+
+    specify { expect(response.terminals.length).to eq(2) }
+
+    describe '.map_terminals' do
+      context 'with one terminal' do
+        before :each do
+          stub_pensio_response('/merchant/API/getTerminals', 'get_terminals_single')
+        end
+
+        let(:response) { PensioAPI::Terminal.all }
+
+        specify { expect(response.terminals.length).to eq(1) }
+        specify { expect(response.terminals.map(&:class)).to eq([PensioAPI::Terminal]) }
+
+        it 'returns the terminal inside an array' do
+          expect(response.terminals).to be_an_instance_of(Array)
+        end
+      end
+
+      context 'with more than one terminal' do
+        specify { expect(response.terminals.length).to eq(2) }
+        specify { expect(response.terminals.map(&:class).uniq).to eq([PensioAPI::Terminal]) }
+
+        it 'returns an array' do
+          expect(response.terminals).to be_an_instance_of(Array)
+        end
+      end
+    end
+  end
+
+  context 'with no terminals' do
+    before :each do
+      stub_pensio_response('/merchant/API/getTerminals', 'get_terminals_none')
+    end
+
+    describe '.transactions' do
+      it 'returns an empty array' do
+        expect(response.terminals).to eq([])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe PensioAPI::Responses::Transaction do
+  before :each do
+    stub_pensio_response('/merchant/API/payments', 'payments')
+  end
+
+  let(:response) { PensioAPI::Transaction.find }
+
+  describe 'object mapping' do
+    it 'maps transactions to transaction objects' do
+      expect(response.transactions.all? { |r| r.class == PensioAPI::Transaction }).to be_true
+    end
+
+    specify { expect(response.transactions.length).to eq(1) }
+
+    describe '.map_transactions' do
+      context 'with one transaction' do
+
+        specify { expect(response.transactions.length).to eq(1) }
+        specify { expect(response.transactions.map(&:class)).to eq([PensioAPI::Transaction]) }
+
+        it 'returns the transaction inside an array' do
+          expect(response.transactions).to be_an_instance_of(Array)
+        end
+      end
+
+      context 'with more than one transaction' do
+        before :each do
+          stub_pensio_response('/merchant/API/payments', 'multiple_payments')
+        end
+
+        let(:response) { PensioAPI::Transaction.find }
+
+        specify { expect(response.transactions.length).to eq(2) }
+        specify { expect(response.transactions.map(&:class).uniq).to eq([PensioAPI::Transaction]) }
+
+        it 'returns an array' do
+          expect(response.transactions).to be_an_instance_of(Array)
+        end
+      end
+    end
+  end
+
+  context 'with no payments' do
+    before :each do
+      stub_pensio_response('/merchant/API/payments', 'payments_none')
+    end
+
+    describe '.transactions' do
+      it 'returns an empty array' do
+        expect(response.transactions).to eq([])
+      end
+    end
+  end
+end

data/spec/lib/pensio_api/subscription_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe PensioAPI::Subscription do
+  before :each do
+    stub_pensio_response('/merchant/API/payments', 'payments')
+    stub_pensio_response('/merchant/API/setupSubscription', 'setup_subscription')
+    stub_pensio_response('/merchant/API/chargeSubscription', 'charge_subscription')
+    stub_pensio_response('/merchant/API/reserveSubscriptionCharge', 'reserve_subscription_charge')
+  end
+
+  # Immediate evaluation ensures that expectations receive the right arguments
+  let!(:subscription) { PensioAPI::Transaction.find.first.to_subscription }
+
+  describe '.setup' do
+    it 'returns an instance of PensioAPI::Transaction' do
+      expect(PensioAPI::Subscription.setup(credit_card_token: '1234')).to be_an_instance_of(PensioAPI::Transaction)
+    end
+  end
+
+  describe '.charge' do
+    it 'returns an instance of PensioAPI::Responses::SubscriptionCharge' do
+      expect(subscription.charge).to be_an_instance_of(PensioAPI::Responses::SubscriptionCharge)
+    end
+  end
+
+  describe '.reserve_charge' do
+    it 'returns an instance of PensioAPI::Responses::SubscriptionCharge' do
+      expect(subscription.reserve_charge).to be_an_instance_of(PensioAPI::Responses::SubscriptionCharge)
+    end
+  end
+
+  describe 'subscription_options' do
+    it 'wraps transaction_id' do
+      expect(subscription.send(:subscription_options)[:transaction_id]).to eq('1')
+    end
+  end
+end

data/spec/lib/pensio_api/terminal_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe PensioAPI::Terminal do
+  before :each do
+    stub_pensio_response('/merchant/API/getTerminals', 'get_terminals')
+  end
+
+  describe '.all' do
+    let(:response) { PensioAPI::Terminal.all }
+
+    specify { expect(response.terminals.length).to eq(2) }
+
+    it 'maps the response to terminal objects' do
+      terminal_classes = response.terminals.map(&:class).uniq
+      expect(terminal_classes).to eq([PensioAPI::Terminal])
+    end
+  end
+end