outoftime-sunspot 0.8.9 → 0.9.0

data/spec/api/indexer_spec.rb

@@ -2,137 +2,165 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe 'indexer' do
   describe 'when indexing an object' do
-    it 'should index id and type' do
-      connection.should_receive(:add).with([hash_including(:id => "Post #{post.id}", :type => ['Post', 'BaseClass'])])
+    it 'should index id' do
       session.index post
+      connection.should have_add_with(:id => "Post #{post.id}")
+    end
+
+    it 'should index type' do
+      session.index post
+      connection.should have_add_with(:type => ['Post', 'MockRecord'])
+    end
+
+    it 'should index class name' do
+      session.index post
+      connection.should have_add_with(:class_name => 'Post')
     end
 
     it 'should index the array of objects supplied' do
       posts = Array.new(2) { Post.new }
-      connection.should_receive(:add).with([hash_including(:id => "Post #{posts.first.id}", :type => ['Post', 'BaseClass']),
-                                            hash_including(:id => "Post #{posts.last.id}", :type => ['Post', 'BaseClass'])])
       session.index posts
+      connection.should have_add_with(
+        { :id => "Post #{posts.first.id}" },
+        { :id => "Post #{posts.last.id}" }
+      )
     end
 
     it 'should index an array containing more than one type of object' do
       post1, comment, post2 = objects = [Post.new, Namespaced::Comment.new, Post.new]
-      connection.should_receive(:add).with([hash_including(:id => "Post #{post1.id}", :type => ['Post', 'BaseClass']),
-                                            hash_including(:id => "Post #{post2.id}", :type => ['Post', 'BaseClass'])])
-      connection.should_receive(:add).with([hash_including(:id => "Namespaced::Comment #{comment.id}", :type => ['Namespaced::Comment', 'BaseClass'])])
       session.index objects
+      connection.should have_add_with(
+        { :id => "Post #{post1.id}", :type => ['Post', 'MockRecord'] },
+        { :id => "Post #{post2.id}", :type => ['Post', 'MockRecord'] }
+      )
+      connection.should have_add_with(:id => "Namespaced::Comment #{comment.id}", :type => ['Namespaced::Comment', 'MockRecord'])
     end
 
     it 'should index text' do
-      post :title => 'A Title', :body => 'A Post'
-      connection.should_receive(:add).with([hash_including(:title_text => 'A Title', :body_text => 'A Post')])
-      session.index post
+      session.index(post(:title => 'A Title', :body => 'A Post'))
+      connection.should have_add_with(:title_text => 'A Title', :body_text => 'A Post')
+    end
+
+    it 'should index text with boost' do
+      session.index(post(:title => 'A Title'))
+      connection.adds.last.first.field_by_name(:title_text).attrs[:boost].should == 2
+    end
+
+    it 'should index multiple values for a text field' do
+      session.index(post(:body => %w(some title)))
+      connection.should have_add_with(:body_text => %w(some title))
     end
 
     it 'should index text via a virtual field' do
-      post :title => 'backwards'
-      connection.should_receive(:add).with([hash_including(:backwards_title_text => 'backwards'.reverse)])
-      session.index post
+      session.index(post(:title => 'backwards'))
+      connection.should have_add_with(:backwards_title_text => 'backwards'.reverse)
     end
 
-    it 'should correctly index a string attribute field' do
-      post :title => 'A Title'
-      connection.should_receive(:add).with([hash_including(:title_s => 'A Title')])
-      session.index post
+    it 'should correctly index a stored string attribute field' do
+      session.index(post(:title => 'A Title'))
+      connection.should have_add_with(:title_ss => 'A Title')
     end
 
     it 'should correctly index an integer attribute field' do
-      post :blog_id => 4
-      connection.should_receive(:add).with([hash_including(:blog_id_i => '4')])
-      session.index post
+      session.index(post(:blog_id => 4))
+      connection.should have_add_with(:blog_id_i => '4')
     end
 
     it 'should correctly index a float attribute field' do
-      post :ratings_average => 2.23
-      connection.should_receive(:add).with([hash_including(:average_rating_f => '2.23')])
-      session.index post
+      session.index(post(:ratings_average => 2.23))
+      connection.should have_add_with(:average_rating_f => '2.23')
     end
 
     it 'should allow indexing by a multiple-value field' do
-      post :category_ids => [3, 14]
-      connection.should_receive(:add).with([hash_including(:category_ids_im => ['3', '14'])])
-      session.index post
+      session.index(post(:category_ids => [3, 14]))
+      connection.should have_add_with(:category_ids_im => ['3', '14'])
     end
 
     it 'should correctly index a time field' do
-      post :published_at => Time.parse('1983-07-08 05:00:00 -0400')
-      connection.should_receive(:add).with([hash_including(:published_at_d => '1983-07-08T09:00:00Z')])
-      session.index post
+      session.index(
+        post(:published_at => Time.parse('1983-07-08 05:00:00 -0400'))
+      )
+      connection.should have_add_with(:published_at_d => '1983-07-08T09:00:00Z')
+    end
+
+    it 'should correctly index a date field' do
+      session.index(post(:expire_date => Date.new(2009, 07, 13)))
+      connection.should have_add_with(:expire_date_d => '2009-07-13T00:00:00Z')
     end
 
     it 'should correctly index a boolean field' do
-      post :featured => true
-      connection.should_receive(:add).with([hash_including(:featured_b => 'true')])
-      session.index post
+      session.index(post(:featured => true))
+      connection.should have_add_with(:featured_b => 'true')
     end
 
     it 'should correctly index a false boolean field' do
-      post :featured => false
-      connection.should_receive(:add).with([hash_including(:featured_b => 'false')])
-      session.index post
+      session.index(post(:featured => false))
+      connection.should have_add_with(:featured_b => 'false')
     end
 
     it 'should not index a nil boolean field' do
-      post
-      connection.should_receive(:add).with([hash_not_including(:featured_b)])
-      session.index post
+      session.index(post)
+      connection.should_not have_add_with(:featured_b)
     end
 
     it 'should correctly index a virtual field' do
-      post :title => 'The Blog Post'
-      connection.should_receive(:add).with([hash_including(:sort_title_s => 'blog post')])
-      session.index post
+      session.index(post(:title => 'The Blog Post'))
+      connection.should have_add_with(:sort_title_s => 'blog post')
     end
 
     it 'should correctly index an external virtual field' do
-      post :category_ids => [1, 2, 3]
-      connection.should_receive(:add).with([hash_including(:primary_category_id_i => '1')])
-      session.index post
+      session.index(post(:category_ids => [1, 2, 3]))
+      connection.should have_add_with(:primary_category_id_i => '1')
     end
 
     it 'should correctly index a field that is defined on a superclass' do
-      Sunspot.setup(BaseClass) { string :author_name }
-      post :author_name => 'Mat Brown'
-      connection.should_receive(:add).with([hash_including(:author_name_s => 'Mat Brown')])
-      session.index post
+      Sunspot.setup(MockRecord) { string :author_name }
+      session.index(post(:author_name => 'Mat Brown'))
+      connection.should have_add_with(:author_name_s => 'Mat Brown')
     end
 
     it 'should commit immediately after index! called' do
-      post :title => 'The Blog Post'
       connection.should_receive(:add).ordered
       connection.should_receive(:commit).ordered
       session.index!(post)
     end
 
     it 'should remove an object from the index' do
-      connection.should_receive(:delete).with("Post #{post.id}")
       session.remove(post)
+      connection.should have_delete("Post #{post.id}")
+    end
+
+    it 'should remove an object by type and id' do
+      session.remove_by_id(Post, 1)
+      connection.should have_delete('Post 1')
+    end
+
+    it 'should remove an object by type and id and immediately commit' do
+      connection.should_receive(:delete_by_id).with('Post 1').ordered
+      connection.should_receive(:commit).ordered
+      session.remove_by_id!(Post, 1)
     end
 
     it 'should remove an object from the index and immediately commit' do
-      connection.should_receive(:delete).with("Post #{post.id}").ordered
+      connection.should_receive(:delete_by_id).ordered
       connection.should_receive(:commit).ordered
       session.remove!(post)
     end
 
     it 'should remove everything from the index' do
-      connection.should_receive(:delete_by_query).with("type:[* TO *]")
       session.remove_all
+      connection.should have_delete_by_query("type:[* TO *]")
     end
 
     it 'should remove everything from the index and immediately commit' do
-      connection.should_receive(:delete_by_query).with("type:[* TO *]").ordered
+      connection.should_receive(:delete_by_query).ordered
       connection.should_receive(:commit).ordered
       session.remove_all!
     end
 
     it 'should be able to remove everything of a given class from the index' do
-      connection.should_receive(:delete_by_query).with("type:Post")
       session.remove_all(Post)
+      connection.should have_delete_by_query("type:Post")
     end
 
     it 'should correctly escape namespaced classes when removing everything from the index' do
@@ -141,44 +169,86 @@ describe 'indexer' do
     end
   end
 
+  describe 'batches' do
+    it 'should send all batched adds in a single request' do
+      posts = Array.new(2) { Post.new }
+      session.batch do
+        for post in posts
+          session.index(post)
+        end
+      end
+      connection.adds.length.should == 1
+    end
+
+    it 'should add all batched adds' do
+      posts = Array.new(2) { Post.new }
+      session.batch do
+        for post in posts
+          session.index(post)
+        end
+      end
+      add = connection.adds.last
+      connection.adds.first.map { |add| add.field_by_name(:id).value }.should ==
+        posts.map { |post| "Post #{post.id}" }
+    end
+
+    it 'should not index changes to models that happen after index call' do
+      post = Post.new
+      session.batch do
+        session.index(post)
+        post.title = 'Title'
+      end
+      connection.adds.first.first.field_by_name(:title_ss).should be_nil
+    end
+  end
+
   describe 'dynamic fields' do
     it 'should index string data' do
-      post(:custom_string => { :test => 'string' })
-      connection.should_receive(:add).with([hash_including(:"custom_string:test_s" => 'string')])
-      session.index(post)
+      session.index(post(:custom_string => { :test => 'string' }))
+      connection.should have_add_with(:"custom_string:test_s" => 'string')
     end
 
     it 'should index integer data with virtual accessor' do
-      post(:category_ids => [1, 2])
-      connection.should_receive(:add).with([hash_including(:"custom_integer:1_i" => '1', :"custom_integer:2_i" => '1')])
-      session.index(post)
+      session.index(post(:category_ids => [1, 2]))
+      connection.should have_add_with(:"custom_integer:1_i" => '1', :"custom_integer:2_i" => '1')
     end
 
     it 'should index float data' do
-      post(:custom_fl => { :test => 1.5 })
-      connection.should_receive(:add).with([hash_including(:"custom_float:test_fm" => '1.5')])
-      session.index(post)
+      session.index(post(:custom_fl => { :test => 1.5 }))
+      connection.should have_add_with(:"custom_float:test_fm" => '1.5')
     end
 
     it 'should index time data' do
-      post(:custom_time => { :test => Time.parse('2009-05-18 18:05:00 -0400') })
-      connection.should_receive(:add).with([hash_including(:"custom_time:test_d" => '2009-05-18T22:05:00Z')])
-      session.index(post)
+      session.index(post(:custom_time => { :test => Time.parse('2009-05-18 18:05:00 -0400') }))
+      connection.should have_add_with(:"custom_time:test_d" => '2009-05-18T22:05:00Z')
     end
 
     it 'should index boolean data' do
-      post(:custom_boolean => { :test => false })
-      connection.should_receive(:add).with([hash_including(:"custom_boolean:test_b" => 'false')])
-      session.index(post)
+      session.index(post(:custom_boolean => { :test => false }))
+      connection.should have_add_with(:"custom_boolean:test_b" => 'false')
     end
 
     it 'should index multiple values for a field' do
-      post(:custom_fl => { :test => [1.0, 2.1, 3.2] })
-      connection.should_receive(:add).with([hash_including(:"custom_float:test_fm" => %w(1.0 2.1 3.2))])
-      session.index(post)
+      session.index(post(:custom_fl => { :test => [1.0, 2.1, 3.2] }))
+      connection.should have_add_with(:"custom_float:test_fm" => %w(1.0 2.1 3.2))
     end
   end
 
+  it 'should index document level boost using block' do
+    session.index(post(:ratings_average => 4.0))
+    connection.adds.last.first.attrs[:boost].should == 1.25
+  end
+
+  it 'should index document level boost using attribute' do
+    session.index(Namespaced::Comment.new(:boost => 1.5))
+    connection.adds.last.first.attrs[:boost].should == 1.5
+  end
+
+  it 'should index document level boost defined statically' do
+    session.index(Photo.new)
+    connection.adds.last.first.attrs[:boost].should == 0.75
+  end
+
   it 'should throw a NoMethodError only if a nonexistent type is defined' do
     lambda { Sunspot.setup(Post) { string :author_name }}.should_not raise_error
     lambda { Sunspot.setup(Post) { bogus :journey }}.should raise_error(NoMethodError)
@@ -189,7 +259,7 @@ describe 'indexer' do
   end
 
   it 'should throw an ArgumentError if an attempt is made to index an object that has no configuration' do
-    lambda { session.index(Time.now) }.should raise_error(Sunspot::NoSetupError)
+    lambda { session.index(Blog.new) }.should raise_error(Sunspot::NoSetupError)
   end
 
   it 'should throw an ArgumentError if single-value field tries to index multiple values' do
@@ -216,7 +286,7 @@ describe 'indexer' do
   end
 
   def connection
-    @connection ||= mock('connection')
+    @connection ||= Mock::Connection.new
   end
 
   def session
@@ -226,4 +296,16 @@ describe 'indexer' do
   def post(attrs = {})
     @post ||= Post.new(attrs)
   end
+
+  def last_add
+    @connection.adds.last
+  end
+
+  def value_in_last_document_for(field_name)
+    @connection.adds.last.last.field_by_name(field_name).value
+  end
+
+  def values_in_last_document_for(field_name)
+    @connection.adds.last.last.fields_by_name(field_name).map { |field| field.value }
+  end
 end

data/spec/api/query_spec.rb

@@ -3,127 +3,151 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 describe Sunspot::Query do
   before :each do
     @config ||= Sunspot::Configuration.build
-    @connection ||= mock('connection')
+    @connection ||= Mock::Connection.new
     @session ||= Sunspot::Session.new(@config, @connection)
     @search = @session.new_search(Post)
   end
 
-  after :each do
-    @search.execute!
-  end
-
   it 'should perform keyword search' do
     @search.query.keywords = 'keyword search'
-    @connection.should_receive(:query).with('(keyword search) AND (type:Post)', hash_including)
+    @search.execute!
+    @connection.should have_last_search_with(:q => 'keyword search')
   end
 
   it 'should add equality restriction' do
     @search.query.add_restriction(:title, :equal_to, 'My Pet Post')
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['title_s:My\ Pet\ Post']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['title_ss:My\ Pet\ Post'])
   end
 
   it 'should add less than restriction' do
     @search.query.add_restriction(:average_rating, :less_than, 3.0)
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['average_rating_f:[* TO 3\.0]']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['average_rating_f:[* TO 3\.0]'])
   end
 
   it 'should add greater than restriction' do
     @search.query.add_restriction(:average_rating, :greater_than, 3.0)
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['average_rating_f:[3\.0 TO *]']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['average_rating_f:[3\.0 TO *]'])
   end
 
   it 'should add between restriction' do
     @search.query.add_restriction(:average_rating, :between, 2.0..4.0)
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['average_rating_f:[2\.0 TO 4\.0]']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['average_rating_f:[2\.0 TO 4\.0]'])
   end
 
   it 'should add any restriction' do
     @search.query.add_restriction(:category_ids, :any_of, [2, 7, 12])
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['category_ids_im:(2 OR 7 OR 12)']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['category_ids_im:(2 OR 7 OR 12)'])
   end
 
   it 'should add all restriction' do
     @search.query.add_restriction(:category_ids, :all_of, [2, 7, 12])
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['category_ids_im:(2 AND 7 AND 12)']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['category_ids_im:(2 AND 7 AND 12)'])
   end
 
   it 'should negate restriction' do
     @search.query.add_negated_restriction(:title, :equal_to, 'Bad Post')
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['-title_s:Bad\ Post']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['-title_ss:Bad\ Post'])
   end
 
   it 'should exclude instance' do
     post = Post.new
     @search.query.exclude_instance(post)
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ["-id:Post\\ #{post.id}"]))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ["-id:Post\\ #{post.id}"])
   end
 
   it 'should paginate using default per-page' do
     @search.query.paginate(2)
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:rows => 30, :start => 30))
+    @search.execute!
+    @connection.should have_last_search_with(:rows => 30)
   end
   
   it 'should paginate using provided per-page' do
     @search.query.paginate(4, 15)
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:rows => 15, :start => 45))
+    @search.execute!
+    @connection.should have_last_search_with(:rows => 15, :start => 45)
   end
 
   it 'should order ascending by default' do
     @search.query.order_by(:average_rating)
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:sort => [{ :average_rating_f => :ascending }]))
+    @search.execute!
+    @connection.should have_last_search_with(:sort => 'average_rating_f asc')
   end
 
   it 'should order descending if specified' do
     @search.query.order_by(:average_rating, :desc)
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:sort => [{ :average_rating_f => :descending }]))
+    @search.execute!
+    @connection.should have_last_search_with(:sort => 'average_rating_f desc')
   end
 
   it 'should request a field facet' do
     @search.query.add_field_facet(:category_ids)
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:facets => { :fields => %w(category_ids_im) }))
+    @search.execute!
+    @connection.should have_last_search_with(:"facet.field" => %w(category_ids_im))
   end
 
   it 'should restrict by dynamic string field with equality restriction' do
     @search.query.dynamic_query(:custom_string).add_restriction(:test, :equal_to, 'string')
-    @connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['custom_string\:test_s:string']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['custom_string\:test_s:string'])
   end
 
   it 'should restrict by dynamic integer field with less than restriction' do
     @search.query.dynamic_query(:custom_integer).add_restriction(:test, :less_than, 1)
-    @connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_integer\:test_i:[* TO 1]']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['custom_integer\:test_i:[* TO 1]'])
   end
 
   it 'should restrict by dynamic float field with between restriction' do
     @search.query.dynamic_query(:custom_float).add_restriction(:test, :between, 2.2..3.3)
-    @connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_float\:test_fm:[2\.2 TO 3\.3]']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['custom_float\:test_fm:[2\.2 TO 3\.3]'])
   end
 
   it 'should restrict by dynamic time field with any of restriction' do
-    @search.query.dynamic_query(:custom_time).add_restriction(:test, :any_of,
-                                                              [Time.parse('2009-02-10 14:00:00 UTC'),
-                                                               Time.parse('2009-02-13 18:00:00 UTC')])
-    @connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_time\:test_d:(2009\-02\-10T14\:00\:00Z OR 2009\-02\-13T18\:00\:00Z)']))
+    @search.query.dynamic_query(:custom_time).add_restriction(
+      :test,
+      :any_of,
+      [Time.parse('2009-02-10 14:00:00 UTC'),
+       Time.parse('2009-02-13 18:00:00 UTC')]
+    )
+    @search.execute!
+    @connection.should have_last_search_with(
+      :fq => ['custom_time\:test_d:(2009\-02\-10T14\:00\:00Z OR 2009\-02\-13T18\:00\:00Z)']
+    )
   end
 
   it 'should restrict by dynamic boolean field with equality restriction' do
     @search.query.dynamic_query(:custom_boolean).add_restriction(:test, :equal_to, false)
-    @connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['custom_boolean\:test_b:false']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['custom_boolean\:test_b:false'])
   end
 
   it 'should negate a dynamic field restriction' do
     @search.query.dynamic_query(:custom_string).add_negated_restriction(:test, :equal_to, 'foo')
-    @connection.should_receive(:query).with(anything, hash_including(:filter_queries => ['-custom_string\:test_s:foo']))
+    @search.execute!
+    @connection.should have_last_search_with(:fq => ['-custom_string\:test_s:foo'])
   end
 
   it 'should order by a dynamic field' do
     @search.query.dynamic_query(:custom_integer).order_by(:test, :desc)
-    @connection.should_receive(:query).with(anything, hash_including(:sort => [{ :"custom_integer:test_i" => :descending }]))
+    @search.execute!
+    @connection.should have_last_search_with(:sort => 'custom_integer:test_i desc')
   end
 
   it 'should order by a dynamic field and static field, with given precedence' do
     @search.query.dynamic_query(:custom_integer).order_by(:test, :desc)
     @search.query.order_by(:sort_title, :asc)
-    @connection.should_receive(:query).with(anything, hash_including(:sort => [{ :"custom_integer:test_i" => :descending },
-                                                                               { :sort_title_s => :ascending}]))
+    @search.execute!
+    @connection.should have_last_search_with(
+      :sort => 'custom_integer:test_i desc, sort_title_s asc'
+    )
   end
 end