elasticsearch-dsl 0.0.0 → 0.1.0

data/test/unit/aggregations/date_range_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class DateRangeTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class ExtendedStatsTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class FilterTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class FiltersTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class GeoBoundsTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class GeoDistanceTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class GeohashGridTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class GlobalTest < ::Test::Unit::TestCase
+        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
+          
+        end
+      end
+    end
+  end
+end

data/test/unit/aggregations/histogram_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class HistogramTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class IpRangeTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class MaxTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class MinTest < ::Test::Unit::TestCase
+        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/nested_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Aggregations
+      class NestedTest < ::Test::Unit::TestCase
+        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