fat_zebra_multi 3.1.0.1

data/spec/lib/fat_zebra/direct_debit_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe FatZebra::DirectDebit do
+
+  let(:valid_direct_debit_payload) {{
+    description:    'Confirmation',
+    amount:         42.0,
+    bsb:            '123-123',
+    account_name:   'Test',
+    account_number: '012345678'
+  }}
+
+  describe '.create', :vcr do
+    subject(:direct_debit) { FatZebra::DirectDebit.create(valid_direct_debit_payload) }
+
+    it { is_expected.to be_accepted }
+    it { expect(direct_debit.bsb).to eq(valid_direct_debit_payload[:bsb]) }
+    it { expect(direct_debit.reference).to_not be_empty }
+    it { expect(direct_debit.id).to_not be_empty }
+
+    context 'validations' do
+      context 'valid' do
+        before { valid_direct_debit_payload[:amount] = 42.42 }
+
+        it { is_expected.to be_accepted }
+      end
+
+      context 'failed' do
+        let(:valid_direct_debit_payload) {{}}
+
+        it { expect{ direct_debit }.to raise_error(FatZebra::RequestValidationError) }
+      end
+
+      context 'failed with non-float' do
+        let(:valid_direct_debit_payload) {{
+          description:    'Confirmation',
+          amount:         123,
+          bsb:            '123-123',
+          account_name:   'Test',
+          account_number: '012345678'
+        }}
+
+        it { expect{ direct_debit }.to raise_error(FatZebra::RequestValidationError) }
+      end
+    end
+  end
+
+  describe '.find', :vcr do
+    let!(:create) { FatZebra::DirectDebit.create(valid_direct_debit_payload) }
+    subject(:direct_debit) { FatZebra::DirectDebit.find(create.reference) }
+
+    it { is_expected.to be_accepted }
+    it { expect(direct_debit.reference).to eq(create.reference) }
+    it { expect(direct_debit.amount).to be_instance_of(Float) }
+  end
+
+  describe '.search', :vcr do
+    let!(:start) { Time.now }
+    subject(:direct_debits) { FatZebra::DirectDebit.search }
+
+    before { 2.times { |i| FatZebra::DirectDebit.create(valid_direct_debit_payload) } }
+
+    it { is_expected.to be_accepted }
+    it { expect(direct_debits.data.count).to be >= 2 }
+  end
+
+  describe '.delete', :vcr do
+    let(:create) { FatZebra::DirectDebit.create(valid_direct_debit_payload) }
+    subject(:direct_debit) { FatZebra::DirectDebit.delete(create.id) }
+
+    it { is_expected.to be_accepted }
+  end
+
+end

data/spec/lib/fat_zebra/fat_zebra_object_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe FatZebra::FatZebraObject do
+
+  let(:klass) { Class.new(FatZebra::FatZebraObject) }
+  subject(:instance) { klass.new(id: 42, name: 'test', test: true) }
+
+  let(:api_response) {{
+    'successful' => true,
+    'response' => {
+      successful: true,
+      id: 84,
+      other: 'other test'
+    }
+  }}
+
+  let(:api_responses) {{
+    'successful' => true,
+    'response' => [{
+      id: 84,
+      other: 'other test'
+    }]
+  }}
+
+  describe 'add attribute accessors' do
+    it { expect(instance.id).to eq(42) }
+    it { expect(instance.name).to eq('test') }
+    it { expect(instance.test).to be_truthy }
+    it { expect(instance.test?).to be_truthy }
+  end
+
+  describe 'add array attribute' do
+    it { expect(instance[:id]).to eq(42) }
+    it { expect(instance[:name]).to eq('test') }
+    it { expect(instance[:test]).to be_truthy }
+  end
+
+  describe 'set array attribute' do
+    before { instance[:id] = 84 }
+
+    it { expect(instance.id).to eq(84) }
+    it { expect(instance[:id]).to eq(84) }
+  end
+
+  describe 'method missing' do
+    before { instance.card = '42' }
+
+    it { expect(instance.card).to eq('42') }
+    it { expect { instance.other }.to raise_error(NameError) }
+  end
+
+  describe '#keys' do
+    it { expect(instance.keys).to match_array([:id, :name, :test]) }
+  end
+
+  describe '#to_hash' do
+    it { expect(instance.to_hash).to eq(id: 42, name: 'test', test: true) }
+  end
+
+  describe '#to_json' do
+    it { expect(instance.to_json).to eq(JSON.generate(id: 42, name: 'test', test: true)) }
+  end
+
+  describe '#load_response_api' do
+    let(:response) {{
+      'successful' => true,
+      'errors' => []
+    }}
+
+    before { instance.load_response_api(response) }
+
+    it { expect(instance.accepted).to be_truthy }
+    it { expect(instance.errors).to eq([]) }
+  end
+
+  describe '#add_data' do
+    before { instance.add_data(:test) }
+
+    it { expect(instance.data).to match_array([:test]) }
+  end
+
+  describe '#update_attributes' do
+    before { instance.update_attributes(id: 84, other: 'other test') }
+
+    it { expect(instance.id).to eq(84) }
+    it { expect(instance.other).to eq('other test') }
+    it { expect(instance.name).to eq('test') }
+  end
+
+  describe '.initialize_from' do
+    context 'with single object' do
+      subject(:instance) { klass.initialize_from(api_response) }
+
+      it { is_expected.to be_successful }
+      it { expect(instance.id).to eq(84) }
+      it { expect(instance.other).to eq('other test') }
+      it { expect { instance.name }.to raise_error(NameError) }
+    end
+
+    context 'with array' do
+      subject(:instance) { klass.initialize_from(api_responses) }
+
+      it { is_expected.to be_accepted }
+      it { expect(instance.data.size).to eq(1) }
+    end
+  end
+
+  describe '#update_from' do
+    before { instance.update_from(api_response) }
+
+    it { is_expected.to be_successful }
+    it { expect(instance.id).to eq(84) }
+    it { expect(instance.other).to eq('other test') }
+    it { expect { instance.name }.to raise_error(NameError) }
+  end
+
+end

data/spec/lib/fat_zebra/information_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe FatZebra::Information do
+
+  describe '.ping', :vcr do
+    let(:nonce) { '262ca5679c2dd86ac866200a7b57fab0' }
+    subject(:ping) { FatZebra::Information.ping(nonce) }
+
+    it { expect(ping.timestamp.to_s).to_not be_empty }
+    it { expect(ping.echo).to eq(nonce) }
+  end
+
+end

data/spec/lib/fat_zebra/multiple_accounts_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe 'Multiple accounts', :vcr, :no_default_account do
+
+  describe 'The basics' do
+    it { expect(FatZebra.configurations).to be_nil }
+
+    let(:purchase_0) { FatZebra::Purchase.create valid_purchase_payload }
+
+    it { expect { purchase_0 }.to raise_error(FatZebra::ConfigurationError, 'No account specified') }
+
+    let(:account_1) {
+      FatZebra::Config.new(
+        username:  'TEST_USERNAME_1',
+        token:     'TEST_TOKEN_1',
+        gateway:   :sandbox,
+        test_mode: true
+      )
+    }
+    let(:account_2) {
+      FatZebra::Config.new(
+        username:  'TEST_USERNAME_2',
+        token:     'TEST_TOKEN_2',
+        gateway:   :sandbox,
+        test_mode: true
+      )
+    }
+
+    it { expect(account_1.valid!).to be_truthy }
+    it { expect(account_2.valid!).to be_truthy }
+
+    let(:purchase_1) { FatZebra::Purchase.create valid_purchase_payload, account: account_1 }
+
+    let(:purchase_2) { FatZebra::Purchase.create valid_purchase_payload, account: account_2 }
+
+    it {
+      expect(purchase_1.accepted?).to be_truthy
+      expect(purchase_1.id).to eq('071-P-ACCOUNT-1')
+    }
+
+    it {
+      expect(purchase_2.accepted?).to be_truthy
+      expect(purchase_2.id).to eq('071-P-ACCOUNT-2')
+    }
+  end
+
+  describe 'Conflicting accounts' do
+    it {
+      expect(FatZebra.configurations).to be_nil
+
+      FatZebra.configure do |config|
+        config.username  = 'TEST_USERNAME_1'
+        config.token     = 'TEST_TOKEN_1'
+        config.gateway   = :sandbox
+        config.test_mode = true
+      end
+
+      account = FatZebra::Config.new(
+        username:  'TEST_USERNAME_2',
+        token:     'TEST_TOKEN_2',
+        gateway:   :sandbox,
+        test_mode: true
+      )
+
+      expect { FatZebra::Purchase.create valid_purchase_payload, account: account }.to raise_error(FatZebra::ConfigurationError, 'Ambiguous accounts specified')
+    }
+  end
+
+end

data/spec/lib/fat_zebra/payment_plan_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe FatZebra::PaymentPlan do
+  let(:customer) { FatZebra::Customer.create(customer_valid_payload) }
+
+  let(:payment_plan_valid_payload) {{
+    payment_method: 'Credit Card',
+    customer:       customer.id,
+    reference:      SecureRandom.hex,
+    setup_fee:      0,
+    amount:         100,
+    start_date:     (Date.today + 90).strftime('%Y-%m-%d'),
+    frequency:      'Weekly',
+    anniversary:    5,
+    total_count:    5,
+    total_amount:   500
+  }}
+
+  describe '.create', :vcr do
+    subject(:payment_plan) { FatZebra::PaymentPlan.create(payment_plan_valid_payload) }
+
+    it { is_expected.to be_accepted }
+    it { expect(payment_plan.id).to_not be_empty }
+    it { expect(payment_plan.payments.count).to eq(5) }
+
+    context 'validations' do
+      let(:payment_plan_valid_payload) {{}}
+
+      it { expect { payment_plan }.to raise_error(FatZebra::RequestValidationError) }
+    end
+  end
+
+  describe '.find', :vcr do
+    let!(:create) { FatZebra::PaymentPlan.create(payment_plan_valid_payload) }
+    subject(:payment_plan) { FatZebra::PaymentPlan.find(create.reference) }
+
+    it { is_expected.to be_accepted }
+    it { expect(payment_plan.reference).to eq(create.reference) }
+    it { expect(payment_plan).to be_a(FatZebra::PaymentPlan) }
+  end
+
+  describe '.update', :vcr do
+    let(:create) { FatZebra::PaymentPlan.create(payment_plan_valid_payload) }
+
+    subject(:payment_plan) { FatZebra::PaymentPlan.update(create.id, new_status: 'Suspended') }
+
+    it { is_expected.to be_accepted }
+    it { expect(payment_plan.status).to eq('Suspended') }
+    it { expect(payment_plan).to be_a(FatZebra::PaymentPlan) }
+  end
+
+  context '#update', :vcr do
+    let(:payment_plan) { FatZebra::PaymentPlan.new(payment_plan_valid_payload) }
+    before { payment_plan.save }
+    before { payment_plan.update(new_status: 'Suspended') }
+
+    it { expect(payment_plan.status).to eq('Suspended') }
+    it { expect(payment_plan).to be_a(FatZebra::PaymentPlan) }
+  end
+
+  describe '.delete', :vcr do
+    let(:create) { FatZebra::PaymentPlan.create(payment_plan_valid_payload) }
+    subject(:payment_plan) { FatZebra::PaymentPlan.delete(create.id) }
+
+    it { is_expected.to be_accepted }
+  end
+
+  describe '#destroy', :vcr do
+    let(:payment_plan) { FatZebra::PaymentPlan.create(payment_plan_valid_payload) }
+    before { payment_plan.destroy }
+
+    it { expect(payment_plan.status).to eq('Cancelled') }
+  end
+
+  describe '#suspend!', :vcr  do
+    let(:payment_plan) { FatZebra::PaymentPlan.new(payment_plan_valid_payload) }
+    before { payment_plan.save }
+    before { payment_plan.suspend! }
+
+    it { expect(payment_plan.status).to eq('Suspended') }
+    it { expect(payment_plan).to be_a(FatZebra::PaymentPlan) }
+  end
+
+  describe '#active!', :vcr  do
+    let(:payment_plan) { FatZebra::PaymentPlan.new(payment_plan_valid_payload) }
+    before { payment_plan.save }
+    before { expect(payment_plan.suspend!.status).to eq('Suspended') }
+    before { payment_plan.active! }
+
+    it { expect(payment_plan.status).to eq('Active') }
+    it { expect(payment_plan).to be_a(FatZebra::PaymentPlan) }
+  end
+
+end

data/spec/lib/fat_zebra/purchase_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe FatZebra::Purchase do
+
+  describe '.create', :vcr do
+    subject(:purchase) { FatZebra::Purchase.create(valid_purchase_payload) }
+
+    it { is_expected.to be_accepted }
+    it { is_expected.to be_successful }
+    it { expect(purchase.card_holder).to eq(valid_purchase_payload[:card_holder]) }
+    it { expect(purchase.currency).to eq('AUD') }
+    it { expect(purchase.reference).to_not be_empty }
+    it { expect(purchase.transaction_id).to_not be_empty }
+    it { expect(purchase.decimal_amount).to eq(100) }
+    it { expect(purchase.card_type).to eq('MasterCard') }
+    it { expect(purchase.card_category).to eq('Credit') }
+    it { expect(purchase.card_token).to_not be_empty }
+    it { expect(purchase.addendum_data).to eq({}) }
+    it { expect(purchase.metadata).to eq({ "authorization_tracking_id" => "", "original_transaction_reference" => "" }) }
+    it { expect(purchase.response_code).to eq('00') }
+
+    context 'bad request' do
+      subject(:purchase) { FatZebra::Purchase.create(valid_purchase_payload.merge(currency: 'XXX' )) }
+
+      it { is_expected.to_not be_accepted }
+      it { is_expected.to_not be_successful }
+    end
+
+    context 'validations' do
+      let(:valid_purchase_payload) {{}}
+
+      it { expect{ purchase }.to raise_error(FatZebra::RequestValidationError) }
+    end
+  end
+
+  describe '.find', :vcr do
+    let!(:create) { FatZebra::Purchase.create(valid_purchase_payload) }
+    subject(:purchase) { FatZebra::Purchase.find(create.reference) }
+
+    it { is_expected.to be_accepted }
+    it { is_expected.to be_successful }
+    it { expect(purchase.reference).to eq(create.reference) }
+    it { expect(purchase.transaction_id).to eq(create.transaction_id) }
+  end
+
+  describe '.search', :vcr do
+    let!(:start) { Date.parse('2017-07-03') }
+    subject(:purchases) { FatZebra::Purchase.search(from: start) }
+
+    before { 2.times { |i| FatZebra::Purchase.create(valid_purchase_payload.merge(reference: "#{SecureRandom.hex}-#{i}")) } }
+
+    it { is_expected.to be_accepted }
+    it { expect(purchases.data.count).to be >= 2 }
+    it { expect(purchases.data.first).to be_a(FatZebra::Purchase) }
+  end
+
+  describe '#refund', :vcr do
+    let(:purchase) { FatZebra::Purchase.create(valid_purchase_payload) }
+    subject(:refund) { purchase.refund }
+
+    it { is_expected.to be_accepted }
+    it { is_expected.to be_successful }
+    it { expect(refund).to be_a(FatZebra::Refund) }
+  end
+
+  describe '#capture', :vcr do
+    let(:purchase) { FatZebra::Purchase.create(valid_purchase_payload.merge(capture: false)) }
+    subject(:capture) { purchase.capture }
+
+    it { is_expected.to be_accepted }
+    it { is_expected.to be_successful }
+    it { expect(capture).to be_a(FatZebra::Purchase) }
+  end
+
+  describe '.void', :vcr do
+    let(:purchase) { FatZebra::Purchase.create(valid_purchase_payload) }
+    subject(:void) { FatZebra::Purchase.void(purchase.id) }
+
+    it { is_expected.to be_accepted }
+    it { is_expected.to be_successful }
+    it { expect(void.message).to eq('Voided') }
+    it { expect(void).to be_a(FatZebra::Purchase) }
+  end
+
+  describe '#void', :vcr do
+    subject(:purchase) { FatZebra::Purchase.create(valid_purchase_payload) }
+    before { expect(purchase.void).to be_truthy }
+
+    it { is_expected.to be_accepted }
+    it { is_expected.to be_successful }
+    it { expect(purchase.message).to eq('Voided') }
+    it { expect(purchase).to be_a(FatZebra::Purchase) }
+  end
+
+  describe '.settlement', :vcr do
+    before { 2.times { |i| FatZebra::Purchase.create(valid_purchase_payload.merge(reference: "#{SecureRandom.hex}-#{i}")) } }
+
+    subject(:settlement) { FatZebra::Purchase.settlement(from: Date.parse('2017/06/22'), to: Date.parse('2017-06-27')) }
+
+    it { is_expected.to be_accepted }
+    it { expect(settlement.data.count).to be >= 2 }
+    it { expect(settlement.data.first).to be_a(FatZebra::Purchase) }
+  end
+
+end