elasticsearch-dsl 0.1.6 → 0.1.10

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

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