elasticated 2.5.5 → 3.0.0

data/spec/date_field_delimiter_spec.rb

@@ -14,15 +14,59 @@ module Elasticated
       end
 
       it "should delimit by one term" do
-        completed_delimiter = delimiter.completed_with conditions: [{created_at: '2016-07-19'}]
-        params = completed_delimiter.build_strategy_params
+        delimiter.add_term :created_at, '2016-07-19'
+        params = delimiter.build_strategy_params
         expect(params).to eq date: '2016-07-19'
       end
 
-      it "should delimit by multiple terms" do
-        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'
+      it "should raise when delimit by multiple terms" do
+        delimiter.add_term :created_at, 'nombre1'
+        delimiter.add_term :created_at, 'nombre2'
+        expect{ delimiter.build_strategy_params }.to raise_error RuntimeError
+      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
+
+      it "should delimit only by the minimum date" do
+        delimiter.set_minimum :created_at, '2016-07-19'
+        delimiter.set_maximum :created_at, :now
+        params = delimiter.build_strategy_params
+        expect(params).to eq date_since: '2016-07-19'
       end
 
     end

data/spec/document_spec.rb

@@ -3,12 +3,8 @@ require_relative 'spec_helper'
 module Elasticated
   describe Document do
 
-    def open_hit(name)
-      JSON.parse File.read "spec/#{name}.json"
-    end
-
     let :hit do
-      open_hit 'elasticsearch_hit_1'
+      open_response 'elasticsearch_hit_1'
     end
 
     it "should parse an elasticsearch hit" do

data/spec/integration_spec.rb

@@ -21,13 +21,13 @@ module Elasticated
         query: {
           filtered: {
             filter: {
-              terms: { age: [23] }
+              term: { age: 23 }
             },
             query: {
               bool: {
                 must: [
-                  { terms: { first_name: [:pablo] } },
-                  { terms: { last_name: [:fernandez] } }
+                  { term: { first_name: :pablo } },
+                  { term: { last_name: :fernandez } }
                 ]
               }
             }
@@ -88,7 +88,7 @@ module Elasticated
                 terms: { field: :user, size: 0 },
                 aggs: {
                   element_id: {
-                    filter: { terms: { element_id: [2] } }
+                    filter: { term: { element_id: 2 } }
                   }
                 }
               },
@@ -130,13 +130,13 @@ module Elasticated
         query: {
           filtered: {
             filter: {
-              terms: { age: [23] }
+              term: { age: 23 }
             },
             query: {
               bool: {
                 must: [
-                  { terms: { first_name: [:pablo] } },
-                  { terms: { last_name: [:fernandez] } }
+                  { term: { first_name: :pablo } },
+                  { term: { last_name: :fernandez } }
                 ]
               }
             }

data/spec/mapping_spec.rb

@@ -3,6 +3,52 @@ require_relative 'spec_helper'
 module Elasticated
   describe Mapping do
 
+    context "the dynamic attribute" do
+
+      it "should be setted to 'true'" do
+        result = Mapping.build do
+          type :a_type do
+            accept_new_fields
+          end
+        end
+        expected_result = {
+            a_type: {
+              dynamic: true
+            }
+          }
+        expect(result.to_h).to eq expected_result
+      end
+
+      it "should be setted to 'false'" do
+        result = Mapping.build do
+          type :a_type do
+            ignore_new_fields
+          end
+        end
+        expected_result = {
+            a_type: {
+              dynamic: false
+            }
+          }
+        expect(result.to_h).to eq expected_result
+      end
+
+      it "should be setted to 'strict'" do
+        result = Mapping.build do
+          type :a_type do
+            strict
+          end
+        end
+        expected_result = {
+            a_type: {
+              dynamic: 'strict'
+            }
+          }
+        expect(result.to_h).to eq expected_result
+      end
+
+    end
+
     it "should build a single integer property" do
       result = Mapping.build do |mapping|
         mapping.type :a_type do |type|
@@ -16,7 +62,7 @@ module Elasticated
             }
           }
         }
-      expect(result).to eq expected_result
+      expect(result.to_h).to eq expected_result
     end
 
     it "should build a single long property" do
@@ -32,7 +78,39 @@ module Elasticated
             }
           }
         }
-      expect(result).to eq expected_result
+      expect(result.to_h).to eq expected_result
+    end
+
+    it "should build a single double property" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.double :a_double
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              a_double: { type: :double, fielddata: { format: :doc_values } }
+            }
+          }
+        }
+      expect(result.to_h).to eq expected_result
+    end
+
+    it "should build a single float property" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.float :a_float
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              a_float: { type: :float, fielddata: { format: :doc_values } }
+            }
+          }
+        }
+      expect(result.to_h).to eq expected_result
     end
 
     it "should build a single date property" do
@@ -48,7 +126,7 @@ module Elasticated
             }
           }
         }
-      expect(result).to eq expected_result
+      expect(result.to_h).to eq expected_result
     end
 
     it "should build a single string property" do
@@ -64,7 +142,7 @@ module Elasticated
             }
           }
         }
-      expect(result).to eq expected_result
+      expect(result.to_h).to eq expected_result
     end
 
     it "should build a single analyzed string property" do
@@ -86,7 +164,7 @@ module Elasticated
             }
           }
         }
-      expect(result).to eq expected_result
+      expect(result.to_h).to eq expected_result
     end
 
     it "should build a single bool property" do
@@ -102,7 +180,7 @@ module Elasticated
             }
           }
         }
-      expect(result).to eq expected_result
+      expect(result.to_h).to eq expected_result
     end
 
     it "should build a single object" do
@@ -125,7 +203,28 @@ module Elasticated
             }
           }
         }
-      expect(result).to eq expected_result
+      expect(result.to_h).to eq expected_result
+    end
+
+    it "should build a single object with dynamic mapping" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.object :an_object do |object|
+            object.accept_new_fields
+          end
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              an_object: {
+                type: :object,
+                dynamic: true
+              }
+            }
+          }
+        }
+      expect(result.to_h).to eq expected_result
     end
 
     it "should build a single nested" do
@@ -150,7 +249,28 @@ module Elasticated
             }
           }
         }
-      expect(result).to eq expected_result
+      expect(result.to_h).to eq expected_result
+    end
+
+    it "should build a partial" do
+      partial = Mapping.partial do |type|
+        type.string :b_name
+      end
+      result = Mapping.build do |mapping|
+        mapping.type :my_type do |type|
+          type.string :a_name
+          type.partial partial
+        end
+      end
+      expected_result = {
+          my_type: {
+            properties: {
+              a_name: { type: :string, index: :not_analyzed, fielddata: { format: :doc_values } },
+              b_name: { type: :string, index: :not_analyzed, fielddata: { format: :doc_values } }
+            }
+          }
+        }
+      expect(result.to_h).to eq expected_result
     end
 
     it "should build a complex mapping" do

data/spec/partitioned_repository_spec.rb

@@ -0,0 +1,218 @@
+require_relative 'spec_helper'
+
+module Elasticated
+  describe PartitionedRepository do
+
+    let(:transport){ double }
+    let(:repository){ PartitionedRepository.new SpecHelper::FakeIndexSelector.new }
+    let(:query){ Query.new }
+
+    before :each do
+      allow(repository.client).to receive(:transport).and_return transport
+    end
+
+    context "on an index refresh" do
+
+      let(:indices){ double }
+
+      before :each do
+        allow(transport).to receive(:indices).and_return indices
+      end
+
+      it "should affect the general alias" do
+        query = Query.new
+        expect(indices).to receive(:refresh).with(index: 'fakeindex')
+        repository.refresh_indices_for(query)
+      end
+
+      it "should affect just one partition" do
+        query = Query.build{ terms :created_at, '2017-01-05' }
+        expect(indices).to receive(:refresh).with(index: 'fakeindex-2017-01-05')
+        repository.refresh_indices_for(query)
+      end
+
+      it "should affect multiple partitions" do
+        query = Query.build{ range :created_at, '2017-01-04', '2017-01-05' }
+        expect(indices).to receive(:refresh).with(index: 'fakeindex-2017-01-04,fakeindex-2017-01-05')
+        repository.refresh_indices_for(query)
+      end
+
+    end
+
+    context "on a search" do
+
+      let(:response){ open_response 'elasticsearch_response_1' }
+
+      it "should affect the general alias" do
+        query = Query.new
+        expect(transport).to receive(:search).with(body: query.build_for_search, type: 'faketype', index: 'fakeindex').and_return response
+        repository.execute_search query, type: 'faketype', as: :single_page
+      end
+
+      it "should affect just one partition" do
+        query = Query.build{ terms :created_at, '2017-01-05' }
+        expect(transport).to receive(:search).with(body: query.build_for_search, type: 'faketype', index: 'fakeindex-2017-01-05').and_return response
+        repository.execute_search query, type: 'faketype', as: :single_page
+      end
+
+      it "should affect multiple partitions" do
+        query = Query.build{ range :created_at, '2017-01-04', '2017-01-05' }
+        expect(transport).to receive(:search).with(body: query.build_for_search, type: 'faketype', index: 'fakeindex-2017-01-04,fakeindex-2017-01-05').and_return response
+        repository.execute_search query, type: 'faketype', as: :single_page
+      end
+
+    end
+
+    context "on a delete by query" do
+
+      it "should affect the general alias" do
+        query = Query.new
+        expect(transport).to receive(:delete_by_query).with(body: query.build_for_search, type: 'faketype', index: 'fakeindex')
+        repository.delete_by query, type: 'faketype'
+      end
+
+      it "should affect just one partition" do
+        query = Query.build{ terms :created_at, '2017-01-05' }
+        expect(transport).to receive(:delete_by_query).with(body: query.build_for_search, type: 'faketype', index: 'fakeindex-2017-01-05')
+        repository.delete_by query, type: 'faketype'
+      end
+
+      it "should affect multiple partitions" do
+        query = Query.build{ range :created_at, '2017-01-04', '2017-01-05' }
+        expect(transport).to receive(:delete_by_query).with(body: query.build_for_search, type: 'faketype', index: 'fakeindex-2017-01-04,fakeindex-2017-01-05')
+        repository.delete_by query, type: 'faketype'
+      end
+
+    end
+
+    context "on a count" do
+
+      let(:response){ open_response 'elasticsearch_count_1' }
+
+      it "should affect the general alias" do
+        query = Query.new
+        expect(transport).to receive(:count).with(body: query.build_for_search, type: 'faketype', index: 'fakeindex').and_return response
+        repository.execute_count query, type: 'faketype'
+      end
+
+      it "should affect just one partition" do
+        query = Query.build{ terms :created_at, '2017-01-05' }
+        expect(transport).to receive(:count).with(body: query.build_for_search, type: 'faketype', index: 'fakeindex-2017-01-05').and_return response
+        repository.execute_count query, type: 'faketype'
+      end
+
+      it "should affect multiple partitions" do
+        query = Query.build{ range :created_at, '2017-01-04', '2017-01-05' }
+        expect(transport).to receive(:count).with(body: query.build_for_search, type: 'faketype', index: 'fakeindex-2017-01-04,fakeindex-2017-01-05').and_return response
+        repository.execute_count query, type: 'faketype'
+      end
+
+    end
+
+    context "on an upsert" do
+
+      let(:source){ { 'name' => 'Pablo', 'created_at' => '2017-01-05' } }
+      let(:document){ Document.create id: 'my_id', type: 'my_type', index: 'my_index', source: source }
+
+      it "should select the correct index on an indexation" do
+        expect(transport).to receive(:index).with(id: 'my_id', type: 'my_type', index: 'fakeindex-2017-01-05', body: source)
+        repository.index_document document
+      end
+
+    end
+
+    context "on a partial update" do
+
+      let(:source){ { 'some_field' => 'some_value' } }
+
+      it "should select the correct index based on the user params" do
+        expect(transport).to receive(:update).with(id: 'my_id', type: 'my_type', index: 'fakeindex-2017-01-05', body: { doc: source })
+        repository.update_document 'my_id', type: 'my_type', source: source, index_for: { date: '2017-01-05' }
+      end
+
+      it "should raise if the user doesnt give the index selection params" do
+        expect{ repository.update_document 'my_id', type: 'my_type', source: source }.to raise_error RuntimeError
+      end
+
+      it "should raise if the user give params affecting multiple indices" do
+        expect{ repository.update_document 'my_id', type: 'my_type', source: source, index_for: { date_since: '2017-01-04', date_until: '2017-01-05' } }.to raise_error RuntimeError
+      end
+
+    end
+
+    context "on a get" do
+
+      it "should select the correct index based on the user params (on a get)" do
+        response = open_response 'elasticsearch_get_response_1'
+        expect(transport).to receive(:get).with(id: 'my_doc_id', index: 'fakeindex-2017-01-05').and_return response
+        repository.get_document 'my_doc_id', index_for: { date: '2017-01-05' }
+      end
+
+      it "should raise if the user doesnt give the index selection params (on a get)" do
+        expect{ repository.get_document 'my_doc_id' }.to raise_error RuntimeError
+      end
+
+      it "should raise if the user give params affecting multiple indices (on a get)" do
+        expect{ repository.get_document 'my_doc_id', index_for: { date_since: '2017-01-04', date_until: '2017-01-05' } }.to raise_error RuntimeError
+      end
+
+    end
+
+    context "on a delete" do
+
+      it "should select the correct index based on the user params (on a delete)" do
+        expect(transport).to receive(:delete).with(id: 'my_doc_id', index: 'fakeindex-2017-01-05')
+        repository.delete_document 'my_doc_id', index_for: { date: '2017-01-05' }
+      end
+
+      it "should raise if the user doesnt give the index selection params (on a delete)" do
+        expect{ repository.delete_document 'my_doc_id' }.to raise_error RuntimeError
+      end
+
+      it "should raise if the user give params affecting multiple indices (on a delete)" do
+        expect{ repository.delete_document 'my_doc_id', index_for: { date_since: '2017-01-04', date_until: '2017-01-05' } }.to raise_error RuntimeError
+      end
+
+    end
+
+    context "on a mget" do
+
+      it "should select the correct index based on the user params (on a mget)" do
+        response = open_response 'elasticsearch_mget_response_1'
+        expect(transport).to receive(:mget).with(body: { ids: ['id1', 'id2'] }, index: 'fakeindex-2017-01-05').and_return response
+        repository.get_document ['id1', 'id2'], index_for: { date: '2017-01-05' }
+      end
+
+      it "should raise if the user doesnt give the index selection params (on a mget)" do
+        expect{ repository.get_document ['id1', 'id2'] }.to raise_error RuntimeError
+      end
+
+      it "should raise if the user give params affecting multiple indices (on a mget)" do
+        expect{ repository.get_document ['id1', 'id2'], index_for: { date_since: '2017-01-04', date_until: '2017-01-05' } }.to raise_error RuntimeError
+      end
+
+    end
+
+    context "on a percolation" do
+
+      let(:query){ Query.new }
+
+      before :each do
+        allow(DateTime).to receive(:now).and_return DateTime.parse '2017-01-05T00:00:00.000Z'
+      end
+
+      it "should select the 'DateTime.now' index" do
+        expect(transport).to receive(:index).with(index: 'fakeindex-2017-01-05', type: '.percolator', id: 'my_id', body: { query: query.build_for_count })
+        repository.create_percolator query, id: 'my_id'
+      end
+
+      it "should check a percolator" do
+        document = Document.new user: 'Pablo', created_at: '2016-12-15'
+        expect(transport).to receive(:percolate).with(index: 'fakeindex-2017-01-05', type: 'my_type', body: { doc: { user: 'Pablo', created_at: '2016-12-15' } })
+        repository.percolate_document document, type: 'my_type'
+      end
+
+    end
+
+  end
+end