sunspot_solr 2.0.0.pre.120720 → 2.0.0.pre.120924

data/sunspot/spec/api/session_proxy/master_slave_session_proxy_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+describe Sunspot::SessionProxy::MasterSlaveSessionProxy do
+  before :each do
+    @master_session, @slave_session = Sunspot::Session.new, Sunspot::Session.new
+    @proxy = Sunspot::SessionProxy::MasterSlaveSessionProxy.new(@master_session, @slave_session)
+  end
+
+  {
+    :master_session => Sunspot::Session.public_instance_methods(false) - [:search, 'search', :new_search, 'new_search', :more_like_this, 'more_like_this', :new_more_like_this, 'new_more_like_this', :config, 'config'],
+    :slave_session => [:search, :new_search, :more_like_this, :new_more_like_this]
+  }.each_pair do |delegate, methods|
+    methods.each do |method|
+      it "should delegate #{method} to #{delegate}" do
+        args = Array.new(Sunspot::Session.instance_method(method).arity.abs) do
+          stub('arg')
+        end
+        instance_variable_get(:"@#{delegate}").should_receive(method).with(*args)
+        @proxy.send(method, *args)
+      end
+    end
+  end
+
+  it 'should return master session config by default' do
+    @proxy.config.should eql(@master_session.config)
+  end
+
+  it 'should return master session config when specified' do
+    @proxy.config(:master).should eql(@master_session.config)
+  end
+
+  it 'should return slave session config when specified' do
+    @proxy.config(:slave).should eql(@slave_session.config)
+  end
+
+  it 'should raise ArgumentError when bogus config specified' do
+    lambda { @proxy.config(:bogus) }.should raise_error
+  end
+
+  it_should_behave_like 'session proxy'
+end

data/sunspot/spec/api/session_proxy/retry_5xx_session_proxy_spec.rb

@@ -0,0 +1,78 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+describe Sunspot::SessionProxy::Retry5xxSessionProxy do
+  
+  before :each do
+    Sunspot::Session.connection_class = Mock::ConnectionFactory.new
+    @sunspot_session = Sunspot.session
+    @proxy = Sunspot::SessionProxy::Retry5xxSessionProxy.new(@sunspot_session)
+    Sunspot.session = @proxy
+  end
+
+  after :each do
+    Sunspot::Session.connection_class = nil
+    Sunspot.reset!(true)
+  end
+
+  class FakeRSolrErrorHttp < RSolr::Error::Http
+    def backtrace
+      []
+    end
+  end
+
+  let :fake_rsolr_request do
+    {:uri => 'http://solr.test/uri'}
+  end
+
+  def fake_rsolr_response(status)
+    {:status => status.to_s}
+  end
+
+  let :post do
+    Post.new(:title => 'test')
+  end
+
+  it "should behave normally without a stubbed exception" do
+    @sunspot_session.should_receive(:index).and_return(mock)
+    Sunspot.index(post)
+  end
+
+  it "should be successful with a single exception followed by a sucess" do
+    e = FakeRSolrErrorHttp.new(fake_rsolr_request, fake_rsolr_response(503))
+    @sunspot_session.should_receive(:index).and_return do
+      @sunspot_session.should_receive(:index).and_return(mock)
+      raise e
+    end
+    Sunspot.index(post)
+  end
+
+  it "should return the error response after two exceptions" do
+    fake_response = fake_rsolr_response(503)
+    e = FakeRSolrErrorHttp.new(fake_rsolr_request, fake_response)
+    fake_success = mock('success')
+
+    @sunspot_session.should_receive(:index).and_return do
+      @sunspot_session.should_receive(:index).and_return do
+        @sunspot_session.stub!(:index).and_return(fake_success)
+        raise e
+      end
+      raise e
+    end
+
+    response = Sunspot.index(post)
+    response.should_not == fake_success
+    response.should == fake_response
+  end
+
+  it "should not retry a 4xx" do
+    e = FakeRSolrErrorHttp.new(fake_rsolr_request, fake_rsolr_response(400))
+    @sunspot_session.should_receive(:index).and_raise(e)
+    lambda { Sunspot.index(post) }.should raise_error
+  end
+
+  # TODO: try against more than just Sunspot.index? but that's just testing the
+  # invocation of delegate, so probably not important. -nz 11Apr12
+
+  it_should_behave_like 'session proxy'
+  
+end

data/sunspot/spec/api/session_proxy/sharding_session_proxy_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+describe Sunspot::SessionProxy::ShardingSessionProxy do
+  before do
+    @proxy = MockShardingSessionProxy.new(session)
+  end
+
+  [:index, :index!, :remove, :remove!].each do |method|
+    it "should delegate #{method} to appropriate shard" do
+      posts = [Post.new(:blog_id => 2), Post.new(:blog_id => 3)]
+      @proxy.sessions[0].should_receive(method).with([posts[0]])
+      @proxy.sessions[1].should_receive(method).with([posts[1]])
+      @proxy.send(method, posts[0])
+      @proxy.send(method, posts[1])
+    end
+  end
+
+  [:remove_by_id, :remove_by_id!].each do |method|
+    it "should raise NotSupportedError when #{method} called" do
+      lambda { @proxy.send(method, Post, 1) }.should raise_error(Sunspot::SessionProxy::NotSupportedError)
+    end
+  end
+
+  [:remove_all, :remove_all!].each do |method|
+    it "should raise NotSupportedError when #{method} called with argument" do
+      lambda { @proxy.send(method, Post) }.should raise_error(Sunspot::SessionProxy::NotSupportedError)
+    end
+
+    it "should delegate #{method} without argument to all shards" do
+      @proxy.sessions.each { |session| session.should_receive(method) }
+      @proxy.send(method)
+    end
+  end
+
+  [:commit, :commit_if_dirty, :commit_if_delete_dirty, :optimize].each do |method|
+    it "should delegate #{method} to all sessions" do
+      @proxy.sessions.each do |session|
+        session.should_receive(method)
+      end
+      @proxy.send(method)
+    end
+  end
+
+  it "should not support the :batch method" do
+    lambda { @proxy.batch }.should raise_error(Sunspot::SessionProxy::NotSupportedError)
+  end
+
+  it "should delegate new_search to search session, adding in shards parameter" do
+    search = @proxy.new_search(Post)
+    search.query[:shards].should ==
+      'http://localhost:8980/solr,http://localhost:8981/solr'
+  end
+
+  it "should delegate search to search session, adding in shards parameter" do
+    @proxy.search(Post)
+    connection.should have_last_search_with(
+      :shards => 'http://localhost:8980/solr,http://localhost:8981/solr'
+    )
+  end
+
+  [:dirty, :delete_dirty].each do |method|
+    it "should be dirty if any of the sessions are dirty" do
+      @proxy.sessions[0].stub!(:"#{method}?").and_return(true)
+      @proxy.should send("be_#{method}")
+    end
+
+    it "should not be dirty if none of the sessions are dirty" do
+      @proxy.should_not send("be_#{method}")
+    end
+  end
+
+  it "should raise a NotSupportedError when :config is called" do
+    lambda { @proxy.config }.should raise_error(Sunspot::SessionProxy::NotSupportedError)
+  end
+
+  it_should_behave_like 'session proxy'
+end

data/sunspot/spec/api/session_proxy/silent_fail_session_proxy_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+describe Sunspot::SessionProxy::ShardingSessionProxy do
+  
+  FakeException = Class.new(StandardError)
+  SUPPORTED_METHODS = Sunspot::SessionProxy::SilentFailSessionProxy::SUPPORTED_METHODS
+
+  before do
+    @search_session = mock(Sunspot::Session.new)
+    @proxy = Sunspot::SessionProxy::SilentFailSessionProxy.new(@search_session)
+  end
+  
+  it "should call rescued_exception when an exception is caught" do
+    SUPPORTED_METHODS.each do |method|
+      e = FakeException.new(method)
+      @search_session.stub!(method).and_raise(e)
+      @proxy.should_receive(:rescued_exception).with(method, e)
+      @proxy.send(method)
+    end
+  end
+  
+  it_should_behave_like 'session proxy'
+  
+end

data/sunspot/spec/api/session_proxy/spec_helper.rb

@@ -0,0 +1,9 @@
+require File.expand_path('spec_helper', File.join(File.dirname(__FILE__), '..'))
+
+shared_examples_for 'session proxy' do
+  Sunspot::Session.public_instance_methods(false).each do |method|
+    it "should respond to #{method.inspect}" do
+      @proxy.should respond_to(method)
+    end
+  end
+end

data/sunspot/spec/api/session_proxy/thread_local_session_proxy_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+require 'weakref'
+
+describe Sunspot::SessionProxy::ThreadLocalSessionProxy do
+  before :each do
+    @config = Sunspot::Configuration.build
+    @proxy = Sunspot::SessionProxy::ThreadLocalSessionProxy.new(@config)
+  end
+
+  it 'should have the same session for the same thread' do
+    @proxy.session.should eql(@proxy.session)
+  end
+
+  it 'should not have the same session for different threads' do
+    session1 = @proxy.session
+    session2 = nil
+    Thread.new do
+      session2 = @proxy.session
+    end.join
+    session1.should_not eql(session2)
+  end
+
+  it 'should not have the same session for the same thread in different proxy instances' do
+    proxy2 = Sunspot::SessionProxy::ThreadLocalSessionProxy.new(@config)
+    @proxy.session.should_not eql(proxy2.session)
+  end
+
+  (Sunspot::Session.public_instance_methods(false) - ['config', :config]).each do |method|
+    it "should delegate #{method.inspect} to its session" do
+      args = Array.new(Sunspot::Session.instance_method(method).arity.abs) do
+        stub('arg')
+      end
+      @proxy.session.should_receive(method).with(*args)
+      @proxy.send(method, *args)
+    end
+  end
+
+  it_should_behave_like 'session proxy'
+end

data/sunspot/spec/api/session_spec.rb

@@ -0,0 +1,232 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+shared_examples_for 'all sessions' do
+  context '#index()' do
+    before :each do
+      @session.index(Post.new)
+    end
+
+    it 'should add document to connection' do
+      connection.should have(1).adds
+    end
+  end
+
+  context '#index!()' do
+    before :each do
+      @session.index!(Post.new)
+    end
+
+    it 'should add document to connection' do
+      connection.should have(1).adds
+    end
+
+    it 'should commit' do
+      connection.should have(1).commits
+    end
+  end
+
+  context '#commit()' do
+    before :each do
+      @session.commit
+    end
+
+    it 'should commit' do
+      connection.should have(1).commits
+    end
+  end
+
+  context '#optimize()' do
+    before :each do
+      @session.optimize
+    end
+
+    it 'should optimize' do
+      connection.should have(1).optims
+    end
+  end
+
+  context '#search()' do
+    before :each do
+      @session.search(Post)
+    end
+
+    it 'should search' do
+      connection.should have(1).searches
+    end
+  end
+end
+
+describe 'Session' do
+  before :each do
+    @connection_factory = Mock::ConnectionFactory.new
+    Sunspot::Session.connection_class = @connection_factory
+  end
+
+  after :each do
+    Sunspot::Session.connection_class = nil
+    Sunspot.reset!
+  end
+
+  context 'singleton session' do
+    before :each do
+      Sunspot.reset!
+      @session = Sunspot
+    end
+
+    it_should_behave_like 'all sessions'
+
+    it 'should open connection with defaults if nothing specified' do
+      Sunspot.commit
+      connection.opts[:url].should == 'http://127.0.0.1:8983/solr'
+    end
+
+    it 'should open a connection with custom host' do
+      Sunspot.config.solr.url = 'http://127.0.0.1:8981/solr'
+      Sunspot.commit
+      connection.opts[:url].should == 'http://127.0.0.1:8981/solr'
+    end
+
+    it 'should open a connection with custom read timeout' do
+      Sunspot.config.solr.read_timeout = 0.5
+      Sunspot.commit
+      connection.opts[:read_timeout].should == 0.5
+    end
+
+    it 'should open a connection with custom open timeout' do
+      Sunspot.config.solr.open_timeout = 0.5
+      Sunspot.commit
+      connection.opts[:open_timeout].should == 0.5
+    end
+  end
+
+  context 'custom session' do
+    before :each do
+      @session = Sunspot::Session.new
+    end
+
+    it_should_behave_like 'all sessions'
+
+    it 'should open a connection with custom host' do
+      session = Sunspot::Session.new do |config|
+        config.solr.url = 'http://127.0.0.1:8982/solr'
+      end
+      session.commit
+      connection.opts[:url].should == 'http://127.0.0.1:8982/solr'
+    end
+  end
+
+  context 'dirty sessions' do
+    before :each do
+      @session = Sunspot::Session.new
+    end
+
+    it 'should start out not dirty' do
+      @session.dirty?.should be_false
+    end
+    
+    it 'should start out not delete_dirty' do
+      @session.delete_dirty?.should be_false
+    end
+
+    it 'should be dirty after adding an item' do
+      @session.index(Post.new)
+      @session.dirty?.should be_true
+    end
+    
+    it 'should be not be delete_dirty after adding an item' do
+      @session.index(Post.new)
+      @session.delete_dirty?.should be_false
+    end
+
+    it 'should be dirty after deleting an item' do
+      @session.remove(Post.new)
+      @session.dirty?.should be_true
+    end
+
+    it 'should be delete_dirty after deleting an item' do
+      @session.remove(Post.new)
+      @session.delete_dirty?.should be_true
+    end
+
+    it 'should be dirty after a remove_all for a class' do
+      @session.remove_all(Post)
+      @session.dirty?.should be_true
+    end
+
+    it 'should be delete_dirty after a remove_all for a class' do
+      @session.remove_all(Post)
+      @session.delete_dirty?.should be_true
+    end
+
+    it 'should be dirty after a global remove_all' do
+      @session.remove_all
+      @session.dirty?.should be_true
+    end
+    
+    it 'should be delete_dirty after a global remove_all' do
+      @session.remove_all
+      @session.delete_dirty?.should be_true
+    end
+    
+    it 'should not be dirty after a commit' do
+      @session.index(Post.new)
+      @session.commit
+      @session.dirty?.should be_false
+    end
+
+    it 'should not be dirty after an optimize' do
+      @session.index(Post.new)
+      @session.optimize
+      @session.dirty?.should be_false
+    end
+
+    it 'should not be delete_dirty after a commit' do
+      @session.remove(Post.new)
+      @session.commit
+      @session.delete_dirty?.should be_false
+    end
+
+    it 'should not be delete_dirty after an optimize' do
+      @session.remove(Post.new)
+      @session.optimize
+      @session.delete_dirty?.should be_false
+    end
+
+    it 'should not commit when commit_if_dirty called on clean session' do
+      @session.commit_if_dirty
+      connection.should have(0).commits
+    end
+
+    it 'should not commit when commit_if_delete_dirty called on clean session' do
+      @session.commit_if_delete_dirty
+      connection.should have(0).commits
+    end
+
+    it 'should commit when commit_if_dirty called on dirty session' do
+      @session.index(Post.new)
+      @session.commit_if_dirty
+      connection.should have(1).commits
+    end
+    
+    it 'should commit when commit_if_delete_dirty called on delete_dirty session' do
+      @session.remove(Post.new)
+      @session.commit_if_delete_dirty
+      connection.should have(1).commits
+    end
+  end
+
+  context 'session proxy' do
+    it 'should send messages to manually assigned session proxy' do
+      stub_session = stub!('session')
+      Sunspot.session = stub_session
+      post = Post.new
+      stub_session.should_receive(:index).with(post)
+      Sunspot.index(post)
+      Sunspot.reset!
+    end
+  end
+
+  def connection
+    @connection_factory.instance
+  end
+end