elasticsearch-dsl 0.1.6 → 0.1.10

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

data/test/unit/aggregations/significant_terms_test.rb

@@ -1,46 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class SignificantTermsTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "SignificantTerms aggregation" do
-          subject { SignificantTerms.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ significant_terms: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = SignificantTerms.new
-
-            subject.field 'bar'
-            subject.size 'bar'
-            subject.shard_size 'bar'
-            subject.min_doc_count 'bar'
-            subject.shard_min_doc_count 'bar'
-            subject.include 'bar'
-            subject.exclude 'bar'
-            subject.background_filter 'bar'
-            subject.mutual_information 'bar'
-            subject.chi_square 'bar'
-            subject.gnd 'bar'
-
-            assert_equal %w[ background_filter chi_square exclude field gnd include min_doc_count mutual_information shard_min_doc_count shard_size size ],
-                         subject.to_hash[:significant_terms].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:significant_terms][:field]
-          end
-
-          should "take a block" do
-            subject = SignificantTerms.new do
-              field 'bar'
-            end
-            assert_equal({significant_terms: { field: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/stats_test.rb

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

data/test/unit/aggregations/sum_test.rb

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

data/test/unit/aggregations/terms_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Aggregations
-      class TermsTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Aggregations
-
-        context "Terms aggregation" do
-          subject { Terms.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ terms: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Terms.new
-
-            subject.field 'bar'
-            subject.size 'bar'
-            subject.shard_size 'bar'
-            subject.order 'bar'
-            subject.min_doc_count 'bar'
-            subject.shard_min_doc_count 'bar'
-            subject.script 'bar'
-            subject.include 'bar'
-            subject.exclude 'bar'
-
-            assert_equal %w[ exclude field include min_doc_count order script shard_min_doc_count shard_size size ],
-                         subject.to_hash[:terms].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:terms][:field]
-          end
-
-          should "take a Hash" do
-            subject = Terms.new field: 'test'
-
-            assert_equal({:terms=>{:field=>"test"}}, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = Terms.new do
-              field 'bar'
-            end
-
-            assert_equal({terms: { field: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/aggregations/top_hits_test.rb

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

data/test/unit/aggregations/value_count_test.rb

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

data/test/unit/filters/and_test.rb

@@ -1,69 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class AndTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "And filter" do
-          subject { And.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ and: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = And.new filters: [ { term: { foo: 'bar' } } ]
-            assert_equal({ and: { filters: [ { term: { foo: 'bar' } } ] } }, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = And.new do
-              term foo: 'bar'
-              term moo: 'mam'
-            end
-            assert_equal({and: [ {term: { foo: 'bar'}}, {term: { moo: 'mam'}} ]}, subject.to_hash)
-          end
-
-          should "behave like an Enumerable" do
-            subject = And.new
-            subject << { term: { foo: 'bar' } }
-            subject << { term: { moo: 'mam' } }
-
-            assert_equal 2,    subject.size
-            assert_equal 'bar', subject[0][:term][:foo]
-            assert subject.any? { |d| d[:term] == { foo: 'bar' } }
-          end
-
-          should "behave like an Enumerable with a block" do
-            subject = And.new do
-              term foo: 'bar'
-              term moo: 'mam'
-            end
-
-            subject.call
-            assert_equal 2,     subject.size
-
-            hash = subject.to_hash
-            assert_equal 'bar', hash[:and][0][:term][:foo]
-            assert hash[:and].any? { |d| d[:term] == { foo: 'bar' } }
-          end
-
-          should "behave like an Array" do
-            subject = And.new
-
-            assert subject.empty?
-
-            subject << { term: { foo: 'bar' } }
-            subject << { term: { moo: 'xam' } }
-
-            assert ! subject.empty?
-
-            assert_equal({ and: [ { term: { foo: 'bar' } }, { term: { moo: 'xam' } } ] }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/bool_test.rb

@@ -1,98 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class BoolTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "Bool Filter" do
-          subject { Bool.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ bool: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = Bool.new must: [ {term: { foo: 'bar' } } ]
-
-            assert_equal( { bool: { must: [ {term: { foo: 'bar' } } ] } }, subject.to_hash )
-          end
-
-          should "take a block" do
-            subject = Bool.new do
-              must { term foo: 'bar' }
-            end
-
-            assert_equal( { bool: { must: [ {term: { foo: 'bar' }} ] } }, subject.to_hash )
-          end
-
-          should "take a block with multiple methods" do
-            subject = Bool.new do
-              must     { term foo: 'bar' }
-              must_not { term moo: 'bam' }
-              should   { term xoo: 'bax' }
-            end
-
-            assert_equal( { bool:
-                            { must:     [ {term: { foo: 'bar' }} ],
-                              must_not: [ {term: { moo: 'bam' }} ],
-                              should:   [ {term: { xoo: 'bax' }} ]
-                            }
-                          },
-                          subject.to_hash )
-          end
-
-          should "take a block with multiple conditions" do
-            subject = Bool.new do
-              must { term foo: 'bar' }
-              must { term moo: 'bam' }
-
-              should { term xoo: 'bax' }
-              should { term zoo: 'baz' }
-            end
-
-            # Make sure we're not additive
-            subject.to_hash
-            subject.to_hash
-
-            assert_equal( { bool:
-                            { must:     [ {term: { foo: 'bar' }}, {term: { moo: 'bam' }} ],
-                              should:   [ {term: { xoo: 'bax' }}, {term: { zoo: 'baz' }} ]
-                            }
-                          },
-                          subject.to_hash )
-          end
-
-          should "take method calls" do
-            subject = Bool.new
-
-            subject.must { term foo: 'bar' }
-            assert_equal( { bool: { must: [ {term: { foo: 'bar' }} ] } }, subject.to_hash )
-
-            subject.must { term moo: 'bam' }
-            assert_equal( { bool: { must: [ {term: { foo: 'bar' }}, {term: { moo: 'bam' }} ]} },
-                          subject.to_hash )
-
-            subject.should { term xoo: 'bax' }
-            assert_equal( { bool:
-                            { must:   [ {term: { foo: 'bar' }}, {term: { moo: 'bam' }} ],
-                              should: [ {term: { xoo: 'bax' }} ] }
-                          },
-                          subject.to_hash )
-          end
-
-          should "be chainable" do
-            subject = Bool.new
-
-            assert_instance_of Bool, subject.must     { term foo: 'bar' }
-            assert_instance_of Bool, subject.must     { term foo: 'bar' }.must { term moo: 'bam' }
-            assert_instance_of Bool, subject.must_not { term foo: 'bar' }
-            assert_instance_of Bool, subject.should   { term foo: 'bar' }
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/exists_test.rb

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

data/test/unit/filters/geo_bounding_box_test.rb

@@ -1,45 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class GeoBoundingBoxTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "GeoBoundingBox filter" do
-          subject { GeoBoundingBox.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ geo_bounding_box: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = GeoBoundingBox.new :foo
-
-            subject.top_left     'bar'
-            subject.bottom_right 'bar'
-            subject.top_right    'bar'
-            subject.bottom_left  'bar'
-            subject.top          'bar'
-            subject.left         'bar'
-            subject.bottom       'bar'
-            subject.right        'bar'
-
-            assert_equal %w[ bottom bottom_left bottom_right left right top top_left top_right ],
-                         subject.to_hash[:geo_bounding_box][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:geo_bounding_box][:foo][:top_left]
-          end
-
-          should "take a block" do
-            subject = GeoBoundingBox.new :foo do
-              top_left     [0,1]
-              bottom_right [3,2]
-            end
-
-            assert_equal({geo_bounding_box: { foo: { top_left: [0,1], bottom_right: [3,2] } }}, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/geo_distance_range_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class GeoDistanceRangeTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "GeoDistanceRange filter" do
-          subject { GeoDistanceRange.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ geo_distance_range: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = GeoDistanceRange.new :foo
-
-            subject.lat 'bar'
-            subject.lon 'bar'
-
-            assert_equal %w[ lat lon ],
-                         subject.to_hash[:geo_distance_range][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:geo_distance_range][:foo][:lat]
-          end
-
-          should "take a block" do
-            subject = GeoDistanceRange.new :foo do
-              lat 40
-              lon -70
-            end
-            assert_equal({geo_distance_range: { foo: { lat: 40, lon: -70 } } }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = GeoDistanceRange.new from: '10km', to: '20km', foo: { lat: 40, lon: -70 }
-            assert_equal({geo_distance_range: { foo: { lat: 40, lon: -70 }, from: '10km', to: '20km' }}, subject.to_hash)
-          end
-
-          should "take options" do
-            subject = GeoDistanceRange.new :foo, from: '10km', to: '20km' do
-              lat 40
-              lon -70
-            end
-            assert_equal({geo_distance_range: { foo: { lat: 40, lon: -70 }, from: '10km', to: '20km' }}, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end