elasticsearch-dsl 0.1.6 → 0.1.7

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

data/test/unit/queries/more_like_this_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class MoreLikeThisTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "MoreLikeThis query" do
-          subject { MoreLikeThis.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ more_like_this: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = MoreLikeThis.new
-
-            subject.fields 'bar'
-            subject.like_text 'bar'
-            subject.min_term_freq 'bar'
-            subject.max_query_terms 'bar'
-            subject.docs 'bar'
-            subject.ids 'bar'
-            subject.include 'bar'
-            subject.exclude 'bar'
-            subject.percent_terms_to_match 'bar'
-            subject.stop_words 'bar'
-            subject.min_doc_freq 'bar'
-            subject.max_doc_freq 'bar'
-            subject.min_word_length 'bar'
-            subject.max_word_length 'bar'
-            subject.boost_terms 'bar'
-            subject.boost 'bar'
-            subject.analyzer 'bar'
-
-            assert_equal %w[ analyzer boost boost_terms docs exclude fields ids include like_text max_doc_freq max_query_terms max_word_length min_doc_freq min_term_freq min_word_length percent_terms_to_match stop_words ],
-                         subject.to_hash[:more_like_this].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:more_like_this][:fields]
-          end
-
-          should "take a block" do
-            subject = MoreLikeThis.new do
-              fields ['foo', 'bar']
-              like_text 'abc'
-            end
-            assert_equal({more_like_this: { fields: ['foo','bar'], like_text: 'abc' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/multi_match_test.rb

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

data/test/unit/queries/nested_test.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class NestedTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Nested query" do
-          subject { Nested.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ nested: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Nested.new
-
-            subject.path 'bar'
-            subject.score_mode 'bar'
-            subject.query 'bar'
-            subject.inner_hits({ size: 1 })
-
-            assert_equal %w[ inner_hits path query score_mode ],
-                         subject.to_hash[:nested].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:nested][:path]
-            assert_equal({ size: 1 }, subject.to_hash[:nested][:inner_hits])
-          end
-
-          should "take the query as a Hash" do
-            subject = Nested.new
-            subject.path 'bar'
-            subject.query match: { foo: 'bar' }
-
-            assert_equal({nested: { path: 'bar', query: { match: { foo: 'bar' } } } }, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = Nested.new do
-              path 'bar'
-              query do
-                match foo: 'bar'
-              end
-            end
-
-            assert_equal({nested: { path: 'bar', query: { match: { foo: 'bar' } } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/prefix_test.rb

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

data/test/unit/queries/query_string_test.rb

@@ -1,56 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class QueryStringTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "QueryString query" do
-          subject { QueryString.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ query_string: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = QueryString.new :foo
-
-            subject.query 'bar'
-            subject.fields 'bar'
-            subject.default_field 'bar'
-            subject.default_operator 'bar'
-            subject.analyzer 'bar'
-            subject.allow_leading_wildcard 'bar'
-            subject.lowercase_expanded_terms 'bar'
-            subject.enable_position_increments 'bar'
-            subject.fuzzy_max_expansions 'bar'
-            subject.fuzziness 'bar'
-            subject.fuzzy_prefix_length 'bar'
-            subject.phrase_slop 'bar'
-            subject.boost 'bar'
-            subject.analyze_wildcard 'bar'
-            subject.auto_generate_phrase_queries 'bar'
-            subject.minimum_should_match 'bar'
-            subject.lenient 'bar'
-            subject.locale 'bar'
-            subject.use_dis_max 'bar'
-            subject.tie_breaker 'bar'
-            subject.time_zone 'bar'
-
-            assert_equal %w[ allow_leading_wildcard analyze_wildcard analyzer auto_generate_phrase_queries boost default_field default_operator enable_position_increments fields fuzziness fuzzy_max_expansions fuzzy_prefix_length lenient locale lowercase_expanded_terms minimum_should_match phrase_slop query tie_breaker time_zone use_dis_max ],
-                         subject.to_hash[:query_string][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:query_string][:foo][:query]
-          end
-
-          should "take a block" do
-            subject = QueryString.new :foo do
-              query 'foo AND bar'
-            end
-            assert_equal({ query_string: { foo: { query: 'foo AND bar' } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/range_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class RangeTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Range Query" do
-
-          should "take a Hash" do
-            @subject = Range.new age: { gte: 10, lte: 20 }
-
-            assert_equal({:range=>{:age=>{:gte=>10, :lte=>20}}}, @subject.to_hash)
-          end
-
-          should "take a block" do
-            @subject = Range.new :age do
-              gte   10
-              lte   20
-              boost 2
-              format 'mm/dd/yyyy'
-            end
-
-            assert_equal({:range=>{:age=>{:gte=>10, :lte=>20, :boost=>2, :format=>'mm/dd/yyyy'}}}, @subject.to_hash)
-          end
-
-          should "take a method call" do
-            @subject = Range.new :age
-            @subject.gte 10
-            @subject.lte 20
-            @subject.format 'mm/dd/yyyy'
-
-            assert_equal({:range=>{:age=>{:gte=>10, :lte=>20, :format=>'mm/dd/yyyy'}}}, @subject.to_hash)
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/regexp_test.rb

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