fat_zebra 3.2.8 → 3.3.0

data/spec/lib/fat_zebra/fat_zebra_object_spec.rb

@@ -1,117 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,117 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::PaymentPlan do
-  let(:customer) { FatZebra::Customer.create(customer_valid_payload) }
-
-  let(:valid_instalment_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
-  }}
-
-  let(:valid_subscription_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'),
-    end_date:       (Date.today + 180).strftime('%Y-%m-%d'),
-    frequency:      'Weekly',
-    anniversary:    5,
-  }}
-
-
-  describe '.create', :vcr do
-    subject(:payment_plan) { FatZebra::PaymentPlan.create(valid_instalment_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 'perpetual subscription' do
-      subject(:subscription_payload) { FatZebra::PaymentPlan.create(valid_subscription_payload) }
-      it { is_expected.to be_accepted }
-      it { expect(subscription_payload.id).to_not be_empty }
-      it { expect(subscription_payload.payments.count).to eq(12) }
-    end
-
-    context 'validations' do
-      let(:valid_instalment_payload) {{}}
-
-      it { expect { payment_plan }.to raise_error(FatZebra::RequestValidationError) }
-
-    end
-
-
-  end
-
-  describe '.find', :vcr do
-    let!(:create) { FatZebra::PaymentPlan.create(valid_instalment_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(valid_instalment_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(valid_instalment_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(valid_instalment_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(valid_instalment_payload) }
-    before { payment_plan.destroy }
-
-    it { expect(payment_plan.status).to eq('Cancelled') }
-  end
-
-  describe '#suspend!', :vcr  do
-    let(:payment_plan) { FatZebra::PaymentPlan.new(valid_instalment_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(valid_instalment_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/paypal/authorization_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Paypal::Authorization do
-
-  describe '.find', :vcr do
-    subject(:authorization) { FatZebra::Paypal::Authorization.find(authorization_id) }
-
-    context 'when found' do
-      let(:authorization_id) { '071-PPA-3AM3CXFFKMFYI3QM' }
-
-      it 'returns authorization' do
-        expect(authorization).to be_accepted
-        expect(authorization.id).to eq(authorization_id)
-        expect(authorization.order).to include('PPO')
-      end
-    end
-  end
-
-  describe '.search', :vcr do
-    context 'with date filter' do
-      subject(:authorizations) { FatZebra::Paypal::Authorization.search(from: start) }
-
-      let(:start) { Date.parse('2020-08-05') }
-
-      it 'returns records created after start date' do
-        created_date_check = authorizations.data.map { |rec| DateTime.strptime(rec.transaction_date, '%Y-%m-%dT%H:%M:%S%z').iso8601 >= start.iso8601 }
-
-        is_expected.to be_accepted
-
-        expect(authorizations.data).to be_a(Array)
-        expect(authorizations.data.first).to be_a(FatZebra::Paypal::Authorization)
-        expect(created_date_check.all?).to be(true)
-      end
-    end
-  end
-
-  describe '#capture', :vcr do
-    subject(:capture_record) { FatZebra::Paypal::Authorization.capture(authorization_id, params_for_capture) }
-
-    let(:authorization_id) { '071-PPA-3AM3CXFFKMFYI3QM' }
-    let(:capture_amount) { 200 }
-    let(:note) { 'test capture $2' }
-    let(:params_for_capture) do
-      {
-        amount: capture_amount,
-        final_Capture: false,
-        note_to_payer: note
-      }
-    end
-
-    it 'returns a new capture record' do
-      is_expected.to be_accepted
-      is_expected.to be_successful
-
-      expect(capture_record).to be_a(FatZebra::Paypal::Capture)
-      expect(capture_record.id).to include('PPC')
-      expect(capture_record.order).to include('PPO')
-      expect(capture_record.amount).to eq(capture_amount)
-      expect(capture_record.note_to_payer).to eq(note)
-      expect(capture_record.balance_available_for_capture).to be > 0
-    end
-  end
-
-  describe '#void', :vcr do
-    subject(:voided_authorization_record) { FatZebra::Paypal::Authorization.void(authorization_id) }
-
-    let(:authorization_id) { '071-PPA-XB5CXLVNIGCNTB8V' }
-
-    it 'returns a voided capture record' do
-      is_expected.to be_accepted
-      is_expected.to be_successful
-
-      expect(voided_authorization_record).to be_a(FatZebra::Paypal::Authorization)
-      expect(voided_authorization_record.id).to include('PPA')
-      expect(voided_authorization_record.response_code).to eq('00')
-      expect(voided_authorization_record.balance_available_for_capture).to eq(0)
-    end
-  end
-end

data/spec/lib/fat_zebra/paypal/billing_agreement_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Paypal::BillingAgreement do
-
-  describe '.find', :vcr do
-    subject(:billing_agreement) { FatZebra::Paypal::BillingAgreement.find(id) }
-
-    context 'when found' do
-      let(:id) { '071-PBA-PYG1L6M4CV4DYHTZ' }
-
-      it 'returns billing_agreement' do
-        expect(billing_agreement).to be_accepted
-        expect(billing_agreement.id).to eq(id)
-      end
-    end
-  end
-
-  describe '.search', :vcr do
-    context 'with date filter' do
-      subject(:billing_agreements) { FatZebra::Paypal::BillingAgreement.search(from: start) }
-
-      let(:start) { Date.parse('2020-08-05') }
-
-      it 'returns records created after start date' do
-        created_date_check = billing_agreements.data.map { |rec| DateTime.strptime(rec.created_at, '%Y-%m-%dT%H:%M:%S%z').iso8601 >= start.iso8601 }
-
-        is_expected.to be_accepted
-
-        expect(billing_agreements.data).to be_a(Array)
-        expect(billing_agreements.data.first).to be_a(FatZebra::Paypal::BillingAgreement)
-        expect(created_date_check.all?).to be(true)
-      end
-    end
-  end
-
-  describe '#charge', :vcr do
-    let(:id) { '071-PBA-PYG1L6M4CV4DYHTZ' }
-
-    context 'Valid payload' do
-      subject(:charge) { FatZebra::Paypal::BillingAgreement.charge(id, valid_charge_billing_agreement_payload) }
-
-      it 'returns a new order record' do
-        is_expected.to be_accepted
-        is_expected.to be_successful
-
-        expect(charge).to be_a(FatZebra::Paypal::Order)
-        expect(charge.billing_agreement_id).to eq(id)
-        expect(charge.payment_source).to eq('BILLING_AGREEMENT')
-        expect(charge.id).to include('PPO')
-        expect(charge.captures.count).to eq(1)
-      end
-    end
-
-    context 'Invalid payload' do
-      subject(:charge) { FatZebra::Paypal::BillingAgreement.charge(id, {}) }
-
-      it 'failed to execute call' do
-        expect{ charge }.to raise_error(FatZebra::RequestValidationError)
-      end
-    end
-  end
-end

data/spec/lib/fat_zebra/paypal/capture_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Paypal::Capture do
-
-  describe '.find', :vcr do
-    subject(:capture) { FatZebra::Paypal::Capture.find(capture_id) }
-
-    context 'when found' do
-      let(:capture_id) { '071-PPC-TUOHT8YJHBY7SBJU' }
-
-      it 'returns capture' do
-        expect(capture).to be_accepted
-        expect(capture.id).to eq(capture_id)
-        expect(capture.order).to include('PPO')
-      end
-    end
-  end
-
-  describe '.search', :vcr do
-    context 'with date filter' do
-      subject(:captures) { FatZebra::Paypal::Capture.search(from: start) }
-
-      let(:start) { Date.parse('2020-08-05') }
-
-      it 'returns records created after start date' do
-        created_date_check = captures.data.map { |rec| DateTime.strptime(rec.transaction_date, '%Y-%m-%dT%H:%M:%S%z').iso8601 >= start.iso8601 }
-
-        is_expected.to be_accepted
-
-        expect(captures.data).to be_a(Array)
-        expect(captures.data.first).to be_a(FatZebra::Paypal::Capture)
-        expect(created_date_check.all?).to be(true)
-      end
-    end
-  end
-
-  describe '#refund', :vcr do
-    subject(:refund_record) { FatZebra::Paypal::Capture.refund(capture_id, params_for_refund) }
-
-    let(:capture_id) { '071-PPC-TUOHT8YJHBY7SBJU' }
-    let(:refund_amount) { 100 }
-    let(:params_for_refund) do
-      {
-        amount: refund_amount,
-        note_to_payer: 'test note'
-      }
-    end
-
-    it 'returns a new refund record' do
-      is_expected.to be_accepted
-      is_expected.to be_successful
-
-      expect(refund_record).to be_a(FatZebra::Paypal::Refund)
-      expect(refund_record.amount).to eq(refund_amount)
-      expect(refund_record.note_to_payer).to eq('test note')
-      expect(refund_record.id).to include('PPR')
-      expect(refund_record.order).to include('PPO')
-    end
-  end
-end

data/spec/lib/fat_zebra/paypal/order_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Paypal::Order do
-
-  describe '.find', :vcr do
-    subject(:order) { FatZebra::Paypal::Order.find(order_id) }
-
-    context 'when found' do
-      let(:order_id) { '071-PPO-U7RRMGM3OY3V2ZMN' }
-
-      it 'returns order' do
-        expect(order).to be_accepted
-        expect(order.id).to eq(order_id)
-      end
-    end
-  end
-
-  describe '.search', :vcr do
-    context 'with date filter' do
-      subject(:orders) { FatZebra::Paypal::Order.search(from: start) }
-
-      let(:start) { Date.parse('2020-08-05') }
-
-      it 'returns orders created after start date' do
-        created_date_check = orders.data.map { |rec| DateTime.strptime(rec.transaction_date, '%Y-%m-%dT%H:%M:%S%z').iso8601 >= start.iso8601 }
-
-        is_expected.to be_accepted
-
-        expect(orders.data).to be_a(Array)
-        expect(orders.data.first).to be_a(FatZebra::Paypal::Order)
-        expect(created_date_check.all?).to be(true)
-      end
-    end
-  end
-end

data/spec/lib/fat_zebra/paypal/refund_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Paypal::Refund do
-
-  describe '.find', :vcr do
-    subject(:refund) { FatZebra::Paypal::Refund.find(refund_id) }
-
-    context 'when found' do
-      let(:refund_id) { '071-PPR-SRR9FP7ZKXT9IXU3' }
-
-      it 'returns refund' do
-        expect(refund).to be_accepted
-        expect(refund.id).to eq(refund_id)
-        expect(refund.order).to include('PPO')
-      end
-    end
-  end
-
-  describe '.search', :vcr do
-    context 'with date filter' do
-      subject(:refunds) { FatZebra::Paypal::Refund.search(from: start) }
-
-      let(:start) { Date.parse('2020-08-05') }
-
-      it 'returns all refund records created after start date' do
-        created_date_check = refunds.data.map { |rec| DateTime.strptime(rec.transaction_date, '%Y-%m-%dT%H:%M:%S%z').iso8601 >= start.iso8601 }
-
-        is_expected.to be_accepted
-
-        expect(refunds.data).to be_a(Array)
-        expect(refunds.data.first).to be_a(FatZebra::Paypal::Refund)
-        expect(created_date_check.all?).to be(true)
-      end
-    end
-  end
-end

data/spec/lib/fat_zebra/purchase_spec.rb

@@ -1,123 +0,0 @@
-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
-
-  describe '#extend!', :vcr do
-    let(:purchase) { FatZebra::Purchase.create(valid_purchase_payload.merge(capture: false)) }
-    subject(:extend) { purchase.extend! }
-
-    it { is_expected.to be_accepted }
-    it { is_expected.to be_successful }
-    it { expect(extend).to be_a(FatZebra::Purchase) }
-  end
-
-  describe '#increment', :vcr do
-    let(:purchase) { FatZebra::Purchase.create(valid_purchase_payload.merge(capture: false)) }
-    subject(:increment) { purchase.increment!(200) }
-
-    it { is_expected.to be_accepted }
-    it { is_expected.to be_successful }
-    it { expect(increment).to be_a(FatZebra::Purchase) }
-    it { expect(increment.amount).to eq(valid_purchase_payload[:amount] + 200) }
-  end
-end