es-elasticity 0.12.0 → 0.13.3.pre1

data/spec/units/multi_search_spec.rb

@@ -1,158 +0,0 @@
-require "elasticity/search"
-require "elasticity/multi_search"
-
-RSpec.describe Elasticity::MultiSearch do
-  let :client do
-    double(:client)
-  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 :index_with_one_hit do
-    {
-      "hits" => {
-        "total" => 1,
-        "hits" => [
-          { "_id" => 3, "_source" => { "name" => "baz" }}
-        ]
-      }
-    }
-  end
-
-  let :index_with_two_hits do
-    {
-      "hits" => {
-        "total" => 2,
-        "hits" => [
-          { "_id" => 1, "_source" => { "name" => "foo" }},
-          { "_id" => 2, "_source" => { "name" => "bar" }}
-        ]
-      }
-    }
-  end
-
-  let :aggregations do
-    {
-      "aggregations" => {
-        "logins_count" => { "value" => 1495 },
-        "gender" => {
-          "buckets" => [
-            {
-              "doc_count" => 100,
-              "key" => "M"
-            },
-            {
-              "doc_count" => 100,
-              "key" => "F"
-            }
-          ],
-          "doc_count_error_upper_bound" => 0,
-          "sum_other_doc_count" => 0
-        }
-      }
-    }
-  end
-
-  let :index_with_two_hits_and_aggregations do
-    index_with_two_hits.merge(aggregations)
-  end
-
-  let :response do
-    {
-      "responses" => [
-        index_with_two_hits_and_aggregations,
-        index_with_one_hit
-      ]
-    }
-  end
-
-  it "performs multi search" 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)
-
-    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 } },
-    ]).and_return(response)
-
-    expect(Array(subject[:first])).to eq [klass.new(_id: 1, name: "foo"), klass.new(_id: 2, name: "bar")]
-    expect(Array(subject[:second])).to eq [klass.new(_id: 3, name: "baz")]
-    expect(subject[:first].total).to eq 2
-    expect(subject[:first].total_pages).to eq 1
-    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
-    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(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

data/spec/units/search_spec.rb

@@ -1,230 +0,0 @@
-require "elasticity/search"
-
-RSpec.describe "Search" do
-  let(:client)         { double(:client) }
-  let(:index_name)     { "index_name" }
-  let(:document_type)  { "document" }
-  let(:body)           { {} }
-
-  let :full_response do
-    { "hits" => { "total" => 2, "hits" => [
-      { "_id" => 1, "_source" => { "name" => "foo" } },
-      { "_id" => 2, "_source" => { "name" => "bar" } },
-    ]}}
-  end
-
-  let :aggregations do
-    {
-      "logins_count" => { "value" => 1495 },
-      "gender" => {
-          "buckets" => [
-              {
-                  "doc_count" => 100,
-                  "key" => "M"
-              },
-              {
-                  "doc_count" => 100,
-                  "key" => "F"
-              }
-          ],
-          "doc_count_error_upper_bound" => 0,
-          "sum_other_doc_count" => 0
-      }
-    }
-  end
-
-  let :full_response_with_aggregations do
-    full_response.merge("aggregations" => aggregations)
-  end
-
-  let :ids_response do
-    { "hits" => { "total" => 2, "hits" => [
-      { "_id" => 1 },
-      { "_id" => 2 },
-    ]}}
-  end
-
-  let :empty_response do
-    { "hits" => { "total" => 0, "hits" => [] }}
-  end
-
-  let :scan_response do
-    { "_scroll_id" => "abc123", "hits" => { "total" => 2, "hits" => [
-      { "_id" => 1, "_source" => { "name" => "foo" } }
-    ]}}
-  end
-
-  let :scroll_response do
-    { "_scroll_id" => "abc456", "hits" => { "total" => 1, "hits" => [
-      { "_id" => 2, "_source" => { "name" => "bar" } },
-    ]}}
-  end
-
-  let :mapper do
-    -> (hit) {
-      klass.new(_id: hit["_id"], name: hit["_source"]["name"], age: hit["_source"]["age"])
-    }
-  end
-
-  let :klass do
-    Class.new do
-      include ActiveModel::Model
-      attr_accessor :_id, :name, :age
-
-      def ==(other)
-        self._id == other._id && self.name == other.name
-      end
-    end
-  end
-
-  describe Elasticity::Search::Facade do
-    subject do
-      described_class.new(client, Elasticity::Search::Definition.new(index_name, document_type, body))
-    end
-
-    it "searches the index and return document models" do
-      expect(client).to receive(:search).with(index: index_name, type: document_type, body: body).and_return(full_response)
-
-      docs = subject.documents(mapper)
-      expected = [klass.new(_id: 1, name: "foo"), klass.new(_id: 2, name: "bar")]
-
-      expect(docs.total).to eq 2
-      expect(docs.size).to eq expected.size
-
-      expect(docs).to_not be_empty
-      expect(docs).to_not be_blank
-
-      expect(docs[0].name).to eq expected[0].name
-      expect(docs[1].name).to eq expected[1].name
-
-      expect(docs.each.first).to eq expected[0]
-      expect(Array(docs)).to eq expected
-    end
-
-    it "searches and the index returns aggregations" do
-      expect(client).to receive(:search).with(index: index_name, type: document_type, body: body).and_return(full_response_with_aggregations)
-
-      docs = subject.documents(mapper)
-      expect(docs.aggregations).to eq aggregations
-    end
-
-    it "searches using scan&scroll" do
-      expect(client).to receive(:search).with(index: index_name, type: document_type, body: body, search_type: :query_then_fetch, size: 100, scroll: "1m").and_return(scan_response)
-      expect(client).to receive(:scroll).with(scroll_id: "abc123", scroll: "1m", body: { scroll_id: "abc123" }).and_return(scroll_response)
-      expect(client).to receive(:scroll).with(scroll_id: "abc456", scroll: "1m", body: { scroll_id: "abc456" }).and_return(empty_response)
-
-      docs = subject.scan_documents(mapper)
-      expected = [klass.new(_id: 1, name: "foo"), klass.new(_id: 2, name: "bar")]
-
-      expect(docs.total).to eq 2
-
-      expect(docs).to_not be_empty
-      expect(docs).to_not be_blank
-
-      expect(Array(docs)).to eq expected
-    end
-
-    it "searches the index and return active record models" do
-      expect(client).to receive(:search).with(index: index_name, type: document_type, body: body.merge(_source: false)).and_return(ids_response)
-
-      relation = double(:relation,
-        connection: double(:connection),
-        table_name: "table_name",
-        klass: double(:klass, primary_key: "id"),
-        to_sql: "SELECT * FROM table_name WHERE id IN (1)"
-      )
-
-      allow(relation.connection).to receive(:quote_column_name) { |name| name }
-      allow(relation.connection).to receive(:quote) { |name| name }
-
-      expect(relation).to receive(:where).with("table_name.id IN (?)", [1, 2]).and_return(relation)
-      expect(relation).to receive(:order).with("FIELD(table_name.id, 1,2)").and_return(relation)
-
-      expect(subject.active_records(relation).to_sql).to eq "SELECT * FROM table_name WHERE id IN (1)"
-    end
-  end
-
-  describe Elasticity::Search::LazySearch do
-    it "provides defaul properties for pagination" do
-      subject = Elasticity::Search::Facade.new(client, Elasticity::Search::Definition.new(index_name, document_type, body))
-      expect(client).to receive(:search).with(index: index_name, type: document_type, body: body).and_return(full_response)
-      docs = subject.documents(mapper)
-
-      expect(docs.per_page).to eq(10)
-      expect(docs.total_pages).to eq(1)
-      expect(docs.current_page).to eq(1)
-      expect(docs.next_page).to eq(nil)
-      expect(docs.previous_page).to eq(nil)
-    end
-
-    it "provides custom properties for pagination" do
-      subject = Elasticity::Search::Facade.new(
-        client,
-        Elasticity::Search::Definition.new(
-          index_name,
-          document_type,
-          { size: 15, from: 15, filter: {} }
-        )
-      )
-      expect(client).to receive(:search).
-        with(
-          index: index_name,
-          type: document_type,
-          body: { size: 15, from: 15, filter: {} }
-        ).and_return({ "hits" => { "total" => 112, "hits" => [] } })
-      docs = subject.documents(mapper)
-
-      expect(docs.per_page).to eq(15)
-      expect(docs.total_pages).to eq(8)
-      expect(docs.current_page).to eq(2)
-      expect(docs.next_page).to eq(3)
-      expect(docs.previous_page).to eq(1)
-    end
-
-    it "merges in additional arguments for search" do
-      results = double(:results, :[] => { "hits" => [] })
-      subject = Elasticity::Search::Facade.new(
-        client,
-        Elasticity::Search::Definition.new(index_name, document_type, {})
-      )
-
-      expect(client).to receive(:search).with(
-        index: index_name,
-        type: document_type,
-        body: {},
-        search_type: :dfs_query_and_fetch
-      ).and_return(results)
-      subject.documents(mapper, search_type: :dfs_query_and_fetch).search_results
-    end
-  end
-
-  describe Elasticity::Search::DocumentProxy do
-    let :search do
-      Elasticity::Search::Facade.new(client, Elasticity::Search::Definition.new(index_name, "document", body))
-    end
-
-    subject do
-      described_class.new(search, mapper)
-    end
-
-    it "automatically maps the documents into the provided Document class" do
-      expect(client).to receive(:search).with(index: index_name, type: document_type, body: body).and_return(full_response)
-      expect(Array(subject)).to eq [klass.new(_id: 1, name: "foo"), klass.new(_id: 2, name: "bar")]
-    end
-
-    it "delegates active_records for the underlying search" do
-      records = double(:records)
-      rel     = double(:relation)
-      expect(search).to receive(:active_records).with(rel).and_return(records)
-      expect(subject.active_records(rel)).to be records
-    end
-
-    it "accepts additional arguments for a search" do
-      results = double(:results)
-
-      expect(search).to receive(:documents).with(mapper, search_type: :dfs_query_then_fetch).and_return(results)
-      expect(subject.documents(search_type: :dfs_query_then_fetch)).to eq(results)
-    end
-
-  end
-end

data/spec/units/strategies/single_index_spec.rb

@@ -1,85 +0,0 @@
-RSpec.describe Elasticity::Strategies::SingleIndex, elasticsearch: true do
-  subject do
-    described_class.new(Elasticity.config.client, "test_index_name", "document")
-  end
-
-  let :index_def do
-    {
-      "mappings" => {
-        "document" => {
-          "properties" => {
-            "name" => { "type" => "text" }
-          }
-        }
-      }
-    }
-  end
-
-  after do
-    subject.delete_if_defined
-  end
-
-  it "allows creating, recreating and deleting an index" do
-    subject.create(index_def)
-    expect(subject.mapping).to eq(index_def)
-
-    subject.recreate(index_def)
-    expect(subject.mapping).to eq(index_def)
-
-    subject.delete
-    expect(subject.mapping).to be nil
-  end
-
-  it "returns nil for mapping and settings when index does not exist" do
-    expect(subject.mapping).to be nil
-    expect(subject.settings).to be nil
-  end
-
-  context "with existing index" do
-    before do
-      subject.create_if_undefined(index_def)
-    end
-
-    it "allows adding, getting and removing documents from the index" do
-      subject.index_document("document", 1, name: "test")
-
-      doc = subject.get_document("document", 1)
-      expect(doc["_source"]["name"]).to eq("test")
-
-      subject.delete_document("document", 1)
-      expect { subject.get_document("document", 1) }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
-    end
-
-    it "allows batching index and delete actions" do
-      results_a = subject.bulk do |b|
-        b.index "document", 1, name: "foo"
-      end
-      expect(results_a["errors"]).to be_falsey
-
-      results_b = subject.bulk do |b|
-        b.index  "document", 2, name: "bar"
-        b.delete "document", 1
-      end
-
-      expect(results_b["errors"]).to be_falsey
-
-      subject.flush
-
-      expect { subject.get_document("document", 1) }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
-      expect(subject.get_document("document", 2)).to eq({"_index"=>"test_index_name", "_type"=>"document", "_id"=>"2", "_version"=>1, "found"=>true, "_source"=>{"name"=>"bar"}})
-    end
-
-    it "allows deleting by query" do
-      subject.index_document("document", 1, name: "foo")
-      subject.index_document("document", 2, name: "bar")
-
-      subject.flush
-      subject.delete_by_query("document", query: { term: { name: "foo" } })
-
-      expect { subject.get_document("document", 1) }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
-      expect { subject.get_document("document", 2) }.to_not raise_error
-
-      subject.flush
-    end
-  end
-end