elasticsearch-dsl 0.1.6 → 0.1.10

data/test/unit/queries/function_score_test.rb

@@ -1,70 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class FunctionScoreTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class FuzzyLikeThisFieldTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,44 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class FuzzyLikeThisTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class FuzzyTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class GeoShapeTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,55 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class HasChildTest < ::Elasticsearch::Test::UnitTestCase
-        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'
-            subject.inner_hits({ size: 1 })
-
-            assert_equal %w[ inner_hits 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]
-            assert_equal({ size: 1 }, subject.to_hash[:has_child][:inner_hits])
-          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

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class HasParentTest < ::Elasticsearch::Test::UnitTestCase
-        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'
-            subject.inner_hits({ size: 1 })
-
-            assert_equal %w[ inner_hits 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]
-            assert_equal({ size: 1 }, subject.to_hash[:has_parent][:inner_hits])
-          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

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class IdsTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,39 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class IndicesTest < ::Elasticsearch::Test::UnitTestCase
-        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

data/test/unit/queries/match_all_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class MatchAllTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "MatchAll query" do
-          subject { MatchAll.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ match_all: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = MatchAll.new
-
-            subject.boost 'bar'
-
-            assert_equal %w[ boost ],
-                         subject.to_hash[:match_all].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:match_all][:boost]
-          end
-
-          should "take a block" do
-            subject = MatchAll.new do
-              boost 'bar'
-            end
-            assert_equal({match_all: { boost: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/match_phrase_prefix_test.rb

@@ -1,62 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class MatchPhrasePrefixTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Match Phrase Prefix Query" do
-          subject { MatchPhrasePrefix.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ match_phrase_prefix: {} }, subject.to_hash)
-          end
-
-          should "take a concrete value" do
-            subject = MatchPhrasePrefix.new message: 'test'
-
-            assert_equal({match_phrase_prefix: {message: "test"}}, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = MatchPhrasePrefix.new
-
-            subject.query    'bar'
-            subject.boost    10
-            subject.max_expansions     1
-
-            assert_equal %w[ boost max_expansions query ],
-                         subject.to_hash[:match_phrase_prefix].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:match_phrase_prefix][:query]
-          end
-
-          should "take a Hash" do
-            subject = MatchPhrasePrefix.new message: { query: 'test' }
-
-            assert_equal({match_phrase_prefix: {message: {query: "test" }}}, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = MatchPhrasePrefix.new :message do
-              query          'test'
-              boost          2
-              max_expansions 1
-            end
-
-            assert_equal({match_phrase_prefix: {message: {query: "test", max_expansions: 1, boost: 2 }}},
-                         subject.to_hash)
-          end
-
-          should "take a method call" do
-            subject = MatchPhrasePrefix.new :message
-            subject.query    'test'
-
-            assert_equal({match_phrase_prefix: {message: {query: "test" }}}, subject.to_hash)
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/match_phrase_test.rb

@@ -1,63 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class MatchPhraseTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Match Phrase Query" do
-          subject { MatchPhrase.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ match_phrase: {} }, subject.to_hash)
-          end
-
-          should "take a concrete value" do
-            subject = MatchPhrase.new message: 'test'
-
-            assert_equal({match_phrase: {message: "test"}}, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = MatchPhrase.new
-
-            subject.query    'bar'
-            subject.analyzer 'standard'
-            subject.boost    10
-            subject.slop     1
-
-            assert_equal %w[ analyzer boost query slop ],
-                         subject.to_hash[:match_phrase].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:match_phrase][:query]
-          end
-
-          should "take a Hash" do
-            subject = MatchPhrase.new message: { query: 'test' }
-
-            assert_equal({match_phrase: {message: {query: "test" }}}, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = MatchPhrase.new :message do
-              query     'test'
-              slop      1
-              boost     2
-            end
-
-            assert_equal({match_phrase: {message: {query: "test", slop: 1, boost: 2 }}},
-                         subject.to_hash)
-          end
-
-          should "take a method call" do
-            subject = MatchPhrase.new :message
-            subject.query    'test'
-
-            assert_equal({match_phrase: {message: {query: "test" }}}, subject.to_hash)
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/match_test.rb

@@ -1,65 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class MatchTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Match Query" do
-          subject { Match.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ match: {} }, subject.to_hash)
-          end
-
-          should "take a concrete value" do
-            subject = Match.new message: 'test'
-
-            assert_equal({match: {message: "test"}}, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Match.new
-
-            subject.query    'bar'
-            subject.operator 'bar'
-            subject.type     'bar'
-
-            assert_equal %w[ operator query type ],
-                         subject.to_hash[:match].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:match][:query]
-          end
-
-          should "take a Hash" do
-            subject = Match.new message: { query: 'test', operator: 'and' }
-
-            assert_equal({match: {message: {query: "test", operator: "and"}}}, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = Match.new :message do
-              query     'test'
-              operator  'and'
-              type      'phrase_prefix'
-              boost     2
-              fuzziness 'AUTO'
-            end
-
-            assert_equal({match: {message: {query: "test", operator: "and", type: 'phrase_prefix', boost: 2, fuzziness: 'AUTO'}}},
-                         subject.to_hash)
-          end
-
-          should "take a method call" do
-            subject = Match.new :message
-            subject.query    'test'
-            subject.operator 'and'
-
-            assert_equal({match: {message: {query: "test", operator: "and"}}}, subject.to_hash)
-          end
-
-        end
-      end
-    end
-  end
-end