braintree 2.98.0 → 4.23.0

data/spec/unit/braintree/transaction_spec.rb

@@ -17,45 +17,38 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "self.create_from_transparent_redirect" do
-    it "raises an exception if the query string is forged" do
-      expect do
-        Braintree::Transaction.create_from_transparent_redirect("http_status=200&forged=query_string")
-      end.to raise_error(Braintree::ForgedQueryString)
-    end
-  end
-
   describe "self.find" do
     it "raises error if passed empty string" do
       expect do
         Braintree::Transaction.find("")
-      end.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError, "id can not be empty")
     end
 
     it "raises error if passed empty string wth space" do
       expect do
         Braintree::Transaction.find(" ")
-      end.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError, "id can not be empty")
     end
 
     it "raises error if passed nil" do
       expect do
         Braintree::Transaction.find(nil)
-      end.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError, "id can not be empty")
     end
   end
 
-  describe "self.create_transaction_url" do
-    it "returns the url" do
-      config = Braintree::Configuration.instantiate
-      Braintree::Transaction.create_transaction_url.should == "http#{config.ssl? ? 's' : ''}://#{config.server}:#{config.port}/merchants/integration_merchant_id/transactions/all/create_via_transparent_redirect_request"
+  describe "self.submit_for_settlement" do
+    it "raises an ArgumentError if transaction_id is an invalid format" do
+      expect do
+        Braintree::Transaction.submit_for_settlement("invalid-transaction-id")
+      end.to raise_error(ArgumentError, "transaction_id is invalid")
     end
   end
 
-  describe "self.submit_for_settlement" do
+  describe "self.adjust_authorization" do
     it "raises an ArgumentError if transaction_id is an invalid format" do
       expect do
-        Braintree::Transaction.submit_for_settlement("invalid-transaction-id")
+        Braintree::Transaction.adjust_authorization("invalid-transaction-id", "10.00")
       end.to raise_error(ArgumentError, "transaction_id is invalid")
     end
   end
@@ -81,16 +74,16 @@ describe Braintree::Transaction do
           :website => "lednerllc.com",
           :phone => "1-999-652-4189 x56883",
           :fax => "012-161-8055"
-        }
+        },
       )
-      transaction.customer_details.id.should == "123"
-      transaction.customer_details.first_name.should == "Adam"
-      transaction.customer_details.last_name.should == "Taylor"
-      transaction.customer_details.company.should == "Ledner LLC"
-      transaction.customer_details.email.should == "adam.taylor@lednerllc.com"
-      transaction.customer_details.website.should == "lednerllc.com"
-      transaction.customer_details.phone.should == "1-999-652-4189 x56883"
-      transaction.customer_details.fax.should == "012-161-8055"
+      expect(transaction.customer_details.id).to eq("123")
+      expect(transaction.customer_details.first_name).to eq("Adam")
+      expect(transaction.customer_details.last_name).to eq("Taylor")
+      expect(transaction.customer_details.company).to eq("Ledner LLC")
+      expect(transaction.customer_details.email).to eq("adam.taylor@lednerllc.com")
+      expect(transaction.customer_details.website).to eq("lednerllc.com")
+      expect(transaction.customer_details.phone).to eq("1-999-652-4189 x56883")
+      expect(transaction.customer_details.fax).to eq("012-161-8055")
     end
 
     it "sets up disbursement attributes in disbursement_details" do
@@ -103,15 +96,15 @@ describe Braintree::Transaction do
           :settlement_currency_exchange_rate => "1",
           :funds_held => false,
           :success => true
-        }
+        },
       )
       disbursement = transaction.disbursement_details
-      disbursement.disbursement_date.should == "2013-04-03"
-      disbursement.settlement_amount.should == "120.00"
-      disbursement.settlement_currency_iso_code.should == "USD"
-      disbursement.settlement_currency_exchange_rate.should == "1"
-      disbursement.funds_held?.should be(false)
-      disbursement.success?.should be(true)
+      expect(disbursement.disbursement_date).to eq(Date.parse("2013-04-03"))
+      expect(disbursement.settlement_amount).to eq("120.00")
+      expect(disbursement.settlement_currency_iso_code).to eq("USD")
+      expect(disbursement.settlement_currency_exchange_rate).to eq("1")
+      expect(disbursement.funds_held?).to be(false)
+      expect(disbursement.success?).to be(true)
     end
 
     it "sets up credit card attributes in credit_card_details" do
@@ -134,24 +127,66 @@ describe Braintree::Transaction do
           :product_id => "Unknown",
           :country_of_issuance => "Narnia",
           :issuing_bank => "Mr Tumnus"
-        }
+        },
       )
-      transaction.credit_card_details.token.should == "mzg2"
-      transaction.credit_card_details.bin.should == "411111"
-      transaction.credit_card_details.last_4.should == "1111"
-      transaction.credit_card_details.card_type.should == "Visa"
-      transaction.credit_card_details.expiration_month.should == "08"
-      transaction.credit_card_details.expiration_year.should == "2009"
-      transaction.credit_card_details.customer_location.should == "US"
-      transaction.credit_card_details.prepaid.should == Braintree::CreditCard::Prepaid::Yes
-      transaction.credit_card_details.healthcare.should == Braintree::CreditCard::Healthcare::Yes
-      transaction.credit_card_details.durbin_regulated.should == Braintree::CreditCard::DurbinRegulated::Yes
-      transaction.credit_card_details.debit.should == Braintree::CreditCard::Debit::Yes
-      transaction.credit_card_details.commercial.should == Braintree::CreditCard::Commercial::No
-      transaction.credit_card_details.payroll.should == Braintree::CreditCard::Payroll::Unknown
-      transaction.credit_card_details.product_id.should == Braintree::CreditCard::ProductId::Unknown
-      transaction.credit_card_details.country_of_issuance.should == "Narnia"
-      transaction.credit_card_details.issuing_bank.should == "Mr Tumnus"
+      expect(transaction.credit_card_details.token).to eq("mzg2")
+      expect(transaction.credit_card_details.bin).to eq("411111")
+      expect(transaction.credit_card_details.last_4).to eq("1111")
+      expect(transaction.credit_card_details.card_type).to eq("Visa")
+      expect(transaction.credit_card_details.expiration_month).to eq("08")
+      expect(transaction.credit_card_details.expiration_year).to eq("2009")
+      expect(transaction.credit_card_details.customer_location).to eq("US")
+      expect(transaction.credit_card_details.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
+      expect(transaction.credit_card_details.healthcare).to eq(Braintree::CreditCard::Healthcare::Yes)
+      expect(transaction.credit_card_details.durbin_regulated).to eq(Braintree::CreditCard::DurbinRegulated::Yes)
+      expect(transaction.credit_card_details.debit).to eq(Braintree::CreditCard::Debit::Yes)
+      expect(transaction.credit_card_details.commercial).to eq(Braintree::CreditCard::Commercial::No)
+      expect(transaction.credit_card_details.payroll).to eq(Braintree::CreditCard::Payroll::Unknown)
+      expect(transaction.credit_card_details.product_id).to eq(Braintree::CreditCard::ProductId::Unknown)
+      expect(transaction.credit_card_details.country_of_issuance).to eq("Narnia")
+      expect(transaction.credit_card_details.issuing_bank).to eq("Mr Tumnus")
+    end
+
+    it "sets up network token attributes in network_token_details" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :network_token => {
+          :token => "mzg2",
+          :bin => "411111",
+          :last_4 => "1111",
+          :card_type => "Visa",
+          :expiration_month => "08",
+          :expiration_year => "2009",
+          :customer_location => "US",
+          :prepaid => "Yes",
+          :healthcare => "Yes",
+          :durbin_regulated => "Yes",
+          :debit => "Yes",
+          :commercial => "No",
+          :payroll => "Unknown",
+          :product_id => "Unknown",
+          :country_of_issuance => "Narnia",
+          :issuing_bank => "Mr Tumnus",
+          :is_network_tokenized => true
+        },
+      )
+      expect(transaction.network_token_details.token).to eq("mzg2")
+      expect(transaction.network_token_details.bin).to eq("411111")
+      expect(transaction.network_token_details.last_4).to eq("1111")
+      expect(transaction.network_token_details.card_type).to eq("Visa")
+      expect(transaction.network_token_details.expiration_month).to eq("08")
+      expect(transaction.network_token_details.expiration_year).to eq("2009")
+      expect(transaction.network_token_details.customer_location).to eq("US")
+      expect(transaction.network_token_details.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
+      expect(transaction.network_token_details.healthcare).to eq(Braintree::CreditCard::Healthcare::Yes)
+      expect(transaction.network_token_details.durbin_regulated).to eq(Braintree::CreditCard::DurbinRegulated::Yes)
+      expect(transaction.network_token_details.debit).to eq(Braintree::CreditCard::Debit::Yes)
+      expect(transaction.network_token_details.commercial).to eq(Braintree::CreditCard::Commercial::No)
+      expect(transaction.network_token_details.payroll).to eq(Braintree::CreditCard::Payroll::Unknown)
+      expect(transaction.network_token_details.product_id).to eq(Braintree::CreditCard::ProductId::Unknown)
+      expect(transaction.network_token_details.country_of_issuance).to eq("Narnia")
+      expect(transaction.network_token_details.issuing_bank).to eq("Mr Tumnus")
+      expect(transaction.network_token_details.is_network_tokenized?).to eq(true)
     end
 
     it "sets up three_d_secure_info" do
@@ -162,32 +197,13 @@ describe Braintree::Transaction do
           :liability_shifted => true,
           :liability_shift_possible => true,
           :status => "authenticate_successful",
-        }
-      )
-
-      transaction.three_d_secure_info.enrolled.should == "Y"
-      transaction.three_d_secure_info.status.should == "authenticate_successful"
-      transaction.three_d_secure_info.liability_shifted.should == true
-      transaction.three_d_secure_info.liability_shift_possible.should == true
-    end
-
-    it "sets up ideal_payment_details" do
-      transaction = Braintree::Transaction._new(
-        :gateway,
-        :ideal_payment => {
-          :ideal_payment_id => "idealpayment_abc_123",
-          :ideal_transaction_id => "1150000008857321",
-          :masked_iban => "12************7890",
-          :bic => "RABONL2U",
-          :image_url => "http://www.example.com/ideal.png"
-        }
+        },
       )
 
-      transaction.ideal_payment_details.ideal_payment_id.should == "idealpayment_abc_123"
-      transaction.ideal_payment_details.ideal_transaction_id.should == "1150000008857321"
-      transaction.ideal_payment_details.masked_iban.should == "12************7890"
-      transaction.ideal_payment_details.bic.should == "RABONL2U"
-      transaction.ideal_payment_details.image_url.should == "http://www.example.com/ideal.png"
+      expect(transaction.three_d_secure_info.status).to eq("authenticate_successful")
+      expect(transaction.three_d_secure_info.enrolled).to eq("Y")
+      expect(transaction.three_d_secure_info.liability_shifted).to eq(true)
+      expect(transaction.three_d_secure_info.liability_shift_possible).to eq(true)
     end
 
     it "sets up history attributes in status_history" do
@@ -195,18 +211,18 @@ describe Braintree::Transaction do
       transaction = Braintree::Transaction._new(
         :gateway,
         :status_history => [
-          { :timestamp => time, :amount => "12.00", :transaction_source => "API",
-            :user => "larry", :status => Braintree::Transaction::Status::Authorized },
-          { :timestamp => Time.utc(2010,1,15), :amount => "12.00", :transaction_source => "API",
+          {:timestamp => time, :amount => "12.00", :transaction_source => "API",
+            :user => "larry", :status => Braintree::Transaction::Status::Authorized},
+          {:timestamp => Time.utc(2010,1,15), :amount => "12.00", :transaction_source => "API",
             :user => "curly", :status => "scheduled_for_settlement"}
         ])
-      transaction.status_history.size.should == 2
-      transaction.status_history[0].user.should == "larry"
-      transaction.status_history[0].amount.should == "12.00"
-      transaction.status_history[0].status.should == Braintree::Transaction::Status::Authorized
-      transaction.status_history[0].transaction_source.should == "API"
-      transaction.status_history[0].timestamp.should == time
-      transaction.status_history[1].user.should == "curly"
+      expect(transaction.status_history.size).to eq(2)
+      expect(transaction.status_history[0].user).to eq("larry")
+      expect(transaction.status_history[0].amount).to eq("12.00")
+      expect(transaction.status_history[0].status).to eq(Braintree::Transaction::Status::Authorized)
+      expect(transaction.status_history[0].transaction_source).to eq("API")
+      expect(transaction.status_history[0].timestamp).to eq(time)
+      expect(transaction.status_history[1].user).to eq("curly")
     end
 
     it "sets up authorization_adjustments" do
@@ -214,32 +230,43 @@ describe Braintree::Transaction do
       transaction = Braintree::Transaction._new(
         :gateway,
         :authorization_adjustments => [
-          { :timestamp => timestamp, :processor_response_code => "1000", :processor_response_text => "Approved", :amount => "12.00", :success => true },
-          { :timestamp => timestamp, :processor_response_code => "3000", :processor_response_text => "Processor Network Unavailable - Try Again", :amount => "12.34", :success => false },
+          {:timestamp => timestamp, :processor_response_code => "1000", :processor_response_text => "Approved", :amount => "12.00", :success => true},
+          {:timestamp => timestamp, :processor_response_code => "3000", :processor_response_text => "Processor Network Unavailable - Try Again", :amount => "12.34", :success => false},
         ])
-      transaction.authorization_adjustments.size.should == 2
-      transaction.authorization_adjustments[0].amount.should == "12.00"
-      transaction.authorization_adjustments[0].success.should == true
-      transaction.authorization_adjustments[0].timestamp.should == timestamp
-      transaction.authorization_adjustments[0].processor_response_code.should == "1000"
-      transaction.authorization_adjustments[0].processor_response_text.should == "Approved"
-      transaction.authorization_adjustments[1].amount.should == "12.34"
-      transaction.authorization_adjustments[1].success.should == false
-      transaction.authorization_adjustments[1].timestamp.should == timestamp
-      transaction.authorization_adjustments[1].processor_response_code.should == "3000"
-      transaction.authorization_adjustments[1].processor_response_text.should == "Processor Network Unavailable - Try Again"
+      expect(transaction.authorization_adjustments.size).to eq(2)
+      expect(transaction.authorization_adjustments[0].amount).to eq("12.00")
+      expect(transaction.authorization_adjustments[0].success).to eq(true)
+      expect(transaction.authorization_adjustments[0].timestamp).to eq(timestamp)
+      expect(transaction.authorization_adjustments[0].processor_response_code).to eq("1000")
+      expect(transaction.authorization_adjustments[0].processor_response_text).to eq("Approved")
+      expect(transaction.authorization_adjustments[1].amount).to eq("12.34")
+      expect(transaction.authorization_adjustments[1].success).to eq(false)
+      expect(transaction.authorization_adjustments[1].timestamp).to eq(timestamp)
+      expect(transaction.authorization_adjustments[1].processor_response_code).to eq("3000")
+      expect(transaction.authorization_adjustments[1].processor_response_text).to eq("Processor Network Unavailable - Try Again")
+    end
+
+    it "accepts retry_ids and retried_transaction_id attributes in a transactions" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :retry_ids => ["retry_id_1"],
+        :retried_transaction_id => "original_retried_tranction_id",
+      )
+      expect(transaction.retry_ids.count).to eq(1)
+      expect(transaction.retry_ids[0]).to eq("retry_id_1")
+      expect(transaction.retried_transaction_id).to eq("original_retried_tranction_id")
     end
 
     it "handles receiving custom as an empty string" do
-      transaction = Braintree::Transaction._new(
+      Braintree::Transaction._new(
         :gateway,
-        :custom => "\n    "
+        :custom => "\n    ",
       )
     end
 
     it "accepts amount as either a String or a BigDecimal" do
-      Braintree::Transaction._new(:gateway, :amount => "12.34").amount.should == BigDecimal("12.34")
-      Braintree::Transaction._new(:gateway, :amount => BigDecimal("12.34")).amount.should == BigDecimal("12.34")
+      expect(Braintree::Transaction._new(:gateway, :amount => "12.34").amount).to eq(BigDecimal("12.34"))
+      expect(Braintree::Transaction._new(:gateway, :amount => BigDecimal("12.34")).amount).to eq(BigDecimal("12.34"))
     end
 
     it "blows up if amount is not a string or BigDecimal" do
@@ -251,17 +278,25 @@ describe Braintree::Transaction do
     it "handles nil risk_data" do
       transaction = Braintree::Transaction._new(
         :gateway,
-        :risk_data => nil
+        :risk_data => nil,
       )
-      transaction.risk_data.should be_nil
+      expect(transaction.risk_data).to be_nil
     end
 
     it "accepts network_transaction_id" do
       transaction = Braintree::Transaction._new(
         :gateway,
-        :network_transaction_id => "123456789012345"
+        :network_transaction_id => "123456789012345",
       )
-      transaction.network_transaction_id.should == "123456789012345"
+      expect(transaction.network_transaction_id).to eq("123456789012345")
+    end
+
+    it "accepts ach_return_code" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :ach_return_code => "R01",
+      )
+      expect(transaction.ach_return_code).to eq("R01")
     end
 
     it "accepts network_response code and network_response_text" do
@@ -273,19 +308,62 @@ describe Braintree::Transaction do
       expect(transaction.network_response_code).to eq("00")
       expect(transaction.network_response_text).to eq("Successful approval/completion or V.I.P. PIN verification is successful")
     end
+
+    it "accepts merchant_advice_code and merchant_advice_text" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :merchant_advice_code => "01",
+        :merchant_advice_code_text => "New account information available",
+      )
+      expect(transaction.merchant_advice_code).to eq("01")
+      expect(transaction.merchant_advice_code_text).to eq("New account information available")
+    end
+
+    it "accepts sepa_direct_debit_return_code" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :sepa_direct_debit_return_code => "AM04",
+      )
+      expect(transaction.sepa_direct_debit_return_code).to eq("AM04")
+    end
+
+    it "accepts sepa_direct_debit_account_details" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :id => "123",
+        :type => "sale",
+        :amount => "12.34",
+        :status => "settled",
+        :sepa_debit_account_detail => {
+          :token => "1234",
+        },
+      )
+      details = transaction.sepa_direct_debit_account_details
+      expect(details.token).to eq("1234")
+    end
+
+    it "accepts debit_network" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :debit_network => "STAR",
+      )
+      expect(transaction.debit_network).to eq "STAR"
+    end
   end
 
   describe "inspect" do
-    it "includes the id, type, amount, and status first" do
+    it "includes the id, type, amount, status, and processed_with_network_token?" do
       transaction = Braintree::Transaction._new(
         :gateway,
         :id => "1234",
         :type => "sale",
         :amount => "100.00",
-        :status => Braintree::Transaction::Status::Authorized
+        :status => Braintree::Transaction::Status::Authorized,
+        :processed_with_network_token => false,
       )
       output = transaction.inspect
-      output.should include(%Q(#<Braintree::Transaction id: "1234", type: "sale", amount: "100.0", status: "authorized"))
+      expect(output).to include(%Q(#<Braintree::Transaction id: "1234", type: "sale", amount: "100.0", status: "authorized"))
+      expect(output).to include(%Q(processed_with_network_token?: false))
     end
   end
 
@@ -294,27 +372,27 @@ describe Braintree::Transaction do
       first = Braintree::Transaction._new(:gateway, :id => 123)
       second = Braintree::Transaction._new(:gateway, :id => 123)
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false for transactions with different ids" do
       first = Braintree::Transaction._new(:gateway, :id => 123)
       second = Braintree::Transaction._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 comparing to nil" do
-      Braintree::Transaction._new(:gateway, {}).should_not == nil
+      expect(Braintree::Transaction._new(:gateway, {})).not_to eq(nil)
     end
 
     it "returns false when comparing to non-transactions" do
       same_id_different_object = Object.new
       def same_id_different_object.id; 123; end
       transaction = Braintree::Transaction._new(:gateway, :id => 123)
-      transaction.should_not == same_id_different_object
+      expect(transaction).not_to eq(same_id_different_object)
     end
   end
 
@@ -329,25 +407,25 @@ describe Braintree::Transaction do
   describe "refunded?" do
     it "is true if the transaciton has been refunded" do
       transaction = Braintree::Transaction._new(:gateway, :refund_id => "123")
-      transaction.refunded?.should == true
+      expect(transaction.refunded?).to eq(true)
     end
 
     it "is false if the transaciton has not been refunded" do
       transaction = Braintree::Transaction._new(:gateway, :refund_id => nil)
-      transaction.refunded?.should == false
+      expect(transaction.refunded?).to eq(false)
     end
   end
 
   describe "sale" do
-    let(:mock_response) { {:transaction => {}}}
-    let(:http_stub) { double('http_stub').as_null_object }
+    let(:mock_response) { {:transaction => {}} }
+    let(:http_stub) { double("http_stub").as_null_object }
 
     RSpec::Matchers.define :skip_advanced_fraud_check_value_is do |value|
         match { |params| params[:transaction][:options][:skip_advanced_fraud_checking] == value }
     end
 
     it "accepts skip_advanced_fraud_checking options with value true" do
-      Braintree::Http.stub(:new).and_return http_stub
+      allow(Braintree::Http).to receive(:new).and_return http_stub
       expect(http_stub).to receive(:post).with(anything, skip_advanced_fraud_check_value_is(true)).and_return(mock_response)
 
       Braintree::Transaction.sale(
@@ -358,12 +436,12 @@ describe Braintree::Transaction do
         },
         :options => {
           :skip_advanced_fraud_checking => true
-        }
+        },
       )
     end
 
     it "accepts skip_advanced_fraud_checking options with value false" do
-      Braintree::Http.stub(:new).and_return http_stub
+      allow(Braintree::Http).to receive(:new).and_return http_stub
       expect(http_stub).to receive(:post).with(anything, skip_advanced_fraud_check_value_is(false)).and_return(mock_response)
 
       Braintree::Transaction.sale(
@@ -374,12 +452,12 @@ describe Braintree::Transaction do
         },
         :options => {
           :skip_advanced_fraud_checking => false
-        }
+        },
       )
     end
 
     it "doesn't include skip_advanced_fraud_checking in params if its not specified" do
-      Braintree::Http.stub(:new).and_return http_stub
+      allow(Braintree::Http).to receive(:new).and_return http_stub
       expect(http_stub).to receive(:post).with(anything, skip_advanced_fraud_check_value_is(nil)).and_return(mock_response)
 
       Braintree::Transaction.sale(
@@ -390,8 +468,27 @@ describe Braintree::Transaction do
         },
         :options => {
           :submit_for_settlement => false
-        }
+        },
       )
     end
   end
+
+  describe "processed_with_network_token?" do
+    it "is true if the transaction was processed with a network token" do
+      transaction = Braintree::Transaction._new(:gateway, :processed_with_network_token => true)
+      expect(transaction.processed_with_network_token?).to eq(true)
+    end
+
+    it "is false if the transaction was not processed with a network token" do
+      transaction = Braintree::Transaction._new(:gateway, :processed_with_network_token => false)
+      expect(transaction.processed_with_network_token?).to eq(false)
+    end
+  end
+
+  describe "gateway rejection reason" do
+    it "verifies excessive_retry mapping" do
+      transaction = Braintree::Transaction._new(:gateway, :gateway_rejection_reason => "excessive_retry")
+      expect(transaction.gateway_rejection_reason).to eq(Braintree::Transaction::GatewayRejectionReason::ExcessiveRetry)
+    end
+  end
 end

data/spec/unit/braintree/unknown_payment_method_spec.rb

@@ -8,26 +8,26 @@ describe Braintree::PayPalAccount do
   describe "token" do
     it "has a token identifier" do
       params = {:unknown_payment_method => {:token => 1234, :default => true}}
-      Braintree::UnknownPaymentMethod.new(@gateway, params).token.should == 1234
+      expect(Braintree::UnknownPaymentMethod.new(@gateway, params).token).to eq(1234)
     end
   end
 
   describe "image_url" do
     it "has a image_url" do
       params = {:unknown_payment_method => {:token => 1234, :default => true}}
-      Braintree::UnknownPaymentMethod.new(@gateway, params).image_url.should == "https://assets.braintreegateway.com/payment_method_logo/unknown.png"
+      expect(Braintree::UnknownPaymentMethod.new(@gateway, params).image_url).to eq("https://assets.braintreegateway.com/payment_method_logo/unknown.png")
     end
   end
 
   describe "default?" do
     it "is true if the paypal account is the default payment method for the customer" do
       params = {:unknown_payment_method => {:token => 1234, :default => true}}
-      Braintree::UnknownPaymentMethod.new(@gateway, params).should be_default
+      expect(Braintree::UnknownPaymentMethod.new(@gateway, params)).to be_default
     end
 
     it "is false if the paypal account is not the default payment methodfor the customer" do
       params = {:unknown_payment_method => {:token => 1234, :default => false}}
-      Braintree::UnknownPaymentMethod.new(@gateway, params).should_not be_default
+      expect(Braintree::UnknownPaymentMethod.new(@gateway, params)).not_to be_default
     end
   end
 end

data/spec/unit/braintree/us_bank_account_spec.rb

@@ -3,11 +3,11 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 describe Braintree::UsBankAccount do
   describe "default?" do
     it "is true if the us bank account is the default us bank account for the customer" do
-      Braintree::UsBankAccount._new(:gateway, :default => true).default?.should == true
+      expect(Braintree::UsBankAccount._new(:gateway, :default => true).default?).to eq(true)
     end
 
     it "is false if the us bank account is not the default us bank account for the customer" do
-      Braintree::UsBankAccount._new(:gateway, :default => false).default?.should == false
+      expect(Braintree::UsBankAccount._new(:gateway, :default => false).default?).to eq(false)
     end
   end
 end

data/spec/unit/braintree/us_bank_account_verification_search_spec.rb

@@ -6,11 +6,11 @@ module Braintree
       it "allows All verification methods" do
         search = UsBankAccountVerificationSearch.new
 
-        lambda do
+        expect do
           search.verification_method.in(
             *Braintree::UsBankAccountVerification::VerificationMethod::All,
           )
-        end.should_not raise_error
+        end.not_to raise_error
       end
     end
 
@@ -19,7 +19,7 @@ module Braintree
         search = UsBankAccountVerificationSearch.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
 
@@ -28,7 +28,7 @@ module Braintree
         search = UsBankAccountVerificationSearch.new
         search.ids.in("id1", "id2")
 
-        search.to_hash.should == {:ids => ["id1", "id2"]}
+        expect(search.to_hash).to eq({:ids => ["id1", "id2"]})
       end
     end
 
@@ -37,14 +37,14 @@ module Braintree
         search = UsBankAccountVerificationSearch.new
         search.account_holder_name.is "v_account_holder_name"
 
-        search.to_hash.should == {:account_holder_name => {:is => "v_account_holder_name"}}
+        expect(search.to_hash).to eq({:account_holder_name => {:is => "v_account_holder_name"}})
       end
     end
 
     context "created_at" do
       it "is a range node" do
         search = UsBankAccountVerificationSearch.new
-        search.created_at.should be_kind_of(Braintree::AdvancedSearch::RangeNode)
+        expect(search.created_at).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
       end
     end
 
@@ -53,7 +53,7 @@ module Braintree
         search = UsBankAccountVerificationSearch.new
         search.account_number.ends_with "1234"
 
-        search.to_hash.should == {:account_number => {:ends_with => "1234"}}
+        expect(search.to_hash).to eq({:account_number => {:ends_with => "1234"}})
       end
     end
   end