chewy 0.9.0 → 0.10.0

data/spec/chewy/index/specification_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe Chewy::Index::Specification do
+  before { Chewy.massacre }
+
+  let(:index1) do
+    stub_index(:places) do
+      define_type(:city) do
+        field :name, type: 'string'
+      end
+    end
+  end
+
+  let(:index2) do
+    stub_index(:places) do
+      settings analyzer: {}
+      define_type(:city) do
+        field :name, type: 'string'
+      end
+    end
+  end
+
+  let(:index3) do
+    stub_index(:places) do
+      define_type(:city) do
+        field :name, type: 'string'
+        field :population, type: 'integer'
+      end
+    end
+  end
+
+  let(:index4) do
+    stub_index(:places) do
+      define_type(:city) do
+        field :population, type: 'integer'
+        field :name, type: 'string'
+      end
+    end
+  end
+
+  let(:index5) do
+    stub_index('namespace/cities') do
+      define_type(:city) do
+        field :population, type: 'integer'
+      end
+    end
+  end
+
+  let(:specification1) { described_class.new(index1) }
+  let(:specification2) { described_class.new(index2) }
+  let(:specification3) { described_class.new(index3) }
+  let(:specification4) { described_class.new(index4) }
+  let(:specification5) { described_class.new(index5) }
+
+  describe '#lock!' do
+    specify do
+      expect { specification1.lock! }.to change { Chewy::Stash::Specification.all.hits }.from([]).to([{
+        '_index' => 'chewy_stash',
+        '_type' => 'specification',
+        '_id' => 'places',
+        '_score' => 1.0,
+        '_source' => {'value' => '{"settings":{"index":{"number_of_shards":1,"number_of_replicas":0}},"mappings":{"city":{"properties":{"name":{"type":"string"}}}}}'}
+      }])
+    end
+
+    context do
+      before { specification1.lock! }
+
+      specify do
+        expect { specification5.lock! }.to change { Chewy::Stash::Specification.all.hits }.to([{
+          '_index' => 'chewy_stash',
+          '_type' => 'specification',
+          '_id' => 'places',
+          '_score' => 1.0,
+          '_source' => {'value' => '{"settings":{"index":{"number_of_shards":1,"number_of_replicas":0}},"mappings":{"city":{"properties":{"name":{"type":"string"}}}}}'}
+        }, {
+          '_index' => 'chewy_stash',
+          '_type' => 'specification',
+          '_id' => 'namespace/cities',
+          '_score' => 1.0,
+          '_source' => {'value' => '{"settings":{"index":{"number_of_shards":1,"number_of_replicas":0}},"mappings":{"city":{"properties":{"population":{"type":"integer"}}}}}'}
+        }])
+      end
+    end
+  end
+
+  describe '#locked' do
+    specify do
+      expect { specification1.lock! }.to change { specification1.locked }.from({}).to(
+        'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+        'mappings' => {'city' => {'properties' => {'name' => {'type' => 'string'}}}}
+      )
+    end
+
+    specify do
+      expect { specification5.lock! }.to change { specification5.locked }.from({}).to(
+        'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+        'mappings' => {'city' => {'properties' => {'population' => {'type' => 'integer'}}}}
+      )
+    end
+
+    context do
+      before { specification1.lock! }
+
+      specify do
+        expect { specification2.lock! }.to change { specification2.locked }.from(
+          'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+          'mappings' => {'city' => {'properties' => {'name' => {'type' => 'string'}}}}
+        ).to(
+          'settings' => {'analyzer' => {}, 'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+          'mappings' => {'city' => {'properties' => {'name' => {'type' => 'string'}}}}
+        )
+      end
+
+      specify do
+        expect { specification3.lock! }.to change { specification3.locked }.from(
+          'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+          'mappings' => {'city' => {'properties' => {'name' => {'type' => 'string'}}}}
+        ).to(
+          'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+          'mappings' => {'city' => {'properties' => {'name' => {'type' => 'string'}, 'population' => {'type' => 'integer'}}}}
+        )
+      end
+    end
+  end
+
+  describe '#current' do
+    specify do
+      expect(specification2.current).to eq(
+        'mappings' => {'city' => {'properties' => {'name' => {'type' => 'string'}}}},
+        'settings' => {'analyzer' => {}, 'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}}
+      )
+    end
+  end
+
+  describe '#changed?' do
+    specify { expect(specification1.changed?).to eq(true) }
+    specify { expect { specification1.lock! }.to change { specification1.changed? }.to(false) }
+
+    context do
+      before { specification1.lock! }
+      specify { expect { specification2.lock! }.to change { specification2.changed? }.from(true).to(false) }
+    end
+
+    context do
+      before { specification1.lock! }
+      specify { expect { specification3.lock! }.to change { specification3.changed? }.from(true).to(false) }
+    end
+
+    context do
+      before { specification1.lock! }
+      specify { expect { specification5.lock! }.to change { specification5.changed? }.from(true) }
+    end
+
+    context do
+      before { specification3.lock! }
+      specify { expect { specification4.lock! }.not_to change { specification4.changed? }.from(false) }
+    end
+  end
+end

data/spec/chewy/index_spec.rb

@@ -61,16 +61,28 @@ describe Chewy::Index do
     specify { expect(stub_const('DeveloperIndex', Class.new(Chewy::Index)).index_name).to eq('developer') }
     specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name).to eq('developers') }
 
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '')).to eq('developers') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '2013')).to eq('developers_2013') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: '')).to eq('developers') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: 'test')).to eq('test_developers') }
+
     context do
-      before { allow(Chewy).to receive_messages(configuration: { prefix: 'testing' }) }
+      before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
       specify { expect(DummiesIndex.index_name).to eq('testing_dummies') }
       specify { expect(stub_index(:dummies) { index_name :users }.index_name).to eq('testing_users') }
+      specify { expect(stub_index(:dummies) { index_name :users }.index_name(prefix: '')).to eq('users') }
     end
   end
 
-  describe '.default_prefix' do
-    before { allow(Chewy).to receive_messages(configuration: { prefix: 'testing' }) }
-    specify { expect(Class.new(Chewy::Index).default_prefix).to eq('testing') }
+  describe '.derivable_name' do
+    specify { expect(Class.new(Chewy::Index).derivable_name).to be_nil }
+    specify { expect(stub_index(:places).derivable_name).to eq('places') }
+    specify { expect(stub_index('namespace/places').derivable_name).to eq('namespace/places') }
+  end
+
+  describe '.prefix' do
+    before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
+    specify { expect(Class.new(Chewy::Index).prefix).to eq('testing') }
   end
 
   describe '.define_type' do
@@ -117,15 +129,14 @@ describe Chewy::Index do
     context 'type methods should be deprecated and can\'t redefine existing ones' do
       before do
         stub_index(:places) do
-          def self.city
-          end
+          def self.city; end
           define_type :city
           define_type :country
         end
       end
 
       specify { expect(PlacesIndex.city).to be_nil }
-      specify { expect(PlacesIndex.country).to be < Chewy::Type }
+      specify { expect(PlacesIndex::Country).to be < Chewy::Type }
     end
   end
 
@@ -145,69 +156,58 @@ describe Chewy::Index do
 
   describe '.types' do
     specify { expect(DummiesIndex.types).to eq(DummiesIndex.type_hash.values) }
-    specify { expect(DummiesIndex.types(:dummy)).to be_a Chewy::Query }
-    specify { expect(DummiesIndex.types(:user)).to be_a Chewy::Query }
+    specify { expect(DummiesIndex.types(:dummy)).to be_a Chewy::Search::Request }
+    specify { expect(DummiesIndex.types(:user)).to be_a Chewy::Search::Request }
   end
 
   describe '.settings' do
     before do
       allow(Chewy).to receive_messages(config: Chewy::Config.send(:new))
 
-      Chewy.analyzer :name, filter: %w(lowercase icu_folding names_nysiis)
+      Chewy.analyzer :name, filter: %w[lowercase icu_folding names_nysiis]
       Chewy.analyzer :phone, tokenizer: 'ngram', char_filter: ['phone']
       Chewy.tokenizer :ngram, type: 'nGram', min_gram: 3, max_gram: 3
       Chewy.char_filter :phone, type: 'pattern_replace', pattern: '[^\d]', replacement: ''
       Chewy.filter :names_nysiis, type: 'phonetic', encoder: 'nysiis', replace: false
     end
 
-    let(:documents) { stub_index(:documents) { settings analysis: { analyzer: [:name, :phone, { sorted: { option: :baz } }] } } }
+    let(:documents) { stub_index(:documents) { settings analysis: {analyzer: [:name, :phone, {sorted: {option: :baz}}]} } }
 
     specify { expect { documents.settings_hash }.to_not change(documents._settings, :inspect) }
     specify do
-      expect(documents.settings_hash).to eq(settings: { analysis: {
-                                              analyzer: { name: { filter: %w(lowercase icu_folding names_nysiis) },
-                                                          phone: { tokenizer: 'ngram', char_filter: ['phone'] },
-                                                          sorted: { option: :baz } },
-                                              tokenizer: { ngram: { type: 'nGram', min_gram: 3, max_gram: 3 } },
-                                              char_filter: { phone: { type: 'pattern_replace', pattern: '[^\d]', replacement: '' } },
-                                              filter: { names_nysiis: { type: 'phonetic', encoder: 'nysiis', replace: false } }
-                                            } })
+      expect(documents.settings_hash).to eq(settings: {analysis: {
+        analyzer: {name: {filter: %w[lowercase icu_folding names_nysiis]},
+                   phone: {tokenizer: 'ngram', char_filter: ['phone']},
+                   sorted: {option: :baz}},
+        tokenizer: {ngram: {type: 'nGram', min_gram: 3, max_gram: 3}},
+        char_filter: {phone: {type: 'pattern_replace', pattern: '[^\d]', replacement: ''}},
+        filter: {names_nysiis: {type: 'phonetic', encoder: 'nysiis', replace: false}}
+      }})
     end
   end
 
   describe '.scopes' do
     before do
       stub_index(:places) do
-        def self.by_rating
-        end
+        def self.by_rating; end
 
-        def self.by_name
-        end
+        def self.by_name; end
 
         define_type :city do
-          def self.by_id
-          end
+          def self.by_id; end
         end
       end
     end
 
     specify { expect(described_class.scopes).to eq([]) }
-    specify { expect(PlacesIndex.scopes).to match_array([:by_rating, :by_name]) }
-  end
-
-  describe '.build_index_name' do
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '')).to eq('developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '2013')).to eq('developers_2013') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: '')).to eq('developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: 'test')).to eq('test_developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(:users, prefix: 'test', suffix: '2013')).to eq('test_users_2013') }
+    specify { expect(PlacesIndex.scopes).to match_array(%i[by_rating by_name]) }
   end
 
   describe '.settings_hash' do
     before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
     specify { expect(stub_index(:documents).settings_hash).to eq({}) }
-    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.settings_hash).to eq(settings: { number_of_shards: 1 }) }
+    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.settings_hash).to eq(settings: {number_of_shards: 1}) }
   end
 
   describe '.mappings_hash' do
@@ -218,7 +218,7 @@ describe Chewy::Index do
                define_type :document do
                  field :name, type: 'string'
                end
-             end.mappings_hash).to eq(mappings: { document: { properties: { name: { type: 'string' } } } })
+             end.mappings_hash).to eq(mappings: {document: {properties: {name: {type: 'string'}}}})
     end
     specify do
       expect(stub_index(:documents) do
@@ -228,21 +228,21 @@ describe Chewy::Index do
                define_type :document2 do
                  field :name, type: 'string'
                end
-             end.mappings_hash[:mappings].keys).to match_array([:document, :document2])
+             end.mappings_hash[:mappings].keys).to match_array(%i[document document2])
     end
   end
 
-  describe '.index_params' do
+  describe '.specification_hash' do
     before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
-    specify { expect(stub_index(:documents).index_params).to eq({}) }
-    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.index_params.keys).to eq([:settings]) }
+    specify { expect(stub_index(:documents).specification_hash).to eq({}) }
+    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.specification_hash.keys).to eq([:settings]) }
     specify do
       expect(stub_index(:documents) do
                define_type :document do
                  field :name, type: 'string'
                end
-             end.index_params.keys).to eq([:mappings])
+             end.specification_hash.keys).to eq([:mappings])
     end
     specify do
       expect(stub_index(:documents) do
@@ -250,44 +250,35 @@ describe Chewy::Index do
                define_type :document do
                  field :name, type: 'string'
                end
-             end.index_params.keys).to match_array([:mappings, :settings])
+             end.specification_hash.keys).to match_array(%i[mappings settings])
     end
   end
 
-  describe '.journal?' do
-    specify { expect(stub_index(:documents).journal?).to eq false }
+  describe '.specification' do
+    subject { stub_index(:documents) }
+    specify { expect(subject.specification).to be_a(Chewy::Index::Specification) }
+    specify { expect(subject.specification).to equal(subject.specification) }
+  end
 
-    context do
-      before { allow(Chewy).to receive_messages(configuration: { journal: true }) }
-      specify { expect(stub_index(:documents).journal?).to eq false }
-    end
+  describe '.default_prefix' do
+    before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
 
     context do
-      let(:index) do
-        stub_index(:documents) do
-          define_type :document do
-          end
-        end
-      end
-
-      specify { expect(index.journal?).to eq false }
-
-      context do
-        before { allow(Chewy).to receive_messages(configuration: { journal: true }) }
-        specify { expect(index.journal?).to eq true }
-      end
+      before { expect(ActiveSupport::Deprecation).to receive(:warn).once }
+      specify { expect(DummiesIndex.default_prefix).to eq('testing') }
     end
 
     context do
-      let(:index) do
-        stub_index(:documents) do
-          define_type :document do
-            default_import_options journal: true
+      before do
+        DummiesIndex.class_eval do
+          def self.default_prefix
+            'borogoves'
           end
         end
       end
 
-      specify { expect(index.journal?).to eq true }
+      before { expect(ActiveSupport::Deprecation).to receive(:warn).once }
+      specify { expect(DummiesIndex.index_name).to eq('borogoves_dummies') }
     end
   end
 end

data/spec/chewy/journal_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Chewy::Journal do
-  context 'journaling', orm: true do
+  context 'journaling', :orm do
     ['', 'namespace/'].each do |namespace|
       context namespace.present? ? 'with namespace' : 'without namespace' do
         before do
@@ -22,11 +22,6 @@ describe Chewy::Journal do
           end
 
           Chewy.massacre
-          begin
-            Chewy.client.indices.delete(index: Chewy::Journal.index_name)
-          rescue Elasticsearch::Transport::Transport::Errors::NotFound
-            nil
-          end
           Chewy.settings[:prefix] = 'some_prefix'
           Timecop.freeze(time)
         end
@@ -56,7 +51,7 @@ describe Chewy::Journal do
 
             places_index.import
 
-            expect(Chewy.client.indices.exists?(index: Chewy::Journal.index_name)).to eq true
+            expect(Chewy::Stash.exists?).to eq true
 
             Timecop.freeze(update_time)
             cities.first.update_attributes!(name: 'Supername')
@@ -64,107 +59,207 @@ describe Chewy::Journal do
             Timecop.freeze(destroy_time)
             countries.last.destroy
 
-            journal_records = Chewy.client.search(index: Chewy::Journal.index_name, type: Chewy::Journal.type_name, sort: 'created_at')['hits']['hits'].map { |r| r['_source'] }
-
+            journal_entries = Chewy::Stash::Journal.order(:created_at).hits.map { |r| r['_source'] }
             expected_journal = [
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'city',
                 'action' => 'index',
-                'object_ids' => [1],
-                'created_at' => time.to_i
+                'references' => ['1'],
+                'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'city',
                 'action' => 'index',
-                'object_ids' => [2],
-                'created_at' => time.to_i
+                'references' => ['2'],
+                'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'country',
                 'action' => 'index',
-                'object_ids' => [1],
-                'created_at' => time.to_i
+                'references' => ['1'],
+                'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'country',
                 'action' => 'index',
-                'object_ids' => [2],
-                'created_at' => time.to_i
+                'references' => ['2'],
+                'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'country',
                 'action' => 'index',
-                'object_ids' => [3],
-                'created_at' => time.to_i
+                'references' => ['3'],
+                'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'city',
                 'action' => 'index',
-                'object_ids' => [1, 2],
-                'created_at' => import_time.to_i
+                'references' => %w[1 2],
+                'created_at' => import_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'country',
                 'action' => 'index',
-                'object_ids' => [1, 2, 3],
-                'created_at' => import_time.to_i
+                'references' => %w[1 2 3],
+                'created_at' => import_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'city',
                 'action' => 'index',
-                'object_ids' => [1],
-                'created_at' => update_time.to_i
+                'references' => ['1'],
+                'created_at' => update_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}places",
                 'type_name' => 'country',
                 'action' => 'delete',
-                'object_ids' => [2],
-                'created_at' => destroy_time.to_i
+                'references' => ['2'],
+                'created_at' => destroy_time.utc.as_json
               }
             ]
 
-            expect(Chewy.client.count(index: Chewy::Journal.index_name)['count']).to eq 9
-            expect(journal_records).to eq expected_journal
-
-            journal_entries = Chewy::Journal::Entry.since(import_time)
-            expect(journal_entries.length).to eq 4
-            # we have only 2 types, so we can group all journal entries(4) into 2
-            expect(Chewy::Journal::Entry.group(journal_entries)).to eq [
-              Chewy::Journal::Entry.new('index_name' => "#{namespace}places",
-                                        'type_name' => 'city',
-                                        'action' => nil,
-                                        'object_ids' => [1, 2],
-                                        'created_at' => nil),
-              Chewy::Journal::Entry.new('index_name' => "#{namespace}places",
-                                        'type_name' => 'country',
-                                        'action' => 'delete',
-                                        'object_ids' => [1, 2, 3],
-                                        'created_at' => destroy_time.to_i)
-            ]
+            expect(Chewy::Stash::Journal.count).to eq 9
+            expect(journal_entries).to eq expected_journal
+
+            journal_entries = Chewy::Stash::Journal.entries(import_time - 1)
+            expect(journal_entries.size).to eq 4
 
             # simulate lost data
             Chewy.client.delete(index: "#{Chewy.settings[:prefix]}_places", type: 'city', id: 1, refresh: true)
-            expect(places_index::City.all.to_a.length).to eq 1
+            expect(places_index::City.count).to eq 1
+
+            described_class.new.apply(time)
+            expect(places_index::City.count).to eq 2
+
+            clean_response = described_class.new.clean(import_time)
+            expect(clean_response['deleted'] || clean_response['_indices']['_all']['deleted']).to eq 7
+            Chewy.client.indices.refresh
+            expect(Chewy::Stash::Journal.count).to eq 2
+
+            Timecop.return
+          end
+        end
+      end
+    end
+  end
+
+  context do
+    before { Chewy.massacre }
+    before do
+      stub_model(:city) do
+        update_index 'cities', :self
+      end
+      stub_model(:country) do
+        update_index 'countries', :self
+      end
 
-            Chewy::Journal::Apply.since(time)
-            expect(places_index::City.all.to_a.length).to eq 2
+      stub_index(:cities) do
+        define_type City do
+          default_import_options journal: true
+        end
+      end
+      stub_index(:countries) do
+        define_type Country do
+          default_import_options journal: true
+        end
+      end
+    end
 
-            expect(Chewy::Journal::Clean.until(import_time)).to eq 7
-            expect(Chewy.client.count(index: Chewy::Journal.index_name)['count']).to eq 2
+    describe '#apply' do
+      specify { expect(described_class.new(CitiesIndex).apply(2.minutes.ago)).to eq(0) }
+
+      context 'with an index filter' do
+        let(:time) { Time.now }
+
+        before { Timecop.freeze(time) }
+        after { Timecop.return }
+
+        specify do
+          Chewy.strategy(:urgent) do
+            Array.new(2) { |i| City.create!(id: i + 1) }
+            Array.new(2) { |i| Country.create!(id: i + 1) }
 
-            expect(Chewy::Journal.delete!).to be_truthy
-            expect { Chewy::Journal.delete! }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
-            expect(Chewy::Journal.delete).to eq false
-            expect(Chewy::Journal.exists?).to eq false
+            # simulate lost data
+            Chewy.client.delete(index: 'cities', type: 'city', id: 1, refresh: true)
+            Chewy.client.delete(index: 'countries', type: 'country', id: 1, refresh: true)
+            expect(CitiesIndex.all.to_a.length).to eq 1
+            expect(CountriesIndex.all.to_a.length).to eq 1
+
+            # Replay on specific index
+            expect(described_class.new(CitiesIndex).apply(time)).to eq(2)
+            expect(CitiesIndex.all.to_a.length).to eq 2
+            expect(CountriesIndex.all.to_a.length).to eq 1
+
+            # Replay on both
+            Chewy.client.delete(index: 'cities', type: 'city', id: 1, refresh: true)
+            expect(CitiesIndex.all.to_a.length).to eq 1
+            expect(described_class.new(CitiesIndex, CountriesIndex).apply(time)).to eq(4)
+            expect(CitiesIndex.all.to_a.length).to eq 2
+            expect(CountriesIndex.all.to_a.length).to eq 2
+          end
+        end
+      end
+
+      context 'retries' do
+        let(:time) { Time.now.to_i }
+        before do
+          Timecop.freeze
+          Chewy.strategy(:urgent)
+          City.create!(id: 1)
+        end
+
+        after do
+          Chewy.strategy.pop
+          Timecop.return
+        end
+
+        specify 'journal was cleaned after the first call' do
+          expect(Chewy::Stash::Journal).to receive(:entries).exactly(2).and_call_original
+          expect(described_class.new.apply(time)).to eq(1)
+        end
+
+        context 'endless journal' do
+          let(:count_of_checks) { 10 } # default
+          let!(:journal_entries) do
+            record = Chewy::Stash::Journal.entries(time).first
+            Array.new(count_of_checks) do |i|
+              Chewy::Stash::Journal.new(
+                record.attributes.merge(
+                  'created_at' => time.to_i + i,
+                  'references' => [i.to_s]
+                )
+              )
+            end
+          end
+
+          specify '10 retries by default' do
+            expect(Chewy::Stash::Journal)
+              .to receive(:entries).exactly(count_of_checks) { [journal_entries.shift].compact }
+            expect(described_class.new.apply(time)).to eq(10)
+          end
+
+          specify 'with :once parameter set' do
+            expect(Chewy::Stash::Journal)
+              .to receive(:entries).exactly(1) { [journal_entries.shift].compact }
+            expect(described_class.new.apply(time, retries: 1)).to eq(1)
+          end
+
+          context 'with retries parameter set' do
+            let(:retries) { 5 }
+
+            specify do
+              expect(Chewy::Stash::Journal)
+                .to receive(:entries).exactly(retries) { [journal_entries.shift].compact }
+              expect(described_class.new.apply(time, retries: retries)).to eq(5)
+            end
           end
         end
       end