elasticsearch-dsl 0.0.0 → 0.1.0

data/test/unit/aggregations/percentile_ranks_test.rb

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

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

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

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

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

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

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

data/test/unit/aggregations/sum_test.rb

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

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

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

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

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class DSLTest < ::Test::Unit::TestCase
+      context "The DSL" do
+        class DummyDSLReceiver
+          include Elasticsearch::DSL
+        end
+
+        should "include the module in receiver" do
+          assert_contains DummyDSLReceiver.included_modules, Elasticsearch::DSL
+          assert_contains DummyDSLReceiver.included_modules, Elasticsearch::DSL::Search
+        end
+      end
+    end
+  end
+end

data/test/unit/filters/and_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Filters
+      class AndTest < ::Test::Unit::TestCase
+        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