braintree 2.10.0 → 4.26.0

data/spec/integration/braintree/transaction_search_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::Transaction, "search" do
   context "advanced" do
@@ -7,13 +8,14 @@ describe Braintree::Transaction, "search" do
         search.billing_first_name.is "thisnameisnotreal"
       end
 
-      collection.maximum_size.should == 0
+      expect(collection.maximum_size).to eq(0)
     end
 
-    it "can search on text fields" do
-      first_name = "Tim#{rand(10000)}"
-      token = "creditcard#{rand(10000)}"
-      customer_id = "customer#{rand(10000)}"
+    #Disabling test until we have more stable CI
+    xit "can search on text fields" do
+      first_name = "Tim_#{rand(10**10)}"
+      token = "creditcard_#{rand(10**10)}"
+      customer_id = "customer_#{rand(10**10)}"
 
       transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -59,11 +61,12 @@ describe Braintree::Transaction, "search" do
           :postal_code => "54321",
           :region => "MA",
           :street_address => "456 Road"
-        }
+        },
       )
 
       SpecHelper.settle_transaction transaction.id
       transaction = Braintree::Transaction.find(transaction.id)
+      credit_card = Braintree::CreditCard.find(token)
 
       search_criteria = {
         :billing_company => "Braintree",
@@ -78,6 +81,7 @@ describe Braintree::Transaction, "search" do
         :credit_card_cardholder_name => "Tom Smith",
         :credit_card_expiration_date => "05/2012",
         :credit_card_number => Braintree::Test::CreditCardNumbers::Visa,
+        :credit_card_unique_identifier => credit_card.unique_number_identifier,
         :customer_company => "Braintree",
         :customer_email => "smith@example.com",
         :customer_fax => "5551231234",
@@ -106,14 +110,14 @@ describe Braintree::Transaction, "search" do
           search.id.is transaction.id
           search.send(criterion).is value
         end
-        collection.maximum_size.should == 1
-        collection.first.id.should == transaction.id
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(transaction.id)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.send(criterion).is("invalid_attribute")
         end
-        collection.should be_empty
+        expect(collection).to be_empty
       end
 
       collection = Braintree::Transaction.search do |search|
@@ -123,8 +127,76 @@ describe Braintree::Transaction, "search" do
         end
       end
 
-      collection.maximum_size.should == 1
-      collection.first.id.should == transaction.id
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(transaction.id)
+    end
+
+    #Disabling test until we have more stable CI
+    xit "searches on users" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
+      )
+
+      collection = Braintree::Transaction.search do |search|
+        search.user.is "integration_user_public_id"
+      end
+
+      expect(collection.any? { |t| t.id == transaction.id }).to eq(true)
+    end
+
+    it "searches on paypal transactions" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
+      )
+
+      paypal_details = transaction.paypal_details
+
+      collection = Braintree::Transaction.search do |search|
+        search.paypal_payment_id.is paypal_details.payment_id
+        search.paypal_authorization_id.is paypal_details.authorization_id
+        search.paypal_payer_email.is paypal_details.payer_email
+      end
+
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(transaction.id)
+    end
+
+    it "searches on store_id" do
+      transaction_id = "contact_visa_transaction"
+      store_id = "store-id"
+
+      collection = Braintree::Transaction.search do |search|
+        search.id.is transaction_id
+        search.store_ids.in store_id
+      end
+
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(transaction_id)
+    end
+
+    it "searches on reason_code" do
+      transaction_id = "ach_txn_ret1"
+      reason_code = "R01"
+
+      collection = Braintree::Transaction.search do |search|
+        search.reason_code.in reason_code
+      end
+
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(transaction_id)
+      expect(collection.first.ach_return_responses.first[:reason_code]).to eq("R01")
+    end
+
+    it "searches on reason_codes" do
+      reason_code = "any_reason_code"
+
+      collection = Braintree::Transaction.search do |search|
+        search.reason_code.is reason_code
+      end
+
+      expect(collection.maximum_size).to eq(2)
     end
 
     context "multiple value fields" do
@@ -134,7 +206,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
-        }
+        },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -142,21 +214,21 @@ describe Braintree::Transaction, "search" do
           search.created_using.is Braintree::Transaction::CreatedUsing::FullInformation
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.created_using.in Braintree::Transaction::CreatedUsing::FullInformation, Braintree::Transaction::CreatedUsing::Token
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.created_using.is Braintree::Transaction::CreatedUsing::Token
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
       end
 
       it "searches on credit_card_customer_location" do
@@ -165,7 +237,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
-        }
+        },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -173,21 +245,21 @@ describe Braintree::Transaction, "search" do
           search.credit_card_customer_location.is Braintree::CreditCard::CustomerLocation::US
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.credit_card_customer_location.in Braintree::CreditCard::CustomerLocation::US, Braintree::CreditCard::CustomerLocation::International
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.credit_card_customer_location.is Braintree::CreditCard::CustomerLocation::International
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
       end
 
       it "searches on merchant_account_id" do
@@ -196,7 +268,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
-        }
+        },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -204,21 +276,21 @@ describe Braintree::Transaction, "search" do
           search.merchant_account_id.is transaction.merchant_account_id
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.merchant_account_id.in transaction.merchant_account_id, "bogus_merchant_account_id"
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.merchant_account_id.is "bogus_merchant_account_id"
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
       end
 
       it "searches on credit_card_card_type" do
@@ -227,7 +299,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
-        }
+        },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -235,28 +307,142 @@ describe Braintree::Transaction, "search" do
           search.credit_card_card_type.is Braintree::CreditCard::CardType::Visa
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.credit_card_card_type.is transaction.credit_card_details.card_type
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.credit_card_card_type.in Braintree::CreditCard::CardType::Visa, Braintree::CreditCard::CardType::MasterCard
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.credit_card_card_type.is Braintree::CreditCard::CardType::MasterCard
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
+      end
+
+      it "searches for an Elo card" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::AdyenMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Elo,
+            :cvv => "737",
+            :expiration_date => "10/2020"
+          },
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.credit_card_card_type.is Braintree::CreditCard::CardType::Elo
+        end
+
+        expect(collection.maximum_size).to eq(1)
+      end
+
+      it "searches by payment instrument type CreditCardDetail" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/12"
+          },
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.payment_instrument_type.in ["CreditCardDetail"]
+        end
+
+        expect(collection.first.id).to eq(transaction.id)
+        expect(collection.first.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
+
+      it "searches by payment instrument type PayPal" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.payment_instrument_type.in ["PayPalDetail"]
+        end
+
+        expect(collection.first.id).to eq(transaction.id)
+        expect(collection.first.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::PayPalAccount)
+      end
+
+      it "searches by payment instrument type LocalPaymentDetail" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::LocalPayment,
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.payment_instrument_type.in ["LocalPaymentDetail"]
+        end
+
+        expect(collection.first.id).to eq(transaction.id)
+        expect(collection.first.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::LocalPayment)
+      end
+
+      it "searches by payment instrument type SepaDebitAccountDetail" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::SepaDirectDebit,
+          :options => {:submit_for_settlement => true},
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.payment_instrument_type.in ["SEPADebitAccountDetail"]
+        end
+
+        expect(collection.first.id).to eq(transaction.id)
+        expect(collection.first.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::SepaDirectDebitAccount)
+      end
+
+      it "searches by paypal_v2_order_id" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::SepaDirectDebit,
+          :options => {:submit_for_settlement => true},
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.sepa_debit_paypal_v2_order_id.is transaction.sepa_direct_debit_account_details.paypal_v2_order_id
+        end
+
+        expect(collection.first.id).to eq(transaction.id)
+        expect(collection.first.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::SepaDirectDebitAccount)
+      end
+
+      it "searches by payment instrument type ApplePay" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.payment_instrument_type.in ["ApplePayDetail"]
+        end
+
+        expect(collection.first.id).to eq(transaction.id)
+        expect(collection.first.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::ApplePayCard)
       end
 
       it "searches on status" do
@@ -265,7 +451,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -273,21 +459,32 @@ describe Braintree::Transaction, "search" do
           search.status.is Braintree::Transaction::Status::Authorized
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.status.in Braintree::Transaction::Status::Authorized, Braintree::Transaction::Status::ProcessorDeclined
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.status.is Braintree::Transaction::Status::ProcessorDeclined
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
+      end
+
+      it "searches for settlement_confirmed transaction" do
+        transaction_id = "settlement_confirmed_txn"
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction_id
+        end
+
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(transaction_id)
       end
 
       it "finds expired authorizations by status" do
@@ -295,8 +492,8 @@ describe Braintree::Transaction, "search" do
           search.status.in Braintree::Transaction::Status::AuthorizationExpired
         end
 
-        collection.maximum_size.should > 0
-        collection.first.status.should == Braintree::Transaction::Status::AuthorizationExpired
+        expect(collection.maximum_size).to be > 0
+        expect(collection.first.status).to eq(Braintree::Transaction::Status::AuthorizationExpired)
       end
 
       it "searches on source" do
@@ -305,7 +502,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -313,21 +510,21 @@ describe Braintree::Transaction, "search" do
           search.source.is Braintree::Transaction::Source::Api
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.source.in Braintree::Transaction::Source::Api, Braintree::Transaction::Source::ControlPanel
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is transaction.id
           search.source.is Braintree::Transaction::Source::ControlPanel
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
       end
 
       it "searches on type" do
@@ -338,7 +535,7 @@ describe Braintree::Transaction, "search" do
           :cardholder_name => cardholder_name,
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
-        }
+        },
         )
 
         transaction = Braintree::Transaction.sale!(
@@ -348,18 +545,18 @@ describe Braintree::Transaction, "search" do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
         },
-        :options => { :submit_for_settlement => true }
+        :options => {:submit_for_settlement => true},
         )
         SpecHelper.settle_transaction transaction.id
 
-        refund_transaction = transaction.refund.new_transaction
+        refund_transaction = Braintree::Transaction.refund(transaction.id).transaction
 
         collection = Braintree::Transaction.search do |search|
           search.credit_card_cardholder_name.is cardholder_name
           search.type.is Braintree::Transaction::Type::Credit
         end
 
-        collection.maximum_size.should == 2
+        expect(collection.maximum_size).to eq(2)
 
         collection = Braintree::Transaction.search do |search|
           search.credit_card_cardholder_name.is cardholder_name
@@ -367,8 +564,8 @@ describe Braintree::Transaction, "search" do
           search.refund.is true
         end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == refund_transaction.id
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(refund_transaction.id)
 
         collection = Braintree::Transaction.search do |search|
           search.credit_card_cardholder_name.is cardholder_name
@@ -376,8 +573,88 @@ describe Braintree::Transaction, "search" do
           search.refund.is false
         end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == credit_transaction.id
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(credit_transaction.id)
+      end
+
+      it "searches on store_ids" do
+        transaction_id = "contact_visa_transaction"
+        store_ids = ["store-id"]
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction_id
+          search.store_ids.in store_ids
+        end
+
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(transaction_id)
+      end
+
+      it "searches on reason_codes for 2 items" do
+        reason_code = ["R01", "R02"]
+
+        collection = Braintree::Transaction.search do |search|
+          search.reason_code.in reason_code
+        end
+
+        expect(collection.maximum_size).to eq(2)
+      end
+
+      it "searches on a reason_code" do
+        reason_code = ["R01"]
+        transaction_id = "ach_txn_ret1"
+
+        collection = Braintree::Transaction.search do |search|
+          search.reason_code.in reason_code
+        end
+
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(transaction_id)
+      end
+
+      xit "searches on debit_network" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::PinlessDebitMerchantAccountId,
+          :currency_iso_code => "USD",
+          :payment_method_nonce => Braintree::Test::Nonce::TransactablePinlessDebitVisa,
+          :options => {
+            :submit_for_settlement => true
+          },
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.credit_card_card_type.is Braintree::CreditCard::CardType::Visa
+        end
+
+        expect(collection.maximum_size).to be > 0
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.debit_network.in Braintree::CreditCard::DebitNetwork::All
+        end
+
+        expect(collection.maximum_size).to be > 0
+      end
+    end
+
+    context "invalid search" do
+      it "raises an exception on invalid transaction type" do
+        expect do
+          Braintree::Transaction.search do |search|
+            search.customer_id.is "9171566"
+            search.type.is "settled"
+          end
+        end.to raise_error(ArgumentError)
+      end
+
+      it "raises an exception on invalid debit network" do
+        expect do
+          Braintree::Transaction.search do |search|
+            search.debit_network.is "invalid_network"
+          end
+        end.to raise_error(ArgumentError)
       end
     end
 
@@ -389,7 +666,7 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
           )
 
           collection = Braintree::Transaction.search do |search|
@@ -397,48 +674,48 @@ describe Braintree::Transaction, "search" do
             search.amount.between "500.00", "1500.00"
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.amount >= "500.00"
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.amount <= "1500.00"
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.amount.between "500.00", "900.00"
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
         end
 
         it "can also take BigDecimal for amount" do
           transaction = Braintree::Transaction.sale!(
-            :amount => BigDecimal.new("1000.00"),
+            :amount => BigDecimal("1000.00"),
             :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
           )
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
-            search.amount <= BigDecimal.new("1000.00")
+            search.amount <= BigDecimal("1000.00")
           end
 
-          collection.maximum_size.should == 1
+          expect(collection.maximum_size).to eq(1)
         end
       end
 
@@ -449,56 +726,56 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/12"
-            }
+            },
           )
 
           created_at = transaction.created_at
-          created_at.should be_utc
+          expect(created_at).to be_utc
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.created_at.between(
               created_at - 60,
-              created_at + 60
+              created_at + 60,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.created_at >= created_at - 1
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.created_at <= created_at + 1
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.created_at.between(
               created_at - 300,
-              created_at - 100
+              created_at - 100,
             )
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.created_at.is created_at
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
         end
 
         it "searches on created_at in local time" do
@@ -507,7 +784,7 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
           )
 
           now = Time.now
@@ -516,38 +793,38 @@ describe Braintree::Transaction, "search" do
             search.id.is transaction.id
             search.created_at.between(
               now - 60,
-              now + 60
+              now + 60,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.created_at >= now - 60
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.created_at <= now + 60
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.created_at.between(
               now - 300,
-              now - 100
+              now - 100,
             )
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
         end
 
         it "searches on created_at with dates" do
@@ -556,19 +833,255 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/12"
-            }
+            },
           )
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.created_at.between(
               Date.today - 1,
-              Date.today + 1
+              Date.today + 1,
+            )
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
+        end
+      end
+
+      context "ach return response created at" do
+        it "it finds records within date range of the custom field" do
+          date_search = Braintree::Transaction.search do |search|
+            search.ach_return_responses_created_at.between(DateTime.now - 1.0, DateTime.now + 1.0)
+          end
+
+          expect(date_search.maximum_size).to eq(2)
+        end
+
+        it "it does not find records not within date range of the custom field" do
+          neg_date_search = Braintree::Transaction.search do |search|
+           search.ach_return_responses_created_at.between(DateTime.now + 1.0, DateTime.now - 1.0)
+          end
+
+          expect(neg_date_search.maximum_size).to eq(0)
+        end
+      end
+
+      context "disbursement_date" do
+        it "searches on disbursement_date in UTC, as a date" do
+          disbursement_time = Date.parse("2013-04-10")
+          transaction_id = "deposittransaction"
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction_id
+            search.disbursement_date.between(
+              disbursement_time - 60,
+              disbursement_time + 60,
+            )
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction_id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction_id
+            search.disbursement_date >= disbursement_time - 1
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction_id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction_id
+            search.disbursement_date <= disbursement_time + 1
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction_id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction_id
+            search.disbursement_date.between(
+              disbursement_time - 300,
+              disbursement_time - 100,
+            )
+          end
+
+          expect(collection.maximum_size).to eq(0)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction_id
+            search.disbursement_date.is disbursement_time
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction_id)
+        end
+
+        it "searches on disbursement_date in local time" do
+          now = Time.parse("2013-04-09 18:00:00 CST")
+          transaction_id = "deposittransaction"
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction_id
+            search.disbursement_date.between(
+              now - 60,
+              now + 60,
+            )
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction_id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction_id
+            search.disbursement_date >= now - 60
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction_id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction_id
+            search.disbursement_date <= now + 60
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction_id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction_id
+            search.disbursement_date.between(
+              now - 300,
+              now - 100,
+            )
+          end
+
+          expect(collection.maximum_size).to eq(0)
+        end
+
+        it "searches on disbursement_date with date ranges" do
+          disbursement_date = Date.new(2013, 4, 10)
+          transaction_id = "deposittransaction"
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction_id
+            search.disbursement_date.between(
+              disbursement_date - 1,
+              disbursement_date + 1,
+            )
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction_id)
+        end
+      end
+
+      context "dispute_date" do
+        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
+
+        xit "searches on dispute_date in UTC" do
+          collection = Braintree::Transaction.search do |search|
+            search.id.is @disputed_transaction.id
+            search.dispute_date.between(
+              @disputed_time - 60,
+              @disputed_time + 60,
+            )
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(@disputed_transaction.id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is @disputed_transaction.id
+            search.dispute_date >= @disputed_time - 1
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(@disputed_transaction.id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is @disputed_transaction.id
+            search.dispute_date <= @disputed_time + 1
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(@disputed_transaction.id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is @disputed_transaction.id
+            search.dispute_date.is @disputed_time
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(@disputed_transaction.id)
+        end
+
+        xit "searches on dispute_date in local time" do
+          now = @disputed_time.localtime("-06:00")
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is @disputed_transaction.id
+            search.dispute_date.between(
+              now - 60,
+              now + 60,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(@disputed_transaction.id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is @disputed_transaction.id
+            search.dispute_date >= now - 60
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(@disputed_transaction.id)
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is @disputed_transaction.id
+            search.dispute_date <= now + 60
+          end
+
+          expect(collection.maximum_size).to eq(1)
+        end
+
+        xit "searches on dispute_date with date ranges" do
+          collection = Braintree::Transaction.search do |search|
+            search.id.is @disputed_transaction.id
+            search.dispute_date.between(
+              @disputed_date - 1,
+              @disputed_date + 1,
+            )
+          end
+
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(@disputed_transaction.id)
         end
       end
 
@@ -579,29 +1092,29 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/12"
-            }
+            },
           )
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.authorized_at.between(
               Date.today - 2,
-              Date.today - 1
+              Date.today - 1,
             )
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.authorized_at.between(
               Date.today - 1,
-              Date.today + 1
+              Date.today + 1,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
         end
 
         it "finds transactions failed in a given range" do
@@ -610,50 +1123,50 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/12"
-            }
+            },
           ).transaction
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.failed_at.between(
               Date.today - 2,
-              Date.today - 1
+              Date.today - 1,
             )
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.failed_at.between(
               Date.today - 1,
-              Date.today + 1
+              Date.today + 1,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
         end
 
         it "finds expired authorizations in a given range" do
           collection = Braintree::Transaction.search do |search|
             search.authorization_expired_at.between(
               Date.today - 2,
-              Date.today - 1
+              Date.today - 1,
             )
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
 
           collection = Braintree::Transaction.search do |search|
             search.authorization_expired_at.between(
               Date.today - 1,
-              Date.today + 1
+              Date.today + 1,
             )
           end
 
-          collection.maximum_size.should > 0
-          collection.first.status.should == Braintree::Transaction::Status::AuthorizationExpired
+          expect(collection.maximum_size).to be > 0
+          expect(collection.first.status).to eq(Braintree::Transaction::Status::AuthorizationExpired)
         end
 
         it "finds transactions gateway_rejected in a given range" do
@@ -672,29 +1185,29 @@ describe Braintree::Transaction, "search" do
                 :number => Braintree::Test::CreditCardNumbers::Visa,
                 :expiration_date => "05/12",
                 :cvv => "200"
-              }
+              },
             ).transaction
 
             collection = Braintree::Transaction.search do |search|
               search.id.is transaction.id
               search.gateway_rejected_at.between(
                 Date.today - 2,
-                Date.today - 1
+                Date.today - 1,
               )
             end
 
-            collection.maximum_size.should == 0
+            expect(collection.maximum_size).to eq(0)
 
             collection = Braintree::Transaction.search do |search|
               search.id.is transaction.id
               search.gateway_rejected_at.between(
                 Date.today - 1,
-                Date.today + 1
+                Date.today + 1,
               )
             end
 
-            collection.maximum_size.should == 1
-            collection.first.id.should == transaction.id
+            expect(collection.maximum_size).to eq(1)
+            expect(collection.first.id).to eq(transaction.id)
           ensure
             Braintree::Configuration.merchant_id = old_merchant
             Braintree::Configuration.public_key = old_public_key
@@ -708,29 +1221,29 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/12"
-            }
+            },
           ).transaction
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.processor_declined_at.between(
               Date.today - 2,
-              Date.today - 1
+              Date.today - 1,
             )
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.processor_declined_at.between(
               Date.today - 1,
-              Date.today + 1
+              Date.today + 1,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
         end
 
         it "finds transactions settled in a given range" do
@@ -742,7 +1255,7 @@ describe Braintree::Transaction, "search" do
             },
             :options => {
               :submit_for_settlement => true
-            }
+            },
           ).transaction
 
           SpecHelper.settle_transaction transaction.id
@@ -751,22 +1264,22 @@ describe Braintree::Transaction, "search" do
             search.id.is transaction.id
             search.settled_at.between(
               Date.today - 2,
-              Date.today - 1
+              Date.today - 1,
             )
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.settled_at.between(
               Date.today - 1,
-              Date.today + 1
+              Date.today + 1,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
         end
 
         it "finds transactions submitted for settlement in a given range" do
@@ -778,29 +1291,29 @@ describe Braintree::Transaction, "search" do
             },
             :options => {
               :submit_for_settlement => true
-            }
+            },
           ).transaction
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.submitted_for_settlement_at.between(
               Date.today - 2,
-              Date.today - 1
+              Date.today - 1,
             )
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.submitted_for_settlement_at.between(
               Date.today - 1,
-              Date.today + 1
+              Date.today + 1,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
         end
 
         it "finds transactions voided in a given range" do
@@ -809,7 +1322,7 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/12"
-            }
+            },
           )
           transaction = Braintree::Transaction.void(transaction.id).transaction
 
@@ -817,22 +1330,22 @@ describe Braintree::Transaction, "search" do
             search.id.is transaction.id
             search.voided_at.between(
               Date.today - 2,
-              Date.today - 1
+              Date.today - 1,
             )
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.voided_at.between(
               Date.today - 1,
-              Date.today + 1
+              Date.today + 1,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(transaction.id)
         end
       end
 
@@ -845,31 +1358,32 @@ describe Braintree::Transaction, "search" do
             },
             :options => {
               :submit_for_settlement => true
-            }
+            },
           )
 
           collection = Braintree::Transaction.search do |search|
             search.id.is transaction.id
             search.authorized_at.between(
               Date.today - 1,
-              Date.today + 1
+              Date.today + 1,
             )
             search.submitted_for_settlement_at.between(
               Date.today - 1,
-              Date.today + 1
+              Date.today + 1,
             )
           end
 
-          collection.maximum_size.should > 0
+          expect(collection.maximum_size).to be > 0
       end
     end
 
-    it "returns multiple results" do
+    #Disabling until we have a more stable CI
+    xit "returns multiple results" do
       collection = Braintree::Transaction.search
-      collection.maximum_size.should > 100
+      expect(collection.maximum_size).to be > 100
 
-      transaction_ids = collection.map {|t| t.id }.uniq.compact
-      transaction_ids.size.should == collection.maximum_size
+      transaction_ids = collection.map { |t| t.id }.uniq.compact
+      expect(transaction_ids.size).to eq(collection.maximum_size)
     end
 
     context "text node operations" do
@@ -880,7 +1394,7 @@ describe Braintree::Transaction, "search" do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2012",
             :cardholder_name => "Tom Smith"
-          }
+          },
         )
       end
 
@@ -890,15 +1404,15 @@ describe Braintree::Transaction, "search" do
           search.credit_card_cardholder_name.is "Tom Smith"
         end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == @transaction.id
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(@transaction.id)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is @transaction.id
           search.credit_card_cardholder_name.is "Invalid"
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
       end
 
       it "is_not" do
@@ -907,15 +1421,15 @@ describe Braintree::Transaction, "search" do
           search.credit_card_cardholder_name.is_not "Anybody Else"
         end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == @transaction.id
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(@transaction.id)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is @transaction.id
           search.credit_card_cardholder_name.is_not "Tom Smith"
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
       end
 
       it "ends_with" do
@@ -924,15 +1438,15 @@ describe Braintree::Transaction, "search" do
           search.credit_card_cardholder_name.ends_with "m Smith"
         end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == @transaction.id
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(@transaction.id)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is @transaction.id
           search.credit_card_cardholder_name.ends_with "Tom S"
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
       end
 
       it "starts_with" do
@@ -941,15 +1455,15 @@ describe Braintree::Transaction, "search" do
           search.credit_card_cardholder_name.starts_with "Tom S"
         end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == @transaction.id
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(@transaction.id)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is @transaction.id
           search.credit_card_cardholder_name.starts_with "m Smith"
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
       end
 
       it "contains" do
@@ -958,16 +1472,91 @@ describe Braintree::Transaction, "search" do
           search.credit_card_cardholder_name.contains "m Sm"
         end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == @transaction.id
+        expect(collection.maximum_size).to eq(1)
+        expect(collection.first.id).to eq(@transaction.id)
 
         collection = Braintree::Transaction.search do |search|
           search.id.is @transaction.id
           search.credit_card_cardholder_name.contains "Anybody Else"
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
+      end
+    end
+
+    context "when the search times out" do
+      it "raises a UnexpectedError" do
+        expect {
+          Braintree::Transaction.search do |search|
+            search.amount.is(-10)
+          end
+        }.to raise_error(Braintree::UnexpectedError)
+      end
+    end
+
+    it "searches by payment instrument type meta checkout" do
+      meta_checkout_card_transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :options => {
+          :submit_for_settlement => true
+        },
+        :payment_method_nonce => Braintree::Test::Nonce::MetaCheckoutCard,
+      )
+
+      meta_checkout_token_transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :options => {
+          :submit_for_settlement => true
+        },
+        :payment_method_nonce => Braintree::Test::Nonce::MetaCheckoutToken,
+      )
+
+      collection = Braintree::Transaction.search do |search|
+        search.payment_instrument_type.in ["MetaCheckout"]
       end
+
+      collection.maximum_size.should == 2
+      txn_ids = collection.map(&:id)
+      expect(txn_ids).to include(meta_checkout_card_transaction.id)
+      expect(txn_ids).to include(meta_checkout_token_transaction.id)
+    end
+  end
+
+  context "pagination" do
+    it "is not affected by new results on the server" do
+      cardholder_name = "Tom Smith #{rand(1_000_000)}"
+      5.times do |index|
+        Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+            :cardholder_name => "#{cardholder_name} #{index}"
+          },
+        )
+      end
+
+      collection = Braintree::Transaction.search do |search|
+        search.credit_card_cardholder_name.starts_with cardholder_name
+      end
+
+      count_before_new_data = collection.instance_variable_get(:@ids).count
+
+      new_cardholder_name = "#{cardholder_name} shouldn't be included"
+      Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+            :cardholder_name => new_cardholder_name,
+          },
+        )
+
+      transactions = collection.to_a
+      expect(transactions.count).to eq(count_before_new_data)
+
+      cardholder_names = transactions.map { |transaction| transaction.credit_card_details.cardholder_name }
+      expect(cardholder_names).to_not include(new_cardholder_name)
     end
   end
 end