fat_zebra 3.2.9 → 3.3.0

data/spec/lib/fat_zebra/refund_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Refund do
-  let(:valid_refund_payload) {{
-    transaction_id: transaction_id,
-    amount:         10000,
-    reference:      reference
-  }}
-
-  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 }
-
-    it { is_expected.to be_accepted }
-    it { is_expected.to be_successful }
-    it { expect(refund.authorization.to_s).to_not be_empty }
-    it { expect(refund.id).to_not be_empty }
-    it { expect(refund.card_holder).to eq('Matthew Savage') }
-    it { expect(refund.transaction_id).to_not eq(transaction_id) }
-    it { expect(refund.reference).to eq(reference) }
-    it { expect(refund.currency).to eq('AUD') }
-    it { expect(refund.response_code).to eq('00') }
-    it { expect(refund.metadata).to eq({}) }
-
-    context 'validations' do
-      let(:valid_refund_payload) {{}}
-
-      it { expect{ refund }.to raise_error(FatZebra::RequestValidationError) }
-    end
-  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(:created_refund) { FatZebra::Refund.create(valid_refund_payload) }
-
-    it { is_expected.to be_accepted }
-    it { is_expected.to be_successful }
-    it { expect(found_refund.reference).to eq(created_refund.reference) }
-  end
-
-  describe '.search', :vcr do
-    subject(:found_refunds) { FatZebra::Refund.search }
-
-    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
-
-    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 }
-
-    it { is_expected.to be_accepted }
-    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

data/spec/lib/fat_zebra/request_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Request do
-  describe '#initalize' do
-    subject do
-      FatZebra::Request
-        .new(params)
-        .http
-    end
-    let(:params) do
-      {
-        url: 'https://cool.dudes/v2/swagtopia.json',
-      }.merge!(proxy_params)
-    end
-    let(:formatted_proxy) { [host, port].join(':') }
-    let(:formatted_host) { URI.parse(host).host }
-    let(:host) { "http://squidward.net" }
-    let(:port) { 6969 }
-
-    context 'with default params' do
-      let(:proxy_params) {{}}
-
-      it 'does not use a proxy configuration' do
-        expect(subject.proxy?).to eq(false)
-      end
-    end
-
-    context 'with env var specifying http proxy' do
-      let(:proxy_params) {{}}
-      before do
-        allow(ENV).to receive(:[]).with("NO_PROXY").and_return(nil)
-        allow(ENV).to receive(:[]).with("no_proxy").and_return(nil)
-        allow(ENV).to receive(:[]).with("http_proxy").and_return(formatted_proxy)
-      end
-
-      it 'draws the proxy configuration from the environment var' do
-        expect(subject.proxy?).to eq(true)
-        expect(subject.proxy_from_env?).to eq(true)
-        expect(subject.proxy_address).to eq(formatted_host)
-        expect(subject.proxy_port).to eq(port)
-      end
-    end
-
-    context 'with custom http_proxy params to the constructor passed via initializer or similar' do
-      let(:proxy_params) do
-        {
-          proxy: formatted_proxy
-        }
-      end
-
-      it 'draws the proxy host and port configuration from the environment var' do
-        expect(subject.proxy?).to eq(true)
-        expect(subject.proxy_from_env?).to eq(false)
-        expect(subject.proxy_address).to eq(formatted_host)
-        expect(subject.proxy_port).to eq(port)
-      end
-    end
-  end
-end

data/spec/lib/fat_zebra/util_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Util do
-
-  describe '#compact' do
-    it { expect(FatZebra::Util.compact(test: nil, other: 'test')).to eq(other: 'test') }
-  end
-
-  describe '#encode_parameters' do
-    it { expect(FatZebra::Util.encode_parameters(id: 42, other: 'test')).to eq("id=42&other=test") }
-  end
-
-  describe '#camelize' do
-    it { expect(FatZebra::Util.camelize('model')).to eq("Model") }
-    it { expect(FatZebra::Util.camelize('my_model')).to eq("MyModel") }
-  end
-
-  describe '#underscore' do
-    it { expect(FatZebra::Util.underscore('Model')).to eq("model") }
-    it { expect(FatZebra::Util.underscore('MyModel')).to eq("my_model") }
-  end
-
-  describe '#format_dates_in_hash' do
-    let (:date) { DateTime.new(2050, 2, 3) }
-
-    it { expect(FatZebra::Util.format_dates_in_hash(date: date)).to eq(date: '2050/02/03') }
-  end
-
-end

data/spec/lib/fat_zebra/utilities/apple_pay/domain_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Utilities::ApplePay::Domain do
-
-  describe '.list', :vcr do
-    subject(:list) { FatZebra::Utilities::ApplePay::Domain.list }
-
-    it "fetches the merchant domains" do
-      expect(list).to be_accepted
-      expect(list.data.length).to eq(2)
-      expect(list.data.first.raw).to eq(
-        {
-          "domain" => "example.com", 
-          "status" => "Active"
-        }
-      )
-      expect(list.data.last.raw).to eq(
-        {
-          "domain" => "example2.com", 
-          "status" => "Active"
-        }
-      )
-    end
-  end
-
-  describe '.register!', :vcr do
-    subject(:create) { FatZebra::Utilities::ApplePay::Domain.register!(domain, valid_payload) }
-
-    let!(:domain) { "www.example99.com" }
-    let!(:valid_payload) {{
-      async: false
-    }}
-
-    it "creates the domain" do
-      expect(create).to be_accepted
-      expect(create.domain).to eq(domain)
-      expect(create.status).to eq("Active")
-    end
-  end
-
-  describe '.find!', :vcr do
-    subject(:find) { FatZebra::Utilities::ApplePay::Domain.find!(domain) }
-    let!(:domain) { "www.example.com" }
-
-    it "fetches the domain" do
-      expect(find).to be_accepted
-      expect(find.domain).to eq(domain)
-      expect(find.status).to eq("Active")
-    end
-  end
-
-  describe '.delete!', :vcr do
-    subject(:delete) { FatZebra::Utilities::ApplePay::Domain.delete!(domain) }
-    let!(:domain) { "www.example99.com" }
-
-    it "deletes the domain" do
-      expect(delete).to be_accepted
-    end
-  end
-end

data/spec/lib/fat_zebra/validation_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::Validation do
-  let(:klass) { Class.new }
-
-  before { klass.send(:extend, FatZebra::Validation) }
-
-  describe '#valid?' do
-    before { klass.validates(:test, required: true, on: :create) }
-
-    it { expect(klass.valid?({}, :create)).to be_falsey }
-    it { expect(klass.valid?({ test: 'valid' }, :create)).to be_truthy }
-    it { expect(klass.valid?({}, :update)).to be_truthy }
-  end
-
-  describe '#valid!' do
-    before { klass.validates(:test, required: true, on: :create) }
-
-    it { expect { klass.valid!({}, :create) }.to raise_error(FatZebra::RequestValidationError) }
-  end
-
-end

data/spec/lib/fat_zebra/web_hook_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe FatZebra::WebHook do
-
-  let(:valid_web_hook_payload) {{
-    events:    '*',
-    mode:      'Test',
-    name:      'test hook',
-    address:   'http://stage.example.com.au/v1/api/hook_listener'
-  }}
-
-  describe '.create', :vcr do
-    subject(:web_hook) { FatZebra::WebHook.create(valid_web_hook_payload) }
-
-    it { is_expected.to be_accepted }
-    it { expect(web_hook.name).to eq('test hook') }
-    it { expect(web_hook.id).to_not be_empty }
-
-    context 'validations' do
-      let(:valid_web_hook_payload) {{}}
-
-      it { expect{ web_hook }.to raise_error(FatZebra::RequestValidationError) }
-    end
-  end
-
-  describe '.search', :vcr do
-    subject(:web_hooks) { FatZebra::WebHook.search }
-
-    before { 2.times { |i| FatZebra::WebHook.create(valid_web_hook_payload) } }
-
-    it { is_expected.to be_accepted }
-    it { expect(web_hooks.data.count).to be >= 2 }
-  end
-
-  describe '#update', :vcr do
-    subject(:web_hook) { FatZebra::WebHook.create(valid_web_hook_payload) }
-    before { web_hook.update(name: 'New Test hook')}
-
-    it { is_expected.to be_accepted }
-    it { expect(web_hook.name).to eq('New Test hook') }
-  end
-
-  describe '.delete', :vcr do
-    let(:create) { FatZebra::WebHook.create(valid_web_hook_payload) }
-    subject(:web_hook) { FatZebra::WebHook.delete(create.id) }
-
-    it { is_expected.to be_accepted }
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,53 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'rspec'
-require 'vcr'
-require 'webmock/rspec'
-require 'date'
-
-require 'fat_zebra'
-
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-##
-# Remove ID from the URL
-uri_ignoring_trailing_id = lambda do |request_1, request_2|
-  uri1, uri2 = request_1.uri, request_2.uri
-  regexp_trail_id = %r(/\d+\-[A-Z]\-.*\/)
-  regexp_trail_id = uri1.match(regexp_trail_id) ? regexp_trail_id : %r(/\d+\-[A-Z]\-.*\z)
-  if uri1.match(regexp_trail_id)
-    r1_without_id = uri1.gsub(regexp_trail_id, "")
-    r2_without_id = uri2.gsub(regexp_trail_id, "")
-    uri1.match(regexp_trail_id) && uri2.match(regexp_trail_id) && r1_without_id == r2_without_id
-  else
-    VCR.request_matchers.uri_without_param(:to, :from)
-  end
-end
-
-VCR.configure do |config|
-  config.cassette_library_dir = 'spec/cassettes'
-  config.hook_into :webmock
-  config.configure_rspec_metadata!
-  config.allow_http_connections_when_no_cassette = true
-  config.default_cassette_options = { match_requests_on: [:method, :query, uri_ignoring_trailing_id] }
-end
-
-RSpec.configure do |config|
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-  config.mock_with :rspec
-
-  config.include_context 'payloads'
-
-  config.before(:each) do
-    FatZebra.configure do |config|
-      config.username  = 'TEST'
-      config.token     = 'TEST'
-      config.gateway   = :sandbox
-      config.test_mode = true
-    end
-  end
-
-end

data/spec/support/payloads.rb

@@ -1,178 +0,0 @@
-require 'rspec'
-
-shared_context 'payloads' do
-
-  let(:valid_purchase_payload) {{
-    amount:      10000,
-    card_holder: 'Matthew Savage',
-    card_number: '5123456789012346',
-    card_expiry: DateTime.new(2030, 2, 3).strftime('%m/%Y'),
-    cvv:         123,
-    reference:   SecureRandom.hex,
-    customer_ip: '1.2.3.4'
-  }}
-
-  let(:valid_credit_card_payload) {{
-    card_holder: 'Matthew Savage',
-    card_number: '5123456789012346',
-    card_expiry: DateTime.new(2030, 2, 3).strftime('%m/%Y'),
-    cvv:         123
-  }}
-
-  let(:customer_valid_payload) {{
-    first_name: 'Harrold',
-    last_name:  'Humphries',
-    reference:  SecureRandom.hex,
-    email:      'hhump@test.com',
-    ip_address: '180.200.33.181',
-    card: {
-        card_holder: 'Harrold Humphries Senior',
-        card_number: '5123456789012346',
-        expiry_date: '05/2023',
-        cvv:         '123'
-    },
-    address: {
-        address:  '1 Harriet Road',
-        city:     'Kooliablin',
-        state:    'NSW',
-        postcode: '2222',
-        country:  'Australia'
-    }
-  }}
-
-  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',
-      reference_id: SecureRandom.hex,
-
-      merchant_name: 'TEST',
-      merchant_new_customer: true,
-      preorder: 1,
-
-      http_accept: 'text/html',
-      http_user_agent: 'Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0',
-
-      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