picky 0.0.0 → 0.0.2

data/spec/lib/results/base_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+describe Results do
+  
+  describe 'to_log' do
+    before(:each) do
+      time = stub :time, :to_s => '0-08-16 10:07:33'
+      Time.stub! :now => time
+    end
+    context 'without results' do
+      before(:each) do
+        @results = Results::Base.new
+      end
+      it 'should output a default log' do
+        @results.to_log('some_query').should == '|0-08-16 10:07:33|0.000000|some_query                                        |       0|   0| 0|'
+      end
+    end
+    context 'with results' do
+      before(:each) do
+        @allocations = stub :allocations,
+                            :process! => nil, :size => 12
+
+        @results = Results::Base.new @allocations
+        @results.stub! :duration => 0.1234567890,
+                       :total    => 12345678,
+                       :offset   => 1234
+      end
+      it 'should output a specific log' do
+        @results.to_log('some_query').should == '|0-08-16 10:07:33|0.123457|some_query                                        |12345678|1234|12|'
+      end
+    end
+  end
+  
+  describe 'to_marshal' do
+    before(:each) do
+      @results = Results::Base.new
+    end
+    it 'should do it correctly' do
+      @results.stub! :serialize => :serialized
+
+      @results.to_marshal.should == "\x04\b:\x0Fserialized"
+    end
+  end
+
+  describe 'to_json' do
+    before(:each) do
+      @results = Results::Base.new
+    end
+    it 'should do it correctly' do
+      @results.stub! :serialize => :serialized
+
+      @results.to_json.should == '"serialized"'
+    end
+  end
+
+  describe 'serialize' do
+    before(:each) do
+      @allocations = stub :allocations, :process! => nil, :to_result => :allocations, :total => :some_total
+
+      @results = Results::Base.new @allocations
+      @results.duration = :some_duration
+    end
+    it 'should do it correctly' do
+      @results.prepare! :some_offset
+
+      @results.serialize.should == { :allocations => :allocations, :offset => :some_offset, :duration => :some_duration, :total => :some_total }
+    end
+  end
+
+  describe 'prepare!' do
+    describe 'Full' do
+      before(:each) do
+        @results = Results::Full.new
+        @allocations = stub :allocations
+        @results.stub! :allocations => @allocations
+      end
+      it 'should first offset (TODO), then truncate' do
+        @allocations.should_receive(:process!).once.with(20, 0).ordered
+
+        @results.prepare!
+      end
+    end
+    describe 'Live' do
+      before(:each) do
+        @results = Results::Live.new
+        @allocations = stub :allocations
+        @results.stub! :allocations => @allocations
+      end
+      it 'should generate truncate the ids fully' do
+        @allocations.should_receive(:process!).once.with(0, 0).ordered
+
+        @results.prepare!
+      end
+    end
+  end
+
+  describe "class accessors" do
+    describe 'Full' do
+      it "should have accessors for max_results" do
+        max_results = stub :max_results
+        old_results = Results::Full.max_results
+        Results::Full.max_results = max_results
+
+        Results::Full.max_results.should == max_results
+
+        Results::Full.max_results = old_results
+      end
+    end
+    describe 'Live' do
+      it "should have accessors for max_results" do
+        max_results = stub :max_results
+        old_results = Results::Live.max_results
+        Results::Live.max_results = max_results
+
+        Results::Live.max_results.should == max_results
+
+        Results::Live.max_results = old_results
+      end
+    end
+  end
+
+  describe 'initialize' do
+    context 'without allocations' do
+      describe 'Full' do
+        it 'should not fail' do
+          lambda {
+            Results::Full.new
+          }.should_not raise_error
+        end
+        it 'should set the allocations to allocations that are empty' do
+          Results::Full.new.instance_variable_get(:@allocations).should be_empty
+        end
+      end
+      describe 'Live' do
+        it 'should not fail' do
+          lambda {
+            Results::Live.new
+          }.should_not raise_error
+        end
+        it 'should set the allocations to allocations that are empty' do
+          Results::Live.new.instance_variable_get(:@allocations).should be_empty
+        end
+      end
+    end
+    context 'with allocations' do
+      describe 'Full' do
+        it 'should not fail' do
+          lambda {
+            Results::Full.new :some_allocations
+          }.should_not raise_error
+        end
+        it 'should set the allocations to an empty array' do
+          Results::Full.new(:some_allocations).instance_variable_get(:@allocations).should == :some_allocations
+        end
+      end
+      describe 'Live' do
+        it 'should not fail' do
+          lambda {
+            Results::Live.new :some_allocations
+          }.should_not raise_error
+        end
+        it 'should set the allocations to an empty array' do
+          Results::Live.new(:some_allocations).instance_variable_get(:@allocations).should == :some_allocations
+        end
+      end
+    end
+  end
+
+  describe 'duration' do
+    describe 'Full' do
+      before(:each) do
+        @results = Results::Full.new
+      end
+      it 'should return the set duration' do
+        @results.duration = :some_duration
+
+        @results.duration.should == :some_duration
+      end
+      it 'should return 0 as a default' do
+        @results.duration.should == 0
+      end
+    end
+    describe 'Live' do
+      before(:each) do
+        @results = Results::Live.new
+      end
+      it 'should return the set duration' do
+        @results.duration = :some_duration
+
+        @results.duration.should == :some_duration
+      end
+      it 'should return 0 as a default' do
+        @results.duration.should == 0
+      end
+    end
+  end
+
+  describe 'total' do
+    describe 'Full' do
+      it 'should delegate to allocations.total' do
+        allocations = stub :allocations
+        results = Results::Full.new allocations
+
+        allocations.should_receive(:total).once
+
+        results.total
+      end
+    end
+    describe 'Live' do
+      it 'should delegate to allocations.total' do
+        allocations = stub :allocations
+        results = Results::Live.new allocations
+
+        allocations.should_receive(:total).once
+
+        results.total
+      end
+    end
+
+  end
+
+  describe "accessors" do
+    before(:each) do
+      @results = Results::Base.new :anything
+      @some_stub = stub(:some)
+    end
+    it "should have accessors for duration" do
+      @results.duration = @some_stub
+      @results.duration.should == @some_stub
+    end
+  end
+
+end

data/spec/lib/routing_spec.rb

@@ -0,0 +1,318 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Routing do
+  
+  before(:each) do
+    @routing = Routing.new
+  end
+  
+  def rack_defaults_for url
+    url, query_string = url.split ??
+    
+    { "GATEWAY_INTERFACE"=>"CGI/1.1",
+      "PATH_INFO"=>"#{url}",
+      "QUERY_STRING"=>"#{query_string}",
+      "REMOTE_ADDR"=>"127.0.0.1",
+      "REMOTE_HOST"=>"localhost",
+      "REQUEST_METHOD"=>"GET",
+      "REQUEST_URI"=>"http://localhost:3001#{url}",
+      "SCRIPT_NAME"=>"",
+      "SERVER_NAME"=>"localhost",
+      "SERVER_PORT"=>"3001",
+      "SERVER_PROTOCOL"=>"HTTP/1.1",
+      "SERVER_SOFTWARE"=>"WEBrick/1.3.1 (Ruby/1.9.2/2010-07-11)",
+      "HTTP_HOST"=>"localhost:3001",
+      "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_8; en-us) AppleWebKit/533.16 (KHTML like Gecko) Version/5.0 Safari/533.16",
+      "HTTP_ACCEPT"=>"application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5",
+      "HTTP_CACHE_CONTROL"=>"max-age=0",
+      "HTTP_ACCEPT_LANGUAGE"=>"en-us",
+      "HTTP_ACCEPT_ENCODING"=>"gzip,
+      deflate",
+      "HTTP_COOKIE"=>"__utma=111872281.1536032598.1255697925.1255697925.1255697925.1; _jsuid=8971917605087477351; locale=de",
+      "HTTP_CONNECTION"=>"keep-alive",
+      "rack.input"=>'' }
+  end
+  
+  context 'real routes' do
+    before(:each) do
+      @routing.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"]]
+    end
+    it 'should route correctly' do
+      env = rack_defaults_for '/'
+      
+      @routing.root 200
+      
+      @routing.routes.freeze
+      @routing.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
+      
+      @routing.routes.freeze
+      @routing.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']] }
+      
+      @routing.routes.freeze
+      @routing.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']] }
+      
+      @routing.routes.freeze
+      @routing.call(env).should == [333, {}, ['this is gurk']]
+    end
+    it 'should route correctly' do
+      env = rack_defaults_for '/searches/live.json?query=some_query'
+      
+      live = stub :live
+      live.should_receive(:search_with_text).once.with(anything, 0).and_return(Results::Live.new)
+      Query::Live.stub! :new => live
+      
+      @routing.live %r{/searches/live}, :some_index
+      
+      @routing.routes.freeze
+      @routing.call(env).should == [200, {"Content-Type"=>"application/octet-stream", "Content-Length"=>"52"}, ["{\"allocations\":[],\"offset\":0,\"duration\":0,\"total\":0}"]]
+    end
+    it 'should route correctly' do
+      env = rack_defaults_for '/searches/live.json?query=some_query'
+      
+      live = stub :live
+      live.should_receive(:search_with_text).once.with(anything, 0).and_return(Results::Live.new)
+      Query::Live.stub! :new => live
+      
+      @routing.live '/searches/live', :some_index
+      
+      @routing.routes.freeze
+      @routing.call(env).should == [200, {"Content-Type"=>"application/octet-stream", "Content-Length"=>"52"}, ["{\"allocations\":[],\"offset\":0,\"duration\":0,\"total\":0}"]]
+    end
+    it 'should route correctly' do
+      env = rack_defaults_for '/searches/full?query=some_query'
+      
+      full = stub :full
+      full.should_receive(:search_with_text).once.with(anything, 0).and_return(Results::Full.new)
+      Query::Full.stub! :new => full
+      
+      @routing.full %r{/searches/full}, :some_index
+      
+      @routing.routes.freeze
+      @routing.call(env).should == [200, {"Content-Type"=>"application/octet-stream", "Content-Length"=>"50"}, ["\x04\b{\t:\x10allocations[\x00:\voffseti\x00:\rdurationi\x00:\ntotali\x00"]]
+    end
+    it 'should route correctly' do
+      env = rack_defaults_for '/searches/full?query=some_query'
+      
+      full = stub :full
+      full.should_receive(:search_with_text).once.with(anything, 0).and_return(Results::Full.new)
+      Query::Full.stub! :new => full
+      
+      @routing.full '/searches/full', :some_index
+      
+      @routing.routes.freeze
+      @routing.call(env).should == [200, {"Content-Type"=>"application/octet-stream", "Content-Length"=>"50"}, ["\x04\b{\t:\x10allocations[\x00:\voffseti\x00:\rdurationi\x00:\ntotali\x00"]]
+    end
+    it 'should route correctly' do
+      env = rack_defaults_for '/searches/some_route?query=some_query'
+      
+      full = stub :full
+      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)
+      
+      @routing.routes.freeze
+      @routing.call(env).should == [200, {"Content-Type"=>"application/octet-stream", "Content-Length"=>"50"}, ["\x04\b{\t:\x10allocations[\x00:\voffseti\x00:\rdurationi\x00:\ntotali\x00"]]
+    end
+    it 'should route correctly' do
+      env = rack_defaults_for '/searches/some_route?query=some_query&type=some_type'
+      
+      full = stub :full
+      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 }
+      
+      @routing.routes.freeze
+      @routing.call(env).should == [200, {"Content-Type"=>"application/octet-stream", "Content-Length"=>"50"}, ["\x04\b{\t:\x10allocations[\x00:\voffseti\x00:\rdurationi\x00:\ntotali\x00"]]
+    end
+    it 'should route correctly' do
+      env = rack_defaults_for '/searches/some_wrong_route?query=some_query'
+      
+      full = stub :full
+      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)
+      
+      @routing.routes.freeze
+      @routing.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
+    end
+    
+    describe 'generate_query_string' do
+      it 'should not allow an empty query condition' do
+        lambda {
+          @routing.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'
+      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'
+        }.should raise_error "Too many query param conditions (only 1 allowed): {:this=>:must_be, :that=>:should_be}"
+      end
+      it 'should be sanity checked' do
+        '/searches/some_route?query=some_query&type=some_type'.should match(%r{#{"type=some_type"}})
+      end
+    end
+    
+    describe 'route' do
+      before(:each) do
+        @some_query_app = stub :some_query_app
+        @routing.stub! :generate_app => @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/ }
+        
+        @routing.route %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/ }
+        
+        @routing.route '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/ }
+        
+        @routing.route '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]
+        
+        @routing.default 200
+      end
+    end
+    
+    describe 'root' do
+      it 'should call answer' do
+        @routing.should_receive(:answer).once.with %r{^/$}, Routing::STATUSES[200]
+        
+        @routing.root 200
+      end
+    end
+    
+    # 
+    describe 'live' do
+      describe 'instance creation' do
+        before(:each) do
+          @routing.stub :route
+        end
+        context 'with options' do
+          it 'should call route correctly' do
+            Query::Live.should_receive(:new).once.with :some_index, :some_other_index
+            
+            @routing.live :url, :some_index, :some_other_index, { :query => { :param => :value } }
+          end
+        end
+        context 'without options' do
+          it 'should call route correctly' do
+            Query::Live.should_receive(:new).once.with :some_index, :some_other_index
+            
+            @routing.live :url, :some_index, :some_other_index
+          end
+        end
+      end
+      describe 'delegation' do
+        context 'with options' do
+          it 'should call route correctly' do
+            Query::Live.stub! :new => :live
+            
+            @routing.should_receive(:route).once.with :url, :live, { :query => { :param => :value } }
+            
+            @routing.live :url, :some_index, { :query => { :param => :value } }
+          end
+        end
+        context 'without options' do
+          it 'should call route correctly' do
+            Query::Live.stub! :new => :live
+            
+            @routing.should_receive(:route).once.with :url, :live, {}
+            
+            @routing.live :url, :some_index
+          end
+        end
+      end
+    end
+    
+    describe 'answer' do
+      context 'with app' do
+        before(:each) do
+          @app = stub :app
+        end
+        context 'with url' 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
+          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
+          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/ }
+            
+            @routing.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" }
+            
+            @routing.answer
+          end
+        end
+      end
+    end
+    
+  end
+  
+end

data/spec/lib/solr/schema_generator_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Solr::SchemaGenerator do
+
+  before(:each) do
+    @types = stub :types
+    @configuration = stub :configuration, :types => @types
+    @generator = Solr::SchemaGenerator.new @configuration
+  end
+
+  describe 'bound_field_names' do
+    before(:each) do
+      @generator.stub! :combine_field_names => :some_field_names
+    end
+    it 'should bind field_names' do
+      b = @generator.bound_field_names
+
+      eval('field_names', b).should == :some_field_names
+    end
+  end
+
+  describe 'generate' do
+    before(:each) do
+      @generator.stub! :bound_field_names
+      @generator.stub! :generate_schema_for
+    end
+    it 'should receive generate_schema_for once with the result of extract_binding' do
+      @generator.stub! :bound_field_names => :some_binding
+
+      @generator.should_receive(:generate_schema_for).once.with :some_binding
+
+      @generator.generate
+    end
+    it 'should extract the binding' do
+      @generator.should_receive(:bound_field_names).once.with
+
+      @generator.generate
+    end
+  end
+
+end

data/spec/lib/sources/db_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Sources::DB do
+  
+  before(:each) do
+    @type       = stub :type, :name => 'some_type_name'
+    @connection = stub :connection
+    
+    @adapter          = stub :adapter, :connection => @connection
+    @select_statement = stub :statement
+    
+    @source = Sources::DB.new @select_statement, @adapter
+  end
+  
+  describe "count" do
+    it "should get the count through the public DB connection" do
+      result = stub(:result, :to_i => 12_345)
+      @connection.should_receive(:select_value).once.and_return(result)
+      
+      @source.count @type
+    end
+    it "should get the id count" do
+      result = stub(:result, :to_i => 12_345)
+      @connection.should_receive(:select_value).once.with("SELECT COUNT(id) FROM some_type_name_type_index")
+      
+      @source.count @type
+    end
+  end
+
+  describe "harvest" do
+    before(:each) do
+      @adapter.stub! :connect
+      @source.stub! :harvest_statement_with_offset
+    end
+    context 'expectations' do
+      before(:each) do
+        @connection.stub! :execute
+      end
+      after(:each) do
+        @source.harvest :some_type, :some_field, :some_offset, :some_chunksize
+      end
+      context "with WHERE" do
+        before(:each) do
+          @source.stub! :select_statement => 'bla WHERE blu'
+        end
+        it "should connect" do
+          @adapter.should_receive(:connect).once.with
+        end
+        it "should call the harvest statement with an offset" do
+          @source.should_receive(:harvest_statement_with_offset).once.with :some_type, :some_field, :some_offset, :some_chunksize
+        end
+      end
+      context "without WHERE" do
+        it "should connect" do
+          @adapter.should_receive(:connect).once.with
+        end
+        it "should call the harvest statement with an offset" do
+          @source.should_receive(:harvest_statement_with_offset).once.with :some_type, :some_field, :some_offset, :some_chunksize
+        end
+      end
+    end
+    context 'returns' do
+      it "should return whatever the execute statement returns" do
+        @connection.stub! :execute => :some_result
+        
+        @source.harvest(:some_type, :some_field, :some_offset, :some_chunksize).should == :some_result
+      end
+    end
+  end
+
+  describe "harvest_statement_with_offset" do
+    before(:each) do
+      @source.should_receive(:type_name).any_number_of_times.and_return :books
+      @field = stub :field, :name => :some_field
+      @type  = stub :type,  :name => :some_type
+    end
+    it "should get a harvest statement and the chunksize to put the statement together" do
+      @source.should_receive(:harvest_statement).once.and_return 'some_example_statement'
+      @source.harvest_statement_with_offset(@type, @field, :some_offset, :some_chunksize)
+    end
+    it "should add an AND if it already contains a WHERE statement" do
+      @source.should_receive(:harvest_statement).and_return 'WHERE'
+      @source.harvest_statement_with_offset(@type, @field, :some_offset, :some_chunksize).should == "WHERE AND st.id > some_offset LIMIT some_chunksize"
+    end
+    it "should add a WHERE if it doesn't already contain one" do
+      @source.should_receive(:harvest_statement).and_return 'some_statement'
+      @source.harvest_statement_with_offset(@type, @field, :some_offset, :some_chunksize).should == "some_statement WHERE st.id > some_offset LIMIT some_chunksize"
+    end
+  end
+  
+end