elasticsearch-dsl 0.1.6 → 0.1.10

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

data/test/unit/queries/simple_query_string_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class SimpleQueryStringTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "SimpleQueryString query" do
-          subject { SimpleQueryString.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ simple_query_string: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = SimpleQueryString.new :foo
-
-            subject.query 'bar'
-            subject.fields 'bar'
-            subject.default_operator 'bar'
-            subject.analyzer 'bar'
-            subject.flags 'bar'
-            subject.lenient 'bar'
-
-            assert_equal %w[ analyzer default_operator fields flags lenient query ],
-                         subject.to_hash[:simple_query_string][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:simple_query_string][:foo][:query]
-          end
-
-          should "take a block" do
-            subject = SimpleQueryString.new :foo do
-              query 'bar'
-            end
-            assert_equal({simple_query_string: { foo: { query: 'bar' } }}, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/span_first_test.rb

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

data/test/unit/queries/span_multi_test.rb

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

data/test/unit/queries/span_near_test.rb

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

data/test/unit/queries/span_not_test.rb

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

data/test/unit/queries/span_or_test.rb

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

data/test/unit/queries/span_term_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class SpanTermTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "SpanTerm query" do
-          subject { SpanTerm.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ span_term: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = SpanTerm.new foo: 'bar'
-            assert_equal({ span_term: { foo: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/template_test.rb

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

data/test/unit/queries/term_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class TermTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        subject { Term.new message: 'test' }
-
-        context "Term Query" do
-          should "take a concrete value" do
-            @subject = Term.new message: 'test'
-
-            assert_equal({:term=>{:message=>"test"}}, @subject.to_hash)
-          end
-
-          should "take a Hash" do
-            @subject = Term.new message: { query: 'test', boost: 2 }
-
-            assert_equal({:term=>{:message=>{:query=>"test", :boost=>2}}}, @subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/terms_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class TermsTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Terms query" do
-          subject { Terms.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ terms: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = Terms.new foo: ['abc', 'xyz']
-            assert_equal({ terms: { foo: ['abc', 'xyz'] } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end