braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/disbursement_spec.rb

@@ -23,9 +23,9 @@ describe Braintree::Disbursement do
       }
 
       disbursement = Braintree::Disbursement._new(Braintree::Configuration.gateway, attributes)
-      disbursement.transactions.maximum_size.should == 1
+      expect(disbursement.transactions.maximum_size).to eq(1)
       transaction = disbursement.transactions.first
-      transaction.id.should == "sub_merchant_transaction"
+      expect(transaction.id).to eq("sub_merchant_transaction")
     end
   end
 end

data/spec/integration/braintree/discount_spec.rb

@@ -20,15 +20,15 @@ describe Braintree::Discount do
       discounts = Braintree::Discount.all
       discount = discounts.select { |discount| discount.id == id }.first
 
-      discount.should_not be_nil
-      discount.amount.should == BigDecimal(expected[:amount])
-      discount.created_at.should_not be_nil
-      discount.description.should == expected[:description]
-      discount.kind.should == expected[:kind]
-      discount.name.should == expected[:name]
-      discount.never_expires.should == expected[:never_expires]
-      discount.number_of_billing_cycles.should == expected[:number_of_billing_cycles]
-      discount.updated_at.should_not be_nil
+      expect(discount).not_to be_nil
+      expect(discount.amount).to eq(BigDecimal(expected[:amount]))
+      expect(discount.created_at).not_to be_nil
+      expect(discount.description).to eq(expected[:description])
+      expect(discount.kind).to eq(expected[:kind])
+      expect(discount.name).to eq(expected[:name])
+      expect(discount.never_expires).to eq(expected[:never_expires])
+      expect(discount.number_of_billing_cycles).to eq(expected[:number_of_billing_cycles])
+      expect(discount.updated_at).not_to be_nil
     end
   end
 end

data/spec/integration/braintree/dispute_search_spec.rb

@@ -18,16 +18,15 @@ describe Braintree::Dispute, "search" do
 
   let(:transaction) do
     result = Braintree::Transaction.sale(
-      :amount => '10.00',
+      :amount => "10.00",
       :credit_card => {
-        :expiration_date => '01/2020',
+        :expiration_date => "01/2020",
         :number => Braintree::Test::CreditCardNumbers::Disputes::Chargeback,
       },
       :customer_id => customer.id,
-      :merchant_account_id => "14LaddersLLC_instant",
       :options => {
         :submit_for_settlement => true,
-      }
+      },
     )
 
     result.transaction
@@ -74,15 +73,52 @@ describe Braintree::Dispute, "search" do
         ]
       end
 
-      expect(collection.disputes.count).to eq(2)
-      dispute = collection.disputes.first
+      expect(collection.disputes.count).to be >= 2
+    end
+
+    it "correctly returns disputes by chargeback protection level flag" do
+      collection = Braintree::Dispute.search do |search|
+        search.chargeback_protection_level.in [
+          Braintree::Dispute::ChargebackProtectionLevel::Effortless
+        ]
+      end
+      expect(collection.disputes.count).to be > 0
+
+      # NEXT_MAJOR_VERSION Remove this assertion when chargeback_protection_level is removed from the SDK
+      collection.disputes.each do |dispute|
+        expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Effortless)
+        expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::EffortlessCBP)
+      end
+    end
+
+    context "pre-dispute program" do
+      it "correctly returns disputes by pre-dispute program" do
+        collection = Braintree::Dispute.search do |search|
+          search.pre_dispute_program.in [
+            Braintree::Dispute::PreDisputeProgram::VisaRdr
+          ]
+        end
+
+        expect(collection.disputes.count).to eq(1)
+        dispute = collection.disputes.first
+        expect(dispute.pre_dispute_program).to eq(Braintree::Dispute::PreDisputeProgram::VisaRdr)
+      end
+
+      it "correctly returns disputes with no pre-dispute program" do
+        collection = Braintree::Dispute.search do |search|
+          search.pre_dispute_program.is Braintree::Dispute::PreDisputeProgram::None
+        end
+
+        expect(collection.disputes.count).to be > 1
+        expect(collection.disputes.map(&:pre_dispute_program).uniq).to eq([Braintree::Dispute::PreDisputeProgram::None])
+      end
     end
 
     it "correctly returns disputes by effective_date range" do
       effective_date = transaction.disputes.first.status_history.first.effective_date
 
       collection = Braintree::Dispute.search do |search|
-        search.effective_date.between(effective_date, Date.parse(effective_date).next_day.to_s)
+        search.effective_date.between(effective_date, effective_date.next_day)
       end
 
       expect(collection.disputes.count).to be >= 1
@@ -95,7 +131,7 @@ describe Braintree::Dispute, "search" do
       disbursement_date = transaction.disputes.first.status_history.first.disbursement_date
 
       collection = Braintree::Dispute.search do |search|
-        search.disbursement_date.between(disbursement_date, Date.parse(disbursement_date).next_day.to_s)
+        search.disbursement_date.between(disbursement_date, disbursement_date.next_day)
       end
 
       expect(collection.disputes.count).to be >= 1
@@ -109,7 +145,7 @@ describe Braintree::Dispute, "search" do
         search.received_date.between("03/03/2014", "03/05/2014")
       end
 
-      expect(collection.disputes.count).to eq(1)
+      expect(collection.disputes.count).to be >= 1
       dispute = collection.disputes.first
 
       expect(dispute.received_date).to eq(Date.new(2014, 3, 4))

data/spec/integration/braintree/dispute_spec.rb

@@ -6,19 +6,19 @@ describe Braintree::Dispute do
   let(:document_upload) do
     file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/bt_logo.png", "r")
     response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
-    document_upload = response.document_upload
+    response.document_upload
   end
 
   let(:transaction) do
     result = Braintree::Transaction.sale(
-      :amount => '10.00',
+      :amount => "10.00",
       :credit_card => {
-        :expiration_date => '01/2020',
+        :expiration_date => "01/2020",
         :number => Braintree::Test::CreditCardNumbers::Disputes::Chargeback
       },
       :options => {
         :submit_for_settlement => true
-      }
+      },
     )
 
     result.transaction
@@ -30,27 +30,27 @@ describe Braintree::Dispute do
     it "changes the dispute status to accepted" do
       result = Braintree::Dispute.accept(dispute.id)
 
-      result.success?.should == true
+      expect(result.success?).to eq(true)
 
       refreshed_dispute = Braintree::Dispute.find(dispute.id)
-      refreshed_dispute.status.should == Braintree::Dispute::Status::Accepted
+      expect(refreshed_dispute.status).to eq(Braintree::Dispute::Status::Accepted)
 
       dispute_from_transaction = Braintree::Transaction.find(dispute.transaction.id).disputes[0]
-      dispute_from_transaction.status.should == Braintree::Dispute::Status::Accepted
+      expect(dispute_from_transaction.status).to eq(Braintree::Dispute::Status::Accepted)
     end
 
     it "returns an error response if the dispute is not in open status" do
       result = Braintree::Dispute.accept("wells_dispute")
 
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyAcceptOpenDispute
-      result.errors.for(:dispute)[0].message.should == "Disputes can only be accepted when they are in an Open state"
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::CanOnlyAcceptOpenDispute)
+      expect(result.errors.for(:dispute)[0].message).to eq("Disputes can only be accepted when they are in an Open state")
     end
 
     it "raises a NotFound exception if the dispute cannot be found" do
       expect do
         Braintree::Dispute.accept("invalid-id")
-      end.to raise_error(Braintree::NotFoundError, 'dispute with id invalid-id not found')
+      end.to raise_error(Braintree::NotFoundError, "dispute with id invalid-id not found")
     end
   end
 
@@ -58,13 +58,13 @@ describe Braintree::Dispute do
     it "creates file evidence for the dispute" do
       result = Braintree::Dispute.add_file_evidence(dispute.id, document_upload.id)
 
-      result.success?.should == true
-      result.evidence.category.should be_nil
-      result.evidence.comment.should be_nil
-      result.evidence.created_at.between?(Time.now - 10, Time.now).should == true
-      result.evidence.id.should =~ /^\w{16,}$/
-      result.evidence.sent_to_processor_at.should == nil
-      result.evidence.url.should include("bt_logo.png")
+      expect(result.success?).to eq(true)
+      expect(result.evidence.category).to be_nil
+      expect(result.evidence.comment).to be_nil
+      expect(result.evidence.created_at.between?(Time.now - 10, Time.now)).to eq(true)
+      expect(result.evidence.id).to match(/^\w{16,}$/)
+      expect(result.evidence.sent_to_processor_at).to eq(nil)
+      expect(result.evidence.url).to include("bt_logo.png")
     end
 
     it "returns a NotFoundError if the dispute doesn't exist" do
@@ -77,9 +77,9 @@ describe Braintree::Dispute do
       Braintree::Dispute.accept(dispute.id)
 
       result = Braintree::Dispute.add_file_evidence(dispute.id, document_upload.id)
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyAddEvidenceToOpenDispute
-      result.errors.for(:dispute)[0].message.should == "Evidence can only be attached to disputes that are in an Open state"
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::CanOnlyAddEvidenceToOpenDispute)
+      expect(result.errors.for(:dispute)[0].message).to eq("Evidence can only be attached to disputes that are in an Open state")
     end
 
     it "returns the new evidence record in subsequent dispute finds" do
@@ -87,17 +87,17 @@ describe Braintree::Dispute do
       refreshed_dispute = Braintree::Dispute.find(dispute.id)
 
       expected_evidence = refreshed_dispute.evidence.find { |e| e.id == result.evidence.id }
-      expected_evidence.should_not == nil
-      expected_evidence.comment.should be_nil
-      expected_evidence.url.should include("bt_logo.png")
+      expect(expected_evidence).not_to eq(nil)
+      expect(expected_evidence.comment).to be_nil
+      expect(expected_evidence.url).to include("bt_logo.png")
     end
 
     it "creates file evidence with a category when provided" do
       result = Braintree::Dispute.add_file_evidence(dispute.id, {category: "GENERAL", document_id: document_upload.id})
 
-      result.success?.should == true
-      result.evidence.category.should == "GENERAL"
-      result.evidence.url.should include("bt_logo.png")
+      expect(result.success?).to eq(true)
+      expect(result.evidence.category).to eq("GENERAL")
+      expect(result.evidence.url).to include("bt_logo.png")
     end
   end
 
@@ -105,15 +105,15 @@ describe Braintree::Dispute do
     it "creates text evidence for the dispute" do
       result = Braintree::Dispute.add_text_evidence(dispute.id, "text evidence")
 
-      result.success?.should == true
-      result.evidence.category.should == nil
-      result.evidence.comment.should == "text evidence"
-      result.evidence.created_at.between?(Time.now - 10, Time.now).should == true
-      result.evidence.id.should =~ /^\w{16,}$/
-      result.evidence.sent_to_processor_at.should == nil
-      result.evidence.url.should == nil
-      result.evidence.tag.should == nil
-      result.evidence.sequence_number.should == nil
+      expect(result.success?).to eq(true)
+      expect(result.evidence.category).to eq(nil)
+      expect(result.evidence.comment).to eq("text evidence")
+      expect(result.evidence.created_at.between?(Time.now - 10, Time.now)).to eq(true)
+      expect(result.evidence.id).to match(/^\w{16,}$/)
+      expect(result.evidence.sent_to_processor_at).to eq(nil)
+      expect(result.evidence.url).to eq(nil)
+      expect(result.evidence.tag).to eq(nil)
+      expect(result.evidence.sequence_number).to eq(nil)
     end
 
     it "returns a NotFoundError if the dispute doesn't exist" do
@@ -126,9 +126,9 @@ describe Braintree::Dispute do
       Braintree::Dispute.accept(dispute.id)
 
       result = Braintree::Dispute.add_text_evidence(dispute.id, "text evidence")
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyAddEvidenceToOpenDispute
-      result.errors.for(:dispute)[0].message.should == "Evidence can only be attached to disputes that are in an Open state"
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::CanOnlyAddEvidenceToOpenDispute)
+      expect(result.errors.for(:dispute)[0].message).to eq("Evidence can only be attached to disputes that are in an Open state")
     end
 
     it "returns the new evidence record in subsequent dispute finds" do
@@ -136,21 +136,47 @@ describe Braintree::Dispute do
       refreshed_dispute = Braintree::Dispute.find(dispute.id)
 
       expected_evidence = refreshed_dispute.evidence.find { |e| e.id == result.evidence.id }
-      expected_evidence.should_not == nil
-      expected_evidence.comment.should == "text evidence"
+      expect(expected_evidence).not_to eq(nil)
+      expect(expected_evidence.comment).to eq("text evidence")
     end
 
     it "creates text evidence for the dispute with optional parameters" do
-      result = Braintree::Dispute.add_text_evidence(dispute.id, { content: "123456789", tag: "REFUND_ID", sequence_number: 7 })
+      result = Braintree::Dispute.add_text_evidence(dispute.id, {content: "123456789", category: "REFUND_ID", sequence_number: 7})
+
+      expect(result.success?).to eq(true)
+      expect(result.evidence.category).to eq("REFUND_ID")
+      expect(result.evidence.comment).to eq("123456789")
+      expect(result.evidence.created_at.between?(Time.now - 10, Time.now)).to eq(true)
+      expect(result.evidence.id).to match(/^\w{16,}$/)
+      expect(result.evidence.sent_to_processor_at).to eq(nil)
+      expect(result.evidence.sequence_number).to eq(7)
+    end
+
+    it "creates text evidence for the dispute with CARRIER_NAME shipping tracking" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, {content: "UPS", category: "CARRIER_NAME", sequence_number: 0})
+
+      expect(result.success?).to eq(true)
+      expect(result.evidence.category).to eq("CARRIER_NAME")
+      expect(result.evidence.comment).to eq("UPS")
+      expect(result.evidence.sequence_number).to eq(0)
+    end
+
+    it "creates text evidence for the dispute with TRACKING_NUMBER shipping tracking" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, {content: "3", category: "TRACKING_NUMBER", sequence_number: 0})
+
+      expect(result.success?).to eq(true)
+      expect(result.evidence.category).to eq("TRACKING_NUMBER")
+      expect(result.evidence.comment).to eq("3")
+      expect(result.evidence.sequence_number).to eq(0)
+    end
+
+    it "creates text evidence for the dispute with TRACKING_URL shipping tracking" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, {content: "https://example.com/tracking-number/abc12345", category: "TRACKING_URL", sequence_number: 1})
 
-      result.success?.should == true
-      result.evidence.category.should == "REFUND_ID"
-      result.evidence.comment.should == "123456789"
-      result.evidence.created_at.between?(Time.now - 10, Time.now).should == true
-      result.evidence.id.should =~ /^\w{16,}$/
-      result.evidence.sent_to_processor_at.should == nil
-      result.evidence.tag.should == "REFUND_ID"
-      result.evidence.sequence_number.should == 7
+      expect(result.success?).to eq(true)
+      expect(result.evidence.category).to eq("TRACKING_URL")
+      expect(result.evidence.comment).to eq("https://example.com/tracking-number/abc12345")
+      expect(result.evidence.sequence_number).to eq(1)
     end
   end
 
@@ -158,24 +184,24 @@ describe Braintree::Dispute do
     it "changes the dispute status to disputed" do
       result = Braintree::Dispute.finalize(dispute.id)
 
-      result.success?.should == true
+      expect(result.success?).to eq(true)
 
       refreshed_dispute = Braintree::Dispute.find(dispute.id)
-      refreshed_dispute.status.should == Braintree::Dispute::Status::Disputed
+      expect(refreshed_dispute.status).to eq(Braintree::Dispute::Status::Disputed)
     end
 
     it "returns an error response if the dispute is not in open status" do
       result = Braintree::Dispute.finalize("wells_dispute")
 
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyFinalizeOpenDispute
-      result.errors.for(:dispute)[0].message.should == "Disputes can only be finalized when they are in an Open state"
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::CanOnlyFinalizeOpenDispute)
+      expect(result.errors.for(:dispute)[0].message).to eq("Disputes can only be finalized when they are in an Open state")
     end
 
     it "raises a NotFound exception if the dispute cannot be found" do
       expect do
         Braintree::Dispute.finalize("invalid-id")
-      end.to raise_error(Braintree::NotFoundError, 'dispute with id invalid-id not found')
+      end.to raise_error(Braintree::NotFoundError, "dispute with id invalid-id not found")
     end
   end
 
@@ -183,12 +209,13 @@ describe Braintree::Dispute do
     it "finds the dispute with the given id" do
       dispute = Braintree::Dispute.find("open_dispute")
 
-      dispute.amount_disputed.should == 31.0
-      dispute.amount_won.should == 0.0
-      dispute.id.should == "open_dispute"
-      dispute.status.should == Braintree::Dispute::Status::Open
-      dispute.transaction.amount.should == 31.0
-      dispute.transaction.id.should == "open_disputed_transaction"
+      expect(dispute.amount_disputed).to eq(31.0)
+      expect(dispute.amount_won).to eq(0.0)
+      expect(dispute.id).to eq("open_dispute")
+      expect(dispute.graphql_id).not_to be_nil
+      expect(dispute.status).to eq(Braintree::Dispute::Status::Open)
+      expect(dispute.transaction.amount).to eq(31.0)
+      expect(dispute.transaction.id).to eq("open_disputed_transaction")
     end
 
     it "raises an ArgumentError if dispute_id is not a string" do
@@ -216,7 +243,7 @@ describe Braintree::Dispute do
     it "removes evidence from the dispute" do
       result = Braintree::Dispute.remove_evidence(dispute.id, evidence.id)
 
-      result.success?.should == true
+      expect(result.success?).to eq(true)
     end
 
     it "returns a NotFoundError if the dispute doesn't exist" do
@@ -236,9 +263,9 @@ describe Braintree::Dispute do
       Braintree::Dispute.accept(dispute.id)
 
       result = Braintree::Dispute.remove_evidence(dispute.id, evidence.id)
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyRemoveEvidenceFromOpenDispute
-      result.errors.for(:dispute)[0].message.should == "Evidence can only be removed from disputes that are in an Open state"
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::CanOnlyRemoveEvidenceFromOpenDispute)
+      expect(result.errors.for(:dispute)[0].message).to eq("Evidence can only be removed from disputes that are in an Open state")
     end
   end
 
@@ -246,61 +273,61 @@ describe Braintree::Dispute do
     it "fails to create file evidence for an unsupported category" do
       result = Braintree::Dispute.add_file_evidence(dispute.id, {category: "NOTREALCATEGORY", document_id: document_upload.id})
 
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyCreateEvidenceWithValidCategory
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::CanOnlyCreateEvidenceWithValidCategory)
     end
 
     it "fails to create text evidence for an unsupported category" do
       result = Braintree::Dispute.add_text_evidence(dispute.id, {category: "NOTREALCATEGORY", content: "evidence"})
 
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::CanOnlyCreateEvidenceWithValidCategory
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::CanOnlyCreateEvidenceWithValidCategory)
     end
 
     it "fails to create text evidence for a file only category MERCHANT_WEBSITE_OR_APP_ACCESS" do
       result = Braintree::Dispute.add_text_evidence(dispute.id, {category: "MERCHANT_WEBSITE_OR_APP_ACCESS", content: "evidence"})
 
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::EvidenceCategoryDocumentOnly
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::EvidenceCategoryDocumentOnly)
     end
 
     it "fails to create file evidence for a text only category DEVICE_ID" do
       result = Braintree::Dispute.add_file_evidence(dispute.id, {category: "DEVICE_ID", document_id: document_upload.id})
 
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::EvidenceCategoryTextOnly
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::EvidenceCategoryTextOnly)
     end
 
     it "fails to create evidence with an invalid date time format" do
       result = Braintree::Dispute.add_text_evidence(dispute.id, {category: "DOWNLOAD_DATE_TIME", content: "baddate"})
 
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::EvidenceContentDateInvalid
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::EvidenceContentDateInvalid)
     end
 
     it "successfully creates text evidence with an valid date time format" do
       result = Braintree::Dispute.add_text_evidence(dispute.id, {category: "DOWNLOAD_DATE_TIME", content: "2018-10-20T18:00:00-0500"})
 
-      result.success?.should == true
+      expect(result.success?).to eq(true)
     end
 
     it "fails to finalize a dispute with digital goods missing" do
       Braintree::Dispute.add_text_evidence(dispute.id, {category: "DEVICE_ID", content: "iphone_id"})
       result = Braintree::Dispute.finalize(dispute.id)
 
-      result.success?.should == false
+      expect(result.success?).to eq(false)
       error_codes = result.errors.for(:dispute).map(&:code)
 
-      error_codes.should include(Braintree::ErrorCodes::Dispute::DigitalGoodsMissingDownloadDate)
-      error_codes.should include(Braintree::ErrorCodes::Dispute::DigitalGoodsMissingEvidence)
+      expect(error_codes).to include(Braintree::ErrorCodes::Dispute::DigitalGoodsMissingDownloadDate)
+      expect(error_codes).to include(Braintree::ErrorCodes::Dispute::DigitalGoodsMissingEvidence)
     end
 
     it "fails to finalize a dispute with partial non-disputed transaction information provided" do
       Braintree::Dispute.add_text_evidence(dispute.id, {category: "PRIOR_NON_DISPUTED_TRANSACTION_ARN", content: "123"})
       result = Braintree::Dispute.finalize(dispute.id)
 
-      result.success?.should == false
-      result.errors.for(:dispute)[0].code.should == Braintree::ErrorCodes::Dispute::NonDisputedPriorTransactionEvidenceMissingDate
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:dispute)[0].code).to eq(Braintree::ErrorCodes::Dispute::NonDisputedPriorTransactionEvidenceMissingDate)
     end
   end
 end

data/spec/integration/braintree/document_upload_spec.rb

@@ -7,30 +7,30 @@ describe Braintree::DocumentUploadGateway do
       response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
       document_upload = response.document_upload
 
-      response.success?.should == true
-      document_upload.id.should_not be_nil
-      document_upload.content_type.should == "image/png"
-      document_upload.kind.should == Braintree::DocumentUpload::Kind::EvidenceDocument
-      document_upload.name.should == "bt_logo.png"
-      document_upload.size.should == 2443
+      expect(response.success?).to eq(true)
+      expect(document_upload.id).not_to be_nil
+      expect(document_upload.content_type).to eq("image/png")
+      expect(document_upload.kind).to eq(Braintree::DocumentUpload::Kind::EvidenceDocument)
+      expect(document_upload.name).to eq("bt_logo.png")
+      expect(document_upload.size).to eq(2443)
     end
 
     it "returns file type error with unsupported file type" do
       file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/gif_extension_bt_logo.gif", "r")
       response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
-      response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::FileTypeIsInvalid
+      expect(response.errors.for(:document_upload).first.code).to eq(Braintree::ErrorCodes::DocumentUpload::FileTypeIsInvalid)
     end
 
     it "returns malformed error with malformed file" do
       file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/malformed_pdf.pdf", "r")
       response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
-      response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::FileIsMalformedOrEncrypted
+      expect(response.errors.for(:document_upload).first.code).to eq(Braintree::ErrorCodes::DocumentUpload::FileIsMalformedOrEncrypted)
     end
 
     it "returns invalid kind error with invalid kind" do
       file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/bt_logo.png", "r")
       response = Braintree::DocumentUpload.create({:kind => "invalid_kind", :file => file})
-      response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::KindIsInvalid
+      expect(response.errors.for(:document_upload).first.code).to eq(Braintree::ErrorCodes::DocumentUpload::KindIsInvalid)
     end
 
     it "returns file too large error with file over 4mb" do
@@ -40,7 +40,19 @@ describe Braintree::DocumentUploadGateway do
         File.open(filename, "w+") { |f| write_times.times { f.write "a" } }
         file = File.new(filename, "r")
         response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
-        response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::FileIsTooLarge
+        expect(response.errors.for(:document_upload).first.code).to eq(Braintree::ErrorCodes::DocumentUpload::FileIsTooLarge)
+      ensure
+        File.delete(filename)
+      end
+    end
+
+    it "returns file is empty error with empty file" do
+      filename = "#{File.dirname(__FILE__)}/../../fixtures/files/empty_file.png"
+      begin
+        File.open(filename, "w+") {}
+        file = File.new(filename, "r")
+        response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
+        expect(response.errors.for(:document_upload).first.code).to eq(Braintree::ErrorCodes::DocumentUpload::FileIsEmpty)
       ensure
         File.delete(filename)
       end
@@ -50,12 +62,12 @@ describe Braintree::DocumentUploadGateway do
       filename = "#{File.dirname(__FILE__)}/../../fixtures/files/too_long.pdf"
       file = File.new(filename, "r")
       response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
-      response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::FileIsTooLong
+      expect(response.errors.for(:document_upload).first.code).to eq(Braintree::ErrorCodes::DocumentUpload::FileIsTooLong)
     end
 
     it "returns invalid keys error if signature is invalid" do
       expect do
-        response = Braintree::DocumentUpload.create({:invalid_key => "do not add", :kind => Braintree::DocumentUpload::Kind::EvidenceDocument})
+        Braintree::DocumentUpload.create({:invalid_key => "do not add", :kind => Braintree::DocumentUpload::Kind::EvidenceDocument})
       end.to raise_error(ArgumentError, "invalid keys: invalid_key")
     end
   end
@@ -65,11 +77,11 @@ describe Braintree::DocumentUploadGateway do
       file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/bt_logo.png", "r")
       document_upload = Braintree::DocumentUpload.create!({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
 
-      document_upload.id.should_not be_nil
-      document_upload.content_type.should == "image/png"
-      document_upload.kind.should == Braintree::DocumentUpload::Kind::EvidenceDocument
-      document_upload.name.should == "bt_logo.png"
-      document_upload.size.should == 2443
+      expect(document_upload.id).not_to be_nil
+      expect(document_upload.content_type).to eq("image/png")
+      expect(document_upload.kind).to eq(Braintree::DocumentUpload::Kind::EvidenceDocument)
+      expect(document_upload.name).to eq("bt_logo.png")
+      expect(document_upload.size).to eq(2443)
     end
   end
 end

data/spec/integration/braintree/error_codes_spec.rb

@@ -6,10 +6,10 @@ describe Braintree::ErrorCodes do
       result = Braintree::Customer.create(
         :credit_card => {
           :cardholder_name => "x" * 256
-        }
+        },
       )
-      result.success?.should == false
-      result.errors.for(:customer).for(:credit_card).map { |e| e.code }.should \
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:customer).for(:credit_card).map { |e| e.code }).to \
         include(Braintree::ErrorCodes::CreditCard::CardholderNameIsTooLong)
     end
   end