braintree-rails 1.3.0 → 1.4.0

data/spec/integration/braintree_rails/address_integration_spec.rb

@@ -13,7 +13,7 @@ describe 'Address Integration' do
     braintree_address = braintree_customer.addresses.first
 
     attributes.each do |key, value|
-      braintree_address.send(key).should == value
+      expect(braintree_address.send(key)).to eq(value)
     end
   end
 
@@ -24,14 +24,14 @@ describe 'Address Integration' do
 
     braintree_customer = Braintree::Customer.find(customer.id)
     braintree_address = braintree_customer.addresses.first
-    braintree_address.first_name.should == 'Foo'
+    expect(braintree_address.first_name).to eq('Foo')
 
     address.last_name = 'Bar'
     address.save!
 
     braintree_customer = Braintree::Customer.find(customer.id)
     braintree_address = braintree_customer.addresses.first
-    braintree_address.last_name.should == 'Bar'
+    expect(braintree_address.last_name).to eq('Bar')
   end
 
   it 'should be able to destroy existing address' do
@@ -39,11 +39,11 @@ describe 'Address Integration' do
     address = customer.addresses.create!(address_hash)
     address.destroy
     expect { Braintree::Address.find(customer.id, address.id) }.to raise_error(Braintree::NotFoundError)
-    address.should_not be_persisted
-    address.should be_frozen
+    expect(address).to_not be_persisted
+    expect(address).to be_frozen
 
     address = customer.addresses.create!(address_hash)
     BraintreeRails::Address.delete(customer.id, address.id)
     expect { Braintree::Address.find(customer.id, address.id) }.to raise_error(Braintree::NotFoundError)
   end
-end
+end

data/spec/integration/braintree_rails/credit_card_integration_spec.rb

@@ -12,11 +12,11 @@ describe 'Credit Card Integration' do
     credit_card = BraintreeRails::CreditCard.new(braintree_customer.credit_cards.first.token)
 
     attributes.except(:number, :cvv, :billing_address).each do |key, value|
-      credit_card.send(key).should == value
+      expect(credit_card.send(key)).to eq(value)
     end
 
     attributes[:billing_address].each do |key, value|
-      credit_card.billing_address.send(key).should == value
+      expect(credit_card.billing_address.send(key)).to eq(value)
     end
   end
 
@@ -27,12 +27,12 @@ describe 'Credit Card Integration' do
 
     braintree_credit_card = Braintree::CreditCard.find(credit_card.id)
     attributes.except(:number, :cvv, :billing_address).each do |key, value|
-      braintree_credit_card.send(key).should == value
+      expect(braintree_credit_card.send(key)).to eq(value)
     end
 
     braintree_address = braintree_credit_card.billing_address
     attributes[:billing_address].each do |key, value|
-      braintree_address.send(key).should == value
+      expect(braintree_address.send(key)).to eq(value)
     end
   end
 
@@ -42,8 +42,8 @@ describe 'Credit Card Integration' do
 
     credit_card.update_attributes!(:cardholder_name => 'Foo Bar', :number => '4111111111111111', :options => {:verify_card => true}, :billing_address => address_hash.merge(:postal_code => '56789'))
     braintree_credit_card = Braintree::CreditCard.find(credit_card.id)
-    braintree_credit_card.cardholder_name.should == 'Foo Bar'
-    braintree_credit_card.billing_address.postal_code.should == '56789'
+    expect(braintree_credit_card.cardholder_name).to eq('Foo Bar')
+    expect(braintree_credit_card.billing_address.postal_code).to eq('56789')
   end
 
   it 'should be able to update just expiration year' do
@@ -52,10 +52,10 @@ describe 'Credit Card Integration' do
 
     credit_card.update_attributes!(:cardholder_name => 'Foo Bar', :number => '4111111111111111', :options => {:verify_card => true}, :expiration_month => '07', :expiration_year => '2013', :billing_address => address_hash.merge(:postal_code => '56789'))
     braintree_credit_card = Braintree::CreditCard.find(credit_card.id)
-    braintree_credit_card.cardholder_name.should == 'Foo Bar'
-    braintree_credit_card.billing_address.postal_code.should == '56789'
-    braintree_credit_card.expiration_month.should == '07'
-    braintree_credit_card.expiration_year.should == '2013'
+    expect(braintree_credit_card.cardholder_name).to eq('Foo Bar')
+    expect(braintree_credit_card.billing_address.postal_code).to eq('56789')
+    expect(braintree_credit_card.expiration_month).to eq('07')
+    expect(braintree_credit_card.expiration_year).to eq('2013')
   end
 
   it 'should be able to update by expiration date' do
@@ -64,11 +64,11 @@ describe 'Credit Card Integration' do
 
     credit_card.update_attributes!(:cardholder_name => 'Foo Bar', :number => '4111111111111111', :options => {:verify_card => true}, :expiration_date => '08/2013', :billing_address => address_hash.merge(:postal_code => '56789'))
     braintree_credit_card = Braintree::CreditCard.find(credit_card.id)
-    braintree_credit_card.cardholder_name.should == 'Foo Bar'
-    braintree_credit_card.billing_address.postal_code.should == '56789'
-    braintree_credit_card.expiration_month.should == '08'
-    braintree_credit_card.expiration_year.should == '2013'
-    braintree_credit_card.expiration_date.should == '08/2013'
+    expect(braintree_credit_card.cardholder_name).to eq('Foo Bar')
+    expect(braintree_credit_card.billing_address.postal_code).to eq('56789')
+    expect(braintree_credit_card.expiration_month).to eq('08')
+    expect(braintree_credit_card.expiration_year).to eq('2013')
+    expect(braintree_credit_card.expiration_date).to eq('08/2013')
   end
 
   it 'should be able to destroy existing credit card' do
@@ -77,8 +77,8 @@ describe 'Credit Card Integration' do
 
     credit_card.destroy!
     expect { Braintree::CreditCard.find(credit_card.token) }.to raise_error(Braintree::NotFoundError)
-    credit_card.should_not be_persisted
-    credit_card.should be_frozen
+    expect(credit_card).to_not be_persisted
+    expect(credit_card).to be_frozen
   end
 
   it 'should be able to capture braintree api errors' do

data/spec/integration/braintree_rails/customer_integration_spec.rb

@@ -8,24 +8,24 @@ describe 'Customer Integration' do
   it 'should fetch customer from Braintree for given id' do
     braintree_customer = Braintree::Customer.create!(:first_name => 'Brain', :last_name => 'Tree')
     customer = BraintreeRails::Customer.new(braintree_customer.id)
-    customer.id.should == braintree_customer.id
-    customer.first_name.should == 'Brain'
-    customer.last_name.should == 'Tree'
-    customer.should be_persisted
+    expect(customer.id).to eq(braintree_customer.id)
+    expect(customer.first_name).to eq('Brain')
+    expect(customer.last_name).to eq('Tree')
+    expect(customer).to be_persisted
   end
 
   it 'should be able to create new customer' do
     customer = BraintreeRails::Customer.create(:first_name => 'Brain', :last_name => 'Tree')
     braintree_customer = Braintree::Customer.find(customer.id)
 
-    braintree_customer.first_name.should == 'Brain'
-    braintree_customer.last_name.should == 'Tree'
+    expect(braintree_customer.first_name).to eq('Brain')
+    expect(braintree_customer.last_name).to eq('Tree')
   end
 
   it 'should be able to create new customer with a credit card' do
     customer = BraintreeRails::Customer.create(:first_name => 'Brain', :last_name => 'Tree', :credit_card => credit_card_hash)
     braintree_customer = Braintree::Customer.find(customer.id)
-    braintree_customer.credit_cards.count.should == 1
+    expect(braintree_customer.credit_cards.count).to eq(1)
   end
 
   it 'should be able to update existing customer' do
@@ -33,8 +33,8 @@ describe 'Customer Integration' do
     customer.update_attributes!(:first_name => 'Foo', :last_name => 'Bar')
 
     braintree_customer = Braintree::Customer.find(customer.id)
-    braintree_customer.first_name.should == 'Foo'
-    braintree_customer.last_name.should == 'Bar'
+    expect(braintree_customer.first_name).to eq('Foo')
+    expect(braintree_customer.last_name).to eq('Bar')
   end
 
   it 'should be able to update existing customer with new credit card' do
@@ -42,35 +42,35 @@ describe 'Customer Integration' do
     customer.update_attributes!(:first_name => 'Foo', :last_name => 'Bar', :credit_card => credit_card_hash.merge(:cardholder_name => "FooBar"))
 
     braintree_customer = Braintree::Customer.find(customer.id)
-    braintree_customer.credit_cards.first.cardholder_name.should == "FooBar"
+    expect(braintree_customer.credit_cards.first.cardholder_name).to eq("FooBar")
   end
 
   it 'should be able to destroy existing customer' do
     customer = BraintreeRails::Customer.create!(:first_name => 'Brain', :last_name => 'Tree')
     customer.destroy
     expect { Braintree::Customer.find(customer.id) }.to raise_error(Braintree::NotFoundError)
-    customer.should_not be_persisted
-    customer.should be_frozen
+    expect(customer).to_not be_persisted
+    expect(customer).to be_frozen
   end
 
   it 'should not throw error when trying to destory an already destoryed customer' do
     customer = BraintreeRails::Customer.create!(:first_name => 'Brain', :last_name => 'Tree')
     customer.destroy
     expect { customer.destroy }.not_to raise_error()
-    customer.should_not be_persisted
-    customer.should be_frozen
+    expect(customer).to_not be_persisted
+    expect(customer).to be_frozen
   end
 
   it "should be able to reload the customer attributes" do
     customer = BraintreeRails::Customer.create!(:first_name => 'Brain', :last_name => 'Tree')
     customer.first_name = 'new name'
-    customer.reload.first_name.should == 'Brain'
+    expect(customer.reload.first_name).to eq('Brain')
   end
 
   it "should be able to reload associations" do
     customer = BraintreeRails::Customer.create!(:first_name => 'Brain', :last_name => 'Tree')
-    customer.credit_cards.should be_empty
+    expect(customer.credit_cards).to be_empty
     Braintree::CreditCard.create(credit_card_hash.merge(:customer_id => customer.id))
-    customer.reload.credit_cards.size.should == 1
+    expect(customer.reload.credit_cards.size).to eq(1)
   end
 end

data/spec/integration/braintree_rails/merchant_account_integration_spec.rb

@@ -4,34 +4,34 @@ describe 'MerchantAccount Integration' do
   it 'should fetch merchant account from Braintree for given id' do
     braintree_merchant_account = Braintree::MerchantAccount.find(BraintreeRails::Configuration.default_merchant_account_id)
     merchant_account = BraintreeRails::MerchantAccount.new(BraintreeRails::Configuration.default_merchant_account_id)
-    merchant_account.id.should == braintree_merchant_account.id
-    merchant_account.status.should == braintree_merchant_account.status
+    expect(merchant_account.id).to eq(braintree_merchant_account.id)
+    expect(merchant_account.status).to eq(braintree_merchant_account.status)
   end
 
   it 'can create sub merchant account' do
     merchant_account = BraintreeRails::MerchantAccount.create(merchant_account_hash)
-    merchant_account.should be_persisted
+    expect(merchant_account).to be_persisted
   end
 
   it 'does not consider merchant account persisted if rejected by Braintree' do
     merchant_account = BraintreeRails::MerchantAccount.create(merchant_account_hash.merge(:tos_accepted => 'false'))
-    merchant_account.should_not be_persisted
+    expect(merchant_account).to_not be_persisted
   end
 
   it 'sets validation errors properly to its associations' do
     merchant_account = BraintreeRails::MerchantAccount.create(merchant_account_hash.merge(:individual => {}, :funding => {}, :business => {:legal_name => "foo"}))
-    merchant_account.should_not be_persisted
-    merchant_account.individual.errors.should_not be_empty
-    merchant_account.funding.errors.should_not be_empty
-    merchant_account.business.errors.should_not be_empty
+    expect(merchant_account).to_not be_persisted
+    expect(merchant_account.individual.errors).to_not be_empty
+    expect(merchant_account.funding.errors).to_not be_empty
+    expect(merchant_account.business.errors).to_not be_empty
   end
 
   it 'can update the submerchant account' do
     individual = merchant_account_hash[:individual].merge(:first_name => "foo")
     merchant_account = BraintreeRails::MerchantAccount.create(merchant_account_hash.merge(:individual => individual))
-    merchant_account.should be_persisted
-    merchant_account.individual.first_name.should == "foo"
+    expect(merchant_account).to be_persisted
+    expect(merchant_account.individual.first_name).to eq("foo")
     merchant_account.update_attributes(:individual => {:first_name => "bar"})
-    merchant_account.individual.first_name.should == "bar"
+    expect(merchant_account.individual.first_name).to eq("bar")
   end
 end

data/spec/integration/braintree_rails/transaction_integration_spec.rb

@@ -6,19 +6,18 @@ describe 'Transaction Integration' do
   end
 
   it 'should be able to create, submit, void transactions for a customer' do
-
     braintree_customer = Braintree::Customer.create!(customer_hash.merge(:credit_card => credit_card_hash))
     customer = BraintreeRails::Customer.new(braintree_customer)
 
     transaction = BraintreeRails::Transaction.create!(:customer => customer, :amount => (1..5).to_a.sample)
-    transaction.should be_persisted
-    transaction.status.should == Braintree::Transaction::Status::Authorized
+    expect(transaction).to be_persisted
+    expect(transaction.status).to eq(Braintree::Transaction::Status::Authorized)
 
     transaction.submit_for_settlement!
-    transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
+    expect(transaction.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
 
     transaction.void!
-    transaction.status.should == Braintree::Transaction::Status::Voided
+    expect(transaction.status).to eq(Braintree::Transaction::Status::Voided)
   end
 
   it 'should be able to create, submit, void transactions for a customer with a credit_card' do
@@ -27,14 +26,14 @@ describe 'Transaction Integration' do
     credit_card = customer.credit_cards.first
 
     transaction = BraintreeRails::Transaction.create!(:customer => customer, :amount => (1..5).to_a.sample, :credit_card => credit_card)
-    transaction.should be_persisted
-    transaction.status.should == Braintree::Transaction::Status::Authorized
+    expect(transaction).to be_persisted
+    expect(transaction.status).to eq(Braintree::Transaction::Status::Authorized)
 
     transaction.submit_for_settlement!
-    transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
+    expect(transaction.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
 
     transaction.void!
-    transaction.status.should == Braintree::Transaction::Status::Voided
+    expect(transaction.status).to eq(Braintree::Transaction::Status::Voided)
   end
 
 
@@ -44,11 +43,11 @@ describe 'Transaction Integration' do
     credit_card = customer.credit_cards.first
     transaction = BraintreeRails::Transaction.create!(:amount => (1..10).to_a.sample, :customer => customer)
 
-    customer.transactions.length.should == 1
+    expect(customer.transactions.length).to eq(1)
     customer.transactions.each do |t|
-     t.should == transaction
+     expect(t).to eq(transaction)
     end
-    credit_card.transactions.count.should == 1
+    expect(credit_card.transactions.count).to eq(1)
   end
 
   it "should be able to load all transactions for a given customer" do
@@ -56,19 +55,19 @@ describe 'Transaction Integration' do
     customer = BraintreeRails::Customer.new(braintree_customer)
     credit_card1 = customer.credit_cards.create!(credit_card_hash.merge(:token => nil))
     credit_card2 = customer.credit_cards.create!(credit_card_hash.merge(:token => nil))
-    customer.credit_cards.size.should == 2
+    expect(customer.credit_cards.size).to eq(2)
 
     transaction1 = BraintreeRails::Transaction.create!(:amount => (1..10).to_a.sample, :customer => customer, :credit_card => credit_card1)
     transaction2 = BraintreeRails::Transaction.create!(:amount => (1..10).to_a.sample, :customer => customer, :credit_card => credit_card2)
-    customer.transactions.size.should == 2
+    expect(customer.transactions.size).to eq(2)
   end
 
   it 'should be able to create a one time transaction' do
     transaction = BraintreeRails::Transaction.create!(:amount => (1..10).to_a.sample, :billing => address_hash, :customer => customer_hash, :credit_card => credit_card_hash)
-    transaction.should be_persisted
-    transaction.id.should_not be_blank
-    transaction.customer.should_not be_blank
-    transaction.credit_card.should_not be_blank
+    expect(transaction).to be_persisted
+    expect(transaction.id).to_not be_blank
+    expect(transaction.customer).to_not be_blank
+    expect(transaction.credit_card).to_not be_blank
   end
 
   it 'should be able to capture braintree api errors' do
@@ -78,8 +77,8 @@ describe 'Transaction Integration' do
     transaction = BraintreeRails::Transaction.create!(:amount => (1..10).to_a.sample, :customer => customer)
 
     transaction.void!
-    transaction.submit_for_settlement.should be_false
-    transaction.errors[:status].should_not be_blank
+    expect(transaction.submit_for_settlement).to eq(false)
+    expect(transaction.errors[:status]).to_not be_blank
   end
 
   describe BraintreeRails::Transactions do
@@ -90,8 +89,8 @@ describe 'Transaction Integration' do
         credit_card = customer.default_credit_card
 
         transaction = BraintreeRails::Transactions.new(customer).create!(:amount => (1..10).to_a.sample)
-        transaction.customer.should == customer
-        transaction.credit_card.should == credit_card
+        expect(transaction.customer).to eq(customer)
+        expect(transaction.credit_card).to eq(credit_card)
       end
 
       it 'can use default credit_card to build new record' do
@@ -100,7 +99,7 @@ describe 'Transaction Integration' do
         credit_card = customer.default_credit_card
 
         transaction = BraintreeRails::Transactions.new(credit_card).create!(:amount => (1..10).to_a.sample)
-        transaction.credit_card.should == credit_card
+        expect(transaction.credit_card).to eq(credit_card)
       end
     end
 
@@ -109,10 +108,10 @@ describe 'Transaction Integration' do
         customer = BraintreeRails::Customer.create!(customer_hash.merge(:credit_card => credit_card_hash))
         credit_card = customer.credit_cards.create!(credit_card_hash.merge(:token => 'card_1'))
         transactions = customer.transactions
-        transactions.should be_empty
+        expect(transactions).to be_empty
 
         transaction = BraintreeRails::Transaction.create!(:amount => (1..10).to_a.sample, :customer => customer, :credit_card => credit_card)
-        transactions.reload.size.should == 1
+        expect(transactions.reload.size).to eq(1)
       end
     end
   end

data/spec/integration/integration_spec_helper.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require 'yaml'
 SimpleCov.command_name "spec:integration"
 
 config = File.join(SPEC_PATH, 'config/braintree_auth.yml')
@@ -9,7 +10,7 @@ if File.exist?(config) && auth = YAML.load_file(config)
   BraintreeRails::Configuration.private_key = auth['private_key']
   BraintreeRails::Configuration.default_merchant_account_id = auth['default_merchant_account_id']
   # BraintreeRails::Configuration.logger = Logger.new('log/braintree.log')
-elsif ENV["TRAVIS_SECURE_ENV_VARS"] == "true" && ENV["TRAVIS_RUBY_VERSION"] == "2.0.0"
+elsif ENV["TRAVIS_SECURE_ENV_VARS"] == "true" && ENV["TRAVIS_RUBY_VERSION"] == "2.1.2"
   BraintreeRails::Configuration.environment = :sandbox
   BraintreeRails::Configuration.merchant_id = ENV['merchant_id']
   BraintreeRails::Configuration.public_key = ENV['public_key']

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '../lib/test_env'))
+I18n.enforce_available_locales = false
 
 SPEC_PATH = File.expand_path(File.dirname(__FILE__))
 FIXTURE_PATH = File.join(SPEC_PATH, 'fixtures')

data/spec/support/helper.rb

@@ -4,8 +4,22 @@ module Helper
   end
 
   def stub_braintree_request(method, path, response)
-    response = response.reverse_merge(:headers => {'Content-Type' => ['application/xml', 'charset=utf-8'], 'Content-Encoding' => 'gzip'})
-    stub_request(method, BraintreeBaseUri+path).to_return(response)
+    configuration = Braintree::Configuration.instantiate
+    request_header = {
+      :headers => {
+        'Accept'=>'application/xml',
+        'Accept-Encoding'=>'gzip',
+        'User-Agent'=> configuration.user_agent,
+        'X-Apiversion'=> configuration.api_version
+      }
+    }
+    response_header = {
+      :headers => {
+        'Content-Type' => ['application/xml', 'charset=utf-8'],
+        'Content-Encoding' => 'gzip'
+      }
+    }
+    stub_request(method, BraintreeBaseUri+path).with(request_header).to_return(response.reverse_merge(response_header))
   end
 
   def address_hash

data/spec/unit/braintree_rails/add_on_spec.rb

@@ -10,10 +10,10 @@ describe BraintreeRails::AddOn do
       braintree_add_on = Braintree::AddOn.all.find { |a| a.id == 'add_on_id' }
       add_on = BraintreeRails::AddOn.new(braintree_add_on)
 
-      add_on.should be_persisted
-      add_on.never_expires?.should == braintree_add_on.never_expires?
+      expect(add_on).to be_persisted
+      expect(add_on.never_expires?).to eq(braintree_add_on.never_expires?)
       BraintreeRails::AddOn.attributes.each do |attribute|
-        add_on.send(attribute).should == braintree_add_on.send(attribute)
+        expect(add_on.send(attribute)).to eq(braintree_add_on.send(attribute))
       end
     end
 
@@ -21,9 +21,9 @@ describe BraintreeRails::AddOn do
       braintree_add_on = Braintree::AddOn.all.find { |a| a.id == 'add_on_id' }
       add_on = BraintreeRails::AddOn.new('add_on_id')
 
-      add_on.should be_persisted
+      expect(add_on).to be_persisted
       BraintreeRails::AddOn.attributes.each do |attribute|
-        add_on.send(attribute).should == braintree_add_on.send(attribute)
+        expect(add_on.send(attribute)).to eq(braintree_add_on.send(attribute))
       end
     end
 
@@ -31,9 +31,9 @@ describe BraintreeRails::AddOn do
       braintree_add_on = Braintree::AddOn.all.find { |a| a.id == 'add_on_id' }
       add_on = BraintreeRails::AddOn.find('add_on_id')
 
-      add_on.should be_persisted
+      expect(add_on).to be_persisted
       BraintreeRails::AddOn.attributes.each do |attribute|
-        add_on.send(attribute).should == braintree_add_on.send(attribute)
+        expect(add_on.send(attribute)).to eq(braintree_add_on.send(attribute))
       end
     end
   end
@@ -43,9 +43,8 @@ describe BraintreeRails::AddOn do
       braintree_add_ons = Braintree::AddOn.all
       add_ons = BraintreeRails::AddOn.all
 
-      add_ons.should respond_to(:each)
-      add_ons.size.should == braintree_add_ons.size
+      expect(add_ons).to respond_to(:each)
+      expect(add_ons.size).to eq(braintree_add_ons.size)
     end
   end
-end
-
+end