picky 2.0.0.pre2 → 2.0.0.pre3

data/spec/lib/internals/indexing/bundle/redis_spec.rb

@@ -0,0 +1,282 @@
+require 'spec_helper'
+
+describe Internals::Indexing::Bundle::Redis do
+
+  before(:each) do
+    @internal_index = stub :index, :name => :some_index
+    @category       = stub :category, :name => :some_category
+    @configuration  = Configuration::Index.new @internal_index, @category
+    
+    @partial     = stub :partial
+    @weights     = stub :weights
+    @similarity  = stub :similarity
+  end
+  let(:index) { described_class.new :some_name, @configuration, @similarity, @partial, @weights }
+
+  describe 'raise_cache_missing' do
+    it 'does something' do
+      expect {
+        index.raise_cache_missing :similarity
+      }.to raise_error("Error: The similarity cache for some_index:some_category:some_name is missing.")
+    end
+  end
+  
+  describe 'warn_cache_small' do
+    it 'warns the user' do
+      index.should_receive(:warn).once.with "Warning: similarity cache for some_index:some_category:some_name smaller than 16 bytes."
+      
+      index.warn_cache_small :similarity
+    end
+  end
+
+  describe 'identifier' do
+    it 'should return a specific identifier' do
+      index.identifier.should == 'some_index:some_category:some_name'
+    end
+  end
+  
+  describe 'initialize_index_for' do
+    context 'token not yet assigned' do
+      before(:each) do
+        index.stub! :index => {}
+      end
+      it 'should assign it an empty array' do
+        index.initialize_index_for :some_token
+
+        index.index[:some_token].should == []
+      end
+    end
+    context 'token already assigned' do
+      before(:each) do
+        index.stub! :index => { :some_token => :already_assigned }
+      end
+      it 'should not assign it anymore' do
+        index.initialize_index_for :some_token
+
+        index.index[:some_token].should == :already_assigned
+      end
+    end
+  end
+  
+  describe 'retrieve' do
+    before(:each) do
+      files = stub :files
+      files.should_receive(:retrieve).once.and_yield '  1234', :some_token
+      index.stub! :files => files
+      
+      @ary = stub :ary
+      @internal_index.should_receive(:[]).any_number_of_times.and_return @ary
+      index.stub! :index => @internal_index
+    end
+    context 'id key format' do
+      before(:each) do
+        index.should_receive(:[]).once.with(:key_format).and_return :to_i
+      end
+      it 'should call the other methods correctly' do
+        @ary.should_receive(:<<).once.with 1234
+        
+        index.retrieve
+      end
+    end
+    context 'other key format' do
+      before(:each) do
+        index.should_receive(:[]).once.with(:key_format).and_return :strip
+      end
+      it 'should call the other methods correctly' do
+        @ary.should_receive(:<<).once.with '1234'
+        
+        index.retrieve
+      end
+    end
+    context 'no key format - default' do
+      before(:each) do
+        index.should_receive(:[]).once.with(:key_format).and_return nil
+      end
+      it 'should call the other methods correctly' do
+        @ary.should_receive(:<<).once.with 1234
+        
+        index.retrieve
+      end
+    end
+  end
+
+  describe 'load_from_index_file' do
+    it 'should call two methods in order' do
+      index.should_receive(:load_from_index_generation_message).once.ordered
+      index.should_receive(:clear).once.ordered
+      index.should_receive(:retrieve).once.ordered
+
+      index.load_from_index_file
+    end
+  end
+
+  describe 'generate_derived' do
+    it 'should call two methods in order' do
+      index.should_receive(:generate_weights).once.ordered
+      index.should_receive(:generate_similarity).once.ordered
+
+      index.generate_derived
+    end
+  end
+
+  describe 'generate_caches_from_memory' do
+    it 'should call two methods in order' do
+      index.should_receive(:cache_from_memory_generation_message).once.ordered
+      index.should_receive(:generate_derived).once.ordered
+
+      index.generate_caches_from_memory
+    end
+  end
+
+  describe 'generate_caches_from_source' do
+    it 'should call two methods in order' do
+      index.should_receive(:load_from_index_file).once.ordered
+      index.should_receive(:generate_caches_from_memory).once.ordered
+
+      index.generate_caches_from_source
+    end
+  end
+  
+  describe 'dump' do
+    it 'should trigger dumps' do
+      index.should_receive(:dump_index).once.with
+      index.should_receive(:dump_weights).once.with
+      index.should_receive(:dump_similarity).once.with
+      index.should_receive(:dump_configuration).once.with
+      
+      index.dump
+    end
+  end
+
+  describe 'raise_unless_cache_exists' do
+    it "calls methods in order" do
+      index.should_receive(:raise_unless_index_exists).once.ordered
+      index.should_receive(:raise_unless_similarity_exists).once.ordered
+      
+      index.raise_unless_cache_exists
+    end
+  end
+  describe 'raise_unless_index_exists' do
+    context 'partial strategy saved' do
+      before(:each) do
+        strategy = stub :strategy, :saved? => true
+        index.stub! :partial_strategy => strategy
+      end
+      it "calls the methods in order" do
+        index.should_receive(:warn_if_index_small).once.ordered
+        index.should_receive(:raise_unless_index_ok).once.ordered
+        
+        index.raise_unless_index_exists
+      end
+    end
+    context 'partial strategy not saved' do
+      before(:each) do
+        strategy = stub :strategy, :saved? => false
+        index.stub! :partial_strategy => strategy
+      end
+      it "calls nothing" do
+        index.should_receive(:warn_if_index_small).never
+        index.should_receive(:raise_unless_index_ok).never
+        
+        index.raise_unless_index_exists
+      end
+    end
+  end
+  describe 'raise_unless_similarity_exists' do
+    context 'similarity strategy saved' do
+      before(:each) do
+        strategy = stub :strategy, :saved? => true
+        index.stub! :similarity_strategy => strategy
+      end
+      it "calls the methods in order" do
+        index.should_receive(:warn_if_similarity_small).once.ordered
+        index.should_receive(:raise_unless_similarity_ok).once.ordered
+        
+        index.raise_unless_similarity_exists
+      end
+    end
+    context 'similarity strategy not saved' do
+      before(:each) do
+        strategy = stub :strategy, :saved? => false
+        index.stub! :similarity_strategy => strategy
+      end
+      it "calls nothing" do
+        index.should_receive(:warn_if_similarity_small).never
+        index.should_receive(:raise_unless_similarity_ok).never
+        
+        index.raise_unless_similarity_exists
+      end
+    end
+  end
+  describe 'warn_if_similarity_small' do
+    let(:backend) { index.backend }
+    context "files similarity cache small" do
+      before(:each) do
+        backend.stub! :similarity_cache_small? => true
+      end
+      it "warns" do
+        index.should_receive(:warn_cache_small).once.with :similarity
+        
+        index.warn_if_similarity_small
+      end
+    end
+    context "files similarity cache not small" do
+      before(:each) do
+        backend.stub! :similarity_cache_small? => false
+      end
+      it "does not warn" do
+        index.should_receive(:warn_cache_small).never
+        
+        index.warn_if_similarity_small
+      end
+    end
+  end
+  describe 'raise_unless_similarity_ok' do
+    let(:backend) { index.backend }
+    context "files similarity cache ok" do
+      before(:each) do
+        backend.stub! :similarity_cache_ok? => true
+      end
+      it "warns" do
+        index.should_receive(:raise_cache_missing).never
+        
+        index.raise_unless_similarity_ok
+      end
+    end
+    context "files similarity cache not ok" do
+      before(:each) do
+        backend.stub! :similarity_cache_ok? => false
+      end
+      it "does not warn" do
+        index.should_receive(:raise_cache_missing).once.with :similarity
+        
+        index.raise_unless_similarity_ok
+      end
+    end
+  end
+  
+  describe 'initialization' do
+    it 'should initialize the index correctly' do
+      index.index.should == {}
+    end
+    it 'should initialize the weights index correctly' do
+      index.weights.should == {}
+    end
+    it 'should initialize the similarity index correctly' do
+      index.similarity.should == {}
+    end
+    it 'should initialize the configuration correctly' do
+      index.configuration.should == {}
+    end
+    it 'should initialize the partial strategy correctly' do
+      index.partial_strategy.should == @partial
+    end
+    it 'should initialize the weights strategy correctly' do
+      index.weights_strategy.should == @weights
+    end
+    it 'should initialize the similarity strategy correctly' do
+      index.similarity_strategy.should == @similarity
+    end
+  end
+
+end

data/spec/lib/internals/indexing/bundle/super_base_spec.rb

@@ -5,7 +5,7 @@ describe Internals::Indexing::Bundle::SuperBase do
   before(:each) do
     @configuration = stub :configuration, :identifier => 'some_identifier'
     Internals::Index::Files.stub! :new
-    @similarity = Similarity::Phonetic.new 3
+    @similarity = Similarity::DoubleMetaphone.new 3
     @bundle = described_class.new :some_name, @configuration, @similarity
   end
   

data/spec/lib/internals/indexing/categories_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Internals::Indexing::Categories do
+  
+  let(:categories) { described_class.new }
+
+  describe 'to_s' do
+    context 'no categories' do
+      it 'outputs the right thing' do
+        categories.to_s.should == ""
+      end
+    end
+    context 'with categories' do
+      before(:each) do
+        index = stub :index, :name => :some_name
+        categories << Internals::Indexing::Category.new(:some_name, index, :source => stub(:source))
+      end
+      it 'outputs the right thing' do
+        categories.to_s.should == "  Category(some_name from some_name):\n  Exact:\n    Memory\n  Partial:\n    Memory\n"
+      end
+    end
+  end
+  
+  describe 'find' do
+    context 'no categories' do
+      it 'raises on none existent category' do
+        expect do
+          categories.find :some_non_existent_name
+        end.to raise_error(%Q{Index category "some_non_existent_name" not found. Possible categories: "".})
+      end
+    end
+    context 'with categories' do
+      before(:each) do
+        index = stub :index, :name => :some_name
+        @category = Internals::Indexing::Category.new(:some_name, index, :source => stub(:source))
+        categories << @category
+      end
+      it 'returns it if found' do
+        categories.find(:some_name).should == @category
+      end
+      it 'raises on none existent category' do
+        expect do
+          categories.find :some_non_existent_name
+        end.to raise_error(%Q{Index category "some_non_existent_name" not found. Possible categories: "some_name".})
+      end
+    end
+  end
+  
+end

data/spec/lib/internals/indexing/category_spec.rb

@@ -5,103 +5,136 @@ describe Internals::Indexing::Category do
   before(:each) do
     @index  = stub :index, :name => :some_index
     @source = stub :some_given_source, :key_format => nil
-    @category = described_class.new :some_category, @index, :source => @source
   end
+  let(:category) { described_class.new(:some_category, @index, :source => @source).tap { |c| c.stub! :timed_exclaim } }
+  
   context "unit specs" do
-    before(:each) do
-      @exact = @category.exact
-      @partial = @category.partial
+    let(:exact) { category.exact }
+    let(:partial) { category.partial }
+    
+    describe 'backup_caches' do
+      it 'delegates to both bundles' do
+        exact.should_receive(:backup).once.with()
+        partial.should_receive(:backup).once.with()
+        
+        category.backup_caches
+      end
+    end
+    describe 'restore_caches' do
+      it 'delegates to both bundles' do
+        exact.should_receive(:restore).once.with()
+        partial.should_receive(:restore).once.with()
+        
+        category.restore_caches
+      end
     end
+    describe 'check_caches' do
+      it 'delegates to both bundles' do
+        exact.should_receive(:raise_unless_cache_exists).once.with()
+        partial.should_receive(:raise_unless_cache_exists).once.with()
+        
+        category.check_caches
+      end
+    end
+    describe 'clear_caches' do
+      it 'delegates to both bundles' do
+        exact.should_receive(:delete).once.with()
+        partial.should_receive(:delete).once.with()
+        
+        category.clear_caches
+      end
+    end
+    
     describe 'dump_caches' do
       before(:each) do
-        @exact.stub! :dump
-        @partial.stub! :dump
+        exact.stub! :dump
+        partial.stub! :dump
       end
       it 'should dump the exact index' do
-        @exact.should_receive(:dump).once.with
+        exact.should_receive(:dump).once.with
 
-        @category.dump_caches
+        category.dump_caches
       end
       it 'should dump the partial index' do
-        @partial.should_receive(:dump).once.with
+        partial.should_receive(:dump).once.with
 
-        @category.dump_caches
+        category.dump_caches
       end
     end
     
     describe 'generate_caches_from_memory' do
       it 'should delegate to partial' do
-        @partial.should_receive(:generate_caches_from_memory).once.with
+        partial.should_receive(:generate_caches_from_memory).once.with
         
-        @category.generate_caches_from_memory
+        category.generate_caches_from_memory
       end
     end
     
     describe 'generate_partial' do
       it 'should return whatever the partial generation returns' do
-        @exact.stub! :index
-        @partial.stub! :generate_partial_from => :generation_returns
+        exact.stub! :index
+        partial.stub! :generate_partial_from => :generation_returns
 
-        @category.generate_partial
+        category.generate_partial
       end
       it 'should use the exact index to generate the partial index' do
         exact_index = stub :exact_index
-        @exact.stub! :index => exact_index
-        @partial.should_receive(:generate_partial_from).once.with(exact_index)
+        exact.stub! :index => exact_index
+        partial.should_receive(:generate_partial_from).once.with(exact_index)
 
-        @category.generate_partial
+        category.generate_partial
       end
     end
 
     describe 'generate_caches_from_source' do
       it 'should delegate to exact' do
-        @exact.should_receive(:generate_caches_from_source).once.with
+        exact.should_receive(:generate_caches_from_source).once.with
 
-        @category.generate_caches_from_source
+        category.generate_caches_from_source
       end
     end
 
     describe 'generate_caches' do
       it 'should call multiple methods in order' do
-        @category.should_receive(:generate_caches_from_source).once.with().ordered
-        @category.should_receive(:generate_partial).once.with().ordered
-        @category.should_receive(:generate_caches_from_memory).once.with().ordered
-        @category.should_receive(:dump_caches).once.with().ordered
-        @category.should_receive(:timed_exclaim).once.ordered
+        category.should_receive(:generate_caches_from_source).once.with().ordered
+        category.should_receive(:generate_partial).once.with().ordered
+        category.should_receive(:generate_caches_from_memory).once.with().ordered
+        category.should_receive(:dump_caches).once.with().ordered
+        category.should_receive(:timed_exclaim).once.ordered
         
-        @category.generate_caches
+        category.generate_caches
       end
     end
     
     describe "cache" do
       before(:each) do
-        @category.stub! :generate_caches
+        category.stub! :generate_caches
       end
       it "prepares the cache directory" do
-        @category.should_receive(:prepare_index_directory).once.with
+        category.should_receive(:prepare_index_directory).once.with
         
-        @category.cache
+        category.cache
       end
       it "tells the indexer to index" do
-        @category.should_receive(:generate_caches).once.with
+        category.should_receive(:generate_caches).once.with
         
-        @category.cache
+        category.cache
       end
     end
     describe "index" do
       before(:each) do
         @indexer = stub :indexer, :index => nil
-        @category.stub! :indexer => @indexer
+        category.stub! :indexer => @indexer
       end
       it "prepares the cache directory" do
-        @category.should_receive(:prepare_index_directory).once.with
+        category.should_receive(:prepare_index_directory).once.with
         
-        @category.index
+        category.index
       end
       it "tells the indexer to index" do
         @indexer.should_receive(:index).once.with
         
-        @category.index
+        category.index
       end
     end
     describe "source" do

data/spec/lib/query/combinations/base_spec.rb

@@ -10,15 +10,6 @@ describe Internals::Query::Combinations::Base do
     @combinations = described_class.new @combinations_ary
   end
   
-  describe "pack_into_allocation" do
-    it "return an Allocation" do
-      @combinations.pack_into_allocation(:some_result_identifier).should be_kind_of(Internals::Query::Allocation)
-    end
-    it "returns an Allocation with specific result_identifier" do
-      @combinations.pack_into_allocation(:some_result_identifier).result_identifier.should == :some_result_identifier
-    end
-  end
-  
   describe "to_result" do
     before(:each) do
       @combination1 = stub :combination1, :to_result => :result1

data/spec/lib/query/combinations/memory_spec.rb

@@ -10,15 +10,6 @@ describe Internals::Query::Combinations::Memory do
     @combinations = described_class.new @combinations_ary
   end
   
-  describe "pack_into_allocation" do
-    it "return an Allocation" do
-      @combinations.pack_into_allocation(:some_result_identifier).should be_kind_of(Internals::Query::Allocation)
-    end
-    it "returns an Allocation with specific result_identifier" do
-      @combinations.pack_into_allocation(:some_result_identifier).result_identifier.should == :some_result_identifier
-    end
-  end
-  
   describe "to_result" do
     before(:each) do
       @combination1 = stub :combination1, :to_result => :result1

data/spec/lib/query/combinations/redis_spec.rb

@@ -10,12 +10,47 @@ describe Internals::Query::Combinations::Redis do
     @combinations = described_class.new @combinations_ary
   end
   
-  describe "pack_into_allocation" do
-    it "return an Allocation" do
-      @combinations.pack_into_allocation(:some_result_identifier).should be_kind_of(Internals::Query::Allocation)
+  describe 'ids' do
+    context 'empty combinations' do
+      let(:combinations) { described_class.new [] }
+      it 'does something' do
+        combinations.ids(20,0).should == []
+      end
+    end
+    context 'non-empty' do
+      let(:combination) { stub :combination, :identifier => :some_combination }
+      let(:combinations) { described_class.new [combination] }
+      let(:redis) { stub :redis }
+      before(:each) do
+        combinations.stub! :redis => redis
+        
+        combinations.stub! :host => 'some.host'
+        combinations.stub! :pid  => 12345
+      end
+      it 'calls the redis backend correctly' do
+        redis.should_receive(:zinterstore).once.ordered.with :"some.host:12345:picky:result", ["some_combination"]
+        redis.should_receive(:zrange).once.ordered.with :"some.host:12345:picky:result", 0, 20
+        redis.should_receive(:del).once.ordered.with :"some.host:12345:picky:result"
+        
+        combinations.ids 20,0
+      end
     end
-    it "returns an Allocation with specific result_identifier" do
-      @combinations.pack_into_allocation(:some_result_identifier).result_identifier.should == :some_result_identifier
+  end
+  
+  describe 'pid' do
+    it "returns the Process' pid" do
+      Process.stub! :pid => 12345
+
+      @combinations.pid.should == 12345
+    end
+  end
+  
+  describe 'host' do
+    before(:each) do
+      @combinations.class.stub! :extract_host => 'some.host'
+    end
+    it 'returns the host' do
+      @combinations.host.should == 'some.host'
     end
   end
   

data/spec/lib/sources/couch_spec.rb

@@ -2,6 +2,28 @@ require 'spec_helper'
 
 describe Sources::Couch do
   
+  describe 'key_format' do
+    context 'default' do
+      let(:source) { Sources::Couch.new(:a, :b, url: 'bla') }
+      it 'is correct' do
+        source.key_format.should == :to_sym
+      end
+    end
+    context 'non-default' do
+      let(:source) { Sources::Couch.new(:a, :b, url: 'bla', key_format: 'some_key_method') }
+      it 'is correct' do
+        source.key_format.should == :some_key_method
+      end
+    end
+  end
+  
+  describe 'to_s' do
+    let(:source) { Sources::Couch.new(:a, :b, :url => 'bla') }
+    it 'is correct' do
+      source.to_s.should == 'Sources::Couch'
+    end
+  end
+  
   describe 'special keys' do
     context 'uuid keys' do
       context "with database" do

data/spec/lib/sources/csv_spec.rb

@@ -3,6 +3,13 @@ require 'csv'
 
 describe Sources::CSV do
   
+  describe 'to_s' do
+    let(:source) { described_class.new :a, :b, :c, file:'some/file.csv' }
+    it 'outputs the correct string' do
+      source.to_s.should == 'Sources::CSV(a, b, c, {:file=>"some/file.csv"})'
+    end
+  end
+  
   describe 'without separator' do
     before(:each) do
       @source = Sources::CSV.new :a, :b, :c, :file => :some_file

data/spec/lib/sources/db_spec.rb

@@ -8,7 +8,7 @@ describe Sources::DB do
     @connection = stub :connection
     @adapter    = stub :adapter, :connection => @connection
     
-    @select_statement = stub :statement
+    @select_statement = stub :statement, :inspect => '"some statement"'
     
     @source = described_class.new @select_statement, :option => :some_options
     
@@ -16,6 +16,12 @@ describe Sources::DB do
     @source.stub! :connect_backend
   end
   
+  describe 'to_s' do
+    it 'does something' do
+      @source.to_s.should == 'Sources::DB("some statement", {:option=>:some_options})'
+    end
+  end
+  
   describe "get_data" do
     before(:each) do
       @type     = stub :type,     :name => :some_type

data/spec/lib/sources/delicious_spec.rb

@@ -1,11 +1,15 @@
 require 'spec_helper'
 
-# TODO Slow spec.
-#
 describe Sources::Delicious do
   
   context "with file" do
     
+    describe 'to_s' do
+      it 'outputs correctly' do
+        described_class.new(:username, :password).to_s.should == 'Sources::Delicious(username)'
+      end
+    end
+    
     describe "check_gem" do
       before(:each) do
         @source = Sources::Delicious.allocate