ts-resque-delta 1.2.4 → 2.0.0

data/spec/thinking_sphinx/deltas/resque_delta/core_index_spec.rb

@@ -1,210 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Deltas::ResqueDelta::CoreIndex do
-  let(:indices) { %w[foo bar] }
-  let(:config) { double('config') }
-
-  describe '#lock_delta' do
-    it 'should lock the delta' do
-      ThinkingSphinx::Deltas::ResqueDelta.should_receive(:lock)
-
-      subject.lock_delta('foo')
-    end
-
-    it 'should lock the delta for the given index' do
-      ThinkingSphinx::Deltas::ResqueDelta.should_receive(:lock).with('foo_delta')
-
-      subject.lock_delta('foo')
-    end
-  end
-
-  describe '#unlock_delta' do
-    it 'should unlock the delta' do
-      ThinkingSphinx::Deltas::ResqueDelta.should_receive(:unlock)
-
-      subject.unlock_delta('foo')
-    end
-
-    it 'should unlock the delta for the given index' do
-      ThinkingSphinx::Deltas::ResqueDelta.should_receive(:unlock).with('foo_delta')
-
-      subject.unlock_delta('foo')
-    end
-  end
-
-  describe '#lock_deltas' do
-    it 'should lock all delta indices' do
-      subject.stub(:sphinx_indices => indices)
-
-      indices.each {|index| subject.should_receive(:lock_delta).once.with(index) }
-
-      subject.lock_deltas
-    end
-  end
-
-  describe '#unlock_deltas' do
-    it 'should unlock all delta indices' do
-      subject.stub(:sphinx_indices => indices)
-
-      indices.each {|index| subject.should_receive(:unlock_delta).once.with(index) }
-
-      subject.unlock_deltas
-    end
-  end
-
-  describe '#with_delta_index_lock' do
-    before :each do
-      subject.stub(:lock_delta)
-      subject.stub(:unlock_delta)
-
-      subject.stub(:block_called)
-
-      @block_called = false
-      @block = lambda { @block_called = true; subject.block_called }
-    end
-
-    it 'should yield' do
-      subject.with_delta_index_lock('foo', &@block)
-      @block_called.should be_true
-    end
-
-    it 'should lock before yielding' do
-      subject.should_receive(:lock_delta).with('foo').ordered
-      subject.should_receive(:block_called).ordered
-
-      subject.with_delta_index_lock('foo', &@block)
-    end
-
-    it 'should unlock after yielding' do
-      subject.should_receive(:block_called).ordered
-      subject.should_receive(:unlock_delta).with('foo').ordered
-
-      subject.with_delta_index_lock('foo', &@block)
-    end
-  end
-
-  describe '#smart_index' do
-    include FakeFS::SpecHelpers
-
-    let(:test_path) { '/tmp/ts-resque-delta/foo' }
-
-    before :each do
-      subject.stub(:ts_config => config)
-      config.stub(:config_file => 'foo_config')
-      config.stub(:build)
-      config.stub(:searchd_file_path => test_path)
-      config.stub_chain(:controller, :index) do
-        # Set $? to 0
-        `#{File.join(SPEC_BIN_PATH, 'true.rb')}`
-      end
-
-      # Silence Generating config message
-      subject.stub(:puts)
-
-      subject.stub(:index_prefixes => indices)
-      subject.stub(:lock_delta)
-      subject.stub(:unlock_delta)
-
-      ThinkingSphinx::Deltas::ResqueDelta.stub(:prepare_for_core_index)
-      Resque.stub(:enqueue)
-    end
-
-    it 'should not generate sphinx configuration if INDEX_ONLY is true' do
-      ENV.stub(:[]).with('INDEX_ONLY').and_return('true')
-      ENV.stub(:[]).with('SILENT').and_return(nil)
-      config.should_not_receive(:build)
-
-      subject.smart_index
-    end
-
-    it 'should generate sphinx configuration if INDEX_ONLY is not true' do
-      ENV.stub(:[]).with('INDEX_ONLY').and_return(nil)
-      ENV.stub(:[]).with('SILENT').and_return(nil)
-      config.should_receive(:build).once
-
-      subject.smart_index
-    end
-
-    it 'should create the sphinx file directory' do
-      subject.smart_index
-
-      File.directory?(test_path).should be_true
-    end
-
-    it 'should index all core indices' do
-      indices.each do |index|
-        config.controller.should_receive(:index).with("#{index}_core", anything)
-      end
-
-      subject.smart_index
-    end
-
-    context "with delta lock" do
-      before :each do
-        subject.stub(:with_delta_index_lock).and_yield
-      end
-
-      it 'should index' do
-        config.controller.should_receive(:index)
-        subject.smart_index
-      end
-
-      it 'should signal resque delta to prepare for the core index' do
-        ThinkingSphinx::Deltas::ResqueDelta.should_receive(:prepare_for_core_index)
-        subject.smart_index
-      end
-    end
-
-    context "without delta lock" do
-      before :each do
-        subject.stub(:with_delta_index_lock)
-      end
-
-      it 'should not index without the delta lock' do
-        config.controller.should_not_receive(:index)
-        subject.smart_index
-      end
-
-      it 'should not signal resque delta to prepare for the core index' do
-        ThinkingSphinx::Deltas::ResqueDelta.should_not_receive(:prepare_for_core_index)
-        subject.smart_index
-      end
-    end
-
-    it 'should create a delta job after the delta is unlocked' do
-      # Create a dummy method on subject that's called when Resque.enqueue is called so we can enforce order.
-      subject.stub(:resque_called)
-      Resque.stub(:enqueue) { subject.resque_called }
-
-      Resque.should_receive(:enqueue)
-
-      subject.should_receive(:with_delta_index_lock).ordered.exactly(indices.size)
-      subject.should_receive(:resque_called).ordered.exactly(indices.size)
-
-      subject.smart_index
-    end
-
-    context 'with an error' do
-      before :each do
-        config.stub_chain(:controller, :index) do
-          # Set $? to 1
-          `#{File.join(SPEC_BIN_PATH, 'false.rb')}`
-        end
-      end
-
-      it 'should stop processing indexes after an error' do
-        config.controller.should_receive(:index).once
-
-        subject.smart_index
-      end
-
-      it 'should return false on failure' do
-        subject.smart_index.should be_false
-      end
-    end
-
-    it 'should return true on success' do
-      subject.smart_index.should be_true
-    end
-  end
-end

data/spec/thinking_sphinx/deltas/resque_delta/flag_as_deleted_set_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Deltas::ResqueDelta::FlagAsDeletedSet do
-  describe '.add' do
-    before :each do
-      Resque.stub_chain(:redis, :sadd => true)
-    end
-
-    it 'should add the document id to the correct set' do
-      Resque.redis.should_receive(:sadd).once.with(subject.set_name('foo_core'), 42)
-      subject.add('foo_core', 42)
-    end
-  end
-
-  describe '.clear!' do
-    before :each do
-      Resque.stub_chain(:redis, :del)
-      ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.stub(:around_perform_lock)
-    end
-
-    it 'should delete all items in the set' do
-      Resque.redis.should_receive(:del).once.with(subject.set_name('foo_core'))
-      subject.clear!('foo_core')
-    end
-
-    context "with DeltaJob integration" do
-      before :each do
-        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.stub(:around_perform_lock).and_yield
-      end
-
-      it 'should acquire the DeltaJob lock' do
-        ThinkingSphinx::Deltas::ResqueDelta::DeltaJob.should_receive(:around_perform_lock).once.with('foo_delta')
-        subject.clear!('foo_core')
-      end
-
-      it 'should delete all items in the processing set' do
-        Resque.redis.should_receive(:del).once.with(subject.processing_name('foo_core'))
-        subject.clear!('foo_core')
-      end
-    end
-  end
-
-  describe '.clear_all!' do
-    let(:core_indices) { %w[foo_core bar_core] }
-
-    it 'should clear each index' do
-      ThinkingSphinx::Deltas::ResqueDelta::IndexUtils.stub_chain(:core_indices, :each).tap do |s|
-        core_indices.inject(s) do |s, index|
-          s.and_yield(index)
-        end
-      end
-
-      core_indices.each do |index|
-        subject.should_receive(:clear!).with(index)
-      end
-
-      subject.clear_all!
-    end
-  end
-
-  describe '.get_subset_for_processing' do
-    let(:mock_redis) do
-      Resque.redis = mr = MockRedis.new
-      subject.add 'foo_core', 42
-      subject.add 'foo_core', 52
-      subject.add 'foo_core', 100
-      mr
-    end
-
-    before :each do
-      Resque.redis = mock_redis.clone
-    end
-
-    it 'should move all members from the flag as deleted set to the processing set' do
-      subject.get_subset_for_processing('foo_core')
-
-      Resque.redis.scard(subject.set_name('foo_core')).should eql(0)
-      Resque.redis.scard(subject.processing_name('foo_core')).should eql(3)
-    end
-
-    it 'should remove the temp set' do
-      subject.get_subset_for_processing('foo_core')
-
-      Resque.redis.scard(subject.temp_name('foo_core')).should eql(0)
-    end
-
-    it 'should preserve existing members of the processing set' do
-      Resque.redis.sadd(subject.processing_name('foo_core'), 1)
-
-      subject.get_subset_for_processing('foo_core')
-
-      Resque.redis.smembers(subject.processing_name('foo_core')).should =~ %w[1 42 52 100]
-    end
-  end
-
-  describe '.processing_members' do
-    let(:document_ids) { %w[1, 2, 3] }
-
-    before :each do
-      Resque.stub_chain(:redis, :smembers => document_ids)
-    end
-
-    it 'should get the members of the correct set' do
-      Resque.redis.should_receive(:smembers).once.with(subject.processing_name('foo_core'))
-      subject.processing_members('foo_core')
-    end
-
-    it 'should return a list of integers' do
-      subject.processing_members('foo_core').each do |id|
-        id.class.should == Fixnum
-      end
-    end
-  end
-
-  describe '.clear_processing' do
-    before :each do
-      Resque.stub_chain(:redis, :del)
-    end
-
-    it 'should delete the processing set' do
-      Resque.redis.should_receive(:del).once.with(subject.processing_name('foo_core'))
-
-      subject.clear_processing('foo_core')
-    end
-  end
-end

data/spec/thinking_sphinx/deltas/resque_delta/index_utils_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Deltas::ResqueDelta::IndexUtils do
-  let(:indices) { %w[foo_core foo_delta foo bar_core bar_delta bar] }
-  let(:config) { double('config') }
-
-  before :each do
-    ThinkingSphinx::Configuration.stub(:instance => config)
-    config.stub(:generate)
-    config.stub_chain(:configuration, :indices, :collect => indices)
-
-    subject.reload!
-  end
-
-  describe '.index_prefixes' do
-    it 'should use a cached value if one exists' do
-      indices = []
-      subject.instance_variable_set(:@prefixes, indices)
-
-      subject.index_prefixes.should be(indices)
-    end
-
-    it 'should return a list of only index prefixes' do
-      subject.index_prefixes.should =~ %w[foo bar]
-    end
-  end
-
-  describe '.core_indices' do
-    it 'should use a cached value if one exists' do
-      indices = []
-      subject.instance_variable_set(:@core_indices, indices)
-
-      subject.core_indices.should be(indices)
-    end
-
-    it 'should return a list of only core indices' do
-      subject.core_indices.should =~ %w[foo_core bar_core]
-    end
-  end
-
-  describe '.delta_indices' do
-    it 'should use a cached value if one exists' do
-      indices = []
-      subject.instance_variable_set(:@delta_indices, indices)
-
-      subject.delta_indices.should be(indices)
-    end
-
-    it 'should return a list of only delta indices' do
-      subject.delta_indices.should =~ %w[foo_delta bar_delta]
-    end
-  end
-
-  describe '.ts_config' do
-    it 'should use a cached value if one exists' do
-      subject.instance_variable_set(:@ts_config, config)
-
-      subject.ts_config.should be(config)
-    end
-
-    it 'should generate the config when fetching the Configuration instance' do
-      config.should_receive(:generate)
-
-      subject.ts_config
-    end
-  end
-end