tire-erez 0.5.4

data/test/integration/nested_query_test.rb

@@ -0,0 +1,135 @@
+require 'test_helper'
+
+module Tire
+
+  class NestedQueryTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context 'Nested queries' do
+
+      setup do
+        @index = Tire.index('products-test') do
+          delete
+
+          create mappings: {
+                   product: {
+                      properties: {
+                        name:     { type: 'string' },
+                        variants: { type: 'nested', size: 'string', color: 'string' }
+                      }
+                    }
+                  }
+
+          store type: 'product',
+                name: 'Duck Shirt',
+                variants: [{ size: 'M', color: 'yellow'}, { size: 'L', color: 'silver'}]
+          store type: 'product',
+                name: 'Western Shirt',
+                variants: [{ size: 'S', color: 'yellow'}, { size: 'M', color: 'silver'}]
+
+          refresh
+        end
+      end
+
+      # teardown { @index.delete }
+
+      should "not return a results when properties match for different objects" do
+        s = Tire.search @index.name do
+          query do
+            nested path: 'variants' do
+              query do
+                boolean do
+                  # No product matches size "S" and color "silver"
+                  must { match 'variants.size',  'S' }
+                  must { match 'variants.color', 'silver'}
+                end
+              end
+            end
+          end
+        end
+
+        assert_equal 0, s.results.size
+      end
+
+      should "return all matching documents when nested documents meet criteria" do
+        s = Tire.search @index.name do
+          query do
+            nested path: 'variants' do
+              query do
+                match 'variants.size', 'M'
+              end
+            end
+          end
+        end
+
+        assert_equal 2, s.results.size
+      end
+
+      should "return matching document when a nested document meets all criteria" do
+        s = Tire.search @index.name do
+          query do
+            nested path: 'variants' do
+              query do
+                boolean do
+                  must { match 'variants.size',  'M' }
+                  must { match 'variants.color', 'silver'}
+                end
+              end
+            end
+          end
+        end
+
+        assert_equal 1, s.results.size
+        assert_equal 'Western Shirt', s.results.first.name
+      end
+
+      should "return matching document when both the query and nested document meet all criteria" do
+        s = Tire.search @index.name do
+          query do
+            boolean do
+              must do
+                match 'name', 'Western'
+              end
+              must do
+                nested path: 'variants' do
+                  query do
+                    match 'variants.size',  'M'
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        assert_equal 1, s.results.size
+        assert_equal 'Western Shirt', s.results.first.name
+      end
+
+      should "not return results when the query and the nested document contradict" do
+        s = Tire.search @index.name do
+          query do
+            boolean do
+              must do
+                match 'name', 'Duck'
+              end
+              must do
+                nested path: 'variants' do
+                  query do
+                    boolean do
+                      must { match 'variants.size',  'M' }
+                      must { match 'variants.color', 'silver'}
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        assert_equal 0, s.results.size
+      end
+
+    end
+  end
+
+end

data/test/integration/percolator_test.rb

@@ -0,0 +1,111 @@
+require 'test_helper'
+
+module Tire
+
+  class PercolatorIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Percolator" do
+      setup do
+        delete_registered_queries
+        @index = Tire.index('percolator-test')
+        @index.create
+      end
+      teardown do
+        delete_registered_queries
+        @index.delete
+      end
+
+      context "when registering a query" do
+        should "register query as a Hash" do
+          query = { :query => { :query_string => { :query => 'warning' } } }
+          assert @index.register_percolator_query('alert', query)
+          Tire.index('_percolator').refresh
+
+          percolator = Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
+          assert percolator
+        end
+
+        should "register query as block" do
+          assert @index.register_percolator_query('alert') { string 'warning' }
+          Tire.index('_percolator').refresh
+
+          percolator = Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
+          assert percolator
+        end
+
+        should "unregister a query" do
+          query = { :query => { :query_string => { :query => 'warning' } } }
+          assert @index.register_percolator_query('alert', query)
+          Tire.index('_percolator').refresh
+          assert Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
+
+          assert @index.unregister_percolator_query('alert')
+          Tire.index('_percolator').refresh
+
+          assert Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert").failure?
+        end
+
+      end
+
+      context "when percolating a document" do
+        setup do
+          @index.register_percolator_query('alert') { string 'warning' }
+          @index.register_percolator_query('gantz') { string '"y u no match"' }
+          @index.register_percolator_query('weather', :tags => ['weather']) { string 'severe' }
+          Tire.index('_percolator').refresh
+        end
+
+        should "return an empty array when no query matches" do
+          matches = @index.percolate :message => 'Situation normal'
+          assert_equal [], matches
+        end
+
+        should "return an array of matching query names" do
+          matches = @index.percolate :message => 'Severe weather warning'
+          assert_equal ['alert','weather'], matches.sort
+        end
+
+        should "return an array of matching query names for specific percolated queries" do
+          matches = @index.percolate(:message => 'Severe weather warning') { term :tags, 'weather' }
+          assert_equal ['weather'], matches
+        end
+      end
+
+      context "when storing document and percolating it" do
+        setup do
+          @index.register_percolator_query('alert') { string 'warning' }
+          @index.register_percolator_query('gantz') { string '"y u no match"' }
+          @index.register_percolator_query('weather', :tags => ['weather']) { string 'severe' }
+          Tire.index('_percolator').refresh
+        end
+
+        should "return an empty array when no query tire_matches" do
+          response = @index.store( {:message => 'Situation normal'}, {:percolate => true} )
+          assert_equal [], response['tire_matches']
+        end
+
+        should "return an array of matching query names" do
+          response = @index.store( {:message => 'Severe weather warning'}, {:percolate => true} )
+          assert_equal ['alert','weather'], response['tire_matches'].sort
+        end
+
+        should "return an array of matching query names for specific percolated queries" do
+          response = @index.store( {:message => 'Severe weather warning'}, {:percolate => 'tags:weather'} )
+          assert_equal ['weather'], response['tire_matches']
+        end
+      end
+
+    end
+
+    private
+
+    def delete_registered_queries
+      Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert") rescue nil
+      Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/gantz") rescue nil
+      Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/weather") rescue nil
+    end
+
+  end
+
+end

data/test/integration/persistent_model_test.rb

@@ -0,0 +1,205 @@
+require 'test_helper'
+
+module Tire
+
+  class PersistentModelIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    def setup
+      super
+      PersistentArticle.index.delete
+    end
+
+    def teardown
+      super
+      PersistentArticle.index.delete
+      PersistentArticleWithDefaults.index.delete
+    end
+
+    context "PersistentModel" do
+      should "search with simple query" do
+        PersistentArticle.create :id => 1, :title => 'One'
+        PersistentArticle.index.refresh
+
+        results = PersistentArticle.search 'one'
+        assert_equal 'One', results.first.title
+      end
+
+      should "search with a block" do
+        PersistentArticle.create :id => 1, :title => 'One'
+        PersistentArticle.index.refresh
+
+        results = PersistentArticle.search(:sort => 'title') { query { string 'one' } }
+        assert_equal 'One', results.first.title
+      end
+
+      should "return instances of model" do
+        PersistentArticle.create :id => 1, :title => 'One'
+        PersistentArticle.index.refresh
+
+        results = PersistentArticle.search 'one'
+        assert_instance_of PersistentArticle, results.first
+      end
+
+      should "save documents into index and find them by IDs" do
+        one = PersistentArticle.create :id => 1, :title => 'One'
+        two = PersistentArticle.create :id => 2, :title => 'Two'
+
+        PersistentArticle.index.refresh
+
+        results = PersistentArticle.find [1, 2]
+
+        assert_equal 2, results.size
+      end
+
+      should "be persisted" do
+        one = PersistentArticle.create :id => 1, :title => 'One'
+        PersistentArticle.index.refresh
+
+        a = PersistentArticle.all.first
+        assert a.persisted?, a.inspect
+
+        b = PersistentArticle.first
+        assert b.persisted?, b.inspect
+
+        c = PersistentArticle.search { query { string 'one' } }.first
+        assert c.persisted?, c.inspect
+      end
+
+      should "return default values for properties without value" do
+        PersistentArticleWithDefaults.create :id => 1, :title => 'One'
+        PersistentArticleWithDefaults.index.refresh
+
+        results = PersistentArticleWithDefaults.all
+
+        assert_equal [], results.first.tags
+      end
+
+      context "with pagination" do
+
+        setup do
+          1.upto(9) { |number| PersistentArticle.create :title => "Test#{number}" }
+          PersistentArticle.index.refresh
+        end
+
+        should "find first page with five results" do
+          results = PersistentArticle.search( :per_page => 5, :page => 1 ) { query { all } }
+          assert_equal 5, results.size
+
+          # WillPaginate
+          #
+          assert_equal 2, results.total_pages
+          assert_equal 1, results.current_page
+          assert_equal nil, results.previous_page
+          assert_equal 2, results.next_page
+
+          # Kaminari
+          #
+          assert_equal 5, results.limit_value
+          assert_equal 9, results.total_count
+          assert_equal 2, results.num_pages
+          assert_equal 0, results.offset_value
+        end
+
+      end
+
+      context "with namespaced models" do
+        setup do
+          MyNamespace::PersistentArticleInNamespace.create :title => 'Test'
+          MyNamespace::PersistentArticleInNamespace.index.refresh
+        end
+
+        teardown do
+          MyNamespace::PersistentArticleInNamespace.index.delete
+        end
+
+        should "find the document in the index" do
+          results = MyNamespace::PersistentArticleInNamespace.search 'test'
+
+          assert       results.any?, "No results returned: #{results.inspect}"
+          assert_equal 1, results.count
+
+          assert_instance_of MyNamespace::PersistentArticleInNamespace, results.first
+        end
+
+      end
+
+      context "multi search" do
+        setup do
+          # Tire.configure { logger STDERR }
+          PersistentArticle.create :title => 'Test'
+          PersistentArticle.create :title => 'Pest'
+          PersistentArticle.index.refresh
+        end
+
+        should "return multiple result sets" do
+          results = PersistentArticle.multi_search do
+            search do
+              query { match :title, 'test' }
+            end
+            search search_type: 'count' do
+              query { match :title, 'pest' }
+            end
+          end
+
+          assert_equal 2, results.size
+
+          assert_equal 1, results[0].size
+          assert_equal 1, results[0].total
+
+          assert_equal 0, results[1].size
+          assert_equal 1, results[1].total
+        end
+      end
+
+      context "with multiple types within single index" do
+
+        setup do
+          # Create documents of two types within single index
+          PersistentArticleInIndex.create :title => "TestInIndex", :tags => ['in_index']
+          PersistentArticle.create :title => "Test", :tags => []
+          PersistentArticle.index.refresh
+        end
+
+        should "returns all documents with proper type" do
+          results = PersistentArticle.all
+
+          assert_equal 1, results.size
+          assert results.all? { |r| r.tags == [] }, "Incorrect results? " + results.to_a.inspect
+
+          results = PersistentArticleInIndex.all
+
+          assert_equal 1, results.size
+          assert results.all? { |r| r.tags == ['in_index'] }, "Incorrect results? " + results.to_a.inspect
+        end
+
+        should "returns first document with proper type" do
+          assert_instance_of PersistentArticle, PersistentArticle.first
+          assert_instance_of PersistentArticleInIndex, PersistentArticleInIndex.first
+
+          assert_equal [], PersistentArticle.first.tags
+          assert_equal ['in_index'], PersistentArticleInIndex.first.tags
+        end
+      end
+
+      context "percolated search" do
+        setup do
+          PersistentArticleWithPercolation.index.register_percolator_query('alert') { string 'warning' }
+          Tire.index('_percolator').refresh
+        end
+
+        should "return matching queries when percolating" do
+          a = PersistentArticleWithPercolation.new :title => 'Warning!'
+          assert_contains a.percolate, 'alert'
+        end
+
+        should "return matching queries when saving" do
+          a = PersistentArticleWithPercolation.create :title => 'Warning!'
+          assert_contains a.tire_matches, 'alert'
+        end
+      end
+
+    end
+
+  end
+end