chewy 0.8.4 → 7.3.4

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,91 +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('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(DevelopersIndex::Developer)).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 '.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) }
+      stub_index(:developers)
 
-      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
 
@@ -97,32 +35,32 @@ 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) }
     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(:faraday_block) { proc { } }
+    let!(:initial_client) { Chewy.current[:chewy_client] }
+    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 } })
+      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|
-        # 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)
 
@@ -132,6 +70,45 @@ 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
+    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

@@ -2,24 +2,25 @@ require 'bundler'
 
 Bundler.require
 
-begin
-  require 'active_record'
-  require 'sequel'
-rescue LoadError
-end
+require 'active_record'
 
 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'
 
 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,
@@ -27,6 +28,8 @@ Chewy.settings = {
   }
 }
 
+# Chewy.transport_logger = Logger.new(STDERR)
+
 RSpec.configure do |config|
   config.mock_with :rspec
   config.order = :random
@@ -37,16 +40,4 @@ RSpec.configure do |config|
   config.include ClassHelpers
 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|
-    [: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,20 +1,42 @@
 require 'database_cleaner'
 
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+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
     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 :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
 
@@ -25,7 +47,30 @@ module ActiveRecordClassHelpers
     :active_record
   end
 
-  def stub_model name, superclass = nil, &block
+  def expects_db_queries(&block)
+    have_queries = false
+    ActiveSupport::Notifications.subscribed(
+      ->(*_) { have_queries = true },
+      'sql.active_record',
+      &block
+    )
+    raise 'Expected some db queries, but none were made' unless have_queries
+  end
+
+  def expects_no_query(except: nil, &block)
+    queries = []
+    ActiveSupport::Notifications.subscribed(
+      ->(*args) { queries << args[4][:sql] },
+      'sql.active_record',
+      &block
+    )
+    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)
     stub_class(name, superclass || ActiveRecord::Base, &block)
   end
 end
@@ -33,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

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