picky 3.0.1 → 3.1.0

data/spec/lib/indexing/bundle_spec.rb

@@ -0,0 +1,302 @@
+require 'spec_helper'
+
+describe Picky::Indexing::Bundle do
+
+  before(:each) do
+    @index    = Picky::Index.new :some_index
+    @category = Picky::Category.new :some_category, @index
+    @similarity = Picky::Similarity::DoubleMetaphone.new 3
+  end
+  let(:bundle) { described_class.new :some_name, @category, Picky::Backends::Memory.new, :some_weights, :some_partial, @similarity }
+  
+  describe 'identifier' do
+    it 'is correct' do
+      bundle.identifier.should == 'test:some_index:some_category:some_name'
+    end
+  end
+  
+  describe 'similar' do
+    before(:each) do
+      bundle.similarity = @similarity.generate_from( :dragon => [1,2,3], :dargon => [4,5,6] )
+    end
+    it 'returns the right similars (not itself)' do
+      bundle.similar(:dragon).should == [:dargon]
+    end
+    it 'returns the right similars' do
+      bundle.similar(:trkn).should == [:dragon, :dargon]
+    end
+    it 'performs' do
+      performance_of { bundle.similar(:dragon) }.should < 0.000075
+    end
+    it 'performs' do
+      performance_of { bundle.similar(:trkn) }.should < 0.00006
+    end
+  end
+  
+  describe 'raise_cache_missing' do
+    it 'does something' do
+      expect {
+        bundle.raise_cache_missing :similarity
+      }.to raise_error("Error: The similarity cache for test:some_index:some_category:some_name is missing.")
+    end
+  end
+  
+  describe 'warn_cache_small' do
+    it 'warns the user' do
+      bundle.should_receive(:warn).once.with "Warning: similarity cache for test:some_index:some_category:some_name smaller than 16 bytes."
+      
+      bundle.warn_cache_small :similarity
+    end
+  end
+  
+  describe 'identifier' do
+    it 'should return a specific identifier' do
+      bundle.identifier.should == 'test:some_index:some_category:some_name'
+    end
+  end
+  
+  describe 'initialize_index_for' do
+    context 'token not yet assigned' do
+      before(:each) do
+        bundle.stub! :index => {}
+      end
+      it 'should assign it an empty array' do
+        bundle.initialize_inverted_index_for :some_token
+
+        bundle.inverted[:some_token].should == []
+      end
+    end
+    context 'token already assigned' do
+      before(:each) do
+        bundle.stub! :index => { :some_token => :already_assigned }
+      end
+      it 'should not assign it anymore' do
+        bundle.initialize_inverted_index_for :some_token
+
+        bundle.index[:some_token].should == :already_assigned
+      end
+    end
+  end
+  
+  describe 'retrieve' do
+    before(:each) do
+      prepared = stub :prepared
+      prepared.should_receive(:retrieve).once.and_yield '  1234', :some_token
+      bundle.stub! :prepared => prepared
+      
+      @ary = stub :ary
+      inverted = stub :inverted, :[] => @ary
+      bundle.stub! :inverted => inverted
+    end
+    context 'id key format' do
+      before(:each) do
+        @category.stub! :key_format => :to_i
+      end
+      it 'should call the other methods correctly' do
+        @ary.should_receive(:<<).once.with 1234
+        
+        bundle.retrieve
+      end
+    end
+    context 'other key format' do
+      before(:each) do
+        @category.stub! :key_format => :strip
+      end
+      it 'should call the other methods correctly' do
+        @ary.should_receive(:<<).once.with '1234'
+        
+        bundle.retrieve
+      end
+    end
+    context 'no key format - default' do
+      before(:each) do
+        @category.stub! :key_format => nil
+      end
+      it 'should call the other methods correctly' do
+        @ary.should_receive(:<<).once.with 1234
+        
+        bundle.retrieve
+      end
+    end
+  end
+
+  describe 'load_from_index_file' do
+    it 'should call two methods in order' do
+      bundle.should_receive(:load_from_prepared_index_generation_message).once.ordered
+      bundle.should_receive(:clear).once.ordered
+      bundle.should_receive(:retrieve).once.ordered
+
+      bundle.load_from_prepared_index_file
+    end
+  end
+
+  describe 'generate_derived' do
+    it 'should call two methods in order' do
+      bundle.should_receive(:generate_weights).once.ordered
+      bundle.should_receive(:generate_similarity).once.ordered
+
+      bundle.generate_derived
+    end
+  end
+
+  describe 'generate_caches_from_memory' do
+    it 'should call two methods in order' do
+      bundle.should_receive(:cache_from_memory_generation_message).once.ordered
+      bundle.should_receive(:generate_derived).once.ordered
+
+      bundle.generate_caches_from_memory
+    end
+  end
+
+  describe 'generate_caches_from_source' do
+    it 'should call two methods in order' do
+      bundle.should_receive(:load_from_prepared_index_file).once.ordered
+      bundle.should_receive(:generate_caches_from_memory).once.ordered
+
+      bundle.generate_caches_from_source
+    end
+  end
+  
+  describe 'dump' do
+    it 'should trigger dumps' do
+      bundle.stub! :timed_exclaim
+      
+      bundle.should_receive(:dump_inverted).once.with
+      bundle.should_receive(:dump_weights).once.with
+      bundle.should_receive(:dump_similarity).once.with
+      bundle.should_receive(:dump_configuration).once.with
+      
+      bundle.dump
+    end
+  end
+
+  describe 'raise_unless_cache_exists' do
+    it "calls methods in order" do
+      bundle.should_receive(:raise_unless_index_exists).once.ordered
+      bundle.should_receive(:raise_unless_similarity_exists).once.ordered
+      
+      bundle.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
+        bundle.stub! :partial_strategy => strategy
+      end
+      it "calls the methods in order" do
+        bundle.should_receive(:warn_if_index_small).once.ordered
+        bundle.should_receive(:raise_unless_index_ok).once.ordered
+        
+        bundle.raise_unless_index_exists
+      end
+    end
+    context 'partial strategy not saved' do
+      before(:each) do
+        strategy = stub :strategy, :saved? => false
+        bundle.stub! :partial_strategy => strategy
+      end
+      it "calls nothing" do
+        bundle.should_receive(:warn_if_index_small).never
+        bundle.should_receive(:raise_unless_index_ok).never
+        
+        bundle.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
+        bundle.stub! :similarity_strategy => strategy
+      end
+      it "calls the methods in order" do
+        bundle.should_receive(:warn_if_similarity_small).once.ordered
+        bundle.should_receive(:raise_unless_similarity_ok).once.ordered
+        
+        bundle.raise_unless_similarity_exists
+      end
+    end
+    context 'similarity strategy not saved' do
+      before(:each) do
+        strategy = stub :strategy, :saved? => false
+        bundle.stub! :similarity_strategy => strategy
+      end
+      it "calls nothing" do
+        bundle.should_receive(:warn_if_similarity_small).never
+        bundle.should_receive(:raise_unless_similarity_ok).never
+        
+        bundle.raise_unless_similarity_exists
+      end
+    end
+  end
+  describe 'warn_if_similarity_small' do
+    context "files similarity cache small" do
+      before(:each) do
+        bundle.stub! :backend_similarity => stub(:backend_similarity, :cache_small? => true)
+      end
+      it "warns" do
+        bundle.should_receive(:warn_cache_small).once.with :similarity
+        
+        bundle.warn_if_similarity_small
+      end
+    end
+    context "files similarity cache not small" do
+      before(:each) do
+        bundle.stub! :backend_similarity => stub(:backend_similarity, :cache_small? => false)
+      end
+      it "does not warn" do
+        bundle.should_receive(:warn_cache_small).never
+        
+        bundle.warn_if_similarity_small
+      end
+    end
+  end
+  describe 'raise_unless_similarity_ok' do
+    context "files similarity cache ok" do
+      before(:each) do
+        bundle.stub! :backend_similarity => stub(:backend_similarity, :cache_ok? => true)
+      end
+      it "warns" do
+        bundle.should_receive(:raise_cache_missing).never
+        
+        bundle.raise_unless_similarity_ok
+      end
+    end
+    context "files similarity cache not ok" do
+      before(:each) do
+        bundle.stub! :backend_similarity => stub(:backend_similarity, :cache_ok? => false)
+      end
+      it "does not warn" do
+        bundle.should_receive(:raise_cache_missing).once.with :similarity
+        
+        bundle.raise_unless_similarity_ok
+      end
+    end
+  end
+  
+  describe 'initialization' do
+    it 'should initialize the index correctly' do
+      bundle.inverted.should == {}
+    end
+    it 'should initialize the weights index correctly' do
+      bundle.weights.should == {}
+    end
+    it 'should initialize the similarity index correctly' do
+      bundle.similarity.should == {}
+    end
+    it 'should initialize the configuration correctly' do
+      bundle.configuration.should == {}
+    end
+    # it 'should initialize the partial strategy correctly' do
+    #   bundle.partial_strategy.should == @partial
+    # end
+    # it 'should initialize the weights strategy correctly' do
+    #   bundle.weights_strategy.should == @weights
+    # end
+    it 'should initialize the similarity strategy correctly' do
+      bundle.similarity_strategy.should == @similarity
+    end
+  end
+  
+end

data/spec/lib/query/allocation_spec.rb

@@ -3,8 +3,10 @@ require 'spec_helper'
 describe Picky::Query::Allocation do
   
   before(:each) do
+    @backend      = stub :backend
+    @index        = stub :index, :result_identifier => :some_result_identifier, :backend => @backend
     @combinations = stub :combinations
-    @allocation = described_class.new @combinations, :some_result_identifier
+    @allocation   = described_class.new @index, @combinations
   end
   
   describe "eql?" do
@@ -130,11 +132,13 @@ describe Picky::Query::Allocation do
   describe 'to_result' do
     context 'with few combinations' do
       before(:each) do
-        @allocation = described_class.new stub(:combinations, :ids => [1,2,3], :to_result => [:some_result]), :some_result_identifier
+        @allocation = described_class.new @index, stub(:combinations, :to_result => [:some_result])
         @allocation.instance_variable_set :@score, :some_score
       end
       context 'with ids' do
         it 'should output an array of information' do
+          @backend.stub! :ids => [1,2,3]
+          
           @allocation.process! 20, 0
 
           @allocation.to_result.should == [:some_result_identifier, :some_score, 3, [:some_result], [1, 2, 3]]
@@ -143,12 +147,14 @@ describe Picky::Query::Allocation do
     end
     context 'with results' do
       before(:each) do
-        combinations = stub :combinations, :ids => [1,2,3], :to_result => [:some_result1, :some_result2]
-        @allocation = described_class.new combinations, :some_result_identifier
+        combinations = stub :combinations, :to_result => [:some_result1, :some_result2]
+        @allocation = described_class.new @index, combinations
         @allocation.instance_variable_set :@score, :some_score
       end
       context 'with ids' do
         it 'should output an array of information' do
+          @backend.stub! :ids => [1,2,3]
+          
           @allocation.process! 20, 0
 
           @allocation.to_result.should == [:some_result_identifier, :some_score, 3, [:some_result1, :some_result2], [1, 2, 3]]
@@ -157,10 +163,12 @@ describe Picky::Query::Allocation do
     end
     context 'without results' do
       before(:each) do
-        @allocation = described_class.new stub(:combinations, :ids => [], :to_result => []), :some_result_identifier
+        @allocation = described_class.new @index, stub(:combinations, :to_result => [])
         @allocation.instance_variable_set :@score, :some_score
       end
       it 'should return nil' do
+        @backend.stub! :ids => []
+        
         @allocation.process! 20, 0
 
         @allocation.to_result.should == nil
@@ -170,10 +178,12 @@ describe Picky::Query::Allocation do
 
   describe 'to_json' do
     before(:each) do
-      @allocation = described_class.new stub(:combination, :ids => [1,2,3,4,5,6,7], :to_result => [:some_result1, :some_result2]), :some_result_identifier
+      @allocation = described_class.new @index, stub(:combination, :to_result => [:some_result1, :some_result2])
       @allocation.instance_variable_set :@score, :some_score
     end
     it 'should output the correct json string' do
+      @backend.stub! :ids => [1,2,3,4,5,6,7]
+      
       @allocation.process! 20, 0
 
       @allocation.to_json.should == '["some_result_identifier","some_score",7,["some_result1","some_result2"],[1,2,3,4,5,6,7]]'
@@ -190,9 +200,9 @@ describe Picky::Query::Allocation do
 
   describe "<=>" do
     it "should sort higher first" do
-      first = described_class.new [], :some_result_identifier
+      first = described_class.new @index, []
       first.instance_variable_set :@score, 20
-      second = described_class.new [], :some_result_identifier
+      second = described_class.new @index, []
       second.instance_variable_set :@score, 10
 
       first.<=>(second).should == -1
@@ -201,11 +211,11 @@ describe Picky::Query::Allocation do
 
   describe "sort!" do
     it "should sort correctly" do
-      first = described_class.new :whatever, :some_result_identifier
+      first = described_class.new @index, :whatever
       first.instance_variable_set :@score, 20
-      second = described_class.new :whatever, :some_result_identifier
+      second = described_class.new @index, :whatever
       second.instance_variable_set :@score, 10
-      third = described_class.new :whatever, :some_result_identifier
+      third = described_class.new @index, :whatever
       third.instance_variable_set :@score, 5
 
       allocations = [second, third, first]

data/spec/lib/query/combination_spec.rb

@@ -6,7 +6,7 @@ describe Picky::Query::Combination do
 
   before(:each) do
     @bundle      = stub :bundle, :identifier => :bundle_name
-    @token       = Picky::Query::Token.processed('some_text~')
+    @token       = Picky::Query::Token.processed('some_text~', 'Some Original~')
     @category    = stub :category, :bundle_for => @bundle, :name => :some_category_name
 
     @combination = described_class.new @token, @category
@@ -41,7 +41,7 @@ describe Picky::Query::Combination do
   describe 'to_result' do
     context 'functional with qualifier' do
       before(:each) do
-        token = Picky::Tokenizers::Query.new.tokenize('name:Blä~').first
+        token = Picky::Query::Token.processed 'name:blä~', 'Blä~'
 
         @combination = Picky::Query::Combination.new token, @category
       end

data/spec/lib/query/{combinations/base_spec.rb → combinations_spec.rb}

@@ -2,7 +2,7 @@
 #
 require 'spec_helper'
 
-describe Picky::Query::Combinations::Base do
+describe Picky::Query::Combinations do
 
   before(:each) do
     @combinations_ary = stub :combinations_ary

data/spec/lib/query/indexes_check_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Picky::Query::IndexesCheck do
+
+  describe 'check_backend_types' do
+    before(:each) do
+      @redis  = stub :redis,  :backend => Picky::Backends::Redis.new
+      @memory = stub :memory, :backend => Picky::Backends::Memory.new
+    end
+    it 'does not raise on the same type' do
+      described_class.check_backend_types [@redis, @redis]
+    end
+    it 'raises on multiple types' do
+      expect do
+        described_class.check_backend_types [@redis, @memory]
+      end.to raise_error(Picky::Query::DifferentTypesError)
+    end
+    it 'raises with the right message on multiple types' do
+      expect do
+        described_class.check_backend_types [@redis, @memory]
+      end.to raise_error("Currently it isn't possible to mix Indexes with backends Picky::Backends::Redis and Picky::Backends::Memory in the same Search instance.")
+    end
+  end
+  
+end

data/spec/lib/query/indexes_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
 describe Picky::Query::Indexes do
-
+  
+  before(:each) do
+    Picky::Query::IndexesCheck.stub! :check_backend_types
+  end
+  
   3.times do |i|
     n       = i + 1
     name    = :"index#{n}"

data/spec/lib/query/token_spec.rb

@@ -5,10 +5,10 @@ describe Picky::Query::Token do
   
   describe '==' do
     it 'is equal if the originals are equal' do
-      described_class.processed('similar~').should == described_class.processed('similar~')
+      described_class.processed('similar~', 'Similar~').should == described_class.processed('similar~', 'Similar~')
     end
     it 'is not equal if the originals are not equal' do
-      described_class.processed('similar~').should_not == described_class.processed('similar')
+      described_class.processed('similar~', 'Similar~').should_not == described_class.processed('similar', 'Similar')
     end
   end
   
@@ -17,7 +17,7 @@ describe Picky::Query::Token do
       @bundle   = stub :bundle, :similar => [:array, :of, :similar]
       @category = stub :category, :bundle_for => @bundle
       
-      @token = described_class.processed 'similar~'
+      @token = described_class.processed 'similar~', 'Similar~'
     end
     it 'returns the right next tokens' do
       next_token = @token.next_similar_token @category
@@ -40,7 +40,7 @@ describe Picky::Query::Token do
         before(:each) do
           @bundle.stub! :similar => [:array, :of, :similar]
 
-          @token = described_class.processed 'similar~'
+          @token = described_class.processed 'similar~', 'Similar'
         end
         it 'should have a certain original text' do
           @token.next_similar @bundle
@@ -54,7 +54,7 @@ describe Picky::Query::Token do
         before(:each) do
           @bundle.stub! :similar => [:array, :of, :similar]
 
-          @token = described_class.processed 'similar~'
+          @token = described_class.processed 'similar~', 'Similar'
         end
         it 'generates all similar' do
           @token.next_similar(@bundle).should == :array
@@ -77,7 +77,7 @@ describe Picky::Query::Token do
         before(:each) do
           @bundle.stub! :similar => [:array, :of, :similar]
 
-          @token = described_class.processed 'nonsimilar'
+          @token = described_class.processed 'nonsimilar', 'Nonsimilar'
         end
         it 'generates all similar' do
           @token.next_similar(@bundle).should == nil
@@ -95,7 +95,7 @@ describe Picky::Query::Token do
     before(:each) do
       @bundle = stub :bundle
       
-      @token = described_class.processed 'flarb~'
+      @token = described_class.processed 'flarb~', 'FLARB~'
     end
     context "with similar" do
       before(:each) do
@@ -177,10 +177,10 @@ describe Picky::Query::Token do
 
   describe 'processed' do
     it 'should return a new token' do
-      described_class.processed('some text').should be_kind_of(described_class)
+      described_class.processed('some text', 'SOME TEXT').should be_kind_of(described_class)
     end
     it 'generates a token' do
-      described_class.processed('some text').class.should == described_class
+      described_class.processed('some text', 'SOME TEXT').class.should == described_class
     end
   end
   
@@ -191,8 +191,6 @@ describe Picky::Query::Token do
     end
     it 'should have an order' do
       token.should_receive(:qualify).once.ordered
-      token.should_receive(:extract_original).once.ordered
-      token.should_receive(:downcase).once.ordered
       token.should_receive(:partialize).once.ordered
       token.should_receive(:similarize).once.ordered
       token.should_receive(:remove_illegals).once.ordered
@@ -205,7 +203,7 @@ describe Picky::Query::Token do
   describe 'partial?' do
     context 'similar, partial' do
       before(:each) do
-        @token = described_class.processed 'similar~'
+        @token = described_class.processed 'similar~', 'Similar~'
         @token.partial = true
       end
       it 'should be false' do
@@ -214,7 +212,7 @@ describe Picky::Query::Token do
     end
     context 'similar, not partial' do
       before(:each) do
-        @token = described_class.processed 'similar~'
+        @token = described_class.processed 'similar~', 'Similar~'
       end
       it 'should be false' do
         @token.partial?.should == false
@@ -222,7 +220,7 @@ describe Picky::Query::Token do
     end
     context 'not similar, partial' do
       before(:each) do
-        @token = described_class.processed 'not similar'
+        @token = described_class.processed 'not similar', 'NOT SIMILAR'
         @token.partial = true
       end
       it 'should be true' do
@@ -231,7 +229,7 @@ describe Picky::Query::Token do
     end
     context 'not similar, not partial' do
       before(:each) do
-        @token = described_class.processed 'not similar'
+        @token = described_class.processed 'not similar', 'NOT SIMILAR'
       end
       it 'should be nil' do
         @token.partial?.should == nil
@@ -241,12 +239,12 @@ describe Picky::Query::Token do
 
   describe 'similar' do
     it 'should not change the original with the text' do
-      token = described_class.processed "bla~"
+      token = described_class.processed "bla~", 'BLA~'
       token.text.should_not == token.original
     end
     def self.it_should_have_similarity text, expected_similarity_value
       it "should have #{ "no" unless expected_similarity_value } similarity for '#{text}'" do
-        described_class.processed(text).similar?.should == expected_similarity_value
+        described_class.processed(text, text.upcase).similar?.should == expected_similarity_value
       end
     end
     it_should_have_similarity 'name:',      nil
@@ -266,7 +264,7 @@ describe Picky::Query::Token do
 
   describe 'special cases' do
     it 'should be blank on ""' do
-      token = described_class.processed '""'
+      token = described_class.processed '""', '""'
 
       token.should be_blank
     end
@@ -274,9 +272,9 @@ describe Picky::Query::Token do
 
   describe "original" do
     it "should keep the original text even when processed" do
-      token = described_class.processed "I'm the original token text."
+      token = described_class.processed "I'm the processed text.", "I'm the original text."
 
-      token.original.should == "I'm the original token text."
+      token.original.should == "I'm the original text."
     end
   end