elasticated 2.5.5 → 3.0.0

data/spec/query_conditions_spec.rb

@@ -13,20 +13,26 @@ module Elasticated
       end
 
       it "should build a 'terms' condition" do
-        qc.equal :field, :value
-        expected_result = { terms: { field: [:value] } }
+        qc.terms :field, [:value1, :value2]
+        expected_result = { terms: { field: [:value1, :value2] } }
+        expect(qc.build).to eq expected_result
+      end
+
+      it "should build a 'terms' condition (with the 'equal' alias)" do
+        qc.equal :field, [:value1, :value2]
+        expected_result = { terms: { field: [:value1, :value2] } }
         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 } }
+        qc.terms :field, [:value1, :value2], execution: :bool, _cache: false
+        expected_result = { terms: { field: [:value1, :value2], 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] } } ] } }
+        qc.not_equal :field, [:value1, :value2]
+        expected_result = { bool: { must_not: [ { terms: { field: [:value1, :value2] } } ] } }
         expect(qc.build).to eq expected_result
       end
 
@@ -66,6 +72,12 @@ module Elasticated
         expect(qc.build).to eq expected_result
       end
 
+      it "should build a 'between' condition (using the 'range' alias)" do
+        qc.range :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 } } }
@@ -122,50 +134,32 @@ module Elasticated
 
       it "should build a 'nested' condition" do
         qc.nested :hash do |n|
-          n.equal :field, :value
+          n.term :field, :value
         end
-        expected_result = { nested: { path: :hash, filter: { terms: { field: [:value] } } } }
+        expected_result = { nested: { path: :hash, filter: { term: { 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
+          n.term :field, :value
         end
-        expected_result = { nested: { path: :hash, _cache: true, filter: { terms: { field: [:value] } } } }
+        expected_result = { nested: { path: :hash, _cache: true, filter: { term: { 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] } } ] } }
+        qc.term :field, :value
+        expected_result = { bool: { must: [ { exists: { field: :field } }, { term: { 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.term :field, :value
         qc.cache
-        expected_result = { bool: { must: [ { exists: { field: :field } }, { terms: { field: [:value] } } ], _cache: true } }
+        expected_result = { bool: { must: [ { exists: { field: :field } }, { term: { field: :value } } ], _cache: true } }
         expect(qc.build).to eq expected_result
       end
 
@@ -175,9 +169,9 @@ module Elasticated
         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] } } ],
+          must: [ {term: { field_one: :value_one } } ],
+          must_not: [ { term: { field_two: :value_two } } ],
+          should: [ { term: { field_three: :value_three } } ],
           minimum_should_match: 2
         } }
         expect(qc.build).to eq expected_result
@@ -190,11 +184,11 @@ module Elasticated
         expected_result = {
           bool: {
             must: [
-              { terms: { age: [19] } }
+              { term: { age: 19 } }
             ],
             should: [
-              { terms: { name: ['Pablo'] } },
-              { terms: { name: ['Santiago'] } }
+              { term: { name: 'Pablo' } },
+              { term: { name: 'Santiago' } }
             ]
           }
         }
@@ -213,13 +207,13 @@ module Elasticated
         expected_result = {
           bool: {
             should: [
-              { terms: { first_name: ['Pablo'] } },
-              { terms: { last_name: ['Fernandez'] } },
+              { term: { first_name: 'Pablo' } },
+              { term: { last_name: 'Fernandez' } },
               {
                 bool: {
                   must: [
-                    { terms: { age: [24] } },
-                    { terms: { country: ['Argentina'] } }
+                    { term: { age: 24 } },
+                    { term: { country: 'Argentina' } }
                   ]
                 }
               }
@@ -242,14 +236,73 @@ module Elasticated
         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] } } ]
+          must: [ {term: { field_one: :value_one } } ],
+          must_not: [ { term: { field_two: :value_two } } ],
+          should: [ { term: { 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

data/spec/query_spec.rb

@@ -67,16 +67,6 @@ module Elasticated
 
     describe "the build method (over other fields)" do
 
-      it "should build a 'match_all' query sorted by a custom hash" do
-        my_custom_hash = { any_key: 'any_value' }
-        q.custom_sort(my_custom_hash)
-        expected_result = {
-          query: { match_all: {} },
-          sort: [my_custom_hash]
-        }
-        expect(q.build).to eq expected_result
-      end
-
       it "should build a 'match_all' query sorted by a single field" do
         q.sort :field
         expected_result = {
@@ -104,16 +94,6 @@ module Elasticated
         expect(q.build).to eq expected_result
       end
 
-      it "should build a 'match_all' query sorted by a custom script" do
-        my_script_hash = { script: "my_script", type: "my_type" }
-        q.sort_by_script(my_script_hash)
-        expected_result = {
-          query: { match_all: {} },
-          sort: [ { _script: my_script_hash } ]
-        }
-        expect(q.build).to eq expected_result
-      end
-
       it "should build a 'match_all' query sorted randomly" do
         q.sort_randomly
         expected_result = {
@@ -168,6 +148,15 @@ module Elasticated
         expect(q.build).to eq expected_result
       end
 
+      it "should build a 'match_all' query returning no source" do
+        q.source false
+        expected_result = {
+          query: { match_all: {} },
+          _source: false
+        }
+        expect(q.build).to eq expected_result
+      end
+
       it "should build an aggregated search query" do
         q.aggregations{ group :field, size: 5 }
         expect(q.build).to eq query: { match_all: {} },
@@ -191,7 +180,7 @@ module Elasticated
 
       it "should raise trying to build a non-aggregated query as an aggregated one" do
         q.size(10).sort(:field).source(:field)
-        expect{ q.build_for_aggregations }.to raise_error
+        expect{ q.build_for_aggregations }.to raise_error RuntimeError
       end
 
       it "should build a 'top hits' query" do
@@ -208,12 +197,14 @@ module Elasticated
       it "should build a complex query" do
         q.filter do
           equal :last_name, 'Fernandez'
+          equal :age, [23, 24]
           should do
             equal :first_name, 'Pablo'
             bool do
               must do
                 equal :first_name, 'Tomas'
                 equal :second_name, 'Agustin'
+                range :age, '2001-01-01', now
               end
             end
           end
@@ -223,8 +214,8 @@ module Elasticated
           not_equal :city, 'CABA'
         end
         q.aggregations do
-          group :entry_type, size: 5 do
-            group :entry_name, compact: true
+          terms :entry_type, size: 5 do
+            terms :entry_name, compact: true
           end
         end
         q.size 20
@@ -239,15 +230,17 @@ module Elasticated
               filter: {
                 bool: {
                   must: [
-                    { terms: { last_name: ['Fernandez'] } }
+                    { term: { last_name: 'Fernandez' } },
+                    { terms: { age: [23, 24] } }
                   ],
                   should: [
-                    { terms: { first_name: ['Pablo'] } },
+                    { term: { first_name: 'Pablo' } },
                     {
                       bool: {
                         must: [
-                          { terms: { first_name: ['Tomas'] } },
-                          { terms: { second_name: ['Agustin'] } }
+                          { term: { first_name: 'Tomas' } },
+                          { term: { second_name: 'Agustin' } },
+                          { range: { age: { gte: '2001-01-01', lte: 'now' } } }
                         ]
                       }
                     }
@@ -258,7 +251,7 @@ module Elasticated
               query: {
                 bool: {
                   must_not: [
-                    { terms: { city: ['CABA'] } }
+                    { term: { city: 'CABA' } }
                   ]
                 }
               }

data/spec/repository_spec.rb

@@ -0,0 +1,245 @@
+require_relative 'spec_helper'
+
+module Elasticated
+  describe Repository do
+
+    let(:transport){ double }
+    let(:repository){ Repository.new }
+    let(:query){ Query.new }
+
+    before :each do
+      allow(repository.client).to receive(:transport).and_return transport
+    end
+
+    def expect_source_preparation
+      expect(repository).to receive(:prepare_source).once.and_call_original
+    end
+
+    def expect_document_preparation
+      expect_source_preparation
+      expect(repository).to receive(:params_for_document).twice.and_call_original
+    end
+
+    def expect_query_preparation
+      expect(repository).to receive(:params_for_query).once.and_call_original
+    end
+
+    def expect_percolator_preparation
+      expect(repository).to receive(:params_for_percolator).once.and_call_original
+    end
+
+    def expect_ids_preparation
+      expect(repository).to receive(:params_for_ids).once.and_call_original
+    end
+
+    def expect_served_document_preparation(times=nil)
+      times ||= :once
+      expect(repository).to receive(:restore_source).send(times).and_call_original
+    end
+
+    context "on a query" do
+
+      it "should return the only page of results" do
+        response = open_response 'elasticsearch_response_1'
+        expect(transport).to receive(:search).with(body: query.build_for_search).and_return response
+        expect_query_preparation
+        results = repository.execute_search query, as: :single_page
+        expect(results.count).to eq 1
+      end
+
+      it "should delete all matching documents" do
+        expect(transport).to receive(:delete_by_query).with(body: query.build_for_count)
+        expect_query_preparation
+        repository.delete_by query
+      end
+
+      it "should return the qty of matching documents" do
+        response = open_response 'elasticsearch_count_1'
+        expect(transport).to receive(:count).with(body: query.build_for_count).and_return response
+        result = repository.execute_count query
+        expect(result).to eq 15
+      end
+
+      it "should return true on a 'exists?' query with hits > 0" do
+        response = open_response 'elasticsearch_count_1'
+        expect(transport).to receive(:count).with(body: query.build_for_count).and_return response
+        result = repository.exists? query
+        expect(result).to eq true
+      end
+
+      it "should return false on a 'exists?' query with hits = 0" do
+        response = open_response 'elasticsearch_count_2'
+        expect(transport).to receive(:count).with(body: query.build_for_count).and_return response
+        result = repository.exists? query
+        expect(result).to eq false
+      end
+
+    end
+
+    context "on an indexation" do
+
+      before :each do
+        expect_document_preparation
+      end
+
+      let(:source){ { 'name' => 'Pablo' } }
+      let(:document){ Document.create id: 'my_id', type: 'my_type', index: 'my_index', source: source }
+
+      it "should index the given document" do
+        expect(transport).to receive(:index).with(id: 'my_id', type: 'my_type', index: 'my_index', body: source)
+        repository.index_document document
+      end
+
+    end
+
+    context "on an update" do
+
+      before :each do
+        expect_source_preparation
+      end
+
+      let(:source){ { 'my_field' => 'my_value' } }
+
+      it "should update the given document" do
+        expect(transport).to receive(:update).with(id: 'my_id', type: 'my_type', index: 'my_index', body: { doc: source })
+        repository.update_document 'my_id', type: 'my_type', index: 'my_index', source: source
+      end
+
+    end
+
+    context "on a single document action" do
+
+      before :each do
+        expect_ids_preparation
+      end
+
+      it "should get some document by id" do
+        response = open_response 'elasticsearch_get_response_1'
+        expect(transport).to receive(:get).with(id: 'my_doc_id').and_return response
+        expect_served_document_preparation
+        result = repository.get_document 'my_doc_id'
+        expect(result).to be_a Document
+      end
+
+      it "should get some document by id and return nil if isnt present" do
+        response = open_response 'elasticsearch_get_response_2'
+        expect(transport).to receive(:get).with(id: 'my_doc_id').and_return response
+        result = repository.get_document 'my_doc_id'
+        expect(result).to be_nil
+      end
+
+      it "should delete some document by id" do
+        expect(transport).to receive(:delete).with(id: 'my_doc_id')
+        repository.delete_document 'my_doc_id'
+      end
+
+      it "should get multiple documents by id" do
+        response = open_response 'elasticsearch_mget_response_1'
+        expect(transport).to receive(:mget).with(body: { ids: ['id1', 'id2'] }).and_return response
+        expect_served_document_preparation :twice
+        result = repository.get_document ['id1', 'id2']
+        expect(result.count).to eq 2
+        expect(result[0]).to be_a Document
+        expect(result[1]).to be_a Document
+      end
+
+    end
+
+    context "on a percolation" do
+
+      before :each do
+        expect_percolator_preparation
+      end
+
+      it "should create a percolator" do
+        expect(transport).to receive(:index).with(index: 'my_index', type: '.percolator', id: 'my_id', body: { query: query.build_for_count })
+        expect_query_preparation
+        repository.create_percolator query, index: 'my_index', id: 'my_id'
+      end
+
+      it "should check a percolator" do
+        document = Document.new user: 'Pablo'
+        expect(transport).to receive(:percolate).with(index: 'my_index', type: 'my_type', body: { doc: { user: 'Pablo' } })
+        expect_document_preparation
+        repository.percolate_document document, index: 'my_index', type: 'my_type'
+      end
+
+    end
+
+    context "on a bulk request" do
+
+      let :source do
+        { some_field: 'some_value' }
+      end
+
+      let :document do
+        Document.create do |doc|
+          doc.id = 2
+          doc.type = 'post'
+          doc.index = 'insights'
+          doc.source = source
+        end
+      end
+
+      let :bulk_request do
+        repository.prepare_bulk do |br|
+          br.delete_document 2, type: 'post', index: 'insights'
+          br.create_document document
+          br.update_document 2, type: 'post', index: 'insights', source: source
+          br.index_document document
+        end
+      end
+
+      it "should execute the correct json" do
+        expect(transport).to receive(:bulk).with body: [
+          { delete: { _index: 'insights', _type: 'post', _id: 2 } },
+          { create: { _index: 'insights', _type: 'post', _id: 2 } },
+          { some_field: 'some_value' },
+          { update: { _index: 'insights', _type: 'post', _id: 2 } },
+          { doc: { some_field: 'some_value' } },
+          { index: { _index: 'insights', _type: 'post', _id: 2 } },
+          { some_field: 'some_value' }
+        ]
+        expect(bulk_request).to receive(:parse)
+        repository.execute_bulk bulk_request
+      end
+
+      it "should forward the 'parse' responsability" do
+        response = open_response 'elasticsearch_bulk_response_1'
+        expect(transport).to receive(:bulk).and_return response
+        expect(bulk_request).to receive(:parse).with(response)
+        repository.execute_bulk bulk_request
+      end
+
+    end
+
+    context "on invalid actions" do
+
+      it "should raise on an empty get" do
+        expect{ repository.get_document [] }.to raise_error RuntimeError
+      end
+
+      it "should raise on an multiple delete" do
+        expect{ repository.delete_document ['id1', 'id2'] }.to raise_error RuntimeError
+      end
+
+      it "should raise if no document source is specified" do
+        expect{ repository.update_document 'my_id', type: 'my_type', index: 'my_index' }.to raise_error RuntimeError
+      end
+
+      it "should raise if no index is specified" do
+        expect{ repository.update_document 'my_id', type: 'my_type', source: Hash.new }.to raise_error RuntimeError
+      end
+
+      it "should raise if no type is specified" do
+        expect{ repository.update_document 'my_id', index: 'my_index', source: Hash.new }.to raise_error RuntimeError
+      end
+
+      it "should raise if no document id is specified" do
+        expect{ repository.update_document type: 'my_type', index: 'my_index', source: Hash.new }.to raise_error RuntimeError
+      end
+
+    end
+
+  end
+end