braintree 2.74.0 → 4.12.0

data/spec/integration/braintree/transaction_us_bank_account_spec.rb

@@ -0,0 +1,438 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::Transaction do
+  describe "self.create us bank account" do
+    context "compliant merchant" do
+      before do
+        Braintree::Configuration.merchant_id = "integration2_merchant_id"
+        Braintree::Configuration.public_key = "integration2_public_key"
+        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
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "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
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "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
+
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "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 }
+
+        context "nonce" do
+          it "sale fails for valid nonce" do
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              :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
+          end
+
+          it "sale fails for invalid nonce" do
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              :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
+          end
+        end
+
+        context "token" do
+          it "sale succeeds for verified token" do
+            result = Braintree::PaymentMethod.create(
+              :payment_method_nonce => non_plaid_nonce,
+              :customer_id => Braintree::Customer.create.customer.id,
+              :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
+            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
+
+            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
+          end
+
+          it "sale fails for unverified token" do
+            payment_method = Braintree::PaymentMethod.create(
+              :payment_method_nonce => non_plaid_nonce,
+              :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
+
+            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 == false
+            result.errors.for(:transaction)[0].code.should == Braintree::ErrorCodes::Transaction::UsBankAccountNotVerified
+          end
+        end
+      end
+    end
+
+    context "exempt merchant" do
+      before do
+        Braintree::Configuration.merchant_id = "integration_merchant_id"
+        Braintree::Configuration.public_key = "integration_public_key"
+        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
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "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
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "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
+
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "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 }
+
+        context "nonce" do
+          it "sale succeeds for valid nonce" do
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+              :payment_method_nonce => non_plaid_nonce,
+              :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 == "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
+          end
+
+          it "sale fails for invalid nonce" do
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+              :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
+          end
+        end
+
+        context "token" do
+          it "sale succeeds for unverified token" do
+            result = Braintree::PaymentMethod.create(
+              :payment_method_nonce => non_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 == 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
+
+            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
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/braintree/us_bank_account_spec.rb

@@ -5,20 +5,23 @@ describe Braintree::UsBankAccount do
   describe "self.find" do
     it "returns a UsBankAccount" do
       customer = Braintree::Customer.create!
-      nonce = generate_valid_us_bank_account_nonce
+      nonce = generate_non_plaid_us_bank_account_nonce
 
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        },
       )
       result.should 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 == "1234"
+      us_bank_account.last_4.should == "0000"
       us_bank_account.account_type.should == "checking"
-      us_bank_account.account_holder_name.should == "Dan Schulman"
+      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
@@ -34,24 +37,31 @@ describe Braintree::UsBankAccount do
   context "self.sale" do
     it "creates a transaction using a us bank account and returns a result object" do
       customer = Braintree::Customer.create!
-      nonce = generate_valid_us_bank_account_nonce
+      nonce = generate_non_plaid_us_bank_account_nonce
 
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        },
       )
       result.should be_success
 
-      result = Braintree::UsBankAccount.sale(result.payment_method.token, :merchant_account_id => "us_bank_merchant_account", :amount => "100.00")
+      result = Braintree::UsBankAccount.sale(
+        result.payment_method.token,
+        :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        :amount => "100.00",
+      )
 
       result.success?.should == true
-      result.transaction.amount.should == BigDecimal.new("100.00")
+      result.transaction.amount.should == BigDecimal("100.00")
       result.transaction.type.should == "sale"
       us_bank_account = result.transaction.us_bank_account_details
       us_bank_account.routing_number.should == "021000021"
-      us_bank_account.last_4.should == "1234"
+      us_bank_account.last_4.should == "0000"
       us_bank_account.account_type.should == "checking"
-      us_bank_account.account_holder_name.should == "Dan Schulman"
+      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
@@ -61,23 +71,30 @@ describe Braintree::UsBankAccount do
   context "self.sale!" do
     it "creates a transaction using a us bank account and returns a result object" do
       customer = Braintree::Customer.create!
-      nonce = generate_valid_us_bank_account_nonce
+      nonce = generate_non_plaid_us_bank_account_nonce
 
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        },
       )
       result.should be_success
 
-      transaction = Braintree::UsBankAccount.sale!(result.payment_method.token, :merchant_account_id => "us_bank_merchant_account", :amount => "100.00")
+      transaction = Braintree::UsBankAccount.sale!(
+        result.payment_method.token,
+        :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        :amount => "100.00",
+      )
 
-      transaction.amount.should == BigDecimal.new("100.00")
+      transaction.amount.should == BigDecimal("100.00")
       transaction.type.should == "sale"
       us_bank_account = transaction.us_bank_account_details
       us_bank_account.routing_number.should == "021000021"
-      us_bank_account.last_4.should == "1234"
+      us_bank_account.last_4.should == "0000"
       us_bank_account.account_type.should == "checking"
-      us_bank_account.account_holder_name.should == "Dan Schulman"
+      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
@@ -85,7 +102,11 @@ describe Braintree::UsBankAccount do
 
     it "does not creates a transaction using a us bank account and returns raises an exception" do
       expect do
-        Braintree::UsBankAccount.sale!(generate_invalid_us_bank_account_nonce, :merchant_account_id => "us_bank_merchant_account", :amount => "100.00")
+        Braintree::UsBankAccount.sale!(
+          generate_invalid_us_bank_account_nonce,
+          :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+          :amount => "100.00",
+        )
       end.to raise_error(Braintree::ValidationsFailed)
     end
   end