elasticsearch-dsl 0.1.6 → 0.1.7

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

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