searchgasm 0.9.2 → 0.9.3

data/lib/searchgasm/search/condition_types/tree_condition.rb

@@ -0,0 +1,20 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class TreeCondition < Condition
+          class << self
+            def name_for_column(column)
+              nil
+            end
+            
+            def name_for_klass(klass)
+              return unless klass.reflect_on_association(:parent) && klass.reflect_on_association(:children)
+              condition_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/search/conditions.rb

@@ -7,58 +7,21 @@ module BinaryLogic
         attr_accessor :klass, :protect, :relationship_name, :scope
         
         class << self
-          def condition_types_for_column_type(type)
-            condition_types = [:equals, :does_not_equal]
-            case type
-            when :string, :text
-              condition_types += [:begins_with, :contains, :keywords, :ends_with]
-            when :integer, :float, :decimal, :datetime, :timestamp, :time, :date
-              condition_types += [:greater_than, :greater_than_or_equal_to, :less_than, :less_than_or_equal_to]
-            end
-            condition_types
+          def register_condition(klass)
+            raise(ArgumentError, "You can only register conditions that extend BinaryLogic::Searchgasm::Search::ConditionTypes::Condition") unless klass.ancestors.include?(ConditionTypes::Condition)
+            conditions << klass
           end
           
-          def aliases_for_condition_type(condition_type)
-            case condition_type
-            when :equals                    then  ["", :is]
-            when :does_not_equal            then  [:is_not, :not]
-            when :begins_with               then  [:starts_with]
-            when :contains                  then  [:like]
-            when :greater_than              then  [:gt, :after]
-            when :greater_than_or_equal_to  then  [:at_least, :gte]
-            when :less_than                 then  [:lt, :before]
-            when :less_than_or_equal_to     then  [:at_most, :lte]
-            else                                  []
-            end
-          end
-        
-          def aliases_for_condition(*args)
-            column, condition_type = nil, nil
-            
-            # Allow a condition object or the column and condition type to be passed
-            if args.size == 1
-              column, condition_type = condition.column, condition.condition
-            else
-              column, condition_type = args.first, args[1]
-            end
-            
-            name = Condition.generate_name(column, condition_type)
-            alias_condition_types = aliases_for_condition_type(condition_type)
-            column_names = [column.name]
-            column_names << column.name.gsub(/_at$/, "") if [:datetime, :timestamp, :time, :date].include?(column.type) && column.name =~ /_at$/
-            
-            aliases = []
-            column_names.each do |column_name|
-              alias_condition_types.each { |alias_condition_type| aliases << Condition.generate_name(column_name, alias_condition_type) }
-            end
-            aliases
+          def conditions
+            @@conditions ||= []
           end
         end
         
         def initialize(klass, init_values = {})
           self.klass = klass
-          klass.columns.each { |column| add_conditions_for_column!(column) }
-          klass.reflect_on_all_associations.each { |association| add_association!(association)  }
+          add_klass_conditions!
+          add_column_conditions!
+          add_associations!
           self.value = init_values
         end
         
@@ -106,9 +69,9 @@ module BinaryLogic
         end
         
         def sanitize
-          sanitized_objects = merge_conditions(*objects.collect { |object| object.sanitize })
-          return scope if sanitized_objects.blank?
-          merge_conditions(sanitized_objects, scope)
+          conditions = merge_conditions(*objects.collect { |object| object.sanitize })
+          return scope if conditions.blank?
+          merge_conditions(conditions, scope)
         end
         
         def value=(values)
@@ -135,57 +98,67 @@ module BinaryLogic
         end
         
         private
-          def add_association!(association)
-            self.class.class_eval <<-SRC
-              def #{association.name}
-                if @#{association.name}.nil?
-                  @#{association.name} = self.class.new(#{association.class_name})
-                  @#{association.name}.relationship_name = "#{association.name}"
-                  self.objects << @#{association.name}
+          def add_associations!
+            klass.reflect_on_all_associations.each do |association|
+              self.class.class_eval <<-end_eval
+                def #{association.name}
+                  if @#{association.name}.nil?
+                    @#{association.name} = self.class.new(#{association.class_name})
+                    @#{association.name}.relationship_name = "#{association.name}"
+                    self.objects << @#{association.name}
+                  end
+                  @#{association.name}
                 end
-                @#{association.name}
-              end
               
-              def #{association.name}=(value); #{association.name}.value = value; end
-              def reset_#{association.name}!; objects.delete(#{association.name}); @#{association.name} = nil; end
-            SRC
-            
-            association.name
+                def #{association.name}=(value); #{association.name}.value = value; end
+                def reset_#{association.name}!; objects.delete(#{association.name}); @#{association.name} = nil; end
+              end_eval
+            end
           end
           
-          def add_conditions_for_column!(column)
-            self.class.condition_types_for_column_type(column.type).collect { |condition_type| add_condition!(condition_type, column) }
+          def add_column_conditions!
+            klass.columns.each do |column|
+              self.class.conditions.each do |condition|
+                name = condition.name_for_column(column)
+                next if name.blank?
+                add_condition!(condition, name, column)
+                condition.aliases_for_column(column).each { |alias_name| add_condition_alias!(alias_name, name) }
+              end
+            end
           end
           
-          def add_condition!(condition_type, column)
-            name = Condition.generate_name(column, condition_type)
+          def add_condition!(condition, name, column = nil)
             self.condition_names << name
-            
-            # Define accessor methods
-            self.class.class_eval <<-SRC
+            self.class.class_eval <<-end_eval
               def #{name}_object
                 if @#{name}.nil?
-                  @#{name} = Condition.new(:#{condition_type}, klass, "#{column.name}")
+                  @#{name} = #{condition.name}.new(klass#{column.nil? ? "" : ", \"#{column.name}\""})
                   self.objects << @#{name}
                 end
                 @#{name}
               end
-              
+
               def #{name}; #{name}_object.value; end
               def #{name}=(value); #{name}_object.value = value; end
               def reset_#{name}!; objects.delete(#{name}_object); @#{name} = nil; end
-            SRC
-            
-            # Define aliases
-            self.class.aliases_for_condition(column, condition_type).each do |alias_name|
-              self.condition_names << alias_name
-              self.class.class_eval do
-                alias_method alias_name, name
-                alias_method "#{alias_name}=", "#{name}="
-              end
+            end_eval
+          end
+          
+          def add_condition_alias!(alias_name, name)
+            self.condition_names << alias_name
+            self.class.class_eval do
+              alias_method alias_name, name
+              alias_method "#{alias_name}=", "#{name}="
+            end
+          end
+          
+          def add_klass_conditions!
+            self.class.conditions.each do |condition|
+              name = condition.name_for_klass(klass)
+              next if name.blank?
+              add_condition!(condition, name)
+              condition.aliases_for_klass(klass).each { |alias_name| add_condition_alias!(alias_name, name) }
             end
-            
-            name
           end
       end
     end

data/lib/searchgasm/version.rb

@@ -68,7 +68,7 @@ module BinaryLogic
 
       MAJOR = 0
       MINOR = 9
-      TINY  = 2
+      TINY  = 3
 
       # The current version as a Version instance
       CURRENT = new(MAJOR, MINOR, TINY)

data/lib/searchgasm.rb

@@ -1,8 +1,29 @@
 require "active_record"
+
 require "searchgasm/active_record/base"
 require "searchgasm/active_record/associations"
+
 require "searchgasm/version"
 require "searchgasm/search/utilities"
-require "searchgasm/search/condition"
 require "searchgasm/search/conditions"
-require "searchgasm/search/base"
+require "searchgasm/search/base"
+
+# Regular conidtion types
+require "searchgasm/search/condition_types/condition"
+require "searchgasm/search/condition_types/begins_with_condition"
+require "searchgasm/search/condition_types/contains_condition"
+require "searchgasm/search/condition_types/does_not_equal_condition"
+require "searchgasm/search/condition_types/ends_with_condition"
+require "searchgasm/search/condition_types/equals_condition"
+require "searchgasm/search/condition_types/greater_than_condition"
+require "searchgasm/search/condition_types/greater_than_or_equal_to_condition"
+require "searchgasm/search/condition_types/keywords_condition"
+require "searchgasm/search/condition_types/less_than_condition"
+require "searchgasm/search/condition_types/less_than_or_equal_to_condition"
+
+# Tree condition types
+require "searchgasm/search/condition_types/tree_condition"
+require "searchgasm/search/condition_types/child_of_condition"
+require "searchgasm/search/condition_types/descendant_of_condition"
+require "searchgasm/search/condition_types/inclusive_descendant_of_condition"
+require "searchgasm/search/condition_types/sibling_of_condition"

data/searchgasm.gemspec

@@ -1,11 +1,11 @@
 
-# Gem::Specification for Searchgasm-0.9.2
+# Gem::Specification for Searchgasm-0.9.3
 # Originally generated by Echoe
 
 --- !ruby/object:Gem::Specification 
 name: searchgasm
 version: !ruby/object:Gem::Version 
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors: 
 - Ben Johnson of Binary Logic
@@ -55,9 +55,23 @@ extra_rdoc_files:
 - CHANGELOG
 - lib/searchgasm/active_record/associations.rb
 - lib/searchgasm/active_record/base.rb
-- lib/searchgasm/helpers.rb
 - lib/searchgasm/search/base.rb
-- lib/searchgasm/search/condition.rb
+- lib/searchgasm/search/condition_types/begins_with_condition.rb
+- lib/searchgasm/search/condition_types/child_of_condition.rb
+- lib/searchgasm/search/condition_types/condition.rb
+- lib/searchgasm/search/condition_types/contains_condition.rb
+- lib/searchgasm/search/condition_types/descendant_of_condition.rb
+- lib/searchgasm/search/condition_types/does_not_equal_condition.rb
+- lib/searchgasm/search/condition_types/ends_with_condition.rb
+- lib/searchgasm/search/condition_types/equals_condition.rb
+- lib/searchgasm/search/condition_types/greater_than_condition.rb
+- lib/searchgasm/search/condition_types/greater_than_or_equal_to_condition.rb
+- lib/searchgasm/search/condition_types/inclusive_descendant_of_condition.rb
+- lib/searchgasm/search/condition_types/keywords_condition.rb
+- lib/searchgasm/search/condition_types/less_than_condition.rb
+- lib/searchgasm/search/condition_types/less_than_or_equal_to_condition.rb
+- lib/searchgasm/search/condition_types/sibling_of_condition.rb
+- lib/searchgasm/search/condition_types/tree_condition.rb
 - lib/searchgasm/search/conditions.rb
 - lib/searchgasm/search/utilities.rb
 - lib/searchgasm/version.rb
@@ -68,9 +82,23 @@ files:
 - init.rb
 - lib/searchgasm/active_record/associations.rb
 - lib/searchgasm/active_record/base.rb
-- lib/searchgasm/helpers.rb
 - lib/searchgasm/search/base.rb
-- lib/searchgasm/search/condition.rb
+- lib/searchgasm/search/condition_types/begins_with_condition.rb
+- lib/searchgasm/search/condition_types/child_of_condition.rb
+- lib/searchgasm/search/condition_types/condition.rb
+- lib/searchgasm/search/condition_types/contains_condition.rb
+- lib/searchgasm/search/condition_types/descendant_of_condition.rb
+- lib/searchgasm/search/condition_types/does_not_equal_condition.rb
+- lib/searchgasm/search/condition_types/ends_with_condition.rb
+- lib/searchgasm/search/condition_types/equals_condition.rb
+- lib/searchgasm/search/condition_types/greater_than_condition.rb
+- lib/searchgasm/search/condition_types/greater_than_or_equal_to_condition.rb
+- lib/searchgasm/search/condition_types/inclusive_descendant_of_condition.rb
+- lib/searchgasm/search/condition_types/keywords_condition.rb
+- lib/searchgasm/search/condition_types/less_than_condition.rb
+- lib/searchgasm/search/condition_types/less_than_or_equal_to_condition.rb
+- lib/searchgasm/search/condition_types/sibling_of_condition.rb
+- lib/searchgasm/search/condition_types/tree_condition.rb
 - lib/searchgasm/search/conditions.rb
 - lib/searchgasm/search/utilities.rb
 - lib/searchgasm/version.rb
@@ -86,10 +114,9 @@ files:
 - test/libs/rexml_fix.rb
 - test/test_active_record_associations.rb
 - test/test_active_record_base.rb
-- test/test_active_record_protection.rb
 - test/test_helper.rb
 - test/test_searchgasm_base.rb
-- test/test_searchgasm_condition.rb
+- test/test_searchgasm_condition_types.rb
 - test/test_searchgasm_conditions.rb
 - searchgasm.gemspec
 has_rdoc: true
@@ -125,8 +152,7 @@ summary: Orgasmic ActiveRecord searching
 test_files: 
 - test/test_active_record_associations.rb
 - test/test_active_record_base.rb
-- test/test_active_record_protection.rb
 - test/test_helper.rb
 - test/test_searchgasm_base.rb
-- test/test_searchgasm_condition.rb
+- test/test_searchgasm_condition_types.rb
 - test/test_searchgasm_conditions.rb

data/test/test_helper.rb

@@ -1,5 +1,6 @@
 require "test/unit"
 require "rubygems"
+require "ruby-debug"
 require "activerecord"
 require File.dirname(__FILE__) + '/libs/acts_as_tree'
 require File.dirname(__FILE__) + '/libs/rexml_fix'

data/test/test_searchgasm_base.rb

@@ -78,6 +78,34 @@ class TestSearchgasmBase < Test::Unit::TestCase
     assert_kind_of BinaryLogic::Searchgasm::Search::Conditions, search.conditions
   end
   
+  def test_include
+    
+  end
+  
+  def test_limit
+    
+  end
+  
+  def test_options
+    
+  end
+  
+  def test_order_as
+    
+  end
+  
+  def test_order_by
+    
+  end
+  
+  def test_page
+    
+  end
+  
+  def test_reset
+    
+  end
+  
   def test_sanitize
     search = BinaryLogic::Searchgasm::Search::Base.new(Account)
     search.per_page = 2
@@ -88,6 +116,10 @@ class TestSearchgasmBase < Test::Unit::TestCase
     assert_equal search.sanitize, {:include => :users, :offset => 6, :readonly => true, :conditions => ["(\"accounts\".\"name\" LIKE ?) AND (\"users\".\"id\" > ?)", "%Binary%", 2], :limit => 2 }
   end
   
+  def test_scope
+    
+  end
+  
   def test_searching
     search = BinaryLogic::Searchgasm::Search::Base.new(Account)
     search.conditions.name_like = "Binary"

data/test/test_searchgasm_condition_types.rb

@@ -0,0 +1,143 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestSearchgasmConditionTypes < Test::Unit::TestCase
+  fixtures :accounts, :users, :orders
+  
+  def setup
+    setup_db
+    load_fixtures
+  end
+  
+  def teardown
+    teardown_db
+  end
+  
+  def test_condition_name
+    assert_equal "equals", BinaryLogic::Searchgasm::Search::ConditionTypes::EqualsCondition.condition_name
+    assert_equal "keywords", BinaryLogic::Searchgasm::Search::ConditionTypes::KeywordsCondition.condition_name
+    assert_equal "greater_than_or_equal_to", BinaryLogic::Searchgasm::Search::ConditionTypes::GreaterThanOrEqualToCondition.condition_name
+  end
+  
+  def test_string_column
+    
+  end
+  
+  def test_comparable_column
+    
+  end
+  
+  def test_initialize
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::KeywordsCondition.new(Account, Account.columns_hash["name"])
+    assert_equal condition.klass, Account
+    assert_equal condition.column, Account.columns_hash["name"]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::GreaterThanCondition.new(Account, "id")
+    assert_equal condition.column, Account.columns_hash["id"]
+  end
+  
+  def test_explicitly_set_value
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::EqualsCondition.new(Account, Account.columns_hash["name"])
+    assert !condition.explicitly_set_value?
+    condition.value = nil
+    assert condition.explicitly_set_value?
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::KeywordsCondition.new(Account, Account.columns_hash["name"])
+    assert !condition.explicitly_set_value?
+    condition.value = nil
+    assert !condition.explicitly_set_value?
+  end
+  
+  def test_ignore_blanks?
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::EqualsCondition.new(Account, Account.columns_hash["id"])
+    assert !condition.ignore_blanks?
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::KeywordsCondition.new(Account, Account.columns_hash["name"])
+    assert condition.ignore_blanks?
+  end
+
+  def test_sanitize
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::BeginsWithCondition.new(Account, Account.columns_hash["name"])
+    condition.value = "Binary"
+    assert_equal condition.sanitize, ["\"accounts\".\"name\" LIKE ?", "Binary%"]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::ChildOfCondition.new(User)
+    condition.value = User.first.id
+    assert_equal condition.sanitize, ["\"users\".\"parent_id\" = ?", User.first.id]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::ChildOfCondition.new(User)
+    condition.value = User.first
+    assert_equal condition.sanitize, ["\"users\".\"parent_id\" = ?", User.first.id]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::ContainsCondition.new(Account, Account.columns_hash["name"])
+    condition.value = "Binary and blah"
+    assert_equal condition.sanitize, ["\"accounts\".\"name\" LIKE ?", "%Binary and blah%"]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::DescendantOfCondition.new(User)
+    condition.value = User.find(1)
+    assert_equal condition.sanitize, ["\"users\".\"id\" = ? OR \"users\".\"id\" = ?", 2, 3]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::DoesNotEqualCondition.new(Account, Account.columns_hash["id"])
+    condition.value = 12
+    assert_equal condition.sanitize, "\"accounts\".\"id\" != 12"
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::DoesNotEqualCondition.new(Account, Account.columns_hash["id"])
+    condition.value = [1,2,3,4]
+    assert_equal condition.sanitize, "\"accounts\".\"id\" NOT IN (1,2,3,4)"
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::DoesNotEqualCondition.new(Account, Account.columns_hash["id"])
+    condition.value = (1..10)
+    assert_equal condition.sanitize, "\"accounts\".\"id\" NOT BETWEEN 1 AND 10"
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::EndsWithCondition.new(Account, Account.columns_hash["name"])
+    condition.value = "Binary"
+    assert_equal condition.sanitize, ["\"accounts\".\"name\" LIKE ?", "%Binary"]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::EqualsCondition.new(Account, Account.columns_hash["id"])
+    condition.value = 12
+    assert_equal condition.sanitize, "\"accounts\".\"id\" = 12"
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::EqualsCondition.new(Account, Account.columns_hash["id"])
+    condition.value = [1,2,3,4]
+    assert_equal condition.sanitize, "\"accounts\".\"id\" IN (1,2,3,4)"
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::EqualsCondition.new(Account, Account.columns_hash["id"])
+    condition.value = (1..10)
+    assert_equal condition.sanitize, "\"accounts\".\"id\" BETWEEN 1 AND 10"
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::GreaterThanCondition.new(Account, Account.columns_hash["id"])
+    condition.value = 2
+    assert_equal condition.sanitize, ["\"accounts\".\"id\" > ?", 2]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::GreaterThanOrEqualToCondition.new(Account, Account.columns_hash["id"])
+    condition.value = 2
+    assert_equal condition.sanitize, ["\"accounts\".\"id\" >= ?", 2]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::InclusiveDescendantOfCondition.new(User)
+    condition.value = User.find(1)
+    assert_equal condition.sanitize, ["(\"users\".\"id\" = ?) OR (\"users\".\"id\" = ? OR \"users\".\"id\" = ?)", 1, 2, 3]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::KeywordsCondition.new(Account, Account.columns_hash["name"])
+    condition.value = "freedom yeah, freedom YEAH right"
+    assert_equal condition.sanitize, ["\"accounts\".\"name\" LIKE ? AND \"accounts\".\"name\" LIKE ? AND \"accounts\".\"name\" LIKE ?", "%freedom%", "%yeah%", "%right%"]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::KeywordsCondition.new(Account, Account.columns_hash["name"])
+    condition.value = "%^$*(^$)"
+    assert_equal condition.sanitize, nil
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::LessThanCondition.new(Account, Account.columns_hash["id"])
+    condition.value = 2
+    assert_equal condition.sanitize, ["\"accounts\".\"id\" < ?", 2]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::LessThanOrEqualToCondition.new(Account, Account.columns_hash["id"])
+    condition.value = 2
+    assert_equal condition.sanitize, ["\"accounts\".\"id\" <= ?", 2]
+    
+    condition = BinaryLogic::Searchgasm::Search::ConditionTypes::SiblingOfCondition.new(User)
+    condition.value = User.find(2)
+    assert_equal condition.sanitize, ["(\"users\".\"id\" != ?) AND (\"users\".\"parent_id\" = ?)", 2, 1]
+  end
+  
+  def test_value
+    
+  end
+end

data/test/test_searchgasm_conditions.rb

@@ -12,31 +12,39 @@ class TestSearchgasmConditions < Test::Unit::TestCase
     teardown_db
   end
   
+  def test_register_conditions
+    BinaryLogic::Searchgasm::Search::Conditions.register_condition(BinaryLogic::Searchgasm::Search::ConditionTypes::KeywordsCondition)
+    assert [BinaryLogic::Searchgasm::Search::ConditionTypes::KeywordsCondition], BinaryLogic::Searchgasm::Search::Conditions.conditions
+    
+    BinaryLogic::Searchgasm::Search::Conditions.register_condition(BinaryLogic::Searchgasm::Search::ConditionTypes::ContainsCondition)
+    assert [BinaryLogic::Searchgasm::Search::ConditionTypes::KeywordsCondition, BinaryLogic::Searchgasm::Search::ConditionTypes::ContainsCondition], BinaryLogic::Searchgasm::Search::Conditions.conditions
+    
+  end
+  
   def test_initialize
     conditions = BinaryLogic::Searchgasm::Search::Conditions.new(Account, :name_contains => "Binary")
     assert_equal conditions.klass, Account
     assert_equal conditions.name_contains, "Binary"
   end
   
+  def test_conditions_added
+    # test to make sure all of the proper methods were add, testing condition_names basically
+  end
+  
   def test_setting_conditions
     [Account, User, Order].each do |klass|
-      conditions = BinaryLogic::Searchgasm::Search::Conditions.new(klass)
-      
-      klass.columns.each do |column|
-        value = column_value(column)
-        BinaryLogic::Searchgasm::Search::Conditions.condition_types_for_column_type(column.type).each do |condition_type|
-          name = BinaryLogic::Searchgasm::Search::Condition.generate_name(column, condition_type)
-          conditions.send("#{name}=", value)
-          assert_equal conditions.send(name), value
-          BinaryLogic::Searchgasm::Search::Conditions.aliases_for_condition(column, condition_type).each do |alias_condition|
-            conditions.send("#{alias_condition}=", value)
-            assert_equal conditions.send(alias_condition), value
-          end
-        end
+      conditions = klass.new_conditions
+      conditions.condition_names.each do |condition_name|
+        conditions.send("#{condition_name}=", 1)
+        assert_equal 1, conditions.send(condition_name)
       end
     end
   end
   
+  def test_assert_valid_values
+    
+  end
+  
   def test_setting_associations
     conditions = BinaryLogic::Searchgasm::Search::Conditions.new(Account, :users => {:first_name_like => "Ben"})
     assert_equal conditions.users.first_name_like, "Ben"
@@ -127,20 +135,4 @@ class TestSearchgasmConditions < Test::Unit::TestCase
     assert_raise(ArgumentError) { account.users.build_conditions("(DELETE FROM users)") }
     assert_nothing_raised { account.users.build_conditions!("(DELETE FROM users)") }
   end
-  
-  private
-    def column_value(column)
-      case column.type
-      when :string, :text, :binary
-        Array.new(50) { (rand(122-97) + 97).chr }.join
-      when :integer
-        rand(99999)
-      when :float, :decimal
-        rand * 100
-      when :datetime, :timestamp, :time
-        Time.now
-      when :date
-        Date.today
-      end
-    end
 end