elasticsearch-model 6.0.0 → 6.1.0

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

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe 'Elasticsearch::Model::Adapter::ActiveRecord Multimodel', if: test_mongoid? do
+
+  before(:all) do
+    connect_mongoid('mongoid_test')
+
+    begin
+      ActiveRecord::Schema.define(:version => 1) do
+      create_table Episode.table_name do |t|
+        t.string :name
+        t.datetime :created_at, :default => 'NOW()'
+      end
+      end
+    rescue
+    end
+  end
+
+  before do
+    clear_tables(Episode, Image)
+    Episode.__elasticsearch__.create_index! force: true
+    Episode.create name: "TheEpisode"
+    Episode.create name: "A great Episode"
+    Episode.create name: "The greatest Episode"
+    Episode.__elasticsearch__.refresh_index!
+
+    Image.__elasticsearch__.create_index! force: true
+    Image.create! name: "The Image"
+    Image.create! name: "A great Image"
+    Image.create! name: "The greatest Image"
+    Image.__elasticsearch__.refresh_index!
+    Image.__elasticsearch__.client.cluster.health wait_for_status: 'yellow'
+  end
+
+  after do
+    [Episode, Image].each do |model|
+      model.__elasticsearch__.client.delete_by_query(index: model.index_name, q: '*')
+      model.delete_all
+      model.__elasticsearch__.refresh_index!
+    end
+  end
+
+  context 'when the search is across multimodels with different adapters' do
+
+    let(:search_result) do
+      Elasticsearch::Model.search(%q<"greatest Episode" OR "greatest Image"^2>, [Episode, Image])
+    end
+
+    it 'executes the search across models' do
+      expect(search_result.results.size).to eq(2)
+      expect(search_result.records.size).to eq(2)
+    end
+
+    it 'returns the correct type of model instance' do
+      expect(search_result.records[0]).to be_a(Image)
+      expect(search_result.records[1]).to be_a(Episode)
+    end
+
+    it 'creates the model instances with the correct attributes' do
+      expect(search_result.results[0].name).to eq('The greatest Image')
+      expect(search_result.records[0].name).to eq('The greatest Image')
+      expect(search_result.results[1].name).to eq('The greatest Episode')
+      expect(search_result.records[1].name).to eq('The greatest Episode')
+    end
+  end
+end

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

@@ -0,0 +1,235 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Adapter::Mongoid do
+
+  before(:all) do
+    class DummyClassForMongoid; end
+    ::Symbol.class_eval { def in; self; end }
+  end
+
+  after(:all) do
+    Elasticsearch::Model::Adapter::Adapter.adapters.delete(DummyClassForMongoid)
+    remove_classes(DummyClassForMongoid)
+  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(:load).and_return(true)
+      allow(rec).to receive(:id).and_return(2)
+    end
+  end
+
+  let(:records) do
+    [record_1, record_2]
+  end
+
+  let(:model) do
+    DummyClassForMongoid.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
+
+  describe 'adapter registration' do
+
+    it 'registers an adapater' do
+      expect(Elasticsearch::Model::Adapter.adapters[Elasticsearch::Model::Adapter::Mongoid]).not_to be_nil
+      expect(Elasticsearch::Model::Adapter.adapters[Elasticsearch::Model::Adapter::Mongoid].call(DummyClassForMongoid)).to be(false)
+    end
+
+    it 'registers the records module' do
+      expect(Elasticsearch::Model::Adapter::Mongoid::Records).to be_a(Module)
+    end
+  end
+
+  describe '#records' do
+
+    before(:all) do
+      DummyClassForMongoid.__send__ :include, Elasticsearch::Model::Adapter::Mongoid::Records
+    end
+
+    let(:instance) do
+      model.tap do |inst|
+        allow(inst).to receive(:klass).and_return(double('class', where: records)).at_least(:once)
+      end
+    end
+
+    it 'returns the records' do
+      expect(instance.records).to eq(records)
+    end
+
+    context 'when an order is not defined for the Mongoid query' do
+
+      context 'when the records have a different order than the hits' do
+
+        before do
+          records.instance_variable_set(:@records, records)
+        end
+
+        it 'reorders the records based on hits order' do
+          expect(records.collect(&:id)).to eq([1, 2])
+          expect(instance.records.to_a.collect(&:id)).to eq([2, 1])
+        end
+      end
+
+      context 'when an order is defined for the Mongoid query' do
+
+        context 'when the records have a different order than the hits' do
+
+          before do
+            records.instance_variable_set(:@records, records)
+            expect(instance.records).to receive(:asc).and_return(records)
+          end
+
+          it 'reorders the records based on hits order' do
+            expect(records.collect(&:id)).to eq([1, 2])
+            expect(instance.records.to_a.collect(&:id)).to eq([2, 1])
+            expect(instance.asc.to_a.collect(&:id)).to eq([1, 2])
+          end
+        end
+      end
+    end
+
+    describe 'callbacks registration' do
+
+      before do
+        expect(DummyClassForMongoid).to receive(:after_create).once
+        expect(DummyClassForMongoid).to receive(:after_update).once
+        expect(DummyClassForMongoid).to receive(:after_destroy).once
+      end
+
+      it 'should register the model class for callbacks' do
+        Elasticsearch::Model::Adapter::Mongoid::Callbacks.included(DummyClassForMongoid)
+      end
+    end
+  end
+
+  describe 'importing' do
+
+    before(:all) do
+      DummyClassForMongoid.__send__ :extend, Elasticsearch::Model::Adapter::Mongoid::Importing
+    end
+
+    let(:relation) do
+      double('relation', each_slice: []).tap do |rel|
+        allow(rel).to receive(:published).and_return(rel)
+        allow(rel).to receive(:no_timeout).and_return(rel)
+        allow(rel).to receive(:class_exec).and_return(rel)
+      end
+    end
+
+    before do
+      allow(DummyClassForMongoid).to receive(:all).and_return(relation)
+    end
+
+    context 'when a scope is specified' do
+
+      it 'applies the scope' do
+        expect(DummyClassForMongoid.__find_in_batches(scope: :published) do; end).to eq([])
+      end
+    end
+
+    context 'query criteria specified as a proc' do
+
+      let(:query) do
+        Proc.new { where(color: "red") }
+      end
+
+      it 'execites the query' do
+        expect(DummyClassForMongoid.__find_in_batches(query: query) do; end).to eq([])
+      end
+    end
+
+    context 'query criteria specified as a hash' do
+
+      before do
+        expect(relation).to receive(:where).with(color: 'red').and_return(relation)
+      end
+
+      let(:query) do
+        { color: "red" }
+      end
+
+      it 'execites the query' do
+        expect(DummyClassForMongoid.__find_in_batches(query: query) do; end).to eq([])
+      end
+    end
+
+    context 'when preprocessing batches' do
+
+      context 'if the query returns results' do
+
+        before do
+          class << DummyClassForMongoid
+            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
+          DummyClassForMongoid.__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 << DummyClassForMongoid
+            def find_in_batches(options = {}, &block)
+              yield [:a, :b]
+            end
+
+            def update_batch(batch)
+              []
+            end
+          end
+        end
+
+        it 'applies the preprocessing method' do
+          DummyClassForMongoid.__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(:as_indexed_json).and_return({})
+          allow(inst).to receive(:id).and_return(1)
+        end
+      end
+
+      it 'returns an proc' do
+        expect(DummyClassForMongoid.__transform.respond_to?(:call)).to be(true)
+      end
+
+      it 'provides a default transformation' do
+        expect(DummyClassForMongoid.__transform.call(instance)).to eq(index: { _id: '1', data: {} })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Adapter::Multiple do
+
+  before(:all) do
+    class DummyOne
+      include Elasticsearch::Model
+
+      index_name 'dummy'
+      document_type 'dummy_one'
+
+      def self.find(ids)
+        ids.map { |id| new(id) }
+      end
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id.to_i
+      end
+    end
+
+    module Namespace
+      class DummyTwo
+        include Elasticsearch::Model
+
+        index_name 'dummy'
+        document_type 'dummy_two'
+
+        def self.find(ids)
+          ids.map { |id| new(id) }
+        end
+
+        attr_reader :id
+
+        def initialize(id)
+          @id = id.to_i
+        end
+      end
+    end
+
+    class DummyTwo
+      include Elasticsearch::Model
+
+      index_name 'other_index'
+      document_type 'dummy_two'
+
+      def self.find(ids)
+        ids.map { |id| new(id) }
+      end
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id.to_i
+      end
+    end
+  end
+
+  after(:all) do
+    [DummyOne, Namespace::DummyTwo, DummyTwo].each do |adapter|
+      Elasticsearch::Model::Adapter::Adapter.adapters.delete(adapter)
+    end
+    Namespace.send(:remove_const, :DummyTwo) if defined?(Namespace::DummyTwo)
+    remove_classes(DummyOne, DummyTwo, Namespace)
+  end
+
+  let(:hits) do
+    [
+      {
+        _index: 'dummy',
+        _type: 'dummy_two',
+        _id: '2'
+      },
+      {
+        _index: 'dummy',
+        _type: 'dummy_one',
+        _id: '2'
+      },
+      {
+        _index: 'other_index',
+        _type: 'dummy_two',
+        _id: '1'
+      },
+      {
+        _index: 'dummy',
+        _type: 'dummy_two',
+        _id: '1'
+      },
+      {
+        _index: 'dummy',
+        _type: 'dummy_one',
+        _id: '3'
+      }
+    ]
+  end
+
+  let(:response) do
+    double('response', response: { 'hits' => { 'hits' => hits } })
+  end
+
+  let(:multimodel) do
+    Elasticsearch::Model::Multimodel.new(DummyOne, DummyTwo, Namespace::DummyTwo)
+  end
+
+  describe '#records' do
+
+    before do
+      multimodel.class.send :include, Elasticsearch::Model::Adapter::Multiple::Records
+      expect(multimodel).to receive(:response).at_least(:once).and_return(response)
+    end
+
+    it 'instantiates the correct types of instances' do
+      expect(multimodel.records[0]).to be_a(Namespace::DummyTwo)
+      expect(multimodel.records[1]).to be_a(DummyOne)
+      expect(multimodel.records[2]).to be_a(DummyTwo)
+      expect(multimodel.records[3]).to be_a(Namespace::DummyTwo)
+      expect(multimodel.records[4]).to be_a(DummyOne)
+    end
+
+    it 'returns the results in the correct order' do
+      expect(multimodel.records.map(&:id)).to eq([2, 2, 1, 1, 3])
+    end
+  end
+end

data/spec/elasticsearch/model/callbacks_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Callbacks do
+
+  before(:all) do
+    class ::DummyCallbacksModel
+    end
+
+    module DummyCallbacksAdapter
+      module CallbacksMixin
+      end
+
+      def callbacks_mixin
+        CallbacksMixin
+      end; module_function :callbacks_mixin
+    end
+  end
+
+  after(:all) do
+    remove_classes(DummyCallbacksModel, DummyCallbacksAdapter)
+  end
+
+  context 'when a model includes the Callbacks module' do
+
+    before do
+      Elasticsearch::Model::Callbacks.included(DummyCallbacksModel)
+    end
+
+    it 'includes the callbacks mixin from the model adapter' do
+      expect(DummyCallbacksModel.ancestors).to include(Elasticsearch::Model::Adapter::Default::Callbacks)
+    end
+  end
+end