braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/merchant_account_spec.rb

@@ -41,7 +41,7 @@ VALID_APPLICATION_PARAMS = {
   :business => {
     :legal_name => "Joe's Bloggs",
     :dba_name => "Joe's Junkyard",
-    :tax_id => "123456789",
+    :tax_id => "423456789",
     :address => {
       :street_address => "456 Fake St",
       :postal_code => "48104",
@@ -65,7 +65,7 @@ describe Braintree::MerchantAccount do
       gateway = Braintree::Gateway.new(
         :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
         :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       code = Braintree::OAuthTestHelper.create_grant(gateway, {
@@ -75,50 +75,50 @@ describe Braintree::MerchantAccount do
 
       result = gateway.oauth.create_token_from_code(
         :code => code,
-        :scope => "read_write"
+        :scope => "read_write",
       )
 
       gateway = Braintree::Gateway.new(
         :access_token => result.credentials.access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       result = gateway.merchant_account.all
-      result.should be_success
-      result.merchant_accounts.count.should > 20
+      expect(result).to be_success
+      expect(result.merchant_accounts.count).to be > 20
     end
 
     it "returns merchant account with correct attributes" do
       gateway = Braintree::Gateway.new(
         :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
         :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       result = gateway.merchant.create(
         :email => "name@email.com",
-        :country_code_alpha3 => "USA",
-        :payment_methods => ["credit_card", "paypal"]
+        :country_code_alpha3 => "GBR",
+        :payment_methods => ["credit_card", "paypal"],
       )
 
       gateway = Braintree::Gateway.new(
         :access_token => result.credentials.access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       result = gateway.merchant_account.all
-      result.should be_success
-      result.merchant_accounts.count.should == 1
-      result.merchant_accounts.first.currency_iso_code.should == "USD"
-      result.merchant_accounts.first.status.should == "active"
-      result.merchant_accounts.first.default.should == true
+      expect(result).to be_success
+      expect(result.merchant_accounts.count).to eq(1)
+      expect(result.merchant_accounts.first.currency_iso_code).to eq("GBP")
+      expect(result.merchant_accounts.first.status).to eq("active")
+      expect(result.merchant_accounts.first.default).to eq(true)
     end
 
     it "returns all merchant accounts for read_only scoped grants" do
       gateway = Braintree::Gateway.new(
         :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
         :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       code = Braintree::OAuthTestHelper.create_grant(gateway, {
@@ -128,17 +128,17 @@ describe Braintree::MerchantAccount do
 
       result = gateway.oauth.create_token_from_code(
         :code => code,
-        :scope => "read_only"
+        :scope => "read_only",
       )
 
       gateway = Braintree::Gateway.new(
         :access_token => result.credentials.access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       result = gateway.merchant_account.all
-      result.should be_success
-      result.merchant_accounts.count.should > 20
+      expect(result).to be_success
+      expect(result.merchant_accounts.count).to be > 20
     end
   end
 
@@ -146,17 +146,17 @@ describe Braintree::MerchantAccount do
     it "accepts the deprecated parameters" do
       result = Braintree::MerchantAccount.create(DEPRECATED_APPLICATION_PARAMS)
 
-      result.should be_success
-      result.merchant_account.status.should == Braintree::MerchantAccount::Status::Pending
-      result.merchant_account.master_merchant_account.id.should == "sandbox_master_merchant_account"
+      expect(result).to be_success
+      expect(result.merchant_account.status).to eq(Braintree::MerchantAccount::Status::Pending)
+      expect(result.merchant_account.master_merchant_account.id).to eq("sandbox_master_merchant_account")
     end
 
     it "creates a merchant account with the new parameters and doesn't require an id" do
       result = Braintree::MerchantAccount.create(VALID_APPLICATION_PARAMS)
 
-      result.should be_success
-      result.merchant_account.status.should == Braintree::MerchantAccount::Status::Pending
-      result.merchant_account.master_merchant_account.id.should == "sandbox_master_merchant_account"
+      expect(result).to be_success
+      expect(result.merchant_account.status).to eq(Braintree::MerchantAccount::Status::Pending)
+      expect(result.merchant_account.master_merchant_account.id).to eq("sandbox_master_merchant_account")
     end
 
     it "allows an id to be passed" do
@@ -164,28 +164,28 @@ describe Braintree::MerchantAccount do
       sub_merchant_account_id = "sub_merchant_account_id#{random_number}"
       result = Braintree::MerchantAccount.create(
         VALID_APPLICATION_PARAMS.merge(
-          :id => sub_merchant_account_id
-        )
+          :id => sub_merchant_account_id,
+        ),
       )
 
-      result.should be_success
-      result.merchant_account.status.should == Braintree::MerchantAccount::Status::Pending
-      result.merchant_account.id.should == sub_merchant_account_id
-      result.merchant_account.master_merchant_account.id.should == "sandbox_master_merchant_account"
+      expect(result).to be_success
+      expect(result.merchant_account.status).to eq(Braintree::MerchantAccount::Status::Pending)
+      expect(result.merchant_account.id).to eq(sub_merchant_account_id)
+      expect(result.merchant_account.master_merchant_account.id).to eq("sandbox_master_merchant_account")
     end
 
     it "handles unsuccessful results" do
       result = Braintree::MerchantAccount.create({})
-      result.should_not be_success
-      result.errors.for(:merchant_account).on(:master_merchant_account_id).first.code.should == Braintree::ErrorCodes::MerchantAccount::MasterMerchantAccountIdIsRequired
+      expect(result).not_to be_success
+      expect(result.errors.for(:merchant_account).on(:master_merchant_account_id).first.code).to eq(Braintree::ErrorCodes::MerchantAccount::MasterMerchantAccountIdIsRequired)
     end
 
     it "requires all fields" do
       result = Braintree::MerchantAccount.create(
-        :master_merchant_account_id => "sandbox_master_merchant_account"
+        :master_merchant_account_id => "sandbox_master_merchant_account",
       )
-      result.should_not be_success
-      result.errors.for(:merchant_account).on(:tos_accepted).first.code.should == Braintree::ErrorCodes::MerchantAccount::TosAcceptedIsRequired
+      expect(result).not_to be_success
+      expect(result.errors.for(:merchant_account).on(:tos_accepted).first.code).to eq(Braintree::ErrorCodes::MerchantAccount::TosAcceptedIsRequired)
     end
 
     context "funding destination" do
@@ -194,7 +194,7 @@ describe Braintree::MerchantAccount do
         params[:funding][:destination] = ::Braintree::MerchantAccount::FundingDestination::Bank
         result = Braintree::MerchantAccount.create(params)
 
-        result.should be_success
+        expect(result).to be_success
       end
 
       it "accepts an email" do
@@ -203,7 +203,7 @@ describe Braintree::MerchantAccount do
         params[:funding][:email] = "joebloggs@compuserve.com"
         result = Braintree::MerchantAccount.create(params)
 
-        result.should be_success
+        expect(result).to be_success
       end
 
       it "accepts a mobile_phone" do
@@ -212,7 +212,7 @@ describe Braintree::MerchantAccount do
         params[:funding][:mobile_phone] = "3125882300"
         result = Braintree::MerchantAccount.create(params)
 
-        result.should be_success
+        expect(result).to be_success
       end
     end
   end
@@ -221,138 +221,137 @@ describe Braintree::MerchantAccount do
     it "creates a merchant account with the new parameters and doesn't require an id" do
       merchant_account = Braintree::MerchantAccount.create!(VALID_APPLICATION_PARAMS)
 
-      merchant_account.status.should == Braintree::MerchantAccount::Status::Pending
-      merchant_account.master_merchant_account.id.should == "sandbox_master_merchant_account"
+      expect(merchant_account.status).to eq(Braintree::MerchantAccount::Status::Pending)
+      expect(merchant_account.master_merchant_account.id).to eq("sandbox_master_merchant_account")
     end
   end
 
   describe "create_for_currency" do
     it "creates a new merchant account for currency" do
       result = SpecHelper::create_merchant
-      result.should be_success
+      expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
         :access_token => result.credentials.access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       result = gateway.merchant_account.create_for_currency(
-        :currency => "JPY"
+        :currency => "JPY",
       )
-      result.should be_success
-      result.merchant_account.currency_iso_code.should == "JPY"
+      expect(result).to be_success
+      expect(result.merchant_account.currency_iso_code).to eq("JPY")
     end
 
     it "returns error if a merchant account already exists for that currency" do
       result = SpecHelper::create_merchant
-      result.should be_success
+      expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
         :access_token => result.credentials.access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       result = gateway.merchant_account.create_for_currency(
-        :currency => "USD"
+        :currency => "USD",
       )
-      result.should be_success
+      expect(result).to be_success
 
       result = gateway.merchant_account.create_for_currency(
-        :currency => "USD"
+        :currency => "USD",
       )
-      result.should_not be_success
+      expect(result).not_to be_success
 
       errors = result.errors.for(:merchant).on(:currency)
-      errors[0].code.should == Braintree::ErrorCodes::Merchant::MerchantAccountExistsForCurrency
+      expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::MerchantAccountExistsForCurrency)
     end
 
     it "returns error if no currency is provided" do
       result = SpecHelper::create_merchant
-      result.should be_success
+      expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
         :access_token => result.credentials.access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       result = gateway.merchant_account.create_for_currency(
-        :currency => nil
+        :currency => nil,
       )
-      result.should_not be_success
+      expect(result).not_to be_success
 
       errors = result.errors.for(:merchant).on(:currency)
-      errors[0].code.should == Braintree::ErrorCodes::Merchant::CurrencyIsRequired
+      expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::CurrencyIsRequired)
 
       result = gateway.merchant_account.create_for_currency({})
-      result.should_not be_success
+      expect(result).not_to be_success
 
       errors = result.errors.for(:merchant).on(:currency)
-      errors[0].code.should == Braintree::ErrorCodes::Merchant::CurrencyIsRequired
+      expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::CurrencyIsRequired)
     end
 
     it "returns error if a currency is not supported" do
       result = SpecHelper::create_merchant
-      result.should be_success
+      expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
         :access_token => result.credentials.access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       result = gateway.merchant_account.create_for_currency(
-        :currency => "FAKE_CURRENCY"
+        :currency => "FAKE_CURRENCY",
       )
-      result.should_not be_success
+      expect(result).not_to be_success
 
       errors = result.errors.for(:merchant).on(:currency)
-      errors[0].code.should == Braintree::ErrorCodes::Merchant::CurrencyIsInvalid
+      expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::CurrencyIsInvalid)
     end
 
     it "returns error if id is passed and already taken" do
       result = SpecHelper::create_merchant
-      result.should be_success
+      expect(result).to be_success
 
       gateway = Braintree::Gateway.new(
         :access_token => result.credentials.access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       merchant = result.merchant
       result = gateway.merchant_account.create_for_currency(
         :currency => "USD",
-        :id => merchant.merchant_accounts.first.id
+        :id => merchant.merchant_accounts.first.id,
       )
-      result.should_not be_success
+      expect(result).not_to be_success
 
       errors = result.errors.for(:merchant).on(:id)
-      errors[0].code.should == Braintree::ErrorCodes::Merchant::MerchantAccountExistsForId
+      expect(errors[0].code).to eq(Braintree::ErrorCodes::Merchant::MerchantAccountExistsForId)
     end
   end
 
   describe "find" do
     it "finds the merchant account with the given token" do
       result = Braintree::MerchantAccount.create(VALID_APPLICATION_PARAMS)
-      result.should be_success
-      result.merchant_account.status.should == Braintree::MerchantAccount::Status::Pending
+      expect(result).to be_success
+      expect(result.merchant_account.status).to eq(Braintree::MerchantAccount::Status::Pending)
 
       id = result.merchant_account.id
       merchant_account = Braintree::MerchantAccount.find(id)
 
-      merchant_account.status.should == Braintree::MerchantAccount::Status::Active
-      merchant_account.individual_details.first_name.should == VALID_APPLICATION_PARAMS[:individual][:first_name]
-      merchant_account.individual_details.last_name.should == VALID_APPLICATION_PARAMS[:individual][:last_name]
+      expect(merchant_account.individual_details.first_name).to eq(VALID_APPLICATION_PARAMS[:individual][:first_name])
+      expect(merchant_account.individual_details.last_name).to eq(VALID_APPLICATION_PARAMS[:individual][:last_name])
     end
 
     it "retrieves the currency iso code for an existing master merchant account" do
       merchant_account = Braintree::MerchantAccount.find("sandbox_master_merchant_account")
 
-      merchant_account.currency_iso_code.should == "USD"
+      expect(merchant_account.currency_iso_code).to eq("USD")
     end
 
     it "raises a NotFoundError exception if merchant account cannot be found" do
       expect do
         Braintree::MerchantAccount.find("non-existant")
-      end.to raise_error(Braintree::NotFoundError, 'Merchant account with id non-existant not found')
+      end.to raise_error(Braintree::NotFoundError, "Merchant account with id non-existant not found")
     end
   end
 
@@ -372,7 +371,7 @@ describe Braintree::MerchantAccount do
       params[:individual][:address][:postal_code] = "60622"
       params[:business][:dba_name] = "James's Bloggs"
       params[:business][:legal_name] = "James's Bloggs Inc"
-      params[:business][:tax_id] = "123456789"
+      params[:business][:tax_id] = "423456789"
       params[:business][:address][:street_address] = "999 Fake St"
       params[:business][:address][:locality] = "Miami"
       params[:business][:address][:region] = "FL"
@@ -383,37 +382,37 @@ describe Braintree::MerchantAccount do
       params[:funding][:mobile_phone] = "1234567890"
       params[:funding][:destination] = Braintree::MerchantAccount::FundingDestination::MobilePhone
       result = Braintree::MerchantAccount.update("sandbox_sub_merchant_account", params)
-      result.should be_success
-      result.merchant_account.status.should == "active"
-      result.merchant_account.id.should == "sandbox_sub_merchant_account"
-      result.merchant_account.master_merchant_account.id.should == "sandbox_master_merchant_account"
-      result.merchant_account.individual_details.first_name.should == "John"
-      result.merchant_account.individual_details.last_name.should == "Doe"
-      result.merchant_account.individual_details.email.should == "john.doe@example.com"
-      result.merchant_account.individual_details.date_of_birth.should == "1970-01-01"
-      result.merchant_account.individual_details.phone.should == "3125551234"
-      result.merchant_account.individual_details.address_details.street_address.should == "123 Fake St"
-      result.merchant_account.individual_details.address_details.locality.should == "Chicago"
-      result.merchant_account.individual_details.address_details.region.should == "IL"
-      result.merchant_account.individual_details.address_details.postal_code.should == "60622"
-      result.merchant_account.business_details.dba_name.should == "James's Bloggs"
-      result.merchant_account.business_details.legal_name.should == "James's Bloggs Inc"
-      result.merchant_account.business_details.tax_id.should == "123456789"
-      result.merchant_account.business_details.address_details.street_address.should == "999 Fake St"
-      result.merchant_account.business_details.address_details.locality.should == "Miami"
-      result.merchant_account.business_details.address_details.region.should == "FL"
-      result.merchant_account.business_details.address_details.postal_code.should == "99999"
-      result.merchant_account.funding_details.account_number_last_4.should == "8798"
-      result.merchant_account.funding_details.routing_number.should == "071000013"
-      result.merchant_account.funding_details.email.should == "check@this.com"
-      result.merchant_account.funding_details.mobile_phone.should == "1234567890"
-      result.merchant_account.funding_details.destination.should == Braintree::MerchantAccount::FundingDestination::MobilePhone
-      result.merchant_account.funding_details.descriptor.should == "Joes Bloggs MI"
+      expect(result).to be_success
+      expect(result.merchant_account.status).to eq("active")
+      expect(result.merchant_account.id).to eq("sandbox_sub_merchant_account")
+      expect(result.merchant_account.master_merchant_account.id).to eq("sandbox_master_merchant_account")
+      expect(result.merchant_account.individual_details.first_name).to eq("John")
+      expect(result.merchant_account.individual_details.last_name).to eq("Doe")
+      expect(result.merchant_account.individual_details.email).to eq("john.doe@example.com")
+      expect(result.merchant_account.individual_details.date_of_birth).to eq("1970-01-01")
+      expect(result.merchant_account.individual_details.phone).to eq("3125551234")
+      expect(result.merchant_account.individual_details.address_details.street_address).to eq("123 Fake St")
+      expect(result.merchant_account.individual_details.address_details.locality).to eq("Chicago")
+      expect(result.merchant_account.individual_details.address_details.region).to eq("IL")
+      expect(result.merchant_account.individual_details.address_details.postal_code).to eq("60622")
+      expect(result.merchant_account.business_details.dba_name).to eq("James's Bloggs")
+      expect(result.merchant_account.business_details.legal_name).to eq("James's Bloggs Inc")
+      expect(result.merchant_account.business_details.tax_id).to eq("423456789")
+      expect(result.merchant_account.business_details.address_details.street_address).to eq("999 Fake St")
+      expect(result.merchant_account.business_details.address_details.locality).to eq("Miami")
+      expect(result.merchant_account.business_details.address_details.region).to eq("FL")
+      expect(result.merchant_account.business_details.address_details.postal_code).to eq("99999")
+      expect(result.merchant_account.funding_details.account_number_last_4).to eq("8798")
+      expect(result.merchant_account.funding_details.routing_number).to eq("071000013")
+      expect(result.merchant_account.funding_details.email).to eq("check@this.com")
+      expect(result.merchant_account.funding_details.mobile_phone).to eq("1234567890")
+      expect(result.merchant_account.funding_details.destination).to eq(Braintree::MerchantAccount::FundingDestination::MobilePhone)
+      expect(result.merchant_account.funding_details.descriptor).to eq("Joes Bloggs MI")
     end
 
     it "does not require all fields" do
-      result = Braintree::MerchantAccount.update("sandbox_sub_merchant_account", { :individual => { :first_name => "Jose" } })
-      result.should be_success
+      result = Braintree::MerchantAccount.update("sandbox_sub_merchant_account", {:individual => {:first_name => "Jose"}})
+      expect(result).to be_success
     end
 
     it "handles validation errors for blank fields" do
@@ -446,17 +445,17 @@ describe Braintree::MerchantAccount do
         }
       )
 
-      result.should_not be_success
-      result.errors.for(:merchant_account).for(:individual).on(:first_name).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::FirstNameIsRequired]
-      result.errors.for(:merchant_account).for(:individual).on(:last_name).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::LastNameIsRequired]
-      result.errors.for(:merchant_account).for(:individual).on(:date_of_birth).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::DateOfBirthIsRequired]
-      result.errors.for(:merchant_account).for(:individual).on(:email).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::EmailIsRequired]
-      result.errors.for(:merchant_account).for(:individual).for(:address).on(:street_address).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::Address::StreetAddressIsRequired]
-      result.errors.for(:merchant_account).for(:individual).for(:address).on(:postal_code).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::Address::PostalCodeIsRequired]
-      result.errors.for(:merchant_account).for(:individual).for(:address).on(:locality).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::Address::LocalityIsRequired]
-      result.errors.for(:merchant_account).for(:individual).for(:address).on(:region).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::Address::RegionIsRequired]
-      result.errors.for(:merchant_account).for(:funding).on(:destination).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::DestinationIsRequired]
-      result.errors.for(:merchant_account).on(:base).should be_empty
+      expect(result).not_to be_success
+      expect(result.errors.for(:merchant_account).for(:individual).on(:first_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::FirstNameIsRequired])
+      expect(result.errors.for(:merchant_account).for(:individual).on(:last_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::LastNameIsRequired])
+      expect(result.errors.for(:merchant_account).for(:individual).on(:date_of_birth).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::DateOfBirthIsRequired])
+      expect(result.errors.for(:merchant_account).for(:individual).on(:email).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::EmailIsRequired])
+      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:street_address).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::StreetAddressIsRequired])
+      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:postal_code).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::PostalCodeIsRequired])
+      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:locality).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::LocalityIsRequired])
+      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:region).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::RegionIsRequired])
+      expect(result.errors.for(:merchant_account).for(:funding).on(:destination).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::DestinationIsRequired])
+      expect(result.errors.for(:merchant_account).on(:base)).to be_empty
     end
 
     it "handles validation errors for invalid fields" do
@@ -495,30 +494,30 @@ describe Braintree::MerchantAccount do
         }
       )
 
-      result.should_not be_success
-      result.errors.for(:merchant_account).for(:individual).on(:first_name).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::FirstNameIsInvalid]
-      result.errors.for(:merchant_account).for(:individual).on(:last_name).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::LastNameIsInvalid]
-      result.errors.for(:merchant_account).for(:individual).on(:email).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::EmailIsInvalid]
-      result.errors.for(:merchant_account).for(:individual).on(:phone).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::PhoneIsInvalid]
-      result.errors.for(:merchant_account).for(:individual).for(:address).on(:street_address).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::Address::StreetAddressIsInvalid]
-      result.errors.for(:merchant_account).for(:individual).for(:address).on(:postal_code).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::Address::PostalCodeIsInvalid]
-      result.errors.for(:merchant_account).for(:individual).for(:address).on(:region).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::Address::RegionIsInvalid]
-      result.errors.for(:merchant_account).for(:individual).on(:ssn).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Individual::SsnIsInvalid]
-
-      result.errors.for(:merchant_account).for(:business).on(:legal_name).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Business::LegalNameIsInvalid]
-      result.errors.for(:merchant_account).for(:business).on(:dba_name).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Business::DbaNameIsInvalid]
-      result.errors.for(:merchant_account).for(:business).on(:tax_id).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Business::TaxIdIsInvalid]
-      result.errors.for(:merchant_account).for(:business).for(:address).on(:street_address).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Business::Address::StreetAddressIsInvalid]
-      result.errors.for(:merchant_account).for(:business).for(:address).on(:postal_code).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Business::Address::PostalCodeIsInvalid]
-      result.errors.for(:merchant_account).for(:business).for(:address).on(:region).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Business::Address::RegionIsInvalid]
-
-      result.errors.for(:merchant_account).for(:funding).on(:destination).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::DestinationIsInvalid]
-      result.errors.for(:merchant_account).for(:funding).on(:routing_number).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::RoutingNumberIsInvalid]
-      result.errors.for(:merchant_account).for(:funding).on(:account_number).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::AccountNumberIsInvalid]
-      result.errors.for(:merchant_account).for(:funding).on(:email).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::EmailIsInvalid]
-      result.errors.for(:merchant_account).for(:funding).on(:mobile_phone).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::MobilePhoneIsInvalid]
-
-      result.errors.for(:merchant_account).on(:base).should be_empty
+      expect(result).not_to be_success
+      expect(result.errors.for(:merchant_account).for(:individual).on(:first_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::FirstNameIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:individual).on(:last_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::LastNameIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:individual).on(:email).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::EmailIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:individual).on(:phone).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::PhoneIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:street_address).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::StreetAddressIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:postal_code).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::PostalCodeIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:individual).for(:address).on(:region).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::Address::RegionIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:individual).on(:ssn).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Individual::SsnIsInvalid])
+
+      expect(result.errors.for(:merchant_account).for(:business).on(:legal_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::LegalNameIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:business).on(:dba_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::DbaNameIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:business).on(:tax_id).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::TaxIdIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:business).for(:address).on(:street_address).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::Address::StreetAddressIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:business).for(:address).on(:postal_code).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::Address::PostalCodeIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:business).for(:address).on(:region).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::Address::RegionIsInvalid])
+
+      expect(result.errors.for(:merchant_account).for(:funding).on(:destination).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::DestinationIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:funding).on(:routing_number).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::RoutingNumberIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:funding).on(:account_number).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::AccountNumberIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:funding).on(:email).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::EmailIsInvalid])
+      expect(result.errors.for(:merchant_account).for(:funding).on(:mobile_phone).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::MobilePhoneIsInvalid])
+
+      expect(result.errors.for(:merchant_account).on(:base)).to be_empty
     end
 
     it "handles validation errors for business fields" do
@@ -531,9 +530,9 @@ describe Braintree::MerchantAccount do
         }
       )
 
-      result.should_not be_success
-      result.errors.for(:merchant_account).for(:business).on(:legal_name).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Business::LegalNameIsRequiredWithTaxId]
-      result.errors.for(:merchant_account).for(:business).on(:tax_id).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Business::TaxIdMustBeBlank]
+      expect(result).not_to be_success
+      expect(result.errors.for(:merchant_account).for(:business).on(:legal_name).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::LegalNameIsRequiredWithTaxId])
+      expect(result.errors.for(:merchant_account).for(:business).on(:tax_id).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::TaxIdMustBeBlank])
 
       result = Braintree::MerchantAccount.update(
         "sandbox_sub_merchant_account", {
@@ -544,8 +543,8 @@ describe Braintree::MerchantAccount do
         }
       )
 
-      result.should_not be_success
-      result.errors.for(:merchant_account).for(:business).on(:tax_id).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Business::TaxIdIsRequiredWithLegalName]
+      expect(result).not_to be_success
+      expect(result.errors.for(:merchant_account).for(:business).on(:tax_id).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Business::TaxIdIsRequiredWithLegalName])
     end
 
     it "handles validation errors for funding fields" do
@@ -559,9 +558,9 @@ describe Braintree::MerchantAccount do
         }
       )
 
-      result.should_not be_success
-      result.errors.for(:merchant_account).for(:funding).on(:routing_number).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::RoutingNumberIsRequired]
-      result.errors.for(:merchant_account).for(:funding).on(:account_number).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::AccountNumberIsRequired]
+      expect(result).not_to be_success
+      expect(result.errors.for(:merchant_account).for(:funding).on(:routing_number).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::RoutingNumberIsRequired])
+      expect(result.errors.for(:merchant_account).for(:funding).on(:account_number).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::AccountNumberIsRequired])
 
       result = Braintree::MerchantAccount.update(
         "sandbox_sub_merchant_account", {
@@ -572,8 +571,8 @@ describe Braintree::MerchantAccount do
         }
       )
 
-      result.should_not be_success
-      result.errors.for(:merchant_account).for(:funding).on(:email).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::EmailIsRequired]
+      expect(result).not_to be_success
+      expect(result.errors.for(:merchant_account).for(:funding).on(:email).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::EmailIsRequired])
 
       result = Braintree::MerchantAccount.update(
         "sandbox_sub_merchant_account", {
@@ -584,8 +583,8 @@ describe Braintree::MerchantAccount do
         }
       )
 
-      result.should_not be_success
-      result.errors.for(:merchant_account).for(:funding).on(:mobile_phone).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::MobilePhoneIsRequired]
+      expect(result).not_to be_success
+      expect(result.errors.for(:merchant_account).for(:funding).on(:mobile_phone).map(&:code)).to eq([Braintree::ErrorCodes::MerchantAccount::Funding::MobilePhoneIsRequired])
     end
   end
 
@@ -597,8 +596,8 @@ describe Braintree::MerchantAccount do
       params[:individual][:first_name] = "John"
       params[:individual][:last_name] = "Doe"
       merchant_account = Braintree::MerchantAccount.update!("sandbox_sub_merchant_account", params)
-      merchant_account.individual_details.first_name.should == "John"
-      merchant_account.individual_details.last_name.should == "Doe"
+      expect(merchant_account.individual_details.first_name).to eq("John")
+      expect(merchant_account.individual_details.last_name).to eq("Doe")
     end
   end
 end