chewy 6.0.0 → 7.6.0

data/spec/chewy/search/response_spec.rb

@@ -8,16 +8,14 @@ describe Chewy::Search::Response, :orm do
     stub_model(:country)
 
     stub_index(:cities) do
-      define_type City do
-        field :name
-        field :rating, type: 'integer'
-      end
+      index_scope City
+      field :name
+      field :rating, type: 'integer'
     end
     stub_index(:countries) do
-      define_type Country do
-        field :name
-        field :rating, type: 'integer'
-      end
+      index_scope Country
+      field :name
+      field :rating, type: 'integer'
     end
   end
 
@@ -127,7 +125,9 @@ describe Chewy::Search::Response, :orm do
     specify { expect(subject.aggs).to eq({}) }
 
     context do
-      let(:request) { Chewy::Search::Request.new(CitiesIndex, CountriesIndex).aggs(avg_rating: {avg: {field: :rating}}) }
+      let(:request) do
+        Chewy::Search::Request.new(CitiesIndex, CountriesIndex).aggs(avg_rating: {avg: {field: :rating}})
+      end
       specify { expect(subject.aggs).to eq('avg_rating' => {'value' => 1.5}) }
     end
   end
@@ -137,7 +137,7 @@ describe Chewy::Search::Response, :orm do
     specify { expect(subject.wrappers).to have(4).items }
     specify do
       expect(subject.wrappers.map(&:class).uniq)
-        .to contain_exactly(CitiesIndex::City, CountriesIndex::Country)
+        .to contain_exactly(CitiesIndex, CountriesIndex)
     end
     specify { expect(subject.wrappers.map(&:_data)).to eq(subject.hits) }
 
@@ -166,7 +166,7 @@ describe Chewy::Search::Response, :orm do
            '_source' => {'id' => 2, 'rating' => 0}}
         ]}}
       end
-      specify { expect(subject.wrappers.first).to be_a(CitiesIndex::City) }
+      specify { expect(subject.wrappers.first).to be_a(CitiesIndex) }
       specify { expect(subject.wrappers.first.id).to eq(2) }
       specify { expect(subject.wrappers.first.rating).to eq(0) }
       specify { expect(subject.wrappers.first._score).to eq(1.3) }
@@ -183,7 +183,7 @@ describe Chewy::Search::Response, :orm do
            '_explanation' => {foo: 'bar'}}
         ]}}
       end
-      specify { expect(subject.wrappers.first).to be_a(CountriesIndex::Country) }
+      specify { expect(subject.wrappers.first).to be_a(CountriesIndex) }
       specify { expect(subject.wrappers.first.id).to eq('2') }
       specify { expect(subject.wrappers.first.rating).to be_nil }
       specify { expect(subject.wrappers.first._score).to eq(1.2) }

data/spec/chewy/search/scrolling_spec.rb

@@ -8,16 +8,14 @@ describe Chewy::Search::Scrolling, :orm do
     stub_model(:country)
 
     stub_index(:cities) do
-      define_type City do
-        field :name
-        field :rating, type: 'integer'
-      end
+      index_scope City
+      field :name
+      field :rating, type: 'integer'
     end
     stub_index(:countries) do
-      define_type Country do
-        field :name
-        field :rating, type: 'integer'
-      end
+      index_scope Country
+      field :name
+      field :rating, type: 'integer'
     end
   end
 
@@ -108,7 +106,7 @@ describe Chewy::Search::Scrolling, :orm do
       end
 
       it 'clears the scroll after completion' do
-        expect(Chewy.client).to receive(:clear_scroll).with(scroll_id: anything).once.and_call_original
+        expect(Chewy.client).to receive(:clear_scroll).with(body: {scroll_id: anything}).once.and_call_original
         request.scroll_batches(batch_size: 3) {}
       end
 
@@ -119,21 +117,16 @@ describe Chewy::Search::Scrolling, :orm do
             outer_payload << payload
           end
           request.scroll_batches(batch_size: 3).to_a
-
           expect(outer_payload).to match_array([
             hash_including(
               index: [CitiesIndex, CountriesIndex],
               indexes: [CitiesIndex, CountriesIndex],
-              request: {index: %w[cities countries], type: %w[city country], body: {sort: ['rating']}, size: 3, scroll: '1m'},
-              type: [CitiesIndex::City, CountriesIndex::Country],
-              types: [CitiesIndex::City, CountriesIndex::Country]
+              request: {index: %w[cities countries], body: {sort: ['rating']}, size: 3, scroll: '1m'}
             ),
             hash_including(
               index: [CitiesIndex, CountriesIndex],
               indexes: [CitiesIndex, CountriesIndex],
-              request: {scroll: '1m', scroll_id: an_instance_of(String)},
-              type: [CitiesIndex::City, CountriesIndex::Country],
-              types: [CitiesIndex::City, CountriesIndex::Country]
+              request: {scroll: '1m', scroll_id: an_instance_of(String)}
             )
           ])
         end
@@ -158,7 +151,7 @@ describe Chewy::Search::Scrolling, :orm do
       end
       specify do
         expect(request.scroll_wrappers(batch_size: 2).map(&:class).uniq)
-          .to eq([CitiesIndex::City, CountriesIndex::Country])
+          .to eq([CitiesIndex, CountriesIndex])
       end
     end
 

data/spec/chewy/search_spec.rb

@@ -4,47 +4,34 @@ describe Chewy::Search do
   before { Chewy.massacre }
 
   before do
-    stub_index(:products) do
-      define_type :product
-    end
+    stub_index(:products)
   end
 
-  let(:product) { ProductsIndex::Product }
-
   describe '.all' do
     specify { expect(ProductsIndex.all).to be_a(Chewy::Search::Request) }
-    specify { expect(product.all).to be_a(Chewy::Search::Request) }
 
     context do
       before { allow(Chewy).to receive_messages(search_class: Chewy::Search::Request) }
 
       specify { expect(ProductsIndex.all).to be_a(Chewy::Search::Request) }
-      specify { expect(product.all).to be_a(Chewy::Search::Request) }
     end
   end
 
   describe '.search_string' do
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(q: 'hello')).twice
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(q: 'hello')).once
       ProductsIndex.search_string('hello')
-      product.search_string('hello')
     end
 
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(explain: true)).twice
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(explain: true)).once
       ProductsIndex.search_string('hello', explain: true)
-      product.search_string('hello', explain: true)
     end
 
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: %w[product]))
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'])).once
       ProductsIndex.search_string('hello')
     end
-
-    specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: %w[product]))
-      product.search_string('hello')
-    end
   end
 
   context 'named scopes' do
@@ -61,10 +48,13 @@ describe Chewy::Search do
           filter { match name: "Name#{index}" }
         end
 
-        define_type City do
-          field :name, type: 'keyword'
-          field :rating, type: :integer
+        def self.by_rating_with_kwargs(value, options:) # rubocop:disable Lint/UnusedMethodArgument
+          filter { match rating: value }
         end
+
+        index_scope City
+        field :name, type: 'keyword'
+        field :rating, type: :integer
       end
 
       stub_index(:countries) do
@@ -76,10 +66,9 @@ describe Chewy::Search do
           filter { match name: "Name#{index}" }
         end
 
-        define_type Country do
-          field :name, type: 'keyword'
-          field :rating, type: :integer
-        end
+        index_scope Country
+        field :name, type: 'keyword'
+        field :rating, type: :integer
       end
     end
 
@@ -92,30 +81,47 @@ describe Chewy::Search do
     end
 
     specify { expect(CitiesIndex.indices(CountriesIndex).by_rating(1).map(&:rating)).to eq([1, 1]) }
-    specify { expect(CitiesIndex.indices(CountriesIndex).by_rating(1).map(&:class)).to match_array([CitiesIndex::City, CountriesIndex::Country]) }
+    specify do
+      expect(CitiesIndex.indices(CountriesIndex).by_rating(1).map(&:class))
+        .to match_array([CitiesIndex, CountriesIndex])
+    end
     specify { expect(CitiesIndex.indices(CountriesIndex).by_rating(1).by_name(2).map(&:rating)).to eq([1]) }
-    specify { expect(CitiesIndex.indices(CountriesIndex).by_rating(1).by_name(2).map(&:class)).to eq([CitiesIndex::City]) }
+    specify do
+      expect(CitiesIndex.indices(CountriesIndex).by_rating(1).by_name(2).map(&:class))
+        .to eq([CitiesIndex])
+    end
     specify { expect(CitiesIndex.indices(CountriesIndex).by_name(3).map(&:rating)).to eq([2, 1]) }
-    specify { expect(CitiesIndex.indices(CountriesIndex).by_name(3).map(&:class)).to eq([CitiesIndex::City, CountriesIndex::Country]) }
+    specify do
+      expect(CitiesIndex.indices(CountriesIndex).by_name(3).map(&:class))
+        .to eq([CitiesIndex, CountriesIndex])
+    end
     specify { expect(CitiesIndex.indices(CountriesIndex).order(:name).by_rating(1).map(&:rating)).to eq([1, 1]) }
-    specify { expect(CitiesIndex.indices(CountriesIndex).order(:name).by_rating(1).map(&:class)).to match_array([CitiesIndex::City, CountriesIndex::Country]) }
+    specify do
+      expect(CitiesIndex.indices(CountriesIndex).order(:name).by_rating(1).map(&:class))
+        .to match_array([CitiesIndex, CountriesIndex])
+    end
 
     specify { expect(CitiesIndex.by_rating(2).map(&:rating)).to eq([2]) }
-    specify { expect(CitiesIndex.by_rating(2).map(&:class)).to eq([CitiesIndex::City]) }
+    specify { expect(CitiesIndex.by_rating(2).map(&:class)).to eq([CitiesIndex]) }
     specify { expect(CitiesIndex.by_rating(2).by_name(3).map(&:rating)).to eq([2]) }
-    specify { expect(CitiesIndex.by_rating(2).by_name(3).map(&:class)).to eq([CitiesIndex::City]) }
+    specify { expect(CitiesIndex.by_rating(2).by_name(3).map(&:class)).to eq([CitiesIndex]) }
     specify { expect(CitiesIndex.by_name(3).map(&:rating)).to eq([2]) }
     specify { expect(CitiesIndex.by_name(3).map(&:rating)).to eq([2]) }
     specify { expect(CitiesIndex.order(:name).by_name(3).map(&:rating)).to eq([2]) }
     specify { expect(CitiesIndex.order(:name).by_name(3).map(&:rating)).to eq([2]) }
     specify { expect(CitiesIndex.order(:name).by_rating(2).map(&:rating)).to eq([2]) }
-    specify { expect(CitiesIndex.order(:name).by_rating(2).map(&:class)).to eq([CitiesIndex::City]) }
+    specify { expect(CitiesIndex.order(:name).by_rating(2).map(&:class)).to eq([CitiesIndex]) }
 
     specify { expect(CountriesIndex.by_rating(3).map(&:rating)).to eq([3]) }
-    specify { expect(CountriesIndex.by_rating(3).map(&:class)).to eq([CountriesIndex::Country]) }
+    specify { expect(CountriesIndex.by_rating(3).map(&:class)).to eq([CountriesIndex]) }
     specify { expect(CountriesIndex.by_rating(3).by_name(5).map(&:rating)).to eq([3]) }
-    specify { expect(CountriesIndex.by_rating(3).by_name(5).map(&:class)).to eq([CountriesIndex::Country]) }
+    specify { expect(CountriesIndex.by_rating(3).by_name(5).map(&:class)).to eq([CountriesIndex]) }
     specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:rating)).to eq([3]) }
-    specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:class)).to eq([CountriesIndex::Country]) }
+    specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:class)).to eq([CountriesIndex]) }
+
+    specify 'supports keyword arguments' do
+      expect(CitiesIndex.by_rating_with_kwargs(3, options: 'blah blah blah').map(&:rating)).to eq([3])
+      expect(CitiesIndex.order(:name).by_rating_with_kwargs(3, options: 'blah blah blah').map(&:rating)).to eq([3])
+    end
   end
 end

data/spec/chewy/stash_spec.rb

@@ -10,12 +10,10 @@ describe Chewy::Stash::Journal, :orm do
   before do
     stub_model(:city)
     stub_index(:cities) do
-      define_type City
+      index_scope City
     end
-    stub_index(:countries) do
-      define_type :country
-    end
-    stub_index(:users) { define_type :user }
+    stub_index(:countries)
+    stub_index(:users)
     stub_index(:borogoves)
   end
 
@@ -28,7 +26,7 @@ describe Chewy::Stash::Journal, :orm do
       CountriesIndex.import!([id: 2, name: 'Country'], journal: true)
     end
     Timecop.travel(Time.now + 2.minutes) do
-      UsersIndex::User.import!([id: 3, name: 'User'], journal: true)
+      UsersIndex.import!([id: 3, name: 'User'], journal: true)
     end
   end
 
@@ -72,26 +70,16 @@ describe Chewy::Stash::Journal, :orm do
     specify { expect(fetch_deleted_number(described_class.clean(only: UsersIndex))).to eq(1) }
     specify { expect(fetch_deleted_number(described_class.clean(only: [CitiesIndex, UsersIndex]))).to eq(2) }
 
-    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: CountriesIndex))).to eq(0) }
+    specify do
+      expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: CountriesIndex))).to eq(0)
+    end
     specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: CitiesIndex))).to eq(1) }
   end
 
   describe '.for' do
     specify { expect(described_class.for(UsersIndex).map(&:index_name)).to eq(['users']) }
-    specify { expect(described_class.for(CitiesIndex, CountriesIndex).map(&:type_name)).to contain_exactly('city', 'country') }
-    specify { expect(described_class.for(CitiesIndex, UsersIndex).map(&:index_name)).to contain_exactly('cities', 'users') }
-  end
-
-  describe '#type' do
-    let(:index_name) { 'users' }
-    let(:type_name) { 'city' }
-    subject { described_class::Journal.new('index_name' => index_name, 'type_name' => type_name).type }
-
-    specify { expect { subject }.to raise_error(Chewy::UnderivableType) }
-
-    context do
-      let(:index_name) { 'cities' }
-      it { is_expected.to eq(CitiesIndex::City) }
+    specify do
+      expect(described_class.for(CitiesIndex, UsersIndex).map(&:index_name)).to contain_exactly('cities', 'users')
     end
   end
 end

data/spec/chewy/strategy/active_job_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-if defined?(::ActiveJob)
+if defined?(ActiveJob)
   describe Chewy::Strategy::ActiveJob do
     around do |example|
       active_job_settings = Chewy.settings[:active_job]
@@ -9,21 +9,21 @@ if defined?(::ActiveJob)
       Chewy.settings[:active_job] = active_job_settings
     end
     before(:all) do
-      ::ActiveJob::Base.logger = Chewy.logger
+      ActiveJob::Base.logger = Chewy.logger
     end
     before do
-      ::ActiveJob::Base.queue_adapter = :test
-      ::ActiveJob::Base.queue_adapter.enqueued_jobs.clear
-      ::ActiveJob::Base.queue_adapter.performed_jobs.clear
+      ActiveJob::Base.queue_adapter = :test
+      ActiveJob::Base.queue_adapter.enqueued_jobs.clear
+      ActiveJob::Base.queue_adapter.performed_jobs.clear
     end
 
     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
 
@@ -32,14 +32,14 @@ if defined?(::ActiveJob)
 
     specify do
       expect { [city, other_city].map(&:save!) }
-        .not_to update_index(CitiesIndex::City, strategy: :active_job)
+        .not_to update_index(CitiesIndex, strategy: :active_job)
     end
 
     specify do
       Chewy.strategy(:active_job) do
         [city, other_city].map(&:save!)
       end
-      enqueued_job = ::ActiveJob::Base.queue_adapter.enqueued_jobs.first
+      enqueued_job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
       expect(enqueued_job[:job]).to eq(Chewy::Strategy::ActiveJob::Worker)
       expect(enqueued_job[:queue]).to eq('low')
     end
@@ -48,26 +48,26 @@ if defined?(::ActiveJob)
       Chewy.strategy(:active_job) do
         [city, other_city].map(&:save!)
       end
-      enqueued_job = ::ActiveJob::Base.queue_adapter.enqueued_jobs.first
+      enqueued_job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
       expect(enqueued_job[:queue]).to eq('low')
     end
 
     specify do
-      ::ActiveJob::Base.queue_adapter = :inline
+      ActiveJob::Base.queue_adapter = :inline
       expect { [city, other_city].map(&:save!) }
-        .to update_index(CitiesIndex::City, strategy: :active_job)
+        .to update_index(CitiesIndex, strategy: :active_job)
         .and_reindex(city, other_city).only
     end
 
     specify do
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
-      Chewy::Strategy::ActiveJob::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::ActiveJob::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::ActiveJob::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::ActiveJob::Worker.new.perform('CitiesIndex', [city.id, other_city.id], suffix: '201601')
     end
   end
 end

data/spec/chewy/strategy/atomic_no_refresh_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Chewy::Strategy::AtomicNoRefresh, :orm do
+  around { |example| Chewy.strategy(:bypass) { example.run } }
+
+  before do
+    stub_model(:country) do
+      update_index('countries') { self }
+    end
+
+    stub_index(:countries) do
+      index_scope Country
+    end
+  end
+
+  let(:country) { Country.create!(name: 'hello', country_code: 'HL') }
+  let(:other_country) { Country.create!(name: 'world', country_code: 'WD') }
+
+  specify do
+    expect { [country, other_country].map(&:save!) }
+      .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+      .and_reindex(country, other_country).only.no_refresh
+  end
+
+  specify do
+    expect { [country, other_country].map(&:destroy) }
+      .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+      .and_delete(country, other_country).only.no_refresh
+  end
+
+  context do
+    before do
+      stub_index(:countries) do
+        index_scope Country
+        root id: -> { country_code }
+      end
+    end
+
+    specify do
+      expect { [country, other_country].map(&:save!) }
+        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+        .and_reindex('HL', 'WD').only.no_refresh
+    end
+
+    specify do
+      expect { [country, other_country].map(&:destroy) }
+        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+        .and_delete('HL', 'WD').only.no_refresh
+    end
+
+    specify do
+      expect do
+        country.save!
+        other_country.destroy
+      end
+        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+        .and_reindex('HL').and_delete('WD').only.no_refresh
+    end
+  end
+end

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