fat_zebra 3.2.1 → 3.2.2

data/spec/cassettes/FatZebra_Paypal_Refund/_search/with_date_filter/returns_all_refund_records_created_after_start_date.yml

@@ -0,0 +1,50 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://gateway.sandbox.fatzebra.com.au/v1.0//paypal/refunds?from=2020/08/05&limit=10&offset=0&test=true
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - application/json
+      User-Agent:
+      - Ruby
+      Host:
+      - gateway.sandbox.fatzebra.com.au
+      Authorization:
+      - Basic VEVTVDpURVNU
+      Content-Type:
+      - application/json
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Cache-Control:
+      - no-store
+      Pragma:
+      - no-cache
+      Content-Type:
+      - application/json; charset=utf-8
+      X-Request-Version:
+      - 1.21.8
+      X-Request-Id:
+      - f9e0e746bb7c4611132605c0fefbd352
+      X-Runtime:
+      - '0.086558'
+      Transfer-Encoding:
+      - chunked
+    body:
+      encoding: UTF-8
+      string: '{"successful":true,"response":[{"id":"071-PPR-SRR9FP7ZKXT9IXU3","amount":100,"refunded":"Approved","message":"Approved","transaction_id":"071-PPR-SRR9FP7ZKXT9IXU3","currency":"AUD","successful":true,"transaction_date":"2020-08-06T23:26:56+10:00","response_code":"00","standalone":false,"note_to_payer":"test
+        note","invoice_id":"071-PPR-SRR9FP7ZKXT9IXU3","decimal_amount":1.0,"paypal_fee":2,"seller_payable_net_amount":98,"balance_available_for_refund":11900,"capture":"071-PPC-TUOHT8YJHBY7SBJU","order":"071-PPO-U7RRMGM3OY3V2ZMN"},{"id":"071-PPR-10HDHDI4QRHVDOGV","amount":10900,"refunded":"Approved","message":"Approved","transaction_id":"071-PPR-10HDHDI4QRHVDOGV","currency":"AUD","successful":true,"transaction_date":"2020-08-05T16:54:15+10:00","response_code":"00","standalone":false,"invoice_id":"071-PPR-10HDHDI4QRHVDOGV","decimal_amount":109.0,"paypal_fee":262,"seller_payable_net_amount":10638,"balance_available_for_refund":0,"capture":"071-PPC-JUNNKEGCHIOL1CFR","order":"071-PPO-RXFR2E6ILCIE6HKI"},{"id":"071-PPR-7BIDZCFHPCCBUSJH","amount":100,"refunded":"Approved","message":"Approved","transaction_id":"071-PPR-7BIDZCFHPCCBUSJH","currency":"AUD","successful":true,"transaction_date":"2020-08-05T11:24:24+10:00","response_code":"00","standalone":false,"note_to_payer":"refund
+        the rest","invoice_id":"071-PPR-7BIDZCFHPCCBUSJH","decimal_amount":1.0,"paypal_fee":2,"seller_payable_net_amount":98,"balance_available_for_refund":0,"capture":"071-PPC-JUNNKEGCHIOL1CFR","order":"071-PPO-RXFR2E6ILCIE6HKI"},{"id":"071-PPR-WXEAYHCGZY7DJYZ2","amount":1000,"refunded":"Approved","message":"Approved","transaction_id":"071-PPR-WXEAYHCGZY7DJYZ2","currency":"AUD","successful":true,"transaction_date":"2020-08-05T10:46:21+10:00","response_code":"00","standalone":false,"note_to_payer":"refund
+        the rest","invoice_id":"071-PPR-WXEAYHCGZY7DJYZ2","decimal_amount":10.0,"paypal_fee":24,"seller_payable_net_amount":976,"balance_available_for_refund":0,"capture":"071-PPC-RBJV9SSA7PWXVXFB","order":"071-PPO-5ICGTHBIMG9T7D4I"},{"id":"071-PPR-6FOW2YDJYBPSDBNB","amount":100,"refunded":"Approved","message":"Approved","transaction_id":"071-PPR-6FOW2YDJYBPSDBNB","currency":"AUD","successful":true,"transaction_date":"2020-08-05T10:40:07+10:00","response_code":"00","standalone":false,"note_to_payer":"refund
+        billing agreement","invoice_id":"071-PPR-6FOW2YDJYBPSDBNB","decimal_amount":1.0,"paypal_fee":2,"seller_payable_net_amount":98,"balance_available_for_refund":0,"capture":"071-PPC-RBJV9SSA7PWXVXFB","order":"071-PPO-5ICGTHBIMG9T7D4I"}],"errors":[],"test":true,"records":5,"total_records":5,"page":1,"total_pages":1}'
+    http_version: 
+  recorded_at: Fri, 07 Aug 2020 00:03:14 GMT
+recorded_with: VCR 3.0.3

data/spec/lib/fat_zebra/authenticate_spec.rb

@@ -5,37 +5,32 @@ describe FatZebra::Authenticate do
     subject(:token) { FatZebra::Authenticate.session(valid_3ds_token_payload) }
 
     let(:valid_3ds_token_payload) {{
-      reference_id: 'xxxx-xxxx-xxxx',
-      confirm_url: 'https://example.com',
-      order_number: 'xxxx-xxxx-xxxx',
-      currency: 'AUS',
+      currency: 'AUD',
       amount: 100
     }}
 
     it 'returns JWT with given params' do
       is_expected.to be_accepted
       expect(token.jwt).to be_truthy
-      expect(token.reference_id).to be_truthy
     end
 
-    it 'returns JWT with some params' do
-      valid_3ds_token_payload.delete(:reference_id)
+    it 'returns JWT with no amount' do
+      valid_3ds_token_payload.delete(:amount)
       is_expected.to be_accepted
       expect(token.jwt).to be_truthy
-      expect(token.reference_id).to be_truthy
     end
 
-    it 'returns JWT with no params' do
-      valid_3ds_token_payload.clear
-      is_expected.to be_accepted
-      expect(token.jwt).to be_truthy
-      expect(token.reference_id).to be_truthy
+    it 'returns error when currency is invalid' do
+      valid_3ds_token_payload[:currency] = 'INVALID'
+      is_expected.not_to be_accepted
+      expect(token.errors).to be_a(Array)
+      expect(token.errors.join).to match(/INVALID is not valid for this merchant. Permitted currencies:/)
     end
 
     it 'returns error when amount is invalid' do
       valid_3ds_token_payload[:amount] = 'INVALID'
       is_expected.not_to be_accepted
-      expect(token.errors).to match(/Amount is invalid/)
+      expect(token.errors).to eq(['Amount is invalid'])
     end    
   end
 
@@ -43,13 +38,16 @@ describe FatZebra::Authenticate do
     subject(:decoded) { FatZebra::Authenticate.decode_session(token: jwt) }
 
     context 'when token is valid' do
-      let(:jwt) { FatZebra::Authenticate.session({}).jwt }
+      let(:valid_3ds_token_payload) {{
+        currency: 'AUD',
+        amount: 100
+      }}
+      let(:jwt) { FatZebra::Authenticate.session(valid_3ds_token_payload).jwt }
 
       it 'decodes JWT' do
         is_expected.to be_accepted
-        expect(decoded.keys).to include('payload')
-        expect(decoded.payload).to be_a(Hash)
-        expect(decoded.errors).not_to be_truthy
+        expect(decoded.keys).to include('processor_transaction_id', 'consumer_session_id', 'error_number', 'error_description')
+        expect(decoded.errors).to be_empty
       end
     end
 
@@ -58,85 +56,130 @@ describe FatZebra::Authenticate do
 
       it 'returns error when invalid token' do
         is_expected.not_to be_accepted
-        expect(decoded.errors).to match(/The token is invalid/)
+        expect(decoded.errors).to eq(['Decoding JWT failed: The token is invalid'])
       end
     end
   end
 
   describe '.authenticate', :vcr do
-    subject(:authenticate) { FatZebra::Authenticate.authenticate(valid_sca_authenticate_payload) }
+    subject(:authenticate) { FatZebra::Authenticate.authenticate(valid_sca_authentication_payload) }
     let!(:credit_card) { FatZebra::Card.create(valid_credit_card_payload) }
 
     context 'with invalid input' do
+      before do
+        valid_sca_authentication_payload[:sca].merge!(valid_sca_enrollment_payload)
+      end
+
       it do
-        valid_sca_authenticate_payload[:card_token] = 'INVALID'
+        valid_sca_authentication_payload[:card_token] = 'INVALID'
         is_expected.not_to be_accepted
-        expect(authenticate.errors).to match(/Card not found/)
+        expect(authenticate.errors.join).to match(/Card not found/)
       end
 
       it do
-        valid_sca_authenticate_payload[:sca] = {}
+        valid_sca_authentication_payload[:sca] = {}
         is_expected.not_to be_accepted
         expect(authenticate.errors.join).to match(/Invalid input data/)
       end
 
       it do
-        valid_sca_authenticate_payload[:sca][:currency] = 'INVALID'
+        valid_sca_authentication_payload[:currency] = 'INVALID'
         is_expected.not_to be_accepted
-        expect(authenticate.errors).to match(/3DS lookup request process failed/)
+        expect(authenticate.errors.join).to match(/INVALID is not valid for this merchant. Permitted currencies:/)
       end
 
       it do
-        valid_sca_authenticate_payload[:sca][:amount] = 'INVALID'
+        valid_sca_authentication_payload[:amount] = 'INVALID'
         is_expected.not_to be_accepted
-        expect(authenticate.errors).to match(/3DS lookup request process failed/)
+        expect(authenticate.errors.join).to match(/3DS authenticate request failed: amount must be filled/)
       end
     end
 
     context 'with frictionless response' do
       before do
         valid_credit_card_payload[:card_number] = '4000000000001000'
+        valid_sca_authentication_payload[:sca].merge!(valid_sca_enrollment_payload)
       end
 
       it do
         is_expected.to be_accepted
-        expect(authenticate.keys).to include('Enrolled', 'ACSUrl', 'CardBin', 'TransactionId')
-        expect(authenticate.errors).not_to be_truthy
+        expect(authenticate.keys).to include('enrolled', 'acs_url', 'version', 'card_bin', 'authentication_transaction_id')
+        expect(authenticate.errors).to be_empty
       end
 
       it do
-        expect(authenticate.Enrolled).to be_truthy
-        expect(authenticate.CardBin).to be_truthy
-        expect(authenticate.ErrorNo).to eq('0')
-        expect(authenticate.ErrorDesc).not_to be_truthy
-        expect(authenticate.CardBrand).to be_truthy
-        expect(authenticate.TransactionId).to be_truthy
+        expect(authenticate.enrolled).to be_truthy
+        expect(authenticate.version).to be_truthy
+        expect(authenticate.card_bin).to be_truthy
+        expect(authenticate.authentication_transaction_id).to be_truthy
       end
     end
 
     context 'with challenge response' do
       before do
         valid_credit_card_payload[:card_number] = '4000000000001091'
+        valid_sca_authentication_payload[:sca].merge!(valid_sca_enrollment_payload)
       end
 
       it do
         is_expected.to be_accepted
-        expect(authenticate.keys).to include('Enrolled', 'ACSUrl', 'CardBin', 'TransactionId')
-        expect(authenticate.errors).not_to be_truthy
+        expect(authenticate.keys).to include('enrolled', 'version', 'card_bin', 'authentication_transaction_id')
+        expect(authenticate.errors).to be_empty
+      end
+
+      it do
+        expect(authenticate.enrolled).to be_truthy
+        expect(authenticate.version).to be_truthy
+        expect(authenticate.card_bin).to be_truthy
+        expect(authenticate.authentication_transaction_id).to be_truthy
+      end
+    end
+
+    context 'with type = validation' do
+      subject(:authenticate) { FatZebra::Authenticate.authenticate(valid_sca_authentication_payload) }
+
+      before do
+        allow(FatZebra::Authenticate).to receive(:authenticate)
+          .with(valid_sca_authentication_payload)
+          .and_return(FatZebra::FatZebraObject.initialize_from(validation_response.to_json))
+
+        valid_credit_card_payload[:card_number] = '4000000000001091'
+        valid_sca_authentication_payload[:sca][:type] = 'validation'
+        valid_sca_authentication_payload[:sca].merge!(valid_sca_validation_payload)
+      end
+
+      let(:validation_response) do
+        {
+          successful: true,
+          response: {
+            action: {
+              proceed: true
+            },
+            version: '2.2.0',
+            enrolled: 'Y',
+            cavv: SecureRandom.hex,
+            xid: SecureRandom.hex,
+            pares: 'Y',
+            eci: '05',
+            authentication_transaction_id: SecureRandom.hex,
+            card_bin: '400000',
+            request_id: SecureRandom.hex,
+            decision: 'ACCEPT'
+          },
+          errors: [],
+          test: true
+        }
       end
-      
+
       it do
-        expect(authenticate.Enrolled).to be_truthy
-        expect(authenticate.CardBin).to be_truthy
-        expect(authenticate.ErrorNo).to eq('0')
-        expect(authenticate.ErrorDesc).not_to be_truthy
-        expect(authenticate.CardBrand).to be_truthy
-        expect(authenticate.TransactionId).to be_truthy
+        is_expected.to be_accepted
+        expect(authenticate.keys).to include('enrolled', 'version', 'card_bin', 'authentication_transaction_id', 'cavv', 'eci', 'xid', 'pares')
+        expect(authenticate.errors).to be_empty
       end
     end
     
     context 'validations' do
-      let(:valid_sca_authenticate_payload) {{}}
+      let(:valid_sca_authentication_payload) {{}}
 
       it { expect{ authenticate }.to raise_error(FatZebra::RequestValidationError) }
     end

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/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