elasticsearch-dsl 0.1.6 → 0.1.10

data/test/unit/aggregations/nested_test.rb

@@ -1,48 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class NestedTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Nested aggregation" 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'
-
-            assert_equal %w[ 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'
-            end
-            assert_equal({nested: { path: 'bar' } }, subject.to_hash)
-          end
-
-          should "define aggregations" do
-            subject = Nested.new do
-              path 'bar'
-
-              aggregation :min_price do
-                min field: 'bam'
-              end
-            end
-
-            assert_equal({nested: { path: 'bar' }, aggregations: { min_price: { min: { field: 'bam' } } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/percentile_ranks_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class PercentileRanksTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "PercentileRanks agg" do
-          subject { PercentileRanks.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ percentile_ranks: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = PercentileRanks.new
-
-            subject.field 'bar'
-            subject.values 'bar'
-            subject.script 'bar'
-            subject.params 'bar'
-            subject.compression 'bar'
-
-            assert_equal %w[ compression field params script values ],
-                         subject.to_hash[:percentile_ranks].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:percentile_ranks][:field]
-          end
-
-          should "take a block" do
-            subject = PercentileRanks.new do
-              field 'bar'
-              values [5, 10]
-            end
-            assert_equal({percentile_ranks: { field: 'bar', values: [5, 10] } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/percentiles_test.rb

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

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

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

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

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

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

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

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

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

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