braintree 2.84.0 → 2.85.0

data/spec/integration/braintree/transaction_search_spec.rb

@@ -776,62 +776,74 @@ describe Braintree::Transaction, "search" do
       end
 
       context "dispute_date" do
-        it "searches on dispute_date in UTC" do
-          disputed_time = Time.parse("2014-03-01 00:00:00 UTC")
-          transaction_id = "2disputetransaction"
+        before(:all) do
+          @disputed_transaction = Braintree::Transaction.sale!(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Disputes::Chargeback,
+              :expiration_date => "03/18"
+            }
+          )
+
+          @disputed_date = @disputed_transaction.disputes.first.received_date
+          @disputed_time = @disputed_date.to_time
 
+          Timeout::timeout(60) {
+            dispute_date_indexed = false
+            until dispute_date_indexed
+              sleep 1
+              collection = Braintree::Transaction.search do |search|
+                search.id.is @disputed_transaction.id
+                search.dispute_date.is @disputed_date
+              end
+
+              dispute_date_indexed = collection.maximum_size == 1
+            end
+          }
+        end
+
+        it "searches on dispute_date in UTC" do
           collection = Braintree::Transaction.search do |search|
-            search.id.is transaction_id
+            search.id.is @disputed_transaction.id
             search.dispute_date.between(
-              disputed_time - 60,
-              disputed_time + 60
+              @disputed_time - 60,
+              @disputed_time + 60
             )
           end
 
           collection.maximum_size.should == 1
-          collection.first.id.should == transaction_id
+          collection.first.id.should == @disputed_transaction.id
 
           collection = Braintree::Transaction.search do |search|
-            search.id.is transaction_id
-            search.dispute_date >= disputed_time - 1
+            search.id.is @disputed_transaction.id
+            search.dispute_date >= @disputed_time - 1
           end
 
           collection.maximum_size.should == 1
-          collection.first.id.should == transaction_id
+          collection.first.id.should == @disputed_transaction.id
 
           collection = Braintree::Transaction.search do |search|
-            search.id.is transaction_id
-            search.dispute_date <= disputed_time + 1
+            search.id.is @disputed_transaction.id
+            search.dispute_date <= @disputed_time + 1
           end
 
           collection.maximum_size.should == 1
-          collection.first.id.should == transaction_id
+          collection.first.id.should == @disputed_transaction.id
 
           collection = Braintree::Transaction.search do |search|
-            search.id.is transaction_id
-            search.disbursement_date.between(
-              disputed_time - 300,
-              disputed_time - 100
-            )
-          end
-
-          collection.maximum_size.should == 0
-
-          collection = Braintree::Transaction.search do |search|
-            search.id.is transaction_id
-            search.dispute_date.is disputed_time
+            search.id.is @disputed_transaction.id
+            search.dispute_date.is @disputed_time
           end
 
           collection.maximum_size.should == 1
-          collection.first.id.should == transaction_id
+          collection.first.id.should == @disputed_transaction.id
         end
 
         it "searches on dispute_date in local time" do
-          now = Time.parse("2014-03-01 18:00:00 CST")
-          transaction_id = "2disputetransaction"
+          now = @disputed_time.localtime("-06:00")
 
           collection = Braintree::Transaction.search do |search|
-            search.id.is transaction_id
+            search.id.is @disputed_transaction.id
             search.dispute_date.between(
               now - 60,
               now + 60
@@ -839,49 +851,35 @@ describe Braintree::Transaction, "search" do
           end
 
           collection.maximum_size.should == 1
-          collection.first.id.should == transaction_id
+          collection.first.id.should == @disputed_transaction.id
 
           collection = Braintree::Transaction.search do |search|
-            search.id.is transaction_id
+            search.id.is @disputed_transaction.id
             search.dispute_date >= now - 60
           end
 
           collection.maximum_size.should == 1
-          collection.first.id.should == transaction_id
+          collection.first.id.should == @disputed_transaction.id
 
           collection = Braintree::Transaction.search do |search|
-            search.id.is transaction_id
+            search.id.is @disputed_transaction.id
             search.dispute_date <= now + 60
           end
 
           collection.maximum_size.should == 1
-          collection.first.id.should == transaction_id
-
-          collection = Braintree::Transaction.search do |search|
-            search.id.is transaction_id
-            search.dispute_date.between(
-              now + 100,
-              now + 300
-            )
-          end
-
-          collection.maximum_size.should == 0
         end
 
         it "searches on dispute_date with date ranges" do
-          disputed_date = Date.new(2014, 3, 1)
-          transaction_id = "disputedtransaction"
-
           collection = Braintree::Transaction.search do |search|
-            search.id.is transaction_id
+            search.id.is @disputed_transaction.id
             search.dispute_date.between(
-              disputed_date - 1,
-              disputed_date + 1
+              @disputed_date - 1,
+              @disputed_date + 1
             )
           end
 
           collection.maximum_size.should == 1
-          collection.first.id.should == transaction_id
+          collection.first.id.should == @disputed_transaction.id
         end
       end
 

data/spec/integration/braintree/transaction_spec.rb

@@ -1281,7 +1281,7 @@ describe Braintree::Transaction do
           }
         )
         result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == true
+        result.transaction.credit_card_details.venmo_sdk?.should == false
       end
     end
 
@@ -2117,96 +2117,6 @@ describe Braintree::Transaction do
       end
     end
 
-    context "us bank account nonce" do
-      let!(:valid_nonce) { generate_valid_us_bank_account_nonce }
-      let!(:invalid_nonce) { generate_invalid_us_bank_account_nonce }
-      it "returns a successful result for tansacting on a us bank account nonce" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => "us_bank_merchant_account",
-          :payment_method_nonce => valid_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.new(Braintree::Test::TransactionAmounts::Authorize)
-        result.transaction.status.should == Braintree::Transaction::Status::SettlementPending
-        result.transaction.us_bank_account_details.routing_number.should == "021000021"
-        result.transaction.us_bank_account_details.last_4.should == "1234"
-        result.transaction.us_bank_account_details.account_type.should == "checking"
-        result.transaction.us_bank_account_details.account_holder_name.should == "Dan Schulman"
-        result.transaction.us_bank_account_details.bank_name.should =~ /CHASE/
-        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
-
-      it "return successful result for vaulting and transacting on vaulted token" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => "us_bank_merchant_account",
-          :payment_method_nonce => valid_nonce,
-          :options => {
-            :submit_for_settlement => true,
-            :store_in_vault => true,
-          }
-        )
-        result.success?.should == true
-        result.transaction.id.should =~ /^\w{6,}$/
-        result.transaction.type.should == "sale"
-        result.transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
-        result.transaction.status.should == Braintree::Transaction::Status::SettlementPending
-        result.transaction.us_bank_account_details.routing_number.should == "021000021"
-        result.transaction.us_bank_account_details.last_4.should == "1234"
-        result.transaction.us_bank_account_details.account_type.should == "checking"
-        result.transaction.us_bank_account_details.account_holder_name.should == "Dan Schulman"
-        result.transaction.us_bank_account_details.bank_name.should =~ /CHASE/
-        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
-
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => "us_bank_merchant_account",
-          :payment_method_token=> result.transaction.us_bank_account_details.token,
-          :options => {
-            :submit_for_settlement => true,
-          }
-        )
-        result.success?.should == true
-        result.transaction.id.should =~ /^\w{6,}$/
-        result.transaction.type.should == "sale"
-        result.transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
-        result.transaction.status.should == Braintree::Transaction::Status::SettlementPending
-        result.transaction.us_bank_account_details.routing_number.should == "021000021"
-        result.transaction.us_bank_account_details.last_4.should == "1234"
-        result.transaction.us_bank_account_details.account_type.should == "checking"
-        result.transaction.us_bank_account_details.account_holder_name.should == "Dan Schulman"
-        result.transaction.us_bank_account_details.bank_name.should =~ /CHASE/
-        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
-
-      it "returns failure for token that doesn't exist" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => "us_bank_merchant_account",
-          :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 "ideal payment nonce" do
       it "returns a successful result for tansacting on an ideal payment nonce" do
         valid_ideal_payment_id = generate_valid_ideal_payment_nonce
@@ -5809,7 +5719,7 @@ describe Braintree::Transaction do
           :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK.generate_test_payment_method_code(Braintree::Test::CreditCardNumbers::Visa)
         )
         result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == true
+        result.transaction.credit_card_details.venmo_sdk?.should == false
       end
 
       it "errors when an invalid payment method code is passed" do
@@ -5836,7 +5746,7 @@ describe Braintree::Transaction do
           }
         )
         result.success?.should == true
-        result.transaction.credit_card_details.venmo_sdk?.should == true
+        result.transaction.credit_card_details.venmo_sdk?.should == false
       end
 
       it "venmo_sdk boolean is false when an invalid session is passed" do

data/spec/integration/braintree/transaction_us_bank_account_spec.rb

@@ -0,0 +1,432 @@
+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
+          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.new(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.new(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.new(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
+          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.new(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.new(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.new(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.new(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