fat_zebra 3.0.11 → 3.2.3

data/spec/lib/fat_zebra/card_spec.rb

@@ -38,4 +38,12 @@ describe FatZebra::Card do
     end
   end
 
+  describe '.find', :vcr do
+    let(:create) { FatZebra::Card.create(valid_credit_card_payload) }
+    subject(:card) { FatZebra::Card.find(create.token) }
+
+    it { is_expected.to be_accepted }
+    it { expect(card.token).to eq(create.token) }
+  end
+
 end

data/spec/lib/fat_zebra/direct_credit_spec.rb

@@ -4,7 +4,7 @@ describe FatZebra::DirectCredit do
 
   let(:valid_direct_credit_payload) {{
     description:    'Confirmation',
-    amount:         42,
+    amount:         42.0,
     bsb:            '123-123',
     account_name:   'Test',
     account_number: '012345678'
@@ -30,6 +30,18 @@ describe FatZebra::DirectCredit do
 
         it { expect{ direct_credit }.to raise_error(FatZebra::RequestValidationError) }
       end
+
+      context 'failed with non-float' do
+        let(:valid_direct_credit_payload) {{
+          description:    'Confirmation',
+          amount:         123,
+          bsb:            '123-123',
+          account_name:   'Test',
+          account_number: '012345678'
+        }}
+
+        it { expect{ direct_credit }.to raise_error(FatZebra::RequestValidationError) }
+      end
     end
   end
 
@@ -39,6 +51,7 @@ describe FatZebra::DirectCredit do
 
     it { is_expected.to be_accepted }
     it { expect(direct_credit.reference).to eq(create.reference) }
+    it { expect(direct_credit.amount).to be_instance_of(Float) }
   end
 
   describe '.search', :vcr do

data/spec/lib/fat_zebra/direct_debit_spec.rb

@@ -4,7 +4,7 @@ describe FatZebra::DirectDebit do
 
   let(:valid_direct_debit_payload) {{
     description:    'Confirmation',
-    amount:         42,
+    amount:         42.0,
     bsb:            '123-123',
     account_name:   'Test',
     account_number: '012345678'
@@ -30,6 +30,18 @@ describe FatZebra::DirectDebit do
 
         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
 
@@ -39,6 +51,7 @@ describe FatZebra::DirectDebit do
 
     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

data/spec/lib/fat_zebra/payment_plan_spec.rb

@@ -9,7 +9,7 @@ describe FatZebra::PaymentPlan do
     reference:      SecureRandom.hex,
     setup_fee:      0,
     amount:         100,
-    start_date:     '2015-07-16',
+    start_date:     (Date.today + 90).strftime('%Y-%m-%d'),
     frequency:      'Weekly',
     anniversary:    5,
     total_count:    5,

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

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

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

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

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

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

@@ -16,7 +16,7 @@ describe FatZebra::Purchase do
     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.metadata).to eq({ "authorization_tracking_id" => "", "original_transaction_reference" => "" }) }
     it { expect(purchase.response_code).to eq('00') }
 
     context 'bad request' do
@@ -77,7 +77,7 @@ describe FatZebra::Purchase do
     subject(:void) { FatZebra::Purchase.void(purchase.id) }
 
     it { is_expected.to be_accepted }
-    it { is_expected.to_not be_successful }
+    it { is_expected.to be_successful }
     it { expect(void.message).to eq('Voided') }
     it { expect(void).to be_a(FatZebra::Purchase) }
   end
@@ -87,7 +87,7 @@ describe FatZebra::Purchase do
     before { expect(purchase.void).to be_truthy }
 
     it { is_expected.to be_accepted }
-    it { is_expected.to_not be_successful }
+    it { is_expected.to be_successful }
     it { expect(purchase.message).to eq('Voided') }
     it { expect(purchase).to be_a(FatZebra::Purchase) }
   end

data/spec/lib/fat_zebra/refund_spec.rb

@@ -8,10 +8,11 @@ describe FatZebra::Refund do
   }}
 
   describe '.create', :vcr do
+    subject(:refund) { FatZebra::Refund.create(valid_refund_payload) }
+
     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_accepted }
     it { is_expected.to be_successful }
@@ -32,44 +33,63 @@ describe FatZebra::Refund do
   end
 
   describe '.find', :vcr do
+    subject(:found_refund) { FatZebra::Refund.find(created_refund.reference) }
+
     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) }
+    let(:created_refund) { FatZebra::Refund.create(valid_refund_payload) }
 
     it { is_expected.to be_accepted }
     it { is_expected.to be_successful }
-    it { expect(direct_credit.reference).to eq(create.reference) }
+    it { expect(found_refund.reference).to eq(created_refund.reference) }
   end
 
   describe '.search', :vcr do
-    subject(:direct_credits) { FatZebra::Refund.search }
+    subject(:found_refunds) { 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
+    let(:created_refunds) do
+      purchase = FatZebra::Purchase.create(valid_purchase_payload)
+      [
+        FatZebra::Refund.create(amount: 1000, reference: SecureRandom.hex, transaction_id: purchase.transaction_id),
+        FatZebra::Refund.create(amount: 1000, reference: SecureRandom.hex, transaction_id: purchase.transaction_id),
+      ]
     end
 
-    it { is_expected.to be_accepted }
-    it { expect(direct_credits.data.count).to be >= 2 }
+    before { created_refunds }
+
+    it "responds with the newly-created refunds" do
+      is_expected.to be_accepted
+      expect(found_refunds.data.map(&:id)).to include(*created_refunds.map(&:id))
+    end
   end
 
   describe '#void', :vcr do
+    subject(:refund) { FatZebra::Refund.create(valid_refund_payload).void }
+
     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) }
-
-    before { refund.void() }
 
     it { is_expected.to be_accepted }
-    it { is_expected.to_not be_successful }
+    it { is_expected.to be_successful }
     it { expect(refund.message).to eq('Voided') }
     it { expect(refund).to be_a(FatZebra::Refund) }
   end
 
+  describe '#declined?' do
+    subject { refund.declined? }
+
+    let(:refund) { described_class.initialize_from({ 'response' => { 'refunded' => refunded } }) }
+
+    context do
+      let(:refunded) { 'Declined' }
+      it { is_expected.to be(true) }
+    end
+
+    context do
+      let(:refunded) { 'Approved' }
+      it { is_expected.to be(false) }
+    end
+  end
 end