picky 0.0.0 → 0.0.2

data/spec/lib/query/combination_spec.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+#
+require 'spec_helper'
+
+describe 'Query::Combination' do
+
+  before(:each) do
+    @bundle      = stub :bundle
+    @token       = stub :token, :text => :some_text, :partial => false, :similar? => true
+    @category    = stub :category, :bundle_for => @bundle, :name => :some_category_name
+
+    @combination = Query::Combination.new @token, @category
+  end
+
+  describe 'hash' do
+    it 'should hash the token and the bundle' do
+      @combination.hash.should == [@token.to_s, @bundle].hash
+    end
+  end
+
+  describe 'in?' do
+    before(:each) do
+      @combination.stub! :identifier => :some_identifier
+    end
+    it 'should check if the given identifiers include the identifier' do
+      @combination.in?([:some_other_identifier, :some_identifier, :some_other_identifier]).should == true
+    end
+    it 'should check if the given identifiers include the identifier' do
+      @combination.in?([:some_other_identifier, :some_other_identifier]).should == false
+    end
+  end
+
+  describe 'to_result' do
+    context 'functional with qualifier' do
+      before(:each) do
+        token = Tokenizers::Query.new.tokenize('name:Blä~').first
+
+        @combination = Query::Combination.new token, @category
+      end
+      it 'should return a correct result' do
+        @combination.to_result.should == [:some_category_name, 'Blä~', :blae]
+      end
+    end
+    it 'should return a correct result' do
+      @token.stub! :to_result => [:some_original_text, :some_text]
+      @combination.stub! :identifier => :some_identifier
+
+      @combination.to_result.should == [:some_identifier, :some_original_text, :some_text]
+    end
+  end
+
+  describe 'identifier' do
+    it 'should get the category name from the bundle' do
+      @combination.identifier.should == :some_category_name
+    end
+  end
+
+  describe 'ids' do
+    it 'should call ids with the text on bundle' do
+      @bundle.should_receive(:ids).once.with :some_text
+
+      @combination.ids
+    end
+    it 'should not call it twice, but cache' do
+      @bundle.stub! :ids => :some_ids
+      @combination.ids
+
+      @bundle.should_receive(:ids).never
+
+      @combination.ids.should == :some_ids
+    end
+  end
+
+  describe 'weight' do
+    it 'should call weight with the text on bundle' do
+      @bundle.should_receive(:weight).once.with :some_text
+
+      @combination.weight
+    end
+    it 'should not call it twice, but cache' do
+      @bundle.stub! :weight => :some_weight
+      @combination.weight
+
+      @bundle.should_receive(:weight).never
+
+      @combination.weight.should == :some_weight
+    end
+  end
+
+end

data/spec/lib/query/combinations_spec.rb

@@ -0,0 +1,83 @@
+# coding: utf-8
+#
+require 'spec_helper'
+
+describe 'Query::Combinations' do
+
+  before(:each) do
+    @combinations_ary = stub :combinations_ary
+
+    @combinations = Query::Combinations.new :some_type, @combinations_ary
+  end
+
+  describe 'remove' do
+    before(:each) do
+      @combination1 = stub :combination1, :in? => false
+      @combination2 = stub :combination2, :in? => true
+      @combination3 = stub :combination3, :in? => true
+
+      @combinations = Query::Combinations.new :some_type, [@combination1, @combination2, @combination3]
+    end
+    it 'should remove the combinations' do
+      @combinations.remove([:any]).should == [@combination1]
+    end
+  end
+
+  describe 'keep' do
+    before(:each) do
+      @combination1 = stub :combination1, :in? => false
+      @combination2 = stub :combination2, :in? => true
+      @combination3 = stub :combination3, :in? => true
+
+      @combinations = Query::Combinations.new :some_type, [@combination1, @combination2, @combination3]
+    end
+    it 'should filter the combinations' do
+      @combinations.keep([:any]).should == [@combination2, @combination3]
+    end
+  end
+
+  describe "ids" do
+    before(:each) do
+      @combination1 = stub :combination1
+      @combination2 = stub :combination2
+      @combination3 = stub :combination3
+      @combinations = Query::Combinations.new :some_type, [@combination1, @combination2, @combination3]
+    end
+    it "should intersect correctly" do
+      @combination1.should_receive(:ids).once.with.and_return (1..100_000).to_a
+      @combination2.should_receive(:ids).once.with.and_return (1..100).to_a
+      @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+      @combinations.ids.should == (1..10).to_a
+    end
+    it "should intersect correctly when intermediate intersect result is empty" do
+      @combination1.should_receive(:ids).once.with.and_return (1..100_000).to_a
+      @combination2.should_receive(:ids).once.with.and_return (11..100).to_a
+      @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+      @combinations.ids.should == []
+    end
+    it "should be fast" do
+      @combination1.should_receive(:ids).once.with.and_return (1..100_000).to_a
+      @combination2.should_receive(:ids).once.with.and_return (1..100).to_a
+      @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+      Benchmark.realtime { @combinations.ids }.should <= 0.004
+    end
+    it "should be fast" do
+      @combination1.should_receive(:ids).once.with.and_return (1..1000).to_a
+      @combination2.should_receive(:ids).once.with.and_return (1..100).to_a
+      @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+      Benchmark.realtime { @combinations.ids }.should <= 0.00015
+    end
+    it "should be fast" do
+      @combination1.should_receive(:ids).once.with.and_return (1..1000).to_a
+      @combination2.should_receive(:ids).once.with.and_return (901..1000).to_a
+      @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+      Benchmark.realtime { @combinations.ids }.should <= 0.0001
+    end
+  end
+
+end

data/spec/lib/query/combinator_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Query::Combinator do
+  
+  context 'with option ignore_unassigned_tokens' do
+    before(:each) do
+      @category1 = stub :category1, :name => :category1
+      @category2 = stub :category2, :name => :category2
+      @category3 = stub :category3, :name => :category3
+      @categories = [@category1, @category2, @category3]
+    end
+    context 'ignore_unassigned_tokens true' do
+      before(:each) do
+        @combinator = Query::Combinator.new @categories, :ignore_unassigned_tokens => true
+      end
+      it 'should return the right value' do
+        @combinator.ignore_unassigned_tokens.should == true
+      end
+    end
+    context 'ignore_unassigned_tokens false' do
+      before(:each) do
+        @combinator = Query::Combinator.new @categories, :ignore_unassigned_tokens => false
+      end
+      it 'should return the right value' do
+        @combinator.ignore_unassigned_tokens.should == false
+      end
+    end
+  end
+  
+  context 'without options' do
+    before(:each) do
+      @category1 = stub :category1, :name => :category1
+      @category2 = stub :category2, :name => :category2
+      @category3 = stub :category3, :name => :category3
+      @categories = [@category1, @category2, @category3]
+      
+      @combinator = Query::Combinator.new @categories
+    end
+    
+    describe 'possible_for' do
+      context 'without preselected categories' do
+        context 'user defined exists' do
+          before(:each) do
+            @token = stub :token, :user_defined_category_name => :category2
+          end
+          context 'combination exists' do
+            before(:each) do
+              @combination = stub :combination
+              @category2.stub! :combination_for => @combination
+            end
+            it 'should return the right combinations' do
+              @combinator.possible_for(@token).should == [@combination]
+            end
+          end
+          context 'combination does not exist' do
+            before(:each) do
+              @category2.stub! :combination_for => nil
+            end
+            it 'should return the right combinations' do
+              @combinator.possible_for(@token).should == []
+            end
+          end
+        end
+        context 'user defined does not exist' do
+
+        end
+      end
+      context 'with preselected categories' do
+
+      end
+    end
+
+    describe 'possible_categories' do
+      context 'user defined exists' do
+        before(:each) do
+          @token = stub :token, :user_defined_category_name => :category2
+        end
+        it 'should return the right categories' do
+          @combinator.possible_categories(@token).should == [@category2]
+        end
+      end
+      context 'user defined does not exist' do
+        before(:each) do
+          @token = stub :token, :user_defined_category_name => nil
+        end
+        it 'should return all categories' do
+          @combinator.possible_categories(@token).should == @categories
+        end
+      end
+    end
+
+    describe 'user_defined_categories' do
+      context 'category exists' do
+        before(:each) do
+          @token = stub :token, :user_defined_category_name => :category2
+        end
+        it 'should return the right categories' do
+          @combinator.user_defined_categories(@token).should == [@category2]
+        end
+      end
+      context 'category does not exist' do
+        before(:each) do
+          @token = stub :token, :user_defined_category_name => :gnoergel
+        end
+        it 'should return nil' do
+          @combinator.user_defined_categories(@token).should == nil
+        end
+      end
+    end
+  end
+  
+end

data/spec/lib/query/full_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Query::Full do
+
+  before(:each) do
+    @index = stub :index
+  end
+
+  describe 'result_type' do
+    before(:each) do
+      @tokens = [
+          Query::Token.processed('some'),
+          Query::Token.processed('query')
+        ]
+      @query = Query::Full.new @tokens, @index
+    end
+    it "should return a specific type" do
+      @query.result_type.should == Results::Full
+    end
+  end
+
+end

data/spec/lib/query/live_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Query::Live do
+
+  before(:each) do
+    # @category1  = Index::Category.new
+    # @type_index = Index::Type.new :some_name, :some_result_type, @category1
+    @index = stub :index
+  end
+
+  describe 'result_type' do
+    before(:each) do
+      @query = Query::Live.new 'some query', 0, @index
+    end
+    it "should return a specific type" do
+      @query.result_type.should == Results::Live
+    end
+  end
+
+  describe "execute" do
+    before(:each) do
+      @query = Query::Live.new @index
+    end
+    it "should get allocations" do
+      @query.should_receive(:results_from).and_return stub(:results, :prepare! => true)
+      @query.should_receive(:sorted_allocations).once
+
+      @query.execute 'some_query', 0
+    end
+    it "should generate a max amount of results from allocations" do
+      allocations = stub :allocations
+      @query.should_receive(:sorted_allocations).and_return allocations
+
+      @query.should_receive(:results_from).once.with(allocations, 0).and_return stub(:results, :prepare! => true)
+
+      @query.execute 'some query', 0
+    end
+  end
+
+  describe "results_from" do
+    describe "with empty ids" do
+      before(:each) do
+        @query = Query::Live.new 'some query', @index
+        @allocations = stub :allocations, :total => 0, :ids => [], :to_result => :some_results, :process! => nil
+      end
+      it "should generate a result" do
+        @query.results_from(@allocations).should be_kind_of Results::Live
+      end
+      it "should generate a result with 0 result count" do
+        @query.results_from(@allocations).total.should == 0
+      end
+      it "should generate a result with 0 duration" do
+        @query.results_from(@allocations).duration.should == 0
+      end
+      it "should generate a result with the allocations" do
+        @query.results_from(@allocations).allocations.should == @allocations
+      end
+    end
+  end
+
+end

data/spec/lib/query/qualifiers_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Query::Qualifiers do
+  
+  before(:each) do
+    Query::Qualifiers.instance << Query::Qualifier.new(:test1, [:t1, :tt1, :ttt1])
+    Query::Qualifiers.instance << Query::Qualifier.new(:test2, [:t2, :tt2, :ttt2])
+    Query::Qualifiers.instance << Query::Qualifier.new(:test3, [:t3, :tt3, :ttt3])
+    Query::Qualifiers.instance.prepare
+  end
+  
+  def self.it_should_normalize(qualifier, expected)
+    it "should map #{qualifier} to #{expected}" do
+      Query::Qualifiers.instance.normalize(qualifier).should == expected
+    end
+  end
+
+  describe "mapping" do
+    it_should_normalize :t1,   :test1
+    it_should_normalize :tt1,  :test1
+    it_should_normalize :ttt1, :test1
+    
+    it_should_normalize :t2,   :test2
+    it_should_normalize :tt2,  :test2
+    it_should_normalize :ttt2, :test2
+    
+    it_should_normalize :t3,   :test3
+    it_should_normalize :tt3,  :test3
+    it_should_normalize :ttt3, :test3
+  end
+end

data/spec/lib/query/solr_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Query::Solr do
+
+  describe 'real server' do
+    before(:each) do
+      @server = Query::Solr.new
+    end
+
+    describe 'execute' do
+      context 'error cases' do
+        before(:each) do
+          @tokens = stub :tokens
+        end
+        context 'tokens are malformed' do
+
+        end
+        context 'server returns strange values' do
+
+        end
+        context 'server raises' do
+          before(:each) do
+            @server.stub! :select => lambda { raise Solr::RequestError }
+          end
+          it 'should not fail' do
+            @tokens.stub! :to_solr_query => ''
+
+            lambda { @server.execute(@tokens) }.should_not raise_error
+          end
+        end
+      end
+    end
+  end
+
+  context 'with connected Server' do
+    before(:each) do
+      @server = stub :server
+      RSolr.stub! :connect => @server
+    end
+  end
+
+  context 'without connected server' do
+    before(:each) do
+      RSolr.should_receive(:connect).and_raise RuntimeError
+    end
+    it 'should have a nil server' do
+      Query::Solr.new(:some_index_type).server.should == nil
+    end
+  end
+
+end