elasticated 1.0.0

data/spec/monthly_partitioned_repository_spec.rb

@@ -0,0 +1,99 @@
+require_relative 'spec_helper'
+
+module Elasticated
+  describe MonthlyPartitionedRepository do
+
+    let :repository do
+      MonthlyPartitionedRepository.new index_name: 'fbinsights-v3', index_alias: 'fbinsights'
+    end
+
+    before :each do
+      Elasticated.configure do |config|
+        config.logger = double.as_null_object
+      end
+    end
+
+    it "should return the correct index name" do
+      date = Date.parse '2015-09-04'
+      name = repository.index_name_for date
+      expect(name).to eq 'fbinsights-v3-2015-09'
+    end
+
+    it "should return the correct index alias" do
+      date = Date.parse '2015-09-04'
+      name = repository.index_alias_for date
+      expect(name).to eq 'fbinsights-2015-09'
+    end
+
+    context "on a search" do
+
+      let :query do
+        Query.new # TODO date
+      end
+
+      it "should execute a search on the correct index" do
+        expect(repository).to receive(:_exec_search).with query, index: 'fbinsights' # TODO
+        repository.execute_search query
+      end
+
+      it "should execute a count on the correct index" do
+        expect(repository).to receive(:_exec_count).with query, index: 'fbinsights' # TODO
+        repository.execute_count query
+      end
+
+      it "should execute a delete on the correct index" do
+        expect(repository).to receive(:_exec_delete).with query, index: 'fbinsights' # TODO
+        repository.delete_by query
+      end
+
+    end
+
+    context "on an indexation" do
+
+      let :document do
+        Document.create source: { 'date' => '2015-09-04' }
+      end
+
+      it "should use the appropiated index alias" do
+        client = repository.client
+        expect(client).to receive(:index_exists?).with('fbinsights-2015-09').and_return true
+        expect(client).to receive(:index_document).with document.source, index: 'fbinsights-2015-09', type: 'post'
+        repository.index_document document, type: 'post'
+      end
+
+      it "should create the appropiated index (only if dynamic creation is enabled)" do
+        client = repository.client
+        expect(client).to receive(:index_exists?).with('fbinsights-2015-09').and_return false
+        expect{ repository.index_document document, type: 'post' }.to raise_error
+        expect(client).to receive(:index_exists?).with('fbinsights-2015-09').and_return false
+        expect(client).to receive(:create_index).with 'fbinsights-v3-2015-09', anything
+        repository.dynamic_creation = true
+        expect(client).to receive(:create_alias).with('fbinsights-v3-2015-09', 'fbinsights-2015-09').once
+        expect(client).to receive(:create_alias).with('fbinsights-v3-2015-09', 'fbinsights').once
+        expect(client).to receive(:index_document).with document.source, index: 'fbinsights-2015-09', type: 'post'
+        repository.index_document document, type: 'post'
+      end
+
+    end
+
+    context "the index creation method" do
+
+      let :date do
+        Date.parse '2015-09-04'
+      end
+
+      it "creates the appropiated index" do
+        expect(repository.client).to receive(:create_index).with 'fbinsights-v3-2015-09', anything
+        repository.create_index! date
+      end
+
+      it "creates the appropiated alias" do
+        expect(repository.client).to receive(:create_alias).with('fbinsights-v3-2015-09', 'fbinsights-2015-09').once
+        expect(repository.client).to receive(:create_alias).with('fbinsights-v3-2015-09', 'fbinsights').once
+        repository.create_alias! date
+      end
+
+    end
+
+  end
+end

data/spec/query_aggregations_spec.rb

@@ -0,0 +1,44 @@
+require_relative 'spec_helper'
+
+module Elasticated
+  describe QueryAggregations do
+
+    let(:qa){ QueryAggregations.new }
+
+    describe "the aggragation lookup method" do
+
+      class DummieAggregation
+        def build; { dummie_body: {} }; end
+        def name; :nn; end
+      end
+
+      it "should instantiate the correct class" do
+        qa.dummie
+        expected_result = { nn: { dummie_body: {} } }
+        expect(qa.build).to eq expected_result
+      end
+
+    end
+
+    describe "the build method" do
+
+      it "should build a single aggregated body" do
+        qa.sum :numeric
+        expected_result = { sum_numeric: { sum: { field: :numeric } } }
+        expect(qa.build).to eq expected_result
+      end
+
+      it "should build a multiple aggregated body" do
+        qa.sum :numeric
+        qa.max :numeric
+        expected_result = {
+          sum_numeric: { sum: { field: :numeric } },
+          max_numeric: { max: { field: :numeric } }
+        }
+        expect(qa.build).to eq expected_result
+      end
+
+    end
+
+  end
+end

data/spec/query_conditions_spec.rb

@@ -0,0 +1,314 @@
+require_relative 'spec_helper'
+
+module Elasticated
+  describe QueryConditions do
+
+    let(:qc){ QueryConditions.new }
+
+    describe 'the build method' do
+
+      it "should build a 'match_all' condition" do
+        expected_result = { match_all: {} }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'terms' condition" do
+        qc.equal :field, :value
+        expected_result = { terms: { field: [:value] } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'terms' condition (with params)" do
+        qc.equal :field, :value, execution: :bool, _cache: false
+        expected_result = { terms: { field: [:value], execution: :bool, _cache: false } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'must_not>terms' condition" do
+        qc.not_equal :field, :value
+        expected_result = { bool: { must_not: [ { terms: { field: [:value] } } ] } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'with' condition" do
+        qc.with :field
+        expected_result = { wildcard: { field: '*' } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'without' condition" do
+        qc.without :field
+        expected_result = { bool: { must_not: [ { wildcard: { field: '*' } } ] } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'wildcard' condition" do
+        qc.wildcard :field, 'regex'
+        expected_result = { wildcard: { field: 'regex' } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build an 'exists' condition" do
+        qc.exists :field_name
+        expected_result = { exists: { field: :field_name } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'missing' condition" do
+        qc.missing :field_name
+        expected_result = { missing: { field: :field_name } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'between' condition" do
+        qc.between :field, :min_value, :max_value
+        expected_result = { range: { field: { gte: :min_value, lte: :max_value } } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'greater_than' condition" do
+        qc.greater_than :field, :min_value
+        expected_result = { range: { field: { gt: :min_value } } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'less_than' condition" do
+        qc.less_than :field, :max_value
+        expected_result = { range: { field: { lt: :max_value } } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'greater_equal' condition" do
+        qc.greater_equal :field, :min_value
+        expected_result = { range: { field: { gte: :min_value } } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'less_equal' condition" do
+        qc.less_equal :field, :max_value
+        expected_result = { range: { field: { lte: :max_value } } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'between' condition (with params)" do
+        qc.between :field, :min_value, :max_value, execution: :index, _cache: true
+        expected_result = { range: { execution: :index, _cache: true, field: { gte: :min_value, lte: :max_value } } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'script' condition" do
+        qc.script 'your_script_here'
+        expected_result = { script: { script: 'your_script_here' } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'script' condition (with params)" do
+        qc.script 'your_script_here', first_param: :one
+        expected_result = { script: { script: 'your_script_here', params: { first_param: :one } } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a custom 'must' condition" do
+        qc.must{ custom term: { field: :value } }
+        expected_result = { term: { field: :value } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a custom 'must_not' condition" do
+        qc.must_not{ custom term: { field: :value } }
+        expected_result = { bool: { must_not: [ { term: { field: :value } } ] } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'nested' condition" do
+        qc.nested :hash do |n|
+          n.equal :field, :value
+        end
+        expected_result = { nested: { path: :hash, filter: { terms: { field: [:value] } } } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'nested' condition (with params)" do
+        qc.nested :hash, _cache: true do |n|
+          n.equal :field, :value
+        end
+        expected_result = { nested: { path: :hash, _cache: true, filter: { terms: { field: [:value] } } } }
+        expect(qc.build).to eq expected_result
+      end
+
+      # it "should build a 'should_equal' condition" do
+      #   qc.should_equal :field, :value
+      #   expected_result = { bool: { should: [ { terms: { field: [:value] } } ] } }
+      #   expect(qc.build).to eq expected_result
+      # end
+
+      # it "should build a 'should_wildcard' condition" do
+      #   qc.should_wildcard :field, 'regex'
+      #   expected_result = { bool: { should: [ { wildcard: { field: 'regex' } } ] } }
+      #   expect(qc.build).to eq expected_result
+      # end
+
+      # it "should build a 'should_with' condition" do
+      #   qc.should_with :field
+      #   expected_result = { bool: { should: [ { wildcard: { field: '*' } } ] } }
+      #   expect(qc.build).to eq expected_result
+      # end
+
+      it "should build a 'bool>must' condition" do
+        qc.exists :field
+        qc.equal :field, :value
+        expected_result = { bool: { must: [ { exists: { field: :field } }, { terms: { field: [:value] } } ] } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'bool>must' cached condition" do
+        qc.exists :field
+        qc.equal :field, :value
+        qc.cache
+        expected_result = { bool: { must: [ { exists: { field: :field } }, { terms: { field: [:value] } } ], _cache: true } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'bool>must+must_not+should' condition" do
+        qc.equal :field_one, :value_one
+        qc.not_equal :field_two, :value_two
+        qc.should{ equal :field_three, :value_three }
+        qc.minimum_should_match 2
+        expected_result = { bool: {
+          must: [ {terms: { field_one: [:value_one] } } ],
+          must_not: [ { terms: { field_two: [:value_two] } } ],
+          should: [ { terms: { field_three: [:value_three] } } ],
+          minimum_should_match: 2
+        } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build nested bool conditions" do
+        qc.must{ equal :age, 19 }
+        qc.should{ equal :name, 'Pablo' }
+        qc.should{ equal :name, 'Santiago' }
+        expected_result = {
+          bool: {
+            must: [
+              { terms: { age: [19] } }
+            ],
+            should: [
+              { terms: { name: ['Pablo'] } },
+              { terms: { name: ['Santiago'] } }
+            ]
+          }
+        }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build nested bools" do
+        qc.should do
+          equal :first_name, 'Pablo'
+          equal :last_name, 'Fernandez'
+          bool do
+            equal :age, 24
+            equal :country, 'Argentina'
+          end
+        end
+        expected_result = {
+          bool: {
+            should: [
+              { terms: { first_name: ['Pablo'] } },
+              { terms: { last_name: ['Fernandez'] } },
+              {
+                bool: {
+                  must: [
+                    { terms: { age: [24] } },
+                    { terms: { country: ['Argentina'] } }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+        expect(qc.build).to eq expected_result
+      end
+
+    end
+
+    describe "the clone method" do
+
+      it 'should clone the must and must_not collections' do
+        qc.equal :field_one, :value_one
+        qc.not_equal :field_two, :value_two
+        qc.should{ equal :field_three, :value_three }
+        new_qc = qc.clone
+        qc.equal :field_four, :value_four
+        qc.not_equal :field_five, :value_five
+        qc.should{ equal :field_six, :value_six }
+        expected_result = { bool: {
+          must: [ {terms: { field_one: [:value_one] } } ],
+          must_not: [ { terms: { field_two: [:value_two] } } ],
+          should: [ { terms: { field_three: [:value_three] } } ]
+        } }
+        expect(new_qc.build).to eq expected_result
+      end
+
+    end
+
+    describe "the term delimiter" do
+
+      let :delimiter do
+        Delimiters::TermFieldDelimiter.new field: :account_id, as: :account
+      end
+
+      it "should not delimit anything" do
+        qc.equal :other_field, 68
+        qc.fill_delimiter delimiter
+        params = delimiter.build_strategy_params
+        expect(params).to be_empty
+      end
+
+      it "should delimit a single condition" do
+        qc.equal :account_id, 68
+        qc.fill_delimiter delimiter
+        params = delimiter.build_strategy_params
+        expect(params).to eq account: [68]
+      end
+
+      it "should delimit by multiple conditions (part 1)" do
+        qc.equal :account_id, [68, 31]
+        qc.fill_delimiter delimiter
+        params = delimiter.build_strategy_params
+        expect(params).to eq account: [68, 31]
+      end
+
+      it "should delimit a multiple conditions (part 2)" do
+        qc.equal :account_id, 68
+        qc.equal :account_id, 31
+        qc.fill_delimiter delimiter
+        params = delimiter.build_strategy_params
+        expect(params).to eq account: [68, 31]
+      end
+
+      it "should delimit by nested conditions" do
+        qc.equal :account_id, 68
+        qc.bool do
+          equal :account_id, 31
+        end
+        qc.fill_delimiter delimiter
+        params = delimiter.build_strategy_params
+        expect(params).to eq account: [68, 31]
+      end
+
+      it "should delimit only by the 'must' part of nested conditions" do
+        qc.equal :account_id, 68
+        qc.bool do
+          must{ equal :account_id, 31 }
+          must_not{ equal :account_id, 85 }
+          should{ equal :account_id, 58 }
+        end
+        qc.fill_delimiter delimiter
+        params = delimiter.build_strategy_params
+        expect(params).to eq account: [68, 31]
+      end
+
+    end
+
+  end
+end