outoftime-sunspot 0.0.1 → 0.0.2

data/spec/api/build_search_spec.rb

@@ -0,0 +1,195 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'Search' do
+  it 'should search by keywords' do
+    connection.should_receive(:query).with('(keyword search) AND (type:Post)', hash_including).twice
+    session.search Post, :keywords => 'keyword search'
+    session.search Post do
+      keywords 'keyword search'
+    end
+  end
+
+  it 'should scope by exact match with a string' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['title_s:My\ Pet\ Post'])).twice
+    session.search Post, :conditions => { :title => 'My Pet Post' }
+    session.search Post do
+      with.title 'My Pet Post'
+    end
+  end
+
+  it 'should ignore nonexistant fields in hash scope' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => []))
+    session.search Post, :conditions => { :bogus => 'Field' }
+  end
+
+  it 'should raise an ArgumentError for nonexistant fields in block scope' do
+    lambda do 
+      session.search Post do
+        with.bogus 'Field'
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should scope by exact match with time' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['published_at_d:1983\-07\-08T09\:00\:00Z'])).twice
+    time = Time.parse('1983-07-08 05:00:00 -0400')
+    session.search Post, :conditions => { :published_at => time }
+    session.search Post do
+      with.published_at time
+    end
+  end
+
+  it 'should scope by less than match with float' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['average_rating_f:[* TO 3\.0]']))
+    session.search Post do
+      with.average_rating.less_than 3.0
+    end
+  end
+
+  it 'should scope by greater than match with float' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['average_rating_f:[3\.0 TO *]']))
+    session.search Post do
+      with.average_rating.greater_than 3.0
+    end
+  end
+
+  it 'should scope by between match with float' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['average_rating_f:[2\.0 TO 4\.0]']))
+    session.search Post do
+      with.average_rating.between 2.0..4.0
+    end
+  end
+
+  it 'should scope by any match with integer' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['category_ids_im:(2 OR 7 OR 12)'])).twice
+    session.search Post, :conditions => { :category_ids => [2, 7, 12] }
+    session.search Post do
+      with.category_ids.any_of [2, 7, 12]
+    end
+  end
+
+  it 'should scope by all match with integer' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:filter_queries => ['category_ids_im:(2 AND 7 AND 12)']))
+    session.search Post do
+      with.category_ids.all_of [2, 7, 12]
+    end
+  end
+
+  it 'should paginate using default per_page when page not provided' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:rows => 30))
+    session.search Post
+  end
+
+  it 'should paginate using default per_page when page provided' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:rows => 30, :start => 30)).twice
+    session.search Post, :page => 2
+    session.search Post do
+      paginate :page => 2
+    end
+  end
+
+  it 'should paginate using provided per_page' do
+    connection.should_receive(:query).with('(type:Post)', :filter_queries => [], :rows => 15, :start => 45).twice
+    session.search Post, :page => 4, :per_page => 15
+    session.search Post do
+      paginate :page => 4, :per_page => 15
+    end
+  end
+
+  it 'should order' do
+    connection.should_receive(:query).with('(type:Post)', hash_including(:sort => [{ :average_rating_f => :descending }])).twice
+    session.search Post, :order => 'average_rating desc'
+    session.search Post do
+      order_by :average_rating, :desc
+    end
+  end
+
+  it 'should build search for multiple types' do
+    connection.should_receive(:query).with('(type:(Post OR Comment))', hash_including)
+    session.search(Post, Comment)
+  end
+
+  it 'should allow search on fields common to all types' do
+    connection.should_receive(:query).with('(type:(Post OR Comment))', hash_including(:filter_queries => ['published_at_d:1983\-07\-08T09\:00\:00Z'])).twice
+    time = Time.parse('1983-07-08 05:00:00 -0400')
+    session.search Post, Comment, :conditions => { :published_at => time }
+    session.search Post, Comment do
+      with.published_at time
+    end
+  end
+
+  it 'should raise exception if search scoped to field not common to all types' do
+    lambda do
+      session.search Post, Comment do
+        with.blog_id 1
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should raise exception if search scoped to field configured differently between types' do
+    lambda do
+      session.search Post, Comment do
+        with.average_rating 2.2 # this is a float in Post but an integer in Comment
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should ignore condition if field is not common to all types' do
+    connection.should_receive(:query).with('(type:(Post OR Comment))', hash_including(:filter_queries => []))    
+    session.search Post, Comment, :conditions => { :blog_id => 1 }
+  end
+
+  it 'should raise ArgumentError if bogus field scoped' do
+    lambda do
+      session.search Post do
+        with.bogus.equal_to :field
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should raise NoMethodError if bogus operator referenced' do
+    lambda do
+      session.search Post do
+        with.category_ids.resembling :bogus_condition
+      end
+    end.should raise_error(NoMethodError)
+  end
+
+  it 'should raise ArgumentError if no :page argument given to paginate' do
+    lambda do
+      session.search Post do
+        paginate
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should raise ArgumentError if bogus argument given to paginate' do
+    lambda do
+      session.search Post do
+        paginate :page => 4, :ugly => :puppy
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should raise NoMethodError if more than one argument passed to scope method' do # or should it?
+    lambda do
+      session.search Post do
+        with.category_ids 4, 5
+      end
+    end.should raise_error(NoMethodError)
+  end
+
+  private
+
+  def config
+    @config ||= Sunspot::Configuration.build
+  end
+
+  def connection
+    @connection ||= mock('connection')
+  end
+
+  def session
+    @session ||= Sunspot::Session.new(config, connection)
+  end
+end

data/spec/api/indexer_spec.rb

@@ -0,0 +1,112 @@
+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']))
+      session.index post
+    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
+    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
+    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
+    end
+
+    it 'should correctly index a float attribute field' do
+      post :average_rating => 2.23
+      connection.should_receive(:add).with(hash_including(:average_rating_f => '2.23'))
+      session.index post
+    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
+    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
+    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
+    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
+    end
+
+    it 'should remove an object from the index' do
+      connection.should_receive(:delete).with("Post #{post.id}")
+      session.remove(post)
+    end
+
+    it 'should be able to remove everything from the index' do
+      connection.should_receive(:delete_by_query).with("type:[* TO *]")
+      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)
+    end
+  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)
+  end
+
+  it 'should throw a NoMethodError if a nonexistent field argument is passed' do
+    lambda { Sunspot.setup(Post) { string :author_name, :bogus => :argument }}.should raise_error(ArgumentError)
+  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(ArgumentError)
+  end
+
+  it 'should throw an ArgumentError if single-value field tries to index multiple values' do
+    lambda do
+      Sunspot.setup(Post) { string :author_name }
+      session.index(post(:author_name => ['Mat Brown', 'Matthew Brown']))
+    end.should raise_error(ArgumentError)
+  end
+
+  private
+
+  def config
+    Sunspot::Configuration.build
+  end
+
+  def connection
+    @connection ||= mock('connection')
+  end
+
+  def session
+    @session ||= Sunspot::Session.new(config, connection)
+  end
+
+  def post(attrs = {})
+    @post ||= Post.new(attrs)
+  end
+end

data/spec/api/search_retrieval_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'retrieving search' do
+  it 'should load search result' do
+    post = Post.new
+    stub_results(post)
+    session.search(Post).results.should == [post]
+  end
+
+  it 'should load multiple search results in order' do
+    post_1, post_2 = Post.new, Post.new
+    stub_results(post_1, post_2)
+    session.search(Post).results.should == [post_1, post_2]
+    stub_results(post_2, post_1)
+    session.search(Post).results.should == [post_2, post_1]
+  end
+
+  it 'should return search total as attribute of results if pagination is provided' do
+    stub_results(Post.new, 4)
+    session.search(Post, :page => 1).results.total_entries.should == 4
+  end
+
+  it 'should return vanilla array if pagination is provided but WillPaginate is not available' do
+    stub_results(Post.new)
+    without_class(WillPaginate) do
+      session.search(Post, :page => 1).results.should_not respond_to(:total_entries)
+    end
+  end
+
+  it 'should return total' do
+    stub_results(Post.new, Post.new, 4)
+    session.search(Post, :page => 1).total.should == 4
+  end
+
+  private
+
+  def stub_results(*results)
+    total_hits = if results.last.is_a?(Integer) then results.pop 
+                 else results.length
+                 end
+    response = mock('response')
+    response.stub!(:hits).and_return(results.map { |result| { 'id' => "#{result.class.name} #{result.id}" }})
+    response.stub!(:total_hits).and_return(total_hits)
+    connection.stub!(:query).and_return(response)
+  end
+
+  def config
+    @config ||= Sunspot::Configuration.build
+
+  end
+
+  def connection
+    @connection ||= mock('connection')
+  end
+
+  def session
+    @session ||= Sunspot::Session.new(config, connection)
+  end
+end

data/spec/api/session_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'Session' do
+  context 'using singleton session' do
+    before :each do
+      Sunspot.reset!
+      connection.should_receive(:add)
+      connection.should_receive(:query)
+    end
+
+    it 'should open connection with defaults if nothing specified' do
+      Solr::Connection.stub!(:new).with('http://localhost:8983/solr', :autocommit => :on).and_return(connection)
+      Sunspot.index(Post.new)
+      Sunspot.search(Post)
+    end
+
+    it 'should open a connection with custom host' do
+      Solr::Connection.stub!(:new).with('http://127.0.0.1:8981/solr', :autocommit => :on).and_return(connection)
+      Sunspot.config.solr.url = 'http://127.0.0.1:8981/solr'
+      Sunspot.index(Post.new)
+      Sunspot.search(Post)
+    end
+  end
+
+  context 'using custom session' do
+    before :each do
+      connection.should_receive(:add)
+      connection.should_receive(:query)
+    end
+
+    it 'should open a connection with custom host' do
+      Solr::Connection.stub!(:new).with('http://127.0.0.1:8982/solr', :autocommit => :on).and_return(connection)
+      session = Sunspot::Session.new do |config|
+        config.solr.url = 'http://127.0.0.1:8982/solr'
+      end
+      session.index(Post.new)
+      session.search(Post)
+    end
+  end
+
+  def connection
+    @connection ||= stub_everything('Connection')
+  end
+end

data/spec/api/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')

data/spec/api/standard_search_builder_spec.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'standard search builder' do
+  before :each do
+    stub_results
+  end
+
+  it 'should give access to order through hash and object' do
+    search = session.search(Post, :order => 'sort_title asc')
+    search.builder.params[:order].should == 'sort_title asc'
+    search.builder.order.should == 'sort_title asc'
+  end
+
+  it 'should give nil order if no order set' do
+    search = session.search(Post)
+    search.builder.params.should have_key(:order)
+    search.builder.params[:order].should be_nil
+    search.builder.order.should be_nil
+  end
+
+  it 'should give access to page and per-page through hash and object' do
+    search = session.search(Post, :page => 2, :per_page => 15)
+    search.builder.params[:page].should == 2
+    search.builder.params[:per_page].should == 15
+    search.builder.page.should == 2
+    search.builder.per_page.should == 15
+  end
+
+  it 'should give access to keywords' do
+    search = session.search(Post, :keywords => 'some keywords')
+    search.builder.params[:keywords].should == 'some keywords'
+    search.builder.keywords.should == 'some keywords'
+  end
+
+  it 'should have nil keywords if no keywords given' do
+    search = session.search(Post)
+    search.builder.params.should have_key(:keywords)
+    search.builder.params[:keywords].should be_nil
+    search.builder.keywords.should be_nil
+  end
+
+  it 'should give access to conditions' do
+    search = session.search(Post, :conditions => { :blog_id => 1 })
+    search.builder.params[:conditions][:blog_id].should == 1
+    search.builder.conditions.blog_id.should == 1
+  end
+
+  it 'should have nil values for fields with unspecified conditions' do
+    search = session.search(Post)
+    %w(title blog_id category_ids average_rating published_at sort_title).each do |field_name|
+      search.builder.params[:conditions].should have_key(field_name.to_sym)
+      search.builder.params[:conditions][field_name.to_sym].should == nil
+      search.builder.conditions.should respond_to(field_name)
+      search.builder.conditions.send(field_name).should == nil
+    end
+  end
+
+  private
+
+  def stub_results(*results)
+    response = mock('response', :hits => [], :total_hits => 0)
+    connection.stub!(:query).and_return(response)
+  end
+
+  def config
+    @config ||= Sunspot::Configuration.build
+  end
+
+  def connection
+    @connection ||= mock('connection')
+  end
+
+  def session
+    @session ||= Sunspot::Session.new(config, connection)
+  end
+end

data/{test/integration/test_field_types.rb → spec/integration/field_types_spec.rb}

@@ -1,6 +1,6 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
+require File.join(File.dirname(__FILE__), 'spec_helper')
 
-class TestFieldTypes < Test::Unit::TestCase
+describe 'field types' do
   def self.test_field_type(name, field, *values)
     raise(ArgumentError, 'Please supply five values') unless values.length == 5
 
@@ -14,40 +14,40 @@ class TestFieldTypes < Test::Unit::TestCase
         end
       end
 
-      test 'should filter by exact match' do
+      it 'should filter by exact match' do
         Sunspot.search(Post) { with.send(field, values[2]) }.results.should == [@posts[2]]
       end
 
-      test 'should filter by less than' do
+      it 'should filter by less than' do
         results = Sunspot.search(Post) { with.send(field).less_than values[2] }.results
         (0..2).each { |i| results.should include(@posts[i]) }
         (3..4).each { |i| results.should_not include(@posts[i]) }
       end
 
-      test 'should filter by greater than' do
+      it 'should filter by greater than' do
         results = Sunspot.search(Post) { with.send(field).greater_than values[2] }.results
         (2..4).each { |i| results.should include(@posts[i]) }
         (0..1).each { |i| results.should_not include(@posts[i]) }
       end
 
-      test 'should filter by between' do
+      it 'should filter by between' do
         results = Sunspot.search(Post) { with.send(field).between(values[1]..values[3]) }.results
         (1..3).each { |i| results.should include(@posts[i]) }
         [0, 4].each { |i| results.should_not include(@posts[i]) }
       end
 
-      test 'should filter by any of' do
+      it 'should filter by any of' do
         results = Sunspot.search(Post) { with.send(field).any_of(values.values_at(1, 3)) }.results
         [1, 3].each { |i| results.should include(@posts[i]) }
         [0, 2, 4].each { |i| results.should_not include(@posts[i]) }
       end
 
-      test 'should order by field ascending' do
+      it 'should order by field ascending' do
         results = Sunspot.search(Post) { order_by field, :asc }.results
         results.should == @posts
       end
 
-      test 'should order by field descending' do
+      it 'should order by field descending' do
         results = Sunspot.search(Post) { order_by field, :desc }.results
         results.should == @posts.reverse
       end

data/{test/integration/test_keyword_search.rb → spec/integration/keyword_search_spec.rb}

@@ -1,6 +1,6 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
+require File.join(File.dirname(__FILE__), 'spec_helper')
 
-class TestKeywordSearch < Test::Unit::TestCase
+describe 'keyword search' do
   before :all do
     Sunspot.remove_all
     @posts = []
@@ -13,18 +13,18 @@ class TestKeywordSearch < Test::Unit::TestCase
     Sunspot.index(*@posts)
   end
 
-  test 'matches a single keyword out of a single field' do
+  it 'matches a single keyword out of a single field' do
     results = Sunspot.search(Post) { keywords 'toast' }.results
     [0, 2].each { |i| results.should include(@posts[i]) }
     [1].each { |i| results.should_not include(@posts[i]) }
   end
 
-  test 'matches multiple words out of a single field' do
+  it 'matches multiple words out of a single field' do
     results = Sunspot.search(Post) { keywords 'elects toast' }.results
     results.should == [@posts[0]]
   end
 
-  test 'matches multiple words in multiple fields' do
+  it 'matches multiple words in multiple fields' do
     results = Sunspot.search(Post) { keywords 'toast wind' }.results
     [0, 2].each { |i| results.should include(@posts[i]) }
     [1].each { |i| results.should_not include(@posts[i]) }

data/spec/integration/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')

data/{test → spec}/integration/test_pagination.rb

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

data/{test/test_helper.rb → spec/spec_helper.rb}

@@ -1,17 +1,13 @@
 require 'rubygems'
-gem 'jeremymcanally-matchy', '>= 0.0.1'
-gem 'jeremymcanally-context', '>= 0.0.6'
 gem 'ruby-debug', '~>0.10'
 gem 'mislav-will_paginate', '~> 2.3'
+gem 'rspec', '~> 1.1'
 
-require 'matchy'
-require 'context'
 require 'ruby-debug'
+require 'spec'
 require 'will_paginate'
 require 'will_paginate/collection'
 
-require File.join(File.dirname(__FILE__), 'custom_expectation')
-
 unless gem_name = ENV['SUNSPOT_TEST_GEM']
   $:.unshift(File.dirname(__FILE__) + '/../lib')
 else
@@ -22,10 +18,8 @@ require 'sunspot'
 require File.join(File.dirname(__FILE__), 'mocks', 'base_class.rb')
 Dir.glob(File.join(File.dirname(__FILE__), 'mocks', '**', '*.rb')).each { |file| require file }
 
-class Test::Unit::TestCase
-  def without_class(clazz)
-    Object.class_eval { remove_const(clazz.name.to_sym) }
-    yield
-    Object.class_eval { const_set(clazz.name.to_sym, clazz) }
-  end
+def without_class(clazz)
+  Object.class_eval { remove_const(clazz.name.to_sym) }
+  yield
+  Object.class_eval { const_set(clazz.name.to_sym, clazz) }
 end

data/tasks/gemspec.rake

@@ -0,0 +1,18 @@
+begin
+  gem 'technicalpickles-jeweler', '~> 0.8.1'
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = 'sunspot'
+    s.executables = 'sunspot-solr'
+    s.summary = 'Library for expressive, powerful interaction with the Solr search engine'
+    s.email = 'mat@patch.com'
+    s.homepage = 'http://github.com/outoftime/sunspot'
+    s.description = 'Library for expressive, powerful interaction with the Solr search engine'
+    s.authors = ['Mat Brown']
+    s.files = FileList['[A-Z]*', '{bin,lib,spec,tasks}/**/*', 'solr/{etc,lib,webapps}/**/*', 'solr/solr/conf/*', 'solr/start.jar']
+    s.add_dependency 'solr-ruby', '>= 0.0.6'
+    s.add_dependency 'extlib', '>= 0.9.10'
+    s.add_development_dependency 'rspec', '~> 1.1'
+    s.add_development_dependency 'ruby-debug', '~> 0.10'
+  end
+end