tire-erez 0.5.4

data/test/unit/results_item_test.rb

@@ -0,0 +1,173 @@
+require 'test_helper'
+
+module Tire
+  class ResultsItemTest < Test::Unit::TestCase
+
+    # ActiveModel compatibility tests
+    #
+    def setup
+      super
+      begin; Object.send(:remove_const, :Rails); rescue; end
+      @model = Results::Item.new :title => 'Test'
+    end
+    include ActiveModel::Lint::Tests
+
+    context "Item" do
+
+      setup do
+        @document = Results::Item.new :title  => 'Test',
+                                      :author => { :name => 'Kafka' },
+                                      :awards => { :best_fiction => { :year => '1925' } }
+      end
+
+      should "be initialized with a Hash or Hash like object" do
+        assert_raise(ArgumentError) { Results::Item.new('FUUUUUUU') }
+
+        assert_nothing_raised do
+          d = Results::Item.new(:id => 1)
+          assert_instance_of Results::Item, d
+        end
+
+        assert_nothing_raised do
+          class AlmostHash < Hash; end
+          d = Results::Item.new(AlmostHash.new(:id => 1))
+        end
+      end
+
+      should "have an 'id' method" do
+        a = Results::Item.new(:_id => 1)
+        b = Results::Item.new(:id => 1)
+        assert_equal 1, a.id
+        assert_equal 1, b.id
+      end
+
+      should "have a 'type' method" do
+        a = Results::Item.new(:_type => 'foo')
+        b = Results::Item.new(:type => 'foo')
+        assert_equal 'foo', a.type
+        assert_equal 'foo', b.type
+      end
+
+      should "respond to :to_indexed_json" do
+        assert_respond_to Results::Item.new, :to_indexed_json
+      end
+
+      should "retrieve simple values from underlying hash" do
+        assert_equal 'Test', @document[:title]
+      end
+
+      should "retrieve hash values from underlying hash" do
+        assert_equal 'Kafka', @document[:author][:name]
+      end
+
+      should "allow to retrieve value by methods" do
+        assert_not_nil @document.title
+        assert_equal 'Test', @document.title
+      end
+
+      should "implement respond_to? for proxied methods" do
+        assert @document.respond_to?(:title)
+        assert @document.respond_to?(:title, true)
+      end
+
+      should "return nil for non-existing keys/methods" do
+        assert_nothing_raised { @document.whatever }
+        assert_nil @document.whatever
+      end
+
+      should "not care about symbols or strings in keys" do
+        @document = Results::Item.new 'title' => 'Test'
+        assert_not_nil @document.title
+        assert_equal 'Test', @document.title
+      end
+
+      should "not care about symbols or strings in composite keys" do
+        @document = Results::Item.new :highlight => { 'name.ngrams' => 'abc' }
+
+        assert_not_nil @document.highlight['name.ngrams']
+        assert_equal   'abc', @document.highlight['name.ngrams']
+        assert_equal   @document.highlight['name.ngrams'], @document.highlight['name.ngrams'.to_sym]
+      end
+
+      should "allow to retrieve values from nested hashes" do
+        assert_not_nil   @document.author.name
+        assert_equal 'Kafka', @document.author.name
+      end
+
+      should "wrap arrays" do
+        @document = Results::Item.new :stats => [1, 2, 3]
+        assert_equal [1, 2, 3], @document.stats
+      end
+
+      should "wrap hashes in arrays" do
+        @document = Results::Item.new :comments => [{:title => 'one'}, {:title => 'two'}]
+        assert_equal 2,    @document.comments.size
+        assert_instance_of Results::Item, @document.comments.first
+        assert_equal       'one', @document.comments.first.title
+        assert_equal       'two', @document.comments.last.title
+      end
+
+      should "be an Item instance" do
+        assert_instance_of Tire::Results::Item, @document
+      end
+
+      should "be convertible to hash" do
+        assert_instance_of Hash, @document.to_hash
+        assert_instance_of Hash, @document.to_hash[:author]
+        assert_instance_of Hash, @document.to_hash[:awards][:best_fiction]
+
+        assert_equal 'Kafka', @document.to_hash[:author][:name]
+        assert_equal '1925',  @document.to_hash[:awards][:best_fiction][:year]
+      end
+
+      should "be convertible to JSON" do
+        assert_instance_of Hash, @document.as_json
+        assert_equal 'Test', @document.as_json(:only => 'title')['title']
+        assert_nil           @document.as_json(:only => 'title')['author']
+      end
+
+      should "be inspectable" do
+        assert_match /<Item .* title|Item .* author/, @document.inspect
+      end
+
+      context "within Rails" do
+
+        setup do
+          module ::Rails
+          end
+
+          class ::FakeRailsModel
+            extend  ActiveModel::Naming
+            include ActiveModel::Conversion
+            def self.find(id, options); new; end
+          end
+
+          @document = Results::Item.new :id => 1, :_type => 'fake_rails_model', :title => 'Test'
+        end
+
+        should "be an instance of model, based on _type" do
+          assert_equal FakeRailsModel, @document.class
+        end
+
+        should "be inspectable with masquerade" do
+          assert_match /<Item \(FakeRailsModel\)/, @document.inspect
+        end
+
+        should "return proper singular and plural forms" do
+          assert_equal 'fake_rails_model',  ActiveModel::Naming.singular(@document)
+          assert_equal 'fake_rails_models', ActiveModel::Naming.plural(@document)
+        end
+
+        should "instantiate itself for deep hashes, not a Ruby class corresponding to type" do
+          document = Results::Item.new :_type => 'my_model', :title => 'Test', :author => { :name => 'John' }
+
+          assert_equal Tire::Results::Item, document.class
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/unit/rubyext_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+module Tire
+
+  class RubyCoreExtensionsTest < Test::Unit::TestCase
+
+    context "Hash" do
+
+      context "with no to_json method provided" do
+
+        setup do
+          @hash = { :one => 1}
+          # Undefine the `to_json` method...
+          ::Hash.class_eval { remove_method(:to_json) rescue nil }
+          # ... and reload the extension, so it's added
+          load 'tire/rubyext/hash.rb'
+        end
+
+        should "have its own to_json method" do
+          assert_respond_to( @hash, :to_json )
+          assert_equal '{"one":1}', @hash.to_json
+        end
+
+        should "allow to pass options to to_json for compatibility" do
+          assert_nothing_raised do
+            assert_equal '{"one":1}', @hash.to_json({})
+          end
+        end
+
+      end
+
+      should "have a to_json method from a JSON serialization library" do
+        assert_respond_to( {}, :to_json )
+        assert_equal '{"one":1}', { :one => 1}.to_json
+      end
+
+      should "have to_indexed_json method doing the same as to_json" do
+        [{}, { :foo => 2 }, { :foo => 4, :bar => 6 }, { :foo => [7,8,9] }].each do |h|
+          assert_equal MultiJson.decode(h.to_json), MultiJson.decode(h.to_indexed_json)
+        end
+      end
+
+      should "properly serialize Time into JSON" do
+        json = { :time => Time.mktime(2011, 01, 01, 11, 00).to_json  }.to_json
+        assert_match /"2011-01-01T11:00:00.*"/, MultiJson.decode(json)['time']
+      end
+
+    end
+
+    context "Array" do
+
+      should "encode itself to JSON" do
+        assert_equal '["one","two"]', ['one','two'].to_json
+      end
+
+    end
+
+    context "Ruby Test::Unit" do
+      should "actually return true from assert..." do
+        assert_equal true, assert(true)
+      end
+    end
+
+  end
+
+end

data/test/unit/search_facet_test.rb

@@ -0,0 +1,186 @@
+require 'test_helper'
+
+module Tire::Search
+
+  class FacetTest < Test::Unit::TestCase
+
+    context "Facet" do
+
+      should "be serialized to JSON" do
+        assert_respond_to Facet.new('foo'), :to_json
+      end
+
+      context "generally" do
+
+        should "encode facets with defaults for current query" do
+          assert_equal( MultiJson.load({ :foo => { :terms => {:field=>'bar',:size=>10,:all_terms=>false} } }.to_json),
+                        MultiJson.load(Facet.new('foo').terms(:bar).to_json) )
+        end
+
+        should "encode facets as global" do
+          assert_equal( MultiJson.load({ :foo => { :terms => {:field=>'bar',:size=>10,:all_terms=>false}, :global => true } }.to_json),
+                        MultiJson.load(Facet.new('foo', :global => true).terms(:bar).to_json) )
+        end
+
+        should "pass options to facets" do
+          payload = Facet.new('foo', :facet_filter => { :term => { :account_id => 'foo' } }).terms(:bar).to_hash
+
+          assert_not_nil payload['foo'][:facet_filter]
+          assert_equal( { :term => { :account_id => 'foo' } },
+                        payload['foo'][:facet_filter] )
+        end
+
+        should "encode facet options" do
+          assert_equal( MultiJson.load( { :foo => { :terms => {:field=>'bar',:size=>5,:all_terms=>false} } }.to_json ),
+                        MultiJson.load( Facet.new('foo').terms(:bar, :size => 5).to_json ) )
+        end
+
+        should "encode facets when passed as a block" do
+          f = Facet.new('foo') do
+            terms :bar
+          end
+          assert_equal( MultiJson.load({ :foo => { :terms => {:field=>'bar',:size=>10,:all_terms=>false} } }.to_json),
+                        MultiJson.load(f.to_json) )
+        end
+
+        should "encode facets when passed as a block, using variables from outer scope" do
+          def foo; 'bar'; end
+
+          f = Facet.new('foo') do |facet|
+            facet.terms foo, :size => 20
+          end
+          assert_equal( MultiJson.load({ :foo => { :terms => {:field=>'bar',:size=>20,:all_terms=>false} } }.to_json),
+                        MultiJson.load(f.to_json) )
+        end
+
+        should "encode facet_filter option with DSL" do
+          f = Facet.new('foo'){
+            terms :published_on
+            facet_filter :terms, :tags => ['ruby']
+          }.to_hash
+
+          assert_equal( { :terms => {:tags => ['ruby'] }}.to_json, f['foo'][:facet_filter].to_json)
+        end
+
+        should "encode multiple facet_filter options with DSL" do
+          f = Facet.new('foo'){
+            terms :published_on
+            facet_filter :and, { :tags => ['ruby'] },
+                               { :words => 250 }
+          }.to_hash
+
+          assert_equal( { :and => [{:tags => ['ruby']}, {:words => 250 }] }.to_json,
+                        f['foo'][:facet_filter].to_json )
+        end
+
+        should "allow arbitrary ordering of methods in the DSL block" do
+          f = Facet.new('foo') do
+            facet_filter :terms, :tags => ['ruby']
+            terms :published_on
+          end.to_hash
+
+          assert_equal( { :terms => {:tags => ['ruby'] }}.to_json, f['foo'][:facet_filter].to_json)
+        end
+
+      end
+
+      context "terms facet" do
+
+        should "encode the default all_terms option" do
+          assert_equal false, Facet.new('foo') { terms :foo }.to_hash['foo'][:terms][:all_terms]
+        end
+
+        should "encode the all_terms option" do
+          assert_equal true, Facet.new('foo') { terms :foo, :all_terms => true }.to_hash['foo'][:terms][:all_terms]
+        end
+
+        should "encode custom options" do
+          assert_equal( MultiJson.load({ :foo => { :terms => {:field=>'bar',:size=>5,:all_terms=>false,:exclude=>['moo']} } }.to_json),
+                        MultiJson.load(Facet.new('foo').terms(:bar, :size => 5, :exclude => ['moo']).to_json) )
+        end
+
+      end
+
+      context "date histogram" do
+
+        should "encode the JSON with default values" do
+          f = Facet.new('date') { date :published_on }
+          assert_equal({ :date => { :date_histogram => { :field => 'published_on', :interval => 'day' } } }.to_json, f.to_json)
+        end
+
+        should "encode the JSON with custom interval" do
+          f = Facet.new('date') { date :published_on, :interval => 'month' }
+          assert_equal({ :date => { :date_histogram => { :field => 'published_on', :interval => 'month' } } }.to_json, f.to_json)
+        end
+
+        should "encode custom options" do
+          f = Facet.new('date') { date :published_on, :value_field => 'price'  }
+          assert_equal( {:date=>{:date_histogram=>{:key_field=>'published_on',:interval=>'day',:value_field=>'price' } } }.to_json,
+                        f.to_json )
+        end
+
+      end
+
+      context "range facet" do
+        should "encode facet options" do
+          f = Facet.new('range') { range :published_on, [{:to => '2010-12-31'}, {:from => '2011-01-01', :to => '2011-05-27'}, {:from => '2011-05-28'}]}
+          assert_equal({ :range => { :range => { :field => 'published_on', :ranges => [{:to => '2010-12-31'}, {:from => '2011-01-01', :to => '2011-05-27'}, {:from => '2011-05-28'}] } } }.to_json, f.to_json)
+        end
+      end
+
+      context "histogram facet" do
+        should "encode facet options with default key" do
+          f = Facet.new('histogram') { histogram :age, {:interval => 5} }
+          assert_equal({ :histogram => { :histogram => { :field => 'age', :interval => 5 } } }.to_json, f.to_json)
+        end
+
+        should "encode the JSON if define an histogram" do
+          f = Facet.new('histogram') { histogram :age, {:histogram => {:key_field => "age", :value_field => "age", :interval => 100}} }
+          assert_equal({ :histogram => { :histogram => {:key_field => "age", :value_field => "age", :interval => 100} } }.to_json, f.to_json)
+        end
+      end
+
+      context "statistical facet" do
+        should "encode facet options" do
+          f = Facet.new('statistical') { statistical :words }
+          assert_equal({:statistical => {:statistical => {:field => 'words'}}}.to_json, f.to_json)
+        end
+
+        should "encode the JSON if a 'statistical' custom option is defined" do
+          f = Facet.new('statistical') { statistical :words, :statistical => {:params => {:factor => 5}} }
+          assert_equal({:statistical => {:statistical => {:params => {:factor => 5 }}}}.to_json, f.to_json)
+        end
+      end
+
+      context "terms_stats facet" do
+        should "should encode facet options" do
+          f = Facet.new('terms_stats') { terms_stats :tags, :words }
+          assert_equal({:terms_stats => {:terms_stats => {:key_field => 'tags', :value_field => 'words'}}}.to_json, f.to_json)
+        end
+      end
+
+      context "query facet" do
+        should "encode facet options" do
+          f = Facet.new('q_facet') do
+            query { string '_exists_:foo' }
+          end
+          assert_equal({ :q_facet => { :query => { :query_string => { :query => '_exists_:foo' } } } }.to_json, f.to_json)
+        end
+      end
+
+      context "filter facet" do
+
+        should "encode facet options" do
+          f = Facet.new('filter_facet') do
+            filter :term, :tags => 'ruby'
+          end
+          assert_equal({ :filter_facet => { :filter => { :term => { :tags => 'ruby' } } } }.to_json, f.to_json)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/unit/search_filter_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Tire::Search
+
+  class FilterTest < Test::Unit::TestCase
+
+    context "Filter" do
+
+      should "be serialized to JSON" do
+        assert_respond_to Filter.new(:terms, {}), :to_json
+      end
+
+      should "encode simple filter declarations as JSON" do
+        assert_equal( { :terms => {} }.to_json,
+                      Filter.new('terms').to_json )
+
+        assert_equal( { :terms => { :tags => ['foo'] } }.to_json,
+                      Filter.new('terms', :tags => ['foo']).to_json )
+
+        assert_equal( { :range => { :age => { :from => 10, :to => 20 } } }.to_json,
+                      Filter.new('range', { :age => { :from => 10, :to => 20 } }).to_json )
+
+        assert_equal( { :geo_distance => { :distance => '12km', :location => [40, -70] } }.to_json,
+                      Filter.new('geo_distance', { :distance => '12km', :location => [40, -70] }).to_json )
+      end
+
+      should "encode 'or' filter with multiple other filters" do
+        # See http://www.elasticsearch.org/guide/reference/query-dsl/or-filter.html
+        assert_equal( { :or => [ {:terms => {:tags => ['foo']}}, {:terms => {:tags => ['bar']}} ] }.to_json,
+                      Filter.new('or', {:terms => {:tags => ['foo']}}, {:terms => {:tags => ['bar']}}).to_json )
+      end
+
+      should "encode 'bool' filter with multiple filters" do
+        # http://www.elasticsearch.org/guide/reference/query-dsl/bool-filter.html
+        assert_equal( { :bool => [ {:must => {:terms => {:tags => ['foo']}}}, {:should => {:terms => {:tags => ['bar']}}} ] }.to_json,
+                      Filter.new('bool', {:must => {:terms => {:tags => ['foo']}}}, { :should => {:terms => {:tags => ['bar']}}}).to_json )
+      end
+
+    end
+
+  end
+end