elasticsearch-dsl 0.0.0 → 0.1.0

data/test/unit/queries/filtered_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class FilteredTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "Filtered query" do
+          subject { Filtered.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ filtered: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = Filtered.new
+
+            subject.query 'bar'
+            subject.filter 'bar'
+            subject.strategy 'bar'
+
+            assert_equal %w[ filter query strategy ],
+                         subject.to_hash[:filtered].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:filtered][:query]
+          end
+
+          should "take a block" do
+            subject = Filtered.new do
+              query 'bar'
+            end
+            assert_equal 'bar', subject.to_hash[:filtered][:query]
+          end
+
+          should "evaluate a block passed to the option method" do
+            subject = Filtered.new do
+              query do
+                match foo: 'BLAM'
+              end
+              filter do
+                term bar: 'slam'
+              end
+            end
+
+            assert_equal({filtered: { query: { match: { foo: 'BLAM' } }, filter: { term: { bar: 'slam' } } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/function_score_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class FunctionScoreTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "FunctionScore query" do
+          subject { FunctionScore.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ function_score: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = FunctionScore.new
+
+            subject.query 'bar'
+            subject.filter 'bar'
+            subject.functions ['bar']
+            subject.script_score 'bar'
+            subject.boost 'bar'
+            subject.max_boost 'bar'
+            subject.score_mode 'bar'
+            subject.boost_mode 'bar'
+
+            assert_equal %w[ boost boost_mode filter functions max_boost query score_mode script_score ],
+                         subject.to_hash[:function_score].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:function_score][:query]
+          end
+
+          should "take a block" do
+            subject = FunctionScore.new do
+              query 'bar'
+            end
+            assert_equal 'bar', subject.to_hash[:function_score][:query]
+          end
+
+          should "evaluate a block passed to the option method" do
+            subject = FunctionScore.new do
+              query do
+                match foo: 'BLAM'
+              end
+              filter do
+                term bar: 'slam'
+              end
+              functions << { foo: { abc: '123' } }
+              functions << { foo: { xyz: '456' } }
+            end
+
+            assert_equal({
+              function_score: {
+                query: { match: { foo: 'BLAM' } },
+                filter: { term: { bar: 'slam' } },
+                functions: [ { foo: { abc: '123' } }, { foo: { xyz: '456' } } ] } },
+              subject.to_hash)
+          end
+
+          should "set the functions directly" do
+            subject = FunctionScore.new
+            subject.functions = [ {foo: { abc: '123' }} ]
+
+            assert_equal({function_score: { functions: [ {foo: { abc: '123' }} ] }}, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/fuzzy_like_this_field_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class FuzzyLikeThisFieldTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "FuzzyLikeThisField query" do
+          subject { FuzzyLikeThisField.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ fuzzy_like_this_field: {} }, subject.to_hash)
+          end
+                          
+          should "have option methods" do
+            subject = FuzzyLikeThisField.new :foo
+            
+            subject.like_text 'bar'
+            subject.fuzziness 'bar'
+            subject.analyzer 'bar'
+            subject.max_query_terms 'bar'
+            subject.prefix_length 'bar'
+            subject.boost 'bar'
+            subject.ignore_tf 'bar'
+          
+            assert_equal %w[ analyzer boost fuzziness ignore_tf like_text max_query_terms prefix_length ],
+                         subject.to_hash[:fuzzy_like_this_field][:foo].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:fuzzy_like_this_field][:foo][:like_text]
+          end
+          
+          should "take a block" do
+            subject = FuzzyLikeThisField.new :foo do
+              like_text 'bar'
+            end
+            assert_equal 'bar', subject.to_hash[:fuzzy_like_this_field][:foo][:like_text]
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/fuzzy_like_this_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class FuzzyLikeThisTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "FuzzyLikeThis query" do
+          subject { FuzzyLikeThis.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ fuzzy_like_this: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = FuzzyLikeThis.new
+
+            subject.fields 'bar'
+            subject.like_text 'bar'
+            subject.fuzziness 'bar'
+            subject.analyzer 'bar'
+            subject.max_query_terms 'bar'
+            subject.prefix_length 'bar'
+            subject.boost 'bar'
+
+            assert_equal %w[ analyzer boost fields fuzziness like_text max_query_terms prefix_length ],
+                         subject.to_hash[:fuzzy_like_this].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:fuzzy_like_this][:fields]
+          end
+
+          should "take a block" do
+            subject = FuzzyLikeThis.new do
+              fields ['foo']
+              like_text 'bar'
+            end
+
+            assert_equal({ fuzzy_like_this: { fields: ['foo'], like_text: 'bar' } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/fuzzy_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class FuzzyTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "Fuzzy query" do
+          subject { Fuzzy.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ fuzzy: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = Fuzzy.new :foo
+
+            subject.value 'bar'
+            subject.boost 'bar'
+            subject.fuzziness 'bar'
+            subject.prefix_length 'bar'
+            subject.max_expansions 'bar'
+
+            assert_equal %w[ boost fuzziness max_expansions prefix_length value ],
+                         subject.to_hash[:fuzzy][:foo].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:fuzzy][:foo][:value]
+          end
+
+          should "take a block" do
+            subject = Fuzzy.new :foo do
+              value 'bar'
+            end
+            assert_equal({fuzzy: { foo: { value: 'bar' } }}, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/geo_shape_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class GeoShapeTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "GeoShape query" do
+          subject { GeoShape.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ geo_shape: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = GeoShape.new :foo
+
+            subject.shape 'bar'
+            subject.indexed_shape 'bar'
+
+            assert_equal %w[ indexed_shape shape ],
+                         subject.to_hash[:geo_shape][:foo].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:geo_shape][:foo][:shape]
+          end
+
+          should "take a block" do
+            subject = GeoShape.new :foo do
+              shape 'bar'
+            end
+            assert_equal({geo_shape: { foo: { shape: 'bar' } }}, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/has_child_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class HasChildTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "HasChild query" do
+          subject { HasChild.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ has_child: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = HasChild.new
+
+            subject.type 'bar'
+            subject.query 'bar'
+            subject.score_mode 'bar'
+            subject.min_children 'bar'
+            subject.max_children 'bar'
+
+            assert_equal %w[ max_children min_children query score_mode type ],
+                         subject.to_hash[:has_child].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:has_child][:type]
+          end
+
+          should "take a block" do
+            subject = HasChild.new do
+              type 'bar'
+              query match: { foo: 'bar' }
+            end
+            assert_equal({ has_child: { type: 'bar', query: { match: { foo: 'bar' } } } }, subject.to_hash)
+          end
+
+          should "take a block for option method" do
+            subject = HasChild.new do
+              type 'bar'
+              query do
+                match :foo do
+                  query 'bar'
+                end
+              end
+            end
+            assert_equal({ has_child: { type: 'bar', query: { match: { foo: { query: 'bar'} } } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/has_parent_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class HasParentTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "HasParent query" do
+          subject { HasParent.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ has_parent: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = HasParent.new
+
+            subject.parent_type 'bar'
+            subject.query 'bar'
+            subject.score_mode 'bar'
+
+            assert_equal %w[ parent_type query score_mode ],
+                         subject.to_hash[:has_parent].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:has_parent][:parent_type]
+          end
+
+          should "take a block" do
+            subject = HasParent.new do
+              parent_type 'bar'
+              query match: { foo: 'bar' }
+            end
+            assert_equal({ has_parent: { parent_type: 'bar', query: { match: { foo: 'bar' } } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/ids_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class IdsTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "Ids query" do
+          subject { Ids.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ ids: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = Ids.new
+
+            subject.type 'bar'
+            subject.values 'bar'
+
+            assert_equal %w[ type values ],
+                         subject.to_hash[:ids].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:ids][:type]
+          end
+
+          should "take a block" do
+            subject = Ids.new do
+              type 'bar'
+              values [1, 2, 3]
+            end
+            assert_equal({ids: { type: 'bar', values: [1, 2, 3] } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/indices_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class IndicesTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "Indices query" do
+          subject { Indices.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ indices: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = Indices.new
+
+            subject.indices 'bar'
+            subject.query 'bar'
+            subject.no_match_query 'bar'
+
+            assert_equal %w[ indices no_match_query query ],
+                         subject.to_hash[:indices].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:indices][:indices]
+          end
+
+          should "take a block" do
+            subject = Indices.new do
+              indices 'bar'
+              query term: { foo: 'bar' }
+            end
+            assert_equal({indices: { indices: 'bar', query: { term: { foo: 'bar' } } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end