elasticsearch-dsl 0.1.6 → 0.1.10

data/test/unit/aggregations/avg_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class AvgTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Avg agg" do
-          subject { Avg.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ avg: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = Avg.new foo: 'bar'
-            assert_equal({ avg: { foo: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/cardinality_test.rb

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class CardinalityTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Cardinality agg" do
-          subject { Cardinality.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ cardinality: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Cardinality.new :foo
-
-            subject.field 'bar'
-            subject.precision_threshold 'bar'
-            subject.rehash 'bar'
-            subject.script 'bar'
-            subject.params 'bar'
-
-            assert_equal %w[ field params precision_threshold rehash script ],
-                         subject.to_hash[:cardinality][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:cardinality][:foo][:field]
-          end
-
-          should "take a block" do
-            subject = Cardinality.new :foo do
-              field 'bar'
-            end
-            assert_equal({cardinality: { foo: { field: 'bar' } }}, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/children_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class ChildrenTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Children aggregation" do
-          subject { Children.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ children: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Children.new
-
-            subject.type 'bar'
-
-            assert_equal %w[ type ],
-                         subject.to_hash[:children].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:children][:type]
-          end
-
-          should "take a block" do
-            subject = Children.new do
-              type 'bar'
-            end
-            assert_equal({children: { type: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/date_histogram_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class DateHistogramTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "DateHistogram aggregation" do
-          subject { DateHistogram.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ date_histogram: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = DateHistogram.new
-
-            subject.field 'bar'
-            subject.interval 'bar'
-            subject.pre_zone 'bar'
-            subject.post_zone 'bar'
-            subject.time_zone 'bar'
-            subject.pre_zone_adjust_large_interval 'bar'
-            subject.pre_offset 'bar'
-            subject.post_offset 'bar'
-            subject.format 'bar'
-            subject.min_doc_count 'bar'
-            subject.extended_bounds 'bar'
-            subject.order 'bar'
-
-            assert_equal %w[ extended_bounds field format interval min_doc_count order post_offset post_zone pre_offset pre_zone pre_zone_adjust_large_interval time_zone ],
-                         subject.to_hash[:date_histogram].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:date_histogram][:field]
-          end
-
-          should "take a block" do
-            subject = DateHistogram.new do
-              field    'bar'
-              interval 'day'
-              format   'yyyy-MM-dd'
-            end
-            assert_equal({date_histogram: { field: 'bar', interval: 'day', format: 'yyyy-MM-dd' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/date_range_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class DateRangeTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "DateRange aggregation" do
-          subject { DateRange.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ date_range: {} }, subject.to_hash)
-
-            subject = DateRange.new field: 'test', ranges: [ {to: 'foo'}, {from: 'bar'} ]
-            assert_equal({ date_range: { field: 'test', ranges: [ {to: 'foo'}, {from: 'bar'} ] } }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = DateRange.new
-
-            subject.field 'bar'
-            subject.format 'bar'
-            subject.ranges 'bar'
-
-            assert_equal %w[ field format ranges ],
-                         subject.to_hash[:date_range].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:date_range][:field]
-          end
-
-          should "take a block" do
-            subject = DateRange.new do
-              field 'bar'
-              ranges [ {to: 'foo'}, {from: 'bar'} ]
-            end
-            assert_equal({date_range: { field: 'bar', ranges: [ {to: 'foo'}, {from: 'bar'} ] } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/extended_stats_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class ExtendedStatsTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "ExtendedStats agg" do
-          subject { ExtendedStats.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ extended_stats: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = ExtendedStats.new foo: 'bar'
-            assert_equal({ extended_stats: { foo: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/filter_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class FilterTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Filter agg" do
-          subject { Filter.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ filter: {} }, subject.to_hash)
-          end
-
-          should "nest another aggregation" do
-            subject = Filter.new terms: { foo: 'bar' } do
-              aggregation :sum_clicks do
-                sum moo: 'bam'
-              end
-            end
-
-            assert_equal(
-              { filter: { terms: { foo: 'bar' } }, aggregations: { sum_clicks: { sum: { moo: 'bam' } } } },
-              subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/filters_test.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class FiltersTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Filters agg" do
-          subject { Elasticsearch::DSL::Search::Aggregations::Filters.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ filters: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Elasticsearch::DSL::Search::Aggregations::Filters.new
-            subject.filters foo: 'bar'
-
-            assert_equal 'bar', subject.to_hash[:filters][:filters][:foo]
-          end
-
-          should "define filters" do
-            subject = Elasticsearch::DSL::Search::Aggregations::Filters.new filters: { foo: 'bar' }
-            assert_equal({ filters: { filters: { foo: 'bar' } } }, subject.to_hash)
-          end
-
-          should "define filters with a block" do
-            subject = Elasticsearch::DSL::Search::Aggregations::Filters.new do
-              filters foo: 'bar'
-            end
-            assert_equal({ filters: { filters: { foo: 'bar' } } }, subject.to_hash)
-          end
-
-          should "define aggregations" do
-            subject = Elasticsearch::DSL::Search::Aggregations::Filters.new do
-              filters foo: { terms: { foo: 'bar' } }
-              aggregation :sum_clicks do
-                sum moo: 'bam'
-              end
-            end
-
-            assert_equal(
-              { filters: { filters: { foo: { terms: { foo: 'bar' } } } }, aggregations: { sum_clicks: { sum: { moo: 'bam' } } } },
-              subject.to_hash)
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/geo_bounds_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class GeoBoundsTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "GeoBounds agg" do
-          subject { GeoBounds.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ geo_bounds: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = GeoBounds.new
-
-            subject.field 'bar'
-            subject.wrap_longitude 'bar'
-
-            assert_equal %w[ field wrap_longitude ],
-                         subject.to_hash[:geo_bounds].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:geo_bounds][:field]
-          end
-
-          should "take a block" do
-            subject = GeoBounds.new do
-              field 'bar'
-            end
-            assert_equal({geo_bounds: { field: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/geo_distance_test.rb

@@ -1,45 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class GeoDistanceTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "GeoDistance aggregation" 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
-
-            subject.field 'bar'
-            subject.origin 'bar'
-            subject.ranges 'bar'
-            subject.unit 'bar'
-            subject.distance_type 'bar'
-
-            assert_equal %w[ distance_type field origin ranges unit ],
-                         subject.to_hash[:geo_distance].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:geo_distance][:field]
-          end
-
-          should "take a block" do
-            subject = GeoDistance.new do
-              field  'bar'
-              origin lat: 50, lon: 5
-              ranges [ { to: 50 }, { from: 50, to: 100 }, { from: 100 } ]
-            end
-            assert_equal(
-              { geo_distance: { field: 'bar', origin: { lat: 50, lon: 5 }, ranges: [ { to: 50 }, { from: 50, to: 100 }, { from: 100 } ] } },
-              subject.to_hash
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/geohash_grid_test.rb

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class GeohashGridTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "GeohashGrid aggregation" do
-          subject { GeohashGrid.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ geohash_grid: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = GeohashGrid.new
-
-            subject.field 'bar'
-            subject.precision 'bar'
-            subject.size 'bar'
-            subject.shard_size 'bar'
-
-            assert_equal %w[ field precision shard_size size ],
-                         subject.to_hash[:geohash_grid].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:geohash_grid][:field]
-          end
-
-          should "take a block" do
-            subject = GeohashGrid.new do
-              field     'bar'
-              precision 5
-            end
-            assert_equal({geohash_grid: { field: 'bar', precision: 5 } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/global_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class GlobalTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Global agg" do
-          subject { Global.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ global: {} }, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = Global.new do
-            end
-            assert_equal({global: {} }, subject.to_hash)
-          end
-
-          should "define aggregations" do
-            subject = Global.new do
-              aggregation :foo do
-                terms field: "bar"
-              end
-            end
-            expected = {
-              aggregations: { foo: { terms: { field: "bar" } } },
-              global: {}
-            }
-            assert_equal(expected, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/histogram_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class HistogramTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Histogram aggregation" do
-          subject { Histogram.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ histogram: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Histogram.new
-
-            subject.field 'bar'
-            subject.interval 'bar'
-            subject.min_doc_count 'bar'
-            subject.extended_bounds 'bar'
-            subject.order 'bar'
-            subject.keyed 'bar'
-
-            assert_equal %w[ extended_bounds field interval keyed min_doc_count order ],
-                         subject.to_hash[:histogram].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:histogram][:field]
-          end
-
-          should "take a block" do
-            subject = Histogram.new do
-              field    'bar'
-              interval 5
-            end
-            assert_equal({histogram: { field: 'bar', interval: 5 } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/ip_range_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class IpRangeTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "IpRange aggregation" do
-          subject { IpRange.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ ip_range: {} }, subject.to_hash)
-
-            subject = IpRange.new field: 'test', ranges: [ {to: 'foo'}, {from: 'bar'} ]
-            assert_equal({ ip_range: { field: 'test', ranges: [ {to: 'foo'}, {from: 'bar'} ] } }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = IpRange.new
-
-            subject.field 'bar'
-            subject.ranges 'bar'
-
-            assert_equal %w[ field ranges ],
-                         subject.to_hash[:ip_range].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:ip_range][:field]
-          end
-
-          should "take a block" do
-            subject = IpRange.new do
-              field 'bar'
-              ranges [ {to: 'foo'}, {from: 'bar'} ]
-            end
-            assert_equal({ip_range: { field: 'bar', ranges: [ {to: 'foo'}, {from: 'bar'} ] } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/max_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class MaxTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Max agg" do
-          subject { Max.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ max: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = Max.new foo: 'bar'
-            assert_equal({ max: { foo: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/min_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class MinTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Min agg" do
-          subject { Min.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ min: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = Min.new foo: 'bar'
-            assert_equal({ min: { foo: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/missing_test.rb

@@ -1,39 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class MissingTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Missing aggregation" do
-          subject { Missing.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ missing: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = Missing.new( { field: 'foo' } )
-            assert_equal({ missing: { field: "foo" } }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject.field 'foo'
-
-            assert_equal %w[ field ], subject.to_hash[:missing].keys.map(&:to_s).sort
-            assert_equal 'foo', 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