elasticsearch-dsl-builder 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 206c3398edd90fbfa998b106308ba95da121a9ef
-  data.tar.gz: f7dc3a66f02bbe956d5797ecf90d0cd3938693fe
+  metadata.gz: 6aa1d929fa40df01a07f94c5de9fc34955bc1b28
+  data.tar.gz: 9536873ac5cb305a3b8ea204b90790644122db15
 SHA512:
-  metadata.gz: 252809b487ac6cf57bbaa0f09f36fd62db89f0be7a1f8e7250eaa326f952f7d636f153de7952d2be963a63bb216fef6472d31bfe516d0b678727fa11feb94dc9
-  data.tar.gz: 6ef757b531ada6a76894b4e4787708c31d7ffdb3c045d636812153d4cb515558762debca6c46862374634d67562dd75ccd0260e3e6b382cc2ee1c5963f7f9d0c
+  metadata.gz: a51f818dfed959576d50bf568ae913c67108ed98c89399de4b6fb08c3a60b99831fe7514b73f94585a5f73a44d500cf8d84891efda4764dd5e07237b13ea5bf8
+  data.tar.gz: 0c536b02879489f756f066d3f945394fafa6299e34c78db5074c5196ae8bd85311164639a0b71d478bc88e28502445737b9ba8216adb454e499b7cb8467f2e68

data/.rubocop.yml

@@ -196,3 +196,7 @@ WordArray:
 
 FrozenStringLiteralComment:
   Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - "**/*_spec.rb"

data/Gemfile.lock

@@ -1,13 +1,15 @@
 PATH
   remote: .
   specs:
-    elasticsearch-dsl-builder (0.0.10)
+    elasticsearch-dsl-builder (0.0.11)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.3.0)
     diff-lcs (1.3)
+    docile (1.1.5)
+    json (2.1.0)
     parallel (1.12.0)
     parser (2.4.0.0)
       ast (~> 2.2)
@@ -36,6 +38,11 @@ GEM
       ruby-progressbar (~> 1.7)
       unicode-display_width (~> 1.0, >= 1.0.1)
     ruby-progressbar (1.9.0)
+    simplecov (0.15.1)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
     unicode-display_width (1.3.0)
 
 PLATFORMS
@@ -46,6 +53,7 @@ DEPENDENCIES
   elasticsearch-dsl-builder!
   rspec (= 3.6.0)
   rubocop (= 0.50.0)
+  simplecov (= 0.15.1)
 
 RUBY VERSION
    ruby 2.3.2p217

data/elasticsearch-dsl-builder.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'elasticsearch-dsl-builder'
-  s.version     = '0.0.10'
+  s.version     = '0.0.11'
   s.date        = '2017-10-06'
   s.summary     = 'Library utilizing builder pattern providing Ruby API for the Elasticsearch Query DSL'
   s.description = 'TBD'
@@ -16,7 +16,9 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files  = ['README.md', 'LICENSE']
   s.rdoc_options      = ['--charset=UTF-8']
 
+  s.required_ruby_version = '~> 2.3'
   s.add_development_dependency 'bundler', '1.14.6'
   s.add_development_dependency 'rubocop', '0.50.0'
   s.add_development_dependency 'rspec', '3.6.0'
+  s.add_development_dependency 'simplecov', '0.15.1'
 end

data/lib/elasticsearch_dsl_builder/dsl/search.rb

@@ -6,12 +6,18 @@ module ElasticsearchDslBuilder
         #
         # @return [self, Query]
         def query(query)
+          raise ArgumentError, 'query must extend type Queries::Query' unless query.is_a?(Queries::Query)
+
           @query = query
           self
         end
 
         def aggregation(name, aggregation)
-          @aggregations ||= AggregationsCollection.new
+          name_valid = name.instance_of?(String) || name.instance_of?(Symbol)
+          raise ArgumentError, 'name must be a String or Symbol' unless name_valid
+          raise ArgumentError, 'aggregation must extend Aggregation' unless aggregation.is_a?(Aggregations::Aggregation)
+
+          @aggregations ||= Aggregations::AggregationsCollection.new
           @aggregations[name.to_sym] = aggregation
           self
         end
@@ -23,30 +29,34 @@ module ElasticsearchDslBuilder
         end
 
         def size(value)
+          raise ArgumentError, 'value must be Numeric' unless value.is_a? Numeric
           @size = value
           self
         end
 
         def from(value)
+          raise ArgumentError, 'value must be Numeric' unless value.is_a? Numeric
           @from = value
           self
         end
 
         def search_after(*values)
-          raise ArgunmentError, 'must pass at least 1 value' if values.nil? || values.empty?
+          raise ArgumentError, 'must pass at least 1 value' if values.nil? || values.empty?
           @search_after = values.flatten
           self
         end
 
         def include_fields(*fields)
-          raise ArgunmentError, 'must pass at least 1 field' if fields.nil? || fields.empty?
+          fields_valid = !fields.nil? && !fields.empty? && fields.all? { |f| f.instance_of?(String) }
+          raise ArgumentError, 'must pass at least 1 field' unless fields_valid
           @included_fields ||= []
           @included_fields.concat fields.flatten
           self
         end
 
         def exclude_fields(*fields)
-          raise ArgunmentError, 'must pass at least 1 field' if fields.nil? || fields.empty?
+          fields_valid = !fields.nil? && !fields.empty? && fields.all? { |f| f.instance_of?(String) }
+          raise ArgumentError, 'must pass at least 1 field' unless fields_valid
           @excluded_fields ||= []
           @excluded_fields.concat fields.flatten
           self

data/lib/elasticsearch_dsl_builder/dsl/search/aggregation.rb

@@ -13,6 +13,10 @@ module ElasticsearchDslBuilder
         class Aggregation
           # Defines an aggregation nested in another one
           def aggregation(name, aggregation)
+            name_valid = name.instance_of?(String) || name.instance_of?(Symbol)
+            raise ArgumentError, 'name must be a String or Symbol' unless name_valid
+            raise ArgumentError, 'aggregation must extend Aggregation' unless aggregation.is_a?(Aggregation)
+
             @aggregations ||= AggregationsCollection.new
             @aggregations[name.to_sym] = aggregation
             self

data/lib/elasticsearch_dsl_builder/dsl/search/aggregations/terms.rb

@@ -0,0 +1,44 @@
+module ElasticsearchDslBuilder
+  module DSL
+    module Search
+      module Aggregations
+        class Terms < Aggregation
+          def initialize(field = nil)
+            @type = :terms
+            field(field)
+            super()
+          end
+
+          def field(field)
+            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
+            @field = field
+            self
+          end
+
+          def include(include)
+            include_valid = include.instance_of?(String) ||
+              (include.instance_of?(Array) && include.all? { |i| i.instance_of?(String)})
+            raise ArgumentError, 'include argument must be a String or Array of Strings' unless include_valid
+            @include = include
+            self
+          end
+
+          def exclude(exclude)
+            exclude_valid = exclude.instance_of?(String) ||
+              (exclude.instance_of?(Array) && exclude.all? { |i| i.instance_of?(String)})
+            raise ArgumentError, 'exclude argument must be a String or Array of Strings' unless exclude_valid
+            @exclude = exclude
+            self
+          end
+
+          def to_hash
+            @aggregation = { field: @field }
+            @aggregation.update(include: @include) if @include
+            @aggregation.update(exclude: @exclude) if @exclude
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_dsl_builder/dsl/search/queries/bool.rb

@@ -16,6 +16,7 @@ module ElasticsearchDslBuilder
           end
 
           def minimum_should_match(value)
+            raise ArgumentError, 'minimum_should_match must be Numeric' unless value.is_a?(Numeric)
             @minimum_should_match = value
             self
           end

data/lib/elasticsearch_dsl_builder/dsl/search/queries/exists.rb

@@ -16,8 +16,7 @@ module ElasticsearchDslBuilder
           end
 
           def to_hash
-            @query = {}
-            @query.update(field: @field) if @field
+            @query = { field: @field }
             super
           end
         end

data/lib/elasticsearch_dsl_builder/dsl/search/queries/has_child.rb

@@ -24,8 +24,7 @@ module ElasticsearchDslBuilder
           end
 
           def to_hash
-            @query = {}
-            @query.update(type: @child_type) if @child_type
+            @query = { type: @child_type }
             @query.update(query: @nested_query) if @nested_query
             super
           end

data/lib/elasticsearch_dsl_builder/dsl/search/queries/match.rb

@@ -11,7 +11,8 @@ module ElasticsearchDslBuilder
           end
 
           def field(field)
-            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
+            field_valid = field.instance_of?(String) || field.instance_of?(Symbol)
+            raise ArgumentError, 'field must be a String or Symbol' unless field_valid
             @field = field.to_sym
             self
           end
@@ -23,8 +24,7 @@ module ElasticsearchDslBuilder
           end
 
           def to_hash
-            @query = {}
-            @query.update(@field => @value) if @field && @value
+            @query = { @field => @value }
             super
           end
         end

data/lib/elasticsearch_dsl_builder/dsl/search/queries/multi_match.rb

@@ -10,9 +10,10 @@ module ElasticsearchDslBuilder
             super()
           end
 
-          def fields(fields)
-            valid = fields.instance_of?(Array) && !fields.empty? && fields.all? { |f| f.instance_of?(String) }
-            raise ArgumentError, 'fields must be a non-empty Array of Strings' unless valid
+          def fields(*fields)
+            fields = fields.flatten
+            valid = !fields.empty? && fields.all? { |f| f.instance_of?(String) }
+            raise ArgumentError, 'fields must be array of Strings' unless valid
             @fields = fields
             self
           end

data/lib/elasticsearch_dsl_builder/dsl/search/queries/nested.rb

@@ -23,8 +23,7 @@ module ElasticsearchDslBuilder
           end
 
           def to_hash
-            @query = {}
-            @query.update(path: @path) if @path
+            @query = { path: @path }
             @query.update(query: @nested_query) if @nested_query
             super
           end

data/lib/elasticsearch_dsl_builder/dsl/search/queries/range.rb

@@ -10,8 +10,9 @@ module ElasticsearchDslBuilder
           end
 
           def field(field)
-            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
-            @field = field
+            field_valid = field.instance_of?(String) || field.instance_of?(Symbol)
+            raise ArgumentError, 'field must be a String' unless field_valid
+            @field = field.to_sym
             self
           end
 
@@ -49,8 +50,7 @@ module ElasticsearchDslBuilder
             nested_query.update(lte: @lte) if @lte
             nested_query.update(format: @format) if @format
 
-            @query = {}
-            @query.update(@field => nested_query) unless nested_query.nil? || nested_query.empty?
+            @query = { @field => nested_query }
             super
           end
         end

data/lib/elasticsearch_dsl_builder/dsl/search/queries/term.rb

@@ -5,13 +5,14 @@ module ElasticsearchDslBuilder
         class Term < Query
           def initialize(field = nil, value = nil)
             @type = :term
-            field(field)
-            value(value)
+            field(field) unless field.nil?
+            value(value) unless value.nil?
             super()
           end
 
           def field(field)
-            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
+            field_valid = field.instance_of?(String) || field.instance_of?(Symbol)
+            raise ArgumentError, 'field must be a String or Symbol' unless field_valid
             @field = field.to_sym
             self
           end
@@ -22,8 +23,8 @@ module ElasticsearchDslBuilder
           end
 
           def to_hash
-            @query = {}
-            @query.update(@field => @value) if @field && @value
+            raise InvalidQuery, 'field and value must be provided for Term Query' unless @field && @value
+            @query = { @field => @value }
             super
           end
         end

data/lib/elasticsearch_dsl_builder/dsl/search/queries/terms.rb

@@ -10,22 +10,22 @@ module ElasticsearchDslBuilder
             super()
           end
 
-          def values(values)
-            valid = values.instance_of?(Array) && !values.empty?
-            raise ArgumentError, 'values must be a non-empty Array' unless valid
+          def values(*values)
+            values = values.flatten
+            raise ArgumentError, 'values must be a non-empty Array' if values.empty? || values.any?(&:nil?)
             @values = values
             self
           end
 
           def field(field)
-            raise ArgumentError, 'field must be a String' unless field.instance_of?(String)
-            @field = field
+            field_valid = field.instance_of?(String) || field.instance_of?(Symbol)
+            raise ArgumentError, 'field must be a String' unless field_valid
+            @field = field.to_sym
             self
           end
 
           def to_hash
-            @query = {}
-            @query.update(@field => @values) if @field && @values
+            @query = { @field => @values }
             super
           end
         end

data/lib/elasticsearch_dsl_builder/dsl/search/sort.rb

@@ -10,6 +10,13 @@ module ElasticsearchDslBuilder
 
         # DSL method to specify sorting item
         def by(name, direction = nil)
+          raise ArgumentError, 'name must be non empty String' unless name.instance_of?(String) && !name.empty?
+          direction_valid = direction.nil? ||
+            (direction.instance_of?(String) && !direction.empty? && ['asc', 'desc'].include?(direction.downcase))
+          unless direction.nil?
+            raise ArgumentError, 'direction must be non empty String' unless direction_valid
+          end
+
           @value << (direction ? { name => direction } : name)
           self
         end

data/lib/elasticsearch_dsl_builder/exceptions.rb

@@ -2,6 +2,6 @@ module ElasticsearchDslBuilder
   # @abstact Exceptions raised by ElasticsearchDslBuilder inherit from Error
   class Error < StandardError; end
 
-  # Exception raised when argument type is not supported
-  class UnsupportedArgumentType < Error; end
+  # Exception raised when Queries::Query.to_hash attempts to build invalid query
+  class InvalidQuery < Error; end
 end

data/spec/lib/dsl/search/aggregations/terms_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Aggregations::Terms do
+  it 'should fail if field not valid' do
+    expect { Aggregations::Terms.new(123) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new('field_a').field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if include not valid' do
+    expect { Aggregations::Terms.new('field_a').include(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new('field_a').include({}) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new('field_a').include([1, 2]) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if exclude not valid' do
+    expect { Aggregations::Terms.new('field_a').exclude(nil) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new('field_a').exclude({}) }.to raise_error(ArgumentError)
+    expect { Aggregations::Terms.new('field_a').exclude([1, 2]) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES aggregation hash' do
+    terms = Aggregations::Terms.new('field_a').
+      include('*ball').exclude(%w(baseball racquetball)).
+      aggregation('nested_agg', Aggregations::Terms.new('field_b'))
+    expect(terms.to_hash).to eq(
+                               terms: { field: 'field_a', include: '*ball', exclude: %w(baseball racquetball) },
+                               aggregations: { nested_agg: { terms: { field: 'field_b' } } }
+                             )
+  end
+end

data/spec/lib/dsl/search/queries/bool_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::Bool do
+  it 'should fail if minimum_should_match not Numeric' do
+    expect { Queries::Bool.new.minimum_should_match('invalid') }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if must argument not a query' do
+    expect { Queries::Bool.new.must('invalid') }.to raise_error(ArgumentError)
+    expect { Queries::Bool.new.must({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if must_not argument not a query' do
+    expect { Queries::Bool.new.must_not('invalid') }.to raise_error(ArgumentError)
+    expect { Queries::Bool.new.must_not({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if should argument not a query' do
+    expect { Queries::Bool.new.should('invalid') }.to raise_error(ArgumentError)
+    expect { Queries::Bool.new.should({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if filter argument not a query' do
+    expect { Queries::Bool.new.filter('invalid') }.to raise_error(ArgumentError)
+    expect { Queries::Bool.new.filter({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    bool = Queries::Bool.new.
+      minimum_should_match(1).
+      must(Queries::Term.new(:field_a, 1)).
+      must_not(Queries::Term.new(:field_a, 2)).
+      should(Queries::Exists.new('posted_at')).
+      filter(Queries::Match.new('field_b', 'value'))
+
+    expect(bool.to_hash).to eq(
+      bool: {
+        minimum_should_match: 1,
+        must: [{ term: { field_a: 1 } }],
+        must_not: [{ term: { field_a: 2 } }],
+        should: [{ exists: { field: 'posted_at' } }],
+        filter: [{ match: { field_b: 'value' } }]
+      }
+    )
+  end
+end

data/spec/lib/dsl/search/queries/exists_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::Exists do
+  it 'should fail if field not a String' do
+    expect { Queries::Exists.new(123) }.to raise_error(ArgumentError)
+    expect { Queries::Exists.new(nil) }.to raise_error(ArgumentError)
+    expect { Queries::Exists.new('valid').field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    exists = Queries::Exists.new('field_a')
+    expect(exists.to_hash).to eq(exists: { field: 'field_a' })
+  end
+end

data/spec/lib/dsl/search/queries/function_score_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::FunctionScore do
+  it 'should fail if query argument not a Queries::Query' do
+    expect { Queries::FunctionScore.new.query('invalid') }.to raise_error(ArgumentError)
+    expect { Queries::FunctionScore.new.query({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if score_mode argument not a String' do
+    expect { Queries::FunctionScore.new.score_mode(nil) }.to raise_error(ArgumentError)
+    expect { Queries::FunctionScore.new.score_mode({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if script_score argument not a String' do
+    expect { Queries::FunctionScore.new.script_score(nil) }.to raise_error(ArgumentError)
+    expect { Queries::FunctionScore.new.script_score({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    function_score = Queries::FunctionScore.new.
+      query(Queries::Term.new(:field_a, 'value')).
+      score_mode('sum').
+      script_score("doc['likes'].value")
+
+    expect(function_score.to_hash).to eq(
+      function_score: {
+        query: { term: { field_a: 'value' } },
+        score_mode: 'sum',
+        script_score: { script: "doc['likes'].value" }
+      }
+    )
+  end
+end

data/spec/lib/dsl/search/queries/has_child_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::HasChild do
+  it 'should fail if child_type not a String' do
+    expect { Queries::HasChild.new(123) }.to raise_error(ArgumentError)
+    expect { Queries::HasChild.new(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if query argument not a Queries::Query' do
+    expect { Queries::HasChild.new('child').query('invalid') }.to raise_error(ArgumentError)
+    expect { Queries::HasChild.new('child').query({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    has_child = Queries::HasChild.new('child').query(Queries::Term.new(:field_a, 'value'))
+    expect(has_child.to_hash).to eq(has_child: { type: 'child', query: { term: { field_a: 'value' } } })
+  end
+end

data/spec/lib/dsl/search/queries/has_parent_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::HasParent do
+  it 'should fail if parent_type not a String' do
+    expect { Queries::HasParent.new(123) }.to raise_error(ArgumentError)
+    expect { Queries::HasParent.new(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if score argument not a boolean' do
+    expect { Queries::HasParent.new('parent').score('invalid') }.to raise_error(ArgumentError)
+    expect { Queries::HasParent.new('parent').score({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if query argument not a Queries::Query' do
+    expect { Queries::HasParent.new('parent').query('invalid') }.to raise_error(ArgumentError)
+    expect { Queries::HasParent.new('parent').query({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    has_parent = Queries::HasParent.new('parent').score(true).query(Queries::Term.new(:field_a, 'value'))
+    expect(has_parent.to_hash).to eq(has_parent: { parent_type: 'parent', score: true, query: { term: { field_a: 'value' } } })
+  end
+end

data/spec/lib/dsl/search/queries/match_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::Match do
+  it 'should fail if field not a String or Symbol' do
+    expect { Queries::Match.new(123, 'value') }.to raise_error(ArgumentError)
+    expect { Queries::Match.new(nil, 'value') }.to raise_error(ArgumentError)
+    expect { Queries::Match.new('field_a', 'value').field({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if value argument not a String' do
+    expect { Queries::Match.new('field_a', 123) }.to raise_error(ArgumentError)
+    expect { Queries::Match.new('field_a', nil) }.to raise_error(ArgumentError)
+    expect { Queries::Match.new('field_a', 'value').value({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    match = Queries::Match.new(:field_a, 'value')
+    expect(match.to_hash).to eq(match: { field_a: 'value' })
+  end
+end

data/spec/lib/dsl/search/queries/multi_match_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::MultiMatch do
+  it 'should fail if fields not Array of Strings' do
+    expect { Queries::MultiMatch.new(123, 'value') }.to raise_error(ArgumentError)
+    expect { Queries::MultiMatch.new(nil, 'value') }.to raise_error(ArgumentError)
+    expect { Queries::MultiMatch.new([], 'value') }.to raise_error(ArgumentError)
+    expect { Queries::MultiMatch.new(['field_a'], 'value').fields({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if value argument not a String' do
+    expect { Queries::MultiMatch.new(['field_a'], 123) }.to raise_error(ArgumentError)
+    expect { Queries::MultiMatch.new(['field_a'], nil) }.to raise_error(ArgumentError)
+    expect { Queries::MultiMatch.new(['field_a'], 'value').value({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    match = Queries::MultiMatch.new(['field_a'], 'value')
+    expect(match.to_hash).to eq(multi_match: { fields: ['field_a'], query: 'value' })
+  end
+end

data/spec/lib/dsl/search/queries/nested_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::Nested do
+  it 'should fail if path not a String' do
+    expect { Queries::Nested.new(nil) }.to raise_error(ArgumentError)
+    expect { Queries::Nested.new(123) }.to raise_error(ArgumentError)
+    expect { Queries::Nested.new('path').path(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if query argument not a Queries::Query' do
+    expect { Queries::Nested.new('path').query(nil) }.to raise_error(ArgumentError)
+    expect { Queries::Nested.new('path').query({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    match = Queries::Nested.new('path').query(Queries::Exists.new('field_a'))
+    expect(match.to_hash).to eq(nested: { path: 'path', query: { exists: { field: 'field_a' } } })
+  end
+end

data/spec/lib/dsl/search/queries/range_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::Range do
+  it 'should fail if field not a String' do
+    expect { Queries::Range.new(123) }.to raise_error(ArgumentError)
+    expect { Queries::Range.new(nil) }.to raise_error(ArgumentError)
+    expect { Queries::Range.new([]) }.to raise_error(ArgumentError)
+    expect { Queries::Range.new('field_a').field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if format argument not a String' do
+    expect { Queries::Range.new(:field_a).format(nil) }.to raise_error(ArgumentError)
+    expect { Queries::Range.new('field_a').format(123) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    range = Queries::Range.new(:field_a).
+      format('YYYY-MM').gt('2017-09').gte('2017-09').lt('2017-09').lte('2017-09')
+    expect(range.to_hash).to eq(
+                               range: {
+                                 field_a: {
+                                   gt: '2017-09', gte: '2017-09', lt: '2017-09', lte: '2017-09',
+                                   format: 'YYYY-MM'
+                                 }
+                               }
+                             )
+  end
+end

data/spec/lib/dsl/search/queries/term_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::Term do
+  it 'should fail if field not valid' do
+    expect { Queries::Term.new(123) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail to create hash if invalid query' do
+    expect { Queries::Term.new.to_hash }.to raise_error(ElasticsearchDslBuilder::InvalidQuery)
+    expect { Queries::Term.new(:field_a).to_hash }.to raise_error(ElasticsearchDslBuilder::InvalidQuery)
+  end
+
+  it 'should chain create valid ES query hash' do
+    initialized_term = Queries::Term.new('field_a', 1)
+    chain_term = Queries::Term.new.field(:field_a).value(1)
+
+    [initialized_term, chain_term].each do |term|
+      expect(term.to_hash).to eq(
+        term: {
+          field_a: 1
+        }
+      )
+    end
+  end
+end

data/spec/lib/dsl/search/queries/terms_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Queries::Terms do
+  it 'should fail if field not valid' do
+    expect { Queries::Terms.new(123, [1, 2]) }.to raise_error(ArgumentError)
+    expect { Queries::Terms.new(nil, [1, 2]) }.to raise_error(ArgumentError)
+    expect { Queries::Terms.new(:field_a, [1, 2]).field(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should fail if values not valid' do
+    expect { Queries::Terms.new(:field_a, []) }.to raise_error(ArgumentError)
+    expect { Queries::Terms.new(:field_a, nil) }.to raise_error(ArgumentError)
+    expect { Queries::Terms.new(:field_a, [1]).values(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain create valid ES query hash' do
+    terms = Queries::Terms.new(:field_a, [1, 2])
+    expect(terms.to_hash).to eq({ terms: { field_a: [1, 2] } })
+  end
+end

data/spec/lib/dsl/search/sort_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Sort do
+  it 'should raise error if by not valid' do
+    expect { Sort.new.by(123, 'asc') }.to raise_error(ArgumentError)
+    expect { Sort.new.by('valid', 'not_asc_or_desc') }.to raise_error(ArgumentError)
+    expect { Sort.new.by('valid', 123) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain build array of sort instructions' do
+    sort = Sort.new.
+      by('posted_at', 'desc').
+      by('id').
+      by('updated', 'desc')
+
+    expect(sort.to_hash).to eq([{ 'posted_at' => 'desc' }, 'id', { 'updated' => 'desc' }])
+  end
+end

data/spec/lib/dsl/search_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL::Search::Search do
+  it 'should raise error if query not a Queries::Query' do
+    expect { Search.new.query({}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if sort_by not valid' do
+    expect { Search.new.sort_by(123, 'asc') }.to raise_error(ArgumentError)
+    expect { Search.new.sort_by('valid', 'not_asc_or_desc') }.to raise_error(ArgumentError)
+    expect { Search.new.sort_by('valid', 123) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if size not Numeric' do
+    expect { Search.new.size('invalid') }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if from not Numeric' do
+    expect { Search.new.from('invalid') }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if search_after contains no values' do
+    expect { Search.new.search_after }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if include_fields invalid' do
+    expect { Search.new.include_fields }.to raise_error(ArgumentError)
+    expect { Search.new.include_fields(123) }.to raise_error(ArgumentError)
+    expect { Search.new.include_fields('valid', 123) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if exclude_fields invalid' do
+    expect { Search.new.exclude_fields }.to raise_error(ArgumentError)
+    expect { Search.new.exclude_fields(123) }.to raise_error(ArgumentError)
+    expect { Search.new.exclude_fields('valid', 123) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if aggregation name invalid' do
+    expect { Search.new.aggregation(nil, Aggregations::Terms.new('field_a')) }.to raise_error(ArgumentError)
+    expect { Search.new.aggregation(123, Aggregations::Terms.new('field_a')) }.to raise_error(ArgumentError)
+  end
+
+  it 'should raise error if aggregation doesnt extend Aggregation' do
+    expect { Search.new.aggregation('valid', nil) }.to raise_error(ArgumentError)
+    expect { Search.new.aggregation(:valid, {}) }.to raise_error(ArgumentError)
+  end
+
+  it 'should chain build an ES search' do
+    search = Search.new.
+      query(Queries::Bool.new).
+      sort_by('posted_at', 'desc').
+      size(5).from(2).
+      search_after(2, 1).
+      include_fields('id', 'content').
+      exclude_fields('no_show').
+      aggregation('my_agg', Aggregations::Terms.new('field_a'))
+
+    expect(search.to_hash).to eq(
+      query: { bool: {} },
+      aggregations: { my_agg: { terms: { field: 'field_a' } } },
+      sort: [
+        { 'posted_at' => 'desc' }
+      ],
+      size: 5,
+      from: 2,
+      search_after: [2, 1],
+      _source: {
+        includes: ['id', 'content'],
+        excludes: ['no_show']
+      }
+    )
+  end
+end

data/spec/lib/dsl_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe ElasticsearchDslBuilder::DSL do
+  class SampleDSLUser
+    include ElasticsearchDslBuilder::DSL
+  end
+
+  it 'should include search modules' do
+    expect(SampleDSLUser.included_modules).to include ElasticsearchDslBuilder::DSL
+    expect(SampleDSLUser.included_modules).to include ElasticsearchDslBuilder::DSL::Search
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rspec'
+
+require 'simplecov'
+SimpleCov.start
+
+require 'elasticsearch_dsl_builder/dsl'
+include ElasticsearchDslBuilder::DSL
+
+RSpec.configure do |config|
+  config.fail_fast = 5
+  config.default_formatter = 'documentation'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-dsl-builder
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Marvin Guerra
@@ -52,6 +52,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 3.6.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.15.1
 description: TBD
 email: marvin@marvinguerra.com
 executables: []
@@ -71,6 +85,7 @@ files:
 - lib/elasticsearch_dsl_builder/dsl.rb
 - lib/elasticsearch_dsl_builder/dsl/search.rb
 - lib/elasticsearch_dsl_builder/dsl/search/aggregation.rb
+- lib/elasticsearch_dsl_builder/dsl/search/aggregations/terms.rb
 - lib/elasticsearch_dsl_builder/dsl/search/queries/bool.rb
 - lib/elasticsearch_dsl_builder/dsl/search/queries/exists.rb
 - lib/elasticsearch_dsl_builder/dsl/search/queries/function_score.rb
@@ -86,6 +101,22 @@ files:
 - lib/elasticsearch_dsl_builder/dsl/search/sort.rb
 - lib/elasticsearch_dsl_builder/dsl/version.rb
 - lib/elasticsearch_dsl_builder/exceptions.rb
+- spec/lib/dsl/search/aggregations/terms_spec.rb
+- spec/lib/dsl/search/queries/bool_spec.rb
+- spec/lib/dsl/search/queries/exists_spec.rb
+- spec/lib/dsl/search/queries/function_score_spec.rb
+- spec/lib/dsl/search/queries/has_child_spec.rb
+- spec/lib/dsl/search/queries/has_parent_spec.rb
+- spec/lib/dsl/search/queries/match_spec.rb
+- spec/lib/dsl/search/queries/multi_match_spec.rb
+- spec/lib/dsl/search/queries/nested_spec.rb
+- spec/lib/dsl/search/queries/range_spec.rb
+- spec/lib/dsl/search/queries/term_spec.rb
+- spec/lib/dsl/search/queries/terms_spec.rb
+- spec/lib/dsl/search/sort_spec.rb
+- spec/lib/dsl/search_spec.rb
+- spec/lib/dsl_spec.rb
+- spec/spec_helper.rb
 homepage: http://rubygems.org/gems/hola
 licenses:
 - MIT
@@ -97,9 +128,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -112,4 +143,20 @@ signing_key:
 specification_version: 4
 summary: Library utilizing builder pattern providing Ruby API for the Elasticsearch
   Query DSL
-test_files: []
+test_files:
+- spec/lib/dsl/search/aggregations/terms_spec.rb
+- spec/lib/dsl/search/queries/bool_spec.rb
+- spec/lib/dsl/search/queries/exists_spec.rb
+- spec/lib/dsl/search/queries/function_score_spec.rb
+- spec/lib/dsl/search/queries/has_child_spec.rb
+- spec/lib/dsl/search/queries/has_parent_spec.rb
+- spec/lib/dsl/search/queries/match_spec.rb
+- spec/lib/dsl/search/queries/multi_match_spec.rb
+- spec/lib/dsl/search/queries/nested_spec.rb
+- spec/lib/dsl/search/queries/range_spec.rb
+- spec/lib/dsl/search/queries/term_spec.rb
+- spec/lib/dsl/search/queries/terms_spec.rb
+- spec/lib/dsl/search/sort_spec.rb
+- spec/lib/dsl/search_spec.rb
+- spec/lib/dsl_spec.rb
+- spec/spec_helper.rb