elasticsearch-dsl 0.0.0 → 0.1.0

data/test/unit/filters/has_parent_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class HasParentTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "HasParent filter" 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.filter 'bar'
+            subject.query 'bar'
+            subject.score_mode 'bar'
+
+            assert_equal %w[ filter 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]
+          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
+
+          should "take a block for option method" do
+            subject = HasParent.new do
+              parent_type 'bar'
+              query do
+                match :foo do
+                  query 'bar'
+                end
+              end
+            end
+            assert_equal({ has_parent: { parent_type: 'bar', query: { match: { foo: { query: 'bar'} } } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/ids_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class IdsTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Ids filter" 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/filters/indices_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class IndicesTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Indices filter" 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.filter 'bar'
+            subject.no_match_filter 'bar'
+
+            assert_equal %w[ filter indices no_match_filter ],
+                         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'
+            end
+            assert_equal({indices: { indices: 'bar' } }, subject.to_hash)
+          end
+
+          should "take a block for methods" do
+            subject = Indices.new do
+              indices 'bar'
+
+              filter do
+                term foo: 'bar'
+              end
+              no_match_filter do
+                term foo: 'bam'
+              end
+            end
+            assert_equal({ indices: { indices: 'bar', filter: { term: { foo: 'bar' } }, no_match_filter: { term: { foo: 'bar' } } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/limit_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class LimitTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Limit filter" do
+          subject { Limit.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ limit: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = Limit.new
+
+            subject.value 'bar'
+
+            assert_equal %w[ value ],
+                         subject.to_hash[:limit].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:limit][:value]
+          end
+
+          should "take a block" do
+            subject = Limit.new do
+              value 'bar'
+            end
+            assert_equal({limit: { value: 'bar' } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/match_all_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class MatchAllTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "MatchAll filter" do
+          subject { MatchAll.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ match_all: {} }, subject.to_hash)
+          end
+          
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/missing_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class MissingTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Missing filter" do
+          subject { Missing.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ missing: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = Missing.new
+
+            subject.field 'bar'
+            subject.existence 'bar'
+            subject.null_value 'bar'
+
+            assert_equal %w[ existence field null_value ],
+                         subject.to_hash[:missing].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:missing][:field]
+          end
+
+          should "take a block" do
+            subject = Missing.new do
+              field 'bar'
+            end
+            assert_equal({missing: { field: 'bar' } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/nested_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class NestedTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Nested filter" 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.filter 'bar'
+
+            assert_equal %w[ filter path ],
+                         subject.to_hash[:nested].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:nested][:path]
+          end
+
+          should "take a block" do
+            subject = Nested.new do
+              path 'bar'
+              filter do
+                term foo: 'bar'
+              end
+            end
+            assert_equal({nested: { path: 'bar', filter: { term: { foo: 'bar' } } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/not_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class NotTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Not filter" do
+          subject { Not.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ not: {} }, subject.to_hash)
+          end
+
+          should "take a Hash" do
+            subject = Not.new filters: [ { term: { foo: 'bar' } } ]
+            assert_equal({ not: { filters: [ { term: { foo: 'bar' } } ] } }, subject.to_hash)
+          end
+
+          should "take a block" do
+            subject = Not.new do
+              term foo: 'bar'
+            end
+            assert_equal({not: {term: { foo: 'bar'}} }, subject.to_hash)
+          end
+
+          should "raise an exception for unknown DSL method" do
+            assert_raise(NoMethodError) { subject.foofoo }
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/or_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class OrTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Or filter" do
+          subject { Or.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ or: {} }, subject.to_hash)
+          end
+
+          should "take a Hash" do
+            subject = Or.new filters: [ { term: { foo: 'bar' } } ]
+            assert_equal({ or: { filters: [ { term: { foo: 'bar' } } ] } }, subject.to_hash)
+          end
+
+          should "take a block" do
+            subject = Or.new do
+              term foo: 'bar'
+              term moo: 'mam'
+            end
+            assert_equal({or: [ {term: { foo: 'bar'}}, {term: { moo: 'mam'}} ]}, subject.to_hash)
+          end
+
+          should "behave like an Enumerable" do
+            subject = Or.new
+            subject << { term: { foo: 'bar' } }
+
+            assert_equal 1, subject.size
+            assert subject.any? { |d| d[:term] == { foo: 'bar' } }
+          end
+
+          should "behave like an Array" do
+            subject = Or.new
+
+            assert subject.empty?
+
+            subject << { term: { foo: 'bar' } }
+            subject << { term: { moo: 'xam' } }
+
+            assert ! subject.empty?
+
+            assert_equal({ or: [ { term: { foo: 'bar' } }, { term: { moo: 'xam' } } ] }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/prefix_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class PrefixTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Prefix filter" do
+          subject { Prefix.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ prefix: {} }, subject.to_hash)
+          end
+
+          should "take a Hash" do
+            subject = Prefix.new foo: 'bar'
+
+            assert_equal({ prefix: { foo: 'bar' } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/query_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class QueryTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Query filter" do
+          subject { Query.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ query: {} }, subject.to_hash)
+          end
+
+          should "take a Hash" do
+            subject = Query.new query_string: { query: 'foo' }
+
+            assert_equal({ query: { query_string: { query: 'foo' } } }, subject.to_hash)
+          end
+
+          should "take a block" do
+            subject = Query.new do
+              match foo: 'bar'
+            end
+
+            assert_equal({ query: { match: { foo: 'bar' } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/range_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class RangeTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Range filter" do
+          subject { Range.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ range: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = Range.new :foo
+
+            subject.gte 'bar'
+            subject.lte 'bar'
+            subject.time_zone 'bar'
+
+            assert_equal %w[ gte lte time_zone ],
+                         subject.to_hash[:range][:foo].keys.map(&:to_s).sort
+
+            assert_equal 'bar', subject.to_hash[:range][:foo][:gte]
+          end
+
+          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
+            end
+
+            assert_equal({ range: { age: { gte: 10, lte: 20 } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end