braintree-rails 1.3.0 → 1.4.0

data/spec/unit/braintree_rails/plan_spec.rb

@@ -10,9 +10,9 @@ describe BraintreeRails::Plan do
       braintree_plan = Braintree::Plan.all.find { |p| p.id == 'plan_id' }
       plan = BraintreeRails::Plan.new(braintree_plan)
 
-      plan.should be_persisted
+      expect(plan).to be_persisted
       BraintreeRails::Plan.attributes.each do |attribute|
-        plan.send(attribute).should == braintree_plan.send(attribute)
+        expect(plan.send(attribute)).to eq(braintree_plan.send(attribute))
       end
     end
 
@@ -20,9 +20,9 @@ describe BraintreeRails::Plan do
       braintree_plan = Braintree::Plan.all.find { |p| p.id == 'plan_id' }
       plan = BraintreeRails::Plan.find('plan_id')
 
-      plan.should be_persisted
+      expect(plan).to be_persisted
       BraintreeRails::Plan.attributes.each do |attribute|
-        plan.send(attribute).should == braintree_plan.send(attribute)
+        expect(plan.send(attribute)).to eq(braintree_plan.send(attribute))
       end
     end
   end
@@ -32,8 +32,8 @@ describe BraintreeRails::Plan do
       braintree_plans = Braintree::Plan.all
       plans = BraintreeRails::Plan.all
 
-      plans.should respond_to(:each)
-      plans.size.should == braintree_plans.size
+      expect(plans).to respond_to(:each)
+      expect(plans.size).to eq(braintree_plans.size)
     end
   end
 
@@ -43,8 +43,8 @@ describe BraintreeRails::Plan do
         braintree_plan = Braintree::Plan.all.find { |p| p.id == 'plan_id' }
         plan = BraintreeRails::Plan.new(braintree_plan)
 
-        plan.send(association).should respond_to(:each)
-        plan.send(association).size.should == braintree_plan.send(association).size
+        expect(plan.send(association)).to respond_to(:each)
+        expect(plan.send(association).size).to eq(braintree_plan.send(association).size)
       end
     end
   end
@@ -62,14 +62,14 @@ describe BraintreeRails::Plan do
         search.plan_id.is 'plan_id'
       end.to_a
 
-      plan.subscriptions.should respond_to(:each)
-      plan.subscriptions.size.should == braintree_subscriptions.size
+      expect(plan.subscriptions).to respond_to(:each)
+      expect(plan.subscriptions.size).to eq(braintree_subscriptions.size)
     end
 
     it 'can build new subscription' do
       plan = BraintreeRails::Plan.new('plan_id')
       subscription = plan.subscriptions.build
-      subscription.plan_id.should == plan.id
+      expect(subscription.plan_id).to eq(plan.id)
     end
   end
-end
+end

data/spec/unit/braintree_rails/subscription_spec.rb

@@ -10,10 +10,10 @@ describe BraintreeRails::Subscription do
       subscription = BraintreeRails::Subscription.new('subscription_id')
       braintree_subscription = Braintree::Subscription.find('subscription_id')
 
-      subscription.should be_persisted
-      subscription.never_expires?.should == braintree_subscription.never_expires?
+      expect(subscription).to be_persisted
+      expect(subscription.never_expires?).to eq(braintree_subscription.never_expires?)
       BraintreeRails::Subscription.attributes.each do |attribute|
-        subscription.send(attribute).should == braintree_subscription.send(attribute) if braintree_subscription.respond_to?(attribute)
+        expect(subscription.send(attribute)).to eq(braintree_subscription.send(attribute)) if braintree_subscription.respond_to?(attribute)
       end
     end
 
@@ -21,27 +21,27 @@ describe BraintreeRails::Subscription do
       braintree_subscription = Braintree::Subscription.find('subscription_id')
       subscription = BraintreeRails::Subscription.new(braintree_subscription)
 
-      subscription.should be_persisted
+      expect(subscription).to be_persisted
       BraintreeRails::Subscription.attributes.each do |attribute|
-        subscription.send(attribute).should == braintree_subscription.send(attribute) if braintree_subscription.respond_to?(attribute)
+        expect(subscription.send(attribute)).to eq(braintree_subscription.send(attribute)) if braintree_subscription.respond_to?(attribute)
       end
     end
 
     it 'should extract values from hash' do
       subscription = BraintreeRails::Subscription.new(:id => 'new_id')
 
-      subscription.should_not be_persisted
-      subscription.id.should == 'new_id'
+      expect(subscription).to_not be_persisted
+      expect(subscription.id).to eq('new_id')
     end
 
     it 'should try to extract value from other types' do
       subscription = BraintreeRails::Subscription.new(OpenStruct.new(:id => 'foobar', :persisted? => true))
 
-      subscription.should be_persisted
-      subscription.id.should == 'foobar'
+      expect(subscription).to be_persisted
+      expect(subscription.id).to eq('foobar')
 
       subscription = BraintreeRails::Subscription.new(OpenStruct.new)
-      subscription.should_not be_persisted
+      expect(subscription).to_not be_persisted
     end
   end
 
@@ -49,136 +49,136 @@ describe BraintreeRails::Subscription do
     it 'should validate id' do
       subscription = BraintreeRails::Subscription.new
       subscription.valid?
-      subscription.errors[:id].should be_blank
+      expect(subscription.errors[:id]).to be_blank
 
       subscription = BraintreeRails::Subscription.new(:id => '@#$%')
       subscription.valid?
-      subscription.errors[:id].should_not be_blank
+      expect(subscription.errors[:id]).to_not be_blank
     end
 
     it 'should billing_day_of_month' do
       subscription = BraintreeRails::Subscription.new
       subscription.valid?
-      subscription.errors[:billing_day_of_month].should be_blank
+      expect(subscription.errors[:billing_day_of_month]).to be_blank
 
       [*(1..28), 31].each do |valid_day|
         subscription = BraintreeRails::Subscription.new(:billing_day_of_month => valid_day)
         subscription.valid?
-        subscription.errors[:billing_day_of_month].should be_blank
+        expect(subscription.errors[:billing_day_of_month]).to be_blank
       end
 
       [29, 30, 'foo'].each do |invalid_day|
         subscription = BraintreeRails::Subscription.new(:billing_day_of_month => invalid_day)
         subscription.valid?
-        subscription.errors[:billing_day_of_month].should_not be_blank
+        expect(subscription.errors[:billing_day_of_month]).to_not be_blank
       end
     end
 
     it 'should validate numericality of number_of_billing_cycles' do
       subscription = BraintreeRails::Subscription.new(:number_of_billing_cycles => 'foobar')
       subscription.valid?
-      subscription.errors[:number_of_billing_cycles].should_not be_blank
+      expect(subscription.errors[:number_of_billing_cycles]).to_not be_blank
 
       [123, '123', nil].each do |valid_number|
         subscription = BraintreeRails::Subscription.new(:number_of_billing_cycles => valid_number)
         subscription.valid?
-        subscription.errors[:number_of_billing_cycles].should be_blank
+        expect(subscription.errors[:number_of_billing_cycles]).to be_blank
       end
 
       [123.45, '123.45', 'foo'].each do |invalid_number|
         subscription = BraintreeRails::Subscription.new(:number_of_billing_cycles => 'foo')
         subscription.valid?
-        subscription.errors[:number_of_billing_cycles].should_not be_blank
+        expect(subscription.errors[:number_of_billing_cycles]).to_not be_blank
       end
     end
 
     it 'should validate number_of_billing_cycles is greater than current_billing_cycle' do
       subscription = BraintreeRails::Subscription.new(:number_of_billing_cycles => '2', :current_billing_cycle => '1')
       subscription.valid?
-      subscription.errors[:number_of_billing_cycles].should be_blank
+      expect(subscription.errors[:number_of_billing_cycles]).to be_blank
 
       subscription = BraintreeRails::Subscription.new(:number_of_billing_cycles => '2', :current_billing_cycle => '3')
       subscription.valid?
-      subscription.errors[:number_of_billing_cycles].should_not be_blank
+      expect(subscription.errors[:number_of_billing_cycles]).to_not be_blank
     end
 
     it 'should validate precence of payment_method_token if new_record?' do
       subscription = BraintreeRails::Subscription.new
       subscription.valid?
-      subscription.errors[:payment_method_token].should_not be_blank
+      expect(subscription.errors[:payment_method_token]).to_not be_blank
 
       subscription = BraintreeRails::Subscription.new(:payment_method_token => 'token')
       subscription.valid?
-      subscription.errors[:payment_method_token].should be_blank
+      expect(subscription.errors[:payment_method_token]).to be_blank
     end
 
     it 'should validate precence of plan_id if new_record?' do
       subscription = BraintreeRails::Subscription.new
       subscription.valid?
-      subscription.errors[:plan_id].should_not be_blank
+      expect(subscription.errors[:plan_id]).to_not be_blank
 
       subscription = BraintreeRails::Subscription.new(:plan_id => 'plan_id')
       subscription.valid?
-      subscription.errors[:plan_id].should be_blank
+      expect(subscription.errors[:plan_id]).to be_blank
     end
 
     it 'should validate numericality of price' do
       subscription = BraintreeRails::Subscription.new(:price => 'foobar')
       subscription.valid?
-      subscription.errors[:price].should_not be_blank
+      expect(subscription.errors[:price]).to_not be_blank
 
       [123, 123.45, '123', '123.45', nil].each do |valid_price|
         subscription = BraintreeRails::Subscription.new(:price => valid_price)
         subscription.valid?
-        subscription.errors[:price].should be_blank
+        expect(subscription.errors[:price]).to be_blank
       end
 
       subscription = BraintreeRails::Subscription.new(:price => 'foo')
       subscription.valid?
-      subscription.errors[:price].should_not be_blank
+      expect(subscription.errors[:price]).to_not be_blank
     end
 
     it 'should validate numericality of trial_duration if trial_period' do
       subscription = BraintreeRails::Subscription.new(:trial_duration => 'foobar')
       subscription.valid?
-      subscription.errors[:trial_duration].should be_blank
+      expect(subscription.errors[:trial_duration]).to be_blank
 
       subscription = BraintreeRails::Subscription.new(:trial_duration => 'foobar', :trial_period => true)
       subscription.valid?
-      subscription.errors[:trial_duration].should_not be_blank
+      expect(subscription.errors[:trial_duration]).to_not be_blank
 
       [1, 9999, '123'].each do |valid_duration|
         subscription = BraintreeRails::Subscription.new(:trial_duration => valid_duration, :trial_period => true)
         subscription.valid?
-        subscription.errors[:trial_duration].should be_blank
+        expect(subscription.errors[:trial_duration]).to be_blank
       end
 
       [0, 10000, 1.23, nil].each do |invalid_duration|
         subscription = BraintreeRails::Subscription.new(:trial_duration => invalid_duration, :trial_period => true)
         subscription.valid?
-        subscription.errors[:trial_duration].should_not be_blank
+        expect(subscription.errors[:trial_duration]).to_not be_blank
       end
     end
 
     it 'should validate trial_duration_unit if trial_period' do
       subscription = BraintreeRails::Subscription.new(:trial_duration_unit => 'foobar')
       subscription.valid?
-      subscription.errors[:trial_duration_unit].should be_blank
+      expect(subscription.errors[:trial_duration_unit]).to be_blank
 
       subscription = BraintreeRails::Subscription.new(:trial_duration_unit => 'foobar', :trial_period => true)
       subscription.valid?
-      subscription.errors[:trial_duration_unit].should_not be_blank
+      expect(subscription.errors[:trial_duration_unit]).to_not be_blank
 
       ['day', 'month'].each do |valid_unit|
         subscription = BraintreeRails::Subscription.new(:trial_duration_unit => valid_unit, :trial_period => true)
         subscription.valid?
-        subscription.errors[:trial_duration_unit].should be_blank
+        expect(subscription.errors[:trial_duration_unit]).to be_blank
       end
 
       ["", "foo", nil].each do |invalid_duration|
         subscription = BraintreeRails::Subscription.new(:trial_duration_unit => invalid_duration, :trial_period => true)
         subscription.valid?
-        subscription.errors[:trial_duration_unit].should_not be_blank
+        expect(subscription.errors[:trial_duration_unit]).to_not be_blank
       end
     end
 
@@ -186,13 +186,13 @@ describe BraintreeRails::Subscription do
       [Date.today, Date.tomorrow, Date.tomorrow.to_s, nil].each do |valid_date|
         subscription = BraintreeRails::Subscription.new(:first_billing_date => valid_date)
         subscription.valid?
-        subscription.errors[:first_billing_date].should be_blank
+        expect(subscription.errors[:first_billing_date]).to be_blank
       end
 
       [Date.yesterday, "invalid date"].each do |invalid_date|
         subscription = BraintreeRails::Subscription.new(:first_billing_date => invalid_date)
         subscription.valid?
-        subscription.errors[:first_billing_date].should_not be_blank
+        expect(subscription.errors[:first_billing_date]).to_not be_blank
       end
     end
   end
@@ -202,7 +202,7 @@ describe BraintreeRails::Subscription do
       subscription = BraintreeRails::Subscription.new('subscription_id')
       braintree_subscription = Braintree::Subscription.find('subscription_id')
       stub_braintree_request(:get, '/plans', :body => fixture('plans.xml'))
-      subscription.plan.id.should == braintree_subscription.plan_id
+      expect(subscription.plan.id).to eq(braintree_subscription.plan_id)
     end
   end
 
@@ -210,8 +210,8 @@ describe BraintreeRails::Subscription do
     it 'should load credit_card from payment_method_token' do
       subscription = BraintreeRails::Subscription.new('subscription_id')
       braintree_subscription = Braintree::Subscription.find('subscription_id')
-      stub_braintree_request(:get, '/payment_methods/credit_card_id', :body => fixture('credit_card.xml'))
-      subscription.credit_card.token.should == braintree_subscription.payment_method_token
+      stub_braintree_request(:get, '/payment_methods/credit_card/credit_card_id', :body => fixture('credit_card.xml'))
+      expect(subscription.credit_card.token).to eq(braintree_subscription.payment_method_token)
     end
   end
 
@@ -221,8 +221,8 @@ describe BraintreeRails::Subscription do
         braintree_subscription = Braintree::Subscription.find('subscription_id')
         subscription = BraintreeRails::Subscription.new(braintree_subscription)
 
-        subscription.send(association).should respond_to(:each)
-        subscription.send(association).size.should == braintree_subscription.send(association).size
+        expect(subscription.send(association)).to respond_to(:each)
+        expect(subscription.send(association).size).to eq(braintree_subscription.send(association).size)
       end
 
       it 'does not support create' do
@@ -241,43 +241,43 @@ describe BraintreeRails::Subscription do
     describe 'save, save!' do
       it 'should return true when saved' do
         subscription = BraintreeRails::Subscription.new(subscription_hash)
-        subscription.save.should be_true
-        subscription.should be_persisted
+        expect(subscription.save).to eq(true)
+        expect(subscription).to be_persisted
       end
 
       it 'should not throw error when not valid' do
         subscription = BraintreeRails::Subscription.new
-        subscription.save.should be_false
-        subscription.should_not be_persisted
+        expect(subscription.save).to eq(false)
+        expect(subscription).to_not be_persisted
       end
 
       it 'should return true when saved with bang' do
         subscription = BraintreeRails::Subscription.new(subscription_hash)
-        subscription.save!.should be_true
-        subscription.should be_persisted
+        expect(subscription.save!).to eq(true)
+        expect(subscription).to be_persisted
       end
 
       it 'should throw error when save invalid record with bang' do
         subscription = BraintreeRails::Subscription.new(:first_name => 'f' * 256)
         expect { subscription.save! }.to raise_error(BraintreeRails::RecordInvalid)
-        subscription.should_not be_persisted
+        expect(subscription).to_not be_persisted
       end
     end
 
     describe 'update_attributes, update_attributes!' do
       it 'should return true when update_attributes' do
         subscription = BraintreeRails::Subscription.new(Braintree::Subscription.find('subscription_id'))
-        subscription.update_attributes(:price => '10').should be_true
+        expect(subscription.update_attributes(:price => '10')).to eq(true)
       end
 
       it 'should not throw error when not valid' do
         subscription = BraintreeRails::Subscription.new(Braintree::Subscription.find('subscription_id'))
-        subscription.update_attributes(:price => 'f' * 256).should be_false
+        expect(subscription.update_attributes(:price => 'f' * 256)).to eq(false)
       end
 
       it 'should return true when update_attributesd with bang' do
         subscription = BraintreeRails::Subscription.new(Braintree::Subscription.find('subscription_id'))
-        subscription.update_attributes!(:price => '10').should be_true
+        expect(subscription.update_attributes!(:price => '10')).to eq(true)
       end
 
       it 'should throw error when update_attributes invalid record with bang' do
@@ -307,4 +307,4 @@ describe BraintreeRails::Subscription do
       end
     end
   end
-end
+end

data/spec/unit/braintree_rails/subscriptions_spec.rb

@@ -16,7 +16,7 @@ describe BraintreeRails::Subscriptions do
 
       subscriptions = BraintreeRails::Subscriptions.new(BraintreeRails::Plan.new('plan_id'))
 
-      subscriptions.map(&:id).sort.should == braintree_subscriptions.map(&:id).sort
+      expect(subscriptions.map(&:id).sort).to eq(braintree_subscriptions.map(&:id).sort)
     end
 
     it 'should load all subscriptions' do
@@ -25,7 +25,7 @@ describe BraintreeRails::Subscriptions do
 
       braintree_subscriptions = Braintree::Subscription.search
       subscriptions = BraintreeRails::Subscriptions.new(nil)
-      subscriptions.map(&:id).sort.should == braintree_subscriptions.map(&:id).sort
+      expect(subscriptions.map(&:id).sort).to eq(braintree_subscriptions.map(&:id).sort)
     end
   end
 
@@ -33,8 +33,7 @@ describe BraintreeRails::Subscriptions do
     it 'has no default options when loading all' do
       subscriptions = BraintreeRails::Subscriptions.new(nil)
       subscription = subscriptions.build
-      subscription.attributes.values.compact.should be_empty
+      expect(subscription.attributes.values.compact).to be_empty
     end
   end
-end
-
+end

data/spec/unit/braintree_rails/transaction_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '../unit_spec_helper'
 describe BraintreeRails::Transaction do
   before do
     stub_braintree_request(:get, '/customers/customer_id', :body => fixture('customer.xml'))
-    stub_braintree_request(:get, '/payment_methods/credit_card_id', :body => fixture('credit_card.xml'))
+    stub_braintree_request(:get, '/payment_methods/credit_card/credit_card_id', :body => fixture('credit_card.xml'))
     stub_braintree_request(:get, '/transactions/transactionid', :body => fixture('transaction.xml'))
   end
 
@@ -12,9 +12,9 @@ describe BraintreeRails::Transaction do
       braintree_transaction = Braintree::Transaction.find('transactionid')
       transaction = BraintreeRails::Transaction.new('transactionid')
 
-      transaction.should be_persisted
+      expect(transaction).to be_persisted
       [:amount, :created_at, :updated_at].each do |attribute|
-        transaction.send(attribute).should == braintree_transaction.send(attribute)
+        expect(transaction.send(attribute)).to eq(braintree_transaction.send(attribute))
       end
     end
 
@@ -22,28 +22,28 @@ describe BraintreeRails::Transaction do
       braintree_transaction = Braintree::Transaction.find('transactionid')
       transaction = BraintreeRails::Transaction.new(braintree_transaction)
 
-      transaction.should be_persisted
+      expect(transaction).to be_persisted
       [:amount, :created_at, :updated_at].each do |attribute|
-        transaction.send(attribute).should == braintree_transaction.send(attribute)
+        expect(transaction.send(attribute)).to eq(braintree_transaction.send(attribute))
       end
     end
 
     it 'should extract values from hash' do
       transaction = BraintreeRails::Transaction.new(:id => 'new_id')
 
-      transaction.should_not be_persisted
-      transaction.id.should == 'new_id'
+      expect(transaction).to_not be_persisted
+      expect(transaction.id).to eq('new_id')
     end
 
     it 'should try to extract value from other types' do
       transaction = BraintreeRails::Transaction.new(OpenStruct.new(:id => 'foobar', :amount => '10.00', :persisted? => true))
 
-      transaction.should be_persisted
-      transaction.id.should == 'foobar'
-      transaction.amount.should == '10.00'
+      expect(transaction).to be_persisted
+      expect(transaction.id).to eq('foobar')
+      expect(transaction.amount).to eq('10.00')
 
       transaction = BraintreeRails::Transaction.new(Object.new)
-      transaction.should_not be_persisted
+      expect(transaction).to_not be_persisted
     end
   end
 
@@ -51,12 +51,12 @@ describe BraintreeRails::Transaction do
     describe association do
       it "should load #{association} for persisted transaction" do
         transaction = BraintreeRails::Transaction.new('transactionid')
-        transaction.send(association).should be_persisted
+        expect(transaction.send(association)).to be_persisted
       end
 
       it "should keep #{association} nil if assigned nil value" do
         transaction = BraintreeRails::Transaction.new(association => nil)
-        transaction.send(association).should be_nil
+        expect(transaction.send(association)).to be_nil
       end
     end
   end
@@ -67,8 +67,8 @@ describe BraintreeRails::Transaction do
         braintree_transaction = Braintree::Transaction.find('transactionid')
         transaction = BraintreeRails::Transaction.new(braintree_transaction)
 
-        transaction.send(association).should respond_to(:each)
-        transaction.send(association).size.should == braintree_transaction.send(association).size
+        expect(transaction.send(association)).to respond_to(:each)
+        expect(transaction.send(association).size).to eq(braintree_transaction.send(association).size)
       end
     end
   end
@@ -77,63 +77,63 @@ describe BraintreeRails::Transaction do
     it 'should validate amount' do
       [nil, 'abc', -1].each do |invalid_value|
         transaction = BraintreeRails::Transaction.new(:amount => invalid_value)
-        transaction.should_not be_valid
-        transaction.errors[:amount].should_not be_blank
+        expect(transaction).to_not be_valid
+        expect(transaction.errors[:amount]).to_not be_blank
       end
 
       [10, 10.0, "10", "10.00"].each do |valid_value|
         transaction = BraintreeRails::Transaction.new(:amount => valid_value)
         transaction.valid?
-        transaction.errors[:amount].should be_blank
+        expect(transaction.errors[:amount]).to be_blank
       end
     end
 
     it 'should validate type' do
       ['refund', 'abc'].each do |invalid_value|
         transaction = BraintreeRails::Transaction.new(:type => invalid_value)
-        transaction.should_not be_valid
-        transaction.errors[:type].should_not be_blank
+        expect(transaction).to_not be_valid
+        expect(transaction.errors[:type]).to_not be_blank
       end
 
       ['sale', 'credit'].each do |valid_value|
         transaction = BraintreeRails::Transaction.new(:type => valid_value)
         transaction.valid?
-        transaction.errors[:type].should be_blank
+        expect(transaction.errors[:type]).to be_blank
       end
     end
 
     describe 'credit card' do
       it 'is valid if new credit card with valid billing address' do
         transaction = BraintreeRails::Transaction.new(:amount => 10, :billing => address_hash, :credit_card => credit_card_hash)
-        transaction.should be_valid
+        expect(transaction).to be_valid
 
         transaction = BraintreeRails::Transaction.new(:amount => 10, :credit_card => credit_card_hash)
-        transaction.should_not be_valid
+        expect(transaction).to_not be_valid
       end
 
       it 'is valid if credit card is persisted' do
         transaction = BraintreeRails::Transaction.new(:amount => 10, :credit_card => BraintreeRails::CreditCard.find('credit_card_id'))
-        transaction.should be_valid
+        expect(transaction).to be_valid
       end
 
       it 'is valid if customer has default credit card' do
         transaction = BraintreeRails::Transaction.new(:amount => 10, :customer => BraintreeRails::Customer.find('customer_id'))
-        transaction.should be_valid
+        expect(transaction).to be_valid
 
         transaction = BraintreeRails::Transaction.new(:amount => 10, :customer => customer_hash)
-        transaction.should_not be_valid
+        expect(transaction).to_not be_valid
       end
 
       it 'should not validate credit card if already persisted' do
         transaction = BraintreeRails::Transaction.new(OpenStruct.new(:amount => 10, :persisted? => true))
-        transaction.should be_valid
+        expect(transaction).to be_valid
       end
     end
   end
 
   describe '#attribute_for_create' do
     it 'should default type to sale' do
-      BraintreeRails::Transaction.new.send(:attributes_for, :create)[:type].should == 'sale'
+      expect(BraintreeRails::Transaction.new.send(:attributes_for, :create)[:type]).to eq('sale')
     end
   end
 
@@ -147,88 +147,100 @@ describe BraintreeRails::Transaction do
       credit_card = BraintreeRails::CreditCard.find('credit_card_id')
       transaction = BraintreeRails::Transaction.new(:amount => '10.00', :customer => customer, :credit_card => credit_card)
 
-      transaction.save.should be_true
-      transaction.status.should == Braintree::Transaction::Status::Authorized
+      expect(transaction.save).to eq(true)
+      expect(transaction.status).to eq(Braintree::Transaction::Status::Authorized)
     end
 
     it 'should create a sale transaction from new credit card' do
       transaction = BraintreeRails::Transaction.new(:amount => '10.00', :billing => address_hash, :credit_card => credit_card_hash)
       transaction.valid?
-      transaction.save.should be_true
-      transaction.status.should == Braintree::Transaction::Status::Authorized
+      expect(transaction.save).to eq(true)
+      expect(transaction.status).to eq(Braintree::Transaction::Status::Authorized)
     end
 
     it 'should clear encrypted attributes even when save failed' do
       transaction = BraintreeRails::Transaction.new(:amount => 'foo', :credit_card => credit_card_hash)
-      transaction.save.should be_false
-      transaction.credit_card.number.should be_blank
+      expect(transaction.save).to eq(false)
+      expect(transaction.credit_card.number).to be_blank
     end
 
     it 'should clear encrypted attributes after save' do
       transaction = BraintreeRails::Transaction.new(:amount => '10.00', :billing => address_hash, :credit_card => credit_card_hash)
       transaction.valid?
-      transaction.save.should be_true
-      transaction.credit_card.number.should be_blank
+      expect(transaction.save).to eq(true)
+      expect(transaction.credit_card.number).to be_blank
     end
 
     it 'should clear encrypted attributes' do
       transaction = BraintreeRails::Transaction.new(:credit_card => credit_card_hash)
       transaction.clear_encryped_attributes
-      transaction.credit_card.number.should be_blank
+      expect(transaction.credit_card.number).to be_blank
     end
 
     it 'should use default credit card of customer if credit_card is not specified' do
       customer = BraintreeRails::Customer.find('customer_id')
       transaction = BraintreeRails::Transaction.new(:amount => '10.00', :customer => customer)
-      transaction.save.should be_true
-      transaction.status.should == Braintree::Transaction::Status::Authorized
+      expect(transaction.save).to eq(true)
+      expect(transaction.status).to eq(Braintree::Transaction::Status::Authorized)
     end
 
     it "should be able to submit_for_settlement a authorized transaction" do
       transaction = BraintreeRails::Transaction.find('transactionid')
       stub_braintree_request(:put, "/transactions/#{transaction.id}/submit_for_settlement", :body => fixture('transaction.xml'))
-      transaction.submit_for_settlement.should be_true
+      expect(transaction.submit_for_settlement).to eq(true)
       transaction.status = Braintree::Transaction::Status::Settled
-      transaction.submit_for_settlement.should be_false
+      expect(transaction.submit_for_settlement).to eq(false)
     end
 
     it "should be able to refund a settled transaction" do
       transaction = BraintreeRails::Transaction.find('transactionid')
       transaction.status = Braintree::Transaction::Status::Settled
       stub_braintree_request(:post, "/transactions/#{transaction.id}/refund", :body => fixture('transaction.xml'))
-      transaction.refund.should be_true
+      expect(transaction.refund).to eq(true)
       transaction.status = Braintree::Transaction::Status::Authorized
-      transaction.refund.should be_false
+      expect(transaction.refund).to eq(false)
     end
 
     it "should be able to void a authorized transaction" do
       transaction = BraintreeRails::Transaction.find('transactionid')
       stub_braintree_request(:put, "/transactions/#{transaction.id}/void", :body => fixture('transaction.xml'))
-      transaction.void.should be_true
+      expect(transaction.void).to eq(true)
       transaction.status = Braintree::Transaction::Status::Settled
-      transaction.void.should be_false
+      expect(transaction.void).to eq(false)
     end
 
     it 'should show errors when trying to submit already voided transaction' do
       transaction = BraintreeRails::Transaction.find('transactionid')
       transaction.status = Braintree::Transaction::Status::Voided
-      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
 
       expect {transaction.submit_for_settlement!}.to raise_error(BraintreeRails::RecordInvalid)
     end
 
-    it 'should propergate api errors to credit card if any' do
+    it 'should propergate api errors to associations if any' do
       customer = BraintreeRails::Customer.find('customer_id')
       credit_card = BraintreeRails::CreditCard.find('credit_card_id')
-      transaction = BraintreeRails::Transaction.new(:amount => '10.00', :customer => customer, :credit_card => credit_card)
+      transaction = BraintreeRails::Transaction.new(:amount => '10.00', :customer => customer, :credit_card => credit_card, :billing => address_hash, :shipping => address_hash)
       stub_braintree_request(:post, '/transactions', :status => 422, :body => fixture('transaction_error.xml'))
       transaction.save
-      transaction.errors[:base].should == ["Credit card type is not accepted by this merchant account."]
-      transaction.credit_card.errors.full_messages.should == ["Number Credit card number is invalid."]
-      transaction.credit_card.errors[:number].first.code.should == "81715"
-      transaction.credit_card.errors[:number].first.message.should == "Credit card number is invalid."
-      transaction.credit_card.errors[:number].first.to_s.should == "Credit card number is invalid."
+      expect(transaction.credit_card.errors[:base][0].code).to eq("81725")
+      expect(transaction.credit_card.errors[:base][0].message).to eq("Credit card must include number, payment_method_nonce, or venmo_sdk_payment_method_code.")
+      expect(transaction.credit_card.errors[:base][0].to_s).to eq("Credit card must include number, payment_method_nonce, or venmo_sdk_payment_method_code.")
+
+      expect(transaction.errors[:merchant_account_id].first.code).to eq('91577')
+      expect(transaction.errors[:merchant_account_id].first.message).to eq("Merchant account does not support payment instrument.")
+      expect(transaction.errors[:merchant_account_id].first.to_s).to eq("Merchant account does not support payment instrument.")
+
+      credit_card_errors = [
+        "Number Credit card type is not accepted by this merchant account.",
+        "Number Credit card number is required.",
+        "Credit card must include number, payment_method_nonce, or venmo_sdk_payment_method_code."
+      ]
+      expect(transaction.credit_card.errors.full_messages.map(&:to_s)).to eq(credit_card_errors)
+
+      expect(transaction.billing.errors.full_messages.map(&:to_s)).to eq(["Postal code Postal code may contain no more than 9 letter or number characters."])
+      expect(transaction.shipping.errors.full_messages.map(&:to_s)).to eq(["Postal code Postal code may contain no more than 9 letter or number characters."])
     end
 
     it 'does not support update or destroy' do
@@ -236,4 +248,4 @@ describe BraintreeRails::Transaction do
       expect {BraintreeRails::Transaction.find('transactionid').destroy!}.to raise_error(BraintreeRails::NotSupportedApiException)
     end
   end
-end
+end