braintree-rails 1.3.0 → 1.4.0

data/spec/unit/braintree_rails/add_ons_spec.rb

@@ -11,12 +11,12 @@ describe BraintreeRails::AddOns do
       braintree_add_ons = braintree_plan.add_ons
       add_ons = BraintreeRails::AddOns.new(BraintreeRails::Plan.find('plan_id'))
 
-      add_ons.size.should == braintree_add_ons.size
+      expect(add_ons.size).to eq(braintree_add_ons.size)
 
       braintree_add_ons.each do |braintree_add_on|
         add_on = add_ons.find(braintree_add_on.id)
         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
@@ -30,4 +30,4 @@ describe BraintreeRails::AddOns do
       expect { add_ons.create }.to raise_error(BraintreeRails::NotSupportedApiException)
     end
   end
-end
+end

data/spec/unit/braintree_rails/address_details_spec.rb

@@ -5,9 +5,9 @@ describe BraintreeRails::AddressDetails do
     [:street_address, :locality, :region, :postal_code].each do |attribute|
       it "requires #{attribute}" do
         address = BraintreeRails::AddressDetails.new(address_details_hash.merge(attribute => nil))
-        address.should be_invalid
-        address.errors[attribute].should == ["can't be blank"]
+        expect(address).to be_invalid
+        expect(address.errors[attribute]).to eq(["can't be blank"])
       end
     end
   end
-end
+end

data/spec/unit/braintree_rails/address_spec.rb

@@ -10,9 +10,9 @@ describe BraintreeRails::Address do
       braintree_address = Braintree::Customer.find('customer_id').addresses.first
       address = BraintreeRails::Address.new(braintree_address)
 
-      address.should be_persisted
+      expect(address).to be_persisted
       BraintreeRails::Address.attributes.each do |attribute|
-        address.send(attribute).should == braintree_address.send(attribute)
+        expect(address.send(attribute)).to eq(braintree_address.send(attribute))
       end
     end
 
@@ -22,29 +22,29 @@ describe BraintreeRails::Address do
       braintree_address = braintree_customer.addresses.first
       address = BraintreeRails::Address.find('customer_id', braintree_address.id)
 
-      address.should be_persisted
+      expect(address).to be_persisted
       BraintreeRails::Address.attributes.each do |attribute|
-        address.send(attribute).should == braintree_address.send(attribute)
+        expect(address.send(attribute)).to eq(braintree_address.send(attribute))
       end
     end
 
     it 'should extract values from hash' do
       address = BraintreeRails::Address.new(:id => 'new_id')
 
-      address.should_not be_persisted
-      address.id.should == 'new_id'
+      expect(address).to_not be_persisted
+      expect(address.id).to eq('new_id')
     end
 
     it 'should try to extract value from other types' do
       address = BraintreeRails::Address.new(OpenStruct.new(:id => 'foobar', :first_name => 'Foo', :last_name => 'Bar', :persisted? => true))
 
-      address.should be_persisted
-      address.id.should == 'foobar'
-      address.first_name.should == 'Foo'
-      address.last_name.should == 'Bar'
+      expect(address).to be_persisted
+      expect(address.id).to eq('foobar')
+      expect(address.first_name).to eq('Foo')
+      expect(address.last_name).to eq('Bar')
 
       address = BraintreeRails::Address.new(Object.new)
-      address.should_not be_persisted
+      expect(address).to_not be_persisted
     end
   end
 
@@ -52,7 +52,7 @@ describe BraintreeRails::Address do
     it 'should auto set country_name' do
       {:country_code_alpha2 => 'US', :country_code_alpha3 => 'USA', :country_code_numeric => '840'}.each_pair do |key, value|
         address = BraintreeRails::Address.new(key => value)
-        address.country_name.should == 'United States of America'
+        expect(address.country_name).to eq('United States of America')
       end
     end
   end
@@ -61,19 +61,19 @@ describe BraintreeRails::Address do
     it 'should load customer for persisted address' do
       stub_braintree_request(:get, '/customers/customer_id', :body => fixture('customer.xml'))
       address = BraintreeRails::Customer.new('customer_id').addresses.first
-      address.customer.should be_persisted
-      address.customer.id.should == 'customer_id'
+      expect(address.customer).to be_persisted
+      expect(address.customer.id).to eq('customer_id')
     end
   end
 
   describe 'full_name' do
     it 'should combine first_name and last_name to form full_name' do
-      BraintreeRails::Address.new(:first_name => "Foo", :last_name => 'Bar').full_name.should == "Foo Bar"
+      expect(BraintreeRails::Address.new(:first_name => "Foo", :last_name => 'Bar').full_name).to eq("Foo Bar")
     end
 
     it 'should not have extra spaces when first_name or last_name is missing' do
-      BraintreeRails::Address.new(:first_name => "Foo").full_name.should == 'Foo'
-      BraintreeRails::Address.new(:last_name => 'Bar').full_name.should == 'Bar'
+      expect(BraintreeRails::Address.new(:first_name => "Foo").full_name).to eq('Foo')
+      expect(BraintreeRails::Address.new(:last_name => 'Bar').full_name).to eq('Bar')
     end
   end
 
@@ -82,15 +82,15 @@ describe BraintreeRails::Address do
       it "should validate length of #{attribute}" do
         address = BraintreeRails::Address.new(attribute => 'f')
         address.valid?
-        address.errors[attribute].should be_blank
+        expect(address.errors[attribute]).to be_blank
 
         address = BraintreeRails::Address.new(attribute => 'f' * 255)
         address.valid?
-        address.errors[attribute].should be_blank
+        expect(address.errors[attribute]).to be_blank
 
         address = BraintreeRails::Address.new(attribute => 'foo' * 256)
         address.valid?
-        address.errors[attribute].should_not be_blank
+        expect(address.errors[attribute]).to_not be_blank
       end
     end
 
@@ -98,30 +98,30 @@ describe BraintreeRails::Address do
       it "should validate presence of #{attribute}" do
         address = BraintreeRails::Address.new(attribute => 'foo')
         address.valid?
-        address.errors[attribute].should be_blank
+        expect(address.errors[attribute]).to be_blank
 
         address = BraintreeRails::Address.new
         address.valid?
-        address.errors[attribute].should_not be_blank
+        expect(address.errors[attribute]).to_not be_blank
       end
     end
 
     it 'should validate format of postal_code' do
       address = BraintreeRails::Address.new({:postal_code => 'CA 94025'})
       address.valid?
-      address.errors[:postal_code].should be_blank
+      expect(address.errors[:postal_code]).to be_blank
 
       address = BraintreeRails::Address.new({:postal_code => '%$'})
       address.valid?
-      address.errors[:postal_code].should_not be_blank
+      expect(address.errors[:postal_code]).to_not be_blank
     end
   end
 
   [BraintreeRails::BillingAddress, BraintreeRails::ShippingAddress].each do |subclass|
     describe subclass do
       it 'should have braintree_model_class to be Braintree::Address' do
-        subclass.braintree_model_class.should == Braintree::Address
+        expect(subclass.braintree_model_class).to eq(Braintree::Address)
       end
     end
   end
-end
+end

data/spec/unit/braintree_rails/addresses_spec.rb

@@ -11,12 +11,12 @@ describe BraintreeRails::Addresses do
       braintree_addresses = braintree_customer.addresses
       addresses = BraintreeRails::Addresses.new(BraintreeRails::Customer.find('customer_id'))
 
-      addresses.size.should == braintree_addresses.size
+      expect(addresses.size).to eq(braintree_addresses.size)
 
       braintree_addresses.each do |braintree_address|
         address = addresses.find(braintree_address.id)
         BraintreeRails::Address.attributes.each do |attribute|
-          address.send(attribute).should == braintree_address.send(attribute)
+          expect(address.send(attribute)).to eq(braintree_address.send(attribute))
         end
       end
     end
@@ -29,10 +29,10 @@ describe BraintreeRails::Addresses do
       addresses = BraintreeRails::Addresses.new(BraintreeRails::Customer.find('customer_id'))
       address = addresses.build({:first_name => 'foo', :last_name => 'bar'})
 
-      address.should_not be_persisted
-      address.customer_id.should == braintree_customer.id
-      address.first_name.should == 'foo'
-      address.last_name.should == 'bar'
+      expect(address).to_not be_persisted
+      expect(address.customer_id).to eq(braintree_customer.id)
+      expect(address.first_name).to eq('foo')
+      expect(address.last_name).to eq('bar')
     end
   end
-end
+end

data/spec/unit/braintree_rails/business_details_spec.rb

@@ -4,25 +4,25 @@ describe BraintreeRails::BusinessDetails do
   describe 'validations' do
     it "requries legal_name if tax_id is present" do
       business = BraintreeRails::BusinessDetails.new(business_details_hash.merge(:legal_name => nil))
-      business.should be_invalid
-      business.errors[:legal_name].should == ["can't be blank"]
+      expect(business).to be_invalid
+      expect(business.errors[:legal_name]).to eq(["can't be blank"])
     end
 
     it "requries tax_id if legal_name is present" do
       business = BraintreeRails::BusinessDetails.new(business_details_hash.merge(:tax_id => nil))
-      business.should be_invalid
-      business.errors[:tax_id].should == ["can't be blank"]
+      expect(business).to be_invalid
+      expect(business.errors[:tax_id]).to eq(["can't be blank"])
     end
 
     it "does not requrie either if neither are present" do
       business = BraintreeRails::BusinessDetails.new({})
-      business.should be_valid
+      expect(business).to be_valid
     end
 
     it "validates assocaited address" do
       business = BraintreeRails::BusinessDetails.new(address_details_hash.merge(:address => {}))
-      business.should be_invalid
-      business.errors[:address].should_not be_empty
+      expect(business).to be_invalid
+      expect(business.errors[:address]).to_not be_empty
     end
   end
-end
+end

data/spec/unit/braintree_rails/configuration_spec.rb

@@ -6,8 +6,8 @@ describe BraintreeRails::Configuration do
       begin
         old_value = Braintree::Configuration.send(config)
         BraintreeRails::Configuration.send("#{config}=", "foo")
-        Braintree::Configuration.send(config).should == "foo"
-        BraintreeRails::Configuration.send(config).should == "foo"
+        expect(Braintree::Configuration.send(config)).to eq("foo")
+        expect(BraintreeRails::Configuration.send(config)).to eq("foo")
       ensure
         BraintreeRails::Configuration.send("#{config}=", old_value)
       end
@@ -16,11 +16,11 @@ describe BraintreeRails::Configuration do
 
   it "should delegate environment to Braintree::Configuration" do
     BraintreeRails::Configuration.environment = :sandbox
-    Braintree::Configuration.environment.should == :sandbox
-    BraintreeRails::Configuration.environment.should == :sandbox
+    expect(Braintree::Configuration.environment).to eq(:sandbox)
+    expect(BraintreeRails::Configuration.environment).to eq(:sandbox)
   end
 
   it "should set custom_user_agent to braintree-rails-#{BraintreeRails::Version}" do
-    Braintree::Configuration.instantiate.user_agent.should include "braintree-rails-#{BraintreeRails::Version}"
+    expect(Braintree::Configuration.instantiate.user_agent).to include "braintree-rails-#{BraintreeRails::Version}"
   end
-end
+end

data/spec/unit/braintree_rails/credit_card_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '../unit_spec_helper'
 
 describe BraintreeRails::CreditCard do
   before do
-    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'))
   end
 
   describe '#initialize' do
@@ -10,14 +10,14 @@ describe BraintreeRails::CreditCard do
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
       braintree_credit_card = Braintree::CreditCard.find('credit_card_id')
 
-      credit_card.should be_persisted
-      credit_card.default?.should == braintree_credit_card.default?
-      credit_card.expired?.should == braintree_credit_card.expired?
-      credit_card.masked_number.should == braintree_credit_card.masked_number
+      expect(credit_card).to be_persisted
+      expect(credit_card.default?).to eq(braintree_credit_card.default?)
+      expect(credit_card.expired?).to eq(braintree_credit_card.expired?)
+      expect(credit_card.masked_number).to eq(braintree_credit_card.masked_number)
       BraintreeRails::CreditCard.attributes.each do |attribute|
         next if BraintreeRails::CreditCard.associations.include?(attribute)
         if braintree_credit_card.respond_to?(attribute)
-          braintree_credit_card.send(attribute).should eq(credit_card.send(attribute))
+          expect(braintree_credit_card.send(attribute)).to eq(credit_card.send(attribute))
         end
       end
     end
@@ -26,11 +26,11 @@ describe BraintreeRails::CreditCard do
       braintree_credit_card = Braintree::CreditCard.find('credit_card_id')
       credit_card = BraintreeRails::CreditCard.new(braintree_credit_card)
 
-      credit_card.should be_persisted
+      expect(credit_card).to be_persisted
       BraintreeRails::CreditCard.attributes.each do |attribute|
         next if BraintreeRails::CreditCard.associations.include?(attribute)
         if braintree_credit_card.respond_to?(attribute)
-          braintree_credit_card.send(attribute).should eq(credit_card.send(attribute))
+          expect(braintree_credit_card.send(attribute)).to eq(credit_card.send(attribute))
         end
       end
     end
@@ -38,19 +38,19 @@ describe BraintreeRails::CreditCard do
     it 'should extract values from hash' do
       credit_card = BraintreeRails::CreditCard.new(:token => 'new_id')
 
-      credit_card.should_not be_persisted
-      credit_card.token.should == 'new_id'
+      expect(credit_card).to_not be_persisted
+      expect(credit_card.token).to eq('new_id')
     end
 
     it 'should try to extract value from other types' do
       credit_card = BraintreeRails::CreditCard.new(OpenStruct.new(:token => 'foobar', :cardholder_name => 'Foo Bar', :persisted? => true))
 
-      credit_card.should be_persisted
-      credit_card.token.should == 'foobar'
-      credit_card.cardholder_name.should == 'Foo Bar'
+      expect(credit_card).to be_persisted
+      expect(credit_card.token).to eq('foobar')
+      expect(credit_card.cardholder_name).to eq('Foo Bar')
 
       credit_card = BraintreeRails::CreditCard.new(OpenStruct.new)
-      credit_card.should_not be_persisted
+      expect(credit_card).to_not be_persisted
     end
   end
 
@@ -58,8 +58,8 @@ describe BraintreeRails::CreditCard do
     it 'should load customer for persisted credit_card' do
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
       stub_braintree_request(:get, '/customers/customer_id', :body => fixture('customer.xml'))
-      credit_card.customer.should be_persisted
-      credit_card.customer.id.should == 'customer_id'
+      expect(credit_card.customer).to be_persisted
+      expect(credit_card.customer.id).to eq('customer_id')
     end
   end
 
@@ -68,29 +68,29 @@ describe BraintreeRails::CreditCard do
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
       braintree_credit_card = Braintree::CreditCard.find('credit_card_id')
 
-      credit_card.subscriptions.should respond_to(:each)
-      credit_card.subscriptions.size.should == braintree_credit_card.subscriptions.size
+      expect(credit_card.subscriptions).to respond_to(:each)
+      expect(credit_card.subscriptions.size).to eq(braintree_credit_card.subscriptions.size)
     end
 
     it 'can build new subscription' do
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
       subscription = credit_card.subscriptions.build
-      subscription.payment_method_token.should == credit_card.token
+      expect(subscription.payment_method_token).to eq(credit_card.token)
     end
   end
 
   describe '#billing_address' do
     it 'should wrap billing_address with Address object' do
       credit_card = BraintreeRails::CreditCard.new(OpenStruct.new(:billing_address => {}))
-      credit_card.billing_address.class.ancestors.should include BraintreeRails::Address
+      expect(credit_card.billing_address.class.ancestors).to include BraintreeRails::Address
 
       credit_card.billing_address = BraintreeRails::Address.new
-      credit_card.billing_address.class.ancestors.should include(BraintreeRails::Address)
+      expect(credit_card.billing_address.class.ancestors).to include(BraintreeRails::Address)
     end
 
     it 'should keep billing_address nil if assigned nil value' do
       credit_card = BraintreeRails::CreditCard.new(OpenStruct.new(:billing_address => nil))
-      credit_card.billing_address.should be_nil
+      expect(credit_card.billing_address).to be_nil
     end
 
   end
@@ -99,48 +99,48 @@ describe BraintreeRails::CreditCard do
     it 'should validate precence of customer_id on create' do
       credit_card = BraintreeRails::CreditCard.new
       credit_card.valid?(:create)
-      credit_card.errors[:customer_id].should_not be_blank
+      expect(credit_card.errors[:customer_id]).to_not be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:customer_id => 'foo')
       credit_card.valid?(:create)
-      credit_card.errors[:customer_id].should be_blank
+      expect(credit_card.errors[:customer_id]).to be_blank
     end
 
     it 'should validate length of customer_id' do
       credit_card = BraintreeRails::CreditCard.new(:customer_id => 'foo' * 13)
       credit_card.valid?(:create)
-      credit_card.errors[:customer_id].should_not be_blank
+      expect(credit_card.errors[:customer_id]).to_not be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:customer_id => 'foo')
       credit_card.valid?(:create)
-      credit_card.errors[:customer_id].should be_blank
+      expect(credit_card.errors[:customer_id]).to be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:customer_id => 'foo' * 12)
       credit_card.valid?(:create)
-      credit_card.errors[:customer_id].should be_blank
+      expect(credit_card.errors[:customer_id]).to be_blank
     end
 
     it 'should validate precence of number if new_record?' do
       credit_card = BraintreeRails::CreditCard.new
       credit_card.valid?
-      credit_card.errors[:number].should_not be_blank
+      expect(credit_card.errors[:number]).to_not be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:number => '4111111111111111')
       credit_card.valid?
-      credit_card.errors[:number].should be_blank
+      expect(credit_card.errors[:number]).to be_blank
 
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
-      credit_card.should be_valid
+      expect(credit_card).to be_valid
     end
 
     it 'should validate precence of cvv' do
       credit_card = BraintreeRails::CreditCard.new
       credit_card.valid?
-      credit_card.errors[:cvv].should_not be_blank
+      expect(credit_card.errors[:cvv]).to_not be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:cvv => '111')
       credit_card.valid?
-      credit_card.errors[:cvv].should be_blank
+      expect(credit_card.errors[:cvv]).to be_blank
     end
 
     describe 'S2S mode' do
@@ -155,101 +155,101 @@ describe BraintreeRails::CreditCard do
       it 'should validate numericality of number' do
         credit_card = BraintreeRails::CreditCard.new(:number => 'foobar')
         credit_card.valid?
-        credit_card.errors[:number].should_not be_blank
+        expect(credit_card.errors[:number]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:number => '4111111111111111')
         credit_card.valid?
-        credit_card.errors[:number].should be_blank
+        expect(credit_card.errors[:number]).to be_blank
       end
 
       it 'should validate length of number' do
         credit_card = BraintreeRails::CreditCard.new(:number => '1')
         credit_card.valid?
-        credit_card.errors[:number].should_not be_blank
+        expect(credit_card.errors[:number]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:number => '1' * 20)
         credit_card.valid?
-        credit_card.errors[:number].should_not be_blank
+        expect(credit_card.errors[:number]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:number => '4111111111111111')
         credit_card.valid?
-        credit_card.errors[:number].should be_blank
+        expect(credit_card.errors[:number]).to be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:number => '6208645006512478950')
         credit_card.valid?
-        credit_card.errors[:number].should be_blank
+        expect(credit_card.errors[:number]).to be_blank
       end
 
       it 'should validate numericality of cvv' do
         credit_card = BraintreeRails::CreditCard.new(:cvv => 'foo')
         credit_card.valid?
-        credit_card.errors[:cvv].should_not be_blank
+        expect(credit_card.errors[:cvv]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:cvv => '111')
         credit_card.valid?
-        credit_card.errors[:cvv].should be_blank
+        expect(credit_card.errors[:cvv]).to be_blank
       end
 
       it 'should validate length of cvv' do
         credit_card = BraintreeRails::CreditCard.new(:cvv => '1')
         credit_card.valid?
-        credit_card.errors[:cvv].should_not be_blank
+        expect(credit_card.errors[:cvv]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:cvv => '1' * 5)
         credit_card.valid?
-        credit_card.errors[:cvv].should_not be_blank
+        expect(credit_card.errors[:cvv]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:cvv => '111')
         credit_card.valid?
-        credit_card.errors[:cvv].should be_blank
+        expect(credit_card.errors[:cvv]).to be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:cvv => '1111')
         credit_card.valid?
-        credit_card.errors[:cvv].should be_blank
+        expect(credit_card.errors[:cvv]).to be_blank
       end
 
       it 'should validate expiration month' do
         credit_card = BraintreeRails::CreditCard.new(:expiration_month => 0)
         credit_card.valid?
-        credit_card.errors[:expiration_month].should_not be_blank
+        expect(credit_card.errors[:expiration_month]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_month => 13)
         credit_card.valid?
-        credit_card.errors[:expiration_month].should_not be_blank
+        expect(credit_card.errors[:expiration_month]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_month => 1.1)
         credit_card.valid?
-        credit_card.errors[:expiration_month].should_not be_blank
+        expect(credit_card.errors[:expiration_month]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_month => 1)
         credit_card.valid?
-        credit_card.errors[:expiration_month].should be_blank
+        expect(credit_card.errors[:expiration_month]).to be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_month => '12')
         credit_card.valid?
-        credit_card.errors[:expiration_month].should be_blank
+        expect(credit_card.errors[:expiration_month]).to be_blank
       end
 
       it 'should validate expiration year' do
         credit_card = BraintreeRails::CreditCard.new(:expiration_year => 1975)
         credit_card.valid?
-        credit_card.errors[:expiration_year].should_not be_blank
+        expect(credit_card.errors[:expiration_year]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_year => 2201)
         credit_card.valid?
-        credit_card.errors[:expiration_year].should_not be_blank
+        expect(credit_card.errors[:expiration_year]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_year => 1976.1)
         credit_card.valid?
-        credit_card.errors[:expiration_year].should_not be_blank
+        expect(credit_card.errors[:expiration_year]).to_not be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_year => 1976)
         credit_card.valid?
-        credit_card.errors[:expiration_year].should be_blank
+        expect(credit_card.errors[:expiration_year]).to be_blank
 
         credit_card = BraintreeRails::CreditCard.new(:expiration_year => '2200')
         credit_card.valid?
-        credit_card.errors[:expiration_year].should be_blank
+        expect(credit_card.errors[:expiration_year]).to be_blank
       end
 
     end
@@ -257,73 +257,73 @@ describe BraintreeRails::CreditCard do
     it 'should validate presence of expiration month' do
       credit_card = BraintreeRails::CreditCard.new
       credit_card.valid?
-      credit_card.errors[:expiration_month].should_not be_blank
+      expect(credit_card.errors[:expiration_month]).to_not be_blank
     end
 
     it 'should validate presence of expiration year' do
       credit_card = BraintreeRails::CreditCard.new
       credit_card.valid?
-      credit_card.errors[:expiration_year].should_not be_blank
+      expect(credit_card.errors[:expiration_year]).to_not be_blank
     end
 
     it 'should validate length of cardholder_name' do
       credit_card = BraintreeRails::CreditCard.new(:cardholder_name => 'f' * 256)
       credit_card.valid?
-      credit_card.errors[:cardholder_name].should_not be_blank
+      expect(credit_card.errors[:cardholder_name]).to_not be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:cardholder_name => 'f')
       credit_card.valid?
-      credit_card.errors[:cardholder_name].should be_blank
+      expect(credit_card.errors[:cardholder_name]).to be_blank
 
       credit_card = BraintreeRails::CreditCard.new(:cardholder_name => 'f' * 255)
       credit_card.valid?
-      credit_card.errors[:cardholder_name].should be_blank
+      expect(credit_card.errors[:cardholder_name]).to be_blank
     end
 
     it 'should validate billing_address' do
       credit_card = BraintreeRails::CreditCard.new(:billing_address => OpenStruct.new(:valid? => false))
       credit_card.valid?
-      credit_card.errors[:billing_address].should_not be_blank
+      expect(credit_card.errors[:billing_address]).to_not be_blank
 
       braintree_credit_card = Braintree::CreditCard.find('credit_card_id')
       credit_card = BraintreeRails::CreditCard.new(:billing_address => braintree_credit_card.billing_address)
       credit_card.valid?
-      credit_card.errors[:billing_address].should be_blank
+      expect(credit_card.errors[:billing_address]).to be_blank
     end
   end
 
   describe 'persistence' do
     it 'should add validation errors returned from Braintree' do
-      stub_braintree_request(:put, '/payment_methods/credit_card_id', :status => 422, :body => fixture('credit_card_validation_error.xml'))
+      stub_braintree_request(:put, '/payment_methods/credit_card/credit_card_id', :status => 422, :body => fixture('credit_card_validation_error.xml'))
       credit_card = BraintreeRails::CreditCard.new('credit_card_id')
       credit_card.update_attributes(:number => '4111111111111111', :cvv => '111')
-      credit_card.errors[:number].should_not be_blank
+      expect(credit_card.errors[:number]).to_not be_blank
 
-      credit_card.billing_address.errors[:street_address].should_not be_blank
-      credit_card.billing_address.errors[:postal_code].should_not be_blank
+      expect(credit_card.billing_address.errors[:street_address]).to_not be_blank
+      expect(credit_card.billing_address.errors[:postal_code]).to_not be_blank
     end
 
     it 'should clear encrypted attributes after save' do
       credit_card = BraintreeRails::CreditCard.find('credit_card_id')
       credit_card.number = "foo"
-      stub_braintree_request(:put, '/payment_methods/credit_card_id', :body => fixture('credit_card.xml'))
+      stub_braintree_request(:put, '/payment_methods/credit_card/credit_card_id', :body => fixture('credit_card.xml'))
       credit_card.save
-      credit_card.number.should be_blank
+      expect(credit_card.number).to be_blank
     end
 
     it 'should clear encrypted attributes even when save! fails' do
       credit_card = BraintreeRails::CreditCard.find('credit_card_id')
       credit_card.number = "foo"
-      stub_braintree_request(:put, '/payment_methods/credit_card_id', :status => 422, :body => fixture('credit_card_validation_error.xml'))
+      stub_braintree_request(:put, '/payment_methods/credit_card/credit_card_id', :status => 422, :body => fixture('credit_card_validation_error.xml'))
       expect {credit_card.save!}.to raise_error(Braintree::ValidationsFailed)
-      credit_card.number.should be_blank
+      expect(credit_card.number).to be_blank
     end
 
     it 'should clear encrypted attributes' do
       credit_card = BraintreeRails::CreditCard.find('credit_card_id')
       credit_card.number = "foo"
       credit_card.clear_encryped_attributes
-      credit_card.number.should be_blank
+      expect(credit_card.number).to be_blank
     end
 
     it 'should update expiration_date when required' do
@@ -334,20 +334,20 @@ describe BraintreeRails::CreditCard do
         :expiration_date => '02/2020',
       }
       credit_card.assign_attributes(attributes)
-      credit_card.attributes_for(:update)[:expiration_date].should == '02/2020'
+      expect(credit_card.attributes_for(:update)[:expiration_date]).to eq('02/2020')
     end
   end
 
   describe 'class methods' do
     it "should wrap Braintree's Model find" do
       credit_card = BraintreeRails::CreditCard.find('credit_card_id')
-      credit_card.id.should == 'credit_card_id'
-      credit_card.should be_persisted
+      expect(credit_card.id).to eq('credit_card_id')
+      expect(credit_card).to be_persisted
     end
 
     it "should delegate delete to Braintree's Model" do
-      stub_braintree_request(:delete, '/payment_methods/credit_card_id', :body => fixture('credit_card.xml'))
-      BraintreeRails::CreditCard.delete('credit_card_id').should be_true
+      stub_braintree_request(:delete, '/payment_methods/credit_card/credit_card_id', :body => fixture('credit_card.xml'))
+      expect(BraintreeRails::CreditCard.delete('credit_card_id')).to eq(true)
     end
   end
-end
+end