picky 1.2.4 → 1.3.0

data/spec/lib/{routing_spec.rb → frontend_adapters/rack_spec.rb}

@@ -2,10 +2,11 @@
 #
 require 'spec_helper'
 
-describe Routing do
+describe FrontendAdapters::Rack do
   
   before(:each) do
-    @routing = Routing.new
+    @rack_adapter = FrontendAdapters::Rack.new
+    @rack_adapter.stub! :exclaim
   end
   
   def rack_defaults_for url
@@ -38,64 +39,64 @@ describe Routing do
   context 'empty?' do
     context 'no routes' do
       before(:each) do
-        @routing.reset_routes
+        @rack_adapter.reset_routes
       end
       it 'returns the right answer' do
-        @routing.empty?.should == true
+        @rack_adapter.empty?.should == true
       end
     end
     context 'with routes' do
       before(:each) do
-        @routing.route %r{something} => :some_query
+        @rack_adapter.route %r{something} => Query::Full.new
       end
       it 'returns the right answer' do
-        @routing.empty?.should == false
+        @rack_adapter.empty?.should == false
       end
     end
   end
   
   context 'real routes' do
     before(:each) do
-      @routing.reset_routes
+      @rack_adapter.reset_routes
       PickyLog.stub! :log
     end
     it 'should route correctly' do
       env = {}
       
-      @routing.routes.freeze
-      @routing.call(env).should == [404, {"Content-Type" => "text/html", "X-Cascade" => "pass"}, ["Not Found"]]
+      @rack_adapter.routes.freeze
+      @rack_adapter.call(env).should == [404, {"Content-Type" => "text/html", "X-Cascade" => "pass"}, ["Not Found"]]
     end
     it 'should route correctly' do
       env = rack_defaults_for '/'
       
-      @routing.root 200
+      @rack_adapter.root 200
       
-      @routing.routes.freeze
-      @routing.call(env).should == [200, {"Content-Type"=>"text/html", "Content-Length"=>"0"}, ['']]
+      @rack_adapter.routes.freeze
+      @rack_adapter.call(env).should == [200, {"Content-Type"=>"text/html", "Content-Length"=>"0"}, ['']]
     end
     it 'should route correctly' do
       env = rack_defaults_for '/blarf'
       
-      @routing.default 200
+      @rack_adapter.default 200
       
-      @routing.routes.freeze
-      @routing.call(env).should == [200, {"Content-Type"=>"text/html", "Content-Length"=>"0"}, ['']]
+      @rack_adapter.routes.freeze
+      @rack_adapter.call(env).should == [200, {"Content-Type"=>"text/html", "Content-Length"=>"0"}, ['']]
     end
     it 'should route correctly' do
       env = rack_defaults_for '/gurk'
       
-      @routing.answer %r{/gurk}, lambda { |env| [333, {}, ['this is gurk']] }
+      @rack_adapter.answer %r{/gurk}, lambda { |env| [333, {}, ['this is gurk']] }
       
-      @routing.routes.freeze
-      @routing.call(env).should == [333, {}, ['this is gurk']]
+      @rack_adapter.routes.freeze
+      @rack_adapter.call(env).should == [333, {}, ['this is gurk']]
     end
     it 'should route correctly' do
       env = rack_defaults_for '/gurk'
       
-      @routing.answer '/gurk', lambda { |env| [333, {}, ['this is gurk']] }
+      @rack_adapter.answer '/gurk', lambda { |env| [333, {}, ['this is gurk']] }
       
-      @routing.routes.freeze
-      @routing.call(env).should == [333, {}, ['this is gurk']]
+      @rack_adapter.routes.freeze
+      @rack_adapter.call(env).should == [333, {}, ['this is gurk']]
     end
     it 'should route correctly' do
       env = rack_defaults_for '/searches/some_route?query=some_query'
@@ -104,10 +105,10 @@ describe Routing do
       full.should_receive(:search_with_text).once.with(anything, 0).and_return(Results::Full.new)
       Query::Full.stub! :new => full
       
-      @routing.route '/searches/some_route' => Query::Full.new(:some_index, :some_other_index)
+      @rack_adapter.route '/searches/some_route' => Query::Full.new(:some_index, :some_other_index)
       
-      @routing.routes.freeze
-      @routing.call(env).should == [200, {"Content-Type"=>"application/octet-stream", "Content-Length"=>"52"}, ["{\"allocations\":[],\"offset\":0,\"duration\":0,\"total\":0}"]]
+      @rack_adapter.routes.freeze
+      @rack_adapter.call(env).should == [200, {"Content-Type"=>"application/json", "Content-Length"=>"52"}, ["{\"allocations\":[],\"offset\":0,\"duration\":0,\"total\":0}"]]
     end
     it 'should route correctly' do
       env = rack_defaults_for '/searches/some_route?query=some_query&type=some_type'
@@ -116,10 +117,10 @@ describe Routing do
       full.should_receive(:search_with_text).once.with(anything, 0).and_return(Results::Full.new)
       Query::Full.stub! :new => full
       
-      @routing.route '/searches/some_route' => Query::Full.new(:some_index, :some_other_index), :query => { :type => :some_type }
+      @rack_adapter.route '/searches/some_route' => Query::Full.new(:some_index, :some_other_index), :query => { :type => :some_type }
       
-      @routing.routes.freeze
-      @routing.call(env).should == [200, {"Content-Type"=>"application/octet-stream", "Content-Length"=>"52"}, ["{\"allocations\":[],\"offset\":0,\"duration\":0,\"total\":0}"]]
+      @rack_adapter.routes.freeze
+      @rack_adapter.call(env).should == [200, {"Content-Type"=>"application/json", "Content-Length"=>"52"}, ["{\"allocations\":[],\"offset\":0,\"duration\":0,\"total\":0}"]]
     end
     it 'should route correctly' do
       env = rack_defaults_for '/searches/some_wrong_route?query=some_query'
@@ -128,36 +129,31 @@ describe Routing do
       full.should_receive(:search_with_text).never
       Query::Full.stub! :new => full
       
-      @routing.route '/searches/some_route' => Query::Full.new(:some_index, :some_other_index)
+      @rack_adapter.route '/searches/some_route' => Query::Full.new(:some_index, :some_other_index)
       
-      @routing.routes.freeze
-      @routing.call(env).should == [404, {"Content-Type"=>"text/html", "X-Cascade"=>"pass"}, ["Not Found"]]
+      @rack_adapter.routes.freeze
+      @rack_adapter.call(env).should == [404, {"Content-Type"=>"text/html", "X-Cascade"=>"pass"}, ["Not Found"]]
     end
   end
   
   context 'stubbed routes' do
     before(:each) do
       @routes = stub :routes
-      @routing.stub! :routes => @routes
-    end
-    describe 'call' do
-      it 'should description' do
-        
-      end
+      @rack_adapter.stub! :routes => @routes
     end
     
     describe 'generate_query_string' do
       it 'should not allow an empty query condition' do
         lambda {
-          @routing.generate_query_string({}).should == 'this=must_be'
+          @rack_adapter.generate_query_string({}).should == 'this=must_be'
         }.should raise_error "At least one query string condition is needed."
       end
       it 'should handle a single condition' do
-        @routing.generate_query_string(:this => :must_be).should == 'this=must_be'
+        @rack_adapter.generate_query_string(:this => :must_be).should == 'this=must_be'
       end
       it 'should not allow multiple query strings' do
         lambda {
-          @routing.generate_query_string(:this => :must_be, :that => :should_be).should == 'this=must_be|that=should_be'
+          @rack_adapter.generate_query_string(:this => :must_be, :that => :should_be).should == 'this=must_be|that=should_be'
         }.should raise_error "Too many query param conditions (only 1 allowed): {:this=>:must_be, :that=>:should_be}"
       end
       it 'should be sanity checked' do
@@ -167,62 +163,69 @@ describe Routing do
     
     describe "route" do
       it "should delegate correctly" do
-        @routing.should_receive(:route_one).once.with %r{regexp1}, :query1, {}
-        @routing.should_receive(:route_one).once.with %r{regexp2}, :query2, {}
+        @rack_adapter.should_receive(:route_one).once.with %r{regexp1}, :query1, {}
+        @rack_adapter.should_receive(:route_one).once.with %r{regexp2}, :query2, {}
         
-        @routing.route %r{regexp1} => :query1, %r{regexp2} => :query2
+        @rack_adapter.route %r{regexp1} => :query1, %r{regexp2} => :query2
       end
       it "should split options correctly" do
-        @routing.should_receive(:route_one).once.with %r{regexp1}, :query1, :some => :option
-        @routing.should_receive(:route_one).once.with %r{regexp2}, :query2, :some => :option
+        @rack_adapter.should_receive(:route_one).once.with %r{regexp1}, :query1, :some => :option
+        @rack_adapter.should_receive(:route_one).once.with %r{regexp2}, :query2, :some => :option
         
-        @routing.route %r{regexp1} => :query1, %r{regexp2} => :query2, :some => :option
+        @rack_adapter.route %r{regexp1} => :query1, %r{regexp2} => :query2, :some => :option
       end
       it 'does not accept nil queries' do
-        lambda { @routing.route %r{some/regexp} => nil }.should raise_error(Routing::TargetQueryNilError, /Routing for \/some\\\/regexp\/ was defined with a nil query object/)
+        lambda { @rack_adapter.route %r{some/regexp} => nil }.should raise_error(FrontendAdapters::Rack::RouteTargetNilError, /Routing for \/some\\\/regexp\/ was defined with a nil target object, i.e. \/some\\\/regexp\/ => nil./)
+      end
+    end
+    
+    describe 'finalize' do
+      before(:each) do
+        @rack_adapter.routes.should_receive(:freeze).once.with
+        
+        @rack_adapter.finalize
       end
     end
     
     describe 'route_one' do
       before(:each) do
-        @some_query_app = stub :some_query_app
-        @routing.stub! :generate_app => @some_query_app
+        Adapters::Rack.stub! :app_for => :some_query_app
       end
       it 'should add the right route' do
-        @routes.should_receive(:add_route).once.with @some_query_app, { :request_method => "GET", :path_info => /some_url/ }
+        @routes.should_receive(:add_route).once.with :some_query_app, { :request_method => "GET", :path_info => /some_url/ }
         
-        @routing.route_one %r{some_url}, :some_query, {}
+        @rack_adapter.route_one %r{some_url}, :some_query, {}
       end
       it 'should add the right route' do
-        @routes.should_receive(:add_route).once.with @some_query_app, { :request_method => "GET", :path_info => /some_url/ }
+        @routes.should_receive(:add_route).once.with :some_query_app, { :request_method => "GET", :path_info => /some_url/ }
         
-        @routing.route_one 'some_url', :some_query, {}
+        @rack_adapter.route_one 'some_url', :some_query, {}
       end
       it 'should add the right route' do
-        @routes.should_receive(:add_route).once.with @some_query_app, { :request_method => "GET", :glarf => :blarf, :path_info => /some_url/ }
+        @routes.should_receive(:add_route).once.with :some_query_app, { :request_method => "GET", :glarf => :blarf, :path_info => /some_url/ }
         
-        @routing.route_one 'some_url', :some_query, { :glarf => :blarf }
+        @rack_adapter.route_one 'some_url', :some_query, { :glarf => :blarf }
       end
     end
     
     describe 'default' do
       it 'should call answer' do
-        @routing.should_receive(:answer).once.with nil, Routing::STATUSES[200]
+        @rack_adapter.should_receive(:answer).once.with nil, FrontendAdapters::Rack::STATUSES[200]
         
-        @routing.default 200
+        @rack_adapter.default 200
       end
     end
     
     describe 'root' do
       it 'should call answer' do
-        @routing.should_receive(:answer).once.with %r{^/$}, Routing::STATUSES[200]
+        @rack_adapter.should_receive(:answer).once.with %r{^/$}, FrontendAdapters::Rack::STATUSES[200]
         
-        @routing.root 200
+        @rack_adapter.root 200
       end
       it 'should call answer' do
-        @routing.should_receive(:answer).once.with %r{^/$}, Routing::STATUSES[404]
+        @rack_adapter.should_receive(:answer).once.with %r{^/$}, FrontendAdapters::Rack::STATUSES[404]
         
-        @routing.root 404
+        @rack_adapter.root 404
       end
     end
     
@@ -235,30 +238,30 @@ describe Routing do
           it 'should use the app with default_options from the url' do
             @routes.should_receive(:add_route).once.with @app, { :request_method => "GET", :path_info => /some_url/ }
             
-            @routing.answer 'some_url', @app
+            @rack_adapter.answer 'some_url', @app
           end
         end
         context 'without url' do
           it 'should use the app with default_options' do
             @routes.should_receive(:add_route).once.with @app, { :request_method => "GET" }
             
-            @routing.answer nil, @app
+            @rack_adapter.answer nil, @app
           end
         end
       end
       context 'without app' do
         context 'with url' do
           it 'should use the 404 with default_options from the url' do
-            @routes.should_receive(:add_route).once.with Routing::STATUSES[200], { :request_method => "GET", :path_info => /some_url/ }
+            @routes.should_receive(:add_route).once.with FrontendAdapters::Rack::STATUSES[200], { :request_method => "GET", :path_info => /some_url/ }
             
-            @routing.answer 'some_url'
+            @rack_adapter.answer 'some_url'
           end
         end
         context 'without url' do
           it 'should use the 404 with default_options' do
-            @routes.should_receive(:add_route).once.with Routing::STATUSES[200], { :request_method => "GET" }
+            @routes.should_receive(:add_route).once.with FrontendAdapters::Rack::STATUSES[200], { :request_method => "GET" }
             
-            @routing.answer
+            @rack_adapter.answer
           end
         end
       end

data/spec/lib/indexed/categories_spec.rb

@@ -39,6 +39,30 @@ describe Indexed::Categories do
     end
   end
   
+  describe 'clear' do
+    before(:each) do
+      @categories = Indexed::Categories.new
+    end
+    it 'is clear right at the beginning' do
+      @categories.categories.should be_empty
+      @categories.category_hash.should be_empty
+    end
+    it "isn't clear anymore after adding" do
+      @categories << stub(:category, :name => :some_name)
+      
+      @categories.categories.should_not be_empty
+      @categories.category_hash.should_not be_empty
+    end
+    it "is clear again after clearing" do
+      @categories << stub(:category, :name => :some_name)
+      
+      @categories.clear
+      
+      @categories.categories.should be_empty
+      @categories.category_hash.should be_empty      
+    end
+  end
+  
   context 'without options' do
     before(:each) do
       @index1 = stub :index1, :name => :some_index

data/spec/lib/interfaces/live_parameters_spec.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe LiveParameters do
+  
+  before(:each) do
+    @parent = stub :parent
+    @child  = stub :child
+    IO.stub! :pipe => [@child, @parent]
+    @parameters = LiveParameters.new
+    @parameters.stub! :exclaim
+  end
+  
+  describe Interfaces::LiveParameters::CouldNotUpdateConfigurationError do
+    before(:each) do
+      @error = Interfaces::LiveParameters::CouldNotUpdateConfigurationError.new :some_key, 'some message'
+    end
+  end
+  
+  describe 'parameters' do
+    context 'all goes well' do
+      it 'does a few things in order' do
+        @parameters.should_receive(:close_child).once.with().ordered
+        @parameters.should_receive(:try_updating_configuration_with).once.with(:a => :b).ordered
+        @parameters.should_receive(:write_parent).once.with(:a => :b).ordered
+        @parameters.should_receive(:extract_configuration).once.with().ordered
+        
+        @parameters.parameters :a => :b
+      end
+    end
+    context 'updating failed' do
+      before(:each) do
+        @parameters.should_receive(:try_updating_configuration_with).and_raise Interfaces::LiveParameters::CouldNotUpdateConfigurationError.new(:a, 'hello')
+      end
+      it 'kills itself and returns' do
+        @parameters.should_receive(:close_child).once.ordered
+        @parameters.should_receive(:harakiri).once.ordered
+        
+        @parameters.parameters( :a => :b ).should == { :a => :ERROR }
+      end
+    end
+  end
+  
+  describe 'harakiri' do
+    before(:each) do
+      Process.stub! :pid => :some_pid
+    end
+    it 'kills itself' do
+      Process.should_receive(:kill).once.with :QUIT, :some_pid
+      
+      @parameters.harakiri
+    end
+  end
+  
+  describe 'write_parent' do
+    before(:each) do
+      Process.stub! :pid => :some_pid
+    end
+    it 'calls the parent' do
+      @parent.should_receive(:write).once.with "[:some_pid, {:a=>:b}];;;"
+      
+      @parameters.write_parent :a => :b
+    end
+  end
+  
+  describe 'close_child' do
+    context 'child is closed' do
+      before(:each) do
+        @child.stub! :closed? => true
+      end
+      it 'does not receive close' do
+        @child.should_receive(:close).never
+        
+        @parameters.close_child
+      end
+    end
+    context 'child not yet closed' do
+      before(:each) do
+        @child.stub! :closed? => false
+      end
+      it 'does receives close' do
+        @child.should_receive(:close).once.with()
+        
+        @parameters.close_child
+      end
+    end
+  end
+  
+  describe 'kill_worker' do
+    context 'all goes well' do
+      it 'uses Process.kill' do
+        Process.should_receive(:kill).once.with :some_signal, :some_pid
+
+        @parameters.kill_worker :some_signal, :some_pid
+      end
+    end
+    context 'there is no such process' do
+      it 'uses Process.kill' do
+        Process.should_receive(:kill).and_raise Errno::ESRCH.new
+        
+        @parameters.should_receive(:remove_worker).once.with :some_pid
+        
+        @parameters.kill_worker :some_signal, :some_pid
+      end
+    end
+  end
+  
+  describe 'kill_each_worker_except' do
+    context 'worker pid in the worker pids' do
+      before(:each) do
+        @parameters.stub! :worker_pids => [1,2,3,4]
+      end
+      it 'kills each except the one' do
+        @parameters.should_receive(:kill_worker).once.with(:KILL, 1)
+        @parameters.should_receive(:kill_worker).once.with(:KILL, 2)
+        
+        @parameters.should_receive(:kill_worker).once.with(:KILL, 4)
+        
+        @parameters.kill_each_worker_except 3 
+      end
+    end
+    context 'worker pid not in the worker pids (unrealistic, but...)' do
+      before(:each) do
+        @parameters.stub! :worker_pids => [1,2,3,4]
+      end
+      it 'kills each except the one' do
+        @parameters.should_receive(:kill_worker).once.with(:KILL, 1)
+        @parameters.should_receive(:kill_worker).once.with(:KILL, 2)
+        @parameters.should_receive(:kill_worker).once.with(:KILL, 3)
+        @parameters.should_receive(:kill_worker).once.with(:KILL, 4)
+        
+        @parameters.kill_each_worker_except 5
+      end
+    end
+  end
+  
+end

data/spec/lib/query/base_spec.rb

@@ -123,26 +123,22 @@ describe 'Query::Base' do
       end
     end
   end
-
-  describe "results_from" do
-    describe 'Full' do
+  
+  describe 'to_s' do
+    context 'with weights' do
       before(:each) do
-        @query = Query::Full.new @index
+        @query = Query::Full.new @index, weights: :some_weights
       end
-      it "should work" do
-        allocations = stub :allocations, :process! => true
-
-        @query.results_from allocations
+      it 'works correctly' do
+        @query.to_s.should == 'Query::Full, weights: some_weights'
       end
     end
-    describe 'Live' do
+    context 'without weights' do
       before(:each) do
-        @query = Query::Live.new @index
+        @query = Query::Full.new @index
       end
-      it "should work" do
-        allocations = stub :allocations, :process! => true
-
-        @query.results_from allocations
+      it 'works correctly' do
+        @query.to_s.should == 'Query::Full'
       end
     end
   end

data/spec/lib/query/live_spec.rb

@@ -21,40 +21,11 @@ describe Query::Live do
       @query = Query::Live.new @index
     end
     it "should get allocations" do
-      @query.should_receive(:results_from).and_return stub(:results, :prepare! => true)
+      @query.result_type.should_receive :from
       @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(0, allocations).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 @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(0, @allocations).allocations.should == @allocations
-      end
-    end
   end
 
 end

data/spec/lib/query/token_spec.rb

@@ -8,6 +8,73 @@ describe Query::Token do
     Query::Qualifiers.instance.prepare
   end
   
+  describe 'next_similar_token' do
+    before(:each) do
+      @bundle   = stub :bundle, :similar => [:array, :of, :similar]
+      @category = stub :category, :bundle_for => @bundle
+      
+      @token = Query::Token.processed 'similar~'
+    end
+    it 'returns the right next tokens' do
+      next_token = @token.next_similar_token @category
+      next_token.text.should == :array
+      next_token = next_token.next_similar_token @category
+      next_token.text.should == :of
+      next_token = next_token.next_similar_token @category
+      next_token.text.should == :similar
+      next_token = next_token.next_similar_token @category
+      next_token.should == nil
+    end
+  end
+  
+  describe 'next_similar' do
+    before(:each) do
+      @bundle = stub :bundle
+    end
+    context 'similar' do
+      context 'with stub' do
+        before(:each) do
+          @bundle.stub! :similar => [:array, :of, :similar]
+
+          @token = Query::Token.processed 'similar~'
+        end
+        it 'generates all similar' do
+          @token.next_similar(@bundle).should == :array
+          @token.next_similar(@bundle).should == :of
+          @token.next_similar(@bundle).should == :similar
+          @token.next_similar(@bundle).should == nil
+        end
+        it 'should have a certain text' do
+          @token.next_similar @bundle
+          @token.next_similar @bundle
+          @token.next_similar @bundle
+          @token.next_similar @bundle
+          
+          @token.text.should == :similar
+        end
+      end
+    end
+    context 'non-similar' do
+      context 'with stub' do
+        before(:each) do
+          @bundle.stub! :similar => [:array, :of, :similar]
+
+          @token = Query::Token.processed 'nonsimilar'
+        end
+        it 'generates all similar' do
+          @token.next_similar(@bundle).should == nil
+        end
+        # TODO
+        #
+        # it 'should have a certain text' do
+        #   @token.next_similar @bundle
+        #   
+        #   @token.text.should == :nonsimilar
+        # end
+      end
+    end
+  end
+  
   describe "generate_similarity_for" do
     before(:each) do
       @bundle = stub :bundle
@@ -18,16 +85,16 @@ describe Query::Token do
       before(:each) do
         @bundle.stub! :similar => [:array, :of, :similar]
       end
-      it "returns an enumerator" do
-        @token.generate_similarity_for(@bundle).to_a.size.should == 3
+      it "returns an array of the right size" do
+        @token.generate_similarity_for(@bundle).size.should == 3
       end
     end
     context "without similar" do
       before(:each) do
-        @bundle.stub! :similar => nil
+        @bundle.stub! :similar => []
       end
-      it "returns an enumerator with 0 entries" do
-        @token.generate_similarity_for(@bundle).to_a.size.should == 0
+      it "returns an array of the right size" do
+        @token.generate_similarity_for(@bundle).size.should == 0
       end
     end
   end