judopay 2.1.0 → 2.1.3

data/spec/judopay/apple_payment_spec.rb

@@ -1,80 +1,80 @@
-require 'spec_helper'
-require 'json'
-require_relative '../../lib/judopay/models/apple_payment'
-
-describe Judopay::ApplePayment do
-  it 'should create a new payment given pk_payment object' do
-    stub_post('/transactions/payments').
-      to_return(:status => 200,
-                :body => lambda { |_request| fixture('transactions/apple_payment.json') })
-
-    payment = build(:apple_payment)
-    response = payment.create
-
-    expect(response).to be_a(Hash)
-    expect(response.result).to eq('Success')
-  end
-
-  it 'should return a bad request exception if basic validation fails' do
-    expect(lambda do
-      Judopay::ApplePayment.new.create
-    end).to raise_error(Judopay::ValidationError)
-  end
-
-  it 'should use the configured Judo ID if one isn\'t provided in the payment request' do
-    stub_post('/transactions/payments').
-      to_return(:status => 200,
-                :body => lambda { |_request| fixture('transactions/apple_payment.json') })
-
-    Judopay.configure do |config|
-      config.judo_id = '123-456'
-    end
-
-    payment = build(:apple_payment, :judo_id => nil)
-    payment.create
-
-    expect(payment.valid?).to eq(true)
-    expect(payment.judo_id).to eq('123-456')
-  end
-
-  it 'properly coerces pk_payment field from_json' do
-    json_string = '{"pkPayment":{"token":{"paymentInstrumentName":"Visa XXXX","paymentNetwork":"Visa","paymentData"'\
-':{"version":"EC_v1","data":"SomeBase64encodedData","signature":"SomeBase64encodedData","header":{"ephemeralPublicKey"'\
-':"someKey","publicKeyHash":"someKey","transactionId":"someId"}}},"billingAddress":1,"shippingAddress":2}}'
-    pk_payment = Judopay::PkPayment.new(
-      :token => Judopay::PkPaymentToken.new(
-        :payment_instrument_name => 'Visa XXXX',
-        :payment_network => 'Visa',
-        :payment_data => {
-          'version' => 'EC_v1',
-          'data' => 'SomeBase64encodedData',
-          'signature' => 'SomeBase64encodedData',
-          'header' => {
-            'ephemeral_public_key' => 'someKey',
-            'public_key_hash' => 'someKey',
-            'transaction_id' => 'someId'
-          }
-        }
-      ),
-      :billing_address => '1',
-      :shipping_address => '2'
-    )
-
-    payment = build(:apple_payment, :pk_payment => json_string)
-    expect(payment.pk_payment).to be == pk_payment
-  end
-
-  it 'should raise an error when bad pk_payment passed' do
-    expect(lambda do
-      Judopay::ApplePayment.new(:pk_payment => '{"someInvalidJson}}')
-    end).to raise_error(Judopay::ValidationError, format(Judopay::PkPayment::WRONG_JSON_ERROR_MESSAGE, 'Judopay::PkPayment'))
-
-    expect(lambda do
-      Judopay::ApplePayment.new(:pk_payment => 1)
-    end).to raise_error(Judopay::ValidationError, format(Judopay::PkPayment::WRONG_OBJECT_ERROR_MESSAGE, 'Judopay::PkPayment'))
-
-    expect(lambda do
-      build(:apple_payment, :pk_payment => '{"valid_json":"Without token field"}').create
-    end).to raise_error(Judopay::ValidationError)
-  end
-end
+require 'spec_helper'
+require 'json'
+require_relative '../../lib/judopay/models/apple_payment'
+
+describe Judopay::ApplePayment do
+  it 'should create a new payment given pk_payment object' do
+    stub_post('/transactions/payments').
+      to_return(:status => 200,
+                :body => lambda { |_request| fixture('transactions/apple_payment.json') })
+
+    payment = build(:apple_payment)
+    response = payment.create
+
+    expect(response).to be_a(Hash)
+    expect(response.result).to eq('Success')
+  end
+
+  it 'should return a bad request exception if basic validation fails' do
+    expect(lambda do
+      Judopay::ApplePayment.new.create
+    end).to raise_error(Judopay::ValidationError)
+  end
+
+  it 'should use the configured Judo ID if one isn\'t provided in the payment request' do
+    stub_post('/transactions/payments').
+      to_return(:status => 200,
+                :body => lambda { |_request| fixture('transactions/apple_payment.json') })
+
+    Judopay.configure do |config|
+      config.judo_id = '123-456'
+    end
+
+    payment = build(:apple_payment, :judo_id => nil)
+    payment.create
+
+    expect(payment.valid?).to eq(true)
+    expect(payment.judo_id).to eq('123-456')
+  end
+
+  it 'properly coerces pk_payment field from_json' do
+    json_string = '{"pkPayment":{"token":{"paymentInstrumentName":"Visa XXXX","paymentNetwork":"Visa","paymentData"'\
+':{"version":"EC_v1","data":"SomeBase64encodedData","signature":"SomeBase64encodedData","header":{"ephemeralPublicKey"'\
+':"someKey","publicKeyHash":"someKey","transactionId":"someId"}}},"billingAddress":1,"shippingAddress":2}}'
+    pk_payment = Judopay::PkPayment.new(
+      :token => Judopay::PkPaymentToken.new(
+        :payment_instrument_name => 'Visa XXXX',
+        :payment_network => 'Visa',
+        :payment_data => {
+          'version' => 'EC_v1',
+          'data' => 'SomeBase64encodedData',
+          'signature' => 'SomeBase64encodedData',
+          'header' => {
+            'ephemeral_public_key' => 'someKey',
+            'public_key_hash' => 'someKey',
+            'transaction_id' => 'someId'
+          }
+        }
+      ),
+      :billing_address => '1',
+      :shipping_address => '2'
+    )
+
+    payment = build(:apple_payment, :pk_payment => json_string)
+    expect(payment.pk_payment).to be == pk_payment
+  end
+
+  it 'should raise an error when bad pk_payment passed' do
+    expect(lambda do
+      Judopay::ApplePayment.new(:pk_payment => '{"someInvalidJson}}')
+    end).to raise_error(Judopay::ValidationError, format(Judopay::PkPayment::WRONG_JSON_ERROR_MESSAGE, :foo => 'Judopay::PkPayment'))
+
+    expect(lambda do
+      Judopay::ApplePayment.new(:pk_payment => 1)
+    end).to raise_error(Judopay::ValidationError, format(Judopay::PkPayment::WRONG_OBJECT_ERROR_MESSAGE, :foo => 'Judopay::PkPayment'))
+
+    expect(lambda do
+      build(:apple_payment, :pk_payment => '{"valid_json":"Without token field"}').create
+    end).to raise_error(Judopay::ValidationError)
+  end
+end

data/spec/judopay/card_address_spec.rb

@@ -1,10 +1,10 @@
-require 'spec_helper'
-require_relative '../../lib/judopay/models/card_address'
-
-describe Judopay::CardAddress do
-  it "should not allow querying of the API if a resource path isn't set on the model" do
-    expect(lambda do
-      Judopay::CardAddress.all
-    end).to raise_error(Judopay::ValidationError)
-  end
-end
+require 'spec_helper'
+require_relative '../../lib/judopay/models/card_address'
+
+describe Judopay::CardAddress do
+  it "should not allow querying of the API if a resource path isn't set on the model" do
+    expect(lambda do
+      Judopay::CardAddress.all
+    end).to raise_error(Judopay::ValidationError)
+  end
+end

data/spec/judopay/card_payment_spec.rb

@@ -1,63 +1,51 @@
-require 'spec_helper'
-require_relative '../../lib/judopay/models/card_payment'
-
-describe Judopay::CardPayment do
-  it 'should create a new payment given valid card details' do
-    stub_post('/transactions/payments').
-      to_return(:status => 200,
-                :body => lambda { |_request| fixture('card_payments/create.json') })
-
-    payment = build(:card_payment)
-    response = payment.create
-
-    expect(response).to be_a(Hash)
-    expect(response.result).to eq('Success')
-  end
-
-  it 'should not create a new payment if the card is declined' do
-    stub_post('/transactions/payments').
-      to_return(:status => 200,
-                :body => lambda { |_request| fixture('card_payments/create_declined.json') })
-
-    payment = build(:card_payment)
-    payment.card_number = '4221690000004963' # Always declined
-    response = payment.create
-
-    expect(response).to be_a(Hash)
-    expect(response.result).to eq('Declined')
-  end
-
-  it 'should return a bad request exception if basic validation fails' do
-    expect(lambda do
-      Judopay::CardPayment.new.create
-    end).to raise_error(Judopay::ValidationError)
-  end
-
-  it "should use the configured Judo ID if one isn't provided in the payment request" do
-    stub_post('/transactions/payments').
-      to_return(:status => 200,
-                :body => lambda { |_request| fixture('card_payments/create.json') })
-
-    Judopay.configure do |config|
-      config.judo_id = '123-456'
-    end
-
-    payment = build(:card_payment, :judo_id => nil)
-    payment.create
-
-    expect(payment.valid?).to eq(true)
-    expect(payment.judo_id).to eq('123-456')
-  end
-
-  it 'should validate a new payment given valid card details' do
-    stub_post('/transactions/payments/validate').
-      to_return(:status => 200,
-                :body => lambda { |_request| fixture('card_payments/validate.json') })
-
-    payment = build(:card_payment)
-    response = payment.validate
-
-    expect(response).to be_a(Hash)
-    expect(response.error_message).to include('good to go') # API could give a more helpful response here
-  end
-end
+require 'spec_helper'
+require_relative '../../lib/judopay/models/card_payment'
+
+describe Judopay::CardPayment do
+  it 'should create a new payment given valid card details' do
+    stub_post('/transactions/payments').
+      to_return(:status => 200,
+                :body => lambda { |_request| fixture('card_payments/create.json') })
+
+    payment = build(:card_payment)
+    response = payment.create
+
+    expect(response).to be_a(Hash)
+    expect(response.result).to eq('Success')
+  end
+
+  it 'should not create a new payment if the card is declined' do
+    stub_post('/transactions/payments').
+      to_return(:status => 200,
+                :body => lambda { |_request| fixture('card_payments/create_declined.json') })
+
+    payment = build(:card_payment)
+    payment.card_number = '4221690000004963' # Always declined
+    response = payment.create
+
+    expect(response).to be_a(Hash)
+    expect(response.result).to eq('Declined')
+  end
+
+  it 'should return a bad request exception if basic validation fails' do
+    expect(lambda do
+      Judopay::CardPayment.new.create
+    end).to raise_error(Judopay::ValidationError)
+  end
+
+  it "should use the configured Judo ID if one isn't provided in the payment request" do
+    stub_post('/transactions/payments').
+      to_return(:status => 200,
+                :body => lambda { |_request| fixture('card_payments/create.json') })
+
+    Judopay.configure do |config|
+      config.judo_id = '123-456'
+    end
+
+    payment = build(:card_payment, :judo_id => nil)
+    payment.create
+
+    expect(payment.valid?).to eq(true)
+    expect(payment.judo_id).to eq('123-456')
+  end
+end

data/spec/judopay/card_preauth_spec.rb

@@ -1,35 +1,35 @@
-require 'spec_helper'
-require_relative '../../lib/judopay/models/card_preauth'
-
-describe Judopay::CardPreauth do
-  it 'should create a new preauth given valid card details' do
-    stub_post('/transactions/preauths').
-      to_return(:status => 200,
-                :body => lambda { |_request| fixture('card_payments/create.json') })
-
-    payment = build(:card_preauth)
-    response = payment.create
-
-    expect(response).to be_a(Hash)
-    expect(response.result).to eq('Success')
-  end
-
-  it 'should not create a new preauth if the card is declined' do
-    stub_post('/transactions/preauths').
-      to_return(:status => 200,
-                :body => lambda { |_request| fixture('card_payments/create_declined.json') })
-
-    payment = build(:card_payment)
-    payment.card_number = '4221690000004963' # Always declined
-    response = payment.create
-
-    expect(response).to be_a(Hash)
-    expect(response.result).to eq('Declined')
-  end
-
-  it 'should return a bad request exception if basic validation fails' do
-    expect(lambda do
-      Judopay::CardPreauth.new.create
-    end).to raise_error(Judopay::ValidationError)
-  end
-end
+require 'spec_helper'
+require_relative '../../lib/judopay/models/card_preauth'
+
+describe Judopay::CardPreauth do
+  it 'should create a new preauth given valid card details' do
+    stub_post('/transactions/preauths').
+      to_return(:status => 200,
+                :body => lambda { |_request| fixture('card_payments/create.json') })
+
+    payment = build(:card_preauth)
+    response = payment.create
+
+    expect(response).to be_a(Hash)
+    expect(response.result).to eq('Success')
+  end
+
+  it 'should not create a new preauth if the card is declined' do
+    stub_post('/transactions/preauths').
+      to_return(:status => 200,
+                :body => lambda { |_request| fixture('card_payments/create_declined.json') })
+
+    payment = build(:card_payment)
+    payment.card_number = '4221690000004963' # Always declined
+    response = payment.create
+
+    expect(response).to be_a(Hash)
+    expect(response.result).to eq('Declined')
+  end
+
+  it 'should return a bad request exception if basic validation fails' do
+    expect(lambda do
+      Judopay::CardPreauth.new.create
+    end).to raise_error(Judopay::ValidationError)
+  end
+end

data/spec/judopay/collection_spec.rb

@@ -1,26 +1,26 @@
-require 'spec_helper'
-require_relative '../../lib/judopay/models/collection'
-
-describe Judopay::Collection do
-  it 'should list all transactions' do
-    stub_get('/transactions/collections').
-      to_return(:status => 200,
-                :body => lambda { |_request| fixture('transactions/all.json') })
-
-    transactions = Judopay::Collection.all
-    expect(transactions).to be_a(Hash)
-    expect(transactions.results[0].amount).to eq(1.01)
-  end
-
-  it 'should create a new collection given a valid payment reference' do
-    stub_post('/transactions/collections').
-      to_return(:status => 200,
-                :body => lambda { |_request| fixture('card_payments/create.json') })
-
-    collection = build(:collection)
-    response = collection.create
-
-    expect(response).to be_a(Hash)
-    expect(response.result).to eq('Success')
-  end
-end
+require 'spec_helper'
+require_relative '../../lib/judopay/models/collection'
+
+describe Judopay::Collection do
+  it 'should list all transactions' do
+    stub_get('/transactions/collections').
+      to_return(:status => 200,
+                :body => lambda { |_request| fixture('transactions/all.json') })
+
+    transactions = Judopay::Collection.all
+    expect(transactions).to be_a(Hash)
+    expect(transactions.results[0].amount).to eq(1.01)
+  end
+
+  it 'should create a new collection given a valid payment reference' do
+    stub_post('/transactions/collections').
+      to_return(:status => 200,
+                :body => lambda { |_request| fixture('card_payments/create.json') })
+
+    collection = build(:collection)
+    response = collection.create
+
+    expect(response).to be_a(Hash)
+    expect(response.result).to eq('Success')
+  end
+end

data/spec/judopay/core_ext/hash_spec.rb

@@ -1,24 +1,24 @@
-require 'spec_helper'
-require_relative '../../../lib/judopay/core_ext/hash'
-
-describe Hash do
-  it 'should convert hash keys to camel case' do
-    original = {
-      'under_score' => 123,
-      'more_words_please' => 'value'
-    }
-    expected_result = {
-      'underScore' => 123,
-      'moreWordsPlease' => 'value'
-    }
-    expect(original.camel_case_keys!).to eq(expected_result)
-  end
-
-  it 'should convert a hash to a valid query string' do
-    original = {
-      'under_score' => 123,
-      'more_words_please' => 'value'
-    }
-    expect(original.to_query_string).to eq('more_words_please=value&under_score=123')
-  end
-end
+require 'spec_helper'
+require_relative '../../../lib/judopay/core_ext/hash'
+
+describe Hash do
+  it 'should convert hash keys to camel case' do
+    original = {
+      'under_score' => 123,
+      'more_words_please' => 'value'
+    }
+    expected_result = {
+      'underScore' => 123,
+      'moreWordsPlease' => 'value'
+    }
+    expect(original.camel_case_keys!).to eq(expected_result)
+  end
+
+  it 'should convert a hash to a valid query string' do
+    original = {
+      'under_score' => 123,
+      'more_words_please' => 'value'
+    }
+    expect(original.to_query_string).to eq('more_words_please=value&under_score=123')
+  end
+end