fat_zebra_multi 3.2.0.1 → 3.2.3.2

data/spec/lib/fat_zebra/authenticate_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe FatZebra::Authenticate do
+  describe '.session', :vcr do
+    subject(:token) { FatZebra::Authenticate.session(valid_3ds_token_payload) }
+
+    let(:valid_3ds_token_payload) {{
+      currency: 'AUD',
+      amount: 100
+    }}
+
+    it 'returns JWT with given params' do
+      is_expected.to be_accepted
+      expect(token.jwt).to be_truthy
+    end
+
+    it 'returns JWT with no amount' do
+      valid_3ds_token_payload.delete(:amount)
+      is_expected.to be_accepted
+      expect(token.jwt).to be_truthy
+    end
+
+    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 eq(['Amount is invalid'])
+    end    
+  end
+
+  describe '.decode_session', :vcr do
+    subject(:decoded) { FatZebra::Authenticate.decode_session(token: jwt) }
+
+    context 'when token is valid' do
+      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('processor_transaction_id', 'consumer_session_id', 'error_number', 'error_description')
+        expect(decoded.errors).to be_empty
+      end
+    end
+
+    context 'when token is invalid' do
+      let(:jwt) { 'INVALID TOKEN' }
+
+      it 'returns error when invalid token' do
+        is_expected.not_to be_accepted
+        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_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_authentication_payload[:card_token] = 'INVALID'
+        is_expected.not_to be_accepted
+        expect(authenticate.errors.join).to match(/Card not found/)
+      end
+
+      it do
+        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_authentication_payload[:currency] = 'INVALID'
+        is_expected.not_to be_accepted
+        expect(authenticate.errors.join).to match(/INVALID is not valid for this merchant. Permitted currencies:/)
+      end
+
+      it do
+        valid_sca_authentication_payload[:amount] = 'INVALID'
+        is_expected.not_to be_accepted
+        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', '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.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', '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
+        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_authentication_payload) {{}}
+
+      it { expect{ authenticate }.to raise_error(FatZebra::RequestValidationError) }
+    end
+  end
+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

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/spec_helper.rb

@@ -1,6 +1,5 @@
 require 'rubygems'
 require 'bundler/setup'
-require 'pry'
 require 'rspec'
 require 'vcr'
 require 'webmock/rspec'

data/spec/support/payloads.rb

@@ -40,46 +40,139 @@ shared_context 'payloads' do
     }
   }}
 
-  let(:valid_3ds_authorise_payload) {{
-    card_number: '5123456789012346',
-    card_expiry: DateTime.now.next_year.strftime('%m/%Y'),
-    threeds: {
-      enabled: true,
-      amount: 100,
-      billing_address1: 'SOME ADDRESS',
-      billing_city: 'Sydney',
-      billing_country_code: '036', # Australia
-      billing_first_name: 'John',
-      billing_last_name: 'Smith',
-      billing_postal_code: '2000',
-      billing_state: 'NSW',
-      currency_code: '036',
-      df_reference_id: SecureRandom.hex(10),
-      mobile_phone: '1234567890',
-      email: 'dev@fatzebra.com.au',
+  let(:valid_sca_enrollment_payload) {{
+    customer: {
+      address_1: '23 Smith Road',
+      address_2: 'North Shore',
+      city: 'Canberra',
+      country: 'AU',
+      state: 'NSW',
+      email: 'test@test.com',
+      first_name: 'James',
+      last_name: 'Smith',
+      phone_number: '0444555666',
+      post_code: '2000',
+      passport_number: 'X1234567890',
+      passport_country: '036',
+      account_changed_at: '20191210',
+      account_created_at: '20191210',
+      account_password_changed_at: '20191210'
+    },
+    shipping_address: {
+      address_1: '23 Smith Road',
+      address_2: 'North Shore',
+      city: 'Sydney',
+      country: 'AU',
+      state: 'NSW',
+      email: 'test@test.com',
+      first_name: 'James',
+      last_name: 'Smith',
+      phone_number: '0444555666',
+      post_code: '2000',
+      method: 'pickup',
+      destination_code: '01',
+    },
+    custom: {
       transaction_mode: 'mobile',
-      transaction_type: 'C',
-      order_number: SecureRandom.hex(10),
+      reference_id: SecureRandom.hex,
+
+      merchant_name: 'TEST',
+      merchant_new_customer: true,
+      preorder: 1,
 
-      shipping_address1: 'SOME ADDRESS',
-      shipping_state: 'NSW',
-      shipping_city: 'Sydney',
-      shipping_country_code: '036',
-      shipping_address2: 'SOME ADDRESS',
-      shipping_address3: 'SOME ADDRESS',
-      shipping_postal_code: '2000',
-      billing_phone: '1234567890',
-      work_phone: '1234567890',
-      billing_address2: 'SOME ADDRESS',
-      billing_address3: 'SOME ADDRESS',
-      authentication_indicator: '01',
-      product_code: 'PHY',
+      http_accept: 'text/html',
+      http_user_agent: 'Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0',
 
-      installment: 2,
-      purchase_date: DateTime.now.next_year.strftime('%Y%m%d%H%M%S'),
-      recurring_end: DateTime.now.next_year.strftime('%Y%m%d'),
-      recurring_frequency: 31
+      recurring_end_date: '20201201',
+      recurring_frequency: 3,
+      recurring_original_purchase_date: '2019120112:00:00'
+    },
+    items: [
+      {
+        unit_price: 23.3,
+        product_description: 'Widgets',
+        product_name: 'Watch',
+        quantity: 1,
+        product_sku: '9999',
+        passenger_first_name: 'John',
+        passenger_last_name: 'Smith',
+      }
+    ],
+    airline_data: {
+      legs: [
+        {
+          carrier_code: 'code',
+          departure_date: '20221012',
+          destination: 'SYD',
+          originating_airport_code: 'MEL',
+        }
+      ],
+      number_of_passengers: 2,
+      passengers: [
+        {
+          first_name: 'John',
+          last_name: 'Smith',
+        },
+        {
+          first_name: 'Megan',
+          last_name: 'Doe',
+        }
+      ]
     }
   }}
 
+  let(:valid_sca_validation_payload) {{
+    authentication_transaction_id: SecureRandom.hex,
+    signed_pares: SecureRandom.hex
+  }}
+
+  let(:valid_sca_authentication_payload) {{
+    card_token: credit_card.token,
+    amount: 100,
+    currency: 'AUD',
+    customer_ip: '111.111.111.111',
+    sca: {
+      type: 'enrollment',
+      merchant_reference_code: SecureRandom.uuid,
+    }
+  }}
+
+  let(:valid_charge_billing_agreement_payload) {{
+    reference: SecureRandom.uuid,
+    amount: 1100,
+    currency: "AUD",
+    customer_ip: '1.2.3.4',
+    options: {
+      brand_name: "EXAMPLE INC"
+    },
+    purchases: [{
+      description: "Sporting Goods",
+      custom_id: "CUST-HighFashions",
+      soft_descriptor: "HighFashions",
+      amount: {
+        item_total: 900,
+        shipping: 200
+      },
+      items: [{
+        name: "T-Shirt",
+        unit_amount: 900,
+        qty: 1,
+        category: "PHYSICAL_GOODS"
+      }],
+      shipping_address: {
+        method: "United States Postal Service 1",
+        address: {
+          first_name: "John",
+          last_name: "Doe",
+          address_1: "100 Kent Street",
+          address_2: "Cafe Lane",
+          city: "Sydney",
+          state: "NSW",
+          postcode: "2000",
+          country: "AU"
+        }
+      }
+    }]
+  }}
+
 end