braintree 2.98.0 → 4.23.0

data/spec/unit/braintree/dispute_spec.rb

@@ -7,13 +7,16 @@ describe Braintree::Dispute do
       :amount => "31.00",
       :amount_disputed => "500.00",
       :amount_won => "0.00",
+      :chargeback_protection_level => nil,
       :created_at => Time.utc(2009, 3, 9, 10, 50, 39),
+      :processor_comments => "forwarded comments",
       :date_opened => "2009-03-09",
       :date_won => "2009-04-15",
       :original_dispute_id => "original_dispute_id",
       :received_date => "2009-03-09",
       :reply_by_date => nil,
       :updated_at => Time.utc(2009, 3, 9, 10, 50, 39),
+      :pre_dispute_program => Braintree::Dispute::PreDisputeProgram::None,
       :evidence => [
         {
           comment: nil,
@@ -41,10 +44,18 @@ describe Braintree::Dispute do
         :amount => "31.00",
         :id => "open_disputed_transaction",
         :created_at => Time.utc(2009, 2, 9, 12, 59, 59),
+        :installment_count => nil,
         :order_id => nil,
         :purchase_order_number => "po",
         :payment_instrument_subtype => "Visa",
-      }
+      },
+      :paypal_messages => [
+        {
+          :message => "message",
+          :sender => "seller",
+          :sent_at => Time.utc(2009, 3, 9, 10, 50, 39),
+        }
+      ]
     }
   end
 
@@ -67,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)
@@ -98,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
@@ -124,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
@@ -133,23 +144,23 @@ 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" })
+          Braintree::Dispute.add_file_evidence("dispute_id", {category: "GENERAL", document_id: "document_id"})
         end.to_not raise_error
       end
 
       it "raises an exception if the optional params contain invalid keys" do
         expect do
-          Braintree::Dispute.add_file_evidence("dispute_id", { random_param: "" })
+          Braintree::Dispute.add_file_evidence("dispute_id", {random_param: ""})
         end.to raise_error(ArgumentError)
       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" })
+          Braintree::Dispute.add_file_evidence("dispute_id", {category: 3, document_id: "document_id"})
         end.to raise_error(ArgumentError)
       end
     end
@@ -175,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
@@ -196,40 +207,33 @@ 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
-        expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { content: "a", tag: "", sequence_number: 3 })
-        end.to_not raise_error
-      end
-
-      it "does not raise an exception if the category parameter is provided" 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 })
+          Braintree::Dispute.add_text_evidence("dispute_id", {content: "a", category: "", sequence_number: 3})
         end.to_not raise_error
       end
 
       it "raises an exception if the optional params contain invalid keys" do
         expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { random_param: "" })
+          Braintree::Dispute.add_text_evidence("dispute_id", {random_param: ""})
         end.to raise_error(ArgumentError)
       end
 
       it "raises an exception if sequence_number is provided and not an integer" do
         expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { sequence_number: "abc" })
+          Braintree::Dispute.add_text_evidence("dispute_id", {sequence_number: "abc"})
         end.to raise_error(ArgumentError)
       end
 
       it "raises an exception if the param tag is not a string" do
         expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { tag: 3 })
+          Braintree::Dispute.add_text_evidence("dispute_id", {tag: 3})
         end.to raise_error(ArgumentError)
       end
 
       it "raises an exception if the param category is not a string" do
         expect do
-          Braintree::Dispute.add_text_evidence("dispute_id", { category: 3 })
+          Braintree::Dispute.add_text_evidence("dispute_id", {category: 3})
         end.to raise_error(ArgumentError)
       end
     end
@@ -277,8 +281,47 @@ 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
+      attributes.merge!(:chargeback_protection_level => Braintree::Dispute::ChargebackProtectionLevel::Effortless)
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Effortless)
+      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::EffortlessCBP)
+    end
+
+    it "returns 'Chargeback Protection tool' when initial chargeback_protection_level is standard" do
+      attributes.merge!(:chargeback_protection_level => Braintree::Dispute::ChargebackProtectionLevel::Standard)
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Standard)
+      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::StandardCBP)
+    end
+
+    it "returns 'No Protection' when initial chargeback_protection_level is nil" do
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.chargeback_protection_level).to eq(nil)
+      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::NoProtection)
+    end
+
+    it "returns 'No Protection' when initial chargeback_protection_level is empty" do
+      attributes.merge!(:chargeback_protection_level => "")
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.chargeback_protection_level).to eq("")
+      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::NoProtection)
+    end
+
+    it "returns 'No Protection' when initial chargeback_protection_level is not_protected" do
+      attributes.merge!(:chargeback_protection_level => Braintree::Dispute::ChargebackProtectionLevel::NotProtected)
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::NotProtected)
+      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::NoProtection)
     end
 
     [
@@ -293,62 +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.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::HistoryEvent objects" do
+    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)
+
+      expect(dispute.paypal_messages.length).to eq(1)
+      paypal_message_1 = dispute.paypal_messages.first
+      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
@@ -356,15 +411,30 @@ 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
+      attributes.delete(:paypal_messages)
+
+      dispute = Braintree::Dispute._new(attributes)
+
+      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
+      attributes.merge!(:pre_dispute_program => Braintree::Dispute::PreDisputeProgram::VisaRdr)
+      dispute = Braintree::Dispute._new(attributes)
+
+      expect(dispute.pre_dispute_program).to eq(Braintree::Dispute::PreDisputeProgram::VisaRdr)
     end
   end
 
@@ -373,21 +443,29 @@ 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
+
+  describe "comments" do
+    let(:dispute) { Braintree::Dispute._new(attributes) }
+
+    it "#processor_comments" do
+      expect(dispute.processor_comments).to eq(attributes[:processor_comments])
     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

@@ -0,0 +1,41 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::EnrichedCustomerData do
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::EnrichedCustomerData.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "self._new" do
+    it "initializes the object with the appropriate attributes set" do
+
+      address = {
+        street_address: "a-street-address",
+        extended_address: "an-extended-address",
+        locality: "a-locality",
+        region: "a-region",
+        postal_code: "a-postal-code"
+      }
+      params = {
+        fields_updated: ["username"],
+        profile_data: {
+          username: "a-username",
+          first_name: "a-first-name",
+          last_name: "a-last-name",
+          phone_number: "a-phone-number",
+          email: "a-email",
+          billing_address: address,
+          shipping_address: address,
+        },
+      }
+
+      payment_method_customer_data_updated = Braintree::EnrichedCustomerData._new(params)
+
+      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

@@ -5,12 +5,12 @@ describe Braintree::ErrorResult do
     it "ignores data other than params, errors, and message" do
       # so that we can add more data into the response in the future without breaking the client lib
       expect do
-        result = Braintree::ErrorResult.new(
+        Braintree::ErrorResult.new(
           :gateway,
           :params => "params",
           :errors => {:errors => []},
           :extra => "is ignored",
-          :message => "foo bar"
+          :message => "foo bar",
         )
       end.to_not raise_error
     end
@@ -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
@@ -36,9 +36,9 @@ describe Braintree::ErrorResult do
         :params => "params",
         :errors => {},
         :verification => {},
-        :transaction => nil
+        :transaction => nil,
       )
-      result.inspect.should include("credit_card_verification: #<Braintree::CreditCardVerification status: ")
+      expect(result.inspect).to include("credit_card_verification: #<Braintree::CreditCardVerification amount: ")
     end
 
     it "does not include the credit_card_verification if there isn't one" do
@@ -47,9 +47,9 @@ describe Braintree::ErrorResult do
         :params => "params",
         :errors => {},
         :verification => nil,
-        :transaction => 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
@@ -58,9 +58,9 @@ describe Braintree::ErrorResult do
         :params => "params",
         :errors => {},
         :verification => nil,
-        :transaction => {}
+        :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
@@ -69,9 +69,9 @@ describe Braintree::ErrorResult do
         :params => "params",
         :errors => {},
         :verification => nil,
-        :transaction => 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

@@ -4,26 +4,26 @@ describe Braintree::Errors do
   describe "for" do
     it "accesses errors for the given scope" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+        :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"}]}
+        :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
 
   describe "inspect" do
     it "is better than the default inspect" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "code1", :attribute => "attr", :message => "message"}]}
+        :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
@@ -33,9 +33,9 @@ describe Braintree::Errors do
           :level2 => {
             :errors => [{:code => "code2", :attribute => "attr2", :message => "message2"}],
           }
-        }
+        },
       )
-      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
@@ -48,9 +48,9 @@ describe Braintree::Errors do
               :errors => [{:code => "code3", :attribute => "attr3", :message => "message3"}],
             }
           }
-        }
+        },
       )
-      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
 
@@ -65,18 +65,18 @@ describe Braintree::Errors do
               {:code => "3", :attribute => "attr3", :message => "message3"}
             ],
           }
-        }
+        },
       )
-      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
 
   describe "size" do
     it "returns the number of validation errors at the first level if only has one level" do
       errors = Braintree::Errors.new(
-        :level1 => {:errors => [{:code => "1", :attribute => "attr", :message => "message"}]}
+        :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
@@ -89,9 +89,9 @@ describe Braintree::Errors do
               {:code => "3", :attribute => "attr3", :message => "message3"}
             ],
           }
-        }
+        },
       )
-      errors.size.should == 3
+      expect(errors.size).to eq(3)
     end
   end
 end