elasticsearch-dsl 0.1.6 → 0.1.7

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