elasticated 2.5.5 → 3.0.0

data/spec/strategy_params_for_query_service_spec.rb

@@ -1,387 +0,0 @@
-require_relative 'spec_helper'
-module Elasticated
-
-  describe StrategyParamsForQueryService do
-    let(:query){ Query.new }
-    let(:service){StrategyParamsForQueryService.new}
-    
-    it 'should create empty delimiter' do
-      delimiters = []
-      expected = {}
-      actual = service.strategy_params_for_query(delimiters, query)
-      expect(actual).to eq expected
-      
-      delimiters = [Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts)]
-      actual = service.strategy_params_for_query(delimiters,query)
-      expect(actual).to eq expected
-
-      delimiters = [
-        Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts),
-        Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)
-      ]
-      actual = service.strategy_params_for_query(delimiters,query)
-      expect(actual).to eq expected
-    end
-
-    it 'should create term dalimiter with a date' do
-      delimiters = [Elasticated::Delimiters::TermFieldDelimiter.new(field: :date)]
-      query.filter {equal :date, '2017-05-28'}
-      expected = {date: ['2017-05-28']}
-      actual = service.strategy_params_for_query(delimiters, query)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date since' do
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {greater_than :date, '2017-05-28'}
-      expected = {date_since: '2017-05-28'}
-      actual = service.strategy_params_for_query(delimiters, query)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date until' do
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {less_equal :date, '2017-05-30'}
-      expected = {date_until: '2017-05-30'}
-      actual = service.strategy_params_for_query(delimiters, query)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date since and date until' do
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {between :date, '2017-05-28', '2017-05-30'}
-      expected = {date_since: '2017-05-28', date_until: '2017-05-30'}
-      actual = service.strategy_params_for_query(delimiters, query)
-      expect(actual).to eq expected
-    end
-
-    it 'should create term delimiter from aggregations' do
-      options = {delimit_by: [:aggregations]}
-      delimiters = [Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts)]
-      query.aggregations do
-        filter :account do
-          conditions { equal :account, 39 }
-        end
-        filter :second_account do
-          conditions { equal :account, 40 }
-        end
-      end
-      expected = {accounts: [39, 40]}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date since from aggregations' do
-      options = {delimit_by: [:aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.aggregations do
-        filter :greater do
-          conditions { greater_than :date, '2017-05-29' }
-        end
-        filter :greater_eq do
-          conditions { greater_equal :date, '2017-05-27' }
-        end
-      end
-      expected = {date_since: '2017-05-27'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date until from aggregations' do
-      options = {delimit_by: [:aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.aggregations do
-        filter :less do
-          conditions { less_than :date, '2017-05-29' }
-        end
-        filter :less_eq do
-          conditions { less_equal :date, '2017-05-27' }
-        end
-      end
-      expected = {date_until: '2017-05-29'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date since and date until from aggregations' do
-      options = {delimit_by: [:aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.aggregations do
-        filter :greater_and_less_1 do
-          conditions { between :date, '2017-05-24', '2017-05-25' }
-        end
-        filter :greater_and_less_2 do
-          conditions { between :date, '2017-05-27', '2017-05-28' }
-        end
-      end
-      expected = {date_since: '2017-05-24', date_until: '2017-05-28'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter without date since nor date until from aggregations' do
-      options = {delimit_by: [:aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.aggregations do
-        filter :greater_and_less_1 do
-          conditions { between :date, '2017-05-24', '2017-05-25' }
-        end
-        filter :greater_and_less_2 do
-          conditions { between :date, '2017-05-27', '2017-05-28' }
-        end
-        filter :not_dates do
-          conditions { equal :account, 39 }
-        end
-      end
-      expected = {}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create term delimiter with date from conditions and aggregations' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::TermFieldDelimiter.new(field: :date)]
-      query.filter {equal :date, '2017-05-23'}
-      query.aggregations do
-        filter :date_zero do
-          conditions { equal :date, '2017-05-24' }
-        end
-      end
-      expected = {date: ['2017-05-23']}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date since from conditions and aggregations' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {greater_than :date, '2017-05-23'}
-      query.aggregations do
-        filter :greater_than_1 do
-          conditions { greater_than :date, '2017-05-30' }
-        end
-      end
-      expected = {date_since: '2017-05-23'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date until from conditions and aggregations' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {less_than :date, '2017-05-23'}
-      query.aggregations do
-        filter :greater_than_1 do
-          conditions { less_equal :date, '2017-05-30' }
-        end
-      end
-      expected = {date_until: '2017-05-23'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date since and date until from conditions and aggregations' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {between :date, '2017-05-23', '2017-05-30'}
-      query.aggregations do
-        filter :greater_and_less_1 do
-          conditions { between :date, '2017-05-01', '2017-05-22' }
-        end
-        filter :greater_and_less_2 do
-          conditions { between :date, '2017-05-31', '2017-06-01' }
-        end
-      end
-      expected = {date_since: '2017-05-23', date_until: '2017-05-30'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date since and date until from conditions and aggregations but without query conditions defined' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.aggregations do
-        filter :greater_and_less_1 do
-          conditions { between :date, '2017-05-01', '2017-05-22' }
-        end
-        filter :greater_and_less_2 do
-          conditions { between :date, '2017-05-31', '2017-06-10' }
-        end
-      end
-      expected = {date_since: '2017-05-01', date_until: '2017-06-10'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date since from conditions and aggregations when one aggregation has not date until' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {greater_than :date, '2017-05-23'}
-      query.aggregations do
-        filter :greater_and_less_1 do
-          conditions { between :date, '2017-05-01', '2017-05-22' }
-        end
-        filter :greater_and_less_2 do
-          conditions { between :date, '2017-05-31', '2017-06-10' }
-        end
-        filter :greater_eq do
-          conditions { greater_equal :date, '2017-05-31' }
-        end
-      end
-      expected = {date_since: '2017-05-23'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date since from conditions and aggregations when one aggregation has account filter' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {greater_than :date, '2017-05-23'}
-      query.aggregations do
-        filter :greater_and_less_1 do
-          conditions { between :date, '2017-05-01', '2017-05-22' }
-        end
-        filter :greater_and_less_2 do
-          conditions { between :date, '2017-05-31', '2017-06-10' }
-        end
-        filter :by_account do
-          conditions { equal :account, 39 }
-        end
-      end
-      expected = {date_since: '2017-05-23'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with date since from conditions and aggregations when one aggregation has account filter' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date), Elasticated::Delimiters::TermFieldDelimiter.new(field: :account, as: :accounts)]
-      query.filter {greater_than :date, '2017-05-23'}
-      query.aggregations do
-        filter :greater_and_less_1 do
-          conditions { between :date, '2017-05-01', '2017-05-22' }
-        end
-        filter :greater_and_less_2 do
-          conditions { between :date, '2017-05-31', '2017-06-10' }
-        end
-        filter :by_account do
-          conditions { equal :account, 39 }
-        end
-      end
-      expected = {date_since: '2017-05-23'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter as term' do
-      options = {delimit_by: [:conditions]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {equal :date, '2017-05-23'}
-      expected = {date: '2017-05-23'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter as term from aggregations' do
-      options = {delimit_by: [:aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.aggregations do
-        filter :greater_and_less_1 do
-          conditions { equal :date, '2017-05-01' }
-        end
-      end
-      expected = {date: '2017-05-01'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter as term from condition and aggregations' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {equal :date, '2017-05-23'}
-      query.aggregations do
-        filter :greater_and_less_1 do
-          conditions { equal :date, '2017-05-01' }
-        end
-      end
-      expected = {date: '2017-05-23'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter as range from terms condition and aggregations' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {equal :date, ['2017-05-23', '2017-06-01']}
-      query.aggregations do
-        filter :greater_and_less_1 do
-          conditions { equal :date, '2017-05-01' }
-        end
-      end
-      expected = {date_since: '2017-05-23', date_until: '2017-06-01'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should not delimit by non-delimiters' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {equal :date, ['2017-05-23', '2017-06-01']}
-      query.aggregations do
-        filter :nothing_to_do do
-          conditions { equal :primary_keywords, ["hello"] }
-          filter :another_filter do
-            conditions { equal :secondary_keywords, ["bye"] }
-          end
-        end
-      end
-      expected = {date_since: '2017-05-23', date_until: '2017-06-01'}
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with different objects (test insights - part 1)' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {equal :date, [Date.today]}
-      query.aggregations do
-        filter :terms_over_date do
-          conditions { equal :date, '2017-01-05'}
-        end
-      end
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expected = {date: Date.today}
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with different objects (test insights - part 2)' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {equal :date, '2017-01-05'}
-      query.aggregations do
-        filter :terms_over_date do
-          conditions { equal :date, [Date.today]}
-        end
-      end
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expected = {date: '2017-01-05'}
-      expect(actual).to eq expected
-    end
-
-    it 'should create date delimiter with different objects (test insights - part 3)' do
-      options = {delimit_by: [:conditions, :aggregations]}
-      delimiters = [Elasticated::Delimiters::DateFieldDelimiter.new(field: :date)]
-      query.filter {equal :date, [Date.parse('2017-05-01')]}
-      query.aggregations do
-        filter :terms_over_date do
-          conditions { equal :date, [Date.today]}
-        end
-      end
-      actual = service.strategy_params_for_query(delimiters, query, options)
-      expected = {date: Date.parse('2017-05-01')}
-      expect(actual).to eq expected
-    end
-
-  end
-
-end