braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/transaction_us_bank_account_spec.rb

@@ -10,123 +10,6 @@ describe Braintree::Transaction do
         Braintree::Configuration.private_key = "integration2_private_key"
       end
 
-      context "plaid-verified" do
-        let(:plaid_nonce) { generate_valid_plaid_us_bank_account_nonce }
-
-        context "nonce" do
-          it "sale succeeds" do
-            result = Braintree::Transaction.create(
-              :type => "sale",
-              :amount => Braintree::Test::TransactionAmounts::Authorize,
-              :merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-              :payment_method_nonce => plaid_nonce,
-              :options => {
-                :submit_for_settlement => true,
-              }
-            )
-            result.success?.should == true
-            result.transaction.id.should =~ /^\w{6,}$/
-            result.transaction.type.should == "sale"
-            result.transaction.payment_instrument_type.should == Braintree::PaymentInstrumentType::UsBankAccount
-            result.transaction.amount.should == BigDecimal(Braintree::Test::TransactionAmounts::Authorize)
-            result.transaction.status.should == Braintree::Transaction::Status::SettlementPending
-            result.transaction.us_bank_account_details.routing_number.should == "011000015"
-            result.transaction.us_bank_account_details.last_4.should == "0000"
-            result.transaction.us_bank_account_details.account_type.should == "checking"
-            result.transaction.us_bank_account_details.account_holder_name.should == "PayPal, Inc."
-            result.transaction.us_bank_account_details.bank_name.should == "FEDERAL RESERVE BANK"
-            result.transaction.us_bank_account_details.ach_mandate.text.should == "cl mandate text"
-            result.transaction.us_bank_account_details.ach_mandate.accepted_at.should be_a Time
-          end
-        end
-
-        context "token" do
-          it "payment_method#create then sale succeeds" do
-            payment_method = Braintree::PaymentMethod.create(
-              :payment_method_nonce => plaid_nonce,
-              :customer_id => Braintree::Customer.create.customer.id,
-              :options => {
-                :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-              }
-            ).payment_method
-
-            payment_method.verifications.count.should == 1
-            payment_method.verifications.first.status.should == Braintree::UsBankAccountVerification::Status::Verified
-            payment_method.verifications.first.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::TokenizedCheck
-            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
-
-            result = Braintree::Transaction.create(
-              :type => "sale",
-              :amount => Braintree::Test::TransactionAmounts::Authorize,
-              :merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-              :payment_method_token => payment_method.token,
-              :options => {
-                :submit_for_settlement => true,
-              }
-            )
-
-            result.success?.should == 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 == "011000015"
-            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 == "PayPal, Inc."
-            transaction.us_bank_account_details.bank_name.should == "FEDERAL RESERVE BANK"
-            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
-          end
-
-          it "transaction#create store_in_vault then sale succeeds" do
-            result = Braintree::Transaction.create(
-              :type => "sale",
-              :amount => Braintree::Test::TransactionAmounts::Authorize,
-              :merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-              :payment_method_nonce => plaid_nonce,
-              :options => {
-                :submit_for_settlement => true,
-                :store_in_vault => true,
-              }
-            )
-
-            result.success?.should == true
-
-            result = Braintree::Transaction.create(
-              :type => "sale",
-              :amount => Braintree::Test::TransactionAmounts::Authorize,
-              :merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-              :payment_method_token => result.transaction.us_bank_account_details.token,
-              :options => {
-                :submit_for_settlement => true,
-              }
-            )
-
-            result.success?.should == 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 == "011000015"
-            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 == "PayPal, Inc."
-            transaction.us_bank_account_details.bank_name.should == "FEDERAL RESERVE BANK"
-            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
-          end
-        end
-      end
-
       context "not plaid-verified" do
         let(:non_plaid_nonce) { generate_non_plaid_us_bank_account_nonce }
         let(:invalid_nonce) { generate_invalid_us_bank_account_nonce }
@@ -140,10 +23,10 @@ describe Braintree::Transaction do
               :payment_method_nonce => non_plaid_nonce,
               :options => {
                 :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
@@ -154,10 +37,10 @@ describe Braintree::Transaction do
               :payment_method_nonce => invalid_nonce,
               :options => {
                 :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
 
@@ -169,16 +52,16 @@ describe Braintree::Transaction do
               :options => {
                 :us_bank_account_verification_method => "independent_check",
                 :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-              }
+              },
             )
             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,10 +70,10 @@ describe Braintree::Transaction do
               :payment_method_token => payment_method.token,
               :options => {
                 :submit_for_settlement => true,
-              }
+              },
             )
 
-            result.success?.should == true
+            expect(result.success?).to eq(true)
           end
 
           it "sale fails for unverified token" do
@@ -199,11 +82,11 @@ describe Braintree::Transaction do
               :customer_id => Braintree::Customer.create.customer.id,
               :options => {
                 :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
-              }
+              },
             ).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",
@@ -212,11 +95,11 @@ describe Braintree::Transaction do
               :payment_method_token => payment_method.token,
               :options => {
                 :submit_for_settlement => true,
-              }
+              },
             )
 
-            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
@@ -229,125 +112,6 @@ describe Braintree::Transaction do
         Braintree::Configuration.private_key = "integration_private_key"
       end
 
-      context "plaid-verified" do
-        let(:plaid_nonce) { generate_valid_plaid_us_bank_account_nonce }
-
-        context "nonce" do
-          it "sale succeeds" do
-            result = Braintree::Transaction.create(
-              :type => "sale",
-              :amount => Braintree::Test::TransactionAmounts::Authorize,
-              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-              :payment_method_nonce => plaid_nonce,
-              :options => {
-                :submit_for_settlement => true,
-              }
-            )
-            result.success?.should == true
-            result.transaction.id.should =~ /^\w{6,}$/
-            result.transaction.type.should == "sale"
-            result.transaction.payment_instrument_type.should == Braintree::PaymentInstrumentType::UsBankAccount
-            result.transaction.amount.should == BigDecimal(Braintree::Test::TransactionAmounts::Authorize)
-            result.transaction.status.should == Braintree::Transaction::Status::SettlementPending
-            result.transaction.us_bank_account_details.routing_number.should == "011000015"
-            result.transaction.us_bank_account_details.last_4.should == "0000"
-            result.transaction.us_bank_account_details.account_type.should == "checking"
-            result.transaction.us_bank_account_details.account_holder_name.should == "PayPal, Inc."
-            result.transaction.us_bank_account_details.bank_name.should == "FEDERAL RESERVE BANK"
-            result.transaction.us_bank_account_details.ach_mandate.text.should == "cl mandate text"
-            result.transaction.us_bank_account_details.ach_mandate.accepted_at.should be_a Time
-          end
-        end
-
-        context "token" do
-          it "payment_method#create then sale succeeds" do
-            result = Braintree::PaymentMethod.create(
-              :payment_method_nonce => plaid_nonce,
-              :customer_id => Braintree::Customer.create.customer.id,
-              :options => {
-                :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-              }
-            )
-
-            payment_method = result.payment_method
-
-            payment_method.verifications.count.should == 1
-            payment_method.verifications.first.status.should == Braintree::UsBankAccountVerification::Status::Verified
-            payment_method.verifications.first.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::TokenizedCheck
-            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
-
-            result = Braintree::Transaction.create(
-              :type => "sale",
-              :amount => Braintree::Test::TransactionAmounts::Authorize,
-              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-              :payment_method_token => payment_method.token,
-              :options => {
-                :submit_for_settlement => true,
-              }
-            )
-
-            result.success?.should == 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 == "011000015"
-            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 == "PayPal, Inc."
-            transaction.us_bank_account_details.bank_name.should == "FEDERAL RESERVE BANK"
-            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
-          end
-
-          it "transaction#create store_in_vault then sale succeeds" do
-            result = Braintree::Transaction.create(
-              :type => "sale",
-              :amount => Braintree::Test::TransactionAmounts::Authorize,
-              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-              :payment_method_nonce => plaid_nonce,
-              :options => {
-                :submit_for_settlement => true,
-                :store_in_vault => true,
-              }
-            )
-
-            result.success?.should == true
-
-            result = Braintree::Transaction.create(
-              :type => "sale",
-              :amount => Braintree::Test::TransactionAmounts::Authorize,
-              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-              :payment_method_token => result.transaction.us_bank_account_details.token,
-              :options => {
-                :submit_for_settlement => true,
-              }
-            )
-
-            result.success?.should == 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 == "011000015"
-            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 == "PayPal, Inc."
-            transaction.us_bank_account_details.bank_name.should == "FEDERAL RESERVE BANK"
-            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
-          end
-        end
-      end
-
       context "not plaid-verified" do
         let(:non_plaid_nonce) { generate_non_plaid_us_bank_account_nonce }
         let(:invalid_nonce) { generate_invalid_us_bank_account_nonce }
@@ -361,23 +125,23 @@ describe Braintree::Transaction do
               :payment_method_nonce => non_plaid_nonce,
               :options => {
                 :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
@@ -388,10 +152,10 @@ describe Braintree::Transaction do
               :payment_method_nonce => invalid_nonce,
               :options => {
                 :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
 
@@ -402,16 +166,16 @@ describe Braintree::Transaction do
               :customer_id => Braintree::Customer.create.customer.id,
               :options => {
                 :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-              }
+              },
             )
             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",
@@ -420,10 +184,10 @@ describe Braintree::Transaction do
               :payment_method_token => payment_method.token,
               :options => {
                 :submit_for_settlement => true,
-              }
+              },
             )
 
-            result.success?.should == true
+            expect(result.success?).to eq(true)
           end
         end
       end

data/spec/integration/braintree/us_bank_account_spec.rb

@@ -12,19 +12,19 @@ describe Braintree::UsBankAccount do
         :customer_id => customer.id,
         :options => {
           :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
@@ -44,27 +44,27 @@ describe Braintree::UsBankAccount do
         :customer_id => customer.id,
         :options => {
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-        }
+        },
       )
-      result.should be_success
+      expect(result).to be_success
 
       result = Braintree::UsBankAccount.sale(
         result.payment_method.token,
         :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-        :amount => "100.00"
+        :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
 
@@ -78,26 +78,26 @@ describe Braintree::UsBankAccount do
         :customer_id => customer.id,
         :options => {
           :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-        }
+        },
       )
-      result.should be_success
+      expect(result).to be_success
 
       transaction = Braintree::UsBankAccount.sale!(
         result.payment_method.token,
         :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-        :amount => "100.00"
+        :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
@@ -105,7 +105,7 @@ describe Braintree::UsBankAccount do
         Braintree::UsBankAccount.sale!(
           generate_invalid_us_bank_account_nonce,
           :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
-          :amount => "100.00"
+          :amount => "100.00",
         )
       end.to raise_error(Braintree::ValidationsFailed)
     end