braintree 4.14.0 → 4.18.0

data/spec/integration/braintree/visa_checkout_card_spec.rb

@@ -9,42 +9,42 @@ describe Braintree::VisaCheckoutCard do
       :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
       :customer_id => customer.id,
     )
-    result.should be_success
+    expect(result).to be_success
 
     visa_checkout_card = result.payment_method
-    visa_checkout_card.should be_a(Braintree::VisaCheckoutCard)
-    visa_checkout_card.call_id.should == "abc123"
-    visa_checkout_card.billing_address.should_not be_nil
-    visa_checkout_card.bin.should_not be_nil
-    visa_checkout_card.card_type.should_not be_nil
-    visa_checkout_card.cardholder_name.should_not be_nil
-    visa_checkout_card.commercial.should_not be_nil
-    visa_checkout_card.country_of_issuance.should_not be_nil
-    visa_checkout_card.created_at.should_not be_nil
-    visa_checkout_card.customer_id.should_not be_nil
-    visa_checkout_card.customer_location.should_not be_nil
-    visa_checkout_card.debit.should_not be_nil
-    visa_checkout_card.default?.should_not be_nil
-    visa_checkout_card.durbin_regulated.should_not be_nil
-    visa_checkout_card.expiration_date.should_not be_nil
-    visa_checkout_card.expiration_month.should_not be_nil
-    visa_checkout_card.expiration_year.should_not be_nil
-    visa_checkout_card.expired?.should_not be_nil
-    visa_checkout_card.healthcare.should_not be_nil
-    visa_checkout_card.image_url.should_not be_nil
-    visa_checkout_card.issuing_bank.should_not be_nil
-    visa_checkout_card.last_4.should_not be_nil
-    visa_checkout_card.payroll.should_not be_nil
-    visa_checkout_card.prepaid.should_not be_nil
-    visa_checkout_card.product_id.should_not be_nil
-    visa_checkout_card.subscriptions.should_not be_nil
-    visa_checkout_card.token.should_not be_nil
-    visa_checkout_card.unique_number_identifier.should_not be_nil
-    visa_checkout_card.updated_at.should_not be_nil
+    expect(visa_checkout_card).to be_a(Braintree::VisaCheckoutCard)
+    expect(visa_checkout_card.call_id).to eq("abc123")
+    expect(visa_checkout_card.billing_address).not_to be_nil
+    expect(visa_checkout_card.bin).not_to be_nil
+    expect(visa_checkout_card.card_type).not_to be_nil
+    expect(visa_checkout_card.cardholder_name).not_to be_nil
+    expect(visa_checkout_card.commercial).not_to be_nil
+    expect(visa_checkout_card.country_of_issuance).not_to be_nil
+    expect(visa_checkout_card.created_at).not_to be_nil
+    expect(visa_checkout_card.customer_id).not_to be_nil
+    expect(visa_checkout_card.customer_location).not_to be_nil
+    expect(visa_checkout_card.debit).not_to be_nil
+    expect(visa_checkout_card.default?).not_to be_nil
+    expect(visa_checkout_card.durbin_regulated).not_to be_nil
+    expect(visa_checkout_card.expiration_date).not_to be_nil
+    expect(visa_checkout_card.expiration_month).not_to be_nil
+    expect(visa_checkout_card.expiration_year).not_to be_nil
+    expect(visa_checkout_card.expired?).not_to be_nil
+    expect(visa_checkout_card.healthcare).not_to be_nil
+    expect(visa_checkout_card.image_url).not_to be_nil
+    expect(visa_checkout_card.issuing_bank).not_to be_nil
+    expect(visa_checkout_card.last_4).not_to be_nil
+    expect(visa_checkout_card.payroll).not_to be_nil
+    expect(visa_checkout_card.prepaid).not_to be_nil
+    expect(visa_checkout_card.product_id).not_to be_nil
+    expect(visa_checkout_card.subscriptions).not_to be_nil
+    expect(visa_checkout_card.token).not_to be_nil
+    expect(visa_checkout_card.unique_number_identifier).not_to be_nil
+    expect(visa_checkout_card.updated_at).not_to be_nil
 
     customer = Braintree::Customer.find(customer.id)
-    customer.visa_checkout_cards.size.should == 1
-    customer.visa_checkout_cards.first.should == visa_checkout_card
+    expect(customer.visa_checkout_cards.size).to eq(1)
+    expect(customer.visa_checkout_cards.first).to eq(visa_checkout_card)
   end
 
   it "can create with verification" do
@@ -55,8 +55,8 @@ describe Braintree::VisaCheckoutCard do
       :customer_id => customer.id,
       :options => {:verify_card => true},
     )
-    result.should be_success
-    result.payment_method.verification.status.should == Braintree::CreditCardVerification::Status::Verified
+    expect(result).to be_success
+    expect(result.payment_method.verification.status).to eq(Braintree::CreditCardVerification::Status::Verified)
   end
 
   it "can search for transactions" do
@@ -64,14 +64,14 @@ describe Braintree::VisaCheckoutCard do
       :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
       :amount => "47.00",
     )
-    transaction_create_result.should be_success
+    expect(transaction_create_result).to be_success
     transaction_id = transaction_create_result.transaction.id
 
     search_results = Braintree::Transaction.search do |search|
       search.id.is transaction_id
       search.payment_instrument_type.is Braintree::PaymentInstrumentType::VisaCheckoutCard
     end
-    search_results.first.id.should == transaction_id
+    expect(search_results.first.id).to eq(transaction_id)
   end
 
   it "can create transaction from nonce and vault" do
@@ -83,28 +83,28 @@ describe Braintree::VisaCheckoutCard do
       :amount => "47.00",
       :options => {:store_in_vault => true},
     )
-    result.should be_success
+    expect(result).to be_success
 
     visa_checkout_card_details = result.transaction.visa_checkout_card_details
-    visa_checkout_card_details.call_id.should == "abc123"
-    visa_checkout_card_details.bin.should_not be_nil
-    visa_checkout_card_details.card_type.should_not be_nil
-    visa_checkout_card_details.cardholder_name.should_not be_nil
-    visa_checkout_card_details.commercial.should_not be_nil
-    visa_checkout_card_details.country_of_issuance.should_not be_nil
-    visa_checkout_card_details.customer_location.should_not be_nil
-    visa_checkout_card_details.debit.should_not be_nil
-    visa_checkout_card_details.durbin_regulated.should_not be_nil
-    visa_checkout_card_details.expiration_date.should_not be_nil
-    visa_checkout_card_details.expiration_month.should_not be_nil
-    visa_checkout_card_details.expiration_year.should_not be_nil
-    visa_checkout_card_details.healthcare.should_not be_nil
-    visa_checkout_card_details.image_url.should_not be_nil
-    visa_checkout_card_details.issuing_bank.should_not be_nil
-    visa_checkout_card_details.last_4.should_not be_nil
-    visa_checkout_card_details.payroll.should_not be_nil
-    visa_checkout_card_details.prepaid.should_not be_nil
-    visa_checkout_card_details.product_id.should_not be_nil
-    visa_checkout_card_details.token.should_not be_nil
+    expect(visa_checkout_card_details.call_id).to eq("abc123")
+    expect(visa_checkout_card_details.bin).not_to be_nil
+    expect(visa_checkout_card_details.card_type).not_to be_nil
+    expect(visa_checkout_card_details.cardholder_name).not_to be_nil
+    expect(visa_checkout_card_details.commercial).not_to be_nil
+    expect(visa_checkout_card_details.country_of_issuance).not_to be_nil
+    expect(visa_checkout_card_details.customer_location).not_to be_nil
+    expect(visa_checkout_card_details.debit).not_to be_nil
+    expect(visa_checkout_card_details.durbin_regulated).not_to be_nil
+    expect(visa_checkout_card_details.expiration_date).not_to be_nil
+    expect(visa_checkout_card_details.expiration_month).not_to be_nil
+    expect(visa_checkout_card_details.expiration_year).not_to be_nil
+    expect(visa_checkout_card_details.healthcare).not_to be_nil
+    expect(visa_checkout_card_details.image_url).not_to be_nil
+    expect(visa_checkout_card_details.issuing_bank).not_to be_nil
+    expect(visa_checkout_card_details.last_4).not_to be_nil
+    expect(visa_checkout_card_details.payroll).not_to be_nil
+    expect(visa_checkout_card_details.prepaid).not_to be_nil
+    expect(visa_checkout_card_details.product_id).not_to be_nil
+    expect(visa_checkout_card_details.token).not_to be_nil
   end
 end

data/spec/spec_helper.rb

@@ -30,19 +30,20 @@ unless defined?(SPEC_HELPER_LOADED)
 
   module SpecHelper
 
+    AdyenMerchantAccountId = "adyen_ma"
+    AibSwedenMaMerchantAccountId = "aib_swe_ma"
+    AnotherUsBankMerchantAccountId = "another_us_bank_merchant_account"
+    CardProcessorBRLMerchantAccountId = "card_processor_brl"
     DefaultMerchantAccountId = "sandbox_credit_card"
+    FakeAmexDirectMerchantAccountId = "fake_amex_direct_usd"
+    FakeFirstDataMerchantAccountId = "fake_first_data_merchant_account"
+    FakeVenmoAccountMerchantAccountId = "fake_first_data_venmo_account"
+    HiperBRLMerchantAccountId = "hiper_brl"
     NonDefaultMerchantAccountId = "sandbox_credit_card_non_default"
     NonDefaultSubMerchantAccountId = "sandbox_sub_merchant_account"
+    PinlessDebitMerchantAccountId = "pinless_debit"
     ThreeDSecureMerchantAccountId = "three_d_secure_merchant_account"
-    FakeAmexDirectMerchantAccountId = "fake_amex_direct_usd"
-    FakeVenmoAccountMerchantAccountId = "fake_first_data_venmo_account"
     UsBankMerchantAccountId = "us_bank_merchant_account"
-    AnotherUsBankMerchantAccountId = "another_us_bank_merchant_account"
-    AdyenMerchantAccountId = "adyen_ma"
-    HiperBRLMerchantAccountId = "hiper_brl"
-    CardProcessorBRLMerchantAccountId = "card_processor_brl"
-    FakeFirstDataMerchantAccountId = "fake_first_data_merchant_account"
-    AibSwedenMaMerchantAccountId = "aib_swe_ma"
 
     TrialPlan = {
       :description => "Plan for integration tests -- with trial",

data/spec/unit/braintree/address_spec.rb

@@ -6,29 +6,29 @@ describe Braintree::Address do
       first = Braintree::Address._new(:gateway, :customer_id => "c1", :id => "a1")
       second = Braintree::Address._new(:gateway, :customer_id => "c1", :id => "a1")
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false if given an address with a different id and the same customer_id" do
       first = Braintree::Address._new(:gateway, :customer_id => "c1", :id => "a1")
       second = Braintree::Address._new(:gateway, :customer_id => "c1", :id => "not a1")
 
-      first.should_not == second
-      second.should_not == first
+      expect(first).not_to eq(second)
+      expect(second).not_to eq(first)
     end
 
     it "returns false if given an address with a different customer_id and the same id" do
       first = Braintree::Address._new(:gateway, :customer_id => "c1", :id => "a1")
       second = Braintree::Address._new(:gateway, :customer_id => "not c1", :id => "a1")
 
-      first.should_not == second
-      second.should_not == first
+      expect(first).not_to eq(second)
+      expect(second).not_to eq(first)
     end
 
     it "returns false when not given an address" do
       address = Braintree::Address._new(:gateway, :id => "a1")
-      address.should_not == "not an address"
+      expect(address).not_to eq("not an address")
     end
   end
 
@@ -80,7 +80,7 @@ describe Braintree::Address do
     end
 
     it "does not raise an error if address_id does not respond to strip" do
-      Braintree::Http.stub(:new).and_return double.as_null_object
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
       expect do
         Braintree::Address.find("customer_id", 8675309)
       end.to_not raise_error

data/spec/unit/braintree/base_module_spec.rb

@@ -8,11 +8,11 @@ describe Braintree::BaseModule do
         klass = Class.new { include Braintree::BaseModule }
         klass.return_object_or_raise(:obj) { result }
       rescue Braintree::ValidationsFailed => ex
+      expect(ex).not_to eq(nil)
+      expect(ex.error_result).to eq(result)
+      expect(ex.inspect).to include(result.inspect)
+      expect(ex.to_s).to include(result.inspect)
       end
-      ex.should_not == nil
-      ex.error_result.should == result
-      ex.inspect.should include(result.inspect)
-      ex.to_s.should include(result.inspect)
     end
   end
 end

data/spec/unit/braintree/client_token_spec.rb

@@ -7,8 +7,8 @@ module Braintree
       it "delegates to ClientTokenGateway#generate" do
         options = {:foo => :bar}
         client_token_gateway = double(:client_token_gateway)
-        client_token_gateway.should_receive(:generate).with(options).once
-        ClientTokenGateway.stub(:new).and_return(client_token_gateway)
+        expect(client_token_gateway).to receive(:generate).with(options).once
+        allow(ClientTokenGateway).to receive(:new).and_return(client_token_gateway)
         ClientToken.generate(options)
       end
 

data/spec/unit/braintree/configuration_spec.rb

@@ -27,9 +27,9 @@ describe Braintree::Configuration do
         :private_key => "private_key",
       )
 
-      config.merchant_id.should == "merchant_id"
-      config.public_key.should == "public_key"
-      config.private_key.should == "private_key"
+      expect(config.merchant_id).to eq("merchant_id")
+      expect(config.public_key).to eq("public_key")
+      expect(config.private_key).to eq("private_key")
     end
 
     it "accepts partner credentials" do
@@ -39,9 +39,9 @@ describe Braintree::Configuration do
         :private_key => "private_key",
       )
 
-      config.merchant_id.should == "partner_id"
-      config.public_key.should == "public_key"
-      config.private_key.should == "private_key"
+      expect(config.merchant_id).to eq("partner_id")
+      expect(config.public_key).to eq("public_key")
+      expect(config.private_key).to eq("private_key")
     end
 
     it "raises if combining client_id/secret with access_token" do
@@ -82,7 +82,7 @@ describe Braintree::Configuration do
           :access_token => "access_token$development$integration_merchant_id$fb27c79dd",
           :environment => "sandbox",
         )
-        $stderr.string.should == "Braintree::Gateway should not be initialized with mixed environments: environment parameter and access_token do not match, environment from access_token is used.\n"
+        expect($stderr.string).to eq("Braintree::Gateway should not be initialized with mixed environments: environment parameter and access_token do not match, environment from access_token is used.\n")
       end
 
       it "does not warn if both environment and access_token are provided and their environments match" do
@@ -90,7 +90,7 @@ describe Braintree::Configuration do
           :access_token => "access_token$development$integration_merchant_id$fb27c79dd",
           :environment => "development",
         )
-        $stderr.string.should == ""
+        expect($stderr.string).to eq("")
       end
     end
 
@@ -102,10 +102,10 @@ describe Braintree::Configuration do
         :proxy_pass => "test",
       )
 
-      config.proxy_address.should == "localhost"
-      config.proxy_port.should == 8080
-      config.proxy_user.should == "user"
-      config.proxy_pass.should == "test"
+      expect(config.proxy_address).to eq("localhost")
+      expect(config.proxy_port).to eq(8080)
+      expect(config.proxy_user).to eq("user")
+      expect(config.proxy_pass).to eq("test")
     end
 
     it "accepts ssl version" do
@@ -113,13 +113,13 @@ describe Braintree::Configuration do
         :ssl_version => :TLSv1_2,
       )
 
-      config.ssl_version.should == :TLSv1_2
+      expect(config.ssl_version).to eq(:TLSv1_2)
     end
   end
 
   describe "base_merchant_path" do
     it "returns /merchants/{merchant_id}" do
-      Braintree::Configuration.instantiate.base_merchant_path.should == "/merchants/integration_merchant_id"
+      expect(Braintree::Configuration.instantiate.base_merchant_path).to eq("/merchants/integration_merchant_id")
     end
   end
 
@@ -127,17 +127,17 @@ describe Braintree::Configuration do
     it "returns the expected url for the development env" do
       Braintree::Configuration.environment = :development
       port = Braintree::Configuration.instantiate.port
-      Braintree::Configuration.instantiate.base_merchant_url.should == "http://localhost:#{port}/merchants/integration_merchant_id"
+      expect(Braintree::Configuration.instantiate.base_merchant_url).to eq("http://localhost:#{port}/merchants/integration_merchant_id")
     end
 
     it "returns the expected url for the sandbox env" do
       Braintree::Configuration.environment = :sandbox
-      Braintree::Configuration.instantiate.base_merchant_url.should == "https://api.sandbox.braintreegateway.com:443/merchants/integration_merchant_id"
+      expect(Braintree::Configuration.instantiate.base_merchant_url).to eq("https://api.sandbox.braintreegateway.com:443/merchants/integration_merchant_id")
     end
 
     it "returns the expected url for the production env" do
       Braintree::Configuration.environment = :production
-      Braintree::Configuration.instantiate.base_merchant_url.should == "https://api.braintreegateway.com:443/merchants/integration_merchant_id"
+      expect(Braintree::Configuration.instantiate.base_merchant_url).to eq("https://api.braintreegateway.com:443/merchants/integration_merchant_id")
     end
   end
 
@@ -145,27 +145,27 @@ describe Braintree::Configuration do
     it "sandbox" do
       Braintree::Configuration.environment = :sandbox
       ca_file = Braintree::Configuration.instantiate.ca_file
-      ca_file.should match(/api_braintreegateway_com\.ca\.crt$/)
-      File.exist?(ca_file).should == true
+      expect(ca_file).to match(/api_braintreegateway_com\.ca\.crt$/)
+      expect(File.exist?(ca_file)).to eq(true)
     end
 
     it "production" do
       Braintree::Configuration.environment = :production
       ca_file = Braintree::Configuration.instantiate.ca_file
-      ca_file.should match(/api_braintreegateway_com\.ca\.crt$/)
-      File.exist?(ca_file).should == true
+      expect(ca_file).to match(/api_braintreegateway_com\.ca\.crt$/)
+      expect(File.exist?(ca_file)).to eq(true)
     end
   end
 
   describe "logger" do
     it "defaults to logging to stdout with log_level info" do
       config = Braintree::Configuration.new
-      config.logger.level.should == Logger::INFO
+      expect(config.logger.level).to eq(Logger::INFO)
     end
 
     it "lazily initializes so that you can do Braintree::Configuration.logger.level = when configuring the client lib" do
       config = Braintree::Configuration.new :logger => nil
-      config.logger.should_not == nil
+      expect(config.logger).not_to eq(nil)
     end
 
     it "can set logger on gateway instance" do
@@ -215,17 +215,17 @@ describe Braintree::Configuration do
 
       gateway = Braintree::Configuration.gateway
 
-      gateway.config.proxy_address.should == "localhost"
-      gateway.config.proxy_port.should == 8080
-      gateway.config.proxy_user.should == "user"
-      gateway.config.proxy_pass.should == "test"
+      expect(gateway.config.proxy_address).to eq("localhost")
+      expect(gateway.config.proxy_port).to eq(8080)
+      expect(gateway.config.proxy_user).to eq("user")
+      expect(gateway.config.proxy_pass).to eq("test")
     end
 
     it "sets the ssl version" do
       Braintree::Configuration.ssl_version = :TLSv1_2
       gateway = Braintree::Configuration.gateway
 
-      gateway.config.ssl_version.should == :TLSv1_2
+      expect(gateway.config.ssl_version).to eq(:TLSv1_2)
     end
   end
 
@@ -253,7 +253,7 @@ describe Braintree::Configuration do
       begin
         old_logger = Braintree::Configuration.logger
         Braintree::Configuration.logger = nil
-        Braintree::Configuration.instantiate.logger.level.should == Logger::INFO
+        expect(Braintree::Configuration.instantiate.logger.level).to eq(Logger::INFO)
       ensure
         Braintree::Configuration.logger = old_logger
       end
@@ -261,7 +261,7 @@ describe Braintree::Configuration do
 
     it "lazily initializes so that you can do Braintree::Configuration.logger.level = when configuring the client lib" do
       Braintree::Configuration.logger = nil
-      Braintree::Configuration.logger.should_not == nil
+      expect(Braintree::Configuration.logger).not_to eq(nil)
     end
   end
 
@@ -316,12 +316,12 @@ describe Braintree::Configuration do
   describe "self.port" do
     it "is 443 for production" do
       Braintree::Configuration.environment = :production
-      Braintree::Configuration.instantiate.port.should == 443
+      expect(Braintree::Configuration.instantiate.port).to eq(443)
     end
 
     it "is 443 for sandbox" do
       Braintree::Configuration.environment = :sandbox
-      Braintree::Configuration.instantiate.port.should == 443
+      expect(Braintree::Configuration.instantiate.port).to eq(443)
     end
 
     it "is 3000 or GATEWAY_PORT environment variable for development" do
@@ -329,10 +329,10 @@ describe Braintree::Configuration do
       old_gateway_port = ENV["GATEWAY_PORT"]
       begin
         ENV["GATEWAY_PORT"] = nil
-        Braintree::Configuration.instantiate.port.should == 3000
+        expect(Braintree::Configuration.instantiate.port).to eq(3000)
 
         ENV["GATEWAY_PORT"] = "1234"
-        Braintree::Configuration.instantiate.port.should == "1234"
+        expect(Braintree::Configuration.instantiate.port).to eq("1234")
       ensure
         ENV["GATEWAY_PORT"] = old_gateway_port
       end
@@ -342,17 +342,17 @@ describe Braintree::Configuration do
   describe "self.protocol" do
     it "is http for development" do
       Braintree::Configuration.environment = :development
-      Braintree::Configuration.instantiate.protocol.should == "http"
+      expect(Braintree::Configuration.instantiate.protocol).to eq("http")
     end
 
     it "is https for production" do
       Braintree::Configuration.environment = :production
-      Braintree::Configuration.instantiate.protocol.should == "https"
+      expect(Braintree::Configuration.instantiate.protocol).to eq("https")
     end
 
     it "is https for sandbox" do
       Braintree::Configuration.environment = :sandbox
-      Braintree::Configuration.instantiate.protocol.should == "https"
+      expect(Braintree::Configuration.instantiate.protocol).to eq("https")
     end
   end
 
@@ -362,10 +362,10 @@ describe Braintree::Configuration do
       old_gateway_url = ENV["GRAPHQL_HOST"]
       begin
         ENV["GRAPHQL_HOST"] = nil
-        Braintree::Configuration.instantiate.graphql_server.should == "graphql.bt.local"
+        expect(Braintree::Configuration.instantiate.graphql_server).to eq("graphql.bt.local")
 
         ENV["GRAPHQL_HOST"] = "gateway"
-        Braintree::Configuration.instantiate.graphql_server.should == "gateway"
+        expect(Braintree::Configuration.instantiate.graphql_server).to eq("gateway")
       ensure
         ENV["GRAPHQL_HOST"] = old_gateway_url
       end
@@ -378,10 +378,10 @@ describe Braintree::Configuration do
       old_gateway_url = ENV["GATEWAY_HOST"]
       begin
         ENV["GATEWAY_HOST"] = nil
-        Braintree::Configuration.instantiate.server.should == "localhost"
+        expect(Braintree::Configuration.instantiate.server).to eq("localhost")
 
         ENV["GATEWAY_HOST"] = "gateway"
-        Braintree::Configuration.instantiate.server.should == "gateway"
+        expect(Braintree::Configuration.instantiate.server).to eq("gateway")
       ensure
         ENV["GATEWAY_HOST"] = old_gateway_url
       end
@@ -389,62 +389,62 @@ describe Braintree::Configuration do
 
     it "is api.braintreegateway.com for production" do
       Braintree::Configuration.environment = :production
-      Braintree::Configuration.instantiate.server.should == "api.braintreegateway.com"
+      expect(Braintree::Configuration.instantiate.server).to eq("api.braintreegateway.com")
     end
 
     it "is api.sandbox.braintreegateway.com for sandbox" do
       Braintree::Configuration.environment = :sandbox
-      Braintree::Configuration.instantiate.server.should == "api.sandbox.braintreegateway.com"
+      expect(Braintree::Configuration.instantiate.server).to eq("api.sandbox.braintreegateway.com")
     end
 
     it "is qa.braintreegateway.com for qa" do
       Braintree::Configuration.environment = :qa
-      Braintree::Configuration.instantiate.server.should == "gateway.qa.braintreepayments.com"
+      expect(Braintree::Configuration.instantiate.server).to eq("gateway.qa.braintreepayments.com")
     end
 
     it "can by changed by configuring the production endpoint" do
       Braintree::Configuration.environment = :production
       Braintree::Configuration.endpoint = "custom-endpoint"
-      Braintree::Configuration.instantiate.server.should == "custom-endpoint.braintreegateway.com"
+      expect(Braintree::Configuration.instantiate.server).to eq("custom-endpoint.braintreegateway.com")
     end
   end
 
   describe "auth_url" do
     it "is http://auth.venmo.dev for development" do
       Braintree::Configuration.environment = :development
-      Braintree::Configuration.instantiate.auth_url.should == "http://auth.venmo.dev:9292"
+      expect(Braintree::Configuration.instantiate.auth_url).to eq("http://auth.venmo.dev:9292")
     end
 
     it "is https://auth.venmo.com for production" do
       Braintree::Configuration.environment = :production
-      Braintree::Configuration.instantiate.auth_url.should == "https://auth.venmo.com"
+      expect(Braintree::Configuration.instantiate.auth_url).to eq("https://auth.venmo.com")
     end
 
     it "is https://auth.sandbox.venmo.com for sandbox" do
       Braintree::Configuration.environment = :sandbox
-      Braintree::Configuration.instantiate.auth_url.should == "https://auth.venmo.sandbox.braintreegateway.com"
+      expect(Braintree::Configuration.instantiate.auth_url).to eq("https://auth.venmo.sandbox.braintreegateway.com")
     end
 
     it "is https://auth.qa.venmo.com for qa" do
       Braintree::Configuration.environment = :qa
-      Braintree::Configuration.instantiate.auth_url.should == "https://auth.venmo.qa2.braintreegateway.com"
+      expect(Braintree::Configuration.instantiate.auth_url).to eq("https://auth.venmo.qa2.braintreegateway.com")
     end
   end
 
   describe "ssl?" do
     it "returns false for development" do
       Braintree::Configuration.environment = :development
-      Braintree::Configuration.instantiate.ssl?.should == false
+      expect(Braintree::Configuration.instantiate.ssl?).to eq(false)
     end
 
     it "returns true for production" do
       Braintree::Configuration.environment = :production
-      Braintree::Configuration.instantiate.ssl?.should == true
+      expect(Braintree::Configuration.instantiate.ssl?).to eq(true)
     end
 
     it "returns true for sandbox" do
       Braintree::Configuration.environment = :sandbox
-      Braintree::Configuration.instantiate.ssl?.should == true
+      expect(Braintree::Configuration.instantiate.ssl?).to eq(true)
     end
   end
 
@@ -455,20 +455,20 @@ describe Braintree::Configuration do
 
     it "appends the default user_agent with the given value" do
       Braintree::Configuration.custom_user_agent = "ActiveMerchant 1.2.3"
-      Braintree::Configuration.instantiate.user_agent.should == "Braintree Ruby Gem #{Braintree::Version::String} (ActiveMerchant 1.2.3)"
+      expect(Braintree::Configuration.instantiate.user_agent).to eq("Braintree Ruby Gem #{Braintree::Version::String} (ActiveMerchant 1.2.3)")
     end
 
     it "does not append anything if there is no custom_user_agent" do
       Braintree::Configuration.custom_user_agent = nil
-      Braintree::Configuration.instantiate.user_agent.should == "Braintree Ruby Gem #{Braintree::Version::String}"
+      expect(Braintree::Configuration.instantiate.user_agent).to eq("Braintree Ruby Gem #{Braintree::Version::String}")
     end
   end
 
   describe "inspect" do
     it "masks the private_key" do
       config = Braintree::Configuration.new(:private_key => "secret_key")
-      config.inspect.should include('@private_key="[FILTERED]"')
-      config.inspect.should_not include("secret_key")
+      expect(config.inspect).to include('@private_key="[FILTERED]"')
+      expect(config.inspect).not_to include("secret_key")
     end
   end
 
@@ -476,7 +476,7 @@ describe Braintree::Configuration do
     it "has a signature service initialized with the private key" do
       config = Braintree::Configuration.new(:private_key => "secret_key")
 
-      config.signature_service.key.should == "secret_key"
+      expect(config.signature_service.key).to eq("secret_key")
     end
   end
 end

data/spec/unit/braintree/credentials_parser_spec.rb

@@ -6,9 +6,9 @@ describe Braintree::CredentialsParser do
       parser = Braintree::CredentialsParser.new
       parser.parse_client_credentials("client_id$development$integration_client_id", "client_secret$development$integration_client_secret")
 
-      parser.client_id.should == "client_id$development$integration_client_id"
-      parser.client_secret.should == "client_secret$development$integration_client_secret"
-      parser.environment.should == :development
+      expect(parser.client_id).to eq("client_id$development$integration_client_id")
+      expect(parser.client_secret).to eq("client_secret$development$integration_client_secret")
+      expect(parser.environment).to eq(:development)
     end
 
     it "raises error on inconsistent environment" do
@@ -57,9 +57,9 @@ describe Braintree::CredentialsParser do
       parser = Braintree::CredentialsParser.new
       parser.parse_access_token("access_token$development$integration_merchant_id$fb27c79dd")
 
-      parser.merchant_id.should == "integration_merchant_id"
-      parser.access_token.should == "access_token$development$integration_merchant_id$fb27c79dd"
-      parser.environment.should == :development
+      expect(parser.merchant_id).to eq("integration_merchant_id")
+      expect(parser.access_token).to eq("access_token$development$integration_merchant_id$fb27c79dd")
+      expect(parser.environment).to eq(:development)
     end
 
     it "raises error on nil access_token" do