braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/transaction_search_spec.rb

@@ -8,7 +8,7 @@ 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
@@ -60,7 +60,7 @@ describe Braintree::Transaction, "search" do
           :postal_code => "54321",
           :region => "MA",
           :street_address => "456 Road"
-        }
+        },
       )
 
       SpecHelper.settle_transaction transaction.id
@@ -109,14 +109,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|
@@ -126,27 +126,27 @@ 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
 
     it "searches on users" do
       transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
       )
 
       collection = Braintree::Transaction.search do |search|
         search.user.is "integration_user_public_id"
       end
 
-      collection.any?{ |t| t.id == transaction.id }.should == true
+      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::PayPalFuturePayment
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
       )
 
       paypal_details = transaction.paypal_details
@@ -157,8 +157,44 @@ describe Braintree::Transaction, "search" do
         search.paypal_payer_email.is paypal_details.payer_email
       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 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
@@ -168,7 +204,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
-        }
+        },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -176,21 +212,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
@@ -199,7 +235,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
-        }
+        },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -207,21 +243,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
@@ -230,7 +266,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
-        }
+        },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -238,21 +274,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
@@ -261,7 +297,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
-        }
+        },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -269,28 +305,28 @@ 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
@@ -301,7 +337,7 @@ describe Braintree::Transaction, "search" do
             :number => Braintree::Test::CreditCardNumbers::Elo,
             :cvv => "737",
             :expiration_date => "10/2020"
-          }
+          },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -309,7 +345,7 @@ describe Braintree::Transaction, "search" do
           search.credit_card_card_type.is Braintree::CreditCard::CardType::Elo
         end
 
-        collection.maximum_size.should == 1
+        expect(collection.maximum_size).to eq(1)
       end
 
       it "searches by payment instrument type CreditCardDetail" do
@@ -318,7 +354,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -326,14 +362,14 @@ describe Braintree::Transaction, "search" do
           search.payment_instrument_type.in ["CreditCardDetail"]
         end
 
-        collection.first.id.should == transaction.id
-        collection.first.payment_instrument_type.should ==Braintree::PaymentInstrumentType::CreditCard
+        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
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -341,14 +377,14 @@ describe Braintree::Transaction, "search" do
           search.payment_instrument_type.in ["PayPalDetail"]
         end
 
-        collection.first.id.should == transaction.id
-        collection.first.payment_instrument_type.should == Braintree::PaymentInstrumentType::PayPalAccount
+        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
+          :payment_method_nonce => Braintree::Test::Nonce::LocalPayment,
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -356,14 +392,46 @@ describe Braintree::Transaction, "search" do
           search.payment_instrument_type.in ["LocalPaymentDetail"]
         end
 
-        collection.first.id.should == transaction.id
-        collection.first.payment_instrument_type.should == Braintree::PaymentInstrumentType::LocalPayment
+        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
+          :payment_method_nonce => Braintree::Test::Nonce::ApplePayVisa,
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -371,8 +439,8 @@ describe Braintree::Transaction, "search" do
           search.payment_instrument_type.in ["ApplePayDetail"]
         end
 
-        collection.first.id.should == transaction.id
-        collection.first.payment_instrument_type.should == Braintree::PaymentInstrumentType::ApplePayCard
+        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
@@ -381,7 +449,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -389,21 +457,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
@@ -411,8 +490,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
@@ -421,7 +500,7 @@ describe Braintree::Transaction, "search" do
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
         )
 
         collection = Braintree::Transaction.search do |search|
@@ -429,21 +508,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
@@ -454,7 +533,7 @@ describe Braintree::Transaction, "search" do
           :cardholder_name => cardholder_name,
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/12"
-        }
+        },
         )
 
         transaction = Braintree::Transaction.sale!(
@@ -464,18 +543,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
@@ -483,8 +562,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
@@ -492,20 +571,89 @@ 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
-          collection = Braintree::Transaction.search do |search|
+          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
 
     context "range fields" do
@@ -516,7 +664,7 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
           )
 
           collection = Braintree::Transaction.search do |search|
@@ -524,31 +672,31 @@ 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
@@ -557,7 +705,7 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
           )
 
           collection = Braintree::Transaction.search do |search|
@@ -565,7 +713,7 @@ describe Braintree::Transaction, "search" do
             search.amount <= BigDecimal("1000.00")
           end
 
-          collection.maximum_size.should == 1
+          expect(collection.maximum_size).to eq(1)
         end
       end
 
@@ -576,56 +724,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
@@ -634,7 +782,7 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/12"
-          }
+          },
           )
 
           now = Time.now
@@ -643,38 +791,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
@@ -683,19 +831,37 @@ 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
 
-          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
+
+      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
 
@@ -708,46 +874,46 @@ describe Braintree::Transaction, "search" do
             search.id.is transaction_id
             search.disbursement_date.between(
               disbursement_time - 60,
-              disbursement_time + 60
+              disbursement_time + 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.disbursement_date >= disbursement_time - 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.disbursement_date <= disbursement_time + 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.disbursement_date.between(
               disbursement_time - 300,
-              disbursement_time - 100
+              disbursement_time - 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.disbursement_date.is disbursement_time
           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 disbursement_date in local time" do
@@ -758,38 +924,38 @@ describe Braintree::Transaction, "search" do
             search.id.is transaction_id
             search.disbursement_date.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.disbursement_date >= 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.disbursement_date <= 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.disbursement_date.between(
               now - 300,
-              now - 100
+              now - 100,
             )
           end
 
-          collection.maximum_size.should == 0
+          expect(collection.maximum_size).to eq(0)
         end
 
         it "searches on disbursement_date with date ranges" do
@@ -800,12 +966,12 @@ describe Braintree::Transaction, "search" do
             search.id.is transaction_id
             search.disbursement_date.between(
               disbursement_date - 1,
-              disbursement_date + 1
+              disbursement_date + 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
 
@@ -816,7 +982,7 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::Disputes::Chargeback,
               :expiration_date => "03/18"
-            }
+            },
           )
 
           @disputed_date = @disputed_transaction.disputes.first.received_date
@@ -841,36 +1007,36 @@ describe Braintree::Transaction, "search" do
             search.id.is @disputed_transaction.id
             search.dispute_date.between(
               @disputed_time - 60,
-              @disputed_time + 60
+              @disputed_time + 60,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == @disputed_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 >= @disputed_time - 1
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == @disputed_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 <= @disputed_time + 1
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == @disputed_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.is @disputed_time
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == @disputed_transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(@disputed_transaction.id)
         end
 
         it "searches on dispute_date in local time" do
@@ -880,27 +1046,27 @@ describe Braintree::Transaction, "search" do
             search.id.is @disputed_transaction.id
             search.dispute_date.between(
               now - 60,
-              now + 60
+              now + 60,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == @disputed_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
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == @disputed_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
 
-          collection.maximum_size.should == 1
+          expect(collection.maximum_size).to eq(1)
         end
 
         it "searches on dispute_date with date ranges" do
@@ -908,12 +1074,12 @@ describe Braintree::Transaction, "search" do
             search.id.is @disputed_transaction.id
             search.dispute_date.between(
               @disputed_date - 1,
-              @disputed_date + 1
+              @disputed_date + 1,
             )
           end
 
-          collection.maximum_size.should == 1
-          collection.first.id.should == @disputed_transaction.id
+          expect(collection.maximum_size).to eq(1)
+          expect(collection.first.id).to eq(@disputed_transaction.id)
         end
       end
 
@@ -924,29 +1090,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
@@ -955,50 +1121,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
@@ -1017,29 +1183,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
@@ -1053,29 +1219,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
@@ -1087,7 +1253,7 @@ describe Braintree::Transaction, "search" do
             },
             :options => {
               :submit_for_settlement => true
-            }
+            },
           ).transaction
 
           SpecHelper.settle_transaction transaction.id
@@ -1096,22 +1262,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
@@ -1123,29 +1289,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
@@ -1154,7 +1320,7 @@ describe Braintree::Transaction, "search" do
             :credit_card => {
               :number => Braintree::Test::CreditCardNumbers::Visa,
               :expiration_date => "05/12"
-            }
+            },
           )
           transaction = Braintree::Transaction.void(transaction.id).transaction
 
@@ -1162,22 +1328,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
 
@@ -1190,31 +1356,31 @@ 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
       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
@@ -1225,7 +1391,7 @@ describe Braintree::Transaction, "search" do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2012",
             :cardholder_name => "Tom Smith"
-          }
+          },
         )
       end
 
@@ -1235,15 +1401,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
@@ -1252,15 +1418,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
@@ -1269,15 +1435,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
@@ -1286,15 +1452,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
@@ -1303,26 +1469,53 @@ 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 Down for Maintenance Error" do
+      it "raises a UnexpectedError" do
         expect {
-          collection = Braintree::Transaction.search do |search|
-            search.amount.is -10
+          Braintree::Transaction.search do |search|
+            search.amount.is(-10)
           end
-        }.to raise_error(Braintree::DownForMaintenanceError)
+        }.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
 
@@ -1336,7 +1529,7 @@ describe Braintree::Transaction, "search" do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2012",
             :cardholder_name => "#{cardholder_name} #{index}"
-          }
+          },
         )
       end
 
@@ -1353,7 +1546,7 @@ describe Braintree::Transaction, "search" do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2012",
             :cardholder_name => new_cardholder_name,
-          }
+          },
         )
 
       transactions = collection.to_a