sunspot_index_queue 1.0.0

data/spec/entry_spec.rb

@@ -0,0 +1,148 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Sunspot::IndexQueue::Entry do
+  
+  context "implementation" do
+    after :each do
+      Sunspot::IndexQueue::Entry.implementation = nil
+    end
+    
+    it "should use the active record implementation by default" do
+      Sunspot::IndexQueue::Entry.implementation = nil
+      Sunspot::IndexQueue::Entry.implementation.should == Sunspot::IndexQueue::Entry::ActiveRecordImpl
+    end
+    
+    it "should be able to set the implementation with a class" do
+      Sunspot::IndexQueue::Entry.implementation = Sunspot::IndexQueue::Entry::MockImpl
+      Sunspot::IndexQueue::Entry.implementation.should == Sunspot::IndexQueue::Entry::MockImpl
+    end
+  
+    it "should be able to set the implementation with a class name" do
+      Sunspot::IndexQueue::Entry.implementation = "Sunspot::IndexQueue::Entry::MockImpl"
+      Sunspot::IndexQueue::Entry.implementation.should == Sunspot::IndexQueue::Entry::MockImpl
+    end
+  
+    it "should be able to set the implementation with a symbol" do
+      Sunspot::IndexQueue::Entry.implementation = :mock
+      Sunspot::IndexQueue::Entry.implementation.should == Sunspot::IndexQueue::Entry::MockImpl
+    end
+  end
+  
+  context "proxy class methods" do
+    
+    before :all do
+      Sunspot::IndexQueue::Entry.implementation = :mock
+    end
+    
+    after :all do
+      Sunspot::IndexQueue::Entry.implementation = nil
+    end
+    
+    let(:implementation) { Sunspot::IndexQueue::Entry.implementation }
+    let(:queue) { Sunspot::IndexQueue.new }
+    let(:entry) { Sunspot::IndexQueue::Entry.implementation.new }
+    
+    it "should proxy the total_count method to the implementation" do
+      implementation.should_receive(:total_count).with(queue).and_return(100)
+      Sunspot::IndexQueue::Entry.total_count(queue).should == 100
+    end
+    
+    it "should proxy the ready_count method to the implementation" do
+      implementation.should_receive(:ready_count).with(queue).and_return(100)
+      Sunspot::IndexQueue::Entry.ready_count(queue).should == 100
+    end
+    
+    it "should proxy the error_count method to the implementation" do
+      implementation.should_receive(:error_count).with(queue).and_return(100)
+      Sunspot::IndexQueue::Entry.error_count(queue).should == 100
+    end
+    
+    it "should proxy the errors method to the implementation" do
+      implementation.should_receive(:errors).with(queue, 2, 1).and_return([entry])
+      Sunspot::IndexQueue::Entry.errors(queue, 2, 1).should == [entry]
+    end
+    
+    it "should proxy the reset! method to the implementation" do
+      implementation.should_receive(:reset!).with(queue)
+      Sunspot::IndexQueue::Entry.reset!(queue)
+    end
+    
+    it "should proxy the next_batch! method to the implementation" do
+      implementation.should_receive(:next_batch!).with(queue).and_return([entry])
+      Sunspot::IndexQueue::Entry.next_batch!(queue).should == [entry]
+    end
+  end
+  
+  context "class methods" do
+    before :all do
+      Sunspot::IndexQueue::Entry.implementation = :mock
+    end
+    
+    after :all do
+      Sunspot::IndexQueue::Entry.implementation = nil
+    end
+    
+    let(:implementation) { Sunspot::IndexQueue::Entry.implementation }
+    let(:queue) { Sunspot::IndexQueue.new }
+    
+    it "should enqueue an entry to the implementation" do
+      implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 1, false, 2)
+      Sunspot::IndexQueue::Entry.enqueue(queue, Sunspot::IndexQueue::Test::Searchable, 1, false, 2)
+    end
+    
+    it "should enqueue an entry to the implementation given a class name" do
+      implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 1, false, 2)
+      Sunspot::IndexQueue::Entry.enqueue(queue, "Sunspot::IndexQueue::Test::Searchable", 1, false, 2)
+    end
+        
+    it "should enqueue multiple entries to the implementation" do
+      implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 1, false, 2)
+      implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 2, false, 2)
+      Sunspot::IndexQueue::Entry.enqueue(queue, Sunspot::IndexQueue::Test::Searchable, [1, 2], false, 2)
+    end
+    
+    it "should not enqueue an entry for an object to the implementation" do
+      queue.class_names << "Sunspot::IndexQueue::Test::Searchable"
+      queue.class_names << "Sunspot::IndexQueue::Test::Searchable::Subclass"
+      implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 1, true, 0)
+      Sunspot::IndexQueue::Entry.enqueue(queue, Sunspot::IndexQueue::Test::Searchable, 1, true, 0)
+      implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable::Subclass, 2, true, 0)
+      Sunspot::IndexQueue::Entry.enqueue(queue, Sunspot::IndexQueue::Test::Searchable::Subclass, 2, true, 0)
+      lambda{ Sunspot::IndexQueue::Entry.enqueue(queue, Object, 1, false) }.should raise_error(ArgumentError)
+    end
+    
+    it "should load all records for an array of entries at once" do
+      entry_1 = Sunspot::IndexQueue::Entry.implementation.new(:record_class_name => "Sunspot::IndexQueue::Test::Searchable", :record_id => 1)
+      entry_2 = Sunspot::IndexQueue::Entry.implementation.new(:record_class_name => "Sunspot::IndexQueue::Test::Searchable", :record_id => 2)
+      entry_3 = Sunspot::IndexQueue::Entry.implementation.new(:record_class_name => "Sunspot::IndexQueue::Test::Searchable::Subclass", :record_id => 3)
+      Sunspot::IndexQueue::Entry.load_all_records([entry_1, entry_2, entry_3])
+      record_1 = entry_1.instance_variable_get(:@record)
+      record_1.should == Sunspot::IndexQueue::Test::Searchable.new("1")
+      entry_1.record.object_id.should == record_1.object_id
+      record_2 = entry_2.instance_variable_get(:@record)
+      record_2.should == Sunspot::IndexQueue::Test::Searchable.new("2")
+      entry_2.record.object_id.should == record_2.object_id
+      record_3 = entry_3.instance_variable_get(:@record)
+      record_3.should == Sunspot::IndexQueue::Test::Searchable::Subclass.new("3")
+      entry_3.record.object_id.should == record_3.object_id
+    end
+  end
+  
+  context "instance methods" do
+    it "should get a record for the entry using the Sunspot DataAccessor" do
+      entry = Sunspot::IndexQueue::Entry::MockImpl.new(:record_class_name => "Sunspot::IndexQueue::Test::Searchable", :record_id => "1")
+      entry.record.class.should == Sunspot::IndexQueue::Test::Searchable
+      entry.record.id.should == "1"
+    end
+    
+    it "should set if an entry has been processed" do
+      entry = Sunspot::IndexQueue::Entry::MockImpl.new(:record_class_name => "Sunspot::IndexQueue::Test::Searchable", :record_id => "1")
+      entry.processed?.should == false
+      entry.processed = true
+      entry.processed?.should == true
+      entry.processed = false
+      entry.processed?.should == false
+    end
+  end
+  
+end

data/spec/index_queue_spec.rb

@@ -0,0 +1,150 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Sunspot::IndexQueue do
+  
+  before :all do
+    Sunspot::IndexQueue::Entry.implementation = :mock
+  end
+  
+  after :all do
+    Sunspot::IndexQueue::Entry.implementation = nil
+  end
+  
+  context "enqueing entries" do
+    let(:queue) { Sunspot::IndexQueue.new }
+    
+    it "should be able to index a record" do
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 1, false, 0)
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 2, false, 1)
+      queue.index(Sunspot::IndexQueue::Test::Searchable.new(1))
+      queue.index(Sunspot::IndexQueue::Test::Searchable.new(2), :priority => 1)
+    end
+  
+    it "should be able to index a class and id" do
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 1, false, 0)
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 2, false, 1)
+      queue.index(:class => Sunspot::IndexQueue::Test::Searchable, :id => 1)
+      queue.index({:class => Sunspot::IndexQueue::Test::Searchable, :id => 2}, :priority => 1)
+    end
+  
+    it "should be able to index multiple records" do
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, [1, 2], false, 0)
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, [3, 4], false, 1)
+      queue.index_all(Sunspot::IndexQueue::Test::Searchable, [1, 2])
+      queue.index_all(Sunspot::IndexQueue::Test::Searchable, [3, 4], :priority => 1)
+    end
+  
+    it "should be able to remove a record" do
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 1, true, 0)
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 2, true, 1)
+      queue.remove(Sunspot::IndexQueue::Test::Searchable.new(1))
+      queue.remove(Sunspot::IndexQueue::Test::Searchable.new(2), :priority => 1)
+    end
+  
+    it "should be able to remove a class and id" do
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 1, true, 0)
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 2, true, 1)
+      queue.remove(:class => Sunspot::IndexQueue::Test::Searchable, :id => 1)
+      queue.remove({:class => Sunspot::IndexQueue::Test::Searchable, :id => 2}, :priority => 1)
+    end
+  
+    it "should be able to remove multiple records" do
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, [1, 2], true, 0)
+      Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, [3, 4], true, 1)
+      queue.remove_all(Sunspot::IndexQueue::Test::Searchable, [1, 2])
+      queue.remove_all(Sunspot::IndexQueue::Test::Searchable, [3, 4], :priority => 1)
+    end
+  
+    it "should be able to set the priority for indexing or removing records in a block" do
+      Sunspot::IndexQueue.default_priority.should == 0
+      
+      Sunspot::IndexQueue.set_priority(1) do
+        Sunspot::IndexQueue.default_priority.should == 1
+        
+        Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 1, false, 1)
+        queue.index(Sunspot::IndexQueue::Test::Searchable.new(1))
+      
+        Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 2, false, 1)
+        queue.index(:class => Sunspot::IndexQueue::Test::Searchable, :id => 2)
+      
+        Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, [3], false, 1)
+        queue.index_all(Sunspot::IndexQueue::Test::Searchable, [3])
+      
+        Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 1, true, 1)
+        queue.remove(Sunspot::IndexQueue::Test::Searchable.new(1))
+      
+        Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, 2, true, 1)
+        queue.remove(:class => Sunspot::IndexQueue::Test::Searchable, :id => 2)
+      
+        Sunspot::IndexQueue::Entry.should_receive(:enqueue).with(queue, Sunspot::IndexQueue::Test::Searchable, [3], true, 1)
+        queue.remove_all(Sunspot::IndexQueue::Test::Searchable, [3])
+      end
+      
+      Sunspot::IndexQueue.default_priority.should == 0
+    end
+  end
+  
+  context "processing" do
+    let(:queue) { Sunspot::IndexQueue.new(:batch_size => 2, :session => mock(:session)) }
+    let(:entry_1) { Sunspot::IndexQueue::Entry::MockImpl.new(:record => record_1, :delete => true) }
+    let(:entry_2) { Sunspot::IndexQueue::Entry::MockImpl.new(:record => record_2, :delete => true) }
+    let(:entry_3) { Sunspot::IndexQueue::Entry::MockImpl.new(:record => record_3, :delete => true) }
+    let(:record_1) { Sunspot::IndexQueue::Test::Searchable.new(1) }
+    let(:record_2) { Sunspot::IndexQueue::Test::Searchable.new(2) }
+    let(:record_3) { Sunspot::IndexQueue::Test::Searchable.new(3) }
+    
+    it "should process all entries in the queue in batch of batch_size" do
+      Sunspot::IndexQueue::Entry.should_receive(:next_batch!).with(queue).and_return([entry_1, entry_2], [entry_3], [])
+      Sunspot::IndexQueue::Entry::MockImpl.should_receive(:ready_count).with(queue).and_return(0)
+      queue.session.should_receive(:batch).twice.and_yield
+      queue.session.should_receive(:remove_by_id).with("Sunspot::IndexQueue::Test::Searchable", "1")
+      queue.session.should_receive(:remove_by_id).with("Sunspot::IndexQueue::Test::Searchable", "2")
+      queue.session.should_receive(:remove_by_id).with("Sunspot::IndexQueue::Test::Searchable", "3")
+      queue.session.should_receive(:commit).twice
+      Sunspot::IndexQueue::Entry::MockImpl.should_receive(:delete_entries).with([entry_1, entry_2])
+      Sunspot::IndexQueue::Entry::MockImpl.should_receive(:delete_entries).with([entry_3])
+      queue.process.should == 3
+    end
+    
+    it "should process all entries in the queue and call a batch wrapper if defined" do
+      Sunspot::IndexQueue::Entry.should_receive(:next_batch!).with(queue).and_return([entry_1, entry_2], [entry_3], [])
+      Sunspot::IndexQueue::Entry::MockImpl.should_receive(:ready_count).with(queue).and_return(0)
+      queue.session.should_receive(:batch).twice.and_yield
+      queue.session.should_receive(:remove_by_id).with("Sunspot::IndexQueue::Test::Searchable", "1")
+      queue.session.should_receive(:remove_by_id).with("Sunspot::IndexQueue::Test::Searchable", "2")
+      queue.session.should_receive(:remove_by_id).with("Sunspot::IndexQueue::Test::Searchable", "3")
+      queue.session.should_receive(:commit).twice
+      Sunspot::IndexQueue::Entry::MockImpl.should_receive(:delete_entries).with([entry_1, entry_2])
+      Sunspot::IndexQueue::Entry::MockImpl.should_receive(:delete_entries).with([entry_3])
+      wrapper_count = 0
+      queue.batch_handler{|batch| wrapper_count += 1; batch.submit!}
+      queue.process.should == 3
+      wrapper_count.should == 2
+    end
+  end
+  
+  context "maintenance" do
+    let(:queue) { Sunspot::IndexQueue.new }
+    
+    it "should be able to reset all entries to clear errors and set them to be processed immediately" do
+      Sunspot::IndexQueue::Entry.should_receive(:reset!).with(queue)
+      queue.reset!
+    end
+    
+    it "should get the total number of entries in the queue" do
+      Sunspot::IndexQueue::Entry.should_receive(:total_count).with(queue).and_return(10)
+      queue.total_count.should == 10
+    end
+    
+    it "should get the number of entries in the queue ready to be processed" do
+      Sunspot::IndexQueue::Entry.should_receive(:ready_count).with(queue).and_return(10)
+      queue.ready_count.should == 10
+    end
+    
+    it "should get the number of entries with errors in the queue" do
+      Sunspot::IndexQueue::Entry.should_receive(:error_count).with(queue).and_return(10)
+      queue.error_count.should == 10
+    end
+  end
+  
+end

data/spec/integration_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'active_record'
+
+describe "Sunspot::IndexQueue integration tests" do
+  before :all do
+    db_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp'))
+    Dir.mkdir(db_dir) unless File.exist?(db_dir)
+    Dir.chdir(db_dir) do
+      FileUtils.rm_rf('data') if File.exist?('data')
+      Dir.mkdir('data')
+      `sunspot-solr start --port=18983 --data-directory=data --pid-dir=data --log-file=data/solr.log --max-memory=64m`
+      raise "Failed to start Solr on port 18983" unless $? == 0
+      # Wait until the server is responding
+      ping_uri = URI.parse("http://127.0.0.1:18983/solr/ping")
+      solr_started = false
+      100.times do
+        begin
+          Net::HTTP.get(ping_uri)
+          solr_started = true
+          break
+        rescue
+          sleep(0.1)
+        end
+      end
+      raise "Solr failed to start after 10 seconds" unless solr_started
+    end
+    
+    db = File.join(db_dir, 'sunspot_index_queue_test.sqlite3')
+    File.delete(db) if File.exist?(db)
+    ActiveRecord::Base.establish_connection("adapter" => "sqlite3", "database" => db)
+    Sunspot::IndexQueue::Entry.implementation = :active_record
+    Sunspot::IndexQueue::Entry::ActiveRecordImpl.create_table
+    
+    @solr_session = Sunspot::Session.new do |config|
+      config.solr.url = 'http://127.0.0.1:18983/solr'
+    end
+  end
+  
+  after :all do
+    db_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp'))
+    Dir.chdir(db_dir) do
+      `sunspot-solr stop --pid-dir=data`
+    end
+    db = File.join(db_dir, 'sunspot_index_queue_test.sqlite3')
+    data = File.join(db_dir, 'data')
+    FileUtils.rm_rf(data) if File.exist?(data)
+    ActiveRecord::Base.connection.disconnect!
+    File.delete(db) if File.exist?(db)
+    Dir.delete(db_dir) if File.exist?(db_dir) and Dir.entries(db_dir).reject{|f| f.match(/^\.+$/)}.empty?
+    Sunspot::IndexQueue::Entry.implementation = nil
+  end
+  
+  let(:session) { Sunspot::IndexQueue::SessionProxy.new(queue) }
+  let(:queue) { Sunspot::IndexQueue.new(:session => @solr_session, :batch_size => 2) }
+  
+  it "should actually work" do
+    Sunspot::IndexQueue::Test::Searchable.mock_db do
+      record_1 = Sunspot::IndexQueue::Test::Searchable.new("1", "one")
+      record_2 = Sunspot::IndexQueue::Test::Searchable.new("2", "two")
+      record_3 = Sunspot::IndexQueue::Test::Searchable::Subclass.new("3", "three")
+      Sunspot::IndexQueue::Test::Searchable.save(record_1, record_2, record_3)
+    
+      # Enqueue records
+      queue.index(record_1)
+      queue.index(record_2)
+      queue.index(record_3)
+      queue.index(record_2)
+      queue.total_count.should == 3
+      queue.ready_count.should == 3
+      queue.error_count.should == 0
+      queue.errors.should == []
+    
+      # Should not be found
+      session.search(Sunspot::IndexQueue::Test::Searchable){with :value, "three"}.results.should == []
+    
+      # Process queue
+      queue.process
+      queue.total_count.should == 0
+      queue.ready_count.should == 0
+      queue.error_count.should == 0
+      queue.errors.should == []
+    
+      # Should be found
+      session.search(Sunspot::IndexQueue::Test::Searchable){with :value, "two"}.results.should == [record_2]
+      session.search(Sunspot::IndexQueue::Test::Searchable){with :value, "three"}.results.should == [record_3]
+    
+      # Subclass should be found
+      session.search(Sunspot::IndexQueue::Test::Searchable::Subclass){with :value, "two"}.results.should == []
+      session.search(Sunspot::IndexQueue::Test::Searchable::Subclass){with :value, "three"}.results.should == [record_3]
+    
+      # Update record
+      record_3.value = "four"
+      
+      queue.index(record_3)
+      Sunspot::IndexQueue::Test::Searchable.save(record_3)
+      session.search(Sunspot::IndexQueue::Test::Searchable){with :value, "three"}.results.should == [record_3]
+      session.search(Sunspot::IndexQueue::Test::Searchable){with :value, "four"}.results.should == []
+      queue.process
+      session.search(Sunspot::IndexQueue::Test::Searchable){with :value, "three"}.results.should == []
+      session.search(Sunspot::IndexQueue::Test::Searchable){with :value, "four"}.results.should == [record_3]
+    
+      # Remove record
+      queue.remove(record_3)
+      session.search(Sunspot::IndexQueue::Test::Searchable){with :value, "four"}.results.should == [record_3]
+      queue.process
+      session.search(Sunspot::IndexQueue::Test::Searchable){with :value, "four"}.results.should == []
+    end
+  end
+  
+end

data/spec/mongo_impl_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../spec_helper', __FILE__)
+require File.expand_path('../entry_impl_examples', __FILE__)
+
+describe Sunspot::IndexQueue::Entry::MongoImpl do
+
+  before :all do
+    Sunspot::IndexQueue::Entry.implementation = :mongo
+    Sunspot::IndexQueue::Entry::MongoImpl.connection = 'localhost'
+    Sunspot::IndexQueue::Entry::MongoImpl.database_name = "sunspot_index_queue_test"
+  end
+  
+  after :all do
+    Sunspot::IndexQueue::Entry.implementation = nil
+  end
+  
+  let(:factory) do
+    factory = Object.new
+    def factory.create (attributes)
+      Sunspot::IndexQueue::Entry::MongoImpl.create(attributes)
+    end
+    
+    def factory.delete_all
+      Sunspot::IndexQueue::Entry::MongoImpl.collection.remove
+    end
+    
+    def factory.find (id)
+      doc = Sunspot::IndexQueue::Entry::MongoImpl.find_one(id)
+    end
+    
+    factory
+  end
+  
+  it_should_behave_like "Entry implementation"
+
+end

data/spec/session_proxy_spec.rb

@@ -0,0 +1,174 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Sunspot::IndexQueue::SessionProxy do
+  
+  before :all do
+    Sunspot::IndexQueue::Entry.implementation = :mock
+  end
+  
+  after :all do
+    Sunspot::IndexQueue::Entry.implementation = nil
+  end
+  
+  context "initialization" do
+    let(:queue) { Sunspot::IndexQueue.new }
+    
+    it "should use the default queue by default" do
+      proxy = Sunspot::IndexQueue::SessionProxy.new
+      proxy.queue.session == proxy.session
+    end
+    
+    it "should use the queue's session by default" do
+      proxy = Sunspot::IndexQueue::SessionProxy.new(queue)
+      proxy.session.should == queue.session
+      proxy.queue.should == queue
+    end
+    
+    it "should be able to specify the underlying session" do
+      session = Sunspot::Session.new
+      proxy = Sunspot::IndexQueue::SessionProxy.new(queue, session)
+      proxy.session.should == session
+      proxy.queue.session.should_not == proxy.session
+    end
+  end
+  
+  context "delgated methods" do
+    
+    subject { Sunspot::IndexQueue::SessionProxy.new(queue, session) }
+    let(:session) { Sunspot::Session.new }
+    let(:queue) { Sunspot::IndexQueue.new }
+    
+    it "should delegate new_search" do
+      session.should_receive(:new_search).with(String, Symbol)
+      subject.new_search(String, Symbol)
+    end
+    
+    it "should delegate search" do
+      session.should_receive(:search).with(String, Symbol)
+      subject.search(String, Symbol)
+    end
+    
+    it "should delegate new_more_like_this" do
+      session.should_receive(:new_more_like_this).with(:test, String, Symbol)
+      subject.new_more_like_this(:test, String, Symbol)
+    end
+    
+    it "should delegate more_like_this" do
+      session.should_receive(:more_like_this).with(:test, String, Symbol)
+      subject.more_like_this(:test, String, Symbol)
+    end
+    
+    it "should delegate config" do
+      subject.config.should == session.config
+    end
+  end
+  
+  context "indexing methods" do
+    
+    subject { Sunspot::IndexQueue::SessionProxy.new(queue, session) }
+    let(:session) { mock(:session) }
+    let(:queue) { Sunspot::IndexQueue.new(:session => mock(:queue_session)) }
+    
+    it "should yield the block to batch" do
+      executed = false
+      subject.batch do
+        executed = true
+      end
+      executed.should == true
+    end
+    
+    it "should not do anything on commit" do
+      subject.commit
+    end
+    
+    it "should not do anything on commit_if_delete_dirty" do
+      subject.commit_if_delete_dirty
+    end
+    
+    it "should not do anything on commit_if_dirty" do
+      subject.commit_if_dirty
+    end
+    
+    it "should not mark deletes as dirty" do
+      Sunspot::IndexQueue::Entry.implementation.stub!(:add)
+      subject.remove(Sunspot::IndexQueue::Test::Searchable.new(1))
+      subject.delete_dirty?.should == false
+    end
+    
+    it "should not mark the session as dirty" do
+      Sunspot::IndexQueue::Entry.implementation.stub!(:add)
+      subject.index(Sunspot::IndexQueue::Test::Searchable.new(1))
+      subject.delete_dirty?.should == false
+    end
+    
+    it "should queue up objects being indexed" do
+      Sunspot::IndexQueue::Entry.implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 1, false, 0)
+      Sunspot::IndexQueue::Entry.implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 2, false, 0)
+      subject.index(Sunspot::IndexQueue::Test::Searchable.new(1), [Sunspot::IndexQueue::Test::Searchable.new(2)])
+    end
+    
+    it "should queue up objects being indexed and committed" do
+      Sunspot::IndexQueue::Entry.implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 1, false, 0)
+      Sunspot::IndexQueue::Entry.implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 2, false, 0)
+      subject.index!(Sunspot::IndexQueue::Test::Searchable.new(1), [Sunspot::IndexQueue::Test::Searchable.new(2)])
+    end
+    
+    it "should queue up objects being removed" do
+      Sunspot::IndexQueue::Entry.implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 1, true, 0)
+      Sunspot::IndexQueue::Entry.implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 2, true, 0)
+      subject.remove(Sunspot::IndexQueue::Test::Searchable.new(1), [Sunspot::IndexQueue::Test::Searchable.new(2)])
+    end
+    
+    it "should queue up objects being removed and committed" do
+      Sunspot::IndexQueue::Entry.implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 1, true, 0)
+      Sunspot::IndexQueue::Entry.implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 2, true, 0)
+      subject.remove!(Sunspot::IndexQueue::Test::Searchable.new(1), [Sunspot::IndexQueue::Test::Searchable.new(2)])
+    end
+    
+    it "should queue up objects being removed by id" do
+      Sunspot::IndexQueue::Entry.implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 1, true, 0)
+      subject.remove_by_id(Sunspot::IndexQueue::Test::Searchable, 1)
+    end
+    
+    it "should queue up objects being removed by id and committed" do
+      Sunspot::IndexQueue::Entry.implementation.should_receive(:add).with(Sunspot::IndexQueue::Test::Searchable, 1, true, 0)
+      subject.remove_by_id(Sunspot::IndexQueue::Test::Searchable, 1)
+    end
+    
+    context "not queueable" do
+      
+      subject { Sunspot::IndexQueue::SessionProxy.new(queue, session) }
+      let(:session) { Sunspot::Session.new }
+      let(:queue) { Sunspot::IndexQueue.new }
+    
+      it "should immediately remove objects using the queue session if the method takes a block" do
+        executed = false
+        queue.session.should_receive(:remove).with(:test).and_yield
+        subject.remove(:test) do
+          executed = true
+        end
+        executed.should == true
+      end
+      
+      it "should immediately remove objects and commit using the queue session if the method takes a block" do
+        executed = false
+        queue.session.should_receive(:remove!).with(:test).and_yield
+        subject.remove!(:test) do
+          executed = true
+        end
+        executed.should == true
+      end
+      
+      it "should immediately remove all classes using the queue session" do
+        queue.session.should_receive(:remove_all).with(Sunspot::IndexQueue::Test::Searchable)
+        subject.remove_all(Sunspot::IndexQueue::Test::Searchable)
+      end
+      
+      it "should immediately remove all classes and and commit using the queue session" do
+        queue.session.should_receive(:remove_all!).with(Sunspot::IndexQueue::Test::Searchable)
+        subject.remove_all!(Sunspot::IndexQueue::Test::Searchable)
+      end
+    end    
+  end
+  
+end