es-elasticity 0.8.3 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 027f21d0948b94e32c1df9c760f02149816e6444
-  data.tar.gz: 1edede15a6eab106d37ac9d39f4c7baed22f6736
+  metadata.gz: cbf73e91f2ff19dfbacefd71a7b370fe7b49e4d6
+  data.tar.gz: 30717c761dc0501315b0d7bd0bbba132a0ed3b99
 SHA512:
-  metadata.gz: 9c7749d76c8dcb7bf44a1f51becafa5bef7cb987b6ea71f15ad1ebc7fefe0e11938191f02f3dba49755c609c23eccd99bcc029bc80717512606deea25a54f0da
-  data.tar.gz: 28804e4fabfe66e03ac4494fde70663fe6055265f65758e459518454302d59386cdbc4c32f0b5bc9fd621f36263403b578891ed39d008fd6603e1d315d65f8a0
+  metadata.gz: 3015d7e3925ccf52831fb5410660db47ce24dfbb449b693745b0a05fc0607fef067475eb6a1efaa9f79887093ebda07640aa27fba5971989307ae44454a6eeee
+  data.tar.gz: a919b8cc74b7b9083d160fe00d5ddfe9556c184cff6842d14aef038722fb444c09056235ae68e071c18c0ffa98de6b6c29f66cc622921e748c6d45bdea98f3ad

data/README.md

@@ -90,8 +90,8 @@ class Search::User < Elasticity::Document
       },
     }
 
-    # Creates a search object from the body and return it.
-    # The returned object # is a lazy evaluated search that behaves like a collection, being
+    # Creates a search object from the body and return it.  The returned
+    # object is a lazy evaluated search that behaves like a collection, being
     # automatically triggered when data is iterated over.
     self.search(body)
   end
@@ -237,8 +237,8 @@ class Search::User < Elasticity::SegmentedDocument
       },
     }
 
-    # Creates a search object from the body and return it.
-    # The returned object # is a lazy evaluated search that behaves like a collection, being
+    # Creates a search object from the body and return it.  The returned
+    # object is a lazy evaluated search that behaves like a collection, being
     # automatically triggered when data is iterated over.
     self.search(body)
   end
@@ -279,7 +279,7 @@ users.adults.to_a # => [#<Search::User{"doximity.com"}:0x819cc5a50cd5 @_id="AVCH
 
 ### Strategies and Hot-remapping
 
-Strategies define how index creation and index operation happens on the lower level. Basically it define the structure that backs the document model. Currently, there are two strategies available: single-index and alias-index.
+Strategies define how index creation and index operation happens on the lower level. Basically it defines the structure that backs the document model. Currently, there are two strategies available: single-index and alias-index.
 
 The single-index strategy is the most straightforward one. It causes one index to be created and any operation will be performed directly on that index. It's very simple but it has the downside of being a lot harder to update existing mapping since you'll have to drop the index and recreate from scratch.
 

data/lib/elasticity.rb

@@ -22,19 +22,20 @@ require "active_model"
 require "elasticsearch"
 
 module Elasticity
-  autoload :Bulk,               "elasticity/bulk"
-  autoload :Config,             "elasticity/config"
-  autoload :IndexConfig,        "elasticity/index_config"
-  autoload :IndexMapper,        "elasticity/index_mapper"
-  autoload :BaseDocument,       "elasticity/base_document"
-  autoload :Document,           "elasticity/document"
-  autoload :SegmentedDocument,  "elasticity/segmented_document"
-  autoload :InstrumentedClient, "elasticity/instrumented_client"
-  autoload :LogSubscriber,      "elasticity/log_subscriber"
-  autoload :MultiSearch,        "elasticity/multi_search"
-  autoload :Search,             "elasticity/search"
-  autoload :Strategies,         "elasticity/strategies"
-  autoload :ScrollableSearch,   "elasticity/scrollable_search"
+  autoload :Bulk,                     "elasticity/bulk"
+  autoload :Config,                   "elasticity/config"
+  autoload :IndexConfig,              "elasticity/index_config"
+  autoload :IndexMapper,              "elasticity/index_mapper"
+  autoload :BaseDocument,             "elasticity/base_document"
+  autoload :Document,                 "elasticity/document"
+  autoload :SegmentedDocument,        "elasticity/segmented_document"
+  autoload :InstrumentedClient,       "elasticity/instrumented_client"
+  autoload :LogSubscriber,            "elasticity/log_subscriber"
+  autoload :MultiSearch,              "elasticity/multi_search"
+  autoload :Search,                   "elasticity/search"
+  autoload :Strategies,               "elasticity/strategies"
+  autoload :ScrollableSearch,         "elasticity/scrollable_search"
+  autoload :MultiSearchResponseParser, "elasticity/multi_search_response_parser"
 
   def self.configure
     @config = Config.new

data/lib/elasticity/multi_search.rb

@@ -1,7 +1,7 @@
 module Elasticity
   class MultiSearch
-
     def initialize(msearch_args = {})
+      @results  = {}
       @searches = {}
       @mappers  = {}
       @msearch_args = msearch_args
@@ -25,39 +25,31 @@ module Elasticity
     end
 
     def [](name)
-      results_collection[name]
+      @results[name] ||= result_for(name)
     end
 
     private
 
-    def results_collection
-      @results_collection ||= fetch
-    end
+    def result_for(name)
+      search = @searches[name]
+      return if search.nil?
 
-    def fetch
-      bodies = @searches.values.map do |hsh|
-        hsh[:search_definition].to_msearch_args
-      end
+      query_response = response_for(@searches.keys.index(name))
+      MultiSearchResponseParser.parse(query_response, search)
+    end
 
-      response = ActiveSupport::Notifications.instrument("multi_search.elasticity", args: { body: bodies }) do
+    def response_for(index)
+      @response ||= ActiveSupport::Notifications.instrument("multi_search.elasticity", args: { body: bodies }) do
         args = { body: bodies.map(&:dup) }.reverse_merge(@msearch_args)
         Elasticity.config.client.msearch(args)
       end
-      results = {}
-
-      @searches.keys.each_with_index do |name, idx|
-        resp = response["responses"][idx]
-        search = @searches[name]
-
-        results[name] = case
-        when search[:documents]
-          Search::Results.new(resp, search[:search_definition].body, search[:documents].method(:map_hit))
-        when search[:active_records]
-          Search::ActiveRecordProxy.map_response(search[:active_records], search[:search_definition].body, resp)
-        end
-      end
+      @response["responses"][index]
+    end
 
-      results
+    def bodies
+      @bodies ||= @searches.values.map do |hsh|
+        hsh[:search_definition].to_msearch_args
+      end
     end
   end
 end

data/lib/elasticity/multi_search_response_parser.rb

@@ -0,0 +1,22 @@
+module Elasticity
+  class MultiSearchResponseParser
+    class UnknownError < StandardError; end
+
+    def self.parse(response, search)
+      raise error_for(response["status"]), response.to_json if response["error"]
+
+      case
+      when search[:documents]
+        Search::Results.new(response, search[:search_definition].body, search[:documents].method(:map_hit))
+      when search[:active_records]
+        Search::ActiveRecordProxy.map_response(search[:active_records], search[:search_definition].body, response)
+      end
+    end
+
+    private
+
+    def self.error_for(status)
+      Elasticsearch::Transport::Transport::ERRORS[status] || UnknownError
+    end
+  end
+end

data/lib/elasticity/version.rb

@@ -1,3 +1,3 @@
 module Elasticity
-  VERSION = "0.8.3"
+  VERSION = "0.8.4"
 end

data/spec/units/multi_search_response_parser_spec.rb

@@ -0,0 +1,121 @@
+require "elasticity/multi_search_response_parser"
+
+RSpec.describe Elasticity::MultiSearchResponseParser do
+  describe ".parse" do
+    let :response do
+      {
+        "hits" => {
+          "total" => 2,
+          "hits" => [
+            { "_id" => 1, "_source" => { "name" => "foo" }},
+            { "_id" => 2, "_source" => { "name" => "bar" }}
+          ]
+        }
+      }
+    end
+
+    let :klass do
+      Class.new do
+        include ActiveModel::Model
+        attr_accessor :_id, :name
+
+        def self.map_hit(hit)
+          new(_id: hit["_id"], name: hit["_source"]["name"])
+        end
+
+        def ==(other)
+          self._id == other._id && self.name == other.name
+        end
+      end
+    end
+
+    let :search do
+      body = {
+        index: "index_first",
+        type: "document_first",
+        search: { search: :first, size: 2 }
+      }
+
+      {
+        search_definition: OpenStruct.new(body: body),
+        documents: klass
+      }
+    end
+
+    it "parses a simple reponse" do
+      search_result = described_class.parse(response, search)
+
+      expect(search_result[0].name).to eq "foo"
+      expect(search_result[1].name).to eq "bar"
+    end
+
+    context "for a 400 error response" do
+      let(:response) do
+        {
+          "error" => {
+            "root_cause" => [
+              {
+                "type" => "too_many_clauses",
+                "reason" => "too_many_clauses: maxClauseCount is set to 1024"
+              }
+            ],
+          },
+          "status" => 400
+        }
+      end
+
+      it "raises an error for the given status code" do
+        expect { described_class.parse response, search }.to(
+          raise_error Elasticsearch::Transport::Transport::Errors::BadRequest,
+                      response.to_json
+        )
+      end
+    end
+
+    context "for a 500 error response" do
+      let(:response) do
+        {
+          "error" => {
+            "root_cause" => [
+              {
+                "type" => "not_index_found",
+                "reason" => "not_index_found: index bla was not found"
+              }
+            ],
+          },
+          "status" => 500
+        }
+      end
+
+      it "raises an error for the given status code" do
+        expect { described_class.parse response, search }.to(
+          raise_error Elasticsearch::Transport::Transport::Errors::InternalServerError,
+                      response.to_json
+        )
+      end
+    end
+
+    context "for an unknown error response" do
+      let(:response) do
+        {
+          "error" => {
+            "root_cause" => [
+              {
+                "type" => "known_error",
+                "reason" => "known_error: Something wrong happened"
+              }
+            ],
+          },
+          "status" => 555
+        }
+      end
+
+      it "raises an unkown error for an known status code" do
+        expect { described_class.parse response, search }.to(
+          raise_error Elasticity::MultiSearchResponseParser::UnknownError,
+                      response.to_json
+        )
+      end
+    end
+  end
+end

data/spec/units/multi_search_spec.rb

@@ -95,18 +95,64 @@ RSpec.describe Elasticity::MultiSearch do
     expect(subject[:first].current_page).to eq 1
     expect(subject[:first].aggregations).to eq aggregations["aggregations"]
     expect(subject[:second].aggregations).to eq Hash.new
+    expect(subject[:third]).to be_nil
   end
 
   it "performs multi search with additional arguments" do
-    msearch = Elasticity::MultiSearch.new(search_type: :dfs_query_then_fetch)
-    msearch.add(:first, Elasticity::Search::Facade.new(client, Elasticity::Search::Definition.new("index_first", "document_first", { search: :first, size: 2 })), documents: klass)
-    msearch.add(:second, Elasticity::Search::Facade.new(client, Elasticity::Search::Definition.new("index_second", "document_second", { search: :second })), documents: klass)
+    subject = Elasticity::MultiSearch.new(search_type: :dfs_query_then_fetch)
+    subject.add(:first, Elasticity::Search::Facade.new(client, Elasticity::Search::Definition.new("index_first", "document_first", { search: :first, size: 2 })), documents: klass)
+    subject.add(:second, Elasticity::Search::Facade.new(client, Elasticity::Search::Definition.new("index_second", "document_second", { search: :second })), documents: klass)
 
     expect(Elasticity.config.client).to receive(:msearch).with(search_type: :dfs_query_then_fetch, body: [
       { index: "index_first", type: "document_first", search: { search: :first, size: 2 } },
       { index: "index_second", type: "document_second", search: { search: :second } },
     ]).and_return(response)
 
-    expect(Array(msearch[:first])).to eq([klass.new(_id: 1, name: "foo"), klass.new(_id: 2, name: "bar")])
+    expect(Array(subject[:first])).to eq([klass.new(_id: 1, name: "foo"), klass.new(_id: 2, name: "bar")])
+  end
+
+  context "when there was an error for one query" do
+    let(:error) do
+      {
+        "error" => {
+          "root_cause" => [
+            {
+              "type" => "too_many_clauses",
+              "reason" => "too_many_clauses: maxClauseCount is set to 1024"
+            }
+          ],
+          "type" => "search_phase_execution_exception",
+          "grouped" => true,
+        },
+        "status" => 400
+      }
+    end
+
+    let(:response) do
+      {
+        "responses" => [
+          index_with_two_hits_and_aggregations,
+          index_with_one_hit,
+          error
+        ]
+      }
+    end
+
+    before do
+      expect(Elasticity.config.client).to receive(:msearch).with(body: [
+        { index: "index_first", type: "document_first", search: { search: :first, size: 2 } },
+        { index: "index_second", type: "document_second", search: { search: :second } },
+        { index: "index_third", type: "document_third", search: { search: :third } },
+      ]).and_return(response)
+    end
+
+    it "raises an error while trying to access the query result" do
+      subject.add(:first, Elasticity::Search::Facade.new(client, Elasticity::Search::Definition.new("index_first", "document_first", { search: :first, size: 2 })), documents: klass)
+      subject.add(:second, Elasticity::Search::Facade.new(client, Elasticity::Search::Definition.new("index_second", "document_second", { search: :second })), documents: klass)
+      subject.add(:third, Elasticity::Search::Facade.new(client, Elasticity::Search::Definition.new("index_third", "document_third", { search: :third })), documents: klass)
+
+      expect(Array(subject[:first])).to eq [klass.new(_id: 1, name: "foo"), klass.new(_id: 2, name: "bar")]
+      expect { subject[:third] }.to raise_error Elasticsearch::Transport::Transport::Errors::BadRequest, error.to_json
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: es-elasticity
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.4
 platform: ruby
 authors:
 - Rodrigo Kochenburger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-07 00:00:00.000000000 Z
+date: 2017-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -221,6 +221,7 @@ files:
 - lib/elasticity/instrumented_client.rb
 - lib/elasticity/log_subscriber.rb
 - lib/elasticity/multi_search.rb
+- lib/elasticity/multi_search_response_parser.rb
 - lib/elasticity/railtie.rb
 - lib/elasticity/scrollable_search.rb
 - lib/elasticity/search.rb
@@ -235,6 +236,7 @@ files:
 - spec/units/document_spec.rb
 - spec/units/index_config_spec.rb
 - spec/units/index_mapper_spec.rb
+- spec/units/multi_search_response_parser_spec.rb
 - spec/units/multi_search_spec.rb
 - spec/units/search_spec.rb
 - spec/units/strategies/single_index_spec.rb
@@ -258,7 +260,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: ActiveModel-based library for working with Elasticsearch
@@ -269,6 +271,7 @@ test_files:
 - spec/units/document_spec.rb
 - spec/units/index_config_spec.rb
 - spec/units/index_mapper_spec.rb
+- spec/units/multi_search_response_parser_spec.rb
 - spec/units/multi_search_spec.rb
 - spec/units/search_spec.rb
 - spec/units/strategies/single_index_spec.rb