elasticsearch-dsl 0.0.0 → 0.1.0

data/test/unit/queries/span_first_test.rb

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

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

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

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

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

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

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

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

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

data/test/unit/queries/top_children_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class TopChildrenTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Queries
+
+        context "TopChildren query" do
+          subject { TopChildren.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ top_children: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = TopChildren.new
+
+            subject.type 'bar'
+            subject.query 'bar'
+            subject.score 'bar'
+            subject.factor 'bar'
+            subject.incremental_factor 'bar'
+            subject._scope 'bar'
+
+            assert_equal %w[ _scope factor incremental_factor query score type ],
+                         subject.to_hash[:top_children].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:top_children][:type]
+          end
+
+          should "take a block" do
+            subject = TopChildren.new do
+              type 'bar'
+              query 'foo'
+            end
+            assert_equal({ top_children: { type: 'bar', query: 'foo' } }, subject.to_hash)
+          end
+
+          should "evaluate a block passed to the query method" do
+            subject = TopChildren.new do
+              type 'bar'
+              query do
+                match foo: 'BLAM'
+              end
+            end
+
+            assert_equal({ top_children: { type: 'bar', query: { match: { foo: 'BLAM' } } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/queries/wildcard_test.rb

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

data/test/unit/search_aggregation_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class SearchAggregationTest < ::Test::Unit::TestCase
+      subject { Elasticsearch::DSL::Search::Aggregation.new }
+
+      context "Search Aggregation" do
+
+        should "be serializable to a Hash" do
+          assert_equal( {}, subject.to_hash )
+
+          subject = Elasticsearch::DSL::Search::Aggregation.new
+          subject.instance_variable_set(:@value, { foo: 'bar' })
+          assert_equal( { foo: 'bar' }, subject.to_hash )
+        end
+
+        should "evaluate the block and return itself" do
+          block   = Proc.new { 1+1 }
+          subject = Elasticsearch::DSL::Search::Aggregation.new &block
+
+          subject.expects(:instance_eval)
+          assert_instance_of Elasticsearch::DSL::Search::Aggregation, subject.call
+        end
+
+        should "call the block and return itself" do
+          block   = Proc.new { |s| 1+1 }
+          subject = Elasticsearch::DSL::Search::Aggregation.new &block
+
+          block.expects(:call)
+          assert_instance_of Elasticsearch::DSL::Search::Aggregation, subject.call
+        end
+
+        should "define the value with DSL methods" do
+          assert_nothing_raised do
+            subject.terms field: 'foo'
+            assert_instance_of Hash, subject.to_hash
+            assert_equal( { terms: { field: 'foo' } }, subject.to_hash )
+          end
+        end
+
+        should "raise an exception for unknown DSL method" do
+          assert_raise(NoMethodError) { subject.foofoo }
+        end
+
+        should "return the aggregations" do
+          subject.expects(:call)
+          subject.instance_variable_set(:@value, mock(aggregations: { foo: 'bar' }))
+
+          subject.aggregations
+        end
+
+        should "define a nested aggregation" do
+          subject.instance_variable_set(:@value, mock(aggregation: true))
+
+          subject.aggregation(:foo) { 1+1 }
+        end
+
+        should "return a non-hashy value directly" do
+          subject.instance_variable_set(:@value, 'FOO')
+          assert_equal 'FOO', subject.to_hash
+        end
+
+        should "return an empty Hash when it has no value set" do
+          subject.instance_variable_set(:@value, nil)
+          assert_equal({}, subject.to_hash)
+        end
+      end
+
+    end
+  end
+end