elasticsearch-dsl 0.0.0 → 0.1.0

data/test/unit/filters/regexp_test.rb

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

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

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

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

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

@@ -0,0 +1,107 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class BoolTest < ::Test::Unit::TestCase
+        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 "take a block with multiple methods" do
+            subject = Bool.new do
+              must     { match foo: 'bar' }
+              must_not { match moo: 'bam' }
+              should   { match xoo: 'bax' }
+            end
+
+            assert_equal( { bool:
+                            { must:     [ {match: { foo: 'bar' }} ],
+                              must_not: [ {match: { moo: 'bam' }} ],
+                              should:   [ {match: { xoo: 'bax' }} ]
+                            }
+                          },
+                          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 "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

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

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class CommonTest < ::Test::Unit::TestCase
+        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

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    module Queries
+      class ConstantScoreTest < ::Test::Unit::TestCase
+        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

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