outoftime-sunspot 0.0.1 → 0.0.2

data/test/api/test_build_search.rb

@@ -1,216 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class TestBuildSearch < Test::Unit::TestCase
-  CONFIG = Sunspot::Configuration.build
-
-  test 'should search by keywords' do
-    connection.expects(:query).with('(keyword search) AND (type:Post)', :filter_queries => [], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
-    session.search Post, :keywords => 'keyword search'
-    session.search Post do
-      keywords 'keyword search'
-    end
-  end
-
-  test 'should scope by exact match with a string' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => ['title_s:My\ Pet\ Post'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
-    session.search Post, :conditions => { :title => 'My Pet Post' }
-    session.search Post do
-      with.title 'My Pet Post'
-    end
-  end
-
-  test 'should ignore nonexistant fields in hash scope' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => [], :start => 0, :rows => CONFIG.pagination.default_per_page)
-    session.search Post, :conditions => { :bogus => 'Field' }
-  end
-
-  test '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
-
-  test 'should scope by exact match with time' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => ['published_at_d:1983\-07\-08T09\:00\:00Z'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
-    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
-
-  test 'should scope by less than match with float' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => ['average_rating_f:[* TO 3\.0]'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
-
-    session.search Post, :conditions => { :average_rating => 3.0 } do
-      conditions.interpret :average_rating, :less_than
-    end
-
-    session.search Post do
-      with.average_rating.less_than 3.0
-    end
-  end
-
-  test 'should scope by greater than match with float' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => ['average_rating_f:[3\.0 TO *]'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
-    session.search Post, :conditions => { :average_rating => 3.0 } do 
-      conditions.interpret :average_rating, :greater_than
-    end
-    session.search Post do
-      with.average_rating.greater_than 3.0
-    end
-  end
-
-  test 'should scope by between match with float' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => ['average_rating_f:[2\.0 TO 4\.0]'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
-    session.search Post, :conditions => { :average_rating => [2.0, 4.0] } do
-      conditions.interpret :average_rating, :between
-    end
-    session.search Post do
-      with.average_rating.between 2.0..4.0
-    end
-  end
-
-  test 'should scope by any match with integer' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => ['category_ids_im:(2 OR 7 OR 12)'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
-    session.search Post, :conditions => { :category_ids => [2, 7, 12] }
-    session.search Post do
-      with.category_ids.any_of [2, 7, 12]
-    end
-  end
-
-  test 'should scope by all match with integer' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => ['category_ids_im:(2 AND 7 AND 12)'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
-    session.search Post, :conditions => { :category_ids => [2, 7, 12] } do
-      conditions.interpret :category_ids, :all_of
-    end
-    session.search Post do
-      with.category_ids.all_of [2, 7, 12]
-    end
-  end
-
-  test 'should allow setting of default conditions' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => ['average_rating_f:2\.0'], :start => 0, :rows => CONFIG.pagination.default_per_page)
-    session.search Post do
-      conditions.default :average_rating, 2.0
-    end
-  end
-
-  test 'should not use default condition value if condition provided' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => ['average_rating_f:3\.0'], :start => 0, :rows => CONFIG.pagination.default_per_page)
-    session.search Post, :conditions => { :average_rating => 3.0 } do
-      conditions.default :average_rating, 2.0
-    end
-  end
-
-  test 'should paginate using default per_page' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => [], :rows => 30, :start => 30).times(2)
-    session.search Post, :page => 2
-    session.search Post do
-      paginate :page => 2
-    end
-  end
-
-  test 'should paginate using provided per_page' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => [], :rows => 15, :start => 45).times(2)
-    session.search Post, :page => 4, :per_page => 15
-    session.search Post do
-      paginate :page => 4, :per_page => 15
-    end
-  end
-
-  test 'should order' do
-    connection.expects(:query).with('(type:Post)', :filter_queries => [], :sort => [{ :average_rating_f => :descending }], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
-    session.search Post, :order => 'average_rating desc'
-    session.search Post do
-      order_by :average_rating, :desc
-    end
-  end
-
-  test 'should build search for multiple types' do
-    connection.expects(:query).with('(type:(Post OR Comment))', :filter_queries => [], :start => 0, :rows => CONFIG.pagination.default_per_page)
-    session.search(Post, Comment)
-  end
-
-  test 'should allow search on fields common to all types' do
-    connection.expects(:query).with('(type:(Post OR Comment))', :filter_queries => ['published_at_d:1983\-07\-08T09\:00\:00Z'], :start => 0, :rows => CONFIG.pagination.default_per_page).times(2)
-    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
-
-  test '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
-
-  test '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
-
-  test 'should ignore condition if field is not common to all types' do
-    connection.expects(:query).with('(type:(Post OR Comment))', :filter_queries => [], :start => 0, :rows => CONFIG.pagination.default_per_page)    
-    session.search Post, Comment, :conditions => { :blog_id => 1 }
-  end
-
-  test '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
-
-  test '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
-
-  test '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
-
-  test '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
-
-  test '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 connection
-    @connection ||= stub
-  end
-
-  def session
-    @session ||= Sunspot::Session.new(CONFIG, connection)
-  end
-end

data/test/api/test_helper.rb

@@ -1,4 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-gem 'mocha', '~>0.9'
-require 'mocha'

data/test/api/test_indexer.rb

@@ -1,110 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class TestIndexer < Test::Unit::TestCase
-  CONFIG = Sunspot::Configuration.build
-
-  describe 'when indexing an object' do
-    test 'should index id and type' do
-      connection.expects(:add).with(has_entries(:id => "Post #{post.id}", :type => ['Post', 'BaseClass']))
-      session.index post
-    end
-
-    test 'should index text' do
-      post :title => 'A Title', :body => 'A Post'
-      connection.expects(:add).with(has_entries(:title_text => 'A Title', :body_text => 'A Post'))
-      session.index post
-    end
-
-    test 'should correctly index a string attribute field' do 
-      post :title => 'A Title'
-      connection.expects(:add).with(has_entries(:title_s => 'A Title'))
-      session.index post
-    end
-
-    test 'should correctly index an integer attribute field' do
-      post :blog_id => 4
-      connection.expects(:add).with(has_entries(:blog_id_i => '4'))
-      session.index post
-    end
-
-    test 'should correctly index a float attribute field' do
-      post :average_rating => 2.23
-      connection.expects(:add).with(has_entries(:average_rating_f => '2.23'))
-      session.index post
-    end
-
-    test 'should allow indexing by a multiple-value field' do
-      post :category_ids => [3, 14]
-      connection.expects(:add).with(has_entries(:category_ids_im => ['3', '14']))
-      session.index post
-    end
-
-    test 'should correctly index a time field' do
-      post :published_at => Time.parse('1983-07-08 05:00:00 -0400')
-      connection.expects(:add).with(has_entries(:published_at_d => '1983-07-08T09:00:00Z'))
-      session.index post
-    end
-
-    test 'should correctly index a virtual field' do
-      post :title => 'The Blog Post'
-      connection.expects(:add).with(has_entries(:sort_title_s => 'blog post'))
-      session.index post
-    end
-
-    test 'should correctly index a field that is defined on a superclass' do
-      Sunspot.setup(BaseClass) { string :author_name }
-      post :author_name => 'Mat Brown'
-      connection.expects(:add).with(has_entries(:author_name_s => 'Mat Brown'))
-      session.index post
-    end
-
-    test 'should remove an object from the index' do
-      connection.expects(:delete).with("Post #{post.id}")
-      session.remove(post)
-    end
-
-    test 'should be able to remove everything from the index' do
-      connection.expects(:delete_by_query).with("type:[* TO *]")
-      session.remove_all
-    end
-
-    test 'should be able to remove everything of a given class from the index' do
-      connection.expects(:delete_by_query).with("type:Post")
-      session.remove_all(Post)
-    end
-  end
-
-  test '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
-
-  test '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
-
-  test '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
-
-  test '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 connection
-    @connection ||= stub
-  end
-
-  def session
-    @session ||= Sunspot::Session.new(CONFIG, connection)
-  end
-
-  def post(attrs = {})
-    @post ||= Post.new(attrs)
-  end
-end

data/test/api/test_retrieve_search.rb

@@ -1,114 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class TestRetrieveSearch < Test::Unit::TestCase
-  CONFIG = Sunspot::Configuration.build
-
-  test 'should load search result' do
-    post = Post.new
-    stub_results(post)
-
-    session.search(Post).results.should == [post]
-  end
-
-  test '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
-
-  test '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
-
-  test '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
-
-  test 'should return total' do
-    stub_results(Post.new, Post.new, 4)
-    session.search(Post, :page => 1).total.should == 4
-  end
-
-  test 'should give access to order through hash and object' do
-    stub_results
-    search = session.search(Post, :order => 'sort_title asc')
-    search.attributes[:order].should == 'sort_title asc'
-    search.order.should == 'sort_title asc'
-  end
-
-  test 'should give nil order if no order set' do
-    stub_results
-    search = session.search(Post)
-    search.attributes.should have_key(:order)
-    search.attributes[:order].should be_nil
-    search.order.should be_nil
-  end
-
-  test 'should give access to page and per-page through hash and object' do
-    stub_results
-    search = session.search(Post, :page => 2, :per_page => 15)
-    search.attributes[:page].should == 2
-    search.attributes[:per_page].should == 15
-    search.page.should == 2
-    search.per_page.should == 15
-  end
-
-  test 'should give access to keywords' do
-    stub_results
-    search = session.search(Post, :keywords => 'some keywords')
-    search.attributes[:keywords].should == 'some keywords'
-    search.keywords.should == 'some keywords'
-  end
-
-  test 'should have nil keywords if no keywords given' do
-    stub_results
-    search = session.search(Post)
-    search.attributes.should have_key(:keywords)
-    search.attributes[:keywords].should be_nil
-    search.keywords.should be_nil
-  end
-
-  test 'should give access to conditions' do
-    stub_results
-    search = session.search(Post, :conditions => { :blog_id => 1 })
-    search.attributes[:conditions][:blog_id].should == 1
-    search.conditions.blog_id.should == 1
-  end
-
-  test 'should have nil values for fields with unspecified conditions' do
-    stub_results
-    search = session.search(Post)
-    %w(title blog_id category_ids average_rating published_at sort_title).each do |field_name|
-      search.attributes[:conditions].should have_key(field_name.to_sym)
-      search.attributes[:conditions][field_name.to_sym].should == nil
-      search.conditions.should respond_to(field_name)
-      search.conditions.send(field_name).should == nil
-    end
-  end
-
-  private
-
-  def stub_results(*results)
-    total_hits = if results.last.is_a?(Integer) then results.pop 
-                 else results.length
-                 end
-    response = stub
-    response.stubs(:hits).returns(results.map { |result| { 'id' => "#{result.class.name} #{result.id}" }})
-    response.stubs(:total_hits).returns(total_hits)
-    connection.stubs(:query).returns(response)
-  end
-
-  def connection
-    @connection ||= Object.new
-  end
-
-  def session
-    @session ||= Sunspot::Session.new(CONFIG, connection)
-  end
-end

data/test/api/test_session.rb

@@ -1,46 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class TestSession < Test::Unit::TestCase
-  context 'using singleton session' do
-    before do
-      Sunspot.reset!
-      connection.expects(:add)
-      connection.expects(:query)
-    end
-
-    test 'should open connection with defaults if nothing specified' do
-      Solr::Connection.stubs(:new).with('http://localhost:8983/solr', :autocommit => :on).returns(connection)
-      Sunspot.index(Post.new)
-      Sunspot.search(Post)
-    end
-
-    test 'should open a connection with custom host' do
-      Solr::Connection.stubs(:new).with('http://127.0.0.1:8981/solr', :autocommit => :on).returns(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 do
-      connection.expects(:add)
-      connection.expects(:query)
-    end
-
-    test 'should open a connection with custom host' do
-      Solr::Connection.stubs(:new).with('http://127.0.0.1:8982/solr', :autocommit => :on).returns(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
-
-  private
-
-  def connection
-    @connection ||= stub_everything('Connection')
-  end
-end

data/test/integration/test_helper.rb

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