elasticsearch-dsl 0.0.0 → 0.1.0

data/test/unit/queries/match_all_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class MatchAllTest < ::Test::Unit::TestCase
+        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_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class MatchTest < ::Test::Unit::TestCase
+        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
+            end
+
+            assert_equal({match: {message: {query: "test", operator: "and", type: 'phrase_prefix', boost: 2}}},
+                         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

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class MoreLikeThisTest < ::Test::Unit::TestCase
+        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

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

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class NestedTest < ::Test::Unit::TestCase
+        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'
+
+            assert_equal %w[ path query score_mode ],
+                         subject.to_hash[:nested].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:nested][:path]
+          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

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

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class QueryStringTest < ::Test::Unit::TestCase
+        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'
+
+            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 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

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class RangeTest < ::Test::Unit::TestCase
+        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
+            end
+
+            assert_equal({:range=>{:age=>{:gte=>10, :lte=>20, :boost=>2}}}, @subject.to_hash)
+          end
+
+          should "take a method call" do
+            @subject = Range.new :age
+            @subject.gte 10
+            @subject.lte 20
+
+            assert_equal({:range=>{:age=>{:gte=>10, :lte=>20}}}, @subject.to_hash)
+          end
+
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/regexp_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class RegexpTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class SimpleQueryStringTest < ::Test::Unit::TestCase
+        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.lowercase_expanded_terms 'bar'
+            subject.locale 'bar'
+            subject.lenient 'bar'
+          
+            assert_equal %w[ analyzer default_operator fields flags lenient locale lowercase_expanded_terms 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