elasticsearch-model 6.0.0 → 6.1.0

data/spec/elasticsearch/model/adapters/active_record/parent_child_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe 'Elasticsearch::Model::Adapter::ActiveRecord Parent-Child' do
+
+  before(:all) do
+    ActiveRecord::Schema.define(version: 1) do
+      create_table :questions do |t|
+        t.string     :title
+        t.text       :text
+        t.string     :author
+        t.timestamps null: false
+      end
+
+      create_table :answers do |t|
+        t.text       :text
+        t.string     :author
+        t.references :question
+        t.timestamps null: false
+      end
+
+      add_index(:answers, :question_id) unless index_exists?(:answers, :question_id)
+
+      clear_tables(Question)
+      ParentChildSearchable.create_index!(force: true)
+
+      q_1 = Question.create!(title: 'First Question',  author: 'John')
+      q_2 = Question.create!(title: 'Second Question', author: 'Jody')
+
+      q_1.answers.create!(text: 'Lorem Ipsum', author: 'Adam')
+      q_1.answers.create!(text: 'Dolor Sit',   author: 'Ryan')
+
+      q_2.answers.create!(text: 'Amet Et', author: 'John')
+
+      Question.__elasticsearch__.refresh_index!
+    end
+  end
+
+  describe 'has_child search' do
+
+    let(:search_result) do
+      Question.search(query: { has_child: { type: 'answer', query: { match: { author: 'john' } } } })
+    end
+
+    it 'finds parents by matching on child search criteria' do
+      expect(search_result.records.first.title).to eq('Second Question')
+    end
+  end
+
+  describe 'hash_parent search' do
+
+    let(:search_result) do
+      Answer.search(query: { has_parent: { parent_type: 'question', query: { match: { author: 'john' } } } })
+    end
+
+    it 'finds children by matching in parent criteria' do
+      expect(search_result.records.map(&:author)).to match(['Adam', 'Ryan'])
+    end
+  end
+
+  context 'when a parent is deleted' do
+
+    before do
+      Question.where(title: 'First Question').each(&:destroy)
+      Question.__elasticsearch__.refresh_index!
+    end
+
+    let(:search_result) do
+      Answer.search(query: { has_parent: { parent_type: 'question', query: { match_all: {} } } })
+    end
+
+    it 'deletes the children' do
+      expect(search_result.results.total).to eq(1)
+    end
+  end
+end

data/spec/elasticsearch/model/adapters/active_record/serialization_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe 'Elasticsearch::Model::Adapter::ActiveRecord Serialization' do
+
+  before(:all) do
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table ArticleWithCustomSerialization.table_name do |t|
+        t.string   :title
+        t.string   :status
+      end
+    end
+
+    ArticleWithCustomSerialization.delete_all
+    ArticleWithCustomSerialization.__elasticsearch__.create_index!(force: true)
+  end
+
+  context 'when the model has a custom serialization defined' do
+
+    before do
+      ArticleWithCustomSerialization.create!(title: 'Test', status: 'green')
+      ArticleWithCustomSerialization.__elasticsearch__.refresh_index!
+    end
+
+    context 'when a document is indexed' do
+
+      let(:search_result) do
+        ArticleWithCustomSerialization.__elasticsearch__.client.get(index: 'article_with_custom_serializations',
+                                                                    type:  '_doc',
+                                                                    id:    '1')
+      end
+
+      it 'applies the serialization when indexing' do
+        expect(search_result['_source']).to eq('title' => 'Test')
+      end
+    end
+
+    context 'when a document is updated' do
+
+      before do
+        article.update_attributes(title: 'UPDATED', status: 'yellow')
+        ArticleWithCustomSerialization.__elasticsearch__.refresh_index!
+      end
+
+      let!(:article) do
+        art = ArticleWithCustomSerialization.create!(title: 'Test', status: 'red')
+        ArticleWithCustomSerialization.__elasticsearch__.refresh_index!
+        art
+      end
+
+      let(:search_result) do
+        ArticleWithCustomSerialization.__elasticsearch__.client.get(index: 'article_with_custom_serializations',
+                                                                    type:  '_doc',
+                                                                    id:    article.id)
+      end
+
+      it 'applies the serialization when updating' do
+        expect(search_result['_source']).to eq('title' => 'UPDATED')
+      end
+    end
+  end
+end

data/spec/elasticsearch/model/adapters/active_record_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Adapter::ActiveRecord do
+
+  before(:all) do
+    class DummyClassForActiveRecord; end
+  end
+
+  after(:all) do
+    Elasticsearch::Model::Adapter::Adapter.adapters.delete(DummyClassForActiveRecord)
+    remove_classes(DummyClassForActiveRecord)
+  end
+
+  let(:model) do
+    DummyClassForActiveRecord.new.tap do |m|
+      allow(m).to receive(:response).and_return(double('response', response: response))
+      allow(m).to receive(:ids).and_return(ids)
+    end
+  end
+
+  let(:response) do
+    { 'hits' => {'hits' => [ {'_id' => 2 }, {'_id' => 1 } ]} }
+  end
+
+  let(:ids) do
+    [2, 1]
+  end
+
+  let(:record_1) do
+    double('record').tap do |rec|
+      allow(rec).to receive(:id).and_return(1)
+    end
+  end
+
+  let(:record_2) do
+    double('record').tap do |rec|
+      allow(rec).to receive(:id).and_return(2)
+    end
+  end
+
+  let(:records) do
+    [record_1, record_2].tap do |r|
+      allow(r).to receive(:load).and_return(true)
+      allow(r).to receive(:exec_queries).and_return(true)
+    end
+  end
+
+  describe 'adapter registration' do
+
+    before(:all) do
+      DummyClassForActiveRecord.__send__ :include, Elasticsearch::Model::Adapter::ActiveRecord::Records
+    end
+
+    it 'can register an adapater' do
+      expect(Elasticsearch::Model::Adapter.adapters[Elasticsearch::Model::Adapter::ActiveRecord]).not_to be_nil
+      expect(Elasticsearch::Model::Adapter.adapters[Elasticsearch::Model::Adapter::ActiveRecord].call(DummyClassForActiveRecord)).to be(false)
+    end
+  end
+
+  describe '#records' do
+
+    before(:all) do
+      DummyClassForActiveRecord.__send__ :include, Elasticsearch::Model::Adapter::ActiveRecord::Records
+    end
+
+    let(:instance) do
+      model.tap do |inst|
+        allow(inst).to receive(:klass).and_return(double('class', primary_key: :some_key, where: records)).at_least(:once)
+        allow(inst).to receive(:order).and_return(double('class', primary_key: :some_key, where: records)).at_least(:once)
+      end
+    end
+
+    it 'returns the list of records' do
+      expect(instance.records).to eq(records)
+    end
+
+    it 'loads the records' do
+      expect(instance.load).to eq(true)
+    end
+
+    context 'when :includes is specified' do
+
+      before do
+        expect(records).to receive(:includes).with([:submodel]).once.and_return(records)
+        instance.options[:includes] = [:submodel]
+      end
+
+      it 'incorporates the includes option in the query' do
+        expect(instance.records).to eq(records)
+      end
+    end
+  end
+
+  describe 'callbacks registration' do
+
+    before do
+      expect(DummyClassForActiveRecord).to receive(:after_commit).exactly(3).times
+    end
+
+    it 'should register the model class for callbacks' do
+      Elasticsearch::Model::Adapter::ActiveRecord::Callbacks.included(DummyClassForActiveRecord)
+    end
+  end
+
+  describe 'importing' do
+
+    before do
+      DummyClassForActiveRecord.__send__ :extend, Elasticsearch::Model::Adapter::ActiveRecord::Importing
+    end
+
+    context 'when an invalid scope is specified' do
+
+      it 'raises a NoMethodError' do
+        expect {
+          DummyClassForActiveRecord.__find_in_batches(scope: :not_found_method)
+        }.to raise_exception(NoMethodError)
+      end
+    end
+
+    context 'when a valid scope is specified' do
+
+      before do
+        expect(DummyClassForActiveRecord).to receive(:find_in_batches).once.and_return([])
+        expect(DummyClassForActiveRecord).to receive(:published).once.and_return(DummyClassForActiveRecord)
+      end
+
+      it 'uses the scope' do
+        expect(DummyClassForActiveRecord.__find_in_batches(scope: :published)).to eq([])
+      end
+    end
+
+    context 'allow query criteria to be specified' do
+
+      before do
+        expect(DummyClassForActiveRecord).to receive(:find_in_batches).once.and_return([])
+        expect(DummyClassForActiveRecord).to receive(:where).with(color: 'red').once.and_return(DummyClassForActiveRecord)
+      end
+
+      it 'uses the scope' do
+        expect(DummyClassForActiveRecord.__find_in_batches(query: -> { where(color: 'red') })).to eq([])
+      end
+    end
+
+    context 'when preprocessing batches' do
+
+      context 'if the query returns results' do
+
+        before do
+          class << DummyClassForActiveRecord
+            def find_in_batches(options = {}, &block)
+              yield [:a, :b]
+            end
+
+            def update_batch(batch)
+              batch.collect { |b| b.to_s + '!' }
+            end
+          end
+        end
+
+        it 'applies the preprocessing method' do
+          DummyClassForActiveRecord.__find_in_batches(preprocess: :update_batch) do |batch|
+            expect(batch).to match(['a!', 'b!'])
+          end
+        end
+      end
+
+      context 'if the query does not return results' do
+
+        before do
+          class << DummyClassForActiveRecord
+            def find_in_batches(options = {}, &block)
+              yield [:a, :b]
+            end
+
+            def update_batch(batch)
+              []
+            end
+          end
+        end
+
+        it 'applies the preprocessing method' do
+          DummyClassForActiveRecord.__find_in_batches(preprocess: :update_batch) do |batch|
+            expect(batch).to match([])
+          end
+        end
+      end
+    end
+
+    context 'when transforming models' do
+
+      let(:instance) do
+        model.tap do |inst|
+          allow(inst).to receive(:id).and_return(1)
+          allow(inst).to receive(:__elasticsearch__).and_return(double('object', id: 1, as_indexed_json: {}))
+        end
+      end
+
+      it 'returns an proc' do
+        expect(DummyClassForActiveRecord.__transform.respond_to?(:call)).to be(true)
+      end
+
+      it 'provides a default transformation' do
+        expect(DummyClassForActiveRecord.__transform.call(instance)).to eq(index: { _id: 1, data: {} })
+      end
+    end
+  end
+end

data/spec/elasticsearch/model/adapters/default_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Adapter::Default do
+
+  before(:all) do
+    class DummyClassForDefaultAdapter; end
+    DummyClassForDefaultAdapter.__send__ :include, Elasticsearch::Model::Adapter::Default::Records
+    DummyClassForDefaultAdapter.__send__ :include, Elasticsearch::Model::Adapter::Default::Importing
+  end
+
+  after(:all) do
+    Elasticsearch::Model::Adapter::Adapter.adapters.delete(DummyClassForDefaultAdapter)
+    remove_classes(DummyClassForDefaultAdapter)
+  end
+
+  let(:instance) do
+    DummyClassForDefaultAdapter.new.tap do |m|
+      allow(m).to receive(:klass).and_return(double('class', primary_key: :some_key, find: [1])).at_least(:once)
+    end
+  end
+
+  it 'should have the default records implementation' do
+    expect(instance.records).to eq([1])
+  end
+
+  it 'should have the default Callback implementation' do
+    expect(Elasticsearch::Model::Adapter::Default::Callbacks).to be_a(Module)
+  end
+
+  it 'should have the default Importing implementation' do
+    expect {
+      DummyClassForDefaultAdapter.new.__find_in_batches
+    }.to raise_exception(Elasticsearch::Model::NotImplemented)
+  end
+
+  it 'should have the default transform implementation' do
+    expect {
+      DummyClassForDefaultAdapter.new.__transform
+    }.to raise_exception(Elasticsearch::Model::NotImplemented)
+  end
+end

data/spec/elasticsearch/model/adapters/mongoid/basic_spec.rb

@@ -0,0 +1,267 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Adapter::Mongoid, if: test_mongoid? do
+
+  before(:all) do
+    connect_mongoid('mongoid_test')
+    Elasticsearch::Model::Adapter.register \
+              Elasticsearch::Model::Adapter::Mongoid,
+              lambda { |klass| !!defined?(::Mongoid::Document) && klass.respond_to?(:ancestors) && klass.ancestors.include?(::Mongoid::Document) }
+
+    MongoidArticle.__elasticsearch__.create_index! force: true
+
+    MongoidArticle.delete_all
+
+    MongoidArticle.__elasticsearch__.refresh_index!
+    MongoidArticle.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'
+  end
+
+  after do
+    clear_indices(MongoidArticle)
+    clear_tables(MongoidArticle)
+  end
+
+  describe 'searching' do
+
+    before do
+      MongoidArticle.create! title: 'Test'
+      MongoidArticle.create! title: 'Testing Coding'
+      MongoidArticle.create! title: 'Coding'
+      MongoidArticle.__elasticsearch__.refresh_index!
+    end
+
+    let(:search_result) do
+      MongoidArticle.search('title:test')
+    end
+
+    it 'find the documents successfully' do
+      expect(search_result.results.size).to eq(2)
+      expect(search_result.records.size).to eq(2)
+    end
+
+    describe '#results' do
+
+      it 'returns a Elasticsearch::Model::Response::Result' do
+        expect(search_result.results.first).to be_a(Elasticsearch::Model::Response::Result)
+      end
+
+      it 'retrieves the document from Elasticsearch' do
+        expect(search_result.results.first.title).to eq('Test')
+      end
+
+      it 'retrieves all results' do
+        expect(search_result.results.collect(&:title)).to match(['Test', 'Testing Coding'])
+      end
+    end
+
+    describe '#records' do
+
+      it 'returns an instance of the model' do
+        expect(search_result.records.first).to be_a(MongoidArticle)
+      end
+
+      it 'retrieves the document from Elasticsearch' do
+        expect(search_result.records.first.title).to eq('Test')
+      end
+
+      it 'iterates over the records' do
+        expect(search_result.records.first.title).to eq('Test')
+      end
+
+      it 'retrieves all records' do
+        expect(search_result.records.collect(&:title)).to match(['Test', 'Testing Coding'])
+      end
+
+      describe '#each_with_hit' do
+
+        it 'yields each hit with the model object' do
+          search_result.records.each_with_hit do |r, h|
+            expect(h._source).not_to be_nil
+            expect(h._source.title).not_to be_nil
+          end
+        end
+
+        it 'preserves the search order' do
+          search_result.records.each_with_hit do |r, h|
+            expect(r.id.to_s).to eq(h._id)
+          end
+        end
+      end
+
+      describe '#map_with_hit' do
+
+        it 'yields each hit with the model object' do
+          search_result.records.map_with_hit do |r, h|
+            expect(h._source).not_to be_nil
+            expect(h._source.title).not_to be_nil
+          end
+        end
+
+        it 'preserves the search order' do
+          search_result.records.map_with_hit do |r, h|
+            expect(r.id.to_s).to eq(h._id)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#destroy' do
+
+    let(:article) do
+      MongoidArticle.create!(title: 'Test')
+    end
+
+    before do
+      article
+      MongoidArticle.create!(title: 'Coding')
+      article.destroy
+      MongoidArticle.__elasticsearch__.refresh_index!
+    end
+
+    it 'removes documents from the index' do
+      expect(MongoidArticle.search('title:test').results.total).to eq(0)
+      expect(MongoidArticle.search('title:code').results.total).to eq(1)
+    end
+  end
+
+  describe 'updates to the document' do
+
+    let(:article) do
+      MongoidArticle.create!(title: 'Test')
+    end
+
+    before do
+      article.title = 'Writing'
+      article.save
+      MongoidArticle.__elasticsearch__.refresh_index!
+    end
+
+    it 'indexes updates' do
+      expect(MongoidArticle.search('title:write').results.total).to eq(1)
+      expect(MongoidArticle.search('title:test').results.total).to eq(0)
+    end
+  end
+
+  describe 'DSL search' do
+
+    before do
+      MongoidArticle.create! title: 'Test'
+      MongoidArticle.create! title: 'Testing Coding'
+      MongoidArticle.create! title: 'Coding'
+      MongoidArticle.__elasticsearch__.refresh_index!
+    end
+
+    let(:search_result) do
+      MongoidArticle.search(query: { match: { title: { query: 'test' } } })
+    end
+
+    it 'finds the matching documents' do
+      expect(search_result.results.size).to eq(2)
+      expect(search_result.records.size).to eq(2)
+    end
+  end
+
+  describe 'paging a collection' do
+
+    before do
+      MongoidArticle.create! title: 'Test'
+      MongoidArticle.create! title: 'Testing Coding'
+      MongoidArticle.create! title: 'Coding'
+      MongoidArticle.__elasticsearch__.refresh_index!
+    end
+
+    let(:search_result) do
+      MongoidArticle.search(query: { match: { title: { query: 'test' } } },
+                            size: 2,
+                            from: 1)
+    end
+
+    it 'applies the size and from parameters' do
+      expect(search_result.results.size).to eq(1)
+      expect(search_result.results.first.title).to eq('Testing Coding')
+      expect(search_result.records.size).to eq(1)
+      expect(search_result.records.first.title).to eq('Testing Coding')
+    end
+  end
+
+  describe 'importing' do
+
+    before do
+      97.times { |i| MongoidArticle.create! title: "Test #{i}" }
+      MongoidArticle.__elasticsearch__.create_index! force: true
+      MongoidArticle.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'
+    end
+
+    context 'when there is no default scope' do
+
+      let!(:batch_count) do
+        batches = 0
+        errors  = MongoidArticle.import(batch_size: 10) do |response|
+          batches += 1
+        end
+        MongoidArticle.__elasticsearch__.refresh_index!
+        batches
+      end
+
+      it 'imports all the documents' do
+        expect(MongoidArticle.search('*').results.total).to eq(97)
+      end
+
+      it 'uses the specified batch size' do
+        expect(batch_count).to eq(10)
+      end
+    end
+
+    context 'when there is a default scope' do
+
+      around(:all) do |example|
+        10.times { |i| MongoidArticle.create! title: 'Test', views: "#{i}" }
+        MongoidArticle.default_scope -> { MongoidArticle.gt(views: 3) }
+        example.run
+        MongoidArticle.default_scoping = nil
+      end
+
+      before do
+        MongoidArticle.__elasticsearch__.import
+        MongoidArticle.__elasticsearch__.refresh_index!
+      end
+
+      it 'uses the default scope' do
+        expect(MongoidArticle.search('*').results.total).to eq(6)
+      end
+    end
+
+    context 'when there is a default scope and a query specified' do
+
+      around(:all) do |example|
+        10.times { |i| MongoidArticle.create! title: 'Test', views: "#{i}" }
+        MongoidArticle.default_scope -> { MongoidArticle.gt(views: 3) }
+        example.run
+        MongoidArticle.default_scoping = nil
+      end
+
+      before do
+        MongoidArticle.import(query: -> { lte(views: 4) })
+        MongoidArticle.__elasticsearch__.refresh_index!
+      end
+
+      it 'combines the query and the default scope' do
+        expect(MongoidArticle.search('*').results.total).to eq(1)
+      end
+    end
+
+    context 'when the batch is empty' do
+
+      before do
+        MongoidArticle.delete_all
+        MongoidArticle.import
+        MongoidArticle.__elasticsearch__.refresh_index!
+      end
+
+      it 'does not make any requests to create documents' do
+        expect(MongoidArticle.search('*').results.total).to eq(0)
+      end
+    end
+  end
+end