fat_zebra 3.2.8 → 3.3.0

data/spec/lib/fat_zebra/authenticate_spec.rb

@@ -1,187 +0,0 @@
-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/bank_account_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::BankAccount do
-
-  let(:valid_bank_account_payload) {{
-    bsb:            '123-123',
-    account_name:   'Test name',
-    account_number: '012345678'
-  }}
-
-  describe '.create', :vcr do
-    subject(:bank_account) { FatZebra::BankAccount.create(valid_bank_account_payload) }
-
-    it { is_expected.to be_accepted }
-    it { expect(bank_account.id).to_not be_empty }
-
-    context 'validations' do
-      let(:valid_bank_account_payload) {{}}
-
-      it { expect{ bank_account }.to raise_error(FatZebra::RequestValidationError) }
-    end
-  end
-
-  describe '.search', :vcr do
-    subject(:bank_accounts) { FatZebra::BankAccount.search }
-
-    before { 2.times { |i| FatZebra::BankAccount.create(valid_bank_account_payload) } }
-
-    it { is_expected.to be_accepted }
-    it { expect(bank_accounts.data.count).to be >= 2 }
-    it { expect(bank_accounts.data.first).to be_a(FatZebra::BankAccount) }
-  end
-
-end

data/spec/lib/fat_zebra/batch_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Batch do
-  let(:batch_path) { "#{File.dirname(__FILE__)}/../../fixtures/batch_test.csv" }
-
-  let(:valid_batch_payload) {{
-    file:     File.new(batch_path),
-    filename: "BATCH-v1-PURCHASE-TEST-#{Time.now.strftime('%Y%m%d')}-#{SecureRandom.hex}.csv"
-  }}
-
-  describe '.create', :vcr do
-    subject(:batch) { FatZebra::Batch.create(valid_batch_payload) }
-
-    context 'with file' do
-      it { is_expected.to be_accepted }
-      it { expect(batch.reference).to_not be_empty }
-    end
-
-    context 'with path' do
-      let(:valid_batch_payload) {{
-        path:     batch_path,
-        filename: "BATCH-v1-PURCHASE-TEST-#{Time.now.strftime('%Y%m%d')}-#{SecureRandom.hex}.csv"
-      }}
-
-      it { is_expected.to be_accepted }
-      it { expect(batch.reference).to_not be_empty }
-    end
-
-    context 'validations' do
-      let(:valid_batch_payload) {{}}
-
-      it { expect{ batch }.to raise_error(FatZebra::RequestValidationError) }
-    end
-  end
-
-  describe '.find', :vcr do
-    let(:create) { FatZebra::Batch.create(valid_batch_payload) }
-    subject(:batch) { FatZebra::Batch.find(create.reference) }
-
-    it { is_expected.to be_accepted }
-    it { expect(batch.reference).to eq(create.reference) }
-  end
-
-  describe '.search', :vcr do
-    subject(:batches) { FatZebra::Batch.search }
-
-    it { is_expected.to be_accepted }
-    it { expect(batches.data.count).to be >= 2 }
-    it { expect(batches.data.first).to be_a(FatZebra::Batch) }
-  end
-
-  describe '#result', :vcr do
-    let(:create) { FatZebra::Batch.create(valid_batch_payload) }
-    let(:batch) { FatZebra::Batch.find(create.reference) }
-
-    it { expect(batch.result).to eq("Batch is not yet completed") }
-  end
-
-end

data/spec/lib/fat_zebra/card_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Card do
-
-  describe '.create', :vcr do
-    subject(:credit_card) { FatZebra::Card.create(valid_credit_card_payload) }
-
-    it { is_expected.to be_accepted }
-    it { expect(credit_card.token).to_not be_empty }
-    it { expect(credit_card.card_holder).to eq('Matthew Savage') }
-    it { expect(credit_card.card_number).to_not be_empty }
-    it { expect(credit_card.card_type).to eq('MasterCard') }
-    it { expect(credit_card.authorized?).to be_truthy }
-
-    context 'validations' do
-      let(:valid_credit_card_payload) {{}}
-
-      it { expect{ credit_card }.to raise_error(FatZebra::RequestValidationError) }
-    end
-  end
-
-  describe '.update', :vcr do
-    let(:valid_credit_card_update_payload) {{
-      card_expiry: DateTime.new(2050, 2, 3).strftime('%m/%Y'),
-    }}
-
-    let(:create) { FatZebra::Card.create(valid_credit_card_payload) }
-    subject(:credit_card) { FatZebra::Card.update(create.token, valid_credit_card_update_payload) }
-
-    it { is_expected.to be_accepted }
-    it { expect(credit_card.token).to eq(create.token) }
-    it { expect(credit_card.card_expiry).to_not eq(create.card_expiry) }
-
-    context 'validations' do
-      let(:valid_credit_card_update_payload) {{}}
-
-      it { expect{ credit_card }.to raise_error(FatZebra::RequestValidationError) }
-    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/config_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Config do
-  let(:params) {{
-    token:       'my-token',
-    username:    'my-username'
-  }}
-
-  subject(:config) { FatZebra::Config.new(params) }
-
-  describe  '#initialize' do
-    it { expect(config.valid!).to be_truthy }
-    it { expect(config.token).to eq(params[:token]) }
-    it { expect(config.username).to eq(params[:username]) }
-    it { expect(config.gateway).to eq('gateway.fatzebra.com.au') }
-    it { expect(config.test_mode).to be_falsey }
-    it { expect(config.http_secure).to be_truthy }
-    it { expect(config.api_version).to eq('v1.0') }
-
-    context 'with all params' do
-      let(:params) {{
-        token:       'my-token',
-        username:    'my-username',
-        gateway:     'my-gateway',
-        test_mode:   'my-test_mode',
-        http_secure: 'my-http_secure',
-        api_version: 'my-api_version',
-        proxy:       'my-proxy'
-      }}
-
-      it { expect(config.valid!).to be_truthy }
-      it { expect(config.gateway).to eq(params[:gateway]) }
-      it { expect(config.test_mode).to eq(params[:test_mode]) }
-      it { expect(config.http_secure).to eq(params[:http_secure]) }
-      it { expect(config.api_version).to eq(params[:api_version]) }
-      it { expect(config.proxy).to eq(params[:proxy]) }
-    end
-
-    %i[username token].each do |field|
-      context "validate #{field}" do
-        let(:params) {{ token: 'my-token', username: 'my-username' }.merge(field => '')}
-
-        it { expect { config.valid! }.to raise_error(FatZebra::ConfigurationError, "#{field} can't be blank") }
-      end
-    end
-
-    context 'with gateway' do
-      before { expect(config.valid!).to be_truthy }
-
-      context 'with production' do
-        subject(:config) { FatZebra::Config.new(params.merge(gateway: :production)) }
-
-        it { expect(config.gateway).to eq('gateway.fatzebra.com.au') }
-      end
-    end
-
-    context 'remove http' do
-      let(:params) {{
-        token:    'my-token',
-        username: 'my-username',
-        gateway:  'http://my-gateway',
-        proxy:    'https://my-proxy'
-      }}
-
-      it { expect(config.gateway).to eq('my-gateway') }
-    end
-
-  end
-end

data/spec/lib/fat_zebra/customer_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Customer do
-
-  describe '.create', :vcr do
-    subject(:customer) { FatZebra::Customer.create(customer_valid_payload) }
-
-    it { is_expected.to be_accepted }
-    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_accepted }
-    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_accepted }
-    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_accepted }
-    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_accepted }
-  end
-
-end

data/spec/lib/fat_zebra/direct_credit_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::DirectCredit do
-
-  let(:valid_direct_credit_payload) {{
-    description:    'Confirmation',
-    amount:         42.0,
-    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_accepted }
-    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
-      context 'valid' do
-        before { valid_direct_credit_payload[:amount] = 42.42 }
-
-        it { is_expected.to be_accepted }
-      end
-
-      context 'failed' do
-        let(:valid_direct_credit_payload) {{}}
-
-        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
-
-  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_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
-    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_accepted }
-    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_accepted }
-  end
-
-end

data/spec/lib/fat_zebra/direct_debit_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::DirectDebit do
-
-  let(:valid_direct_debit_payload) {{
-    description:    'Confirmation',
-    amount:         42.0,
-    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_accepted }
-    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
-      context 'valid' do
-        before { valid_direct_debit_payload[:amount] = 42.42 }
-
-        it { is_expected.to be_accepted }
-      end
-
-      context 'failed' do
-        let(:valid_direct_debit_payload) {{}}
-
-        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
-
-  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_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
-    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_accepted }
-    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_accepted }
-  end
-
-end