searchlogic 1.5.3 → 1.5.4

data/test/test_active_record_base.rb

@@ -1,93 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-class TestActiveRecordBase < Test::Unit::TestCase
-  def test_standard_find
-    assert_equal [1,2,3], Account.all.map(&:id)
-    assert_equal 1, Account.first.id
-    assert_equal [1,2,3], Account.find(:all).map(&:id)
-    assert_equal [1], Account.find(:all, :conditions => {:name => "Binary Logic"}).map(&:id)
-    assert_equal [1], Account.find(:all, :conditions => ["name = ?", "Binary Logic"]).map(&:id)
-    assert_equal [1], Account.find(:all, :conditions => "name = 'Binary Logic'").map(&:id)
-    assert_equal 1, Account.find(:first).id
-    assert_equal [1,2,3], Account.find(:all, nil).map(&:id)
-    assert_equal [1,2,3], Account.find(:all, {}).map(&:id)
-    assert_equal [1,2,3], Account.find(:all, :select => "id, name").map(&:id)
-  end
-  
-  def test_standard_calculations
-    assert_equal 3, Account.count({})
-    assert_equal 3, Account.count(nil)
-    assert_equal 3, Account.count(:limit => 1)
-    assert_equal 0, Account.count(:limit => 10, :offset => 10)
-    assert_equal 6, Account.sum("id")
-    assert_equal 6, Account.sum("id", {})
-    assert_equal 2, Account.average("id")
-    assert_equal 3, Account.maximum("id")
-    assert_equal 1, Account.minimum("id")
-  end
-  
-  def test_valid_ar_options
-    assert_equal [ :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly, :group, :from, :lock ], ActiveRecord::Base.valid_find_options
-    assert_equal [:conditions, :joins, :order, :select, :group, :having, :distinct, :limit, :offset, :include, :from], ActiveRecord::Base.valid_calculations_options
-  end
-  
-  def test_build_search
-    search = Account.new_search(:conditions => {:name_keywords => "awesome"}, :page => 2, :per_page => 15)
-    assert_kind_of Searchlogic::Search::Base, search
-    assert_equal({}, search.scope)
-    assert_equal Account, search.klass
-    assert_equal "awesome", search.conditions.name_keywords
-    assert_equal 2, search.page
-    assert_equal 15, search.per_page
-  end
-  
-  def test_searchlogic_searching
-    assert_equal Account.find(1, 3), Account.all(:conditions => {:name_contains => "Binary"})
-    assert_equal [Account.find(1)], Account.all(:conditions => {:name_contains => "Binary", :users => {:first_name_starts_with => "Ben"}})
-    assert_equal [], Account.all(:conditions => {:name_contains => "Binary", :users => {:first_name_starts_with => "Ben", :last_name => "Mills"}})
-    assert_equal Account.find(1, 2), Account.all(:conditions => {:users => {:id_gt => 0}}, :include => :users)
-    
-    read_only_accounts = Account.all(:conditions => {:name_contains => "Binary"}, :readonly => true)
-    assert read_only_accounts.first.readonly?
-    
-    assert_equal Account.find(1, 3), Account.all(:conditions => {:name_contains => "Binary"}, :page => 2)
-    assert_equal [], Account.all(:conditions => {:name_contains => "Binary"}, :page => 2, :per_page => 20)
-    
-    assert_equal [Account.find(1)], Account.scope1.all(:conditions => {:users => {:first_name_starts_with => "Ben"}})
-  end
-  
-  def test_searchlogic_counting
-    assert_equal 2, Account.count(:conditions => {:name_contains => "Binary"})
-    assert_equal 1, Account.count(:conditions => {:name_contains => "Binary", :users => {:first_name_contains => "Ben"}})
-    assert_equal 1, Account.count(:conditions => {:name_contains => "Binary", :users => {:first_name_contains => "Ben"}}, :limit => 10, :offset => 10, :order_by => "id", :group => "id")
-  end
-  
-  def test_scoping
-    assert_equal({:conditions => {:name => "Binary"}, :limit => 10, :readonly => true}, Account.send(:with_scope, :find => {:conditions => {:name => "Binary"}, :limit => 10, :readonly => true}) { Account.send(:scope, :find) })
-    assert_equal({:conditions => ["\"accounts\".\"name\" LIKE ?", "%Binary%"], :limit => 10, :offset => 20}, Account.send(:with_scope, :find => {:conditions => {:name_contains => "Binary"}, :per_page => 10, :page => 3}) { Account.send(:scope, :find) })
-  end
-  
-  def test_accessible_conditions
-    Account.conditions_accessible :name_contains
-    assert_equal Set.new(["name_contains"]), Account.accessible_conditions
-    Account.conditions_accessible :id_gt
-    assert_equal Set.new(["id_gt", "name_contains"]), Account.accessible_conditions
-    Account.conditions_accessible :id_gt, :name_contains
-    assert_equal Set.new(["id_gt", "name_contains"]), Account.accessible_conditions
-    Account.send(:write_inheritable_attribute, :conditions_accessible, nil)
-  end
-  
-  def test_protected_conditions
-    Account.conditions_protected :name_contains
-    assert_equal Set.new(["name_contains"]), Account.protected_conditions
-    Account.conditions_protected :id_gt
-    assert_equal Set.new(["id_gt", "name_contains"]), Account.protected_conditions
-    Account.conditions_protected :id_gt, :name_contains
-    assert_equal Set.new(["id_gt", "name_contains"]), Account.protected_conditions
-    Account.send(:write_inheritable_attribute, :conditions_protected, nil)
-  end
-  
-  def test_includes
-    assert_nothing_raised { Account.all(:conditions => {:users => {:first_name_like => "Ben"}}, :include => :users) }
-  end
-end

data/test/test_condition_base.rb

@@ -1,52 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-class TestConditionBase < Test::Unit::TestCase
-  def test_condition_type_name
-    assert_equal "equals", Searchlogic::Condition::Equals.condition_type_name
-    assert_equal "keywords", Searchlogic::Condition::Keywords.condition_type_name
-    assert_equal "greater_than_or_equal_to", Searchlogic::Condition::GreaterThanOrEqualTo.condition_type_name
-  end
-  
-  def test_ignore_meaningless_value?
-    assert !Searchlogic::Condition::Equals.ignore_meaningless_value?
-    assert Searchlogic::Condition::Keywords.ignore_meaningless_value?
-    assert !Searchlogic::Condition::NotEqual.ignore_meaningless_value?
-  end
-  
-  def test_value_type
-    assert_equal nil, Searchlogic::Condition::Equals.value_type
-    assert_equal nil, Searchlogic::Condition::Keywords.value_type
-    assert_equal :boolean, Searchlogic::Condition::Nil.value_type
-    assert_equal :boolean, Searchlogic::Condition::Blank.value_type
-    assert_equal nil, Searchlogic::Condition::GreaterThan.value_type
-  end
-  
-  def test_initialize
-    condition = Searchlogic::Condition::Keywords.new(Account, :column => Account.columns_hash["name"])
-    assert_equal condition.klass, Account
-    assert_equal Account.columns_hash["name"], condition.column
-    
-    condition = Searchlogic::Condition::GreaterThan.new(Account, :column => "id")
-    assert_equal Account.columns_hash["id"], condition.column
-    
-    condition = Searchlogic::Condition::GreaterThan.new(Account, :column => "id", :column_type => :string, :column_sql_format => "some sql")
-    assert_equal Account.columns_hash["id"], condition.column
-    condition.value = "awesome"
-    assert_equal ["some sql > ?", "awesome"], condition.sanitize
-  end
-  
-  def test_explicitly_set_value
-    condition = Searchlogic::Condition::Keywords.new(Account, :column => Account.columns_hash["name"])
-    assert !condition.explicitly_set_value?
-    condition.value = "test"
-    assert condition.explicitly_set_value?
-  end
-  
-  def test_sanitize
-    # This is tested thoroughly in test_condition_types
-  end
-  
-  def test_value
-    # This is tested thoroughly in test_condition_types
-  end
-end

data/test/test_condition_types.rb

@@ -1,143 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-class TestConditionTypes < Test::Unit::TestCase
-  def test_sanitize
-    condition = Searchlogic::Condition::BeginsWith.new(Account, :column => Account.columns_hash["name"])
-    condition.value = "Binary"
-    assert_equal ["\"accounts\".\"name\" LIKE ?", "Binary%"], condition.sanitize
-    
-    condition = Searchlogic::Condition::Blank.new(Account, :column => Account.columns_hash["id"])
-    condition.value = "true"
-    assert_equal "\"accounts\".\"id\" IS NULL or \"accounts\".\"id\" = '' or \"accounts\".\"id\" = false", condition.sanitize
-    
-    condition = Searchlogic::Condition::Blank.new(Account, :column => Account.columns_hash["id"])
-    condition.value = "false"
-    assert_equal "\"accounts\".\"id\" IS NOT NULL and \"accounts\".\"id\" != '' and \"accounts\".\"id\" != false", condition.sanitize
-    
-    condition = Searchlogic::Condition::Blank.new(Account, :column => Account.columns_hash["id"])
-    condition.value = true
-    assert_equal "\"accounts\".\"id\" IS NULL or \"accounts\".\"id\" = '' or \"accounts\".\"id\" = false", condition.sanitize
-    
-    condition = Searchlogic::Condition::Blank.new(Account, :column => Account.columns_hash["id"])
-    condition.value = false
-    assert_equal "\"accounts\".\"id\" IS NOT NULL and \"accounts\".\"id\" != '' and \"accounts\".\"id\" != false", condition.sanitize
-    
-    condition = Searchlogic::Condition::Blank.new(Account, :column => Account.columns_hash["id"])
-    condition.value = nil
-    assert_equal nil, condition.sanitize
-    
-    condition = Searchlogic::Condition::Blank.new(Account, :column => Account.columns_hash["id"])
-    condition.value = ""
-    assert_equal nil, condition.sanitize
-    
-    condition = Searchlogic::Condition::ChildOf.new(User)
-    condition.value = User.first.id
-    assert_equal ["\"users\".\"parent_id\" = ?", User.first.id], condition.sanitize
-    
-    condition = Searchlogic::Condition::ChildOf.new(User)
-    condition.value = User.first
-    assert_equal ["\"users\".\"parent_id\" = ?", User.first.id], condition.sanitize
-    
-    condition = Searchlogic::Condition::DescendantOf.new(User)
-    condition.value = User.find(1)
-    assert_equal ["\"users\".\"id\" = ? OR \"users\".\"id\" = ?", 2, 3], condition.sanitize
-    
-    condition = Searchlogic::Condition::EndsWith.new(Account, :column => Account.columns_hash["name"])
-    condition.value = "Binary"
-    assert_equal ["\"accounts\".\"name\" LIKE ?", "%Binary"], condition.sanitize
-    
-    condition = Searchlogic::Condition::Equals.new(Account, :column => Account.columns_hash["id"])
-    condition.value = 12
-    assert_equal ["\"accounts\".\"id\" = ?", 12], condition.sanitize
-    
-    condition = Searchlogic::Condition::Equals.new(Account, :column => Account.columns_hash["id"])
-    condition.value = [1,2,3,4]
-    assert_equal ["\"accounts\".\"id\" IN (?)", [1, 2, 3, 4]], condition.sanitize
-    
-    condition = Searchlogic::Condition::Equals.new(Account, :column => Account.columns_hash["id"])
-    condition.value = (1..10)
-    assert_equal ["\"accounts\".\"id\" BETWEEN ? AND ?", 1, 10], condition.sanitize
-    
-    condition = Searchlogic::Condition::GreaterThan.new(Account, :column => Account.columns_hash["id"])
-    condition.value = 2
-    assert_equal ["\"accounts\".\"id\" > ?", 2], condition.sanitize
-    
-    condition = Searchlogic::Condition::GreaterThanOrEqualTo.new(Account, :column => Account.columns_hash["id"])
-    condition.value = 2
-    assert_equal ["\"accounts\".\"id\" >= ?", 2], condition.sanitize
-    
-    condition = Searchlogic::Condition::InclusiveDescendantOf.new(User)
-    condition.value = User.find(1)
-    assert_equal ["(\"users\".\"id\" = ?) OR (\"users\".\"id\" = ? OR \"users\".\"id\" = ?)", 1, 2, 3], condition.sanitize
-    
-    condition = Searchlogic::Condition::Like.new(Account, :column => Account.columns_hash["name"])
-    condition.value = "Binary and blah"
-    assert_equal ["\"accounts\".\"name\" LIKE ?", "%Binary and blah%"], condition.sanitize
-    
-    condition = Searchlogic::Condition::Nil.new(Account, :column => Account.columns_hash["id"])
-    condition.value = true
-    assert_equal "\"accounts\".\"id\" IS NULL", condition.sanitize
-    
-    condition = Searchlogic::Condition::Nil.new(Account, :column => Account.columns_hash["id"])
-    condition.value = false
-    assert_equal "\"accounts\".\"id\" IS NOT NULL", condition.sanitize
-    
-    condition = Searchlogic::Condition::Nil.new(Account, :column => Account.columns_hash["id"])
-    condition.value = "true"
-    assert_equal "\"accounts\".\"id\" IS NULL", condition.sanitize
-    
-    condition = Searchlogic::Condition::Nil.new(Account, :column => Account.columns_hash["id"])
-    condition.value = "false"
-    assert_equal "\"accounts\".\"id\" IS NOT NULL", condition.sanitize
-    
-    condition = Searchlogic::Condition::Nil.new(Account, :column => Account.columns_hash["id"])
-    condition.value = nil
-    assert_equal nil, condition.sanitize
-    
-    condition = Searchlogic::Condition::Nil.new(Account, :column => Account.columns_hash["id"])
-    condition.value = ""
-    assert_equal nil, condition.sanitize
-    
-    condition = Searchlogic::Condition::NotEqual.new(Account, :column => Account.columns_hash["id"])
-    condition.value = 12
-    assert_equal ["\"accounts\".\"id\" != ?", 12], condition.sanitize
-    
-    condition = Searchlogic::Condition::NotEqual.new(Account, :column => Account.columns_hash["id"])
-    condition.value = [1,2,3,4]
-    assert_equal ["\"accounts\".\"id\" NOT IN (?)", [1, 2, 3, 4]], condition.sanitize
-    
-    condition = Searchlogic::Condition::NotEqual.new(Account, :column => Account.columns_hash["id"])
-    condition.value = (1..10)
-    assert_equal ["\"accounts\".\"id\" NOT BETWEEN ? AND ?", 1, 10], condition.sanitize
-    
-    condition = Searchlogic::Condition::NotNil.new(Account, :column => Account.columns_hash["created_at"])
-    condition.value = "1"
-    assert_equal "\"accounts\".\"created_at\" IS NOT NULL", condition.sanitize
-    condition.value = "false"
-    assert_equal "\"accounts\".\"created_at\" IS NULL", condition.sanitize
-    
-    condition = Searchlogic::Condition::Keywords.new(Account, :column => Account.columns_hash["name"])
-    condition.value = "freedom yeah, freedom YEAH right"
-    assert_equal ["\"accounts\".\"name\" LIKE ? AND \"accounts\".\"name\" LIKE ? AND \"accounts\".\"name\" LIKE ?", "%freedom%", "%yeah%", "%right%"], condition.sanitize
-    
-    condition = Searchlogic::Condition::Keywords.new(Account, :column => Account.columns_hash["name"])
-    condition.value = "%^$*(^$)"
-    assert_equal nil, condition.sanitize
-    
-    condition = Searchlogic::Condition::Keywords.new(Account, :column => Account.columns_hash["name"])
-    condition.value = "%^$*(^$) àáâãäåßéèêëìíîïñòóôõöùúûüýÿ"
-    assert_equal ["\"accounts\".\"name\" LIKE ?", "%àáâãäåßéèêëìíîïñòóôõöùúûüýÿ%"], condition.sanitize
-    
-    condition = Searchlogic::Condition::LessThan.new(Account, :column => Account.columns_hash["id"])
-    condition.value = 2
-    assert_equal ["\"accounts\".\"id\" < ?", 2], condition.sanitize
-    
-    condition = Searchlogic::Condition::LessThanOrEqualTo.new(Account, :column => Account.columns_hash["id"])
-    condition.value = 2
-    assert_equal ["\"accounts\".\"id\" <= ?", 2], condition.sanitize
-    
-    condition = Searchlogic::Condition::SiblingOf.new(User)
-    condition.value = User.find(2)
-    assert_equal ["(\"users\".\"id\" != ?) AND (\"users\".\"parent_id\" = ?)", 2, 1], condition.sanitize
-  end
-end

data/test/test_conditions_base.rb

@@ -1,242 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-class TestConditionsBase < Test::Unit::TestCase
-  def test_register_conditions
-    Searchlogic::Conditions::Base.register_condition(Searchlogic::Condition::Keywords)
-    assert [Searchlogic::Condition::Keywords], Searchlogic::Conditions::Base.conditions
-    
-    Searchlogic::Conditions::Base.register_condition(Searchlogic::Condition::Like)
-    assert [Searchlogic::Condition::Keywords, Searchlogic::Condition::Like], Searchlogic::Conditions::Base.conditions
-  end
-  
-  def test_association_names
-    assert_equal ["dogs", "children", "user_groups", "orders", "account", "parent", "cats"], Searchlogic::Cache::UserConditions.association_names
-    assert_equal ["admin", "orders", "users"], Searchlogic::Cache::AccountConditions.association_names
-  end
-  
-  def test_condition_names
-    # This is tested thoroughly through the tests
-  end
-  
-  def test_needed
-    assert !Searchlogic::Conditions::Base.needed?(User, {})
-    assert !Searchlogic::Conditions::Base.needed?(User, {:first_name => "Ben"})
-    assert Searchlogic::Conditions::Base.needed?(User, {:first_name_contains => "Awesome"})
-    assert !Searchlogic::Conditions::Base.needed?(User, {"orders.id" => 2})
-  end
-  
-  def test_initialize
-    conditions = Searchlogic::Cache::AccountConditions.new(:name_contains => "Binary")
-    assert_equal conditions.klass, Account
-    assert_equal conditions.name_contains, "Binary"
-  end
-  
-  def test_any
-    conditions = Searchlogic::Cache::AccountConditions.new
-    assert !conditions.any?
-
-    conditions = Searchlogic::Cache::AccountConditions.new(:any => true)
-    assert conditions.any?
-    conditions.any = "false"
-    assert !conditions.any?
-    
-    conditions = Searchlogic::Cache::AccountConditions.new
-    conditions.name_contains = "Binary"
-    assert_equal ["\"accounts\".\"name\" LIKE ?", "%Binary%"], conditions.sanitize
-    conditions.id = 1
-    assert_equal ["(\"accounts\".\"id\" = ?) AND (\"accounts\".\"name\" LIKE ?)", 1, "%Binary%"], conditions.sanitize
-    conditions.any = true
-    assert_equal ["(\"accounts\".\"id\" = ?) OR (\"accounts\".\"name\" LIKE ?)", 1, "%Binary%"], conditions.sanitize
-    conditions.any = false
-    assert_equal ["(\"accounts\".\"id\" = ?) AND (\"accounts\".\"name\" LIKE ?)", 1, "%Binary%"], conditions.sanitize
-  end
-  
-  def test_auto_joins
-    conditions = Searchlogic::Cache::AccountConditions.new
-    assert_equal conditions.auto_joins, nil
-    
-    conditions.name_like = "Binary"
-    assert_equal conditions.auto_joins, nil
-    
-    conditions.users.first_name_like = "Ben"
-    assert_equal conditions.auto_joins, :users
-    
-    conditions.users.orders.description_like = "apple"
-    assert_equal conditions.auto_joins, {:users => :orders} 
-  end
-  
-  def test_inspect
-    conditions = Searchlogic::Cache::AccountConditions.new
-    assert_nothing_raised { conditions.inspect }
-  end
-  
-  def test_sanitize
-    conditions = Searchlogic::Cache::AccountConditions.new
-    conditions.name_contains = "Binary"
-    conditions.id_gt = 5
-    now = Time.now
-    conditions.created_after = now
-    assert_equal ["(\"accounts\".\"created_at\" > ?) AND (\"accounts\".\"id\" > ?) AND (\"accounts\".\"name\" LIKE ?)", now, 5, "%Binary%"], conditions.sanitize
-    
-    # test out associations
-    conditions.users.first_name_like = "Ben"
-    conditions.users.id_gt = 10
-    conditions.users.orders.total_lt = 500
-    assert_equal ["(\"accounts\".\"created_at\" > ?) AND (\"accounts\".\"id\" > ?) AND (\"accounts\".\"name\" LIKE ?) AND ((\"users\".\"first_name\" LIKE ?) AND (\"users\".\"id\" > ?) AND (\"orders\".\"total\" < ?))", now, 5, "%Binary%", "%Ben%", 10, 500], conditions.sanitize
-    
-    # test that raw sql is returned
-    conditions.conditions = "awesome"
-    assert_equal "awesome", conditions.sanitize
-  end
-  
-  def test_conditions
-    conditions = Searchlogic::Cache::AccountConditions.new
-    now = Time.now
-    v = {:name_like => "Binary", :created_at_greater_than => now}
-    conditions.conditions = v
-    assert_equal v, conditions.conditions
-    
-    sql = "id in (1,2,3,4)"
-    conditions.conditions = sql
-    assert_equal sql, conditions.conditions
-    assert_equal({}, conditions.send(:objects))
-    
-    v2 = {:id_less_than => 5, :name_begins_with => "Beginning of string"}
-    conditions.conditions = v2
-    assert_equal v2, conditions.conditions
-    
-    v = {:name_like => "Binary", :created_at_greater_than => now}
-    conditions.conditions = v
-    assert_equal v2.merge(v), conditions.conditions
-    
-    sql2 = "id > 5 and name = 'Test'"
-    conditions.conditions = sql2
-    assert_equal sql2, conditions.conditions
-    assert_equal({}, conditions.send(:objects))
-    
-    conditions.name_contains = "awesome"
-    assert_equal({:name_like => "awesome"}, conditions.conditions)
-    
-    now = Time.now
-    conditions.conditions = {:id_gt => "", :id => "", :name => ["", "", ""], :created_at => ["", now], :name_starts_with => "Ben"}
-    assert_equal({:name_like => "awesome", :name_begins_with => "Ben", :created_at_equals => now}, conditions.conditions)
-  end
-  
-  # Other general usage tests, need to clean these up
-  
-  def test_setting_conditions
-    [Account, User, Order].each do |klass|
-      conditions = "Searchlogic::Cache::#{klass}Conditions".constantize.new
-      conditions.class.condition_names.each do |condition_name|
-        conditions.send("#{condition_name}=", 1)
-        assert_equal 1, conditions.send(condition_name)
-      end
-    end
-  end
-  
-  def test_accessible_protected_conditions
-    Account.conditions_accessible << :name_contains
-    conditions = Searchlogic::Cache::AccountConditions.new
-    conditions.conditions = {:created_after => Time.now, :name_contains => "Binary"}
-    assert({:name_contains => "Binary"}, conditions.conditions)
-    Account.send(:write_inheritable_attribute, :conditions_accessible, nil)
-    
-    Account.conditions_protected << :name_contains
-    conditions = Searchlogic::Cache::AccountConditions.new
-    now = Time.now
-    conditions.conditions = {:created_after => now, :name_contains => "Binary"}
-    assert({:created_after => now}, conditions.conditions)
-    Account.send(:write_inheritable_attribute, :conditions_protected, nil)
-  end
-  
-  def test_assert_valid_values
-    conditions = Searchlogic::Cache::UserConditions.new
-    assert_raise(NoMethodError) { conditions.conditions = {:unknown => "blah"} }
-    assert_nothing_raised { conditions.conditions = {:first_name => "blah"} }
-    assert_nothing_raised { conditions.conditions = {:first_name_contains => "blah"} }
-  end
-  
-  def test_setting_associations
-    conditions = Searchlogic::Cache::AccountConditions.new(:users => {:first_name_like => "Ben"})
-    assert_equal conditions.users.first_name_like, "Ben"
-    
-    conditions.users.last_name_begins_with = "Ben"
-    assert_equal conditions.users.last_name_begins_with, "Ben"
-  end
-  
-  def test_virtual_columns
-    conditions = Searchlogic::Cache::AccountConditions.new
-    conditions.hour_of_created_gt = 2
-    assert_equal ["strftime('%H', \"accounts\".\"created_at\") > ?", 2], conditions.sanitize
-    conditions.dow_of_created_at_most = 5
-    assert_equal ["(strftime('%w', \"accounts\".\"created_at\") <= ?) AND (strftime('%H', \"accounts\".\"created_at\") > ?)", 5, 2], conditions.sanitize
-    conditions.month_of_created_at_nil = true
-    assert_equal ["(strftime('%w', \"accounts\".\"created_at\") <= ?) AND (strftime('%H', \"accounts\".\"created_at\") > ?) AND (strftime('%m', \"accounts\".\"created_at\") IS NULL)", 5, 2], conditions.sanitize
-    conditions.min_of_hour_of_month_of_created_at_nil = true
-    assert_equal ["(strftime('%w', \"accounts\".\"created_at\") <= ?) AND (strftime('%H', \"accounts\".\"created_at\") > ?) AND (strftime('%m', strftime('%H', strftime('%M', \"accounts\".\"created_at\"))) IS NULL) AND (strftime('%m', \"accounts\".\"created_at\") IS NULL)", 5, 2], conditions.sanitize
-  end
-  
-  def test_objects
-    conditions = Searchlogic::Cache::AccountConditions.new
-    assert_equal({}, conditions.send(:objects))
-    
-    conditions.name_contains = "Binary"
-    assert_equal 1, conditions.send(:objects).size
-    
-    conditions.users.first_name_contains = "Ben"
-    assert_equal 2, conditions.send(:objects).size
-  end
-  
-  def test_reset
-    conditions = Searchlogic::Cache::AccountConditions.new
-    
-    conditions.name_contains = "Binary"
-    assert_equal 1, conditions.send(:objects).size
-    
-    conditions.reset_name_like!
-    conditions.reset_name_contains! # should set up aliases for reset
-    assert_equal({}, conditions.send(:objects))
-    
-    conditions.users.first_name_like = "Ben"
-    assert_equal 1, conditions.send(:objects).size
-    
-    conditions.reset_users!
-    assert_equal({}, conditions.send(:objects))
-    
-    conditions.name_begins_with ="Binary"
-    conditions.users.orders.total_gt = 200
-    assert_equal 2, conditions.send(:objects).size
-    
-    conditions.reset_name_begins_with!
-    assert_equal 1, conditions.send(:objects).size
-    
-    conditions.reset_users!
-    assert_equal({}, conditions.send(:objects))
-  end
-  
-  def test_method_conflicts
-    conditions = Searchlogic::Cache::AccountConditions.new
-    assert_equal nil, conditions.id
-  end
-  
-  def test_sti
-    #s = User.new_search
-    #s.conditions.dogs.description_like = "awesome"
-    #s.conditions.cats.description_like = "awesome"
-    #s.select = "ass"
-    #s.all
-    
-    joins = []
-    join_dependency = ::ActiveRecord::Associations::ClassMethods::JoinDependency.new(User, [:dogs, :cats], nil)
-    join_dependency.join_associations.each_with_index do |assoc, index|
-      #raise assoc.aliased_table_name.inspect if index == 1
-      joins << assoc.association_join
-    end
-    #raise joins.inspect
-    
-    conditions = Searchlogic::Cache::UserConditions.new
-    conditions.dogs.description_like = "Harry"
-    r = User.reflect_on_association(:dogs)
-    #raise r.inspect
-  end
-end