chewy 5.1.0 → 7.2.7

data/spec/chewy/strategy/atomic_spec.rb

@@ -5,11 +5,11 @@ describe Chewy::Strategy::Atomic, :orm do
 
   before do
     stub_model(:country) do
-      update_index('countries#country') { self }
+      update_index('countries') { self }
     end
 
     stub_index(:countries) do
-      define_type Country
+      index_scope Country
     end
   end
 
@@ -18,35 +18,34 @@ describe Chewy::Strategy::Atomic, :orm do
 
   specify do
     expect { [country, other_country].map(&:save!) }
-      .to update_index(CountriesIndex::Country, strategy: :atomic)
+      .to update_index(CountriesIndex, strategy: :atomic)
       .and_reindex(country, other_country).only
   end
 
   specify do
     expect { [country, other_country].map(&:destroy) }
-      .to update_index(CountriesIndex::Country, strategy: :atomic)
+      .to update_index(CountriesIndex, strategy: :atomic)
       .and_delete(country, other_country).only
   end
 
   context do
     before do
       stub_index(:countries) do
-        define_type Country do
-          root id: -> { country_code } do
-          end
+        index_scope Country
+        root id: -> { country_code } do
         end
       end
     end
 
     specify do
       expect { [country, other_country].map(&:save!) }
-        .to update_index(CountriesIndex::Country, strategy: :atomic)
+        .to update_index(CountriesIndex, strategy: :atomic)
         .and_reindex('HL', 'WD').only
     end
 
     specify do
       expect { [country, other_country].map(&:destroy) }
-        .to update_index(CountriesIndex::Country, strategy: :atomic)
+        .to update_index(CountriesIndex, strategy: :atomic)
         .and_delete('HL', 'WD').only
     end
 
@@ -55,7 +54,7 @@ describe Chewy::Strategy::Atomic, :orm do
         country.save!
         other_country.destroy
       end
-        .to update_index(CountriesIndex::Country, strategy: :atomic)
+        .to update_index(CountriesIndex, strategy: :atomic)
         .and_reindex('HL').and_delete('WD').only
     end
   end

data/spec/chewy/strategy/lazy_sidekiq_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+if defined?(::Sidekiq)
+  require 'sidekiq/testing'
+
+  describe Chewy::Strategy::LazySidekiq do
+    around do |example|
+      sidekiq_settings = Chewy.settings[:sidekiq]
+      Chewy.settings[:sidekiq] = {queue: 'low'}
+      Chewy.strategy(:bypass) { example.run }
+      Chewy.settings[:sidekiq] = sidekiq_settings
+    end
+    before { ::Sidekiq::Worker.clear_all }
+
+    context 'strategy' do
+      before do
+        stub_model(:city) do
+          update_index('cities') { self }
+        end
+
+        stub_index(:cities) do
+          index_scope City
+        end
+      end
+
+      let(:city) { City.create!(name: 'hello') }
+      let(:other_city) { City.create!(name: 'world') }
+
+      it 'does not update indices synchronously' do
+        expect { [city, other_city].map(&:save!) }
+          .not_to update_index(CitiesIndex, strategy: :lazy_sidekiq)
+      end
+
+      it 'updates indices asynchronously on record save' do
+        expect(::Sidekiq::Client).to receive(:push)
+          .with(hash_including(
+                  'class' => Chewy::Strategy::LazySidekiq::IndicesUpdateWorker,
+                  'queue' => 'low'
+                ))
+          .and_call_original
+          .once
+        ::Sidekiq::Testing.inline! do
+          expect { [city, other_city].map(&:save!) }
+            .to update_index(CitiesIndex, strategy: :lazy_sidekiq)
+            .and_reindex(city, other_city).only
+        end
+      end
+
+      it 'updates indices asynchronously with falling back to sidekiq strategy on record destroy' do
+        expect(::Sidekiq::Client).not_to receive(:push)
+          .with(hash_including(
+                  'class' => Chewy::Strategy::LazySidekiq::IndicesUpdateWorker,
+                  'queue' => 'low'
+                ))
+        expect(::Sidekiq::Client).to receive(:push)
+          .with(hash_including(
+                  'class' => Chewy::Strategy::Sidekiq::Worker,
+                  'queue' => 'low',
+                  'args' => ['CitiesIndex', [city.id, other_city.id]]
+                ))
+          .and_call_original
+          .once
+        ::Sidekiq::Testing.inline! do
+          expect { [city, other_city].map(&:destroy) }.to update_index(CitiesIndex, strategy: :sidekiq)
+        end
+      end
+
+      it 'calls Index#import!' do
+        allow(City).to receive(:where).with(id: [city.id, other_city.id]).and_return([city, other_city])
+        expect(city).to receive(:run_chewy_callbacks).and_call_original
+        expect(other_city).to receive(:run_chewy_callbacks).and_call_original
+
+        expect do
+          ::Sidekiq::Testing.inline! do
+            Chewy::Strategy::LazySidekiq::IndicesUpdateWorker.new.perform({'City' => [city.id, other_city.id]})
+          end
+        end.to update_index(CitiesIndex).and_reindex(city, other_city).only
+      end
+
+      context 'when Chewy.disable_refresh_async is true' do
+        before do
+          allow(Chewy).to receive(:disable_refresh_async).and_return(true)
+        end
+
+        it 'calls Index#import! with refresh false' do
+          allow(City).to receive(:where).with(id: [city.id, other_city.id]).and_return([city, other_city])
+          expect(city).to receive(:run_chewy_callbacks).and_call_original
+          expect(other_city).to receive(:run_chewy_callbacks).and_call_original
+
+          expect do
+            ::Sidekiq::Testing.inline! do
+              Chewy::Strategy::LazySidekiq::IndicesUpdateWorker.new.perform({'City' => [city.id, other_city.id]})
+            end
+          end.to update_index(CitiesIndex).and_reindex(city, other_city).only.no_refresh
+        end
+      end
+    end
+
+    context 'integration' do
+      around { |example| ::Sidekiq::Testing.inline! { example.run } }
+
+      let(:update_condition) { true }
+
+      before do
+        city_model
+        country_model
+
+        City.belongs_to :country
+        Country.has_many :cities
+
+        stub_index(:cities) do
+          index_scope City
+        end
+
+        stub_index(:countries) do
+          index_scope Country
+        end
+      end
+
+      context 'state dependent' do
+        let(:city_model) do
+          stub_model(:city) do
+            update_index(-> { 'cities' }, :self)
+            update_index('countries') { changes['country_id'] || previous_changes['country_id'] || country }
+          end
+        end
+
+        let(:country_model) do
+          stub_model(:country) do
+            update_index('cities', if: -> { state_dependent_update_condition }) { cities }
+            update_index(-> { 'countries' }, :self)
+            attr_accessor :state_dependent_update_condition
+          end
+        end
+
+        context 'city updates' do
+          let!(:country1) { Country.create!(id: 1) }
+          let!(:country2) { Country.create!(id: 2) }
+          let!(:city) { City.create!(id: 1, country: country1) }
+
+          it 'does not update index of removed entity because model state on the moment of save cannot be fetched' do
+            expect { city.update!(country: nil) }.not_to update_index('countries', strategy: :lazy_sidekiq)
+          end
+          it 'does not update index of removed entity because model state on the moment of save cannot be fetched' do
+            expect { city.update!(country: country2) }.to update_index('countries', strategy: :lazy_sidekiq).and_reindex(country2).only
+          end
+        end
+
+        context 'country updates' do
+          let!(:country) do
+            cities = Array.new(2) { |i| City.create!(id: i) }
+            Country.create!(id: 1, cities: cities, state_dependent_update_condition: update_condition)
+          end
+
+          it 'does not update index because state of attribute cannot be fetched' do
+            expect { country.save! }.not_to update_index('cities', strategy: :lazy_sidekiq)
+          end
+        end
+      end
+
+      context 'state independent' do
+        let(:city_model) do
+          stub_model(:city) do
+            update_index(-> { 'cities' }, :self)
+            update_index('countries') { country }
+          end
+        end
+
+        let(:country_model) do
+          stub_model(:country) do
+            update_index('cities', if: -> { state_independent_update_condition }) { cities }
+            update_index(-> { 'countries' }, :self)
+          end
+        end
+
+        before do
+          allow_any_instance_of(Country).to receive(:state_independent_update_condition).and_return(update_condition)
+        end
+
+        context 'when city updates' do
+          let!(:country1) { Country.create!(id: 1) }
+          let!(:country2) { Country.create!(id: 2) }
+          let!(:city) { City.create!(id: 1, country: country1) }
+
+          specify { expect { city.save! }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(city).only }
+          specify { expect { city.save! }.to update_index('countries', strategy: :lazy_sidekiq).and_reindex(country1).only }
+
+          specify { expect { city.destroy }.not_to update_index('cities').and_reindex(city).only }
+          specify { expect { city.destroy }.to update_index('countries', strategy: :sidekiq).and_reindex(country1).only }
+
+          specify { expect { city.update!(country: nil) }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(city).only }
+          specify { expect { city.update!(country: country2) }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(city).only }
+        end
+
+        context 'when country updates' do
+          let!(:country) do
+            cities = Array.new(2) { |i| City.create!(id: i) }
+            Country.create!(id: 1, cities: cities)
+          end
+          specify { expect { country.save! }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(country.cities).only }
+          specify { expect { country.save! }.to update_index('countries', strategy: :lazy_sidekiq).and_reindex(country).only }
+
+          specify { expect { country.destroy }.to update_index('cities', strategy: :sidekiq).and_reindex(country.cities).only }
+          specify { expect { country.destroy }.not_to update_index('countries').and_reindex(country).only }
+
+          context 'when update condition is false' do
+            let(:update_condition) { false }
+            specify { expect { country.save! }.not_to update_index('cities', strategy: :lazy_sidekiq) }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/chewy/strategy/sidekiq_spec.rb

@@ -4,15 +4,20 @@ if defined?(::Sidekiq)
   require 'sidekiq/testing'
 
   describe Chewy::Strategy::Sidekiq do
-    around { |example| Chewy.strategy(:bypass) { example.run } }
+    around do |example|
+      sidekiq_settings = Chewy.settings[:sidekiq]
+      Chewy.settings[:sidekiq] = {queue: 'low'}
+      Chewy.strategy(:bypass) { example.run }
+      Chewy.settings[:sidekiq] = sidekiq_settings
+    end
     before { ::Sidekiq::Worker.clear_all }
     before do
       stub_model(:city) do
-        update_index('cities#city') { self }
+        update_index('cities') { self }
       end
 
       stub_index(:cities) do
-        define_type City
+        index_scope City
       end
     end
 
@@ -21,28 +26,27 @@ if defined?(::Sidekiq)
 
     specify do
       expect { [city, other_city].map(&:save!) }
-        .not_to update_index(CitiesIndex::City, strategy: :sidekiq)
+        .not_to update_index(CitiesIndex, strategy: :sidekiq)
     end
 
     specify do
-      Chewy.settings[:sidekiq] = {queue: 'low'}
       expect(::Sidekiq::Client).to receive(:push).with(hash_including('queue' => 'low')).and_call_original
       ::Sidekiq::Testing.inline! do
         expect { [city, other_city].map(&:save!) }
-          .to update_index(CitiesIndex::City, strategy: :sidekiq)
+          .to update_index(CitiesIndex, strategy: :sidekiq)
           .and_reindex(city, other_city).only
       end
     end
 
     specify do
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
-      Chewy::Strategy::Sidekiq::Worker.new.perform('CitiesIndex::City', [city.id, other_city.id], suffix: '201601')
+      expect(CitiesIndex).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
+      Chewy::Strategy::Sidekiq::Worker.new.perform('CitiesIndex', [city.id, other_city.id], suffix: '201601')
     end
 
     specify do
       allow(Chewy).to receive(:disable_refresh_async).and_return(true)
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601', refresh: false)
-      Chewy::Strategy::Sidekiq::Worker.new.perform('CitiesIndex::City', [city.id, other_city.id], suffix: '201601')
+      expect(CitiesIndex).to receive(:import!).with([city.id, other_city.id], suffix: '201601', refresh: false)
+      Chewy::Strategy::Sidekiq::Worker.new.perform('CitiesIndex', [city.id, other_city.id], suffix: '201601')
     end
   end
 end

data/spec/chewy/strategy_spec.rb

@@ -14,7 +14,10 @@ describe Chewy::Strategy do
   end
 
   describe '#push' do
-    specify { expect { strategy.push(:unexistant) }.to raise_error(RuntimeError).with_message("Can't find update strategy `unexistant`") }
+    specify do
+      expect { strategy.push(:unexistant) }
+        .to raise_error(RuntimeError).with_message("Can't find update strategy `unexistant`")
+    end
 
     specify do
       expect { strategy.push(:atomic) }
@@ -35,7 +38,10 @@ describe Chewy::Strategy do
   end
 
   describe '#wrap' do
-    specify { expect { strategy.wrap(:unexistant) {} }.to raise_error(RuntimeError).with_message("Can't find update strategy `unexistant`") }
+    specify do
+      expect { strategy.wrap(:unexistant) {} }
+        .to raise_error(RuntimeError).with_message("Can't find update strategy `unexistant`")
+    end
 
     specify do
       expect do
@@ -49,11 +55,11 @@ describe Chewy::Strategy do
   context 'nesting', :orm do
     before do
       stub_model(:city) do
-        update_index('cities#city') { self }
+        update_index('cities') { self }
       end
 
       stub_index(:cities) do
-        define_type City
+        index_scope City
       end
     end
 
@@ -64,12 +70,12 @@ describe Chewy::Strategy do
       around { |example| Chewy.strategy(:bypass) { example.run } }
 
       specify do
-        expect(CitiesIndex::City).not_to receive(:import!)
+        expect(CitiesIndex).not_to receive(:import!)
         [city, other_city].map(&:save!)
       end
 
       specify do
-        expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id]).once
+        expect(CitiesIndex).to receive(:import!).with([city.id, other_city.id]).once
         Chewy.strategy(:atomic) { [city, other_city].map(&:save!) }
       end
     end
@@ -78,41 +84,39 @@ describe Chewy::Strategy do
       around { |example| Chewy.strategy(:urgent) { example.run } }
 
       specify do
-        expect(CitiesIndex::City).to receive(:import!).at_least(2).times
+        expect(CitiesIndex).to receive(:import!).at_least(2).times
         [city, other_city].map(&:save!)
       end
 
       specify do
-        expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id]).once
+        expect(CitiesIndex).to receive(:import!).with([city.id, other_city.id]).once
         Chewy.strategy(:atomic) { [city, other_city].map(&:save!) }
       end
 
       context 'hash passed to urgent' do
         before do
-          stub_index(:cities) do
-            define_type :city
-          end
+          stub_index(:cities)
 
           stub_model(:city) do
-            update_index('cities#city') { {name: name} }
+            update_index('cities') { {name: name} }
           end
         end
 
         specify do
           [city, other_city].map(&:save!)
-          expect(CitiesIndex::City.total_count).to eq(4)
+          expect(CitiesIndex.total_count).to eq(4)
         end
 
         context do
           before do
             stub_model(:city) do
-              update_index('cities#city') { {id: id.to_s, name: name} }
+              update_index('cities') { {id: id.to_s, name: name} }
             end
           end
 
           specify do
             [city, other_city].map(&:save!)
-            expect(CitiesIndex::City.total_count).to eq(2)
+            expect(CitiesIndex.total_count).to eq(2)
           end
         end
       end

data/spec/chewy_spec.rb

@@ -5,120 +5,29 @@ describe Chewy do
     expect(Chewy::VERSION).not_to be nil
   end
 
-  describe '.derive_type' do
+  describe '.derive_name' 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_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]) }
+      stub_index(:developers)
 
-    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) }
-
-    context 'Symbol' do
-      subject { described_class.create_type(CitiesIndex, :city) }
-
-      it { is_expected.to be_a Class }
-      it { is_expected.to be < Chewy::Type }
-      its(:name) { should == 'CitiesIndex::City' }
-      its(:index) { should == CitiesIndex }
-      its(:type_name) { should == 'city' }
+      stub_index('namespace/autocomplete')
     end
 
-    context 'simple model' do
-      before { stub_class(:city) }
-      subject { described_class.create_type(CitiesIndex, City) }
-
-      it { is_expected.to be_a Class }
-      it { is_expected.to be < Chewy::Type }
-      its(:name) { should == 'CitiesIndex::City' }
-      its(:index) { should == CitiesIndex }
-      its(:type_name) { should == 'city' }
-    end
-
-    context 'model scope', :orm do
-      before { stub_model(:city) }
-      subject { described_class.create_type(CitiesIndex, City.where(rating: 1)) }
-
-      it { is_expected.to be_a Class }
-      it { is_expected.to be < Chewy::Type }
-      its(:name) { should == 'CitiesIndex::City' }
-      its(:index) { should == CitiesIndex }
-      its(:type_name) { should == 'city' }
+    specify do
+      expect { described_class.derive_name('some') }
+        .to raise_error(Chewy::UndefinedIndex, /SomeIndex/)
     end
-
-    context 'Namespaced index' do
-      before { stub_class(:city) }
-      before { stub_index('namespace/cities') }
-
-      subject { described_class.create_type(Namespace::CitiesIndex, City) }
-
-      it { is_expected.to be_a Class }
-      it { is_expected.to be < Chewy::Type }
-      its(:name) { should == 'Namespace::CitiesIndex::City' }
-      its(:index) { should == Namespace::CitiesIndex }
-      its(:type_name) { should == 'city' }
+    specify do
+      expect { described_class.derive_name('borogoves') }
+        .to raise_error(Chewy::UndefinedIndex, /Borogoves/)
     end
 
-    context 'Namespaced model' do
-      before { stub_class('namespace/city') }
-
-      subject { described_class.create_type(CitiesIndex, Namespace::City) }
-
-      it { is_expected.to be_a Class }
-      it { is_expected.to be < Chewy::Type }
-      its(:name) { should == 'CitiesIndex::City' }
-      its(:index) { should == CitiesIndex }
-      its(:type_name) { should == 'city' }
+    specify { expect(described_class.derive_name(DevelopersIndex)).to eq(DevelopersIndex) }
+    specify { expect(described_class.derive_name('developers_index')).to eq(DevelopersIndex) }
+    specify { expect(described_class.derive_name('developers')).to eq(DevelopersIndex) }
+    specify do
+      expect(described_class.derive_name('namespace/autocomplete')).to eq(Namespace::AutocompleteIndex)
     end
   end
 
@@ -130,7 +39,6 @@ describe Chewy do
       stub_index(:admins).create!
       allow(Chewy).to receive_messages(configuration: Chewy.configuration.merge(prefix: 'prefix2'))
       stub_index(:developers).create!
-      stub_index(:companies).create!
 
       Chewy.massacre
 
@@ -139,17 +47,16 @@ describe Chewy do
 
     specify { expect(AdminsIndex.exists?).to eq(true) }
     specify { expect(DevelopersIndex.exists?).to eq(false) }
-    specify { expect(CompaniesIndex.exists?).to eq(false) }
   end
 
   describe '.client' do
-    let!(:initial_client) { Thread.current[:chewy_client] }
+    let!(:initial_client) { Chewy.current[:chewy_client] }
     let(:faraday_block) { proc {} }
     let(:mock_client) { double(:client) }
     let(:expected_client_config) { {transport_options: {}} }
 
     before do
-      Thread.current[:chewy_client] = nil
+      Chewy.current[:chewy_client] = nil
       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|
@@ -163,7 +70,7 @@ describe Chewy do
 
     its(:client) { is_expected.to eq(mock_client) }
 
-    after { Thread.current[:chewy_client] = initial_client }
+    after { Chewy.current[:chewy_client] = initial_client }
   end
 
   describe '.create_indices' do

data/spec/spec_helper.rb

@@ -2,12 +2,7 @@ require 'bundler'
 
 Bundler.require
 
-begin
-  require 'active_record'
-  require 'sequel'
-rescue LoadError
-  nil
-end
+require 'active_record'
 
 require 'rspec/its'
 require 'rspec/collection_matchers'
@@ -21,8 +16,11 @@ require 'support/class_helpers'
 
 require 'chewy/rspec'
 
+host = ENV['ES_HOST'] || 'localhost'
+port = ENV['ES_PORT'] || 9250
+
 Chewy.settings = {
-  host: 'localhost:9250',
+  host: "#{host}:#{port}",
   wait_for_status: 'green',
   index: {
     number_of_shards: 1,
@@ -30,15 +28,8 @@ 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
@@ -47,20 +38,6 @@ RSpec.configure do |config|
 
   config.include FailHelpers
   config.include ClassHelpers
-
-  Aws.config.update(stub_responses: true) if defined?(::Aws)
 end
 
-if defined?(::ActiveRecord)
-  require 'support/active_record'
-elsif defined?(::Mongoid)
-  require 'support/mongoid'
-elsif defined?(::Sequel)
-  require 'support/sequel'
-else
-  RSpec.configure do |config|
-    %i[orm mongoid active_record sequel].each do |group|
-      config.filter_run_excluding(group)
-    end
-  end
-end
+require 'support/active_record'