braintree 4.14.0 → 4.15.0

data/spec/unit/braintree/dispute_spec.rb

@@ -78,9 +78,9 @@ describe Braintree::Dispute 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
-        Braintree::Dispute.stub(:_new).and_return nil
-        Braintree::ErrorResult.stub(:new).and_return nil
+        allow(Braintree::Http).to receive(:new).and_return double.as_null_object
+        allow(Braintree::Dispute).to receive(:_new).and_return nil
+        allow(Braintree::ErrorResult).to receive(:new).and_return nil
 
         expect do
           Braintree::Dispute.public_send(method_name, 8675309)
@@ -109,8 +109,8 @@ describe Braintree::Dispute do
     end
 
     it "does not raise an exception if the dispute_id is a fixnum" do
-      Braintree::Http.stub(:new).and_return double.as_null_object
-      Braintree::Dispute.stub(:_new).and_return nil
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
+      allow(Braintree::Dispute).to receive(:_new).and_return nil
       expect do
         Braintree::Dispute.add_file_evidence(8675309, "doc_upload_id")
       end.to_not raise_error
@@ -135,8 +135,8 @@ describe Braintree::Dispute do
     end
 
     it "does not raise an exception if the document_upload_id is a fixnum" do
-      Braintree::Http.stub(:new).and_return double.as_null_object
-      Braintree::Dispute.stub(:_new).and_return nil
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
+      allow(Braintree::Dispute).to receive(:_new).and_return nil
       expect do
         Braintree::Dispute.add_file_evidence("dispute_id", 8675309)
       end.to_not raise_error
@@ -144,7 +144,7 @@ describe Braintree::Dispute do
 
     describe "with optional params" do
       it "does not raise an exception if the optional parameters are valid" 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::Dispute.add_file_evidence("dispute_id", {category: "GENERAL", document_id: "document_id"})
         end.to_not raise_error
@@ -157,7 +157,7 @@ describe Braintree::Dispute do
       end
 
       it "raises an exception if the param tag is not a string" 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::Dispute.add_file_evidence("dispute_id", {category: 3, document_id: "document_id"})
@@ -186,8 +186,8 @@ describe Braintree::Dispute 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
-      Braintree::Dispute.stub(:_new).and_return nil
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
+      allow(Braintree::Dispute).to receive(:_new).and_return nil
       expect do
         Braintree::Dispute.add_text_evidence(8675309, "text evidence")
       end.to_not raise_error
@@ -207,7 +207,7 @@ describe Braintree::Dispute do
 
     describe "with optional params" do
       it "does not raise an exception if the optional parameters are valid" 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::Dispute.add_text_evidence("dispute_id", {content: "a", category: "", sequence_number: 3})
         end.to_not raise_error
@@ -281,8 +281,8 @@ describe Braintree::Dispute do
     it "converts string amount_dispute and amount_won" do
       dispute = Braintree::Dispute._new(attributes)
 
-      dispute.amount_disputed.should == 500.0
-      dispute.amount_won.should == 0.0
+      expect(dispute.amount_disputed).to eq(500.0)
+      expect(dispute.amount_won).to eq(0.0)
     end
 
     it "returns 'Effortless Chargeback Protection tool' when initial chargeback_protection_level is effortless" do
@@ -336,74 +336,74 @@ describe Braintree::Dispute do
 
         dispute = Braintree::Dispute._new(attributes)
 
-        dispute.send(field).should == nil
+        expect(dispute.send(field)).to eq(nil)
       end
     end
 
     it "converts date_opened, date_won, reply_by_date, received_date from String to Date" do
       dispute = Braintree::Dispute._new(attributes.merge(:reply_by_date => "2009-03-14"))
 
-      dispute.date_opened.should == Date.new(2009, 3, 9)
-      dispute.date_won.should == Date.new(2009, 4, 15)
-      dispute.received_date.should == Date.new(2009, 3, 9)
-      dispute.reply_by_date.should == Date.new(2009, 3, 14)
+      expect(dispute.date_opened).to eq(Date.new(2009, 3, 9))
+      expect(dispute.date_won).to eq(Date.new(2009, 4, 15))
+      expect(dispute.received_date).to eq(Date.new(2009, 3, 9))
+      expect(dispute.reply_by_date).to eq(Date.new(2009, 3, 14))
     end
 
     it "converts transaction hash into a Dispute::TransactionDetails object first" do
       dispute = Braintree::Dispute._new(attributes)
 
-      dispute.transaction_details.id.should == "open_disputed_transaction"
-      dispute.transaction_details.amount.should == 31.00
+      expect(dispute.transaction_details.id).to eq("open_disputed_transaction")
+      expect(dispute.transaction_details.amount).to eq(31.00)
     end
 
     it "converts transaction hash into a Dispute::Transaction object" do
       dispute = Braintree::Dispute._new(attributes)
 
-      dispute.transaction.amount.should == 31.00
-      dispute.transaction.id.should == "open_disputed_transaction"
-      dispute.transaction.created_at.should == Time.utc(2009, 2, 9, 12, 59, 59)
-      dispute.transaction.installment_count.should == nil
-      dispute.transaction.order_id.should == nil
-      dispute.transaction.purchase_order_number.should == "po"
-      dispute.transaction.payment_instrument_subtype.should == "Visa"
+      expect(dispute.transaction.amount).to eq(31.00)
+      expect(dispute.transaction.id).to eq("open_disputed_transaction")
+      expect(dispute.transaction.created_at).to eq(Time.utc(2009, 2, 9, 12, 59, 59))
+      expect(dispute.transaction.installment_count).to eq(nil)
+      expect(dispute.transaction.order_id).to eq(nil)
+      expect(dispute.transaction.purchase_order_number).to eq("po")
+      expect(dispute.transaction.payment_instrument_subtype).to eq("Visa")
     end
 
     it "converts status_history hash into an array of Dispute::StatusHistory objects" do
       dispute = Braintree::Dispute._new(attributes)
 
-      dispute.status_history.length.should == 1
+      expect(dispute.status_history.length).to eq(1)
       status_history_1 = dispute.status_history.first
-      status_history_1.status.should == Braintree::Dispute::Status::Open
-      status_history_1.timestamp.should == Time.utc(2009, 3, 9, 10, 50, 39)
+      expect(status_history_1.status).to eq(Braintree::Dispute::Status::Open)
+      expect(status_history_1.timestamp).to eq(Time.utc(2009, 3, 9, 10, 50, 39))
     end
 
     it "converts evidence hash into an array of Dispute::Evidence objects" do
       dispute = Braintree::Dispute._new(attributes)
 
-      dispute.evidence.length.should ==2
+      expect(dispute.evidence.length).to eq(2)
       evidence1 = dispute.evidence.first
-      evidence1.comment.should == nil
-      evidence1.created_at.should == Time.utc(2009, 3, 10, 12, 5, 20)
-      evidence1.id.should == "evidence1"
-      evidence1.sent_to_processor_at.should == nil
-      evidence1.url.should == "url_of_file_evidence"
+      expect(evidence1.comment).to eq(nil)
+      expect(evidence1.created_at).to eq(Time.utc(2009, 3, 10, 12, 5, 20))
+      expect(evidence1.id).to eq("evidence1")
+      expect(evidence1.sent_to_processor_at).to eq(nil)
+      expect(evidence1.url).to eq("url_of_file_evidence")
 
       evidence2 = dispute.evidence.last
-      evidence2.comment.should == "text evidence"
-      evidence2.created_at.should == Time.utc(2009, 3, 10, 12, 5, 21)
-      evidence2.id.should == "evidence2"
-      evidence2.sent_to_processor_at.should == Date.new(2009, 3, 13)
-      evidence2.url.should == nil
+      expect(evidence2.comment).to eq("text evidence")
+      expect(evidence2.created_at).to eq(Time.utc(2009, 3, 10, 12, 5, 21))
+      expect(evidence2.id).to eq("evidence2")
+      expect(evidence2.sent_to_processor_at).to eq(Date.new(2009, 3, 13))
+      expect(evidence2.url).to eq(nil)
     end
 
     it "converts paypal_messages hash into an array of Dispute::PayPalMessage objects" do
       dispute = Braintree::Dispute._new(attributes)
 
-      dispute.paypal_messages.length.should == 1
+      expect(dispute.paypal_messages.length).to eq(1)
       paypal_message_1 = dispute.paypal_messages.first
-      paypal_message_1.message.should == "message"
-      paypal_message_1.sender.should == "seller"
-      paypal_message_1.sent_at.should == Time.utc(2009, 3, 9, 10, 50, 39)
+      expect(paypal_message_1.message).to eq("message")
+      expect(paypal_message_1.sender).to eq("seller")
+      expect(paypal_message_1.sent_at).to eq(Time.utc(2009, 3, 9, 10, 50, 39))
     end
 
     it "handles nil evidence" do
@@ -411,7 +411,7 @@ describe Braintree::Dispute do
 
       dispute = Braintree::Dispute._new(attributes)
 
-      dispute.evidence.should == nil
+      expect(dispute.evidence).to eq(nil)
     end
 
     it "handles nil paypal_messages" do
@@ -419,15 +419,15 @@ describe Braintree::Dispute do
 
       dispute = Braintree::Dispute._new(attributes)
 
-      dispute.paypal_messages.should == nil
+      expect(dispute.paypal_messages).to eq(nil)
     end
 
     it "sets the older webhook fields for backwards compatibility" do
       dispute = Braintree::Dispute._new(attributes)
 
-      dispute.amount.should == 31.00
-      dispute.date_opened.should == Date.new(2009, 3, 9)
-      dispute.date_won.should == Date.new(2009, 4, 15)
+      expect(dispute.amount).to eq(31.00)
+      expect(dispute.date_opened).to eq(Date.new(2009, 3, 9))
+      expect(dispute.date_won).to eq(Date.new(2009, 4, 15))
     end
 
     it "returns pre_dispute_program value" do
@@ -443,21 +443,21 @@ describe Braintree::Dispute do
       first = Braintree::Dispute._new(attributes)
       second = Braintree::Dispute._new(attributes)
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false when given a dispute with a different id" do
       first = Braintree::Dispute._new(attributes)
       second = Braintree::Dispute._new(attributes.merge(:id => "1234"))
 
-      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 dispute" do
       dispute = Braintree::Dispute._new(attributes)
-      dispute.should_not == "not a dispute"
+      expect(dispute).not_to eq("not a dispute")
     end
   end
 

data/spec/unit/braintree/document_upload_spec.rb

@@ -5,11 +5,11 @@ describe Braintree::DocumentUpload do
     it "sets attributes" do
       response = {:size => 555, :kind => "evidence_document", :name => "up_file.pdf", :content_type => "application/pdf", :id => "my_id"}
       document_upload = Braintree::DocumentUpload._new(response)
-      document_upload.id.should == "my_id"
-      document_upload.size.should == 555
-      document_upload.name.should == "up_file.pdf"
-      document_upload.content_type.should == "application/pdf"
-      document_upload.kind.should == Braintree::DocumentUpload::Kind::EvidenceDocument
+      expect(document_upload.id).to eq("my_id")
+      expect(document_upload.size).to eq(555)
+      expect(document_upload.name).to eq("up_file.pdf")
+      expect(document_upload.content_type).to eq("application/pdf")
+      expect(document_upload.kind).to eq(Braintree::DocumentUpload::Kind::EvidenceDocument)
     end
   end
 
@@ -17,19 +17,19 @@ describe Braintree::DocumentUpload do
     it "sets identity document" do
       response = {:size => 555, :kind => "identity_document", :name => "up_file.pdf", :content_type => "application/pdf", :id => "my_id"}
       document_upload = Braintree::DocumentUpload._new(response)
-      document_upload.kind.should == Braintree::DocumentUpload::Kind::IdentityDocument
+      expect(document_upload.kind).to eq(Braintree::DocumentUpload::Kind::IdentityDocument)
     end
 
     it "sets evidence document" do
       response = {:size => 555, :kind => "evidence_document", :name => "up_file.pdf", :content_type => "application/pdf", :id => "my_id"}
       document_upload = Braintree::DocumentUpload._new(response)
-      document_upload.kind.should == Braintree::DocumentUpload::Kind::EvidenceDocument
+      expect(document_upload.kind).to eq(Braintree::DocumentUpload::Kind::EvidenceDocument)
     end
 
     it "sets payout invoice document" do
       response = {:size => 555, :kind => "payout_invoice_document", :name => "up_file.pdf", :content_type => "application/pdf", :id => "my_id"}
       document_upload = Braintree::DocumentUpload._new(response)
-      document_upload.kind.should == Braintree::DocumentUpload::Kind::PayoutInvoiceDocument
+      expect(document_upload.kind).to eq(Braintree::DocumentUpload::Kind::PayoutInvoiceDocument)
     end
   end
 end

data/spec/unit/braintree/enriched_customer_data_spec.rb

@@ -25,8 +25,8 @@ describe Braintree::EnrichedCustomerData do
 
       payment_method_customer_data_updated = Braintree::EnrichedCustomerData._new(params)
 
-      payment_method_customer_data_updated.profile_data.should be_a(Braintree::VenmoProfileData)
-      payment_method_customer_data_updated.fields_updated.should eq(["username"])
+      expect(payment_method_customer_data_updated.profile_data).to be_a(Braintree::VenmoProfileData)
+      expect(payment_method_customer_data_updated.fields_updated).to eq(["username"])
     end
   end
 end

data/spec/unit/braintree/error_result_spec.rb

@@ -27,7 +27,7 @@ describe Braintree::ErrorResult do
         }
       }
       result = Braintree::ErrorResult.new(:gateway, :params => "params", :errors => errors)
-      result.inspect.should == "#<Braintree::ErrorResult params:{...} errors:<level1:[(code1) message], level1/level2:[(code2) message2]>>"
+      expect(result.inspect).to eq("#<Braintree::ErrorResult params:{...} errors:<level1:[(code1) message], level1/level2:[(code2) message2]>>")
     end
 
     it "includes the credit_card_verification if there is one" do
@@ -38,7 +38,7 @@ describe Braintree::ErrorResult do
         :verification => {},
         :transaction => nil,
       )
-      result.inspect.should include("credit_card_verification: #<Braintree::CreditCardVerification status: ")
+      expect(result.inspect).to include("credit_card_verification: #<Braintree::CreditCardVerification status: ")
     end
 
     it "does not include the credit_card_verification if there isn't one" do
@@ -49,7 +49,7 @@ describe Braintree::ErrorResult do
         :verification => nil,
         :transaction => nil,
       )
-      result.inspect.should_not include("credit_card_verification")
+      expect(result.inspect).not_to include("credit_card_verification")
     end
 
     it "includes the transaction if there is one" do
@@ -60,7 +60,7 @@ describe Braintree::ErrorResult do
         :verification => nil,
         :transaction => {},
       )
-      result.inspect.should include("transaction: #<Braintree::Transaction id: ")
+      expect(result.inspect).to include("transaction: #<Braintree::Transaction id: ")
     end
 
     it "does not include the transaction if there isn't one" do
@@ -71,7 +71,7 @@ describe Braintree::ErrorResult do
         :verification => nil,
         :transaction => nil,
       )
-      result.inspect.should_not include("transaction")
+      expect(result.inspect).not_to include("transaction")
     end
   end
 end

data/spec/unit/braintree/errors_spec.rb

@@ -6,15 +6,15 @@ describe Braintree::Errors do
       errors = Braintree::Errors.new(
         :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]},
       )
-      errors.for(:level1).size.should == 1
-      errors.for(:level1)[0].code.should == "code1"
+      expect(errors.for(:level1).size).to eq(1)
+      expect(errors.for(:level1)[0].code).to eq("code1")
     end
 
     it "returns nil if there are no errors at the given scope" do
       errors = Braintree::Errors.new(
         :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]},
       )
-      errors.for(:no_errors_here).should == nil
+      expect(errors.for(:no_errors_here)).to eq(nil)
     end
   end
 
@@ -23,7 +23,7 @@ describe Braintree::Errors do
       errors = Braintree::Errors.new(
         :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]},
       )
-      errors.inspect.should == "#<Braintree::Errors level1:[(code1) message]>"
+      expect(errors.inspect).to eq("#<Braintree::Errors level1:[(code1) message]>")
     end
 
     it "shows errors 2 levels deep" do
@@ -35,7 +35,7 @@ describe Braintree::Errors do
           }
         },
       )
-      errors.inspect.should == "#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2]>"
+      expect(errors.inspect).to eq("#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2]>")
     end
 
     it "shows errors 3 levels deep" do
@@ -50,7 +50,7 @@ describe Braintree::Errors do
           }
         },
       )
-      errors.inspect.should == "#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2], level1/level2/level3:[(code3) message3]>"
+      expect(errors.inspect).to eq("#<Braintree::Errors level1:[(code1) message], level1/level2:[(code2) message2], level1/level2/level3:[(code3) message3]>")
     end
   end
 
@@ -67,7 +67,7 @@ describe Braintree::Errors do
           }
         },
       )
-      errors.map { |e| e.code }.sort.should == %w[1 2 3]
+      expect(errors.map { |e| e.code }.sort).to eq(%w[1 2 3])
     end
   end
 
@@ -76,7 +76,7 @@ describe Braintree::Errors do
       errors = Braintree::Errors.new(
         :level1 => {:errors => [{:code => "1", :attribute => "attr", :message => "message"}]},
       )
-      errors.size.should == 1
+      expect(errors.size).to eq(1)
     end
 
     it "returns the total number of validation errors in the hierarchy" do
@@ -91,7 +91,7 @@ describe Braintree::Errors do
           }
         },
       )
-      errors.size.should == 3
+      expect(errors.size).to eq(3)
     end
   end
 end

data/spec/unit/braintree/http_spec.rb

@@ -15,7 +15,7 @@ END
 [Braintree]   <last-name>Doe</last-name>
 [Braintree] </customer>
 END
-      Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml).should == expected_xml
+      expect(Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml)).to eq(expected_xml)
     end
 
     it "sanitizes credit card number and cvv" do
@@ -38,7 +38,7 @@ END
 [Braintree]   <encrypted-card-data>***</encrypted-card-data>
 [Braintree] </customer>
 END
-      Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml).should == expected_xml
+      expect(Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml)).to eq(expected_xml)
     end
 
     it "sanitizes credit card number and cvv with newlines" do
@@ -59,7 +59,7 @@ END
 [Braintree]   <cvv>***</cvv>
 [Braintree] </customer>
 END
-      Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml).should == expected_xml
+      expect(Braintree::Http.new(:config)._format_and_sanitize_body_for_log(input_xml)).to eq(expected_xml)
     end
   end
 
@@ -80,7 +80,7 @@ END
         :start => nil,
       )
 
-      Net::HTTP.should_receive(:new).with(nil, nil, "localhost", 8080, "user", "test").and_return(net_http_instance)
+      expect(Net::HTTP).to receive(:new).with(nil, nil, "localhost", 8080, "user", "test").and_return(net_http_instance)
 
       http._http_do("GET", "/plans")
     end
@@ -99,7 +99,7 @@ END
         :start => nil,
       )
 
-      Net::HTTP.should_receive(:new).with(nil, nil, "localhost", 8080, nil, nil).and_return(net_http_instance)
+      expect(Net::HTTP).to receive(:new).with(nil, nil, "localhost", 8080, nil, nil).and_return(net_http_instance)
 
       http._http_do("GET", "/plans")
     end
@@ -114,7 +114,7 @@ END
         :start => nil,
       )
 
-      Net::HTTP.should_receive(:new).with(nil, nil).and_return(net_http_instance)
+      expect(Net::HTTP).to receive(:new).with(nil, nil).and_return(net_http_instance)
 
       http._http_do("GET", "/plans")
     end
@@ -185,13 +185,13 @@ END
 
   describe "_build_query_string" do
     it "returns an empty string for empty query params" do
-      Braintree::Http.new(:config)._build_query_string({}).should == ""
+      expect(Braintree::Http.new(:config)._build_query_string({})).to eq("")
     end
 
     it "returns a proper query string for non-nested hashes" do
       query_params = {:one => 1, :two => 2}
 
-      Braintree::Http.new(:config)._build_query_string(query_params).should =~ /^\?(one=1&two=2|two=2&one=1)$/
+      expect(Braintree::Http.new(:config)._build_query_string(query_params)).to match(/^\?(one=1&two=2|two=2&one=1)$/)
     end
 
     it "raises ArgumentError for nested hashes" do

data/spec/unit/braintree/local_payment_completed_spec.rb

@@ -24,13 +24,13 @@ describe Braintree::LocalPaymentCompleted do
       }
       local_payment_completed = Braintree::LocalPaymentCompleted._new(params)
 
-      local_payment_completed.payment_id.should eq("a-payment-id")
-      local_payment_completed.payer_id.should eq("a-payer-id")
-      local_payment_completed.payment_method_nonce.should eq("a-nonce")
-      local_payment_completed.transaction.id.should eq("a-transaction-id")
-      local_payment_completed.transaction.amount.should eq(31.0)
-      local_payment_completed.transaction.order_id.should eq("an-order-id")
-      local_payment_completed.transaction.status.should eq(Braintree::Transaction::Status::Authorized)
+      expect(local_payment_completed.payment_id).to eq("a-payment-id")
+      expect(local_payment_completed.payer_id).to eq("a-payer-id")
+      expect(local_payment_completed.payment_method_nonce).to eq("a-nonce")
+      expect(local_payment_completed.transaction.id).to eq("a-transaction-id")
+      expect(local_payment_completed.transaction.amount).to eq(31.0)
+      expect(local_payment_completed.transaction.order_id).to eq("an-order-id")
+      expect(local_payment_completed.transaction.status).to eq(Braintree::Transaction::Status::Authorized)
     end
 
     it "initializes the object with the appropriate attributes set if no transaction is provided" do
@@ -41,10 +41,10 @@ describe Braintree::LocalPaymentCompleted do
       }
       local_payment_completed = Braintree::LocalPaymentCompleted._new(params)
 
-      local_payment_completed.payment_id.should eq("a-payment-id")
-      local_payment_completed.payer_id.should eq("a-payer-id")
-      local_payment_completed.payment_method_nonce.should eq("a-nonce")
-      local_payment_completed.transaction.should be_nil
+      expect(local_payment_completed.payment_id).to eq("a-payment-id")
+      expect(local_payment_completed.payer_id).to eq("a-payer-id")
+      expect(local_payment_completed.payment_method_nonce).to eq("a-nonce")
+      expect(local_payment_completed.transaction).to be_nil
     end
   end
 end

data/spec/unit/braintree/local_payment_expired_spec.rb

@@ -17,8 +17,8 @@ describe Braintree::LocalPaymentExpired do
       }
       local_payment_expired = Braintree::LocalPaymentExpired._new(params)
 
-      local_payment_expired.payment_id.should eq("a-payment-id")
-      local_payment_expired.payment_context_id.should eq("a-payment-context-id")
+      expect(local_payment_expired.payment_id).to eq("a-payment-id")
+      expect(local_payment_expired.payment_context_id).to eq("a-payment-context-id")
     end
   end
 end

data/spec/unit/braintree/local_payment_funded_spec.rb

@@ -23,12 +23,12 @@ describe Braintree::LocalPaymentFunded do
       }
       local_payment_funded = Braintree::LocalPaymentFunded._new(params)
 
-      local_payment_funded.payment_id.should eq("a-payment-id")
-      local_payment_funded.payment_context_id.should eq("a-payment-context-id")
-      local_payment_funded.transaction.id.should eq("a-transaction-id")
-      local_payment_funded.transaction.amount.should eq(31.0)
-      local_payment_funded.transaction.order_id.should eq("an-order-id")
-      local_payment_funded.transaction.status.should eq(Braintree::Transaction::Status::Settled)
+      expect(local_payment_funded.payment_id).to eq("a-payment-id")
+      expect(local_payment_funded.payment_context_id).to eq("a-payment-context-id")
+      expect(local_payment_funded.transaction.id).to eq("a-transaction-id")
+      expect(local_payment_funded.transaction.amount).to eq(31.0)
+      expect(local_payment_funded.transaction.order_id).to eq("an-order-id")
+      expect(local_payment_funded.transaction.status).to eq(Braintree::Transaction::Status::Settled)
     end
   end
 end

data/spec/unit/braintree/merchant_account_spec.rb

@@ -5,7 +5,7 @@ describe Braintree::MerchantAccount do
     it "is a string representation of the merchant account" do
       account = Braintree::MerchantAccount._new(nil, :id => "merchant_account", :status => "active", :master_merchant_account => nil)
 
-      account.inspect.should == "#<Braintree::MerchantAccount: id: \"merchant_account\", status: \"active\", master_merchant_account: nil>"
+      expect(account.inspect).to eq("#<Braintree::MerchantAccount: id: \"merchant_account\", status: \"active\", master_merchant_account: nil>")
     end
 
     it "handles a master merchant account" do
@@ -17,16 +17,16 @@ describe Braintree::MerchantAccount do
       )
 
       master_merchant_account = "#<Braintree::MerchantAccount: id: \"master_merchant_account\", status: \"active\", master_merchant_account: nil>"
-      account.inspect.should == "#<Braintree::MerchantAccount: id: \"merchant_account\", status: \"active\", master_merchant_account: #{master_merchant_account}>"
+      expect(account.inspect).to eq("#<Braintree::MerchantAccount: id: \"merchant_account\", status: \"active\", master_merchant_account: #{master_merchant_account}>")
     end
   end
 
   describe "default?" do
     it "is an alias of default" do
       account = Braintree::MerchantAccount._new(nil, :default => false)
-      account.default?.should == false
+      expect(account.default?).to eq(false)
       account = Braintree::MerchantAccount._new(nil, :default => true)
-      account.default?.should == true
+      expect(account.default?).to eq(true)
     end
   end
 end

data/spec/unit/braintree/modification_spec.rb

@@ -2,6 +2,6 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Braintree::Modification do
   it "converts string amount" do
-    Braintree::Modification._new(:amount => "100.00").amount.should == BigDecimal("100.00")
+    expect(Braintree::Modification._new(:amount => "100.00").amount).to eq(BigDecimal("100.00"))
   end
 end

data/spec/unit/braintree/payment_method_customer_data_updated_metadata_spec.rb

@@ -34,12 +34,12 @@ describe Braintree::PaymentMethodCustomerDataUpdatedMetadata do
 
       payment_method_customer_data_updated = Braintree::PaymentMethodCustomerDataUpdatedMetadata._new(:gateway, params)
 
-      payment_method_customer_data_updated.token.should eq("a-token")
-      payment_method_customer_data_updated.datetime_updated.should eq("2022-01-01T21:28:37Z")
-      payment_method_customer_data_updated.payment_method.should be_a(Braintree::VenmoAccount)
-      payment_method_customer_data_updated.enriched_customer_data.profile_data.first_name.should eq("a-first-name")
-      payment_method_customer_data_updated.enriched_customer_data.profile_data.last_name.should eq("a-last-name")
-      payment_method_customer_data_updated.enriched_customer_data.fields_updated.should eq(["username"])
+      expect(payment_method_customer_data_updated.token).to eq("a-token")
+      expect(payment_method_customer_data_updated.datetime_updated).to eq("2022-01-01T21:28:37Z")
+      expect(payment_method_customer_data_updated.payment_method).to be_a(Braintree::VenmoAccount)
+      expect(payment_method_customer_data_updated.enriched_customer_data.profile_data.first_name).to eq("a-first-name")
+      expect(payment_method_customer_data_updated.enriched_customer_data.profile_data.last_name).to eq("a-last-name")
+      expect(payment_method_customer_data_updated.enriched_customer_data.fields_updated).to eq(["username"])
     end
   end
 end

data/spec/unit/braintree/payment_method_nonce_details_payer_info_spec.rb

@@ -14,18 +14,18 @@ describe Braintree::PaymentMethodNonceDetailsPayerInfo do
 
   describe "#initialize" do
     it "sets attributes" do
-      payment_method_nonce_details_payer_info.billing_agreement_id.should == "billing-agreement-id"
-      payment_method_nonce_details_payer_info.country_code.should == "US"
-      payment_method_nonce_details_payer_info.email.should == "test@example.com"
-      payment_method_nonce_details_payer_info.first_name.should == "First"
-      payment_method_nonce_details_payer_info.last_name.should == "Last"
-      payment_method_nonce_details_payer_info.payer_id.should == "payer-id"
+      expect(payment_method_nonce_details_payer_info.billing_agreement_id).to eq("billing-agreement-id")
+      expect(payment_method_nonce_details_payer_info.country_code).to eq("US")
+      expect(payment_method_nonce_details_payer_info.email).to eq("test@example.com")
+      expect(payment_method_nonce_details_payer_info.first_name).to eq("First")
+      expect(payment_method_nonce_details_payer_info.last_name).to eq("Last")
+      expect(payment_method_nonce_details_payer_info.payer_id).to eq("payer-id")
     end
   end
 
   describe "inspect" do
     it "prints the attributes" do
-      payment_method_nonce_details_payer_info.inspect.should == %(#<PaymentMethodNonceDetailsPayerInfo billing_agreement_id: \"billing-agreement-id\", country_code: \"US\", email: \"test@example.com\", first_name: \"First\", last_name: \"Last\", payer_id: \"payer-id\">)
+      expect(payment_method_nonce_details_payer_info.inspect).to eq(%(#<PaymentMethodNonceDetailsPayerInfo billing_agreement_id: \"billing-agreement-id\", country_code: \"US\", email: \"test@example.com\", first_name: \"First\", last_name: \"Last\", payer_id: \"payer-id\">))
     end
   end
 end