erichummel-sunspot 1.2.1a

data/spec/integration/scoped_search_spec.rb

@@ -0,0 +1,354 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'scoped_search' do
+  def self.test_field_type(name, attribute, field, *values)
+    clazz =
+      if values.first.is_a?(Class)
+        values.shift
+      else
+        Post
+      end
+    raise(ArgumentError, 'Please supply five values') unless values.length == 5
+
+    context "with field of type #{name}" do
+      before :all do
+        Sunspot.remove_all
+        @objects = values.map do |value|
+          object = clazz.new(attribute => value)
+          Sunspot.index(object)
+          object
+        end
+        Sunspot.commit
+      end
+
+      it 'should filter by exact match' do
+        Sunspot.search(clazz) { with(field, values[2]) }.results.should == [@objects[2]]
+      end
+
+      it 'should reject by inexact match' do
+        results = Sunspot.search(clazz) { without(field, values[2]) }.results
+        [0, 1, 3, 4].each { |i| results.should include(@objects[i]) }
+        results.should_not include(@objects[2])
+      end
+
+      it 'should filter by less than' do
+        results = Sunspot.search(clazz) { with(field).less_than values[2] }.results
+        (0..2).each { |i| results.should include(@objects[i]) }
+        (3..4).each { |i| results.should_not include(@objects[i]) }
+      end
+
+      it 'should reject by less than' do
+        results = Sunspot.search(clazz) { without(field).less_than values[2] }.results
+        (0..2).each { |i| results.should_not include(@objects[i]) }
+        (3..4).each { |i| results.should include(@objects[i]) }
+      end
+
+      it 'should filter by greater than' do
+        results = Sunspot.search(clazz) { with(field).greater_than values[2] }.results
+        (2..4).each { |i| results.should include(@objects[i]) }
+        (0..1).each { |i| results.should_not include(@objects[i]) }
+      end
+
+      it 'should reject by greater than' do
+        results = Sunspot.search(clazz) { without(field).greater_than values[2] }.results
+        (2..4).each { |i| results.should_not include(@objects[i]) }
+        (0..1).each { |i| results.should include(@objects[i]) }
+      end
+
+      it 'should filter by between' do
+        results = Sunspot.search(clazz) { with(field).between(values[1]..values[3]) }.results
+        (1..3).each { |i| results.should include(@objects[i]) }
+        [0, 4].each { |i| results.should_not include(@objects[i]) }
+      end
+
+      it 'should reject by between' do
+        results = Sunspot.search(clazz) { without(field).between(values[1]..values[3]) }.results
+        (1..3).each { |i| results.should_not include(@objects[i]) }
+        [0, 4].each { |i| results.should include(@objects[i]) }
+      end
+
+      it 'should filter by any of' do
+        results = Sunspot.search(clazz) { with(field).any_of(values.values_at(1, 3)) }.results
+        [1, 3].each { |i| results.should include(@objects[i]) }
+        [0, 2, 4].each { |i| results.should_not include(@objects[i]) }
+      end
+
+      it 'should reject by any of' do
+        results = Sunspot.search(clazz) { without(field).any_of(values.values_at(1, 3)) }.results
+        [1, 3].each { |i| results.should_not include(@objects[i]) }
+        [0, 2, 4].each { |i| results.should include(@objects[i]) }
+      end
+
+      it 'should order by field ascending' do
+        results = Sunspot.search(clazz) { order_by field, :asc }.results
+        results.should == @objects
+      end
+
+      it 'should order by field descending' do
+        results = Sunspot.search(clazz) { order_by field, :desc }.results
+        results.should == @objects.reverse
+      end
+    end
+  end
+
+  test_field_type 'String', :title, :title, 'apple pie', 'banana split', 'cherry tart', 'date pastry', 'eggplant a la mode'
+  test_field_type 'Integer', :blog_id, :blog_id, -2, 0, 3, 12, 20
+  test_field_type 'Long', :hash, :hash, Namespaced::Comment, 2**29, 2**30, 2**31, 2**32, 2**33
+  test_field_type 'Float', :ratings_average, :average_rating, -2.5, 0.0, 3.2, 3.5, 16.0
+  test_field_type 'Double', :average_rating, :average_rating, Namespaced::Comment, -2.5, 0.0, 3.2, 3.5, 16.0
+  test_field_type 'Time', :published_at, :published_at, *(['1970-01-01 00:00:00 UTC', '1983-07-08 04:00:00 UTC', '1983-07-08 02:00:00 -0500',
+                                                           '2005-11-05 10:00:00 UTC', Time.now.to_s].map { |t| Time.parse(t) })
+  test_field_type 'Trie Integer', :size, :size, Photo, -2, 0, 3, 12, 20
+  test_field_type 'Trie Float', :average_rating, :average_rating, Photo, -2.5, 0.0, 3.2, 3.5, 16.0
+  test_field_type 'Trie Time', :created_at, :created_at, Photo, *(['1970-01-01 00:00:00 UTC', '1983-07-08 04:00:00 UTC', '1983-07-08 02:00:00 -0500',
+                                                                   '2005-11-05 10:00:00 UTC', Time.now.to_s].map { |t| Time.parse(t) })
+
+  describe 'Boolean field type' do
+    before :all do
+      Sunspot.remove_all
+      @posts = [Post.new(:featured => true), Post.new(:featured => false), Post.new]
+      Sunspot.index!(@posts)
+    end
+
+    it 'should filter by exact match for true' do
+      Sunspot.search(Post) { with(:featured, true) }.results.should == [@posts[0]]
+    end
+
+    it 'should filter for exact match for false' do
+      Sunspot.search(Post) { with(:featured, false) }.results.should == [@posts[1]]
+    end
+  end
+
+  describe 'reserved words' do
+    %w(AND OR NOT TO).each do |word|
+      it "should successfully search for #{word.inspect}" do
+        Sunspot.index!(post = Post.new(:title => word))
+        Sunspot.search(Post) { with(:title, word) }.results.should == [post]
+      end
+    end
+  end
+
+  describe 'passing nil value to equal' do
+    before :all do
+      Sunspot.remove_all
+      @posts = [Post.new(:title => 'apple'), Post.new]
+      Sunspot.index!(@posts)
+    end
+
+    it 'should filter results without value for field' do
+      Sunspot.search(Post) { with(:title, nil) }.results.should == [@posts[1]]
+    end
+
+    it 'should exclude results without value for field' do
+      Sunspot.search(Post) { without(:title, nil) }.results.should == [@posts[0]]
+    end
+  end
+
+  describe 'prefix searching' do
+    before :each do
+      Sunspot.remove_all
+      @posts = ['test', 'test post', 'some test', 'bogus'].map do |title|
+        Post.new(:title => title)
+      end
+      Sunspot.index!(@posts)
+    end
+
+    it 'should return results whose prefix matches' do
+      Sunspot.search(Post) { with(:title).starting_with('test') }.results.should == @posts[0..1]
+    end
+  end
+
+  describe 'inclusion by identity' do
+    before do
+      @posts = (1..5).map do |i|
+        post = Post.new
+        Sunspot.index(post)
+        post
+      end
+      Sunspot.commit
+    end
+
+    it 'should only return included object' do
+      included_post = @posts.shift
+      Sunspot.search(Post) { with(included_post) }.results.should include(included_post)
+    end
+
+    it 'should not return objects not included' do
+      included_post = @posts.shift
+      for excluded_post in @posts
+        Sunspot.search(Post) { with(included_post) }.results.should_not include(excluded_post)
+      end
+    end
+
+    it 'should return included objects' do
+      included_posts = [@posts.shift, @posts.shift]
+      for included_post in included_posts
+        Sunspot.search(Post) { with(included_posts) }.results.should include(included_post)
+      end
+    end
+  end
+
+  describe 'exclusion by identity' do
+    before do
+      @posts = (1..5).map do |i|
+        post = Post.new
+        Sunspot.index(post)
+        post
+      end
+      Sunspot.commit
+    end
+
+    it 'should not return excluded object' do
+      excluded_post = @posts.shift
+      Sunspot.search(Post) { without(excluded_post) }.results.should_not include(excluded_post)
+    end
+
+    it 'should return objects not excluded' do
+      excluded_post = @posts.shift
+      for included_post in @posts
+        Sunspot.search(Post) { without(excluded_post) }.results.should include(included_post)
+      end
+    end
+
+    it 'should not return excluded objects' do
+      excluded_posts = [@posts.shift, @posts.shift]
+      for excluded_post in excluded_posts
+        Sunspot.search(Post) { without(excluded_posts) }.results.should_not include(excluded_post)
+      end
+    end
+  end
+
+  describe 'connectives' do
+    before :each do
+      Sunspot.remove_all
+    end
+
+    it 'should return results that match any restriction in a disjunction' do
+      posts = (1..3).map { |i| Post.new(:blog_id => i)}
+      Sunspot.index!(posts)
+      Sunspot.search(Post) do
+        any_of do
+          with(:blog_id, 1)
+          with(:blog_id, 2)
+        end
+      end.results.should == posts[0..1]
+    end
+
+    it 'should return results that match a nested conjunction in a disjunction' do
+      posts = [
+        Post.new(:title => 'No', :blog_id => 1),
+        Post.new(:title => 'Yes', :blog_id => 2),
+        Post.new(:title => 'Yes', :blog_id => 3),
+        Post.new(:title => 'No', :blog_id => 2)
+      ]
+      Sunspot.index!(posts)
+      Sunspot.search(Post) do
+        any_of do
+          with(:blog_id, 1)
+          all_of do
+            with(:blog_id, 2)
+            with(:title, 'Yes')
+          end
+        end
+      end.results.should == posts[0..1]
+    end
+
+    it 'should return results that match a conjunction with a negated restriction' do
+      posts = [
+        Post.new(:title => 'No', :blog_id => 1),
+        Post.new(:title => 'Yes', :blog_id => 2),
+        Post.new(:title => 'No', :blog_id => 2)
+      ]
+      Sunspot.index!(posts)
+      search = Sunspot.search(Post) do
+        any_of do
+          with(:blog_id, 1)
+          without(:title, 'No')
+        end
+      end
+      search.results.should == posts[0..1]
+    end
+
+    it 'should return results that match a conjunction with a disjunction with a conjunction with a negated restriction' do
+      posts = [
+        Post.new(:title => 'Yes', :ratings_average => 2.0),
+        Post.new(:blog_id => 1, :category_ids => [4], :ratings_average => 2.0),
+        Post.new(:blog_id => 1),
+        Post.new(:blog_id => 2),
+        Post.new(:blog_id => 1, :ratings_average => 2.0)
+      ]
+      Sunspot.index!(posts)
+      search = Sunspot.search(Post) do
+        any_of do
+          with(:title, 'Yes')
+          all_of do
+            with(:blog_id, 1)
+            any_of do
+              with(:category_ids, 4)
+              without(:average_rating, 2.0)
+            end
+          end
+        end
+      end
+      search.results.should == posts[0..2]
+    end
+
+    it 'should return results that match a disjunction with a negated restriction and a nested disjunction in a conjunction with a negated restriction' do
+      posts = [
+        Post.new,
+        Post.new(:title => 'Yes', :blog_id => 1, :category_ids => [4], :ratings_average => 2.0),
+        Post.new(:title => 'Yes', :blog_id => 1),
+        Post.new(:title => 'Yes'),
+        Post.new(:title => 'Yes', :category_ids => [4], :ratings_average => 2.0),
+        Post.new(:title => 'Yes', :blog_id => 1, :ratings_average => 2.0)
+      ]
+      Sunspot.index!(posts)
+      search = Sunspot.search(Post) do
+        any_of do
+          without(:title, 'Yes')
+          all_of do
+            with(:blog_id, 1)
+            any_of do
+              with(:category_ids, 4)
+              without(:average_rating, 2.0)
+            end
+          end
+        end
+      end
+      search.results.should == posts[0..2]
+    end
+  end
+
+  describe 'multiple column ordering' do
+    before do
+      Sunspot.remove_all
+      @posts = [
+        Post.new(:ratings_average => 2, :title => 'banana'),
+        Post.new(:ratings_average => 2, :title => 'eggplant'),
+        Post.new(:ratings_average => 1, :title => 'apple')
+      ].each { |post| Sunspot.index(post) }
+      Sunspot.commit
+    end
+
+    it 'should order with precedence given' do
+      search = Sunspot.search(Post) do
+        order_by :average_rating, :desc
+        order_by :sort_title, :asc
+      end
+      search.results.should == @posts
+    end
+  end
+
+  describe 'ordering by random' do
+    it 'should order randomly (run this test again if it fails)' do
+      Sunspot.remove_all
+      Sunspot.index!(Array.new(100) { Post.new })
+      result_sets = Array.new(2) do
+        Sunspot.search(Post) { order_by_random }.results.map do |result|
+          result.id
+        end
+      end
+      result_sets[0].should_not == result_sets[1]
+    end
+  end
+end

data/spec/integration/spec_helper.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    Sunspot.config.solr.url = ENV['SOLR_URL'] || 'http://localhost:8983/solr'
+  end
+end

data/spec/integration/stored_fields_spec.rb

@@ -0,0 +1,10 @@
+describe 'stored fields' do
+  before :all do
+    Sunspot.remove_all
+    Sunspot.index!(Post.new(:title => 'A Title'))
+  end
+
+  it 'should return stored fields' do
+    Sunspot.search(Post).hits.first.stored(:title).should == 'A Title'
+  end
+end

data/spec/integration/test_pagination.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'pagination' do
+  before :all do
+    Sunspot.remove_all
+    @posts = (0..19).map do |i|
+      Post.new(:blog_id => i)
+    end
+    Sunspot.index(*@posts)
+  end
+
+  it 'should return all by default' do
+    results = Sunspot.search(Post) { order_by :blog_id }.results
+    results.should == @posts
+  end
+
+  it 'should return first page of 10' do
+    results = Sunspot.search(Post) do
+      order_by :blog_id
+      paginate :page => 1, :per_page => 10
+    end.results
+    results.should == @posts[0,10]
+  end
+
+  it 'should return second page of 10' do
+    results = Sunspot.search(Post) do
+      order_by :blog_id
+      paginate :page => 2, :per_page => 10
+    end.results
+    results.should == @posts[10,10]
+  end
+end

data/spec/mocks/adapters.rb

@@ -0,0 +1,32 @@
+class AbstractModel
+end
+
+class Model < AbstractModel
+end
+
+class AbstractModelInstanceAdapter < Sunspot::Adapters::InstanceAdapter
+end
+
+class AbstractModelDataAccessor < Sunspot::Adapters::DataAccessor
+end
+
+Sunspot::Adapters::InstanceAdapter.register(AbstractModelInstanceAdapter, AbstractModel)
+Sunspot::Adapters::DataAccessor.register(AbstractModelDataAccessor, AbstractModel)
+
+
+module MixInModel
+end
+
+class MixModel
+  include MixInModel
+end
+
+class MixInModelInstanceAdapter < Sunspot::Adapters::InstanceAdapter
+end
+
+class MixInModelDataAccessor < Sunspot::Adapters::DataAccessor
+end
+
+Sunspot::Adapters::InstanceAdapter.register(MixInModelInstanceAdapter, MixInModel)
+Sunspot::Adapters::DataAccessor.register(MixInModelDataAccessor, MixInModel)
+

data/spec/mocks/blog.rb

@@ -0,0 +1,3 @@
+class Blog < MockRecord
+  attr_accessor :name
+end

data/spec/mocks/comment.rb

@@ -0,0 +1,21 @@
+module Namespaced
+  class Comment < MockRecord
+    attr_reader :id
+    attr_accessor :author_name, :published_at, :body, :average_rating, :boost,
+                  :hash
+
+    def custom_float
+      @custom_float ||= {}
+    end
+  end
+end
+
+Sunspot.setup(Namespaced::Comment) do
+  text :body, :author_name
+  string :author_name
+  time :published_at, :trie => true
+  long :hash
+  double :average_rating
+  dynamic_float :custom_float, :multiple => true
+  boost :boost
+end

data/spec/mocks/connection.rb

@@ -0,0 +1,126 @@
+module Mock
+  class ConnectionFactory
+    def connect(opts)
+      if @instance
+        raise('Factory can only create an instance once!')
+      else
+        @instance = Connection.new(opts)
+      end
+    end
+
+    def new(url = nil)
+      if @instance
+        raise('Factory can only create an instance once!')
+      else
+        @instance = Connection.new(url)
+      end
+    end
+
+    def instance
+      @instance ||= Connection.new
+    end
+  end
+
+  class Connection
+    attr_reader :adds, :commits, :optims, :searches, :message, :opts, :deletes_by_query
+    attr_accessor :response
+    attr_writer :expected_handler
+    undef_method :select # annoyingly defined on Object
+
+    def initialize(opts = {})
+      @opts = opts
+      @message = OpenStruct.new
+      @adds, @deletes, @deletes_by_query, @commits, @optims, @searches = Array.new(6) { [] }
+      @expected_handler = :select
+    end
+
+    def add(documents)
+      @adds << Array(documents)
+    end
+
+    def delete_by_id(ids)
+      @deletes << Array(ids)
+    end
+
+    def delete_by_query(query)
+      @deletes_by_query << query
+    end
+
+    def commit
+      @commits << Time.now
+    end
+
+    def optimize
+      @optims << Time.now
+    end
+
+    def request(path, params)
+      unless path == "/#{@expected_handler}"
+        raise ArgumentError, "Expected request to #{@expected_handler} request handler"
+      end
+      @searches << @last_search = params
+      @response || {}
+    end
+
+    def method_missing(method, *args, &block)
+      request("/#{method}", *args)
+    end
+
+    def has_add_with?(*documents)
+      @adds.any? do |add|
+        documents.all? do |document|
+          add.any? do |added|
+            if document.is_a?(Hash)
+              document.all? do |field, value|
+                added.fields_by_name(field).map do |field|
+                  field.value.to_s
+                end == Array(value).map { |v| v.to_s }
+              end
+            else
+              !added.fields_by_name(document).empty?
+            end
+          end
+        end
+      end
+    end
+
+    def has_delete?(*ids)
+      @deletes.any? do |delete|
+        delete & ids == ids
+      end
+    end
+
+    def has_delete_by_query?(query)
+      @deletes_by_query.include?(query)
+    end
+
+    def has_last_search_with?(params)
+      with?(@last_search, params) if @last_search
+    end
+
+    def has_last_search_including?(key, *values)
+      return unless @last_search
+      if @last_search.has_key?(key)
+        if @last_search[key].is_a?(Array)
+          (@last_search[key] & values).length == values.length
+        elsif values.length == 1
+          @last_search[key] == values.first
+        end
+      end
+    end
+
+    private
+
+    def with?(request, params)
+      if params.respond_to?(:all?)
+        params.all? do |key, value|
+          if request.has_key?(key)
+            request[key] == value
+          end
+        end
+      else
+        request.has_key?(params)
+      end
+    end
+  end
+end

data/spec/mocks/mock_adapter.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), 'post')
+
+module MockAdapter
+  class InstanceAdapter < Sunspot::Adapters::InstanceAdapter
+    def id
+      @instance.id
+    end
+  end
+
+  class DataAccessor < Sunspot::Adapters::DataAccessor
+    def load(id)
+      @clazz.get(id.to_i)
+    end
+
+    def load_all(ids)
+      all = @clazz.get_all(ids.map { |id| id.to_i })
+      if @custom_title
+        all.each { |item| item.title = @custom_title }
+      end
+      all
+    end
+
+    def custom_title=(custom_title)
+      @custom_title = custom_title
+    end
+  end
+end
+
+Sunspot::Adapters::DataAccessor.register(MockAdapter::DataAccessor, MockRecord)
+Sunspot::Adapters::InstanceAdapter.register(MockAdapter::InstanceAdapter, MockRecord)

data/spec/mocks/mock_class_sharding_session_proxy.rb

@@ -0,0 +1,24 @@
+class MockClassShardingSessionProxy < Sunspot::SessionProxy::ClassShardingSessionProxy
+  attr_reader :post_session, :photo_session
+
+  def initialize(search_session)
+    super
+    @post_session, @photo_session = Sunspot::Session.new, Sunspot::Session.new
+    @post_session.config.solr.url = 'http://posts.solr.local/solr'
+    @photo_session.config.solr.url = 'http://photos.solr.local/solr'
+    @sessions = {
+      Post => @post_session,
+      Photo => @photo_session
+    }
+  end
+
+  def session_for_class(clazz)
+    @sessions[clazz]
+  end
+
+  def all_sessions
+    @sessions.values.sort do |lsession, rsession|
+      lsession.config.solr.url <=> rsession.config.solr.url
+    end
+  end
+end

data/spec/mocks/mock_record.rb

@@ -0,0 +1,52 @@
+class MockRecord
+  IDS = Hash.new { |h, k| h[k] = 0 }
+  QUERY_COUNTS = Hash.new { |h, k| h[k] = 0 }
+  INSTANCES = Hash.new { |h, k| h[k] = {} }
+
+  attr_reader :id
+
+  class <<self
+    def reset!
+      IDS[name.to_sym] = 0
+      INSTANCES[name.to_sym] = {}
+    end
+  end
+
+  def initialize(attrs = {})
+    @id = attrs.delete(:id) || IDS[self.class.name.to_sym] += 1
+    INSTANCES[self.class.name.to_sym][@id] = self
+    attrs.each_pair do |name, value|
+      send(:"#{name}=", value)
+    end
+  end
+
+  def self.inherited(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def get(id)
+      QUERY_COUNTS[self.name.to_sym] += 1
+      get_instance(id)
+    end
+
+    def get_all(ids)
+      QUERY_COUNTS[self.name.to_sym] += 1
+      ids.map { |id| get_instance(id) }.compact.sort_by { |instance| instance.id }
+    end
+
+    def query_count
+      QUERY_COUNTS[self.name.to_sym]
+    end
+
+    private
+
+    def get_instance(id)
+      INSTANCES[self.name.to_sym][id]
+    end
+  end
+
+  def destroy
+    INSTANCES[self.class.name.to_sym].delete(@id)
+  end
+end