elasticsearch-dsl 0.1.6 → 0.1.7

data/test/unit/queries/simple_query_string_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class SimpleQueryStringTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "SimpleQueryString query" do
-          subject { SimpleQueryString.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ simple_query_string: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = SimpleQueryString.new :foo
-
-            subject.query 'bar'
-            subject.fields 'bar'
-            subject.default_operator 'bar'
-            subject.analyzer 'bar'
-            subject.flags 'bar'
-            subject.lenient 'bar'
-
-            assert_equal %w[ analyzer default_operator fields flags lenient query ],
-                         subject.to_hash[:simple_query_string][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:simple_query_string][:foo][:query]
-          end
-
-          should "take a block" do
-            subject = SimpleQueryString.new :foo do
-              query 'bar'
-            end
-            assert_equal({simple_query_string: { foo: { query: 'bar' } }}, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/span_first_test.rb

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

data/test/unit/queries/span_multi_test.rb

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

data/test/unit/queries/span_near_test.rb

@@ -1,39 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class SpanNearTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "SpanNear query" do
-          subject { SpanNear.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ span_near: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = SpanNear.new
-
-            subject.span_near 'bar'
-            subject.slop 'bar'
-            subject.in_order 'bar'
-            subject.collect_payloads 'bar'
-
-            assert_equal %w[ collect_payloads in_order slop span_near ],
-                         subject.to_hash[:span_near].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:span_near][:span_near]
-          end
-
-          should "take a block" do
-            subject = SpanNear.new do
-              span_near 'bar'
-            end
-            assert_equal({ span_near: { span_near: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/span_not_test.rb

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class SpanNotTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "SpanNot query" do
-          subject { SpanNot.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ span_not: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = SpanNot.new
-
-            subject.include 'bar'
-            subject.exclude 'bar'
-            subject.pre 'bar'
-            subject.post 'bar'
-            subject.dist 'bar'
-
-            assert_equal %w[ dist exclude include post pre ],
-                         subject.to_hash[:span_not].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:span_not][:include]
-          end
-
-          should "take a block" do
-            subject = SpanNot.new do
-              include 'bar'
-            end
-            assert_equal({ span_not: { include: 'bar' } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/span_or_test.rb

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

data/test/unit/queries/span_term_test.rb

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

data/test/unit/queries/template_test.rb

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

data/test/unit/queries/term_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class TermTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        subject { Term.new message: 'test' }
-
-        context "Term Query" 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/queries/terms_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class TermsTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Terms query" do
-          subject { Terms.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ terms: {} }, subject.to_hash)
-          end
-
-          should "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/queries/top_children_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class TopChildrenTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "TopChildren query" do
-          subject { TopChildren.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ top_children: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = TopChildren.new
-
-            subject.type 'bar'
-            subject.query 'bar'
-            subject.score 'bar'
-            subject.factor 'bar'
-            subject.incremental_factor 'bar'
-            subject._scope 'bar'
-
-            assert_equal %w[ _scope factor incremental_factor query score type ],
-                         subject.to_hash[:top_children].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:top_children][:type]
-          end
-
-          should "take a block" do
-            subject = TopChildren.new do
-              type 'bar'
-              query 'foo'
-            end
-            assert_equal({ top_children: { type: 'bar', query: 'foo' } }, subject.to_hash)
-          end
-
-          should "evaluate a block passed to the query method" do
-            subject = TopChildren.new do
-              type 'bar'
-              query do
-                match foo: 'BLAM'
-              end
-            end
-
-            assert_equal({ top_children: { type: 'bar', query: { match: { foo: 'BLAM' } } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/wildcard_test.rb

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