elasticsearch-dsl 0.0.0 → 0.1.0

data/test/unit/filters/bool_test.rb

@@ -0,0 +1,98 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class BoolTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "Bool Filter" do
+          subject { Bool.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ bool: {} }, subject.to_hash)
+          end
+
+          should "take a Hash" do
+            subject = Bool.new must: [ {term: { foo: 'bar' } } ]
+
+            assert_equal( { bool: { must: [ {term: { foo: 'bar' } } ] } }, subject.to_hash )
+          end
+
+          should "take a block" do
+            subject = Bool.new do
+              must { term foo: 'bar' }
+            end
+
+            assert_equal( { bool: { must: [ {term: { foo: 'bar' }} ] } }, subject.to_hash )
+          end
+
+          should "take a block with multiple methods" do
+            subject = Bool.new do
+              must     { term foo: 'bar' }
+              must_not { term moo: 'bam' }
+              should   { term xoo: 'bax' }
+            end
+
+            assert_equal( { bool:
+                            { must:     [ {term: { foo: 'bar' }} ],
+                              must_not: [ {term: { moo: 'bam' }} ],
+                              should:   [ {term: { xoo: 'bax' }} ]
+                            }
+                          },
+                          subject.to_hash )
+          end
+
+          should "take a block with multiple conditions" do
+            subject = Bool.new do
+              must { term foo: 'bar' }
+              must { term moo: 'bam' }
+
+              should { term xoo: 'bax' }
+              should { term zoo: 'baz' }
+            end
+
+            # Make sure we're not additive
+            subject.to_hash
+            subject.to_hash
+
+            assert_equal( { bool:
+                            { must:     [ {term: { foo: 'bar' }}, {term: { moo: 'bam' }} ],
+                              should:   [ {term: { xoo: 'bax' }}, {term: { zoo: 'baz' }} ]
+                            }
+                          },
+                          subject.to_hash )
+          end
+
+          should "take method calls" do
+            subject = Bool.new
+
+            subject.must { term foo: 'bar' }
+            assert_equal( { bool: { must: [ {term: { foo: 'bar' }} ] } }, subject.to_hash )
+
+            subject.must { term moo: 'bam' }
+            assert_equal( { bool: { must: [ {term: { foo: 'bar' }}, {term: { moo: 'bam' }} ]} },
+                          subject.to_hash )
+
+            subject.should { term xoo: 'bax' }
+            assert_equal( { bool:
+                            { must:   [ {term: { foo: 'bar' }}, {term: { moo: 'bam' }} ],
+                              should: [ {term: { xoo: 'bax' }} ] }
+                          },
+                          subject.to_hash )
+          end
+
+          should "be chainable" do
+            subject = Bool.new
+
+            assert_instance_of Bool, subject.must     { term foo: 'bar' }
+            assert_instance_of Bool, subject.must     { term foo: 'bar' }.must { term moo: 'bam' }
+            assert_instance_of Bool, subject.must_not { term foo: 'bar' }
+            assert_instance_of Bool, subject.should   { term foo: 'bar' }
+          end
+
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/exists_test.rb

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

data/test/unit/filters/geo_bounding_box_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class GeoBoundingBoxTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "GeoBoundingBox filter" do
+          subject { GeoBoundingBox.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ geo_bounding_box: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = GeoBoundingBox.new :foo
+
+            subject.top_left     'bar'
+            subject.bottom_right 'bar'
+            subject.top_right    'bar'
+            subject.bottom_left  'bar'
+            subject.top          'bar'
+            subject.left         'bar'
+            subject.bottom       'bar'
+            subject.right        'bar'
+
+            assert_equal %w[ bottom bottom_left bottom_right left right top top_left top_right ],
+                         subject.to_hash[:geo_bounding_box][:foo].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:geo_bounding_box][:foo][:top_left]
+          end
+
+          should "take a block" do
+            subject = GeoBoundingBox.new :foo do
+              top_left     [0,1]
+              bottom_right [3,2]
+            end
+
+            assert_equal({geo_bounding_box: { foo: { top_left: [0,1], bottom_right: [3,2] } }}, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/geo_distance_range_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class GeoDistanceRangeTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "GeoDistanceRange filter" do
+          subject { GeoDistanceRange.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ geo_distance_range: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = GeoDistanceRange.new :foo
+
+            subject.lat 'bar'
+            subject.lon 'bar'
+
+            assert_equal %w[ lat lon ],
+                         subject.to_hash[:geo_distance_range][:foo].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:geo_distance_range][:foo][:lat]
+          end
+
+          should "take a block" do
+            subject = GeoDistanceRange.new :foo do
+              lat 40
+              lon -70
+            end
+            assert_equal({geo_distance_range: { foo: { lat: 40, lon: -70 } } }, subject.to_hash)
+          end
+
+          should "take a Hash" do
+            subject = GeoDistanceRange.new from: '10km', to: '20km', foo: { lat: 40, lon: -70 }
+            assert_equal({geo_distance_range: { foo: { lat: 40, lon: -70 }, from: '10km', to: '20km' }}, subject.to_hash)
+          end
+
+          should "take options" do
+            subject = GeoDistanceRange.new :foo, from: '10km', to: '20km' do
+              lat 40
+              lon -70
+            end
+            assert_equal({geo_distance_range: { foo: { lat: 40, lon: -70 }, from: '10km', to: '20km' }}, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/geo_distance_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class GeoDistanceTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "GeoDistance filter" do
+          subject { GeoDistance.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ geo_distance: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = GeoDistance.new :foo
+
+            subject.distance 'bar'
+            subject.distance_type 'bar'
+            subject.lat 'bar'
+            subject.lon 'bar'
+
+            assert_equal %w[ distance distance_type foo ],
+                         subject.to_hash[:geo_distance].keys.map(&:to_s).sort
+            assert_equal %w[ lat lon ],
+                         subject.to_hash[:geo_distance][:foo].keys.map(&:to_s).sort
+
+            assert_equal 'bar', subject.to_hash[:geo_distance][:distance]
+            assert_equal 'bar', subject.to_hash[:geo_distance][:foo][:lat]
+          end
+
+          should "take a block" do
+            subject = GeoDistance.new :foo do
+              distance '1km'
+              lat 40
+              lon -70
+            end
+            assert_equal({geo_distance: { distance: '1km', foo: { lat: 40, lon: -70 } }}, subject.to_hash)
+          end
+
+          should "take a Hash" do
+            subject = GeoDistance.new distance: '10km', foo: { lat: 40, lon: -70 }
+            assert_equal({geo_distance: { foo: { lat: 40, lon: -70 }, distance: '10km' }}, subject.to_hash)
+          end
+
+          should "take options" do
+            subject = GeoDistance.new :foo, distance: '10km' do
+              lat 40
+              lon -70
+            end
+            assert_equal({geo_distance: { foo: { lat: 40, lon: -70 }, distance: '10km' }}, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/geo_polygon_test.rb

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

data/test/unit/filters/geo_shape_test.rb

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

data/test/unit/filters/geohash_cell_test.rb

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

data/test/unit/filters/has_child_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class HasChildTest < ::Test::Unit::TestCase
+        include Elasticsearch::DSL::Search::Filters
+
+        context "HasChild filter" do
+          subject { HasChild.new }
+
+          should "be converted to a Hash" do
+            assert_equal({ has_child: {} }, subject.to_hash)
+          end
+
+          should "have option methods" do
+            subject = HasChild.new
+
+            subject.type 'bar'
+            subject.query 'bar'
+            subject.filter 'bar'
+            subject.min_children 'bar'
+            subject.max_children 'bar'
+
+            assert_equal %w[ filter max_children min_children query type ],
+                         subject.to_hash[:has_child].keys.map(&:to_s).sort
+            assert_equal 'bar', subject.to_hash[:has_child][:type]
+          end
+
+          should "take a block" do
+            subject = HasChild.new do
+              type 'bar'
+            end
+            assert_equal({has_child: { type: 'bar' } }, subject.to_hash)
+          end
+
+          should "take a block for option method" do
+            subject = HasChild.new do
+              type 'bar'
+              query do
+                match :foo do
+                  query 'bar'
+                end
+              end
+            end
+            assert_equal({ has_child: { type: 'bar', query: { match: { foo: { query: 'bar'} } } } }, subject.to_hash)
+          end
+        end
+      end
+    end
+  end
+end