albanpeignier-searchapi 0.1

data/lib/search_api/sql_fragment.rb

@@ -0,0 +1,98 @@
+module SearchApi
+  
+  # Utility class that implements logic for sql fragments (such as ["escaped_sql = ?", dirty_string])
+  
+  class SqlFragment < Array
+    # A class that makes it more easy to manipulate SQL fragments : 'a=1' or ['a=?', 1]
+    #
+    # c = SqlFragment()             => []
+    # c = SqlFragment('')           => []
+    # c = SqlFragment('a=1')        => ["a=1"]
+    # c = SqlFragment(['a=?', 1])   => ["a=?", 1]
+    # c.or(SqlFragment())           => ["a=?", 1]
+    # c.or(SqlFragment('b=2'))      => ["(a=?) OR (b=2)", 1]
+    # c.or!(['b=?', 2])             => ["(a=?) OR (b=?)", 1, 2]
+    # c.and('c=3')                  => ["((a=?) OR (b=?)) AND (c=3)", 1, 2]
+    # c << ['c=?', 3]               => ["((a=?) OR (b=?)) AND (c=?)", 1, 2, 3]
+    # c                             => ["((a=?) OR (b=?)) AND (c=?)", 1, 2, 3]
+  
+    class << self
+      def sanitize(*args)
+        self.new(*args).sanitize
+      end
+    end
+  
+    attr_reader :logical_operator
+  
+    def initialize(*args)
+      if args.length > 1
+      else
+        args = args.first
+      end
+    
+      # default operator is AND
+      self.logical_operator = :and
+    
+      return if args.nil? or args.empty?
+    
+      if args.is_a? Array
+        replace(args)
+      else
+        self.push(args)
+      end
+    end
+  
+    def logical_operator=(logical_operator)
+      @logical_operator = (logical_operator || :and)
+    end
+  
+    def and(inSqlFragment)
+      inSqlFragment = SqlFragment.new(inSqlFragment) unless inSqlFragment.is_a?(SqlFragment)
+      return self if inSqlFragment.empty?
+      return inSqlFragment if empty?
+      SqlFragment(["(#{sqlString}) AND (#{inSqlFragment[0]})"] + sqlParameters + inSqlFragment[1..-1])
+    end
+    def and!(inSqlFragment) replace(self.and(inSqlFragment)) end
+
+    def or(inSqlFragment)
+      inSqlFragment = SqlFragment.new(inSqlFragment) unless inSqlFragment.is_a?(SqlFragment)
+      return self if inSqlFragment.empty?
+      return inSqlFragment if empty?
+      SqlFragment(["(#{sqlString}) OR (#{inSqlFragment[0]})"] + sqlParameters + inSqlFragment[1..-1])
+    end
+    def or!(inSqlFragment) replace(self.or(inSqlFragment)) end
+  
+    def <<(inSqlFragment)
+      case logical_operator
+      when :and!, :and
+        and!(inSqlFragment)
+      when :or!, :or
+        or!(inSqlFragment)
+      else
+        raise "Unsupported logical_operator #{logical_operator.inspect}"
+      end
+    end
+  
+    def not
+      return self if empty?
+      SqlFragment(["NOT(#{sqlString})"]+sqlParameters)
+    end
+  
+    def sqlString
+      self[0]
+    end
+    def sqlParameters
+      self[1..-1]
+    end
+  
+    def sanitize
+      fragment = self
+      ActiveRecord::Base.instance_eval do sanitize_sql(fragment) end
+    end
+  end
+end
+
+
+def SqlFragment(*args)
+  SearchApi::SqlFragment.new(*args)
+end

data/lib/search_api/text_criterion.rb

@@ -0,0 +1,132 @@
+module SearchApi
+  
+  # Utility class that implements fulltext search.
+  #
+  # Includes some Google-like features.
+  
+  class TextCriterion
+    # t = TextCriterion.new('bonjour +les +amis -toto  -"allons bon" define:"salut poulette"')
+    # t.meta_keywords      => {"define"=>["salut poulette"]}
+    # t.mandatory_keywords => ["les", "amis"]
+    # t.optional_keywords  => ["bonjour"],
+    # t.negative_keywords  => ["toto", "allons bon"],
+    # t.positive_keywords  = t.mandatory_keywords+t.optional_keywords
+  
+    # 
+    attr_accessor :meta_keywords
+    attr_accessor :mandatory_keywords
+    attr_accessor :negative_keywords
+    attr_accessor :optional_keywords
+  
+    def initialize(inSearchString='', inOptions= {})
+      # inOptions may contain :
+      # :exclude => string, Regexp, or list of Strings and Regexp to exclude (strings are case insensitive)
+    
+      @options = inOptions
+      @options[:exclude] = [@options[:exclude]] unless @options[:exclude].nil? || (@options[:exclude].is_a?(Enumerable) && !@options[:exclude].is_a?(String))
+      @options[:parse_meta?] = true if @options[:parse_meta?].nil?
+    
+      @meta_keywords = {}
+      @mandatory_keywords = []
+      @negative_keywords = []
+      @optional_keywords = []
+    
+      unless inSearchString.blank?
+    
+        currentMeta = nil
+      
+        splitter = /
+              (
+                  [-+]?\b[^ ":]+\b:?
+              )
+              |
+              (
+                  [-+]?"[^"]*"
+              )
+            /x
+    
+        inSearchString.gsub(/\s+/, ' ').scan(splitter).each { |keyword|
+          keyword=(keyword[0]||keyword[1]).gsub(/"/, '')
+      
+          if currentMeta
+            @meta_keywords[currentMeta] ||= []
+            @meta_keywords[currentMeta] << keyword
+            currentMeta = nil
+          else
+            case keyword
+            when /^-/
+              @negative_keywords << keyword[1..-1] unless exclude_keyword?(keyword[1..-1])
+            when /^\+/
+              @mandatory_keywords << keyword[1..-1] unless exclude_keyword?(keyword[1..-1])
+            when /:$/
+              if @options[:parse_meta?]
+                currentMeta = keyword[0..-2]
+              else
+                @optional_keywords << keyword unless exclude_keyword?(keyword)
+              end
+            else
+              @optional_keywords << keyword unless exclude_keyword?(keyword)
+            end
+          end
+        }
+    
+        # if everything is excluded, look for the whole search string
+        @optional_keywords << inSearchString if @meta_keywords.empty? && @mandatory_keywords.empty? && @negative_keywords.empty? && @optional_keywords.empty?
+      end
+    end
+  
+    def to_s
+      chunks = []
+      chunks += @mandatory_keywords.map { |x| (x =~ / /) ? "+\"#{x}\"" : "+#{x}" } unless @mandatory_keywords.blank?
+      chunks += @negative_keywords.map { |x| (x =~ / /) ? "-\"#{x}\"" : "-#{x}" } unless @negative_keywords.blank?
+      chunks += @optional_keywords.map { |x| (x =~ / /) ? "\"#{x}\"" : x.to_s } unless @optional_keywords.blank?
+      chunks += @meta_keywords.inject([]) { |s, key_value|
+        key, value = key_value
+        if value.is_a?(Array)
+          s += value.map { |x| (x =~ / /) ? "#{key}:\"#{x}\"" : "#{key}:#{x}" }
+        else
+          s << ((value =~ / /) ? "#{key}:\"#{value}\"" : "#{key}:#{value}")
+        end
+        s
+      } if @meta_keywords
+      chunks.join(' ')
+    end
+  
+    def positive_keywords
+      @mandatory_keywords + @optional_keywords
+    end
+  
+    def condition(inFields)
+      conditions = SqlFragment.new
+    
+      conditions << (@mandatory_keywords.inject(SqlFragment.new) { |cv, value|
+        value = "%#{value}%"
+        cv.and(inFields.inject(SqlFragment.new) { |cf, field|
+          cf.or(["#{field} like ?", value])
+        })
+      })
+  
+      conditions << (@negative_keywords.inject(SqlFragment.new) { |cv, value|
+        value = "%#{value}%"
+        cv.and(inFields.inject(SqlFragment.new) { |cf, field|
+          cf.or(["#{field} is not null AND #{field} like ?", value])
+        })
+      }.not)
+  
+      conditions << (@optional_keywords.inject(SqlFragment.new) { |cv, value|
+        value = "%#{value}%"
+        cv.or(inFields.inject(SqlFragment.new) { |cf, field|
+          cf.or(["#{field} like ?", value])
+        })
+      })
+    
+      conditions
+    end
+
+    protected
+      def exclude_keyword?(inKeyword)
+        return false unless @options[:exclude]
+        return @options[:exclude].any? { |exclude| inKeyword =~ (exclude.is_a?(Regexp) ? exclude : Regexp.new(Regexp.escape(exclude), 'i')) }
+      end
+  end
+end

data/searchapi.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{searchapi}
+  s.version = "0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Gwendal Rou\303\251"]
+  s.date = %q{2009-03-31}
+  s.email = ["gr@pierlis.com"]
+  s.extra_rdoc_files = ["Manifest.txt"]
+  s.files = ["MIT-LICENSE", "Manifest.txt", "README", "Rakefile", "db/migrate/001_create_searchable.rb", "init.rb", "install.rb", "lib/search_api.rb", "lib/search_api/active_record_bridge.rb", "lib/search_api/active_record_integration.rb", "lib/search_api/bridge.rb", "lib/search_api/callbacks.rb", "lib/search_api/errors.rb", "lib/search_api/search.rb", "lib/search_api/sql_fragment.rb", "lib/search_api/text_criterion.rb", "searchapi.gemspec", "tasks/search_api_tasks.rake", "test/active_record_bridge_test.rb", "test/active_record_integration_test.rb", "test/bridge_test.rb", "test/callbacks_test.rb", "test/mock_model.rb", "test/search_test.rb", "uninstall.rb"]
+  s.has_rdoc = true
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{searchapi}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Ruby on Rails plugin which purpose is to let the developper define Search APIs for ActiveRecord models}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+      s.add_development_dependency(%q<hoe>, [">= 1.11.0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<hoe>, [">= 1.11.0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<hoe>, [">= 1.11.0"])
+  end
+end

data/tasks/search_api_tasks.rake

@@ -0,0 +1,8 @@
+namespace :searchapi do
+  task :migrate_test_db => :environment do
+    RAILS_ENV = "test" unless defined?(RAILS_ENV)
+
+    ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+    ActiveRecord::Migrator.migrate(File.join(File.dirname(__FILE__), %w{.. db migrate}))
+  end
+end

data/test/active_record_bridge_test.rb

@@ -0,0 +1,488 @@
+require 'test/unit'
+RAILS_ENV = "test" unless defined?(RAILS_ENV)
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+require 'search_api'
+require 'active_record_bridge'
+require 'test/mock_model'
+
+class ActiveRecordBridgeTest < Test::Unit::TestCase
+  
+  def setup
+    begin
+      Searchable.find(:first)
+    rescue
+      raise "run 'rake searchapi_migrate_test_db' in the application directory before running searchapi tests"
+    end
+  end
+  
+  
+  def test_active_record_type_cast
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable, :type_cast => true
+    end
+    
+    search = search_class.new
+    
+    # test number column
+    search.age = '12'
+    assert_equal 12, search.age
+    
+    # test text column
+    search.name = ' thing '
+    assert_equal ' thing ', search.name
+    
+    # test boolean column
+    search.funny = true
+    assert_equal true, search.funny
+    
+    search.funny = false
+    assert_equal false, search.funny
+    
+    search.funny = 1
+    assert_equal true, search.funny
+    
+    search.funny = 0
+    assert_equal false, search.funny
+  end
+  
+
+  def test_empty_search
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+    end
+    
+    assert_equivalent_request search_class,
+                              nil,
+                              nil
+  end
+  
+
+  def test_eq_operator
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :years, :column => :age, :operator => :eq
+    end
+    
+
+    # nil equality must behaves like ActiveRecord::Base
+    assert_equivalent_request search_class,
+                              {:conditions => {:age => nil}},
+                              {:years => nil}
+                              
+    # value equality must behaves like ActiveRecord::Base
+    assert_equivalent_request search_class,
+                              {:conditions => {:age => 50}},
+                              {:years => 50}
+    
+    # array equality must behaves like ActiveRecord::Base
+    assert_equivalent_request search_class,
+                              {:conditions => {:age => [11,23,54,92,42,24,25,26]}},
+                              {:years => [11,23,54,92,42,24,25,26]}
+    
+    # range equality must behaves like ActiveRecord::Base
+    assert_equivalent_request search_class,
+                              {:conditions => {:age => 0..20}},
+                              {:years => 0..20}
+  end
+
+
+  def test_neq_operator
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :not_funny, :column => :funny, :operator => :neq, :type_cast => true
+    end
+    
+
+    # nil negation -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              {:conditions => "funny IS NOT NULL"},
+                              {:not_funny => nil}
+                              
+    # valued negation
+    assert_equivalent_request search_class,
+                              {:conditions => ["funny = ? OR funny IS NULL", false]},
+                              {:not_funny => true}
+    assert_equivalent_request search_class,
+                              {:conditions => ["funny = ? OR funny IS NULL", true]},
+                              {:not_funny => false}
+  end
+  
+  
+  def test_lt_operator
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :limit_age, :column => :age, :operator => :lt
+    end
+    
+
+    # nil upper bound -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:limit_age => nil}
+                              
+    # valued upper bound
+    assert_equivalent_request search_class,
+                              {:conditions => "age < 50"},
+                              {:limit_age => 50}
+  end
+
+
+  def test_lte_operator
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :limit_age, :column => :age, :operator => :lte
+    end
+    
+
+    # nil upper bound -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:limit_age => nil}
+                              
+    # valued upper bound
+    assert_equivalent_request search_class,
+                              {:conditions => "age <= 50"},
+                              {:limit_age => 50}
+  end
+
+
+  def test_gt_operator
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :limit_age, :column => :age, :operator => :gt
+    end
+    
+
+    # nil lower bound -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:limit_age => nil}
+                              
+    # valued lower bound
+    assert_equivalent_request search_class,
+                              {:conditions => "age > 50"},
+                              {:limit_age => 50}
+  end
+
+
+  def test_gte_operator
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :limit_age, :column => :age, :operator => :gte
+    end
+    
+
+    # nil upper bound -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:limit_age => nil}
+                              
+    # valued upper bound
+    assert_equivalent_request search_class,
+                              {:conditions => "age >= 50"},
+                              {:limit_age => 50}
+  end
+
+
+  def test_starts_with_operator
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :name_beginning, :column => :name, :operator => :starts_with, :type_cast => true
+    end
+    
+
+    # nil beginning string -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:name_beginning => nil}
+                              
+    # empty beginning string -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:name_beginning => ''}
+                              
+    # valued beginning string
+    assert_equivalent_request search_class,
+                              {:conditions => ["name like ?", 'Mary%']},
+                              {:name_beginning => 'Mary'}
+  end
+  
+
+  def test_ends_with_operator
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :name_ending, :column => :name, :operator => :ends_with, :type_cast => true
+    end
+    
+
+    # nil ending string -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:name_ending => nil}
+                              
+    # empty ending string -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:name_ending => ''}
+                              
+    # valued ending string
+    assert_equivalent_request search_class,
+                              {:conditions => ["name like ?", '%Ann']},
+                              {:name_ending => 'Ann'}
+  end
+  
+
+  def test_contains_operator
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :name_partial, :column => :name, :operator => :contains, :type_cast => true
+    end
+    
+
+    # nil partial string -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:name_partial => nil}
+                              
+    # empty partial string -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:name_partial => ''}
+                              
+    # valued partial string
+    assert_equivalent_request search_class,
+                              {:conditions => ["name like ?", '%ar%']},
+                              {:name_partial => 'ar'}
+  end
+  
+  
+  def test_full_text_operator
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :keyword, :column => [:name, :city], :operator => :full_text
+    end
+    
+
+    # nil full text search -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:keyword => nil}
+                              
+    # empty full text search -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:keyword => nil}
+                              
+    # valued full text search
+    assert_equivalent_request search_class,
+                              {:conditions => ["((searchables.`name` like ?) OR (searchables.`city` like ?)) OR ((searchables.`name` like ?) OR (searchables.`city` like ?))", "%Mary%", "%Mary%", "%Paris%", "%Paris%"]},
+                              {:keyword => 'Mary Paris'}
+  end
+  
+  
+  def test_multi_column_search
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+    end
+    
+    
+    assert_equivalent_request search_class,
+                              {:conditions => {:age=>(10..30).to_a, :city=>['Paris', 'London']}},
+                              {:age => (10..30).to_a, :city => ['Paris', 'London']}
+  end
+  
+  
+  def test_automatic_search_attribute_builders
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+    end
+    
+    # assert columns names are there
+    assert Searchable.columns.map(&:name).all? { |column_name| search_class.search_attributes.include?(column_name.to_sym)}
+    
+    # assert lower and upper bound search attributes are there
+    assert %w(min_age max_age).all? { |column_name| search_class.search_attributes.include?(column_name.to_sym)}
+  end
+  
+
+  def test_equality_automatic_attributes
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+    end
+    
+
+    # nil equality must behaves like ActiveRecord::Base
+    conditions = {:age => nil}
+    assert_equivalent_request search_class,
+                              {:conditions => conditions},
+                              conditions
+                              
+    # value equality must behaves like ActiveRecord::Base
+    conditions = {:name => 'Mary'}
+    assert_equivalent_request search_class,
+                              {:conditions => conditions},
+                              conditions
+    
+    # array equality must behaves like ActiveRecord::Base
+    conditions = {:age => [11,23,54,92,42,24,25,26]}
+    assert_equivalent_request search_class,
+                              {:conditions => conditions},
+                              conditions
+    
+    # range equality must behaves like ActiveRecord::Base
+    conditions = {:age => 0..20}
+    assert_equivalent_request search_class,
+                              {:conditions => conditions},
+                              conditions
+  end
+  
+
+  def test_lower_bound_automatic_attributes
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+    end
+    
+
+    # nil lower bound -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:min_age => nil}
+                              
+    # valued lower bound
+    assert_equivalent_request search_class,
+                              {:conditions => "age >= 50"},
+                              {:min_age => 50}
+  end
+  
+
+  def test_upper_bound_automatic_attributes
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+    end
+    
+
+    # nil upper bound -> don't search (allow null values)
+    assert_equivalent_request search_class,
+                              nil,
+                              {:max_age => nil}
+                              
+    # valued upper bound
+    assert_equivalent_request search_class,
+                              {:conditions => "age <= 50"},
+                              {:max_age => 50}
+  end
+
+
+  def test_block_defined_search
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :age_limit do |search|
+        { :conditions => ["age < ?", search.age_limit] }
+      end
+    end
+    
+    assert_equivalent_request search_class,
+                              {:conditions => "age < 50"},
+                              {:age_limit => 50}
+  end
+  
+
+  def test_valid_find_options
+    # create a search class
+    search_class = Class.new(::SearchApi::Search::Base)
+    
+    # define some search_accessors
+    search_class.class_eval do
+      model Searchable
+      search_accessor :bad_hash do |search|
+        { :foo => :bar }  # invalid key
+      end
+    end
+    
+    assert_raise ArgumentError do
+      search_class.new(:bad_hash => true).find_options
+    end
+  end
+
+
+  protected
+  
+  def assert_equivalent_request(search_class, traditional_find_options, search_options)
+    traditional_result_ids = Searchable.find(:all, traditional_find_options).map(&:id).sort
+    search_result_ids = Searchable.find(:all, search_class.new(search_options).find_options).map(&:id).sort
+    assert !traditional_result_ids.empty?
+    assert_equal traditional_result_ids, search_result_ids
+  end
+end