elasticsearch-dsl 0.1.6 → 0.1.7

data/test/unit/queries/bool_test.rb

@@ -1,147 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class BoolTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Bool Query" 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: [ {match: { foo: 'bar' }} ]
-
-            assert_equal( { bool: { must: [ {match: { foo: 'bar' }} ] } }, subject.to_hash )
-          end
-
-          should "take a block" do
-            subject = Bool.new do
-              must { match foo: 'bar' }
-            end
-
-            assert_equal( { bool: {must: [ {match: { foo: 'bar' }} ] } }, subject.to_hash )
-          end
-
-          should "have option methods" do
-            subject = Bool.new do
-              should   { term tag: 'wow' }
-              should   { term tag: 'elasticsearch' }
-
-              minimum_should_match 1
-              boost 1.0
-            end
-
-            assert_equal( { bool:
-                            {
-                              minimum_should_match: 1,
-                              boost: 1.0,
-                              should:     [ {term: { tag: 'wow' }}, {term: { tag: 'elasticsearch' }} ]
-                            }
-                          },
-                          subject.to_hash )
-          end
-
-          should "take a block with multiple methods" do
-            subject = Bool.new do
-              must     { match foo: 'bar' }
-              must_not { match moo: 'bam' }
-              should   { match xoo: 'bax' }
-              filter   { term  zoo: 'baz'}
-            end
-
-            assert_equal( { bool:
-                            { must:     [ {match: { foo: 'bar' }} ],
-                              must_not: [ {match: { moo: 'bam' }} ],
-                              should:   [ {match: { xoo: 'bax' }} ],
-                              filter:   [ {term:  { zoo: 'baz' }}]
-                            }
-                          },
-                          subject.to_hash )
-          end
-
-          should "take a block with multiple conditions" do
-            subject = Bool.new do
-              must do
-                match foo: 'bar'
-              end
-
-              must do
-                match moo: 'bam'
-              end
-
-              should do
-                match xoo: 'bax'
-              end
-
-              should do
-                match zoo: 'baz'
-              end
-            end
-
-            # Make sure we're not additive
-            subject.to_hash
-            subject.to_hash
-
-            assert_equal( { bool:
-                            { must:     [ {match: { foo: 'bar' }}, {match: { moo: 'bam' }} ],
-                              should:   [ {match: { xoo: 'bax' }}, {match: { zoo: 'baz' }} ]
-                            }
-                          },
-                          subject.to_hash )
-          end
-
-          should "take method calls" do
-            subject = Bool.new
-
-            subject.must { match foo: 'bar' }
-            assert_equal( { bool: { must: [ {match: { foo: 'bar' }} ] } }, subject.to_hash )
-
-            subject.must { match moo: 'bam' }
-            assert_equal( { bool: { must: [ {match: { foo: 'bar' }}, {match: { moo: 'bam' }} ]} },
-                          subject.to_hash )
-
-            subject.should { match xoo: 'bax' }
-            assert_equal( { bool:
-                            { must:   [ {match: { foo: 'bar' }}, {match: { moo: 'bam' }} ],
-                              should: [ {match: { xoo: 'bax' }} ] }
-                          },
-                          subject.to_hash )
-          end
-
-          should "combine chained filters" do
-            subject = Bool.new
-            subject.
-              filter {
-                term foo: "bar"
-              }
-            subject.filter {
-                term zoo: "baz"
-              }
-
-            assert_equal( { bool:
-                            { filter: [
-                              { term: { foo: "bar"}},
-                              { term: { zoo: "baz"}}
-                            ] }
-                          },
-                          subject.to_hash)
-          end
-
-          should "be chainable" do
-            subject = Bool.new
-
-            assert_instance_of Bool, subject.must     { match foo: 'bar' }
-            assert_instance_of Bool, subject.must     { match foo: 'bar' }.must { match moo: 'bam' }
-            assert_instance_of Bool, subject.must_not { match foo: 'bar' }
-            assert_instance_of Bool, subject.should   { match foo: 'bar' }
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/boosting_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class BoostingTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Boosting query" do
-          subject { Boosting.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ boosting: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Boosting.new
-
-            subject.positive 'bar'
-            subject.negative 'bar'
-            subject.negative_boost 'bar'
-
-            assert_equal %w[ negative negative_boost positive ],
-                         subject.to_hash[:boosting].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:boosting][:positive]
-          end
-
-          should "take a block" do
-            subject = Boosting.new do
-              positive foo: 'bar'
-              negative moo: 'xoo'
-            end
-
-            assert_equal 'bar', subject.to_hash[:boosting][:positive][:foo]
-            assert_equal 'xoo', subject.to_hash[:boosting][:negative][:moo]
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/common_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class CommonTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Common query" do
-          subject { Common.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ common: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Common.new :foo
-
-            subject.query 'bar'
-            subject.cutoff_frequency 'bar'
-            subject.low_freq_operator 'bar'
-            subject.minimum_should_match 'bar'
-            subject.boost 'bar'
-            subject.analyzer 'bar'
-            subject.disable_coord 'bar'
-
-            assert_equal %w[ analyzer boost cutoff_frequency disable_coord low_freq_operator minimum_should_match query ],
-                         subject.to_hash[:common][:foo].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:common][:foo][:query]
-          end
-
-          should "take a block" do
-            subject = Common.new :foo do
-              query 'bar'
-            end
-            assert_equal 'bar', subject.to_hash[:common][:foo][:query]
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/constant_score_test.rb

@@ -1,47 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class ConstantScoreTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "ConstantScore query" do
-          subject { ConstantScore.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ constant_score: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = ConstantScore.new
-
-            subject.query 'bar'
-            subject.filter 'bar'
-            subject.boost 'bar'
-
-            assert_equal %w[ boost filter query ],
-                         subject.to_hash[:constant_score].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:constant_score][:query]
-          end
-
-          should "take a block" do
-            subject = ConstantScore.new do
-              query term: { foo: 'bar' }
-            end
-            assert_equal 'bar', subject.to_hash[:constant_score][:query][:term][:foo]
-          end
-
-          should "evaluate a block passed to the option method" do
-            subject = ConstantScore.new do
-              query do
-                term foo: 'bar'
-              end
-            end
-            assert_equal 'bar', subject.to_hash[:constant_score][:query][:term][:foo]
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/dis_max_test.rb

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

data/test/unit/queries/exists_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class ExistsTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Exists query" 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/queries/filtered_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class FilteredTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "Filtered query" do
-          subject { Filtered.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ filtered: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = Filtered.new
-
-            subject.query 'bar'
-            subject.filter 'bar'
-            subject.strategy 'bar'
-
-            assert_equal %w[ filter query strategy ],
-                         subject.to_hash[:filtered].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:filtered][:query]
-          end
-
-          should "take a block" do
-            subject = Filtered.new do
-              query 'bar'
-            end
-            assert_equal 'bar', subject.to_hash[:filtered][:query]
-          end
-
-          should "evaluate a block passed to the option method" do
-            subject = Filtered.new do
-              query do
-                match foo: 'BLAM'
-              end
-              filter do
-                term bar: 'slam'
-              end
-            end
-
-            assert_equal({filtered: { query: { match: { foo: 'BLAM' } }, filter: { term: { bar: 'slam' } } } }, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end

data/test/unit/queries/function_score_test.rb

@@ -1,70 +0,0 @@
-require 'test_helper'
-
-module Elasticsearch
-  module Test
-    module Queries
-      class FunctionScoreTest < ::Elasticsearch::Test::UnitTestCase
-        include Elasticsearch::DSL::Search::Queries
-
-        context "FunctionScore query" do
-          subject { FunctionScore.new }
-
-          should "be converted to a Hash" do
-            assert_equal({ function_score: {} }, subject.to_hash)
-          end
-
-          should "have option methods" do
-            subject = FunctionScore.new
-
-            subject.query 'bar'
-            subject.filter 'bar'
-            subject.functions ['bar']
-            subject.script_score 'bar'
-            subject.boost 'bar'
-            subject.max_boost 'bar'
-            subject.score_mode 'bar'
-            subject.boost_mode 'bar'
-
-            assert_equal %w[ boost boost_mode filter functions max_boost query score_mode script_score ],
-                         subject.to_hash[:function_score].keys.map(&:to_s).sort
-            assert_equal 'bar', subject.to_hash[:function_score][:query]
-          end
-
-          should "take a block" do
-            subject = FunctionScore.new do
-              query 'bar'
-            end
-            assert_equal 'bar', subject.to_hash[:function_score][:query]
-          end
-
-          should "evaluate a block passed to the option method" do
-            subject = FunctionScore.new do
-              query do
-                match foo: 'BLAM'
-              end
-              filter do
-                term bar: 'slam'
-              end
-              functions << { foo: { abc: '123' } }
-              functions << { foo: { xyz: '456' } }
-            end
-
-            assert_equal({
-              function_score: {
-                query: { match: { foo: 'BLAM' } },
-                filter: { term: { bar: 'slam' } },
-                functions: [ { foo: { abc: '123' } }, { foo: { xyz: '456' } } ] } },
-              subject.to_hash)
-          end
-
-          should "set the functions directly" do
-            subject = FunctionScore.new
-            subject.functions = [ {foo: { abc: '123' }} ]
-
-            assert_equal({function_score: { functions: [ {foo: { abc: '123' }} ] }}, subject.to_hash)
-          end
-        end
-      end
-    end
-  end
-end