elasticsearch-dsl 0.1.6 → 0.1.7

data/test/unit/filters/match_all_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class MatchAllTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "MatchAll filter" do
-          subject { MatchAll.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ match_all: {} }, subject.to_hash)
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/missing_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class MissingTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "Missing filter" do
-          subject { Missing.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ missing: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Missing.new
-
-            subject.field 'bar'
-            subject.existence 'bar'
-            subject.null_value 'bar'
-
-            assert_equal %w[ existence field null_value ],
-                         subject.to_hash[:missing].keys.map(&:to_s).sort
-            assert_equal 'bar', 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/filters/nested_test.rb

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class NestedTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "Nested filter" 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'
-            subject.filter 'bar'
-
-            assert_equal %w[ filter 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'
-              filter do
-                term foo: 'bar'
-              end
-            end
-            assert_equal({nested: { path: 'bar', filter: { term: { foo: 'bar' } } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/not_test.rb

@@ -1,35 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class NotTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "Not filter" do
-          subject { Not.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ not: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = Not.new filters: [ { term: { foo: 'bar' } } ]
-            assert_equal({ not: { filters: [ { term: { foo: 'bar' } } ] } }, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = Not.new do
-              term foo: 'bar'
-            end
-            assert_equal({not: {term: { foo: 'bar'}} }, subject.to_hash)
-          end
-
-          should "raise an exception for unknown DSL method" do
-            assert_raise(NoMethodError) { subject.foofoo }
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/or_test.rb

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

data/test/unit/filters/prefix_test.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class PrefixTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "Prefix filter" do
-          subject { Prefix.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ prefix: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = Prefix.new foo: 'bar'
-
-            assert_equal({ prefix: { foo: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/query_test.rb

@@ -1,33 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class QueryTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "Query filter" do
-          subject { Query.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ query: {} }, subject.to_hash)
-          end
-
-          should "take a Hash" do
-            subject = Query.new query_string: { query: 'foo' }
-
-            assert_equal({ query: { query_string: { query: 'foo' } } }, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = Query.new do
-              match foo: 'bar'
-            end
-
-            assert_equal({ query: { match: { foo: 'bar' } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/range_test.rb

@@ -1,48 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class RangeTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "Range filter" do
-          subject { Range.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ range: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Range.new :foo
-
-            subject.gte 'bar'
-            subject.lte 'bar'
-            subject.time_zone 'bar'
-            subject.format 'bar'
-
-            assert_equal %w[ format gte lte time_zone ],
-                         subject.to_hash[:range][:foo].keys.map(&:to_s).sort
-
-            assert_equal 'bar', subject.to_hash[:range][:foo][:gte]
-          end
-
-          should "take a hash" do
-            subject = Range.new age: { gte: 10, lte: 20 }
-
-            assert_equal({ range: { age: { gte: 10, lte: 20 } } }, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = Range.new :age do
-              gte 10
-              lte 20
-            end
-
-            assert_equal({ range: { age: { gte: 10, lte: 20 } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/regexp_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class RegexpTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "Regexp filter" do
-          subject { Regexp.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ regexp: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Regexp.new :foo
-
-            subject.value 'bar'
-            subject.flags 'bar'
-
-            assert_equal %w[ flags value ],
-                         subject.to_hash[:regexp][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:regexp][:foo][:value]
-          end
-
-          should "take a Hash" do
-            subject = Regexp.new foo: 'b.*r'
-            assert_equal({regexp: { foo: 'b.*r' }}, subject.to_hash)
-          end
-
-          should "take a block" do
-            subject = Regexp.new :foo do
-              value 'b*r'
-            end
-            assert_equal({regexp: { foo: { value: 'b*r' } }}, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/script_test.rb

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

data/test/unit/filters/term_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class TermTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        subject { Term.new message: 'test' }
-
-        context "Term Filter" do
-          should "take a concrete value" do
-            @subject = Term.new message: 'test'
-
-            assert_equal({ term: { message: 'test' } }, @subject.to_hash)
-          end
-
-          should "take a Hash" do
-            @subject = Term.new message: { query: 'test', boost: 2 }
-
-            assert_equal({ term: { message: { query: 'test', boost: 2 }}}, @subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/terms_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Filters
-      class TermsTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Filters
-
-        context "Terms filter" do
-          subject { Terms.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ terms: {} }, subject.to_hash)
-          end
-
-          should "be take a Hash" do
-            subject = Terms.new foo: ['abc', 'xyz']
-            assert_equal({ terms: { foo: ['abc', 'xyz'] } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/filters/type_test.rb

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