braintree 4.14.0 → 4.15.0

data/spec/integration/braintree/transaction_us_bank_account_spec.rb

@@ -25,8 +25,8 @@ describe Braintree::Transaction do
                 :submit_for_settlement => true,
               },
             )
-            result.success?.should == false
-            result.errors.for(:transaction).on(:payment_method_nonce)[0].code.should == Braintree::ErrorCodes::Transaction::UsBankAccountNonceMustBePlaidVerified
+            expect(result.success?).to eq(false)
+            expect(result.errors.for(:transaction).on(:payment_method_nonce)[0].code).to eq(Braintree::ErrorCodes::Transaction::UsBankAccountNonceMustBePlaidVerified)
           end
 
           it "sale fails for invalid nonce" do
@@ -39,8 +39,8 @@ describe Braintree::Transaction do
                 :submit_for_settlement => true,
               },
             )
-            result.success?.should == false
-            result.errors.for(:transaction).on(:payment_method_nonce)[0].code.should == Braintree::ErrorCodes::Transaction::PaymentMethodNonceUnknown
+            expect(result.success?).to eq(false)
+            expect(result.errors.for(:transaction).on(:payment_method_nonce)[0].code).to eq(Braintree::ErrorCodes::Transaction::PaymentMethodNonceUnknown)
           end
         end
 
@@ -56,12 +56,12 @@ describe Braintree::Transaction do
             )
             payment_method = result.payment_method
 
-            payment_method.verifications.count.should == 1
+            expect(payment_method.verifications.count).to eq(1)
             payment_method.verifications.first.status == Braintree::UsBankAccountVerification::Status::Verified
             payment_method.verifications.first.verification_method == Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck
-            payment_method.verifications.first.id.should_not be_empty
-            payment_method.verifications.first.verification_determined_at.should be_a Time
-            payment_method.verified.should == true
+            expect(payment_method.verifications.first.id).not_to be_empty
+            expect(payment_method.verifications.first.verification_determined_at).to be_a Time
+            expect(payment_method.verified).to eq(true)
 
             result = Braintree::Transaction.create(
               :type => "sale",
@@ -73,7 +73,7 @@ describe Braintree::Transaction do
               },
             )
 
-            result.success?.should == true
+            expect(result.success?).to eq(true)
           end
 
           it "sale fails for unverified token" do
@@ -85,8 +85,8 @@ describe Braintree::Transaction do
               },
             ).payment_method
 
-            payment_method.verifications.count.should == 0
-            payment_method.verified.should == false
+            expect(payment_method.verifications.count).to eq(0)
+            expect(payment_method.verified).to eq(false)
 
             result = Braintree::Transaction.create(
               :type => "sale",
@@ -98,8 +98,8 @@ describe Braintree::Transaction do
               },
             )
 
-            result.success?.should == false
-            result.errors.for(:transaction)[0].code.should == Braintree::ErrorCodes::Transaction::UsBankAccountNotVerified
+            expect(result.success?).to eq(false)
+            expect(result.errors.for(:transaction)[0].code).to eq(Braintree::ErrorCodes::Transaction::UsBankAccountNotVerified)
           end
         end
       end
@@ -127,21 +127,21 @@ describe Braintree::Transaction do
                 :submit_for_settlement => true,
               },
             )
-            result.success?.should == true
+            expect(result.success?).to eq(true)
 
             transaction = result.transaction
 
-            transaction.id.should =~ /^\w{6,}$/
-            transaction.type.should == "sale"
-            transaction.amount.should == BigDecimal(Braintree::Test::TransactionAmounts::Authorize)
-            transaction.status.should == Braintree::Transaction::Status::SettlementPending
-            transaction.us_bank_account_details.routing_number.should == "021000021"
-            transaction.us_bank_account_details.last_4.should == "0000"
-            transaction.us_bank_account_details.account_type.should == "checking"
-            transaction.us_bank_account_details.account_holder_name.should == "John Doe"
-            transaction.us_bank_account_details.bank_name.should =~ /CHASE/
-            transaction.us_bank_account_details.ach_mandate.text.should == "cl mandate text"
-            transaction.us_bank_account_details.ach_mandate.accepted_at.should be_a Time
+            expect(transaction.id).to match(/^\w{6,}$/)
+            expect(transaction.type).to eq("sale")
+            expect(transaction.amount).to eq(BigDecimal(Braintree::Test::TransactionAmounts::Authorize))
+            expect(transaction.status).to eq(Braintree::Transaction::Status::SettlementPending)
+            expect(transaction.us_bank_account_details.routing_number).to eq("021000021")
+            expect(transaction.us_bank_account_details.last_4).to eq("0000")
+            expect(transaction.us_bank_account_details.account_type).to eq("checking")
+            expect(transaction.us_bank_account_details.account_holder_name).to eq("John Doe")
+            expect(transaction.us_bank_account_details.bank_name).to match(/CHASE/)
+            expect(transaction.us_bank_account_details.ach_mandate.text).to eq("cl mandate text")
+            expect(transaction.us_bank_account_details.ach_mandate.accepted_at).to be_a Time
           end
 
           it "sale fails for invalid nonce" do
@@ -154,8 +154,8 @@ describe Braintree::Transaction do
                 :submit_for_settlement => true,
               },
             )
-            result.success?.should == false
-            result.errors.for(:transaction).on(:payment_method_nonce)[0].code.should == Braintree::ErrorCodes::Transaction::PaymentMethodNonceUnknown
+            expect(result.success?).to eq(false)
+            expect(result.errors.for(:transaction).on(:payment_method_nonce)[0].code).to eq(Braintree::ErrorCodes::Transaction::PaymentMethodNonceUnknown)
           end
         end
 
@@ -170,12 +170,12 @@ describe Braintree::Transaction do
             )
             payment_method = result.payment_method
 
-            payment_method.verifications.count.should == 1
+            expect(payment_method.verifications.count).to eq(1)
             payment_method.verifications.first.status == Braintree::UsBankAccountVerification::Status::Verified
             payment_method.verifications.first.verification_method == Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck
-            payment_method.verifications.first.id.should_not be_empty
-            payment_method.verifications.first.verification_determined_at.should be_a Time
-            payment_method.verified.should == true
+            expect(payment_method.verifications.first.id).not_to be_empty
+            expect(payment_method.verifications.first.verification_determined_at).to be_a Time
+            expect(payment_method.verified).to eq(true)
 
             result = Braintree::Transaction.create(
               :type => "sale",
@@ -187,7 +187,7 @@ describe Braintree::Transaction do
               },
             )
 
-            result.success?.should == true
+            expect(result.success?).to eq(true)
           end
         end
       end

data/spec/integration/braintree/us_bank_account_spec.rb

@@ -14,17 +14,17 @@ describe Braintree::UsBankAccount do
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
         },
       )
-      result.should be_success
+      expect(result).to be_success
 
       us_bank_account = Braintree::UsBankAccount.find(result.payment_method.token)
-      us_bank_account.should be_a(Braintree::UsBankAccount)
-      us_bank_account.routing_number.should == "021000021"
-      us_bank_account.last_4.should == "0000"
-      us_bank_account.account_type.should == "checking"
-      us_bank_account.account_holder_name.should == "John Doe"
-      us_bank_account.bank_name.should =~ /CHASE/
-      us_bank_account.ach_mandate.text.should == "cl mandate text"
-      us_bank_account.ach_mandate.accepted_at.should be_a Time
+      expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+      expect(us_bank_account.routing_number).to eq("021000021")
+      expect(us_bank_account.last_4).to eq("0000")
+      expect(us_bank_account.account_type).to eq("checking")
+      expect(us_bank_account.account_holder_name).to eq("John Doe")
+      expect(us_bank_account.bank_name).to match(/CHASE/)
+      expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+      expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
     end
 
     it "raises if the payment method token is not found" do
@@ -46,7 +46,7 @@ describe Braintree::UsBankAccount do
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
         },
       )
-      result.should be_success
+      expect(result).to be_success
 
       result = Braintree::UsBankAccount.sale(
         result.payment_method.token,
@@ -54,17 +54,17 @@ describe Braintree::UsBankAccount do
         :amount => "100.00",
       )
 
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal("100.00")
-      result.transaction.type.should == "sale"
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("sale")
       us_bank_account = result.transaction.us_bank_account_details
-      us_bank_account.routing_number.should == "021000021"
-      us_bank_account.last_4.should == "0000"
-      us_bank_account.account_type.should == "checking"
-      us_bank_account.account_holder_name.should == "John Doe"
-      us_bank_account.bank_name.should =~ /CHASE/
-      us_bank_account.ach_mandate.text.should == "cl mandate text"
-      us_bank_account.ach_mandate.accepted_at.should be_a Time
+      expect(us_bank_account.routing_number).to eq("021000021")
+      expect(us_bank_account.last_4).to eq("0000")
+      expect(us_bank_account.account_type).to eq("checking")
+      expect(us_bank_account.account_holder_name).to eq("John Doe")
+      expect(us_bank_account.bank_name).to match(/CHASE/)
+      expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+      expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
     end
   end
 
@@ -80,7 +80,7 @@ describe Braintree::UsBankAccount do
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
         },
       )
-      result.should be_success
+      expect(result).to be_success
 
       transaction = Braintree::UsBankAccount.sale!(
         result.payment_method.token,
@@ -88,16 +88,16 @@ describe Braintree::UsBankAccount do
         :amount => "100.00",
       )
 
-      transaction.amount.should == BigDecimal("100.00")
-      transaction.type.should == "sale"
+      expect(transaction.amount).to eq(BigDecimal("100.00"))
+      expect(transaction.type).to eq("sale")
       us_bank_account = transaction.us_bank_account_details
-      us_bank_account.routing_number.should == "021000021"
-      us_bank_account.last_4.should == "0000"
-      us_bank_account.account_type.should == "checking"
-      us_bank_account.account_holder_name.should == "John Doe"
-      us_bank_account.bank_name.should =~ /CHASE/
-      us_bank_account.ach_mandate.text.should == "cl mandate text"
-      us_bank_account.ach_mandate.accepted_at.should be_a Time
+      expect(us_bank_account.routing_number).to eq("021000021")
+      expect(us_bank_account.last_4).to eq("0000")
+      expect(us_bank_account.account_type).to eq("checking")
+      expect(us_bank_account.account_holder_name).to eq("John Doe")
+      expect(us_bank_account.bank_name).to match(/CHASE/)
+      expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+      expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
     end
 
     it "does not creates a transaction using a us bank account and returns raises an exception" do

data/spec/integration/braintree/us_bank_account_verification_search_spec.rb

@@ -7,7 +7,7 @@ describe Braintree::UsBankAccountVerification, "search" do
       search.account_holder_name.is "thisnameisnotreal"
     end
 
-    collection.maximum_size.should == 0
+    expect(collection.maximum_size).to eq(0)
   end
 
   let(:nonce) { generate_non_plaid_us_bank_account_nonce }
@@ -40,14 +40,14 @@ describe Braintree::UsBankAccountVerification, "search" do
         search.id.is verification.id
         search.send(criterion).is value
       end
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
 
       collection = Braintree::UsBankAccountVerification.search do |search|
         search.id.is verification.id
         search.send(criterion).is "invalid_attribute"
       end
-      collection.should be_empty
+      expect(collection).to be_empty
     end
 
     collection = Braintree::UsBankAccountVerification.search do |search|
@@ -57,8 +57,8 @@ describe Braintree::UsBankAccountVerification, "search" do
       end
     end
 
-    collection.maximum_size.should == 1
-    collection.first.id.should == verification.id
+    expect(collection.maximum_size).to eq(1)
+    expect(collection.first.id).to eq(verification.id)
   end
 
   describe "multiple value fields" do
@@ -87,7 +87,7 @@ describe Braintree::UsBankAccountVerification, "search" do
         search.ids.in verification1.id, verification2.id
       end
 
-      collection.maximum_size.should == 2
+      expect(collection.maximum_size).to eq(2)
     end
   end
 
@@ -114,24 +114,24 @@ describe Braintree::UsBankAccountVerification, "search" do
         )
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
 
       collection = Braintree::UsBankAccountVerification.search do |search|
         search.id.is verification.id
         search.created_at >= created_at - 1
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
 
       collection = Braintree::UsBankAccountVerification.search do |search|
         search.id.is verification.id
         search.created_at <= created_at + 1
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
 
       collection = Braintree::UsBankAccountVerification.search do |search|
         search.id.is verification.id
@@ -141,15 +141,15 @@ describe Braintree::UsBankAccountVerification, "search" do
         )
       end
 
-      collection.maximum_size.should == 0
+      expect(collection.maximum_size).to eq(0)
 
       collection = Braintree::UsBankAccountVerification.search do |search|
         search.id.is verification.id
         search.created_at.is created_at
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
     end
   end
 
@@ -171,8 +171,8 @@ describe Braintree::UsBankAccountVerification, "search" do
         search.account_number.ends_with "0000"
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == verification.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
     end
   end
 end

data/spec/integration/braintree/us_bank_account_verification_spec.rb

@@ -39,20 +39,20 @@ describe Braintree::UsBankAccountVerification do
           },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
-        verification.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers
-        verification.status.should == Braintree::UsBankAccountVerification::Status::Pending
+        expect(verification.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers)
+        expect(verification.status).to eq(Braintree::UsBankAccountVerification::Status::Pending)
 
         response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [17, 29])
 
-        response.should be_success
-        response.us_bank_account_verification.status.should == Braintree::UsBankAccountVerification::Status::Verified
+        expect(response).to be_success
+        expect(response.us_bank_account_verification.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
 
         us_bank_account = Braintree::UsBankAccount.find(response.us_bank_account_verification.us_bank_account[:token])
 
-        us_bank_account.verified.should be_truthy
+        expect(us_bank_account.verified).to be_truthy
       end
 
       it "successfully confirms not-yet-settled amounts" do
@@ -67,16 +67,16 @@ describe Braintree::UsBankAccountVerification do
           },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
-        verification.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers
-        verification.status.should == Braintree::UsBankAccountVerification::Status::Pending
+        expect(verification.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers)
+        expect(verification.status).to eq(Braintree::UsBankAccountVerification::Status::Pending)
 
         response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [17, 29])
 
-        response.should be_success
-        response.us_bank_account_verification.status.should == Braintree::UsBankAccountVerification::Status::Pending
+        expect(response).to be_success
+        expect(response.us_bank_account_verification.status).to eq(Braintree::UsBankAccountVerification::Status::Pending)
       end
 
       it "attempts to confirm" do
@@ -89,16 +89,16 @@ describe Braintree::UsBankAccountVerification do
           },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
-        verification.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers
-        verification.status.should == Braintree::UsBankAccountVerification::Status::Pending
+        expect(verification.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::MicroTransfers)
+        expect(verification.status).to eq(Braintree::UsBankAccountVerification::Status::Pending)
 
         response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
 
-        response.should_not be_success
-        response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::AmountsDoNotMatch
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::AmountsDoNotMatch)
       end
 
       it "exceeds the confirmation attempt threshold" do
@@ -111,7 +111,7 @@ describe Braintree::UsBankAccountVerification do
           },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
 
@@ -119,17 +119,17 @@ describe Braintree::UsBankAccountVerification do
         4.times do
           response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
 
-          response.should_not be_success
-          response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::AmountsDoNotMatch
+          expect(response).not_to be_success
+          expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::AmountsDoNotMatch)
         end
 
         response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
-        response.should_not be_success
-        response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::TooManyConfirmationAttempts
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::TooManyConfirmationAttempts)
 
         response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
-        response.should_not be_success
-        response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::TooManyConfirmationAttempts
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::TooManyConfirmationAttempts)
       end
 
       it "returns an error for invalid deposit amounts" do
@@ -142,13 +142,13 @@ describe Braintree::UsBankAccountVerification do
           },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
         response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, ["abc"])
 
-        response.should_not be_success
-        response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::InvalidDepositAmounts
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::InvalidDepositAmounts)
       end
     end
 
@@ -163,13 +163,13 @@ describe Braintree::UsBankAccountVerification do
           },
         )
 
-        result.should be_success
+        expect(result).to be_success
 
         verification = result.payment_method.verifications.first
         response = Braintree::UsBankAccountVerification.confirm_micro_transfer_amounts(verification.id, [1, 1])
 
-        response.should_not be_success
-        response.errors.for(:us_bank_account_verification)[0].code.should == Braintree::ErrorCodes::UsBankAccountVerification::MustBeMicroTransfersVerification
+        expect(response).not_to be_success
+        expect(response.errors.for(:us_bank_account_verification)[0].code).to eq(Braintree::ErrorCodes::UsBankAccountVerification::MustBeMicroTransfersVerification)
       end
     end
   end
@@ -185,12 +185,12 @@ describe Braintree::UsBankAccountVerification do
         },
       )
 
-      result.should be_success
+      expect(result).to be_success
 
       created_verification = result.payment_method.verifications.first
       found_verification = Braintree::UsBankAccountVerification.find(created_verification.id)
 
-      found_verification.should == created_verification
+      expect(found_verification).to eq(created_verification)
     end
 
     it "raises a NotFoundError exception if verification cannot be found" do
@@ -224,7 +224,7 @@ describe Braintree::UsBankAccountVerification do
         search.verification_method.in created_verification.verification_method
       end
 
-      found_verifications.should include(created_verification)
+      expect(found_verifications).to include(created_verification)
     end
 
     it "searches and finds verifications using customer fields" do
@@ -234,7 +234,7 @@ describe Braintree::UsBankAccountVerification do
         search.payment_method_token.is payment_method.token
       end
 
-      found_verifications.count.should eq(1)
+      expect(found_verifications.count).to eq(1)
     end
   end
 end