elasticated 2.4.0 → 2.5.0

data/lib/elasticated/partitioned_repository.rb

@@ -13,13 +13,18 @@ module Elasticated
       client.refresh_indices affected_indices
     end
 
+    # override
+    def execute_aggregations(query, opts={})
+      super(query, {delimit_by: [:conditions, :aggregations]}.merge(opts))
+    end
+
     protected
 
     # override
     def execute(action, query, opts={})
-      affected_indices = affected_indices_for query
+      affected_indices = affected_indices_for query, opts
       affected_indices = affected_indices*','
-      super action, query, opts.merge(index: affected_indices)
+      super action, query, opts.merge(index: affected_indices).reject { |k,_| k == :delimit_by }
     end
 
     # override
@@ -34,8 +39,8 @@ module Elasticated
       super action, query, opts.merge(index: affected_index)
     end
 
-    def affected_indices_for(query)
-      index_selector.indices_for_query(query)
+    def affected_indices_for(query, opts={})
+      index_selector.indices_for_query(query, opts)
     end
 
   end

data/lib/elasticated/query.rb

@@ -150,11 +150,10 @@ module Elasticated
       _aggregations.parse response
     end
 
-    # delimiters
-
-    def fill_delimiter(field_delimiter)
-      _conditions.fill_delimiter field_delimiter
-      _filter_conditions.fill_delimiter field_delimiter
+    # visitor methods
+    
+    def accept_visitor(visitor)
+      visitor.visit_query(self)
     end
 
     # conditions & filter shorthands

data/lib/elasticated/query_aggregations.rb

@@ -27,12 +27,16 @@ module Elasticated
       end
     end
 
-    def merge! other_query_aggs
+    def merge!(other_query_aggs)
       other_query_aggs._aggregations.each do |other_aggregation|
         add_aggregation other_aggregation
       end
     end
 
+    def accept_visitor(visitor)
+      visitor.visit_query_aggregations(self)
+    end
+
     private
 
     def get_aggregation_class(agg_name)

data/lib/elasticated/query_conditions.rb

@@ -11,10 +11,8 @@ module Elasticated
       self._should = BooleanClause.new
     end
 
-    # delimiters
-
-    def fill_delimiter(field_delimiter)
-      _must.fill_delimiter field_delimiter
+    def accept_visitor(visitor)
+      visitor.visit_query_conditions(self)
     end
 
     # conditions

data/lib/elasticated/strategy_params_for_query_service.rb

@@ -0,0 +1,14 @@
+module Elasticated
+  class StrategyParamsForQueryService
+
+    def strategy_params_for_query(empty_delimiters, query, opts={})
+      query_delimiters = query.accept_visitor(Elasticated.delimiter_visitor)
+
+      empty_delimiters.inject Hash.new do |params, empty_delimiter|
+        built_delimiter = empty_delimiter.completed_with(query_delimiters, opts)
+        params.merge built_delimiter.build_strategy_params
+      end
+    end
+
+  end
+end

data/lib/elasticated/term_delimiter_factory.rb

@@ -0,0 +1,71 @@
+module Elasticated
+  class TermDelimiterFactory
+
+    def create(empty_delimiter, query_delimiters, opts={})
+      klass = Delimiters::TermFieldDelimiter
+      field = empty_delimiter.field_name
+      delimit_by = opts.fetch(:delimit_by, [:conditions])
+
+      case delimit_by
+      when []
+        relevant_delimiters = []
+      when [:conditions]
+        relevant_delimiters = relevant_field_delimiters(query_delimiters.fetch(:conditions), field)
+      when [:aggregations]
+        relevant_delimiters = relevant_field_delimiters(query_delimiters.fetch(:aggregations), field)
+      else
+        condition_delimiters   = query_delimiters.fetch(:conditions)
+        aggregation_delimiters = query_delimiters.fetch(:aggregations)
+        relevant_delimiters    = [merge_delimiters(condition_delimiters, aggregation_delimiters,field)]
+      end
+
+      values = empty_delimiter.values + relevant_delimiters.flat_map(&:values).flatten(1)
+      klass.new(values: values, field: field, as: empty_delimiter.filter_name)
+    end
+
+
+    def relevant_field_delimiters(all_delimiters, field)
+      all_delimiters.each_with_object(Array.new) do |delimiter, array|
+        field_delimiter = delimiter.select { |k,_| k == field }
+        array << field_delimiter unless field_delimiter.empty?
+      end
+    end
+
+    def merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      aggregation_delimiters_by_field = extract_aggregation_delimiters(aggregation_delimiters, field)
+      condition_delimiters_by_field   = extract_condition_delimiters(condition_delimiters,field)
+      aggregation_delimiters_by_field.merge condition_delimiters_by_field
+    end
+
+    private
+
+    def extract_aggregation_delimiters(delimiters, field)
+      delimiters.inject(delimiters.first) do |mcd_acum, delimiter|
+        merge_aggregation_repeated_keys(mcd_acum, delimiter, field)
+      end
+    end
+
+    def extract_condition_delimiters(delimiters, field)
+      delimiters.inject(delimiters.first) do |mcd_acum, delimiter|
+        merge_condition_repeated_keys(mcd_acum, delimiter, field)
+      end
+    end
+
+    def merge_aggregation_repeated_keys(this, another_hash, field)
+      this_field = this[field]
+      another_hash_field = another_hash[field]
+      return {} if this_field.nil? or another_hash_field.nil?
+      {field => (this_field + another_hash_field).uniq}
+    end
+
+    def merge_condition_repeated_keys(this, another_hash, field)
+      this_field = this[field]
+      another_hash_field = another_hash[field]
+      return this if another_hash_field.nil? and not this_field.nil?
+      return (another_hash.select { |(k,v)| k == field }) if this_field.nil? and not another_hash_field.nil?
+      return {} if another_hash_field.nil? and this_field.nil?
+      {field => (this_field + another_hash_field).uniq}
+    end
+
+  end
+end

data/lib/version.rb

@@ -1,9 +1,13 @@
 module Elasticated
-  VERSION = '2.4.0'
+  VERSION = '2.5.0'
 end
 
 # Changelog
 
+# 2.5.0
+# Ahora los delimiters son inmutables
+# Se puede delimitar por aggregations
+
 # 2.4.0
 # Ahora se puede ordenar un search por un campo, script o hash custom
 

data/spec/date_field_delimiter_spec.rb

@@ -14,56 +14,17 @@ module Elasticated
       end
 
       it "should delimit by one term" do
-        delimiter.add_term :created_at, '2016-07-19'
-        params = delimiter.build_strategy_params
+        completed_delimiter = delimiter.completed_with conditions: [{created_at: '2016-07-19'}]
+        params = completed_delimiter.build_strategy_params
         expect(params).to eq date: '2016-07-19'
       end
 
       it "should delimit by multiple terms" do
-        delimiter.add_term :created_at, '2017-03-30'
-        delimiter.add_term :created_at, '2017-03-25'
-        delimiter.add_term :created_at, '2017-03-27'
-        params = delimiter.build_strategy_params
+        completed_delimiter = delimiter.completed_with conditions: [{created_at: '2017-03-30'},{created_at: '2017-03-25'},{created_at: '2017-03-27'}]
+        params = completed_delimiter.build_strategy_params
         expect(params).to eq date_since: '2017-03-25', date_until: '2017-03-30'
       end
 
-      it "should delimit by a min date" do
-        delimiter.set_minimum :created_at, '2016-07-19'
-        params = delimiter.build_strategy_params
-        expect(params).to eq date_since: '2016-07-19'
-      end
-
-      it "should delimit by a max date" do
-        delimiter.set_maximum :created_at, '2016-07-19'
-        params = delimiter.build_strategy_params
-        expect(params).to eq date_until: '2016-07-19'
-      end
-
-      it "should delimit by a range of dates" do
-        delimiter.set_minimum :created_at, '2016-07-19'
-        delimiter.set_maximum :created_at, '2016-07-21'
-        params = delimiter.build_strategy_params
-        expect(params).to eq date_since: '2016-07-19', date_until: '2016-07-21'
-      end
-
-      it "should delimit by the most restricted range of dates" do
-        delimiter.set_minimum :created_at, '2016-07-19'
-        delimiter.set_maximum :created_at, '2016-07-25'
-        delimiter.set_minimum :created_at, '2016-07-17' # ignored minimum
-        delimiter.set_maximum :created_at, '2016-07-24'
-        delimiter.set_maximum :created_at, '2016-07-26' # ignored maximum
-        params = delimiter.build_strategy_params
-        expect(params).to eq date_since: '2016-07-19', date_until: '2016-07-24'
-      end
-
-      it "should prefer a term over a range of dates" do
-        delimiter.set_minimum :created_at, '2016-07-19'
-        delimiter.set_maximum :created_at, '2016-07-21'
-        delimiter.add_term :created_at, '2016-07-20'
-        params = delimiter.build_strategy_params
-        expect(params).to eq date: '2016-07-20'
-      end
-
     end
   end
 end

data/spec/delimiter_factory_spec.rb

@@ -0,0 +1,366 @@
+require_relative 'spec_helper'
+
+module Elasticated
+  describe TermDelimiterFactory do
+    let(:empty_delimiter){ Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts) }
+
+    it "should create empty term delimiter from empty conditions" do
+      query_delimiters = { conditions: [], aggregations: []}
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts, values: [])
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create empty term delimiter from empty condition delimiter definition and none aggregation delimiters' do
+      query_delimiters = { conditions: [{}], aggregations: [] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts, values: [])
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{}, {}], aggregations: [] }
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create term delimiter with account from condition delimiter' do
+      query_delimiters = { conditions: [{account: [39]}], aggregations: [] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts, values: [39])
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create term delimiter with account from condition delimiter with other empty definitions' do
+      query_delimiters = { conditions: [{account: [39]}, {}, {}], aggregations: [] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts, values: [39])
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{account: [39,40]}, {}, {}], aggregations: [] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts, values: [39,40])
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create term delimiter with two accounts from different condition delimiters' do
+      query_delimiters = { conditions: [{account: [39]}, {account: 40}, {}], aggregations: [] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts, values: [39, 40])
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create term delimiter with two accounts from different condition delimiters with one different field in one delimiter' do
+      query_delimiters = { conditions: [{account: [39], tags: ["a_tag"]}, {account: 40}, {}], aggregations: [] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts, values: [39, 40])
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{account: [39], tags: ["a_tag"]}, {account: 40, tags: ["another_tag"]}, {}], aggregations: [] }
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create term delimiter with account from aggregation delimiter with no condition delimiters' do
+      options = {delimit_by: [:aggregations]}
+      query_delimiters = { conditions: [{}], aggregations: [{account: [39]}] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts, values: [39])
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{}], aggregations: [{account: [39]}, {account: [40]}] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts, values: [39, 40])
+      actual = Elasticated.term_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should merge empty delimiters' do
+      condition_delimiters = [{}]
+      aggregation_delimiters = [{}]
+      field = :account
+      expected = {}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge empty condition delimiter with one aggregation delimiter' do
+      condition_delimiters = [{}]
+      aggregation_delimiters = [{account: [39]}]
+      field = :account
+      expected = {account: [39]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge empty condition delimiter with two aggregation delimiters' do
+      condition_delimiters = [{}]
+      aggregation_delimiters = [{account: [39]}, {account: [40]}]
+      field = :account
+      expected = {account: [39, 40]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge empty condition delimiter with two different aggregation delimiters' do
+      condition_delimiters = [{}]
+      aggregation_delimiters = [{account: [39]}, {tags: ["a_tag"]}]
+      field = :account
+      expected = {}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+      
+      aggregation_delimiters = [{tags: ["a_tag"]}, {account: [39]}]
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge empty condition delimiter with two equal aggregation delimiters and one different' do
+      condition_delimiters = [{}]
+      aggregation_delimiters = [{account: [39]}, {account: [40], tags: ["a_tag"]}]
+      field = :account
+      expected = {account: [39, 40]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge one condition delimiter with empty aggregation delimiters' do
+      condition_delimiters = [{account: [39]}]
+      aggregation_delimiters = [{}]
+      field = :account
+      expected = {account: [39]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge two condition delimiter with empty aggregation delimiters' do
+      condition_delimiters = [{account: [39]}, {account: [40]}]
+      aggregation_delimiters = [{}]
+      field = :account
+      expected = {account: [39, 40]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge two different condition delimiters with empty aggregation delimiters' do
+      condition_delimiters = [{account: [39]}, {tags: ["a_tag"]}]
+      aggregation_delimiters = [{}]
+      field = :account
+      expected = {account: [39]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+
+      condition_delimiters = [{tags: ["a_tag"]}, {account: [39]}]
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge two equal and one different condition delimiters with empty delimiters' do
+      condition_delimiters = [{account: [39]}, {account: [40], tags: ["a_tag"]}]
+      aggregation_delimiters = [{}]
+      field = :account
+      expected = {account: [39, 40]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+      
+      condition_delimiters = [{tags: ["a_tag"], account: [40]}, {account: [39]}]
+      expected = {account: [40, 39]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge one condition delimiter with one aggregation delimiter of a different field' do
+      condition_delimiters = [{account: [39]}]
+      aggregation_delimiters = [{tags: ["a_tag"]}]
+      field = :account
+      expected = {account: [39]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge one condition delimiter with one aggregation delimiter of the same field' do
+      condition_delimiters = [{account: [39]}]
+      aggregation_delimiters = [{account: [40]}]
+      field = :account
+      expected = {account: [39]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+    it 'should merge two condition delimiter of different field with one aggregation delimiter of another field' do
+      condition_delimiters = [{account: [39]}, {groups: ["a_group"]}]
+      aggregation_delimiters = [{tags: ["a_tag"]}]
+      field = :account
+      expected = {account: [39]}
+      actual = Elasticated.term_delimiter_factory.merge_delimiters(condition_delimiters, aggregation_delimiters, field)
+      expect(actual).to eq(expected)
+    end
+
+  end
+
+  describe DateDelimiterFactory do
+    let(:empty_delimiter){ Elasticated::Delimiters::DateFieldDelimiter.new(field: :date) }
+    let(:term_empty_delimiter){ Elasticated::Delimiters::TermFieldDelimiter.new(field: :date) }
+
+    it "should create empty date delimiter from empty conditions" do
+      query_delimiters = { conditions: [], aggregations: []}
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :date)
+      actual = Elasticated.term_delimiter_factory.create(term_empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create empty date delimiter from empty condition delimiter definition and none aggregation delimiters' do
+      query_delimiters = { conditions: [{}], aggregations: [] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :date)
+      actual = Elasticated.term_delimiter_factory.create(term_empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{}, {}], aggregations: [] }
+      actual = Elasticated.term_delimiter_factory.create(term_empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create date delimiter from condition delimiter' do
+      query_delimiters = { conditions: [{date: ['2017-05-26']}], aggregations: [] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :date, values: ['2017-05-26'])
+      actual = Elasticated.term_delimiter_factory.create(term_empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_since: '2017-05-26'}], aggregations: [] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_until: '2017-05-26'}], aggregations: [] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_until: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    
+      query_delimiters = { conditions: [{date_since: '2017-05-26', date_until: '2017-05-26'}], aggregations: [] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-26', date_until: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create date delimiter from many condition delimiters' do
+      query_delimiters = { conditions: [{date: ['2017-05-26']}, {date: ['2017-05-27']}, {date: ['2017-05-25']}], aggregations: [] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :date, values: ['2017-05-26', '2017-05-27', '2017-05-25'])
+      actual = Elasticated.term_delimiter_factory.create(term_empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_since: '2017-05-26'}, {date_since: '2017-05-25'}, {date_since: '2017-05-27'}], aggregations: [] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-25')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_until: '2017-05-26'}, {date_until: '2017-05-25'}, {date_until: '2017-05-27'}], aggregations: [] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_until: '2017-05-27')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_since: '2017-05-25', date_until: '2017-05-26'}, {date_since: '2017-05-27', date_until: '2017-05-28'}], aggregations: [] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-25', date_until: '2017-05-28')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create date delimiter from aggregation delimiters' do
+      options = {delimit_by: [:aggregations]}
+      query_delimiters = { conditions: [{}], aggregations: [{date_since: '2017-05-26'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [], aggregations: [{date_since: '2017-05-26'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [], aggregations: [{date_until: '2017-05-26'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_until: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    
+      query_delimiters = { conditions: [], aggregations: [{date_since: '2017-05-26', date_until: '2017-05-26'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-26', date_until: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create date delimiter from many aggregation delimiters' do
+      options = {delimit_by: [:aggregations]}
+      query_delimiters = { conditions: [], aggregations: [{date: ['2017-05-26']}, {date: ['2017-05-27']}, {date: ['2017-05-25']}] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :date, values: ['2017-05-26', '2017-05-27', '2017-05-25'])
+      actual = Elasticated.term_delimiter_factory.create(term_empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [], aggregations: [{date_since: '2017-05-26'}, {date_since: '2017-05-25'}, {date_since: '2017-05-27'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-25')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [], aggregations: [{date_until: '2017-05-26'}, {date_until: '2017-05-25'}, {date_until: '2017-05-27'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_until: '2017-05-27')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [], aggregations: [{date_since: '2017-05-25', date_until: '2017-05-26'}, {date_since: '2017-05-27', date_until: '2017-05-28'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-25', date_until: '2017-05-28')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [], aggregations: [{date_since: '2017-05-25'}, {date_until: '2017-05-28'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create date delimiter from condition and aggregation delimiters' do
+      options = {delimit_by: [:conditions, :aggregations]}
+      query_delimiters = { conditions: [{date: ['2017-05-26']}, {date: ['2017-05-27']}], aggregations: [{date: ['2017-05-25']}] }
+      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :date, values: ['2017-05-26', '2017-05-27'])
+      actual = Elasticated.term_delimiter_factory.create(term_empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_since: '2017-05-26'}], aggregations: [{date_since: '2017-05-25'}, {date_since: '2017-05-27'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_until: '2017-05-26'}, {date_until: '2017-05-25'}], aggregations: [{date_until: '2017-05-27'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_until: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_since: '2017-05-25', date_until: '2017-05-26'}], aggregations: [{date_since: '2017-05-27', date_until: '2017-05-28'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-25', date_until: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_until: '2017-05-28'}], aggregations: [{date_since: '2017-05-25'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-25', date_until: '2017-05-28')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [], aggregations: [{date_since: '2017-05-27', date_until: '2017-05-28'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-27', date_until: '2017-05-28')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_since: '2017-05-26'}], aggregations: [{date_since: '2017-05-27', date_until: '2017-05-28'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-26', date_until: '2017-05-28')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+
+      query_delimiters = { conditions: [{date_since: '2017-05-26'}], aggregations: [{date_since: '2017-05-27', date_until: '2017-05-28'}, {date_since: '2017-05-27'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-26')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+
+    it 'should create date delimiter from condition and aggregation delimiters when condition delimiter has many different filters' do
+      options = {delimit_by: [:conditions, :aggregations]}
+      query_delimiters = { conditions: [{date_since: '2017-05-26'}, {date_until: '2017-05-31'}], aggregations: [{date_since: '2017-05-27', date_until: '2017-05-28'}, {date_since: '2017-05-27'}] }
+      expected = Elasticated::Delimiters::DateFieldDelimiter.new(field: :date, date_since: '2017-05-26', date_until: '2017-05-31')
+      actual = Elasticated.date_delimiter_factory.create(empty_delimiter, query_delimiters, options)
+      expect(actual.build_strategy_params).to eq(expected.build_strategy_params)
+    end
+  end
+end