fat_zebra 2.0.13 → 3.0.0

data/spec/lib/fat_zebra/customer_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe FatZebra::Customer do
+
+  describe '.create', :vcr do
+    subject(:customer) { FatZebra::Customer.create(customer_valid_payload) }
+
+    it { is_expected.to be_successful }
+    it { expect(customer.id).to_not be_empty }
+    it { expect(customer.first_name).to eq(customer_valid_payload[:first_name]) }
+    it { expect(customer.last_name).to eq(customer_valid_payload[:last_name]) }
+    it { expect(customer.card_token).to_not be_empty }
+    it { expect(customer.bank_account).to be_nil }
+
+    context 'validations' do
+      let(:customer_valid_payload) {{}}
+
+      it { expect{ customer }.to raise_error(FatZebra::RequestValidationError) }
+    end
+  end
+
+  describe '.search', :vcr do
+    subject(:purchases) { FatZebra::Customer.search }
+
+    it { is_expected.to be_successful }
+    it { expect(purchases.data.count).to be >= 2 }
+    it { expect(purchases.data.first).to be_a(FatZebra::Customer) }
+  end
+
+  describe '.find', :vcr do
+    let!(:create) { FatZebra::Customer.create(customer_valid_payload) }
+    subject(:customer) { FatZebra::Customer.find(create.reference) }
+
+    it { is_expected.to be_successful }
+    it { expect(customer.reference).to eq(create.reference) }
+  end
+
+  describe '.update', :vcr do
+    let(:create) { FatZebra::Customer.create(customer_valid_payload) }
+    subject(:customer) { FatZebra::Customer.update(create.id, first_name: 'New Name') }
+
+    it { is_expected.to be_successful }
+    it { expect(customer.first_name).to eq('New Name') }
+  end
+
+  describe '.delete', :vcr do
+    let(:create) { FatZebra::Customer.create(customer_valid_payload) }
+    subject(:customer) { FatZebra::Customer.delete(create.id) }
+
+    it { is_expected.to be_successful }
+  end
+
+end

data/spec/lib/fat_zebra/direct_credit_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe FatZebra::DirectCredit do
+
+  let(:valid_direct_credit_payload) {{
+    description:    'Confirmation',
+    amount:         42,
+    bsb:            '123-123',
+    account_name:   'Test',
+    account_number: '012345678'
+  }}
+
+  describe '.create', :vcr do
+    subject(:direct_credit) { FatZebra::DirectCredit.create(valid_direct_credit_payload) }
+
+    it { is_expected.to be_successful }
+    it { expect(direct_credit.bsb).to eq(valid_direct_credit_payload[:bsb]) }
+    it { expect(direct_credit.reference).to_not be_empty }
+    it { expect(direct_credit.id).to_not be_empty }
+
+    context 'validations' do
+      let(:valid_direct_credit_payload) {{}}
+
+      it { expect{ direct_credit }.to raise_error(FatZebra::RequestValidationError) }
+    end
+  end
+
+  describe '.find', :vcr do
+    let!(:create) { FatZebra::DirectCredit.create(valid_direct_credit_payload) }
+    subject(:direct_credit) { FatZebra::DirectCredit.find(create.reference) }
+
+    it { is_expected.to be_successful }
+    it { expect(direct_credit.reference).to eq(create.reference) }
+  end
+
+  describe '.search', :vcr do
+    let!(:start) { Time.now }
+    subject(:direct_credits) { FatZebra::DirectCredit.search }
+
+    before { 2.times { |i| FatZebra::DirectCredit.create(valid_direct_credit_payload) } }
+
+    it { is_expected.to be_successful }
+    it { expect(direct_credits.data.count).to be >= 2 }
+  end
+
+  describe '.delete', :vcr do
+    let(:create) { FatZebra::DirectCredit.create(valid_direct_credit_payload) }
+    subject(:direct_credit) { FatZebra::DirectCredit.delete(create.id) }
+
+    it { is_expected.to be_successful }
+  end
+
+end

data/spec/lib/fat_zebra/direct_debit_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe FatZebra::DirectDebit do
+
+  let(:valid_direct_debit_payload) {{
+    description:    'Confirmation',
+    amount:         42,
+    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_successful }
+    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
+      let(:valid_direct_debit_payload) {{}}
+
+      it { expect{ direct_debit }.to raise_error(FatZebra::RequestValidationError) }
+    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_successful }
+    it { expect(direct_debit.reference).to eq(create.reference) }
+  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_successful }
+    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_successful }
+  end
+
+end

data/spec/lib/fat_zebra/fat_zebra_object_spec.rb

@@ -0,0 +1,116 @@
+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' => {
+      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.successful).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_successful }
+      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/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:     '2015-07-16',
+    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_successful }
+    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_successful }
+    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_successful }
+    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_successful }
+  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,92 @@
+require 'spec_helper'
+
+describe FatZebra::Purchase do
+
+  describe '.create', :vcr do
+    subject(:purchase) { FatZebra::Purchase.create(valid_purchase_payload) }
+
+    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({}) }
+    it { expect(purchase.response_code).to eq('00') }
+
+    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_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) { Time.now }
+    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_successful }
+    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_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_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_not be_successful }
+    it { expect(void.message).to eq('Voided') }
+    it { expect(void).to be_a(FatZebra::Purchase) }
+  end
+
+  describe '#void', :vcr do
+    let(:purchase) { FatZebra::Purchase.create(valid_purchase_payload) }
+    before { expect(purchase.void).to be_truthy }
+
+    it { is_expected.to_not 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: Time.now - (86400 * 5), to: Time.now) }
+
+    it { is_expected.to be_successful }
+    it { expect(settlement.data.count).to be >= 2 }
+    it { expect(settlement.data.first).to be_a(FatZebra::Purchase) }
+  end
+
+end

data/spec/lib/fat_zebra/refund_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe FatZebra::Refund do
+  let(:valid_refund_payload) {{
+    transaction_id: transaction_id,
+    amount:         10000,
+    reference:      reference
+  }}
+
+  describe '.create', :vcr do
+    let(:purchase) { FatZebra::Purchase.create(valid_purchase_payload) }
+    let(:transaction_id) { purchase.transaction_id }
+    let(:reference) { purchase.reference }
+    subject(:refund) { FatZebra::Refund.create(valid_refund_payload) }
+
+    it { is_expected.to be_successful }
+    it { expect(refund.authorization.to_s).to_not be_empty }
+    it { expect(refund.id).to_not be_empty }
+    it { expect(refund.card_holder).to eq('Matthew Savage') }
+    it { expect(refund.transaction_id).to_not eq(transaction_id) }
+    it { expect(refund.reference).to eq(reference) }
+    it { expect(refund.currency).to eq('AUD') }
+    it { expect(refund.response_code).to eq('00') }
+    it { expect(refund.metadata).to eq({}) }
+
+    context 'validations' do
+      let(:valid_refund_payload) {{}}
+
+      it { expect{ refund }.to raise_error(FatZebra::RequestValidationError) }
+    end
+  end
+
+  describe '.find', :vcr do
+    let(:purchase) { FatZebra::Purchase.create(valid_purchase_payload) }
+    let(:transaction_id) { purchase.transaction_id }
+    let(:reference) { purchase.reference }
+    let(:create) { FatZebra::Refund.create(valid_refund_payload) }
+
+    subject(:direct_credit) { FatZebra::Refund.find(create.reference) }
+
+    it { is_expected.to be_successful }
+    it { expect(direct_credit.reference).to eq(create.reference) }
+  end
+
+  describe '.search', :vcr do
+    subject(:direct_credits) { FatZebra::Refund.search }
+
+    before do
+      2.times do |i|
+        purchase = FatZebra::Purchase.create(valid_purchase_payload)
+        FatZebra::Refund.create(amount: 10000, reference: purchase.reference, transaction_id: purchase.transaction_id)
+      end
+    end
+
+    it { is_expected.to be_successful }
+    it { expect(direct_credits.data.count).to be >= 2 }
+  end
+
+  describe '#void', :vcr do
+    let(:purchase) { FatZebra::Purchase.create(valid_purchase_payload) }
+    let(:transaction_id) { purchase.transaction_id }
+    let(:reference) { purchase.reference }
+    let(:refund) { FatZebra::Refund.create(valid_refund_payload) }
+
+    before { refund.void() }
+
+    it { is_expected.to_not be_successful }
+    it { expect(refund.message).to eq('Voided') }
+    it { expect(refund).to be_a(FatZebra::Refund) }
+  end
+
+end

data/spec/lib/fat_zebra/util_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe FatZebra::Util do
+
+  describe '#compact' do
+    it { expect(FatZebra::Util.compact(test: nil, other: 'test')).to eq(other: 'test') }
+  end
+
+  describe '#encode_parameters' do
+    it { expect(FatZebra::Util.encode_parameters(id: 42, other: 'test')).to eq("id=42&other=test") }
+  end
+
+  describe '#underscore' do
+    it { expect(FatZebra::Util.underscore('Model')).to eq("model") }
+    it { expect(FatZebra::Util.underscore('MyModel')).to eq("my_model") }
+  end
+
+  describe '#format_dates_in_hash' do
+    let (:date) { DateTime.new(2050, 2, 3) }
+
+    it { expect(FatZebra::Util.format_dates_in_hash(date: date)).to eq(date: '2050/02/03') }
+  end
+
+end

data/spec/lib/fat_zebra/validation_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe FatZebra::Validation do
+  let(:klass) { Class.new }
+
+  before { klass.send(:extend, FatZebra::Validation) }
+
+  describe '#valid?' do
+    before { klass.validates(:test, required: true, on: :create) }
+
+    it { expect(klass.valid?({}, :create)).to be_falsey }
+    it { expect(klass.valid?({ test: 'valid' }, :create)).to be_truthy }
+    it { expect(klass.valid?({}, :update)).to be_truthy }
+  end
+
+  describe '#valid!' do
+    before { klass.validates(:test, required: true, on: :create) }
+
+    it { expect { klass.valid!({}, :create) }.to raise_error(FatZebra::RequestValidationError) }
+  end
+
+end

data/spec/lib/fat_zebra/web_hook_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe FatZebra::WebHook do
+
+  let(:valid_web_hook_payload) {{
+    events:    '*',
+    mode:      'Test',
+    name:      'test hook',
+    address:   'http://stage.example.com.au/v1/api/hook_listener'
+  }}
+
+  describe '.create', :vcr do
+    subject(:web_hook) { FatZebra::WebHook.create(valid_web_hook_payload) }
+
+    it { is_expected.to be_successful }
+    it { expect(web_hook.name).to eq('test hook') }
+    it { expect(web_hook.id).to_not be_empty }
+
+    context 'validations' do
+      let(:valid_web_hook_payload) {{}}
+
+      it { expect{ web_hook }.to raise_error(FatZebra::RequestValidationError) }
+    end
+  end
+
+  describe '.search', :vcr do
+    subject(:web_hooks) { FatZebra::WebHook.search }
+
+    before { 2.times { |i| FatZebra::WebHook.create(valid_web_hook_payload) } }
+
+    it { is_expected.to be_successful }
+    it { expect(web_hooks.data.count).to be >= 2 }
+  end
+
+  describe '#update', :vcr do
+    subject(:web_hook) { FatZebra::WebHook.create(valid_web_hook_payload) }
+    before { web_hook.update(name: 'New Test hook')}
+
+    it { is_expected.to be_successful }
+    it { expect(web_hook.name).to eq('New Test hook') }
+  end
+
+  describe '.delete', :vcr do
+    let(:create) { FatZebra::WebHook.create(valid_web_hook_payload) }
+    subject(:web_hook) { FatZebra::WebHook.delete(create.id) }
+
+    it { is_expected.to be_successful }
+  end
+
+end