chewy 6.0.0 → 7.5.1

data/spec/chewy_spec.rb

@@ -5,115 +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
-      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(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) }
-  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
-      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]) }
-  end
+      stub_index(:developers)
 
-  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' }
-    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' }
+      stub_index('namespace/autocomplete')
     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
 
@@ -136,27 +50,30 @@ describe Chewy do
   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
-      allow(Chewy).to receive_messages(configuration: {transport_options: {proc: faraday_block}})
+      Chewy.current[:chewy_client] = nil
+    end
 
-      allow(::Elasticsearch::Client).to receive(:new).with(expected_client_config) do |*_args, &passed_block|
+    specify do
+      expect(Chewy).to receive_messages(configuration: {transport_options: {proc: faraday_block}})
+
+      expect(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)
 
         mock_client
       end
-    end
 
-    its(:client) { is_expected.to eq(mock_client) }
+      expect(Chewy.client).to be_a(Chewy::ElasticClient)
+    end
 
-    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,19 +2,14 @@ require 'bundler'
 
 Bundler.require
 
-begin
-  require 'active_record'
-  require 'sequel'
-rescue LoadError
-  nil
-end
+require 'active_record'
 
 require 'rspec/its'
 require 'rspec/collection_matchers'
 
 require 'timecop'
 
-Kaminari::Hooks.init if defined?(::Kaminari::Hooks)
+Kaminari::Hooks.init if defined?(Kaminari::Hooks)
 
 require 'support/fail_helpers'
 require 'support/class_helpers'
@@ -43,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'

data/spec/support/active_record.rb

@@ -1,11 +1,14 @@
 require 'database_cleaner'
 
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: 'file::memory:?cache=shared', pool: 10)
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:', 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)
+if ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks)
+  ActiveRecord::Base.raise_in_transactional_callbacks = true
+end
 
 ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'countries'")
 ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'cities'")
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'locations'")
 ActiveRecord::Schema.define do
   create_table :countries do |t|
     t.column :name, :string
@@ -17,9 +20,24 @@ ActiveRecord::Schema.define do
   create_table :cities do |t|
     t.column :country_id, :integer
     t.column :name, :string
+    t.column :historical_name, :string
+    t.column :description, :string
     t.column :rating, :integer
     t.column :updated_at, :datetime
   end
+
+  create_table :locations do |t|
+    t.column :city_id, :integer
+    t.column :lat, :string
+    t.column :lon, :string
+  end
+
+  create_table :comments do |t|
+    t.column :content, :string
+    t.column :comment_type, :string
+    t.column :commented_id, :integer
+    t.column :updated_at, :datetime
+  end
 end
 
 module ActiveRecordClassHelpers
@@ -39,14 +57,17 @@ module ActiveRecordClassHelpers
     raise 'Expected some db queries, but none were made' unless have_queries
   end
 
-  def expects_no_query(&block)
+  def expects_no_query(except: nil, &block)
     queries = []
     ActiveSupport::Notifications.subscribed(
       ->(*args) { queries << args[4][:sql] },
       'sql.active_record',
       &block
     )
-    raise "Expected no DB queries, but the following ones were made: #{queries.join(', ')}" if queries.present?
+    ofending_queries = except ? queries.find_all { |query| !query.match(except) } : queries
+    if ofending_queries.present?
+      raise "Expected no DB queries, but the following ones were made: #{ofending_queries.join(', ')}"
+    end
   end
 
   def stub_model(name, superclass = nil, &block)
@@ -57,9 +78,6 @@ end
 RSpec.configure do |config|
   config.include ActiveRecordClassHelpers
 
-  config.filter_run_excluding :mongoid
-  config.filter_run_excluding :sequel
-
   config.before(:suite) do
     DatabaseCleaner.clean_with :truncation
     DatabaseCleaner.strategy = :truncation