picky 0.0.0 → 0.0.2

data/spec/lib/query/allocation_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+describe Query::Allocation do
+  
+  before(:each) do
+    @combinations = stub :combinations
+    @allocation = Query::Allocation.new @combinations
+  end
+  
+  describe 'remove' do
+    it 'should delegate to the combinations' do
+      @combinations.should_receive(:remove).once.with [:some_identifiers]
+      
+      @allocation.remove [:some_identifiers]
+    end
+  end
+  
+  describe 'keep' do
+    it 'should delegate to the combinations' do
+      @combinations.should_receive(:keep).once.with [:some_identifiers]
+      
+      @allocation.keep [:some_identifiers]
+    end
+  end
+  
+  describe 'process!' do
+    context 'no ids' do
+      before(:each) do
+        @allocation.stub! :calculate_ids => []
+      end
+      it 'should process right' do
+        @allocation.process!(0, 0).should == []
+      end
+      it 'should process right' do
+        @allocation.process!(0, 10).should == []
+      end
+      it 'should process right' do
+        @allocation.process!(20, 0).should == []
+      end
+      it 'should process right' do
+        @allocation.process!(20, 10).should == []
+      end
+    end
+    context 'with ids' do
+      before(:each) do
+        @allocation.stub! :calculate_ids => [1,2,3,4,5,6,7,8,9,10]
+      end
+      it 'should process right' do
+        @allocation.process!(0, 0).should == []
+      end
+      it 'should process right' do
+        @allocation.process!(0, 10).should == []
+      end
+      it 'should process right' do
+        @allocation.process!(5, 0).should == [1,2,3,4,5]
+      end
+      it 'should process right' do
+        @allocation.process!(5, 5).should == [6,7,8,9,10]
+      end
+      it 'should process right' do
+        @allocation.process!(20, 0).should == [1,2,3,4,5,6,7,8,9,10]
+      end
+      it 'should process right' do
+        @allocation.process!(20, 5).should == [6,7,8,9,10]
+      end
+      it 'should process right' do
+        @allocation.process!(20, 10).should == []
+      end
+    end
+  end
+
+  describe 'to_result' do
+    context 'with few combinations' do
+      before(:each) do
+        @allocation = Query::Allocation.new stub(:combinations, :ids => [1,2,3], :to_result => [:some_result])
+        @allocation.instance_variable_set :@score, :some_score
+        @allocation.result_type = :some_result_type
+      end
+      context 'with ids' do
+        it 'should output an array of information' do
+          @allocation.process! 20, 0
+
+          @allocation.to_result.should == [:some_result_type, :some_score, 3, [:some_result], [1, 2, 3]]
+        end
+      end
+    end
+    context 'with results' do
+      before(:each) do
+        combinations = stub :combinations, :ids => [1,2,3], :to_result => [:some_result1, :some_result2]
+        @allocation = Query::Allocation.new combinations
+        @allocation.instance_variable_set :@score, :some_score
+        @allocation.result_type = :some_result_type
+      end
+      context 'with ids' do
+        it 'should output an array of information' do
+          @allocation.process! 20, 0
+
+          @allocation.to_result.should == [:some_result_type, :some_score, 3, [:some_result1, :some_result2], [1, 2, 3]]
+        end
+      end
+    end
+    context 'without results' do
+      before(:each) do
+        @allocation = Query::Allocation.new stub(:combinations, :ids => [], :to_result => [])
+        @allocation.instance_variable_set :@score, :some_score
+      end
+      it 'should return nil' do
+        @allocation.process! 20, 0
+
+        @allocation.to_result.should == nil
+      end
+    end
+  end
+
+  describe 'to_json' do
+    before(:each) do
+      @allocation = Query::Allocation.new stub(:combination, :ids => [1,2,3,4,5,6,7], :to_result => [:some_result1, :some_result2])
+      @allocation.instance_variable_set :@score, :some_score
+      @allocation.result_type = :some_result_type
+    end
+    it 'should output the correct json string' do
+      @allocation.process! 20, 0
+
+      @allocation.to_json.should == '["some_result_type","some_score",7,["some_result1","some_result2"],[1,2,3,4,5,6,7]]'
+    end
+  end
+
+  describe "calculate_score" do
+    it 'should delegate to the combinations' do
+      @combinations.should_receive(:calculate_score).once.with :some_weights
+
+      @allocation.calculate_score :some_weights
+    end
+  end
+
+  describe "<=>" do
+    it "should sort higher first" do
+      first = Query::Allocation.new []
+      first.instance_variable_set :@score, 20
+      second = Query::Allocation.new []
+      second.instance_variable_set :@score, 10
+
+      first.<=>(second).should == -1
+    end
+  end
+
+  describe "sort!" do
+    it "should sort correctly" do
+      first = Query::Allocation.new :whatever
+      first.instance_variable_set :@score, 20
+      second = Query::Allocation.new :whatever
+      second.instance_variable_set :@score, 10
+      third = Query::Allocation.new :whatever
+      third.instance_variable_set :@score, 5
+
+      allocations = [second, third, first]
+
+      allocations.sort!.should == [first, second, third]
+    end
+  end
+
+  describe "process!" do
+    before(:each) do
+      @amount = stub :amount
+      @offset = stub :offset
+      @ids    = stub :ids, :size => :some_original_size, :slice! => :some_sliced_ids
+      @allocation.stub! :calculate_ids => @ids
+    end
+    it 'should calculate_ids' do
+      @allocation.should_receive(:calculate_ids).once.with.and_return @ids
+
+      @allocation.process! @amount, @offset
+    end
+    it 'should get the original ids count' do
+      @allocation.process! @amount, @offset
+
+      @allocation.count.should == :some_original_size
+    end
+    it 'should slice! the ids down' do
+      @ids.should_receive(:slice!).once.with @offset, @amount
+
+      @allocation.process! @amount, @offset
+    end
+    it 'should return the sliced ids' do
+      @allocation.process!(@amount, @offset).should == :some_sliced_ids
+    end
+    it 'should assign the sliced ids correctly' do
+      @allocation.process! @amount, @offset
+
+      @allocation.ids.should == :some_sliced_ids
+    end
+  end
+
+end

data/spec/lib/query/allocations_spec.rb

@@ -0,0 +1,336 @@
+require 'spec_helper'
+
+describe Query::Allocations do
+
+  describe 'reduce_to' do
+    before(:each) do
+      @allocation1 = stub :allocation1
+      @allocation2 = stub :allocation2
+      @allocation3 = stub :allocation3
+      @allocations = Query::Allocations.new [@allocation1, @allocation2, @allocation3]
+    end
+    it 'should do nothing' do
+      @allocations.reduce_to 2
+
+      @allocations.to_a.should == [@allocation1, @allocation2]
+    end
+  end
+
+  describe 'remove' do
+    before(:each) do
+      @allocation1 = stub :allocation1
+      @allocation2 = stub :allocation2
+      @allocation3 = stub :allocation3
+      @allocations = Query::Allocations.new [@allocation1, @allocation2, @allocation3]
+    end
+    context 'identifiers empty' do
+      it 'should do nothing' do
+        @allocation1.should_receive(:remove).never
+        @allocation2.should_receive(:remove).never
+
+        @allocations.remove
+      end
+    end
+    context 'identifiers not empty' do
+      it 'should remove each' do
+        @allocation1.should_receive(:remove).once.with :some_identifier
+        @allocation2.should_receive(:remove).once.with :some_identifier
+        @allocation3.should_receive(:remove).once.with :some_identifier
+
+        @allocations.remove :some_identifier
+      end
+    end
+  end
+
+  describe 'keep' do
+    before(:each) do
+      @allocation1 = stub :allocation1
+      @allocation2 = stub :allocation2
+      @allocation3 = stub :allocation3
+      @allocations = Query::Allocations.new [@allocation1, @allocation2, @allocation3]
+    end
+    context 'identifiers empty' do
+      it 'should do nothing' do
+        @allocation1.should_receive(:keep).never
+        @allocation2.should_receive(:keep).never
+
+        @allocations.keep
+      end
+    end
+    context 'identifiers not empty' do
+      it 'should filter each' do
+        @allocation1.should_receive(:keep).once.with :some_identifier
+        @allocation2.should_receive(:keep).once.with :some_identifier
+        @allocation3.should_receive(:keep).once.with :some_identifier
+
+        @allocations.keep :some_identifier
+      end
+    end
+  end
+
+  describe 'ids' do
+    before(:each) do
+      @allocation1 = stub :allocation1, :ids => [1, 2, 3, 4]
+      @allocation2 = stub :allocation2, :ids => [5, 6, 7]
+      @allocation3 = stub :allocation3, :ids => [8, 9]
+      @allocations = Query::Allocations.new [@allocation1, @allocation2, @allocation3]
+    end
+    it 'should return the right amount of ids' do
+      @allocations.ids(0).should == []
+    end
+    it 'should return the right amount of ids' do
+      @allocations.ids(6).should == [1,2,3,4,5,6]
+    end
+    it 'should return the right amount of ids' do
+      @allocations.ids.should == [1,2,3,4,5,6,7,8,9]
+    end
+  end
+
+  describe 'process!' do
+    before(:each) do
+      @allocation1 = stub :allocation1, :process! => [], :count => 4 #, ids: [1, 2, 3, 4]
+      @allocation2 = stub :allocation2, :process! => [], :count => 3 #, ids: [5, 6, 7]
+      @allocation3 = stub :allocation3, :process! => [], :count => 2 #, ids: [8, 9]
+      @allocations = Query::Allocations.new [@allocation1, @allocation2, @allocation3]
+    end
+    describe 'amount spanning 3 allocations' do
+      before(:each) do
+        @amount = 6
+        @offset = 2
+      end
+      it 'should call the process! method right' do
+        @allocation1.should_receive(:process!).once.with(6,2).and_return [3,4]
+        @allocation2.should_receive(:process!).once.with(4,0).and_return [5,6,7]
+        @allocation3.should_receive(:process!).once.with(1,0).and_return [8]
+
+        @allocations.process! @amount, @offset
+      end
+    end
+    describe 'large offset' do
+      before(:each) do
+        @amount = 10
+        @offset = 8
+      end
+      it 'should call the process! method right' do
+        @allocation1.should_receive(:process!).once.with(10,8).and_return []
+        @allocation2.should_receive(:process!).once.with(10,4).and_return []
+        @allocation3.should_receive(:process!).once.with(10,1).and_return [9]
+
+        @allocations.process! @amount, @offset
+      end
+    end
+    context 'amount 0' do
+      before(:each) do
+        @amount = 0
+      end
+      it 'should return an empty array always' do
+        @allocation1.should_receive(:process!).once.with(0,0).and_return []
+        @allocation2.should_receive(:process!).once.with(0,0).and_return []
+        @allocation3.should_receive(:process!).once.with(0,0).and_return []
+
+        @allocations.process! @amount
+      end
+    end
+    context 'amount > 0' do
+      before(:each) do
+        @amount = 3
+      end
+      context 'offset 0' do
+        before(:each) do
+          @offset = 0
+        end
+        it 'should return certain ids' do
+          @allocation1.should_receive(:process!).once.with(3,0).and_return [1,2,3]
+          @allocation2.should_receive(:process!).once.with(0,0)
+
+          @allocations.process! @amount, @offset
+        end
+      end
+      context 'offset 3' do
+        before(:each) do
+          @offset = 3
+        end
+        it 'should return certain ids' do
+          @allocation1.should_receive(:process!).once.with(3,3).and_return [4]
+          @allocation2.should_receive(:process!).once.with(2,0).and_return [5,6]
+
+          @allocations.process! @amount, @offset
+        end
+      end
+    end
+  end
+
+  describe 'random_ids' do
+    context 'enough ids' do
+      before(:each) do
+        @allocation1 = stub :allocation1, :ids => [1, 2, 3]
+        @allocation2 = stub :allocation1, :ids => [4, 5, 6, 7]
+        @allocations = Query::Allocations.new [@allocation1, @allocation2]
+      end
+      it 'should return one random id from the first allocations by default' do
+        @allocations.random_ids.size.should == 1
+      end
+      it 'should return multiple random ids from the first allocation' do
+        @allocations.random_ids(5).size.should == 3
+      end
+      it "should return one random id from the first allocation's ids" do
+        (1..7).to_a.should include(@allocations.random_ids.first)
+      end
+      it 'should not contain the same id twice' do
+        100.times do
+          @allocations.random_ids(2).uniq.size.should_not == 1
+        end
+      end
+    end
+    context 'just one id' do
+      before(:each) do
+        @allocation1 = stub :allocation1, :ids => [1]
+        @allocation2 = stub :allocation1, :ids => []
+        @allocations = Query::Allocations.new [@allocation1, @allocation2]
+      end
+      it 'should return one random id from its allocations by default' do
+        @allocations.random_ids.size.should == 1
+      end
+      it 'should return multiple random ids from its allocations' do
+        @allocations.random_ids(5).size.should == 1
+      end
+      it 'should return one random id from the allocations ids' do
+        @allocations.random_ids.should == [1]
+      end
+    end
+    context 'no id' do
+      before(:each) do
+        @allocation1 = stub :allocation1, :ids => []
+        @allocation2 = stub :allocation1, :ids => []
+        @allocations = Query::Allocations.new [@allocation1, @allocation2]
+      end
+      it 'should return one random id from its allocations by default' do
+        @allocations.random_ids.size.should == 0
+      end
+      it 'should return no random id from its allocations' do
+        @allocations.random_ids(5).size.should == 0
+      end
+      it 'should return no random id from the allocations ids' do
+        @allocations.random_ids.should == []
+      end
+    end
+  end
+
+  describe 'to_result' do
+    context 'all allocations have results' do
+      before(:each) do
+        @allocation = stub :allocation
+        @allocations = Query::Allocations.new [@allocation, @allocation, @allocation]
+      end
+      it 'should delegate to each allocation with no params' do
+        @allocation.should_receive(:to_result).exactly(3).times.with
+
+        @allocations.to_result
+      end
+    end
+    context 'one allocation has no results' do
+      before(:each) do
+        @allocation           = stub :allocation, :to_result => :some_result
+        @no_result_allocation = stub :no_results, :to_result => nil
+        @allocations = Query::Allocations.new [@allocation, @no_result_allocation, @allocation]
+      end
+      it 'should delegate to each allocation with the same params' do
+        @allocations.to_result.should == [:some_result, :some_result]
+      end
+    end
+  end
+
+  describe 'total' do
+    context 'with allocations' do
+      before(:each) do
+        @allocations = Query::Allocations.new [
+          stub(:allocation, :process! => (1..10).to_a, :count => 10),
+          stub(:allocation, :process! => (1..80).to_a, :count => 80),
+          stub(:allocation, :process! => (1..20).to_a, :count => 20)
+        ]
+      end
+      it 'should traverse the allocations and sum the counts' do
+        @allocations.process! 20, 0
+
+        @allocations.total.should == 110
+      end
+    end
+    context 'without allocations' do
+      before(:each) do
+        @allocations = Query::Allocations.new []
+      end
+      it 'should be 0' do
+        @allocations.process! 20, 0
+
+        @allocations.total.should == 0
+      end
+    end
+  end
+
+  describe "each" do
+    before(:each) do
+      @internal_allocations = mock :internal_allocations
+      @allocations = Query::Allocations.new @internal_allocations
+    end
+    it "should delegate to the internal allocations" do
+      stub_proc = lambda {}
+      @internal_allocations.should_receive(:each).once.with &stub_proc
+
+      @allocations.each &stub_proc
+    end
+  end
+  describe "inject" do
+    before(:each) do
+      @internal_allocations = mock :internal_allocations
+      @allocations = Query::Allocations.new @internal_allocations
+    end
+    it "should delegate to the internal allocations" do
+      stub_proc = lambda {}
+      @internal_allocations.should_receive(:inject).once.with &stub_proc
+
+      @allocations.inject &stub_proc
+    end
+  end
+  describe "empty?" do
+    before(:each) do
+      @internal_allocations = mock :internal_allocations
+      @allocations = Query::Allocations.new @internal_allocations
+    end
+    it "should delegate to the internal allocations array" do
+      @internal_allocations.should_receive(:empty?).once
+      @allocations.empty?
+    end
+  end
+
+  describe "to_s" do
+    before(:each) do
+      @internal_allocations = mock :internal_allocations
+      @allocations = Query::Allocations.new @internal_allocations
+    end
+    it "should delegate to the internal allocations array" do
+      @internal_allocations.should_receive(:inspect).once
+      @allocations.to_s
+    end
+  end
+
+  describe "process!" do
+    context 'some allocations' do
+      before(:each) do
+        @allocations = Query::Allocations.new [
+          stub(:allocation, :process! => (1..10).to_a, :count => 10),
+          stub(:allocation, :process! => (1..80).to_a, :count => 80),
+          stub(:allocation, :process! => (1..20).to_a, :count => 20)
+        ]
+      end
+      it 'should calculate the right total' do
+        @allocations.process! 20, 0
+
+        @allocations.total.should == 110
+      end
+      it 'should be fast' do
+        Benchmark.realtime { @allocations.process!(20, 0) }.should <= 0.0001
+      end
+    end
+  end
+
+end

data/spec/lib/query/base_spec.rb

@@ -0,0 +1,104 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe 'Query::Base' do
+  
+  describe 'reduce' do
+    context 'real' do
+      before(:each) do
+        @allocations = stub :allocations
+        @query       = Query::Full.new
+      end
+      context 'reduce_to_amount not set' do
+        it 'should not call anything on the allocations' do
+          @allocations.should_receive(:reduce_to).never
+          
+          @query.reduce @allocations
+        end
+      end
+      context 'reduce_to_amount set' do
+        before(:each) do
+          @query.reduce_to_amount = :some_amount
+        end
+        it 'should call reduce_to on the allocations' do
+          @allocations.should_receive(:reduce_to).once.with :some_amount
+          
+          @query.reduce @allocations
+        end
+      end
+    end
+    context 'stubbed' do
+      before(:each) do
+        @allocations = stub :allocations
+        @query       = Query::Full.new
+      end
+      context 'reduce_to_amount not set' do
+        it 'should not call anything on the allocations' do
+          @allocations.should_receive(:reduce_to).never
+          
+          @query.reduce @allocations
+        end
+      end
+      context 'reduce_to_amount set' do
+        before(:each) do
+          @query.stub! :reduce_to_amount => :some_amount
+        end
+        it 'should call reduce_to on the allocations' do
+          @allocations.should_receive(:reduce_to).once.with :some_amount
+          
+          @query.reduce @allocations
+        end
+      end
+    end
+  end
+  
+  describe 'initializer' do
+    context 'with tokenizer' do
+      before(:each) do
+        @tokenizer = stub :tokenizer, :tokenize => :some_tokenized_text
+        @query     = Query::Full.new 'some query', :some_index, :tokenizer => @tokenizer
+      end
+      it 'should tokenize using the tokenizer' do
+        @query.tokenized('some text').should == :some_tokenized_text
+      end
+    end
+  end
+
+  describe "results_from" do
+    describe 'Full' do
+      before(:each) do
+        @query = Query::Full.new 'some query', :some_index
+      end
+      it "should work" do
+        allocations = stub :allocations, :process! => true
+
+        @query.results_from allocations
+      end
+    end
+    describe 'Live' do
+      before(:each) do
+        @query = Query::Live.new 'some query', :some_index
+      end
+      it "should work" do
+        allocations = stub :allocations, :process! => true
+
+        @query.results_from allocations
+      end
+    end
+  end
+
+  describe "sorted_allocations" do
+    before(:each) do
+      @index_class = stub :index_class
+      @query = Query::Base.new @index_class
+    end
+    it "should generate the right kind of allocations" do
+      tokens = @query.tokenized 'some query'
+      
+      @index_class.stub! :possible_combinations => []
+      
+      @query.sorted_allocations(tokens).should be_kind_of(Query::Allocations)
+    end
+  end
+
+end