braintree 4.14.0 → 4.15.0

data/spec/unit/braintree/credit_card_spec.rb

@@ -20,11 +20,12 @@ describe Braintree::CreditCard do
         :expiration_year,
         :number,
         :token,
-        :venmo_sdk_payment_method_code,
+        :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
         :device_data,
         :payment_method_nonce,
         {:external_vault=>[:network_transaction_id]},
-        {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
+        {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
+          :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -66,11 +67,12 @@ describe Braintree::CreditCard do
         :expiration_year,
         :number,
         :token,
-        :venmo_sdk_payment_method_code,
+        :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
         :device_data,
         :payment_method_nonce,
         {:external_vault=>[:network_transaction_id]},
-        {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
+        {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
+          :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -106,31 +108,31 @@ describe Braintree::CreditCard do
       first = Braintree::CreditCard._new(:gateway, :token => 123)
       second = Braintree::CreditCard._new(:gateway, :token => 123)
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false if given a credit card with a different token" do
       first = Braintree::CreditCard._new(:gateway, :token => 123)
       second = Braintree::CreditCard._new(:gateway, :token => 124)
 
-      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 not given a credit card" do
       credit_card = Braintree::CreditCard._new(:gateway, :token => 123)
-      credit_card.should_not == "not a credit card"
+      expect(credit_card).not_to eq("not a credit card")
     end
   end
 
   describe "default?" do
     it "is true if the credit card is the default credit card for the customer" do
-      Braintree::CreditCard._new(:gateway, :default => true).default?.should == true
+      expect(Braintree::CreditCard._new(:gateway, :default => true).default?).to eq(true)
     end
 
     it "is false if the credit card is not the default credit card for the customer" do
-      Braintree::CreditCard._new(:gateway, :default => false).default?.should == false
+      expect(Braintree::CreditCard._new(:gateway, :default => false).default?).to eq(false)
     end
   end
 
@@ -154,7 +156,7 @@ describe Braintree::CreditCard 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::CreditCard.find(8675309)
       end.to_not raise_error
@@ -164,7 +166,7 @@ describe Braintree::CreditCard do
   describe "inspect" do
     it "includes the token first" do
       output = Braintree::CreditCard._new(:gateway, :token => "cc123").inspect
-      output.should include("#<Braintree::CreditCard token: \"cc123\",")
+      expect(output).to include("#<Braintree::CreditCard token: \"cc123\",")
     end
 
     it "includes all customer attributes" do
@@ -183,18 +185,18 @@ describe Braintree::CreditCard do
         :is_network_tokenized => false,
       )
       output = credit_card.inspect
-      output.should include(%q(bin: "411111"))
-      output.should include(%q(card_type: "Visa"))
-      output.should include(%q(cardholder_name: "John Miller"))
+      expect(output).to include(%q(bin: "411111"))
+      expect(output).to include(%q(card_type: "Visa"))
+      expect(output).to include(%q(cardholder_name: "John Miller"))
 
-      output.should include(%q(customer_id: "cid1"))
-      output.should include(%q(expiration_month: "01"))
-      output.should include(%q(expiration_year: "2020"))
-      output.should include(%q(last_4: "1111"))
-      output.should include(%q(token: "tok1"))
-      output.should include(%Q(updated_at: #{credit_card.updated_at.inspect}))
-      output.should include(%Q(created_at: #{credit_card.created_at.inspect}))
-      output.should include(%q(is_network_tokenized?: false))
+      expect(output).to include(%q(customer_id: "cid1"))
+      expect(output).to include(%q(expiration_month: "01"))
+      expect(output).to include(%q(expiration_year: "2020"))
+      expect(output).to include(%q(last_4: "1111"))
+      expect(output).to include(%q(token: "tok1"))
+      expect(output).to include(%Q(updated_at: #{credit_card.updated_at.inspect}))
+      expect(output).to include(%Q(created_at: #{credit_card.created_at.inspect}))
+      expect(output).to include(%q(is_network_tokenized?: false))
     end
   end
 
@@ -205,7 +207,7 @@ describe Braintree::CreditCard do
         :bin => "510510",
         :last_4 => "5100",
       )
-      credit_card.masked_number.should == "510510******5100"
+      expect(credit_card.masked_number).to eq("510510******5100")
     end
   end
 
@@ -217,7 +219,7 @@ describe Braintree::CreditCard do
         :last_4 => "5100",
         :is_network_tokenized => true,
       )
-      credit_card.is_network_tokenized?.should == true
+      expect(credit_card.is_network_tokenized?).to eq(true)
     end
 
     it "returns false" do
@@ -227,7 +229,7 @@ describe Braintree::CreditCard do
         :last_4 => "5100",
         :is_network_tokenized => false,
       )
-      credit_card.is_network_tokenized?.should == false
+      expect(credit_card.is_network_tokenized?).to eq(false)
     end
   end
 
@@ -253,12 +255,12 @@ describe Braintree::CreditCard do
         verification1 = {:created_at => Time.now, :id => 123}
         verification2 = {:created_at => Time.now - 3600, :id => 456}
         credit_card = Braintree::CreditCard._new(Braintree::Configuration.gateway, {:verifications => [verification1, verification2]})
-        credit_card.verification.id.should == 123
+        expect(credit_card.verification.id).to eq(123)
       end
 
       it "picks nil if verifications are empty" do
         credit_card = Braintree::CreditCard._new(Braintree::Configuration.gateway, {})
-        credit_card.verification.should be_nil
+        expect(credit_card.verification).to be_nil
       end
     end
   end

data/spec/unit/braintree/credit_card_verification_gateway_spec.rb

@@ -14,38 +14,38 @@ describe Braintree::CreditCardVerificationGateway do
     it "creates a credit card verification gateway" do
       result = Braintree::CreditCardVerificationGateway.new(gateway)
 
-      result.inspect.should include("merchant_id")
-      result.inspect.should include("public_key")
-      result.inspect.should include("private_key")
+      expect(result.inspect).to include("merchant_id")
+      expect(result.inspect).to include("public_key")
+      expect(result.inspect).to include("private_key")
     end
 
     it "creates a credit card verification gateway signature" do
       result = Braintree::CreditCardVerificationGateway._create_signature
-      result.inspect.should include("credit_card")
-      result.inspect.should include("credit_card")
-      result.inspect.should include("cardholder_name")
-      result.inspect.should include("cvv")
-      result.inspect.should include("expiration_date")
-      result.inspect.should include("expiration_month")
-      result.inspect.should include("expiration_year")
-      result.inspect.should include("number")
-      result.inspect.should include("billing_address")
-      result.inspect.should include("intended_transaction_source")
-      result.inspect.should include("options")
-      result.inspect.should include("amount")
-      result.inspect.should include("merchant_account_id")
-      result.inspect.should include("account_type")
-      result.inspect.should include("payment_method_nonce")
-      result.inspect.should include("three_d_secure_authentication_id")
-      result.inspect.should include("three_d_secure_pass_thru")
-      result.inspect.should include("eci_flag")
-      result.inspect.should include("cavv")
-      result.inspect.should include("xid")
-      result.inspect.should include("three_d_secure_version")
-      result.inspect.should include("authentication_response")
-      result.inspect.should include("directory_response")
-      result.inspect.should include("cavv_algorithm")
-      result.inspect.should include("ds_transaction_id")
+      expect(result.inspect).to include("credit_card")
+      expect(result.inspect).to include("credit_card")
+      expect(result.inspect).to include("cardholder_name")
+      expect(result.inspect).to include("cvv")
+      expect(result.inspect).to include("expiration_date")
+      expect(result.inspect).to include("expiration_month")
+      expect(result.inspect).to include("expiration_year")
+      expect(result.inspect).to include("number")
+      expect(result.inspect).to include("billing_address")
+      expect(result.inspect).to include("intended_transaction_source")
+      expect(result.inspect).to include("options")
+      expect(result.inspect).to include("amount")
+      expect(result.inspect).to include("merchant_account_id")
+      expect(result.inspect).to include("account_type")
+      expect(result.inspect).to include("payment_method_nonce")
+      expect(result.inspect).to include("three_d_secure_authentication_id")
+      expect(result.inspect).to include("three_d_secure_pass_thru")
+      expect(result.inspect).to include("eci_flag")
+      expect(result.inspect).to include("cavv")
+      expect(result.inspect).to include("xid")
+      expect(result.inspect).to include("three_d_secure_version")
+      expect(result.inspect).to include("authentication_response")
+      expect(result.inspect).to include("directory_response")
+      expect(result.inspect).to include("cavv_algorithm")
+      expect(result.inspect).to include("ds_transaction_id")
     end
   end
 end

data/spec/unit/braintree/credit_card_verification_search_spec.rb

@@ -7,11 +7,11 @@ module Braintree
       it "allows All card types" do
         search = CreditCardVerificationSearch.new
 
-        lambda do
+        expect do
           search.credit_card_card_type.in(
             *Braintree::CreditCard::CardType::All,
           )
-        end.should_not raise_error
+        end.not_to raise_error
       end
     end
 
@@ -20,7 +20,7 @@ module Braintree
         search = CreditCardVerificationSearch.new
         search.id.is "v_id"
 
-        search.to_hash.should == {:id => {:is => "v_id"}}
+        expect(search.to_hash).to eq({:id => {:is => "v_id"}})
       end
     end
 
@@ -29,7 +29,7 @@ module Braintree
         search = CreditCardVerificationSearch.new
         search.ids.in("id1","id2")
 
-        search.to_hash.should == {:ids => ["id1", "id2"]}
+        expect(search.to_hash).to eq({:ids => ["id1", "id2"]})
       end
     end
 
@@ -38,7 +38,7 @@ module Braintree
         search = CreditCardVerificationSearch.new
         search.credit_card_cardholder_name.is "v_cardholder_name"
 
-        search.to_hash.should == {:credit_card_cardholder_name => {:is => "v_cardholder_name"}}
+        expect(search.to_hash).to eq({:credit_card_cardholder_name => {:is => "v_cardholder_name"}})
       end
     end
 
@@ -47,7 +47,7 @@ module Braintree
         search = CreditCardVerificationSearch.new
         search.credit_card_expiration_date.is_not "v_credit_card_expiration_date"
 
-        search.to_hash.should == {:credit_card_expiration_date => {:is_not => "v_credit_card_expiration_date"}}
+        expect(search.to_hash).to eq({:credit_card_expiration_date => {:is_not => "v_credit_card_expiration_date"}})
       end
     end
 
@@ -57,7 +57,7 @@ module Braintree
 
         search.credit_card_number.starts_with "v_credit_card_bin"
 
-        search.to_hash.should == {:credit_card_number => {:starts_with => "v_credit_card_bin"}}
+        expect(search.to_hash).to eq({:credit_card_number => {:starts_with => "v_credit_card_bin"}})
       end
 
       it "ends with" do
@@ -65,14 +65,14 @@ module Braintree
 
         search.credit_card_number.ends_with "v_credit_card_last_4"
 
-        search.to_hash.should == {:credit_card_number => {:ends_with => "v_credit_card_last_4"}}
+        expect(search.to_hash).to eq({:credit_card_number => {:ends_with => "v_credit_card_last_4"}})
       end
     end
 
     context "created_at" do
       it "is a range node" do
         search = CreditCardVerificationSearch.new
-        search.created_at.should be_kind_of(Braintree::AdvancedSearch::RangeNode)
+        expect(search.created_at).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
       end
     end
   end

data/spec/unit/braintree/credit_card_verification_spec.rb

@@ -18,7 +18,7 @@ describe Braintree::CreditCardVerification do
         :network_response_text => "Do not Honor",
       )
 
-      verification.inspect.should == %(#<Braintree::CreditCardVerification status: "verified", processor_response_code: "2000", processor_response_text: "Do Not Honor", amount: "12.45", currency_iso_code: "USD", cvv_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", network_response_code: "05", network_response_text: "Do not Honor", merchant_account_id: "some_id", gateway_rejection_reason: nil, id: nil, credit_card: nil, billing: nil, created_at: nil>)
+      expect(verification.inspect).to eq(%(#<Braintree::CreditCardVerification status: "verified", processor_response_code: "2000", processor_response_text: "Do Not Honor", amount: "12.45", currency_iso_code: "USD", cvv_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", network_response_code: "05", network_response_text: "Do not Honor", merchant_account_id: "some_id", gateway_rejection_reason: nil, id: nil, credit_card: nil, billing: nil, created_at: nil>))
     end
 
     it "has a status" do
@@ -33,13 +33,13 @@ describe Braintree::CreditCardVerification do
         :merchant_account_id => "some_id",
       )
 
-      verification.status.should == Braintree::CreditCardVerification::Status::Verified
+      expect(verification.status).to eq(Braintree::CreditCardVerification::Status::Verified)
     end
   end
 
   it "accepts amount as either a String or BigDecimal" do
-    Braintree::CreditCardVerification._new(:amount => "12.34").amount.should == BigDecimal("12.34")
-    Braintree::CreditCardVerification._new(:amount => BigDecimal("12.34")).amount.should == BigDecimal("12.34")
+    expect(Braintree::CreditCardVerification._new(:amount => "12.34").amount).to eq(BigDecimal("12.34"))
+    expect(Braintree::CreditCardVerification._new(:amount => BigDecimal("12.34")).amount).to eq(BigDecimal("12.34"))
   end
 
   it "accepts network_transaction_id" do
@@ -88,27 +88,27 @@ describe Braintree::CreditCardVerification do
       first = Braintree::CreditCardVerification._new(:id => 123)
       second = Braintree::CreditCardVerification._new(:id => 123)
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false for verifications with different ids" do
       first = Braintree::CreditCardVerification._new(:id => 123)
       second = Braintree::CreditCardVerification._new(:id => 124)
 
-      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 comparing to nil" do
-      Braintree::CreditCardVerification._new({}).should_not == nil
+      expect(Braintree::CreditCardVerification._new({})).not_to eq(nil)
     end
 
     it "returns false when comparing to non-verifications" do
       same_id_different_object = Object.new
       def same_id_different_object.id; 123; end
       verification = Braintree::CreditCardVerification._new(:id => 123)
-      verification.should_not == same_id_different_object
+      expect(verification).not_to eq(same_id_different_object)
     end
   end
 
@@ -123,17 +123,17 @@ describe Braintree::CreditCardVerification do
         :transaction_risk_score => "12",
       })
 
-      verification.risk_data.id.should == "123"
-      verification.risk_data.decision.should == "WOO YOU WON $1000 dollars"
-      verification.risk_data.decision_reasons.should == ["reason"]
-      verification.risk_data.device_data_captured.should == true
-      verification.risk_data.fraud_service_provider.should == "paypal_fraud_protection"
-      verification.risk_data.transaction_risk_score.should == "12"
+      expect(verification.risk_data.id).to eq("123")
+      expect(verification.risk_data.decision).to eq("WOO YOU WON $1000 dollars")
+      expect(verification.risk_data.decision_reasons).to eq(["reason"])
+      expect(verification.risk_data.device_data_captured).to eq(true)
+      expect(verification.risk_data.fraud_service_provider).to eq("paypal_fraud_protection")
+      expect(verification.risk_data.transaction_risk_score).to eq("12")
     end
 
     it "handles a nil risk_data" do
       verification = Braintree::CreditCardVerification._new(:risk_data => nil)
-      verification.risk_data.should be_nil
+      expect(verification.risk_data).to be_nil
     end
   end
 

data/spec/unit/braintree/customer_spec.rb

@@ -4,7 +4,7 @@ describe Braintree::Customer do
   describe "inspect" do
     it "includes the id first" do
       output = Braintree::Customer._new(:gateway, {:first_name => "Dan", :id => "1234"}).inspect
-      output.should include("#<Braintree::Customer id: \"1234\",")
+      expect(output).to include("#<Braintree::Customer id: \"1234\",")
     end
 
     it "includes all customer attributes" do
@@ -21,19 +21,19 @@ describe Braintree::Customer do
         :updated_at => Time.now,
       )
       output = customer.inspect
-      output.should include(%q(company: "Company"))
-      output.should include(%q(email: "e@mail.com"))
-      output.should include(%q(fax: "483-438-5821"))
-      output.should include(%q(first_name: "Patrick"))
-      output.should include(%q(last_name: "Smith"))
-      output.should include(%q(phone: "802-483-5932"))
-      output.should include(%q(website: "patrick.smith.com"))
-      output.should include(%q(addresses: []))
-      output.should include(%q(credit_cards: []))
-      output.should include(%q(paypal_accounts: []))
-      output.should include(%q(tax_identifiers: []))
-      output.should include(%Q(created_at: #{customer.created_at.inspect}))
-      output.should include(%Q(updated_at: #{customer.updated_at.inspect}))
+      expect(output).to include(%q(company: "Company"))
+      expect(output).to include(%q(email: "e@mail.com"))
+      expect(output).to include(%q(fax: "483-438-5821"))
+      expect(output).to include(%q(first_name: "Patrick"))
+      expect(output).to include(%q(last_name: "Smith"))
+      expect(output).to include(%q(phone: "802-483-5932"))
+      expect(output).to include(%q(website: "patrick.smith.com"))
+      expect(output).to include(%q(addresses: []))
+      expect(output).to include(%q(credit_cards: []))
+      expect(output).to include(%q(paypal_accounts: []))
+      expect(output).to include(%q(tax_identifiers: []))
+      expect(output).to include(%Q(created_at: #{customer.created_at.inspect}))
+      expect(output).to include(%Q(updated_at: #{customer.updated_at.inspect}))
     end
   end
 
@@ -59,7 +59,7 @@ describe Braintree::Customer do
     end
 
     it "does not raise an exception if the id is a fixnum" 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::Customer.find(8675309)
       end.to_not raise_error
@@ -97,11 +97,12 @@ describe Braintree::Customer do
           :expiration_year,
           :number,
           :token,
-          :venmo_sdk_payment_method_code,
+          :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
           :device_data,
           :payment_method_nonce,
           {:external_vault=>[:network_transaction_id]},
-          {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
+          {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
+            :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
           {:billing_address => [
             :company,
             :country_code_alpha2,
@@ -190,7 +191,7 @@ describe Braintree::Customer do
           :expiration_year,
           :number,
           :token,
-          :venmo_sdk_payment_method_code,
+          :venmo_sdk_payment_method_code, # NEXT_MAJOR_VERSION Remove this attribute
           :device_data,
           :payment_method_nonce,
           {:external_vault=>[:network_transaction_id]},
@@ -200,7 +201,7 @@ describe Braintree::Customer do
             :verification_merchant_account_id,
             :verify_card,
             :verification_amount,
-            :venmo_sdk_session,
+            :venmo_sdk_session, # NEXT_MAJOR_VERSION Remove this attribute
             :fail_on_duplicate_payment_method,
             :verification_account_type,
             :verification_currency_iso_code,
@@ -271,21 +272,21 @@ describe Braintree::Customer do
       first = Braintree::Customer._new(:gateway, :id => 123)
       second = Braintree::Customer._new(:gateway, :id => 123)
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false when given a customer with a different id" do
       first = Braintree::Customer._new(:gateway, :id => 123)
       second = Braintree::Customer._new(:gateway, :id => 124)
 
-      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 a customer" do
       customer = Braintree::Customer._new(:gateway, :id => 123)
-      customer.should_not == "not a customer"
+      expect(customer).not_to eq("not a customer")
     end
   end
 
@@ -307,25 +308,25 @@ describe Braintree::Customer do
         ],
       )
 
-      customer.credit_cards.size.should == 2
-      customer.credit_cards[0].token.should == "credit_card_1"
-      customer.credit_cards[1].token.should == "credit_card_2"
+      expect(customer.credit_cards.size).to eq(2)
+      expect(customer.credit_cards[0].token).to eq("credit_card_1")
+      expect(customer.credit_cards[1].token).to eq("credit_card_2")
 
-      customer.paypal_accounts.size.should == 2
-      customer.paypal_accounts[0].token.should == "paypal_1"
-      customer.paypal_accounts[1].token.should == "paypal_2"
+      expect(customer.paypal_accounts.size).to eq(2)
+      expect(customer.paypal_accounts[0].token).to eq("paypal_1")
+      expect(customer.paypal_accounts[1].token).to eq("paypal_2")
 
-      customer.sepa_direct_debit_accounts.size.should == 2
-      customer.sepa_direct_debit_accounts[0].token.should == "sepa_debit_1"
-      customer.sepa_direct_debit_accounts[1].token.should == "sepa_debit_2"
+      expect(customer.sepa_direct_debit_accounts.size).to eq(2)
+      expect(customer.sepa_direct_debit_accounts[0].token).to eq("sepa_debit_1")
+      expect(customer.sepa_direct_debit_accounts[1].token).to eq("sepa_debit_2")
 
-      customer.payment_methods.count.should == 6
-      customer.payment_methods.map(&:token).should include("credit_card_1")
-      customer.payment_methods.map(&:token).should include("credit_card_2")
-      customer.payment_methods.map(&:token).should include("paypal_1")
-      customer.payment_methods.map(&:token).should include("paypal_2")
-      customer.payment_methods.map(&:token).should include("sepa_debit_1")
-      customer.payment_methods.map(&:token).should include("sepa_debit_2")
+      expect(customer.payment_methods.count).to eq(6)
+      expect(customer.payment_methods.map(&:token)).to include("credit_card_1")
+      expect(customer.payment_methods.map(&:token)).to include("credit_card_2")
+      expect(customer.payment_methods.map(&:token)).to include("paypal_1")
+      expect(customer.payment_methods.map(&:token)).to include("paypal_2")
+      expect(customer.payment_methods.map(&:token)).to include("sepa_debit_1")
+      expect(customer.payment_methods.map(&:token)).to include("sepa_debit_2")
     end
   end
 

data/spec/unit/braintree/digest_spec.rb

@@ -6,13 +6,13 @@ describe Braintree::Digest do
       original_key = Braintree::Configuration.private_key
       private_key = "\xaa" * 80
       data = "Test Using Larger Than Block-Size Key - Hash Key First"
-      Braintree::Digest.hexdigest(private_key, data).should == "aa4ae5e15272d00e95705637ce8a3b55ed402112"
+      expect(Braintree::Digest.hexdigest(private_key, data)).to eq("aa4ae5e15272d00e95705637ce8a3b55ed402112")
     end
 
     it "returns the sha1 hmac of the input string (test case 7 from RFC 2202)" do
       private_key = "\xaa" * 80
       data = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
-      Braintree::Digest.hexdigest(private_key, data).should == "e8e99d0f45237d786d6bbaa7965c7808bbff1a91"
+      expect(Braintree::Digest.hexdigest(private_key, data)).to eq("e8e99d0f45237d786d6bbaa7965c7808bbff1a91")
     end
 
     it "doesn't blow up if message is nil" do
@@ -22,15 +22,15 @@ describe Braintree::Digest do
 
   describe "self.secure_compare" do
     it "returns true if two strings are equal" do
-      Braintree::Digest.secure_compare("A_string", "A_string").should be(true)
+      expect(Braintree::Digest.secure_compare("A_string", "A_string")).to be(true)
     end
 
     it "returns false if two strings are different and the same length" do
-      Braintree::Digest.secure_compare("A_string", "A_strong").should be(false)
+      expect(Braintree::Digest.secure_compare("A_string", "A_strong")).to be(false)
     end
 
     it "returns false if one is a prefix of the other" do
-      Braintree::Digest.secure_compare("A_string", "A_string_that_is_longer").should be(false)
+      expect(Braintree::Digest.secure_compare("A_string", "A_string_that_is_longer")).to be(false)
     end
   end
 end

data/spec/unit/braintree/disbursement_spec.rb

@@ -31,15 +31,15 @@ describe Braintree::Disbursement do
         :success => false,
       )
 
-      disbursement.inspect.should include('id: "123456"')
-      disbursement.inspect.should include('amount: "100.0"')
-      disbursement.inspect.should include('exception_message: "invalid_account_number"')
-      disbursement.inspect.should include("disbursement_date: 2013-04-10")
-      disbursement.inspect.should include('follow_up_action: "update"')
-      disbursement.inspect.should include("merchant_account: #<Braintree::MerchantAccount: ")
-      disbursement.inspect.should include('transaction_ids: ["sub_merchant_transaction"]')
-      disbursement.inspect.should include("retry: false")
-      disbursement.inspect.should include("success: false")
+      expect(disbursement.inspect).to include('id: "123456"')
+      expect(disbursement.inspect).to include('amount: "100.0"')
+      expect(disbursement.inspect).to include('exception_message: "invalid_account_number"')
+      expect(disbursement.inspect).to include("disbursement_date: 2013-04-10")
+      expect(disbursement.inspect).to include('follow_up_action: "update"')
+      expect(disbursement.inspect).to include("merchant_account: #<Braintree::MerchantAccount: ")
+      expect(disbursement.inspect).to include('transaction_ids: ["sub_merchant_transaction"]')
+      expect(disbursement.inspect).to include("retry: false")
+      expect(disbursement.inspect).to include("success: false")
     end
   end
 
@@ -58,7 +58,7 @@ describe Braintree::Disbursement do
         :success => false,
         :disbursement_date => "2013-04-10",
       )
-      disbursement.success?.should == false
+      expect(disbursement.success?).to eq(false)
 
       disbursement = Braintree::Disbursement._new(
         :gateway,
@@ -73,7 +73,7 @@ describe Braintree::Disbursement do
         :success => true,
         :disbursement_date => "2013-04-10",
       )
-      disbursement.success?.should == true
+      expect(disbursement.success?).to eq(true)
     end
   end
 

data/spec/unit/braintree/dispute_search_spec.rb

@@ -5,14 +5,14 @@ describe Braintree::DisputeSearch do
     search = Braintree::DisputeSearch.new
     search.id.is "dispute1"
     search.id.is "dispute2"
-    search.to_hash.should == {:id => {:is => "dispute2"}}
+    expect(search.to_hash).to eq({:id => {:is => "dispute2"}})
   end
 
   it "overrides previous 'in' with new 'in' for the same field" do
     search = Braintree::DisputeSearch.new
     search.status.in Braintree::Dispute::Status::Open
     search.status.in Braintree::Dispute::Status::Won
-    search.to_hash.should == {:status => [Braintree::Dispute::Status::Won]}
+    expect(search.to_hash).to eq({:status => [Braintree::Dispute::Status::Won]})
   end
 
   [