chewy 0.8.4 → 5.1.0

data/spec/chewy/type/wrapper_spec.rb

@@ -10,36 +10,65 @@ describe Chewy::Type::Wrapper do
 
   let(:city_type) { CitiesIndex::City }
 
-  subject(:city) { city_type.new(name: 'Martin', age: 42) }
-
-  it do
-    is_expected.to respond_to(:name)
-      .and respond_to(:age)
-      .and have_attributes(
-        name: 'Martin',
-        age: 42
-      )
+  describe '.build' do
+    specify do
+      expect(city_type.build({}).attributes)
+        .to eq('id' => nil, '_score' => nil, '_explanation' => nil)
+    end
+    specify do
+      expect(city_type.build('_source' => {name: 'Martin'}).attributes)
+        .to eq('id' => nil, '_score' => nil, '_explanation' => nil, 'name' => 'Martin')
+    end
+    specify do
+      expect(city_type.build('_id' => 42).attributes)
+        .to eq('id' => 42, '_score' => nil, '_explanation' => nil)
+    end
+    specify do
+      expect(city_type.build('_id' => 42, '_source' => {'id' => 43}).attributes)
+        .to eq('id' => 43, '_score' => nil, '_explanation' => nil)
+    end
+    specify do
+      expect(city_type.build('_score' => 42, '_explanation' => {foo: 'bar'}).attributes)
+        .to eq('id' => nil, '_score' => 42, '_explanation' => {foo: 'bar'})
+    end
+    specify do
+      expect(city_type.build('_score' => 42, 'borogoves' => {foo: 'bar'})._data)
+        .to eq('_score' => 42, 'borogoves' => {foo: 'bar'})
+    end
   end
 
-  it { expect { city.population }.to raise_error(NoMethodError) }
-
-  context 'highlight' do
-    subject(:city) do
-      city_type.new(name: 'Martin', age: 42)
-        .tap do |city|
-          city._data = {
-            'highlight' => { 'name' => ['<b>Mar</b>tin'] }
-          }
-        end
-    end
+  describe '#initialize' do
+    subject(:city) { city_type.new(name: 'Martin', age: 42) }
 
     it do
-      is_expected.to respond_to(:name_highlight)
+      is_expected.to respond_to(:name)
+        .and respond_to(:age)
         .and have_attributes(
           name: 'Martin',
-          name_highlight: '<b>Mar</b>tin'
+          age: 42
         )
     end
+
+    it { expect { city.population }.to raise_error(NoMethodError) }
+
+    context 'highlight' do
+      subject(:city) do
+        city_type.new(name: 'Martin', age: 42)
+          .tap do |city|
+            city._data = {
+              'highlight' => {'name' => ['<b>Mar</b>tin']}
+            }
+          end
+      end
+
+      it do
+        is_expected.to respond_to(:name_highlight)
+          .and have_attributes(
+            name: 'Martin',
+            name_highlight: '<b>Mar</b>tin'
+          )
+      end
+    end
   end
 
   describe '#==' do
@@ -52,7 +81,18 @@ describe Chewy::Type::Wrapper do
 
     specify { expect(city_type.new(id: '42')).to eq(City.new.tap { |m| allow(m).to receive_messages(id: 42) }) }
     specify { expect(city_type.new(id: 42)).not_to eq(City.new.tap { |m| allow(m).to receive_messages(id: 43) }) }
-
     specify { expect(city_type.new(id: 42)).not_to eq(Class.new) }
+
+    context 'models', :orm do
+      before do
+        stub_model(:city)
+        stub_index(:cities) do
+          define_type City
+        end
+      end
+      specify { expect(city_type.new(id: '42')).to eq(City.new.tap { |m| allow(m).to receive_messages(id: 42) }) }
+      specify { expect(city_type.new(id: 42)).not_to eq(City.new.tap { |m| allow(m).to receive_messages(id: 43) }) }
+      specify { expect(city_type.new(id: 42)).not_to eq(Class.new) }
+    end
   end
 end

data/spec/chewy/type_spec.rb

@@ -1,33 +1,55 @@
 require 'spec_helper'
 
 describe Chewy::Type do
+  describe '.derivable_name' do
+    specify { expect { Class.new(Chewy::Type).derivable_name }.to raise_error NotImplementedError }
+
+    specify do
+      index = Class.new(Chewy::Index) { define_type :city }
+      expect(index::City.derivable_name).to be_nil
+    end
+
+    specify do
+      stub_index(:places) { define_type :city }
+      expect(PlacesIndex::City.derivable_name).to eq('places#city')
+    end
+
+    specify do
+      stub_index('namespace/places') { define_type :city }
+      expect(Namespace::PlacesIndex::City.derivable_name).to eq('namespace/places#city')
+    end
+  end
+
+  describe '.types' do
+    subject { Class.new(Chewy::Type) }
+    specify { expect(subject.types).to eq([subject]) }
+  end
+
   describe '.scopes' do
     before do
       stub_index(:places) do
-        def self.by_id
-        end
+        def self.by_id; end
 
         define_type :city do
-          def self.by_rating
-          end
+          def self.by_rating; end
 
-          def self.by_name
-          end
+          def self.by_name; end
         end
       end
     end
 
     specify { expect(described_class.scopes).to eq([]) }
-    specify { expect(PlacesIndex::City.scopes).to match_array([:by_rating, :by_name]) }
+    specify { expect(PlacesIndex::City.scopes).to match_array(%i[by_rating by_name]) }
     specify { expect { PlacesIndex::City.non_existing_method_call }.to raise_error(NoMethodError) }
 
     specify { expect(PlacesIndex::City._default_import_options).to eq({}) }
-    specify { expect { PlacesIndex::City.default_import_options(invalid_option: "Yeah!") }.to raise_error(ArgumentError) }
+    specify { expect { PlacesIndex::City.default_import_options(invalid_option: 'Yeah!') }.to raise_error(ArgumentError) }
 
     context 'default_import_options is set' do
-      before { PlacesIndex::City.default_import_options(batch_size: 500) }
+      let(:converter) { -> {} }
+      before { PlacesIndex::City.default_import_options(batch_size: 500, raw_import: converter) }
 
-      specify { expect(PlacesIndex::City._default_import_options).to eq(batch_size: 500) }
+      specify { expect(PlacesIndex::City._default_import_options).to eq(batch_size: 500, raw_import: converter) }
     end
   end
 end

data/spec/chewy_spec.rb

@@ -19,19 +19,48 @@ describe Chewy do
       end
     end
 
-    specify { expect { described_class.derive_type('developers_index#developers') }.to raise_error Chewy::UnderivableType, /DevelopersIndexIndex/ }
-    specify { expect { described_class.derive_type('some#developers') }.to raise_error Chewy::UnderivableType, /SomeIndex/ }
-    specify { expect { described_class.derive_type('borogoves#developers') }.to raise_error Chewy::UnderivableType, /Borogoves/ }
-    specify { expect { described_class.derive_type('developers#borogoves') }.to raise_error Chewy::UnderivableType, /DevelopersIndex.*borogoves/ }
-    specify { expect { described_class.derive_type('namespace/autocomplete') }.to raise_error Chewy::UnderivableType, /AutocompleteIndex.*namespace\/autocomplete#type_name/ }
+    specify { expect { described_class.derive_type('some#developers') }.to raise_error(Chewy::UnderivableType, /SomeIndex/) }
+    specify { expect { described_class.derive_type('borogoves#developers') }.to raise_error(Chewy::UnderivableType, /Borogoves/) }
+    specify { expect { described_class.derive_type('developers#borogoves') }.to raise_error(Chewy::UnderivableType, /DevelopersIndex.*borogoves/) }
+    specify { expect { described_class.derive_type('namespace/autocomplete') }.to raise_error(Chewy::UnderivableType, %r{AutocompleteIndex.*namespace/autocomplete#type_name}) }
 
     specify { expect(described_class.derive_type(DevelopersIndex::Developer)).to eq(DevelopersIndex::Developer) }
+    specify { expect(described_class.derive_type('developers_index')).to eq(DevelopersIndex::Developer) }
     specify { expect(described_class.derive_type('developers')).to eq(DevelopersIndex::Developer) }
     specify { expect(described_class.derive_type('developers#developer')).to eq(DevelopersIndex::Developer) }
     specify { expect(described_class.derive_type('namespace/autocomplete#developer')).to eq(Namespace::AutocompleteIndex::Developer) }
     specify { expect(described_class.derive_type('namespace/autocomplete#company')).to eq(Namespace::AutocompleteIndex::Company) }
   end
 
+  describe '.derive_types' do
+    before do
+      stub_const('SomeIndex', Class.new)
+
+      stub_index(:developers) do
+        define_type :developer
+      end
+
+      stub_index('namespace/autocomplete') do
+        define_type :developer
+        define_type :company
+      end
+    end
+
+    specify { expect { described_class.derive_types('some#developers') }.to raise_error(Chewy::UnderivableType, /SomeIndex/) }
+    specify { expect { described_class.derive_types('borogoves#developers') }.to raise_error(Chewy::UnderivableType, /Borogoves/) }
+    specify { expect { described_class.derive_types('developers#borogoves') }.to raise_error(Chewy::UnderivableType, /DevelopersIndex.*borogoves/) }
+
+    specify { expect(described_class.derive_types(Namespace::AutocompleteIndex)).to match_array(Namespace::AutocompleteIndex.types) }
+    specify { expect(described_class.derive_types(DevelopersIndex::Developer)).to eq([DevelopersIndex::Developer]) }
+
+    specify { expect(described_class.derive_types('developers_index')).to eq([DevelopersIndex::Developer]) }
+    specify { expect(described_class.derive_types('developers')).to eq([DevelopersIndex::Developer]) }
+    specify { expect(described_class.derive_types('developers#developer')).to eq([DevelopersIndex::Developer]) }
+    specify { expect(described_class.derive_types('namespace/autocomplete')).to match_array(Namespace::AutocompleteIndex.types) }
+    specify { expect(described_class.derive_types('namespace/autocomplete#developer')).to eq([Namespace::AutocompleteIndex::Developer]) }
+    specify { expect(described_class.derive_types('namespace/autocomplete#company')).to eq([Namespace::AutocompleteIndex::Company]) }
+  end
+
   describe '.create_type' do
     before { stub_index(:cities) }
 
@@ -97,13 +126,15 @@ describe Chewy do
     before { Chewy.massacre }
 
     before do
-      allow(Chewy).to receive_messages(configuration: { prefix: 'prefix1' })
+      allow(Chewy).to receive_messages(configuration: Chewy.configuration.merge(prefix: 'prefix1'))
       stub_index(:admins).create!
-      allow(Chewy).to receive_messages(configuration: { prefix: 'prefix2' })
+      allow(Chewy).to receive_messages(configuration: Chewy.configuration.merge(prefix: 'prefix2'))
       stub_index(:developers).create!
       stub_index(:companies).create!
 
       Chewy.massacre
+
+      allow(Chewy).to receive_messages(configuration: Chewy.configuration.merge(prefix: 'prefix1'))
     end
 
     specify { expect(AdminsIndex.exists?).to eq(true) }
@@ -113,16 +144,16 @@ describe Chewy do
 
   describe '.client' do
     let!(:initial_client) { Thread.current[:chewy_client] }
-    let(:faraday_block) { proc { } }
+    let(:faraday_block) { proc {} }
     let(:mock_client) { double(:client) }
-    let(:expected_client_config) { { transport_options: {} } }
+    let(:expected_client_config) { {transport_options: {}} }
 
     before do
       Thread.current[:chewy_client] = nil
-      allow(Chewy).to receive_messages(configuration: { transport_options: { proc: faraday_block } })
+      allow(Chewy).to receive_messages(configuration: {transport_options: {proc: faraday_block}})
 
-      allow(::Elasticsearch::Client).to receive(:new).with(expected_client_config) do |*args, &passed_block|
-        # RSpec's `with(…, &block)` was used previously, but doesn't actually do
+      allow(::Elasticsearch::Client).to receive(:new).with(expected_client_config) do |*_args, &passed_block|
+        # RSpec's `with(..., &block)` was used previously, but doesn't actually do
         # any verification of the passed block (even of its presence).
         expect(passed_block.source_location).to eq(faraday_block.source_location)
 
@@ -134,4 +165,43 @@ describe Chewy do
 
     after { Thread.current[:chewy_client] = initial_client }
   end
+
+  describe '.create_indices' do
+    before do
+      stub_index(:cities)
+      stub_index(:places)
+
+      # To avoid flaky issues when previous specs were run
+      allow(Chewy::Index).to receive(:descendants).and_return([CitiesIndex, PlacesIndex])
+
+      Chewy.massacre
+    end
+
+    specify do
+      expect(CitiesIndex.exists?).to eq false
+      expect(PlacesIndex.exists?).to eq false
+
+      CitiesIndex.create!
+
+      expect(CitiesIndex.exists?).to eq true
+      expect(PlacesIndex.exists?).to eq false
+
+      expect { Chewy.create_indices }.not_to raise_error
+
+      expect(CitiesIndex.exists?).to eq true
+      expect(PlacesIndex.exists?).to eq true
+    end
+
+    specify '.create_indices!' do
+      expect(CitiesIndex.exists?).to eq false
+      expect(PlacesIndex.exists?).to eq false
+
+      expect { Chewy.create_indices! }.not_to raise_error
+
+      expect(CitiesIndex.exists?).to eq true
+      expect(PlacesIndex.exists?).to eq true
+
+      expect { Chewy.create_indices! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -6,12 +6,15 @@ begin
   require 'active_record'
   require 'sequel'
 rescue LoadError
+  nil
 end
 
 require 'rspec/its'
 require 'rspec/collection_matchers'
 
-Kaminari::Hooks.init if defined?(::Kaminari)
+require 'timecop'
+
+Kaminari::Hooks.init if defined?(::Kaminari::Hooks)
 
 require 'support/fail_helpers'
 require 'support/class_helpers'
@@ -27,6 +30,15 @@ Chewy.settings = {
   }
 }
 
+Chewy.default_field_type = 'string' if Chewy::Runtime.version < '5.0'
+# Chewy.transport_logger = Logger.new(STDERR)
+
+KEYWORD_FIELD = if Chewy::Runtime.version < '5.0'
+  {type: 'string', index: 'not_analyzed'}
+else
+  {type: 'keyword'}
+end
+
 RSpec.configure do |config|
   config.mock_with :rspec
   config.order = :random
@@ -35,6 +47,8 @@ RSpec.configure do |config|
 
   config.include FailHelpers
   config.include ClassHelpers
+
+  Aws.config.update(stub_responses: true) if defined?(::Aws)
 end
 
 if defined?(::ActiveRecord)
@@ -45,7 +59,7 @@ elsif defined?(::Sequel)
   require 'support/sequel'
 else
   RSpec.configure do |config|
-    [:orm, :mongoid, :active_record, :sequel].each do |group|
+    %i[orm mongoid active_record sequel].each do |group|
       config.filter_run_excluding(group)
     end
   end

data/spec/support/active_record.rb

@@ -1,20 +1,24 @@
 require 'database_cleaner'
 
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: 'file::memory:?cache=shared', pool: 10)
 ActiveRecord::Base.logger = Logger.new('/dev/null')
 ActiveRecord::Base.raise_in_transactional_callbacks = true if ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks)
 
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'countries'")
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'cities'")
 ActiveRecord::Schema.define do
   create_table :countries do |t|
     t.column :name, :string
     t.column :country_code, :string
     t.column :rating, :integer
+    t.column :updated_at, :datetime
   end
 
   create_table :cities do |t|
     t.column :country_id, :integer
     t.column :name, :string
     t.column :rating, :integer
+    t.column :updated_at, :datetime
   end
 end
 
@@ -25,7 +29,7 @@ module ActiveRecordClassHelpers
     :active_record
   end
 
-  def stub_model name, superclass = nil, &block
+  def stub_model(name, superclass = nil, &block)
     stub_class(name, superclass || ActiveRecord::Base, &block)
   end
 end

data/spec/support/class_helpers.rb

@@ -1,31 +1,16 @@
 module ClassHelpers
   extend ActiveSupport::Concern
 
-  def stub_index name, superclass = nil, &block
-    stub_class("#{name.to_s.camelize}Index", superclass || Chewy::Index) { index_name = name }
+  def stub_index(name, superclass = nil, &block)
+    stub_class("#{name.to_s.camelize}Index", superclass || Chewy::Index)
       .tap { |i| i.class_eval(&block) if block }
   end
 
-  def stub_class name, superclass = nil, &block
+  def stub_class(name, superclass = nil, &block)
     stub_const(name.to_s.camelize, Class.new(superclass || Object, &block))
   end
 
-  def stub_model name, superclass = nil, &block
+  def stub_model(_name, _superclass = nil)
     raise NotImplementedError, 'Seems like no ORM/ODM are loaded, please check your Gemfile'
   end
-
-  def skip_on_version_gte version, message = "Removed from elasticsearch #{version}"
-    skip message if Chewy::Runtime.version >= version
-  end
-
-  def skip_on_version_lt version, message = "Only for elasticsearch #{version} and greater"
-    skip message if Chewy::Runtime.version < version
-  end
-
-  def skip_on_plugin_missing_from_version plugin, version, message = "Plugin '#{plugin}' is missing on elasticsearch > #{version}"
-    if Chewy::Runtime.version >= version
-      plugins = Chewy.client.nodes.info(plugins: true)["nodes"].values.map { |item| item["plugins"] }.flatten
-      skip message unless plugins.find { |item| item["name"] == plugin }
-    end
-  end
 end

data/spec/support/mongoid.rb

@@ -11,7 +11,7 @@ CONFIG = {
       uri: 'mongodb://127.0.0.1:27017/chewy_mongoid_test'
     }
   }
-}
+}.freeze
 
 Mongoid.configure do |config|
   config.load_configuration(CONFIG)
@@ -22,11 +22,21 @@ Mongoid.logger = Logger.new('/dev/null')
 module MongoidClassHelpers
   extend ActiveSupport::Concern
 
+  module Document
+    def serializable_hash(options = nil)
+      hash = super(options)
+      hash['id'] = hash.delete('_id') if hash.key?('_id')
+      hash
+    end
+  end
+
   module Country
     extend ActiveSupport::Concern
 
     included do
       include Mongoid::Document
+      include Mongoid::Timestamps::Updated
+      include Document
 
       field :name, type: String
       field :country_code, type: String
@@ -39,6 +49,8 @@ module MongoidClassHelpers
 
     included do
       include Mongoid::Document
+      include Mongoid::Timestamps::Updated
+      include Document
 
       field :name, type: String
       field :rating, type: Integer
@@ -49,14 +61,14 @@ module MongoidClassHelpers
     :mongoid
   end
 
-  def stub_model name, superclass = nil, &block
+  def stub_model(name, superclass = nil, &block)
     mixin = "MongoidClassHelpers::#{name.to_s.camelize}".safe_constantize || Mongoid::Document
-    superclass ||= Class.new do
+
+    model = stub_class(name, superclass) do
       include mixin
       store_in collection: name.to_s.tableize
     end
-
-    stub_class(name, superclass, &block)
+    model.tap { |i| i.class_eval(&block) if block }
   end
 end
 

data/spec/support/sequel.rb

@@ -1,12 +1,14 @@
 require 'database_cleaner'
 
-DB = Sequel.sqlite# logger: Logger.new(STDOUT)
+DB = Sequel.sqlite # logger: Logger.new(STDERR)
+Sequel::Deprecation.output = false
 
 DB.create_table :countries do
   primary_key :id
   column :name, :string
   column :country_code, :string
   column :rating, :integer
+  column :updated_at, :datetime
 end
 
 DB.create_table :cities do
@@ -14,14 +16,17 @@ DB.create_table :cities do
   column :country_id, :integer
   column :name, :string
   column :rating, :integer
+  column :updated_at, :datetime
 end
 
 DB.create_table :rating_cities do
   primary_key :rating
   column :country_id, :integer
   column :name, :string
+  column :updated_at, :datetime
 end
 
+Sequel::Model.plugin :timestamps, update_on_create: true
 Sequel::Model.plugin :chewy_observe
 
 module SequelClassHelpers