elasticated 2.5.5 → 3.0.0

data/lib/elasticated/block_evaluation.rb

@@ -1,15 +0,0 @@
-module Elasticated
-  module BlockEvaluation
-
-    def evaluate(block=nil, obj=nil)
-      return unless block
-      obj ||= self
-      if block.parameters.empty?
-        obj.instance_exec &block
-      else
-        block.call obj
-      end
-    end
-
-  end
-end

data/lib/elasticated/clonable.rb

@@ -1,58 +0,0 @@
-module Elasticated
-  module Clonable
-
-    def clone
-      ret = super
-      instance_variables.each do |instance_variable|
-        value = instance_variable_get instance_variable
-        value = case value.class
-        when Array
-          clone_array value
-        when Hash
-          Helpers.hash_deep_dup value
-        else
-          value.clone
-        end
-        ret.instance_variable_set instance_variable, value
-      end
-      ret
-    end
-
-    def ==(other_entity)
-      other_entity.class == self.class &&
-      instance_variables.all? do |instance_variable|
-        next true if instance_variable == :@_subaggregations # Subaggregated
-        value = instance_variable_get instance_variable
-        other_value = other_entity.instance_variable_get instance_variable
-        case other_value.class
-        when Array
-          compare_arrays value, other_value
-        else
-          other_value == value
-        end
-      end
-    end
-
-    private
-
-    def clone_array(array)
-      array.map do |element|
-        case element.class
-        when Hash
-          Helpers.hash_deep_dup element
-        when Array
-          clone_array element
-        else
-          element.clone
-        end
-      end
-    end
-
-    def compare_arrays(array_a, array_b)
-      array_a.all? do |element|
-        array_b.include? element
-      end && array_a.size == array_b.size
-    end
-
-  end
-end

data/lib/elasticated/configurable.rb

@@ -1,20 +0,0 @@
-module Elasticated
-  module Configurable
-
-    def self.delegated(attr_name)
-      define_method attr_name do
-        instance_variable_get("@#{attr_name}") || Configuration.send(attr_name)
-      end
-      define_method "#{attr_name}=" do |value|
-        instance_variable_set "@#{attr_name}", value
-      end
-    end
-
-    delegated :logger
-    alias_method :log, :logger
-    delegated :scroll_expiration_time
-    delegated :scroll_page_size
-    delegated :search_page_size
-
-  end
-end

data/lib/elasticated/date_delimiter_factory.rb

@@ -1,123 +0,0 @@
-module Elasticated
-  class DateDelimiterFactory
-
-    def create(empty_delimiter, query_delimiters, opts={})
-      klass = Delimiters::DateFieldDelimiter
-      field = empty_delimiter.field_name
-      filter_name = empty_delimiter.filter_name
-      field_since = "#{field}_since".to_sym
-      field_until = "#{field}_until".to_sym
-      filter_since = "#{filter_name}_since".to_sym
-      filter_until = "#{filter_name}_until".to_sym
-      field_term = field.to_sym
-      delimit_by = opts.fetch(:delimit_by, [:conditions])
-
-      case delimit_by
-      when []
-        _since = nil
-        _until = nil
-      when [:conditions]
-        if has_terms?(query_delimiters, :conditions, field_term)
-          _since = since_condition_delimiters(query_delimiters.fetch(:conditions, []), field_term)
-          _until = until_condition_delimiters(query_delimiters.fetch(:conditions, []), field_term)
-        else
-          _since = since_condition_delimiters(query_delimiters.fetch(:conditions, []), field_since)
-          _until = until_condition_delimiters(query_delimiters.fetch(:conditions, []), field_until)
-        end
-      when [:aggregations]
-        if has_terms?(query_delimiters, :aggregations, field_term)
-          _since = since_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_term)
-          _until = until_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_term)
-        else
-          _since = since_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_since)
-          _until = until_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_until)
-        end
-      when [:conditions, :aggregations]
-        if has_terms?(query_delimiters, :conditions, field_term)
-          _since = since_condition_delimiters(query_delimiters.fetch(:conditions, []), field_term)
-          _until = until_condition_delimiters(query_delimiters.fetch(:conditions, []), field_term)
-          _since = since_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_term) if _since.nil?
-          _until = until_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_term) if _until.nil?
-        else
-          condition_since = since_condition_delimiters(query_delimiters.fetch(:conditions, []), field_since)
-          condition_until = until_condition_delimiters(query_delimiters.fetch(:conditions, []), field_until)
-          aggregation_since = since_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_since)
-          aggregation_until = until_aggregation_delimiters(query_delimiters.fetch(:aggregations, []), field_until)
-          _since = condition_since || aggregation_since
-          _until = condition_until || aggregation_until
-        end
-      end
-
-      filtered_empty_delimiter = {
-        filter_since => _since,
-        filter_until => _until
-      }.select { |_, v| not v.nil? }
-
-      klass.new(filtered_empty_delimiter.merge(field: field, as: filter_name))
-    end
-
-    private
-
-    def since_aggregation_delimiters(all_aggregation_delimiters, field_since)
-      return nil if missing_field?(all_aggregation_delimiters, field_since)
-      return min_since_delimiter(all_aggregation_delimiters, field_since) if all_aggregation_delimiters.any? { |delimiter| delimiter[field_since].is_a? Array }
-      since_delimiters = all_aggregation_delimiters.min_by { |delimiter| delimiter[field_since] }
-      since_delimiters.nil? ? nil : since_delimiters[field_since]
-    end
-
-    def since_condition_delimiters(all_condition_delimiters, field_since)
-      condition_delimiterts_with_field = all_condition_delimiters.select { |delimiter| delimiter[field_since] }
-      return min_since_delimiter(condition_delimiterts_with_field, field_since) if condition_delimiterts_with_field.any? { |delimiter| delimiter[field_since].is_a? Array }
-      since_delimiters = condition_delimiterts_with_field.min_by { |delimiter| delimiter[field_since] }
-      since_delimiters.nil? ? nil : since_delimiters[field_since]
-    end
-
-    def min_since_delimiter(delimiters, field)
-      array_delimiters = delimiters.select { |delimiter| delimiter[field].is_a? Array }
-      min_array_delimiter = array_delimiters.min_by { |delimiter| delimiter[field].min }
-      individual_delimiters = delimiters.select { |delimiter| not delimiter[field].is_a? Array }
-      min_individual_delimiter = individual_delimiters.min_by { |delimiter| delimiter[field] }
-      if not (min_array_delimiter.nil? or min_individual_delimiter.nil?)
-        min_array_delimiter > min_individual_delimiter ? min_individual_delimiter : min_array_delimiter
-      else
-        return min_array_delimiter[field].min if min_array_delimiter and min_array_delimiter[field].min
-        min_individual_delimiter
-      end
-    end
-
-    def until_aggregation_delimiters(all_aggregation_delimiters, field_until)
-      return nil if missing_field?(all_aggregation_delimiters, field_until)
-      return max_until_delimiter(all_aggregation_delimiters, field_until) if all_aggregation_delimiters.any? { |delimiter| delimiter[field_until].is_a? Array }
-      until_delimiters = all_aggregation_delimiters.max_by { |delimiter| delimiter[field_until] }
-      until_delimiters.nil? ? nil : until_delimiters[field_until]
-    end
-
-    def until_condition_delimiters(all_condition_delimiters, field_until)
-      condition_delimiterts_with_field = all_condition_delimiters.select { |delimiter| delimiter[field_until] }
-      return max_until_delimiter(condition_delimiterts_with_field, field_until) if condition_delimiterts_with_field.any? { |delimiter| delimiter[field_until].is_a? Array }
-      until_delimiters = condition_delimiterts_with_field.max_by { |delimiter| delimiter[field_until] }
-      until_delimiters.nil? ? nil : until_delimiters[field_until]
-    end
-
-    def max_until_delimiter(delimiters, field)
-      array_delimiters = delimiters.select { |delimiter| delimiter[field].is_a? Array }
-      max_array_delimiter = array_delimiters.max_by { |delimiter| delimiter[field].max }
-      individual_delimiters = delimiters.select { |delimiter| not delimiter[field].is_a? Array }
-      max_individual_delimiter = individual_delimiters.max_by { |delimiter| delimiter[field] }
-      if not (max_array_delimiter.nil? or max_individual_delimiter.nil?)
-        max_array_delimiter > max_individual_delimiter ? max_individual_delimiter : max_array_delimiter
-      else
-        return max_array_delimiter[field].max if max_array_delimiter and max_array_delimiter[field].max
-        max_individual_delimiter
-      end
-    end
-
-    def missing_field?(delimiters, field)
-      delimiters.any? { |delimiter| not delimiter.has_key?(field) }
-    end
-
-    def has_terms?(delimiters, condition_or_agg, field)
-      delimiters.fetch(condition_or_agg, []).any? { |delimiter| delimiter[field] }
-    end
-  end
-end

data/lib/elasticated/delimiter_visitor.rb

@@ -1,53 +0,0 @@
-module Elasticated
-  class DelimiterVisitor
-
-    def visit_query(query)
-      {
-        conditions: query._conditions.accept_visitor(self) + query._filter_conditions.accept_visitor(self),
-        aggregations: query._aggregations.accept_visitor(self)
-      }
-    end
-
-    def visit_query_conditions(query_conditions)
-      query_conditions._must.accept_visitor(self)
-    end
-
-    def visit_boolean_clause(boolean_clause)
-      boolean_clause.conditions.flat_map { |c| c.accept_visitor(self) }
-    end
-
-    def visit_condition(condition)
-      {}
-    end
-
-    def visit_terms(terms_condition)
-      { terms_condition.field => terms_condition.values }
-    end
-
-    def visit_range(range_condition)
-      field = range_condition.field
-      minimum_value = range_condition.body[:gt] || range_condition.body[:gte]
-      maximum_value = range_condition.body[:lt] || range_condition.body[:lte]
-
-      {}.tap do |h|
-        h["#{field}_since".to_sym] = minimum_value if minimum_value
-        h["#{field}_until".to_sym] = maximum_value if maximum_value
-      end
-    end
-
-    def visit_query_aggregations(query_aggregations)
-      query_aggregations._aggregations.inject([]) do |acum, aggregation|
-        acum + [aggregation.accept_visitor(self).inject(:merge)].compact
-      end
-    end
-
-    def visit_aggregation(aggregation)
-      []
-    end
-
-    def visit_filter_aggregation(filter_aggregation)
-      filter_aggregation._subaggregations._conditions.accept_visitor(self).flatten(1)
-    end
-
-  end
-end

data/lib/elasticated/inspectionable.rb

@@ -1,9 +0,0 @@
-module Elasticated
-  module Inspectionable
-
-    def inspect
-      "#<#{self.class.name}:#{build}>"
-    end
-
-  end
-end

data/lib/elasticated/strategy_params_for_query_service.rb

@@ -1,14 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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)
-      first_delimiter = delimiters.first || {}
-      delimiters.inject(first_delimiter) do |mcd_acum, delimiter|
-        merge_aggregation_repeated_keys(mcd_acum, delimiter, field)
-      end
-    end
-
-    def extract_condition_delimiters(delimiters, field)
-      first_delimiter = delimiters.first || {}
-      delimiters.inject(first_delimiter) 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/spec/delimiter_factory_spec.rb

@@ -1,399 +0,0 @@
-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 create term delimiter with two account from aggregation delimiter when delimiting by aggregations' do
-      options = {delimit_by: [:aggregations]}
-      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 create term delimiter with no accounts from aggregation delimiter when there are at least one condition delimiters' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      query_delimiters = { conditions: [{account: [31]}], aggregations: [{account: [39]}, {account: [40]}] }
-      expected = Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts, values: [31])
-      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 create term delimiter with two accounts from aggregation delimiter when there are no condition delimiters' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      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 create term delimiter with two accounts from condition delimiters when there are not aggregation delimiters' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      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, 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