schof-searchlogic 0.0.2

data/test/active_record_tests/associations_test.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ActiveRecordTests
+  class AssociationsTest < ActiveSupport::TestCase
+    def test_has_many
+      binary_logic = accounts(:binary_logic)
+      ben = users(:ben)
+      jennifer = users(:jennifer)
+      
+      search = binary_logic.users.new_search
+      assert_kind_of Searchlogic::Search::Base, search
+      assert_equal User, search.klass
+      assert_equal({:conditions => "\"users\".account_id = #{binary_logic.id}"}, search.scope)
+      
+      assert_equal [ben, jennifer], search.all
+      assert_equal ben, search.first
+      assert_equal ((ben.id + jennifer.id) / 2.0), search.average("id")
+      assert_equal 2, search.count
+    
+      search.conditions.first_name_contains = "Ben"
+    
+      assert_equal [ben], search.all
+      assert_equal ben, search.first
+      assert_equal ben.id, search.average("id")
+      assert_equal 1, search.count
+    
+      assert_equal 2, binary_logic.users.count
+      assert_equal 1, binary_logic.users.all(:conditions => {:first_name_contains => "Ben"}).size
+      assert_equal 0, binary_logic.users.all(:conditions => {:first_name_contains => "No one"}).size
+      assert_equal ben.id, binary_logic.users.sum("id", :conditions => {:first_name_contains => "Ben"})
+      assert_equal 0, binary_logic.users.sum("id", :conditions => {:first_name_contains => "No one"})
+      assert_equal ben.id, binary_logic.users.average("id", :conditions => {:first_name_contains => "Ben"})
+    end
+  
+    def test_has_many_through
+      binary_logic = accounts(:binary_logic)
+      
+      search = binary_logic.orders.new_search
+      assert_kind_of Searchlogic::Search::Base, search
+      assert_equal Order, search.klass
+      assert_equal({:joins => "INNER JOIN users ON orders.user_id = users.id   ", :conditions => "(\"users\".account_id = #{binary_logic.id})"}, search.scope)
+      
+      bens_order = orders(:bens_order)
+      assert_equal [bens_order], search.all
+      assert_equal bens_order, search.first
+      assert_equal bens_order.id, search.average("id")
+      assert_equal 1, search.count
+    
+      search.conditions.total_gt = 100
+    
+      assert_equal [bens_order], search.all
+      assert_equal bens_order, search.first
+      assert_equal bens_order.id, search.average("id")
+      assert_equal 1, search.count
+    
+      assert_equal 1, binary_logic.orders.count
+      assert_equal 1, binary_logic.orders.all(:conditions => {:total_gt => 100}).size
+      assert_equal 0, binary_logic.orders.all(:conditions => {:total_gt => 1000}).size
+      assert_equal bens_order.id, binary_logic.orders.sum("id", :conditions => {:total_gt => 100})
+      assert_equal 0, binary_logic.orders.sum("id", :conditions => {:total_gt => 1000})
+      assert_equal bens_order.id, binary_logic.orders.average("id", :conditions => {:total_gt => 100})
+    end
+  
+    def test_habtm
+      neco = user_groups(:neco)
+      ben = users(:ben)
+      drew = users(:drew)
+      
+      search = neco.users.new_search
+      assert_kind_of Searchlogic::Search::Base, search
+      assert_equal User, search.klass
+      assert_equal({:conditions => "\"user_groups_users\".user_group_id = #{neco.id} ", :joins => "INNER JOIN \"user_groups_users\" ON \"users\".id = \"user_groups_users\".user_id"}, search.scope)
+      assert_equal [drew, ben], search.all
+      
+      assert_equal drew, search.first
+      assert_equal ((ben.id + drew.id) / 2.0).to_s, search.average("id").to_s
+      assert_equal 2, search.count
+    
+      search.conditions.first_name_contains = "Ben"
+
+      assert_equal [ben], search.all
+      assert_equal ben, search.first
+      assert_equal ben.id, search.average("id")
+      assert_equal 1, search.count
+    
+      assert_equal 2, neco.users.count
+      assert_equal 1, neco.users.all(:conditions => {:first_name_contains => "Ben"}).size
+      assert_equal 0, neco.users.all(:conditions => {:first_name_contains => "No one"}).size
+      assert_equal ben.id, neco.users.sum("id", :conditions => {:first_name_contains => "Ben"})
+      assert_equal 0, neco.users.sum("id", :conditions => {:first_name_contains => "No one"})
+      assert_equal ben.id, neco.users.average("id", :conditions => {:first_name_contains => "Ben"})
+    end
+  end
+end

data/test/active_record_tests/base_test.rb

@@ -0,0 +1,115 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ActiveRecordTests
+  class BaseTest < ActiveSupport::TestCase
+    def test_standard_find
+      binary_logic = accounts(:binary_logic)
+      neco = accounts(:neco)
+      binary_fun = accounts(:binary_fun)
+      
+      assert_equal [binary_logic, binary_fun, neco], Account.all
+      assert_equal binary_logic, Account.first
+      
+      assert_equal [binary_logic, binary_fun, neco], Account.find(:all)
+      assert_equal [binary_logic], Account.find(:all, :conditions => {:name => "Binary Logic"})
+      assert_equal [binary_logic], Account.find(:all, :conditions => ["name = ?", "Binary Logic"])
+      assert_equal [binary_logic], Account.find(:all, :conditions => "name = 'Binary Logic'")
+      assert_equal binary_logic, Account.find(:first)
+      assert_equal [binary_logic, binary_fun, neco], Account.find(:all, nil)
+      assert_equal [binary_logic, binary_fun, neco], Account.find(:all, {})
+      assert_equal [binary_logic, binary_fun, neco], Account.find(:all, :select => "id, name")
+    end
+    
+    def test_standard_calculations
+      binary_logic = accounts(:binary_logic)
+      neco = accounts(:neco)
+      binary_fun = accounts(:binary_fun)
+      
+      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 binary_logic.id + neco.id + binary_fun.id, Account.sum("id")
+      assert_equal binary_logic.id + neco.id + binary_fun.id, Account.sum("id", {})
+      assert_equal (binary_logic.id + neco.id + binary_fun.id) / 3.0, Account.average("id")
+      assert_equal neco.id, Account.maximum("id")
+      assert_equal binary_logic.id, 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
+      binary_logic = accounts(:binary_logic)
+      neco = accounts(:neco)
+      binary_fun = accounts(:binary_fun)
+      
+      assert_equal [binary_logic, binary_fun], Account.all(:conditions => {:name_contains => "Binary"})
+      assert_equal [binary_logic], 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 [binary_logic, neco], 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 [binary_logic, binary_fun], Account.all(:conditions => {:name_contains => "Binary"}, :page => 2)
+      assert_equal [], Account.all(:conditions => {:name_contains => "Binary"}, :page => 2, :per_page => 20)
+      
+      assert_equal [binary_logic], 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 => "accounts.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
+    
+    def test_remove_duplicate_joins
+      query = "SELECT DISTINCT `ticket_groups`.* FROM `ticket_groups` INNER JOIN tickets ON ticket_groups.id = tickets.ticket_group_id     LEFT OUTER JOIN `tickets` ON tickets.ticket_group_id = ticket_groups.id  WHERE (`tickets`.`id` = 2) AND ((`tickets`.event_id = 810802042))  LIMIT 20"
+      cleaned_query = ActiveRecord::Base.send(:remove_duplicate_joins, query)
+      expected_query = "SELECT DISTINCT `ticket_groups`.* FROM `ticket_groups` INNER JOIN tickets ON ticket_groups.id = tickets.ticket_group_id WHERE (`tickets`.`id` = 2) AND ((`tickets`.event_id = 810802042)) LIMIT 20"
+      assert_equal expected_query, cleaned_query
+    end
+  end
+end

data/test/condition_tests/base_test.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class BaseTest < ActiveSupport::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_nil Searchlogic::Condition::Equals.value_type
+      assert_nil Searchlogic::Condition::Keywords.value_type
+      assert_equal :boolean, Searchlogic::Condition::Nil.value_type
+      assert_equal :boolean, Searchlogic::Condition::Blank.value_type
+      assert_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
+end

data/test/condition_tests/begins_with_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class BeginsWithTest < ActiveSupport::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
+    end
+  end
+end

data/test/condition_tests/blank_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class BlankTest < ActiveSupport::TestCase
+    def test_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_nil condition.sanitize
+    
+      condition = Searchlogic::Condition::Blank.new(Account, :column => Account.columns_hash["id"])
+      condition.value = ""
+      assert_nil condition.sanitize
+    end
+  end
+end

data/test/condition_tests/child_of_test.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class ChildOfTest < ActiveSupport::TestCase
+    def test_sanitize
+      ben = users(:ben)
+      
+      condition = Searchlogic::Condition::ChildOf.new(User)
+      condition.value = ben.id
+      assert_equal ["\"users\".\"parent_id\" = ?", ben.id], condition.sanitize
+
+      condition = Searchlogic::Condition::ChildOf.new(User)
+      condition.value = ben
+      assert_equal ["\"users\".\"parent_id\" = ?", ben.id], condition.sanitize
+    end
+  end
+end

data/test/condition_tests/descendant_of_test.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class DescendantOfTest < ActiveSupport::TestCase
+    def test_sanitize
+      ben = users(:ben)
+      condition = Searchlogic::Condition::DescendantOf.new(User)
+      condition.value = ben
+      assert_equal ["(\"users\".\"id\" != ? AND (\"users\".\"lft\" >= ? AND \"users\".\"rgt\" <= ?))", ben.id, ben.left, ben.right], condition.sanitize
+    end
+  end
+end

data/test/condition_tests/ends_with_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class EndsWithTest < ActiveSupport::TestCase
+    def test_sanitize
+      condition = Searchlogic::Condition::EndsWith.new(Account, :column => Account.columns_hash["name"])
+      condition.value = "Binary"
+      assert_equal ["\"accounts\".\"name\" LIKE ?", "%Binary"], condition.sanitize
+    end
+  end
+end

data/test/condition_tests/equals_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class EqualsTest < ActiveSupport::TestCase
+    def test_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 = []
+      assert_equal [], condition.value
+      assert_nil condition.sanitize
+      
+      search = User.new_search
+      search.conditions.id = []
+      assert_equal [], search.conditions.id
+    
+      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
+    end
+  end
+end

data/test/condition_tests/greater_than_or_equal_to_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class GreaterThanOrEqualToTest < ActiveSupport::TestCase
+    def test_sanitize
+      condition = Searchlogic::Condition::GreaterThanOrEqualTo.new(Account, :column => Account.columns_hash["id"])
+      condition.value = 2
+      assert_equal ["\"accounts\".\"id\" >= ?", 2], condition.sanitize
+    end
+  end
+end

data/test/condition_tests/greater_than_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class GreaterThanTest < ActiveSupport::TestCase
+    def test_sanitize
+      condition = Searchlogic::Condition::GreaterThan.new(Account, :column => Account.columns_hash["id"])
+      condition.value = 2
+      assert_equal ["\"accounts\".\"id\" > ?", 2], condition.sanitize
+    end
+  end
+end

data/test/condition_tests/inclusive_descendant_of_test.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class InclusiveDescendantOfTest < ActiveSupport::TestCase
+    def test_sanitize
+      ben = users(:ben)
+      condition = Searchlogic::Condition::InclusiveDescendantOf.new(User)
+      condition.value = ben
+      assert_equal ["(\"users\".\"lft\" >= ? AND \"users\".\"rgt\" <= ?)", ben.left, ben.right], condition.sanitize
+    end
+  end
+end

data/test/condition_tests/keywords_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module ConditionTests
+  class KeywordsTest < ActiveSupport::TestCase
+    def test_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_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::Keywords.new(Account, :column => Account.columns_hash["name"])
+      condition.value = "ben@ben.com"
+      assert_equal ["\"accounts\".\"name\" LIKE ?", "%ben@ben.com%"], condition.sanitize
+    end
+  end
+end