Modernize test suite: replace deprecated syntax, remove dead tests

- Replace `its/should` with `specify/expect` in config_spec and
  repository_spec (also removes a duplicate transport_logger test)
- Remove duplicate specify blocks in query_proxy_spec
- Remove permanently-pending Groovy script tests in response_spec
  (Groovy scripting unsupported since ES 6)
- Modernize version test description in chewy_spec
- Remove broken xdescribe '.massacre' (never called .massacre,
  incorrect setup, untestable with ES 8 defaults)
- Remove xcontext 'applying journal' from actions_spec (timing-
  dependent, full of debug prints, covered by journaling context)

Author: bbatsov

spec/chewy/config_spec.rb

@@ -3,18 +3,17 @@
 describe Chewy::Config do
   subject { described_class.send(:new) }
 
-  its(:logger) { should be_nil }
-  its(:transport_logger) { should be_nil }
-  its(:transport_logger) { should be_nil }
-  its(:root_strategy) { should == :base }
-  its(:request_strategy) { should == :atomic }
-  its(:console_strategy) { should == :urgent }
-  its(:use_after_commit_callbacks) { should == true }
-  its(:indices_path) { should == 'app/chewy' }
-  its(:reset_disable_refresh_interval) { should == false }
-  its(:reset_no_replicas) { should == false }
-  its(:disable_refresh_async) { should == false }
-  its(:search_class) { should be < Chewy::Search::Request }
+  specify { expect(subject.logger).to be_nil }
+  specify { expect(subject.transport_logger).to be_nil }
+  specify { expect(subject.root_strategy).to eq(:base) }
+  specify { expect(subject.request_strategy).to eq(:atomic) }
+  specify { expect(subject.console_strategy).to eq(:urgent) }
+  specify { expect(subject.use_after_commit_callbacks).to eq(true) }
+  specify { expect(subject.indices_path).to eq('app/chewy') }
+  specify { expect(subject.reset_disable_refresh_interval).to eq(false) }
+  specify { expect(subject.reset_no_replicas).to eq(false) }
+  specify { expect(subject.disable_refresh_async).to eq(false) }
+  specify { expect(subject.search_class).to be < Chewy::Search::Request }
 
   describe '#transport_logger=' do
     let(:logger) { Logger.new('/dev/null') }

spec/chewy/index/actions_spec.rb

@@ -583,67 +583,6 @@
       end
     end
 
-    xcontext 'applying journal' do
-      before do
-        stub_index(:cities) do
-          index_scope City
-          field :name, value: (lambda do
-            sleep(rating)
-            name
-          end)
-        end
-      end
-
-      let!(:cities) { Array.new(3) { |i| City.create!(id: i + 1, name: "Name#{i + 1}", rating: 1) } }
-
-      let(:parallel_update) do
-        Thread.new do
-          p 'start parallel'
-          sleep(1.5)
-          cities.first.update(name: 'NewName1', rating: 0)
-          cities.last.update(name: 'NewName3', rating: 0)
-          CitiesIndex::City.import!([cities.first, cities.last], journal: true)
-          p 'end parallel'
-        end
-      end
-
-      specify 'with journal application' do
-        cities
-        p 'cities created1'
-        ActiveRecord::Base.connection.close if defined?(ActiveRecord::Base)
-        [
-          parallel_update,
-          Thread.new do
-            p 'start reset1'
-            CitiesIndex.reset!('suffix')
-            p 'end reset1'
-          end
-        ].map(&:join)
-        ActiveRecord::Base.connection.reconnect! if defined?(ActiveRecord::Base)
-        p 'expect1'
-        expect(CitiesIndex::City.pluck(:_id, :name)).to contain_exactly(%w[1 NewName1], %w[2 Name2], %w[3 NewName3])
-        p 'end expect1'
-      end
-
-      specify 'without journal application' do
-        cities
-        p 'cities created2'
-        ActiveRecord::Base.connection.close if defined?(ActiveRecord::Base)
-        [
-          parallel_update,
-          Thread.new do
-            p 'start reset2'
-            CitiesIndex.reset!('suffix', apply_journal: false)
-            p 'end reset2'
-          end
-        ].map(&:join)
-        ActiveRecord::Base.connection.reconnect! if defined?(ActiveRecord::Base)
-        p 'expect2'
-        expect(CitiesIndex::City.pluck(:_id, :name)).to contain_exactly(%w[1 Name1], %w[2 Name2], %w[3 Name3])
-        p 'end expect2'
-      end
-    end
-
     context 'journaling' do
       before { City.create!(id: 1, name: 'Moscow') }
 

spec/chewy/repository_spec.rb

@@ -3,10 +3,10 @@
 describe Chewy::Repository do
   subject { described_class.send(:new) }
 
-  its(:analyzers) { should == {} }
-  its(:tokenizers) { should == {} }
-  its(:filters) { should == {} }
-  its(:char_filters) { should == {} }
+  specify { expect(subject.analyzers).to eq({}) }
+  specify { expect(subject.tokenizers).to eq({}) }
+  specify { expect(subject.filters).to eq({}) }
+  specify { expect(subject.char_filters).to eq({}) }
 
   describe '#analyzer' do
     specify { expect(subject.analyzer(:name)).to be_nil }

spec/chewy/search/query_proxy_spec.rb

@@ -12,10 +12,6 @@
       expect(subject.must(multi_match: {foo: 'bar'}).render[:body])
         .to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
     end
-    specify do
-      expect(subject.must(multi_match: {foo: 'bar'}).render[:body])
-        .to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
-    end
   end
 
   describe '#should' do
@@ -24,10 +20,6 @@
       expect(subject.should(multi_match: {foo: 'bar'}).render[:body])
         .to eq(query: {bool: {must: {match: {foo: 'bar'}}, should: {multi_match: {foo: 'bar'}}}})
     end
-    specify do
-      expect(subject.should(multi_match: {foo: 'bar'}).render[:body])
-        .to eq(query: {bool: {must: {match: {foo: 'bar'}}, should: {multi_match: {foo: 'bar'}}}})
-    end
   end
 
   describe '#must_not' do
@@ -36,10 +28,6 @@
       expect(subject.must_not(multi_match: {foo: 'bar'}).render[:body])
         .to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}})
     end
-    specify do
-      expect(subject.must_not(multi_match: {foo: 'bar'}).render[:body])
-        .to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}})
-    end
   end
 
   describe '#and' do
@@ -48,10 +36,6 @@
       expect(subject.and(multi_match: {foo: 'bar'}).render[:body])
         .to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
     end
-    specify do
-      expect(subject.and(multi_match: {foo: 'bar'}).render[:body])
-        .to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
-    end
     specify do
       expect(subject.and(scope).render[:body])
         .to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {bool: {must_not: {match: {foo: 'bar'}}}}]}})
@@ -64,10 +48,6 @@
       expect(subject.or(multi_match: {foo: 'bar'}).render[:body])
         .to eq(query: {bool: {should: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
     end
-    specify do
-      expect(subject.or(multi_match: {foo: 'bar'}).render[:body])
-        .to eq(query: {bool: {should: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
-    end
     specify do
       expect(subject.or(scope).render[:body])
         .to eq(query: {bool: {should: [{match: {foo: 'bar'}}, {bool: {must_not: {match: {foo: 'bar'}}}}]}})
@@ -80,10 +60,6 @@
       expect(subject.not(multi_match: {foo: 'bar'}).render[:body])
         .to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}})
     end
-    specify do
-      expect(subject.not(multi_match: {foo: 'bar'}).render[:body])
-        .to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}})
-    end
     specify do
       expect(subject.not(scope).render[:body])
         .to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {bool: {must_not: {match: {foo: 'bar'}}}}}})

spec/chewy/search/response_spec.rb

@@ -68,32 +68,10 @@
 
   describe '#took' do
     specify { expect(subject.took).to be >= 0 }
-
-    context do
-      let(:request) do
-        Chewy::Search::Request.new(CitiesIndex)
-          .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}})
-      end
-      specify do
-        pending
-        expect(subject.took).to be > 100
-      end
-    end
   end
 
   describe '#timed_out?' do
     specify { expect(subject.timed_out?).to eq(false) }
-
-    context do
-      let(:request) do
-        Chewy::Search::Request.new(CitiesIndex)
-          .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}}).timeout('10ms')
-      end
-      specify do
-        pending
-        expect(subject.timed_out?).to eq(true)
-      end
-    end
   end
 
   describe '#suggest' do

spec/chewy_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Chewy do
-  it 'should have a version number' do
-    expect(Chewy::VERSION).not_to be nil
+  it 'has a version number' do
+    expect(Chewy::VERSION).not_to be_nil
   end
 
   describe '.derive_name' do
@@ -31,24 +31,6 @@
     end
   end
 
-  xdescribe '.massacre' do
-    before { drop_indices }
-
-    before do
-      allow(Chewy).to receive_messages(configuration: Chewy.configuration.merge(prefix: 'prefix1'))
-      stub_index(:admins).create!
-      allow(Chewy).to receive_messages(configuration: Chewy.configuration.merge(prefix: 'prefix2'))
-      stub_index(:developers).create!
-
-      drop_indices
-
-      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) }
-  end
-
   describe '.client' do
     let!(:initial_client) { Chewy.current[:chewy_client] }
     let(:faraday_block) { proc {} }