elasticsearch-dsl 0.1.6 → 0.1.10

data/test/unit/filters/geo_distance_test.rb

@@ -1,58 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class GeoDistanceTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,36 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class GeoPolygonTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class GeoShapeTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,43 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class GeohashCellTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,54 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class HasChildTest < ::Elasticsearch::Test::UnitTestCase
-        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'
-            subject.inner_hits({ size: 1 })
-
-            assert_equal %w[ filter inner_hits 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]
-            assert_equal({ size: 1 }, subject.to_hash[:has_child][:inner_hits])
-          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

data/test/unit/filters/has_parent_test.rb

@@ -1,54 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class HasParentTest < ::Elasticsearch::Test::UnitTestCase
-        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'
-            subject.inner_hits({ size: 1 })
-
-            assert_equal %w[ filter inner_hits 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]
-            assert_equal({ size: 1 }, subject.to_hash[:has_parent][:inner_hits])
-          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

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class IdsTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class IndicesTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,36 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class LimitTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class MatchAllTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class MissingTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class NestedTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,35 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class NotTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class OrTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class PrefixTest < ::Elasticsearch::Test::UnitTestCase
-        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

@@ -1,33 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class QueryTest < ::Elasticsearch::Test::UnitTestCase
-        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