elasticsearch-dsl 0.1.6 → 0.1.7

data/test/unit/aggregations/pipeline/derivative_test.rb

@@ -1,39 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class DerivativeTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Derivative agg" do
-          subject { Derivative.new }
-
-          should "be converted to a hash" do
-            assert_equal({ derivative: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Derivative.new :foo
-
-            subject.buckets_path 'bar'
-            subject.gap_policy 'bar'
-            subject.format 'bar'
-
-            assert_equal %w[ buckets_path format gap_policy ],
-              subject.to_hash[:derivative][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:derivative][:foo][:buckets_path]
-          end
-
-          should "take a block" do
-            subject = Derivative.new :foo do
-              format 'bar'
-            end
-            assert_equal({derivative: { foo: { format: 'bar' } } }, subject.to_hash)
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/pipeline/extended_stats_bucket_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class ExtendedStatsBucketTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Extended Stats Bucket agg" do
-          subject { ExtendedStatsBucket.new }
-
-          should "be converted to a hash" do
-            assert_equal({ extended_stats_bucket: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = ExtendedStatsBucket.new :foo
-
-            subject.buckets_path 'bar'
-            subject.gap_policy 'skip'
-            subject.format 'bar'
-
-            assert_equal %w[ buckets_path format gap_policy ],
-              subject.to_hash[:extended_stats_bucket][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:extended_stats_bucket][:foo][:buckets_path]
-          end
-
-          should "take a block" do
-            subject = ExtendedStatsBucket.new :foo do
-              format 'bar'
-            end
-            assert_equal({extended_stats_bucket: { foo: { format: 'bar' } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/pipeline/max_bucket_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class MaxBucketTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Max Bucket agg" do
-          subject { MaxBucket.new }
-
-          should "be converted to a hash" do
-            assert_equal({ max_bucket: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = MaxBucket.new :foo
-
-            subject.buckets_path 'bar'
-            subject.gap_policy 'bar'
-            subject.format 'bar'
-
-            assert_equal %w[ buckets_path format gap_policy ],
-              subject.to_hash[:max_bucket][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:max_bucket][:foo][:buckets_path]
-          end
-
-          should "take a block" do
-            subject = MaxBucket.new :foo do
-              format 'bar'
-            end
-            assert_equal({max_bucket: { foo: { format: 'bar' } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/pipeline/min_bucket_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class MinBucketTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Min Bucket agg" do
-          subject { MinBucket.new }
-
-          should "be converted to a hash" do
-            assert_equal({ min_bucket: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = MinBucket.new :foo
-
-            subject.buckets_path 'bar'
-            subject.gap_policy 'bar'
-            subject.format 'bar'
-
-            assert_equal %w[ buckets_path format gap_policy ],
-              subject.to_hash[:min_bucket][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:min_bucket][:foo][:buckets_path]
-          end
-
-          should "take a block" do
-            subject = MinBucket.new :foo do
-              format 'bar'
-            end
-            assert_equal({min_bucket: { foo: { format: 'bar' } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/pipeline/moving_avg_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class MovingAvgTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Moving Average Bucket agg" do
-          subject { MovingAvg.new }
-
-          should "be converted to a hash" do
-            assert_equal({ moving_avg: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = MovingAvg.new :foo
-
-            subject.buckets_path 'bar'
-            subject.gap_policy 'skip'
-            subject.minimize false
-            subject.model 'simple'
-            subject.settings({ period: 7 })
-            subject.window 5
-
-            assert_equal %w[ buckets_path gap_policy minimize model settings window ],
-              subject.to_hash[:moving_avg][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:moving_avg][:foo][:buckets_path]
-          end
-
-          should "take a block" do
-            subject = MovingAvg.new :foo do
-              format 'bar'
-            end
-            assert_equal({moving_avg: { foo: { format: 'bar' } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/pipeline/percentiles_bucket_test.rb

@@ -1,39 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class PercentilesBucketTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Percentiles Bucket agg" do
-          subject { PercentilesBucket.new }
-
-          should "be converted to a hash" do
-            assert_equal({ percentiles_bucket: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = PercentilesBucket.new :foo
-
-            subject.buckets_path 'bar'
-            subject.gap_policy 'skip'
-            subject.format 'bar'
-            subject.percents [ 1, 5, 25, 50, 75, 95, 99 ]
-
-            assert_equal %w[ buckets_path format gap_policy percents ],
-              subject.to_hash[:percentiles_bucket][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:percentiles_bucket][:foo][:buckets_path]
-          end
-
-          should "take a block" do
-            subject = PercentilesBucket.new :foo do
-              format 'bar'
-            end
-            assert_equal({percentiles_bucket: { foo: { format: 'bar' } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/pipeline/serial_diff_test.rb

@@ -1,39 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class SerialDiffTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Serial Defferencing agg" do
-          subject { SerialDiff.new }
-
-          should "be converted to a hash" do
-            assert_equal({ serial_diff: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = SerialDiff.new :foo
-
-            subject.buckets_path 'bar'
-            subject.lag 1
-            subject.gap_policy 'skip'
-            subject.format 'foo'
-
-            assert_equal %w[ buckets_path format gap_policy lag ],
-              subject.to_hash[:serial_diff][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:serial_diff][:foo][:buckets_path]
-          end
-
-          should "take a block" do
-            subject = SerialDiff.new :foo do
-              gap_policy 'skip'
-            end
-            assert_equal({serial_diff: { foo: { gap_policy: 'skip' } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/pipeline/stats_bucket_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class StatsBucketTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Stats Bucket agg" do
-          subject { StatsBucket.new }
-
-          should "be converted to a hash" do
-            assert_equal({ stats_bucket: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = StatsBucket.new :foo
-
-            subject.buckets_path 'bar'
-            subject.gap_policy 'bar'
-            subject.format 'bar'
-
-            assert_equal %w[ buckets_path format gap_policy ],
-              subject.to_hash[:stats_bucket][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:stats_bucket][:foo][:buckets_path]
-          end
-
-          should "take a block" do
-            subject = StatsBucket.new :foo do
-              format 'bar'
-            end
-            assert_equal({stats_bucket: { foo: { format: 'bar' } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/pipeline/sum_bucket_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class SumBucketTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Sum Bucket agg" do
-          subject { SumBucket.new }
-
-          should "be converted to a hash" do
-            assert_equal({ sum_bucket: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = SumBucket.new :foo
-
-            subject.buckets_path 'bar'
-            subject.gap_policy 'bar'
-            subject.format 'bar'
-
-            assert_equal %w[ buckets_path format gap_policy ],
-              subject.to_hash[:sum_bucket][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:sum_bucket][:foo][:buckets_path]
-          end
-
-          should "take a block" do
-            subject = SumBucket.new :foo do
-              format 'bar'
-            end
-            assert_equal({sum_bucket: { foo: { format: 'bar' } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/range_test.rb

@@ -1,59 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class RangeTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Range aggregation" do
-
-          should "take a Hash" do
-            subject = Range.new( { field: 'test', ranges: [ { to: 50 } ] } )
-            assert_equal({ range: { field: "test", ranges: [ {to: 50} ] } }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Range.new
-
-            subject.field 'foo'
-            subject.script 'bar*2'
-
-            assert_equal %w[ field script ], subject.to_hash[:range].keys.map(&:to_s).sort
-            assert_equal 'foo', subject.to_hash[:range][:field]
-          end
-
-          should "take a block with keyed ranges" do
-            subject = Range.new field: 'test' do
-              key 'foo', to: 10
-              key 'bar', from: 10, to: 20
-            end
-
-            assert_equal({ range: { field: "test", keyed: true, ranges: [ {to: 10, key: 'foo'}, { from: 10, to: 20, key: 'bar'}]}}, subject.to_hash)
-          end
-
-          should "let you set keyed to false explicitly" do
-            subject = Range.new do
-              keyed false
-              field 'test'
-              key   'foo', to: 10
-              key   'bar', from: 10, to: 20
-            end
-
-            assert_equal({ range: { field: "test", keyed: false, ranges: [ {to: 10, key: 'foo'}, { from: 10, to: 20, key: 'bar'}]}}, subject.to_hash)
-          end
-
-          should "define field in the block" do
-            subject = Range.new do
-              field 'test'
-              key   'foo', to: 10
-              key   'bar', from: 10, to: 20
-            end
-
-            assert_equal({ range: { field: "test", keyed: true, ranges: [ {to: 10, key: 'foo'}, { from: 10, to: 20, key: 'bar'}]}}, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/reverse_nested_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class ReverseNestedTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "ReverseNested aggregation" do
-          subject { ReverseNested.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ reverse_nested: {} }, subject.to_hash)
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/scripted_metric_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class ScriptedMetricTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "ScriptedMetric agg" do
-          subject { ScriptedMetric.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ scripted_metric: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = ScriptedMetric.new
-
-            subject.init_script 'bar'
-            subject.map_script 'bar'
-            subject.combine_script 'bar'
-            subject.reduce_script 'bar'
-            subject.params 'bar'
-            subject.lang 'bar'
-
-            assert_equal %w[ combine_script init_script lang map_script params reduce_script ],
-                         subject.to_hash[:scripted_metric].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:scripted_metric][:init_script]
-          end
-
-          should "take a block" do
-            subject = ScriptedMetric.new do
-              init_script 'bar'
-            end
-            assert_equal({scripted_metric: { init_script: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end