nuatt_sunspot 1.1.0.3

data/spec/api/indexer/spec_helper.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))

data/spec/api/indexer_spec.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'indexer', :type => :indexer do
+  it 'should completely wipe setup if class redefined (reloaded)' do
+    Object::ReloadableClass = Class.new(MockRecord)
+    Sunspot.setup(ReloadableClass) { string(:title) }
+    Object.class_eval { remove_const(:ReloadableClass) }
+    Object::ReloadableClass = Class.new(MockRecord)
+    Sunspot.setup(ReloadableClass) {}
+    lambda do
+      Sunspot.search(ReloadableClass) { with(:title, 'title') }
+    end.should raise_error(Sunspot::UnrecognizedFieldError)
+  end
+end

data/spec/api/query/advanced_manipulation_examples.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+shared_examples_for "query with advanced manipulation" do
+  describe 'adjust_solr_params' do
+    before :each do
+      search do
+        adjust_solr_params do |params|
+          params[:rows] = 40
+          params[:qt] = 'complicated'
+        end
+      end
+    end
+
+    it "modifies existing param" do
+      connection.should have_last_search_with(:rows  => 40)
+    end
+
+    it "adds new param" do
+      connection.should have_last_search_with(:qt => 'complicated')
+    end
+  end
+
+  describe 'request_handler' do
+    before :each do
+      connection.expected_handler = :myRequestHandler
+      search do
+        request_handler :myRequestHandler
+      end
+    end
+
+    it 'should use specified request handler' do
+      connection.should have_last_search_with({})
+    end
+  end
+end

data/spec/api/query/connectives_examples.rb

@@ -0,0 +1,176 @@
+shared_examples_for "query with connective scope" do
+  it 'creates a disjunction between two restrictions' do
+    search do
+      any_of do
+        with :category_ids, 1
+        with :blog_id, 2
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, '(category_ids_im:1 OR blog_id_i:2)'
+    )
+  end
+
+  it 'creates a conjunction inside of a disjunction' do
+    search do
+      any_of do
+        with :blog_id, 2
+        all_of do
+          with :category_ids, 1
+          with(:average_rating).greater_than(3.0)
+        end
+      end
+    end
+    connection.should have_last_search_including(
+      :fq,
+      '(blog_id_i:2 OR (category_ids_im:1 AND average_rating_ft:[3\.0 TO *]))'
+    )
+  end
+
+  it 'creates a disjunction with nested conjunction with negated restrictions' do
+    search do
+      any_of do
+        with :category_ids, 1
+        all_of do
+          without(:average_rating).greater_than(3.0)
+          with(:blog_id, 1)
+        end
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, '(category_ids_im:1 OR (-average_rating_ft:[3\.0 TO *] AND blog_id_i:1))'
+    )
+  end
+
+  it 'does nothing special if #all_of called from the top level' do
+    search do
+      all_of do
+        with :blog_id, 2
+        with :category_ids, 1
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, 'blog_id_i:2', 'category_ids_im:1'
+    )
+  end
+
+  it 'creates a disjunction with negated restrictions' do
+    search do
+      any_of do
+        with :category_ids, 1
+        without(:average_rating).greater_than(3.0)
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, '-(-category_ids_im:1 AND average_rating_ft:[3\.0 TO *])'
+    )
+  end
+
+  it 'creates a disjunction with a negated restriction and a nested disjunction in a conjunction with a negated restriction' do
+    search do
+      any_of do
+        without(:title, 'Yes')
+        all_of do
+          with(:blog_id, 1)
+          any_of do
+            with(:category_ids, 4)
+            without(:average_rating, 2.0)
+          end
+        end
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, '-(title_ss:Yes AND -(blog_id_i:1 AND -(-category_ids_im:4 AND average_rating_ft:2\.0)))'
+    )
+  end
+  it 'creates a disjunction with nested conjunction with nested disjunction with negated restriction' do
+    search do
+      any_of do
+        with(:title, 'Yes')
+        all_of do
+          with(:blog_id, 1)
+          any_of do
+            with(:category_ids, 4)
+            without(:average_rating, 2.0)
+          end
+        end
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, '(title_ss:Yes OR (blog_id_i:1 AND -(-category_ids_im:4 AND average_rating_ft:2\.0)))'
+    )
+  end
+
+  #
+  # This is important because if a disjunction could be nested in another
+  # disjunction, then the inner disjunction could denormalize (and thus
+  # become negated) after the outer disjunction denormalized (checking to
+  # see if the inner one is negated). Since conjunctions never need to
+  # denormalize, if a disjunction can only contain conjunctions or restrictions,
+  # we can guarantee that the negation state of a disjunction's components will
+  # not change when #to_params is called on them.
+  #
+  # Since disjunction is associative, this behavior has no effect on the actual
+  # logical semantics of the disjunction.
+  #
+  it 'creates a single disjunction when disjunctions nested' do
+    search do
+      any_of do
+        with(:title, 'Yes')
+        any_of do
+          with(:blog_id, 1)
+          with(:category_ids, 4)
+        end
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, '(title_ss:Yes OR blog_id_i:1 OR category_ids_im:4)'
+    )
+  end
+
+  it 'creates a disjunction with instance exclusion' do
+    post = Post.new
+    search do
+      any_of do
+        without(post)
+        with(:category_ids, 1)
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, "-(id:Post\\ #{post.id} AND -category_ids_im:1)"
+    )
+  end
+
+  it 'creates a disjunction with empty restriction' do
+    search do
+      any_of do
+        with(:average_rating, nil)
+        with(:average_rating).greater_than(3.0)
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, '-(average_rating_ft:[* TO *] AND -average_rating_ft:[3\.0 TO *])'
+    )
+  end
+
+  it 'creates a disjunction with some text field components' do
+    search do
+      any_of do
+        text_fields do
+          with(:title).starting_with('test')
+        end
+        with(:blog_id, 1)
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, '(title_text:test* OR blog_id_i:1)'
+    )
+  end
+
+  it 'should ignore empty connectives' do
+    search do
+      any_of {}
+    end
+    connection.should_not have_last_search_including(:fq, '')
+  end
+end

data/spec/api/query/dsl_spec.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'query DSL', :type => :query do
+  it 'should allow building search using block argument rather than instance_eval' do
+    @blog_id = 1
+    session.search Post do |query|
+      query.with(:blog_id, @blog_id)
+    end
+    connection.should have_last_search_including(:fq, 'blog_id_i:1')
+  end
+
+  it 'should accept a block in the #new_search method' do
+    search = session.new_search(Post) { with(:blog_id, 1) }
+    search.execute
+    connection.should have_last_search_including(:fq, 'blog_id_i:1')
+  end
+end
+

data/spec/api/query/dynamic_fields_examples.rb

@@ -0,0 +1,165 @@
+shared_examples_for "query with dynamic field support" do
+  it 'restricts by dynamic string field with equality restriction' do
+    search do
+      dynamic :custom_string do
+        with :test, 'string'
+      end
+    end
+    connection.should have_last_search_including(:fq, 'custom_string\:test_ss:string')
+  end
+
+  it 'restricts by dynamic integer field with less than restriction' do
+    search do
+      dynamic :custom_integer do
+        with(:test).less_than(1)
+      end
+    end
+    connection.should have_last_search_including(:fq, 'custom_integer\:test_i:[* TO 1]')
+  end
+
+  it 'restricts by dynamic float field with between restriction' do
+    search do
+      dynamic :custom_float do
+        with(:test).between(2.2..3.3)
+      end
+    end
+    connection.should have_last_search_including(:fq, 'custom_float\:test_fm:[2\.2 TO 3\.3]')
+  end
+
+  it 'restricts by dynamic time field with any of restriction' do
+    search do
+      dynamic :custom_time do
+        with(:test).any_of([Time.parse('2009-02-10 14:00:00 UTC'),
+                            Time.parse('2009-02-13 18:00:00 UTC')])
+      end
+    end
+    connection.should have_last_search_including(:fq, 'custom_time\:test_d:(2009\-02\-10T14\:00\:00Z OR 2009\-02\-13T18\:00\:00Z)')
+  end
+
+  it 'restricts by dynamic boolean field with equality restriction' do
+    search do
+      dynamic :custom_boolean do
+        with :test, false
+      end
+    end
+    connection.should have_last_search_including(:fq, 'custom_boolean\:test_b:false')
+  end
+
+  it 'negates a dynamic field restriction' do
+    search do
+      dynamic :custom_string do
+        without :test, 'foo'
+      end
+    end
+    connection.should have_last_search_including(:fq, '-custom_string\:test_ss:foo')
+  end
+
+  it 'scopes by a dynamic field inside a disjunction' do
+    search do
+      any_of do
+        dynamic :custom_string do
+          with :test, 'foo'
+        end
+        with :title, 'bar'
+      end
+    end
+    connection.should have_last_search_including(
+      :fq, '(custom_string\:test_ss:foo OR title_ss:bar)'
+    )
+  end
+
+  it 'orders by a dynamic field' do
+    search do
+      dynamic :custom_integer do
+        order_by :test, :desc
+      end
+    end
+    connection.should have_last_search_with(:sort => 'custom_integer:test_i desc')
+  end
+
+  it 'orders by a dynamic field and static field, with given precedence' do
+    search do
+      dynamic :custom_integer do
+        order_by :test, :desc
+      end
+      order_by :sort_title, :asc
+    end
+    connection.should have_last_search_with(:sort => 'custom_integer:test_i desc, sort_title_s asc')
+  end
+
+  it 'raises an UnrecognizedFieldError if an unknown dynamic field is searched by' do
+    lambda do
+      search do
+        dynamic(:bogus) { with :some, 'value' }
+      end
+    end.should raise_error(Sunspot::UnrecognizedFieldError)
+  end
+
+  it 'raises a NoMethodError if pagination is attempted in a dynamic query' do
+    lambda do
+      search do
+        dynamic :custom_string do
+          paginate :page => 3, :per_page => 10
+        end
+      end
+    end.should raise_error(NoMethodError)
+  end
+
+  it 'requests field facet on dynamic field' do
+    search do
+      dynamic :custom_string do
+        facet(:test)
+      end
+    end
+    connection.should have_last_search_including(:"facet.field", 'custom_string:test_ss')
+  end
+
+  it 'requests named field facet on dynamic field' do
+    search do
+      dynamic :custom_string do
+        facet(:test, :name => :bogus)
+      end
+    end
+    connection.should have_last_search_including(:"facet.field", '{!key=bogus}custom_string:test_ss')
+  end
+
+  it 'requests query facet with internal dynamic field' do
+    search do
+      facet :test do
+        row 'foo' do
+          dynamic :custom_string do
+            with :test, 'foo'
+          end
+        end
+      end
+    end
+    connection.should have_last_search_with(
+      :"facet.query" => 'custom_string\:test_ss:foo'
+    )
+  end
+
+  it 'requests query facet with external dynamic field' do
+    search do
+      dynamic :custom_string do
+        facet :test do
+          row 'foo' do
+            with :test, 'foo'
+          end
+        end
+      end
+    end
+    connection.should have_last_search_including(
+      :"facet.query",
+      'custom_string\:test_ss:foo'
+    )
+  end
+
+  it 'allows scoping on dynamic fields common to all types' do
+    search Post, Namespaced::Comment do
+      dynamic :custom_float do
+        with(:test, 1.23)
+      end
+    end
+    connection.should have_last_search_including(:fq, 'custom_float\\:test_fm:1\\.23')
+  end
+end

data/spec/api/query/faceting_examples.rb

@@ -0,0 +1,399 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+shared_examples_for "facetable query" do
+  describe 'on fields' do
+    it 'does not turn faceting on if no facet requested' do
+      search
+      connection.should_not have_last_search_with('facet')
+    end
+
+    it 'turns faceting on if facet is requested' do
+      search do
+        facet :category_ids
+      end
+      connection.should have_last_search_with(:facet => 'true')
+    end
+
+    it 'requests single field facet' do
+      search do
+        facet :category_ids
+      end
+      connection.should have_last_search_with(:"facet.field" => %w(category_ids_im))
+    end
+
+    it 'requests multiple field facets' do
+      search do
+        facet :category_ids, :blog_id
+      end
+      connection.should have_last_search_with(:"facet.field" => %w(category_ids_im blog_id_i))
+    end
+
+    it 'sets facet sort by count' do
+      search do
+        facet :category_ids, :sort => :count
+      end
+      connection.should have_last_search_with(:"f.category_ids_im.facet.sort" => 'true')
+    end
+
+    it 'sets facet sort by index' do
+      search do
+        facet :category_ids, :sort => :index
+      end
+      connection.should have_last_search_with(:"f.category_ids_im.facet.sort" => 'false')
+    end
+
+    it 'raises ArgumentError if bogus facet sort provided' do
+      lambda do
+        search do
+          facet :category_ids, :sort => :sideways
+        end
+      end.should raise_error(ArgumentError)
+    end
+
+    it 'sets the facet limit' do
+      search do
+        facet :category_ids, :limit => 10
+      end
+      connection.should have_last_search_with(:"f.category_ids_im.facet.limit" => 10)
+    end
+
+    it 'sets the facet minimum count' do
+      search do
+        facet :category_ids, :minimum_count => 5
+      end
+      connection.should have_last_search_with(:"f.category_ids_im.facet.mincount" => 5)
+    end
+
+    it 'sets the facet minimum count to zero if zeros are allowed' do
+      search do
+        facet :category_ids, :zeros => true
+      end
+      connection.should have_last_search_with(:"f.category_ids_im.facet.mincount" => 0)
+    end
+
+    it 'sets the facet minimum count to one by default' do
+      search do
+        facet :category_ids
+      end
+      connection.should have_last_search_with(:"f.category_ids_im.facet.mincount" => 1)
+    end
+
+    it 'sets the facet prefix' do
+      search do
+        facet :title, :prefix => 'Test'
+      end
+      connection.should have_last_search_with(:"f.title_ss.facet.prefix" => 'Test')
+    end
+
+    it 'escapes the facet prefix' do
+      search do
+        facet :title, :prefix => 'Test Title'
+      end
+      connection.should have_last_search_with(:"f.title_ss.facet.prefix" => 'Test\ Title')
+    end
+
+    it 'sends a query facet for :any extra' do
+      search do
+        facet :category_ids, :extra => :any
+      end
+      connection.should have_last_search_with(:"facet.query" => "category_ids_im:[* TO *]")
+    end
+
+    it 'sends a query facet for :none extra' do
+      search do
+        facet :category_ids, :extra => :none
+      end
+      connection.should have_last_search_with(:"facet.query" => "-category_ids_im:[* TO *]")
+    end
+
+    it 'raises an ArgumentError if bogus extra is passed' do
+      lambda do
+        search do
+          facet :category_ids, :extra => :bogus
+        end
+      end.should raise_error(ArgumentError)
+    end
+
+    it 'tags and excludes a scope filter in a field facet' do
+      search do
+        blog_filter = with(:blog_id, 1)
+        facet(:blog_id, :exclude => blog_filter)
+      end
+      filter_tag = get_filter_tag('blog_id_i:1')
+      connection.should have_last_search_with(
+        :"facet.field" => %W({!ex=#{filter_tag}}blog_id_i)
+      )
+    end
+
+    it 'tags and excludes a disjunction filter in a field facet' do
+      search do
+        blog_filter = any_of do
+          with(:blog_id, 1)
+          with(:blog_id, 2)
+        end
+        facet(:blog_id, :exclude => blog_filter)
+      end
+      filter_tag = get_filter_tag('(blog_id_i:1 OR blog_id_i:2)')
+      connection.should have_last_search_with(
+        :"facet.field" => %W({!ex=#{filter_tag}}blog_id_i)
+      )
+    end
+
+    it 'tags and excludes multiple filters in a field facet' do
+      search do
+        blog_filter = with(:blog_id, 1)
+        category_filter = with(:category_ids, 2)
+        facet(:blog_id, :exclude => [blog_filter, category_filter])
+      end
+      filter_tags = %w(blog_id_i:1 category_ids_im:2).map do |phrase|
+        get_filter_tag(phrase)
+      end.join(',')
+      connection.should have_last_search_with(
+        :"facet.field" => %W({!ex=#{filter_tags}}blog_id_i)
+      )
+    end
+
+    it 'does not tag a filter if it is not excluded' do
+      search do
+        with(:blog_id, 1)
+      end
+      connection.should have_last_search_including(:fq, "blog_id_i:1")
+    end
+
+    it 'names a field facet' do
+      search do
+        facet(:blog_id, :name => :blog)
+      end
+      connection.should have_last_search_including(:"facet.field", "{!key=blog}blog_id_i")
+    end
+
+    it 'uses the custom field facet name in facet option parameters' do
+      search do
+        facet(:blog_id, :name => :blog, :sort => :count)
+      end
+      connection.should have_last_search_with(:"f.blog.facet.sort" => 'true')
+    end
+
+    it 'raises an ArgumentError if exclusion attempted on a query facet' do
+      lambda do
+        search do
+          blog_filter = with(:blog_id, 1)
+          facet(:bad, :exclude => blog_filter) do
+            row(:bogus) { with(:blog_id, 1) }
+          end
+        end
+      end.should raise_error(ArgumentError)
+    end
+
+    it 'raises an ArgumentError if exclusion attempted on a restricted field facet' do
+      lambda do
+        search do
+          blog_filter = with(:blog_id, 1)
+          facet(:blog_id, :only => 1, :exclude => blog_filter)
+        end
+      end.should raise_error(ArgumentError)
+    end
+
+    it 'raises an ArgumentError if exclusion attempted on a facet with :extra' do
+      lambda do
+        search do
+          blog_filter = with(:blog_id, 1)
+          facet(:blog_id, :extra => :all, :exclude => blog_filter)
+        end
+      end.should raise_error(ArgumentError)
+    end
+  end
+
+  describe 'on time ranges' do
+    before :each do
+      @time_range = (Time.parse('2009-06-01 00:00:00 -0400')..
+                     Time.parse('2009-07-01 00:00:00 -0400'))
+    end
+
+    it 'does not send date facet parameters if time range is not specified' do
+      search do |query|
+        query.facet :published_at
+      end
+      connection.should_not have_last_search_with(:"facet.date")
+    end
+
+    it 'sets the facet to a date facet if time range is specified' do
+      search do |query|
+        query.facet :published_at, :time_range => @time_range
+      end
+      connection.should have_last_search_with(:"facet.date" => ['published_at_dt'])
+    end
+
+    it 'sets the facet start and end' do
+      search do |query|
+        query.facet :published_at, :time_range => @time_range
+      end
+      connection.should have_last_search_with(
+        :"f.published_at_dt.facet.date.start" => '2009-06-01T04:00:00Z',
+        :"f.published_at_dt.facet.date.end" => '2009-07-01T04:00:00Z'
+      )
+    end
+
+    it 'defaults the time interval to 1 day' do
+      search do |query|
+        query.facet :published_at, :time_range => @time_range
+      end
+      connection.should have_last_search_with(:"f.published_at_dt.facet.date.gap" => "+86400SECONDS")
+    end
+
+    it 'uses custom time interval' do
+      search do |query|
+        query.facet :published_at, :time_range => @time_range, :time_interval => 3600
+      end
+      connection.should have_last_search_with(:"f.published_at_dt.facet.date.gap" => "+3600SECONDS")
+    end
+
+    it 'does not allow date faceting on a non-date field' do
+      lambda do
+        search do |query|
+          query.facet :blog_id, :time_range => @time_range
+        end
+      end.should raise_error(ArgumentError)
+    end
+  end
+
+  describe 'using queries' do
+    it 'turns faceting on' do
+      search do
+        facet :foo do
+          row :bar do
+            with(:average_rating).between(4.0..5.0)
+          end
+        end
+      end
+      connection.should have_last_search_with(:facet => 'true')
+    end
+
+    it 'facets by query' do
+      search do
+        facet :foo do
+          row :bar do
+            with(:average_rating).between(4.0..5.0)
+          end
+        end
+      end
+      connection.should have_last_search_with(:"facet.query" => 'average_rating_ft:[4\.0 TO 5\.0]')
+    end
+
+    it 'requests multiple query facets' do
+      search do
+        facet :foo do
+          row :bar do
+            with(:average_rating).between(3.0..4.0)
+          end
+          row :baz do
+            with(:average_rating).between(4.0..5.0)
+          end
+        end
+      end
+      connection.should have_last_search_with(
+        :"facet.query" => [
+          'average_rating_ft:[3\.0 TO 4\.0]',
+          'average_rating_ft:[4\.0 TO 5\.0]'
+        ]
+      )
+    end
+
+    it 'requests query facet with multiple conditions' do
+      search do
+        facet :foo do
+          row :bar do
+            with(:category_ids, 1)
+            with(:blog_id, 2)
+          end
+        end
+      end
+      connection.should have_last_search_with(
+        :"facet.query" => '(category_ids_im:1 AND blog_id_i:2)'
+      )
+    end
+
+    it 'requests query facet with disjunction' do
+      search do
+        facet :foo do
+          row :bar do
+            any_of do
+              with(:category_ids, 1)
+              with(:blog_id, 2)
+            end
+          end
+        end
+      end
+      connection.should have_last_search_with(
+        :"facet.query" => '(category_ids_im:1 OR blog_id_i:2)'
+      )
+    end
+
+    it 'builds query facets when passed :only argument to field facet declaration' do
+      search do
+        facet :category_ids, :only => [1, 3]
+      end
+      connection.should have_last_search_with(
+        :"facet.query" => ['category_ids_im:1', 'category_ids_im:3']
+      )
+    end
+
+    it 'converts limited query facet values to the correct type' do
+      search do
+        facet :published_at, :only => [Time.utc(2009, 8, 28, 15, 33), Time.utc(2008,8, 28, 15, 33)]
+      end
+      connection.should have_last_search_with(
+        :"facet.query" => [
+          'published_at_dt:2009\-08\-28T15\:33\:00Z',
+          'published_at_dt:2008\-08\-28T15\:33\:00Z'
+        ]
+      )
+    end
+
+    it 'ignores facet query with no rows' do
+      search do
+        facet(:foo) {}
+      end
+      connection.should_not have_last_search_with(:"facet.query")
+    end
+
+    it 'ignores facet query row with no restrictions' do
+      search do
+        facet :foo do
+          row(:bar) do
+            with(:blog_id, 1)
+          end
+          row(:baz) {}
+        end
+      end
+      connection.searches.last[:"facet.query"].should be_a(String)
+    end
+
+    it 'ignores facet query with only empty rows' do
+      search do
+        facet :foo do
+          row(:bar) {}
+        end
+      end
+      connection.should_not have_last_search_with(:"facet.query")
+    end
+
+    it 'does not allow 0 arguments to facet method with block' do
+      lambda do
+        search do
+          facet do
+          end
+        end
+      end.should raise_error(ArgumentError)
+    end
+
+    it 'does not allow more than 1 argument to facet method with block' do
+      lambda do
+        search do
+          facet :foo, :bar do
+          end
+        end
+      end.should raise_error(ArgumentError)
+    end
+  end
+end