es-elasticity 0.12.0 → 0.13.3.pre1

data/spec/functional/search_spec.rb

@@ -1,117 +0,0 @@
-RSpec.describe "Search", elasticsearch: true do
-  class CatDoc < Elasticity::Document
-    configure do |c|
-      c.strategy = Elasticity::Strategies::SingleIndex
-      c.document_type  = "cat"
-      c.mapping = { "properties" => {
-        name: { type: "text" },
-        description: { type: "text" },
-        age: { type: "integer" }
-      } }
-    end
-
-    attr_accessor :name, :age, :description
-
-    def to_document
-      { name: name, age: age, description: description }
-    end
-  end
-
-  class DogDoc < Elasticity::Document
-    configure do |c|
-      c.strategy = Elasticity::Strategies::SingleIndex
-      c.document_type = "dog"
-      c.mapping = { "properties" => {
-        name: { type: "keyword" },
-        description: { type: "text" },
-        age: { type: "integer" },
-        hungry: { type: "boolean" }
-      } }
-    end
-    attr_accessor :name, :age, :description, :hungry
-
-    def to_document
-      { name: name, age: age, description: description, hungry: hungry }
-    end
-  end
-
-  describe "search_args" do
-    before do
-      CatDoc.recreate_index
-      DogDoc.recreate_index
-
-      @elastic_search_client.cluster.health wait_for_status: 'yellow'
-
-      cat = CatDoc.new(name: "felix the cat", age: 10, description: "I am an old cat")
-      dog = DogDoc.new(name: "fido", age: 4, hungry: true, description: "I am a hungry dog")
-
-      cat.update
-      dog.update
-
-      CatDoc.flush_index
-    end
-
-    describe "explain: true" do
-      def get_explanations(results)
-        results.map(&:_explanation)
-      end
-
-      it "supports on single index search results" do
-        results = CatDoc.search({}, { explain: true }).search_results
-
-        expect(get_explanations(results)).to all( be_truthy )
-      end
-
-      it "supports for multisearch" do
-        cat = CatDoc.search({}, { explain: true })
-        dog = DogDoc.search({})
-
-        subject = Elasticity::MultiSearch.new do |m|
-          m.add(:cats, cat, documents: CatDoc)
-          m.add(:dogs, dog, documents: DogDoc)
-        end
-
-        expect(get_explanations(subject[:cats])).to all( be_truthy )
-        expect(get_explanations(subject[:dogs])).to all( be_nil )
-      end
-    end
-
-    describe "highlight" do
-      it "is nil when the highlight does not return" do
-        results =  CatDoc.search({}).search_results
-
-        expect(results.first.highlighted_attrs).to be_nil
-        expect(results.first.highlighted).to be_nil
-      end
-
-      describe "when specifying highlight" do
-        let(:cat_search_result) {
-          highlight_search = {
-              query: {
-                  multi_match: {
-                      query: "cat",
-                      fields: ["name^1000", "description"]
-                  }
-              },
-              highlight: {
-                  fields: {
-                      "*": {}
-                  }
-              }
-          }
-
-          CatDoc.search(highlight_search).search_results.first
-        }
-
-        it "highlighted_attrs returns the highlighted" do
-          expect(cat_search_result.highlighted_attrs).to eq(["name", "description"])
-        end
-
-        it "highlighted returns a new object with the name transformed" do
-          expect(cat_search_result.highlighted.name.first).to include("felix")
-          expect(cat_search_result.highlighted.description.first).to include("old")
-        end
-      end
-    end
-  end
-end

data/spec/functional/segmented_spec.rb

@@ -1,86 +0,0 @@
-RSpec.describe "Segmented indexes", elasticsearch: true do
-  subject do
-    Class.new(Elasticity::SegmentedDocument) do
-      def self.name
-        "SomeClass"
-      end
-
-      configure do |c|
-        c.index_base_name = "people"
-        c.document_type = "person"
-        c.mapping = {
-          properties: {
-            name: { type: "text" },
-          },
-        }
-      end
-
-      attr_accessor :name
-
-      def self.by_name(name)
-        search(query: { match: { name: name } })
-      end
-
-      def to_document
-        { name: name }
-      end
-    end
-  end
-
-  def ensure_index(*segments)
-    @indexed ||= []
-    segments.each(&:recreate_index)
-    @indexed += segments
-  end
-
-  after do
-    Array(@indexed).each { |i| i.delete_index }
-  end
-
-  it "allows all operations on a segment" do
-    seg = subject.segment("A")
-    ensure_index(seg)
-
-    rodrigo = seg.new(name: "rodrigo")
-
-    id, success = rodrigo.update
-    expect(id).to be_kind_of(String)
-    expect(success).to be true
-
-    seg.flush_index
-    results = seg.by_name("rodrigo").to_a.first
-    expect(results.class).to eq rodrigo.class
-    expect(results.name).to eq rodrigo.name
-
-    rodrigo.delete
-    seg.flush_index
-
-    results = seg.by_name("rodrigo").to_a
-    expect(results).to be_empty
-  end
-
-  it "isolates segments from one another" do
-    seg_a = subject.segment("A")
-    seg_b = subject.segment("B")
-    ensure_index(seg_a, seg_b)
-
-    doc_a = seg_a.new(name: "doc a")
-    _, success = doc_a.update
-    expect(success).to be true
-
-    doc_b = seg_b.new(name: "doc b")
-    _, success = doc_b.update
-    expect(success).to be true
-
-    seg_a.flush_index
-    seg_b.flush_index
-
-    res_a = seg_a.by_name("doc").to_a.first
-    expect(res_a.class).to eq doc_a.class
-    expect(res_a.name).to eq doc_a.name
-
-    res_b = seg_b.by_name("doc").to_a.first
-    expect(res_b.class).to eq doc_b.class
-    expect(res_b.name).to eq doc_b.name
-  end
-end

data/spec/rspec_config.rb

@@ -1,42 +0,0 @@
-require "simplecov"
-require "oj"
-
-SimpleCov.start
-
-require "elasticity"
-require "pry"
-require "byebug"
-
-def elastic_search_client
-  return @elastic_search_client if defined?(@elastic_search_client)
-  @elastic_search_client = Elasticsearch::Client.new host: "http://0.0.0.0:9200"
-end
-
-logger = Logger.new("spec/spec.log")
-logger.level = Logger::DEBUG
-
-ActiveSupport::LogSubscriber.logger = logger
-Elasticity::LogSubscriber.attach_to(:elasticity)
-
-RSpec.configure do |c|
-  c.disable_monkey_patching!
-
-  c.before(:suite) do
-    logger.info "init.rspec Starting test suite execution"
-  end
-
-  c.before(:each) do |example|
-    logger.info "spec.rspec #{example.full_description}"
-
-    if example.metadata[:elasticsearch]
-      client = elastic_search_client
-    else
-      client = double(:elasticsearch_client)
-    end
-
-    Elasticity.configure do |e|
-      e.client    = client
-      e.namespace = "elasticity_test"
-    end
-  end
-end

data/spec/units/document_spec.rb

@@ -1,63 +0,0 @@
-require "elasticity/search"
-
-RSpec.describe Elasticity::Document do
-  mappings = {
-    properties: {
-      name: { type: "string" },
-
-      items: {
-        type: "nested",
-        properties: {
-          name: { type: "string" },
-        },
-      }
-    }
-  }
-
-  let :klass do
-    Class.new(described_class) do
-      def self.name
-        "SomeClass"
-      end
-
-      configure do |c|
-        c.index_base_name = "class_names"
-        c.document_type   = "class_name"
-        c.mapping         = mappings
-        c.settings = { number_of_shards: 2 }
-      end
-
-      attr_accessor :name, :items
-
-      def to_document
-        { name: name, items: items }
-      end
-    end
-  end
-
-  let :strategy do
-    double(:strategy)
-  end
-
-  before :each do
-    allow(Elasticity::Strategies::AliasIndex).to receive(:new).and_return(strategy)
-  end
-
-  it "requires subclasses to define to_document method" do
-    expect { Class.new(described_class).new.to_document }.to raise_error(NotImplementedError)
-  end
-
-  context "instance" do
-    subject { klass.new _id: 1, name: "Foo", items: [{ name: "Item1" }] }
-
-    it "stores the document in the strategy" do
-      expect(strategy).to receive(:index_document).with("class_name", 1, { name: "Foo", items: [{ name: "Item1" }] }).and_return("_id" => "1", "created" => true)
-      subject.update
-    end
-
-    it "assigns number_of_shards if present" do
-      expect(subject.config.settings[:number_of_shards]).to eq 2
-      expect(subject.config.definition[:settings][:number_of_shards]).to eq 2
-    end
-  end
-end

data/spec/units/index_config_spec.rb

@@ -1,97 +0,0 @@
-require 'elasticity/index_config'
-
-RSpec.describe Elasticity::IndexConfig do
-  let(:elasticity_config) { double("config", client: double("client", versions: ["5.3.4"])) }
-  subject {  }
-
-    let(:defaults) do
-      {
-        index_base_name: 'users',
-        document_type: 'user'
-      }
-    end
-
-  it 'accepts default configuration options' do
-    config = described_class.new(elasticity_config, defaults) {}
-    expect(config.index_base_name).to eql('users')
-    expect(config.document_type).to eql('user')
-  end
-
-  it 'overrides defaults' do
-    config = described_class.new(elasticity_config, defaults) do |c|
-      c.index_base_name = 'user_documents'
-      c.document_type = 'users'
-    end
-
-    expect(config.index_base_name).to eql('user_documents')
-    expect(config.document_type).to eql('users')
-  end
-
-  context "subclass warnings and exceptions" do
-    class Multied < Elasticity::Document
-    end
-    describe "multi_mapping exceptions" do
-      it "raises an exception for version 7 and above if subclasses are configured" do
-        stub_version("7.0.0")
-        expect do
-          Multied.configure do |c|
-            c.index_base_name = "cats_and_dogs"
-            c.strategy = Elasticity::Strategies::SingleIndex
-            c.subclasses = { cat: "Cat", dog: "Dog" }
-          end
-        end.to raise_error(
-          Elasticity::IndexConfig::SubclassError,
-          Elasticity::IndexConfig::SUBCLASSES_ERROR
-        )
-      end
-
-      it "does not raise an exception for version 7 and above if no subclasses are configured" do
-        stub_version("7.0.0")
-        expect do
-          Multied.configure do |c|
-            c.index_base_name = "cats_and_dogs"
-            c.strategy = Elasticity::Strategies::SingleIndex
-          end
-        end.to_not raise_error
-      end
-    end
-
-    describe "multi_mapping warnings" do
-      it "warns if multi_mapping is not supported by the ES version" do
-        stub_version("6.0.2")
-        expect do
-          Multied.configure do |c|
-            c.index_base_name = "cats_and_dogs"
-            c.strategy = Elasticity::Strategies::SingleIndex
-            c.subclasses = { cat: "Cat", dog: "Dog" }
-          end
-        end.to output("#{Elasticity::IndexConfig::SUBCLASSES_WARNING}\n").to_stderr
-      end
-
-      it "does not warn if multi_mapping is supported by the ES version" do
-        stub_version("5.3.1")
-        expect do
-          Multied.configure do |c|
-            c.index_base_name = "cats_and_dogs"
-            c.strategy = Elasticity::Strategies::SingleIndex
-            c.subclasses = { cat: "Cat", dog: "Dog" }
-          end
-        end.to_not output.to_stderr
-      end
-
-      it "does not warn when no subclasses are configured" do
-        stub_version("6.0.2")
-        expect do
-          Multied.configure do |c|
-            c.index_base_name = "cats_and_dogs"
-            c.strategy = Elasticity::Strategies::SingleIndex
-          end
-        end.to_not output.to_stderr
-      end
-    end
-
-    def stub_version(version)
-      allow_any_instance_of(Elasticity::InstrumentedClient).to receive(:versions).and_return([version])
-    end
-  end
-end

data/spec/units/index_mapper_spec.rb

@@ -1,4 +0,0 @@
-require "elasticity/index_mapper"
-
-RSpec.describe Elasticity::IndexMapper do
-end

data/spec/units/multi_search_response_parser_spec.rb

@@ -1,121 +0,0 @@
-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