braintree 4.14.0 → 4.15.0

data/spec/integration/braintree/merchant_account_spec.rb

@@ -84,8 +84,8 @@ describe Braintree::MerchantAccount do
       )
 
       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
@@ -107,11 +107,11 @@ describe Braintree::MerchantAccount do
       )
 
       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("USD")
+      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
@@ -137,8 +137,8 @@ describe Braintree::MerchantAccount do
       )
 
       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
@@ -168,24 +168,24 @@ describe Braintree::MerchantAccount do
         ),
       )
 
-      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",
       )
-      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,15 +221,15 @@ 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,
@@ -239,13 +239,13 @@ describe Braintree::MerchantAccount do
       result = gateway.merchant_account.create_for_currency(
         :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,
@@ -255,20 +255,20 @@ describe Braintree::MerchantAccount do
       result = gateway.merchant_account.create_for_currency(
         :currency => "USD",
       )
-      result.should be_success
+      expect(result).to be_success
 
       result = gateway.merchant_account.create_for_currency(
         :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,
@@ -278,21 +278,21 @@ describe Braintree::MerchantAccount do
       result = gateway.merchant_account.create_for_currency(
         :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,
@@ -302,15 +302,15 @@ describe Braintree::MerchantAccount do
       result = gateway.merchant_account.create_for_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,
@@ -322,30 +322,30 @@ describe Braintree::MerchantAccount do
         :currency => "USD",
         :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.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
@@ -382,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 == "423456789"
-      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
+      expect(result).to be_success
     end
 
     it "handles validation errors for blank fields" do
@@ -445,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
@@ -494,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
@@ -530,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", {
@@ -543,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
@@ -558,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", {
@@ -571,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", {
@@ -583,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
 
@@ -596,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