chewy 7.1.0 → 7.2.0

data/spec/chewy/minitest/helpers_spec.rb

@@ -18,54 +18,52 @@ describe :minitest_helper do
 
   before do
     stub_index(:dummies) do
-      define_type :dummy do
-        root value: ->(_o) { {} }
-      end
+      root value: ->(_o) { {} }
     end
   end
 
   context 'assert_indexes' do
     specify 'doesn\'t fail when index updates correctly' do
       expect do
-        assert_indexes DummiesIndex::Dummy do
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+        assert_indexes DummiesIndex do
+          DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
         end
       end.to_not raise_error
     end
 
     specify 'fails when index doesn\'t update' do
       expect do
-        assert_indexes DummiesIndex::Dummy do
+        assert_indexes DummiesIndex do
         end
       end.to raise_error(RSpec::Expectations::ExpectationNotMetError)
     end
 
     specify 'SearchIndexReceiver catches the indexes' do
-      receiver = assert_indexes DummiesIndex::Dummy do
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      receiver = assert_indexes DummiesIndex do
+        DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
       end
 
       expect(receiver).to be_a(SearchIndexReceiver)
 
       expect(
-        receiver.indexes_for(DummiesIndex::Dummy)
+        receiver.indexes_for(DummiesIndex)
                 .map { |index| index[:_id] }
       ).to match_array([41, 42])
     end
 
     specify 'Real index is bypassed when asserting' do
-      expect(DummiesIndex::Dummy).not_to receive(:bulk)
+      expect(DummiesIndex).not_to receive(:bulk)
 
-      assert_indexes DummiesIndex::Dummy do
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      assert_indexes DummiesIndex do
+        DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
       end
     end
 
     specify 'Real index is allowed when asserting' do
-      expect(DummiesIndex::Dummy).to receive(:bulk)
+      expect(DummiesIndex).to receive(:bulk)
 
-      assert_indexes DummiesIndex::Dummy, bypass_actual_index: false do
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      assert_indexes DummiesIndex, bypass_actual_index: false do
+        DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
       end
     end
   end

data/spec/chewy/minitest/search_index_receiver_spec.rb

@@ -26,97 +26,93 @@ describe :search_index_receiver do
 
   before do
     stub_index(:dummies) do
-      define_type :fizz do
-        root value: ->(_o) { {} }
-      end
+      root value: ->(_o) { {} }
     end
 
     stub_index(:dummies2) do
-      define_type :buzz do
-        root value: ->(_o) { {} }
-      end
+      root value: ->(_o) { {} }
     end
   end
 
   context 'catch' do
     specify 'archives more than one type' do
-      receiver.catch search_request(2), DummiesIndex::Fizz
-      receiver.catch search_request(3), Dummies2Index::Buzz
-      expect(receiver.indexes.keys).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
+      receiver.catch search_request(2), DummiesIndex
+      receiver.catch search_request(3), Dummies2Index
+      expect(receiver.indexes.keys).to match_array([DummiesIndex, Dummies2Index])
     end
   end
 
   context 'indexes_for' do
     before do
-      receiver.catch search_request(2), DummiesIndex::Fizz
-      receiver.catch search_request(3), Dummies2Index::Buzz
+      receiver.catch search_request(2), DummiesIndex
+      receiver.catch search_request(3), Dummies2Index
     end
 
     specify 'returns indexes for a specific type' do
-      expect(parse_request(receiver.indexes_for(DummiesIndex::Fizz))).to match_array([1, 2])
+      expect(parse_request(receiver.indexes_for(DummiesIndex))).to match_array([1, 2])
     end
 
     specify 'returns only indexes for all types' do
       index_responses = receiver.indexes
-      expect(index_responses.keys).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
+      expect(index_responses.keys).to match_array([DummiesIndex, Dummies2Index])
       expect(parse_request(index_responses.values.flatten)).to match_array([1, 2, 1, 2, 3])
     end
   end
 
   context 'deletes_for' do
     before do
-      receiver.catch search_request(2, verb: :delete), DummiesIndex::Fizz
-      receiver.catch search_request(3, verb: :delete), Dummies2Index::Buzz
+      receiver.catch search_request(2, verb: :delete), DummiesIndex
+      receiver.catch search_request(3, verb: :delete), Dummies2Index
     end
 
     specify 'returns deletes for a specific type' do
-      expect(receiver.deletes_for(Dummies2Index::Buzz)).to match_array([1, 2, 3])
+      expect(receiver.deletes_for(Dummies2Index)).to match_array([1, 2, 3])
     end
 
     specify 'returns only deletes for all types' do
       deletes = receiver.deletes
-      expect(deletes.keys).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
+      expect(deletes.keys).to match_array([DummiesIndex, Dummies2Index])
       expect(deletes.values.flatten).to match_array([1, 2, 1, 2, 3])
     end
   end
 
   context 'indexed?' do
     before do
-      receiver.catch search_request(1), DummiesIndex::Fizz
+      receiver.catch search_request(1), DummiesIndex
     end
 
     specify 'validates that an object was indexed' do
       dummy = OpenStruct.new(id: 1)
-      expect(receiver.indexed?(dummy, DummiesIndex::Fizz)).to be(true)
+      expect(receiver.indexed?(dummy, DummiesIndex)).to be(true)
     end
 
     specify 'doesn\'t validate than unindexed objects were indexed' do
       dummy = OpenStruct.new(id: 2)
-      expect(receiver.indexed?(dummy, DummiesIndex::Fizz)).to be(false)
+      expect(receiver.indexed?(dummy, DummiesIndex)).to be(false)
     end
   end
 
   context 'deleted?' do
     before do
-      receiver.catch search_request(1, verb: :delete), DummiesIndex::Fizz
+      receiver.catch search_request(1, verb: :delete), DummiesIndex
     end
 
     specify 'validates than an object was deleted' do
       dummy = OpenStruct.new(id: 1)
-      expect(receiver.deleted?(dummy, DummiesIndex::Fizz)).to be(true)
+      expect(receiver.deleted?(dummy, DummiesIndex)).to be(true)
     end
 
     specify 'doesn\'t validate than undeleted objects were deleted' do
       dummy = OpenStruct.new(id: 2)
-      expect(receiver.deleted?(dummy, DummiesIndex::Fizz)).to be(false)
+      expect(receiver.deleted?(dummy, DummiesIndex)).to be(false)
     end
   end
 
   context 'updated_indexes' do
     specify 'provides a list of indices updated' do
-      receiver.catch search_request(2, verb: :delete), DummiesIndex::Fizz
-      receiver.catch search_request(3, verb: :delete), Dummies2Index::Buzz
-      expect(receiver.updated_indexes).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
+      receiver.catch search_request(2, verb: :delete), DummiesIndex
+      receiver.catch search_request(3, verb: :delete), Dummies2Index
+      expect(receiver.updated_indexes).to match_array([DummiesIndex, Dummies2Index])
     end
   end
 end

data/spec/chewy/multi_search_spec.rb

@@ -13,10 +13,9 @@ describe Chewy::MultiSearch do
         aggs(country: {terms: {field: :country_id}})
       end
 
-      define_type City do
-        field :name, type: 'keyword'
-        field :country_id, type: 'keyword'
-      end
+      index_scope City
+      field :name, type: 'keyword'
+      field :country_id, type: 'keyword'
     end
   end
 
@@ -78,7 +77,7 @@ describe Chewy::MultiSearch do
         is_expected.to have(2).responses
         expect(responses[0]).to be_a(Chewy::Search::Response)
         expect(responses[1]).to be_a(Chewy::Search::Response)
-        expect(responses[1].wrappers).to all(be_a CitiesIndex::City)
+        expect(responses[1].wrappers).to all(be_a CitiesIndex)
       end
     end
   end

data/spec/chewy/rake_helper_spec.rb

@@ -8,13 +8,12 @@ describe Chewy::RakeHelper, :orm do
     stub_model(:country)
 
     stub_index(:cities) do
-      define_type City do
-        field :name
-        field :updated_at, type: 'date'
-      end
+      index_scope City
+      field :name
+      field :updated_at, type: 'date'
     end
     stub_index(:countries) do
-      define_type Country
+      index_scope Country
     end
     stub_index(:users)
 
@@ -52,17 +51,18 @@ describe Chewy::RakeHelper, :orm do
         .to update_index(CitiesIndex)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AResetting CitiesIndex
-  Imported CitiesIndex::City in \\d+s, stats: index 3
-  Applying journal to \\[CitiesIndex::City\\], 2 entries, stage 1
-  Imported CitiesIndex::City in \\d+s, stats: index 2
-  Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
+  Imported CitiesIndex in \\d+s, stats: index 3
+  Applying journal to \\[CitiesIndex\\], 2 entries, stage 1
+  Imported CitiesIndex in \\d+s, stats: index 2
+  Imported Chewy::Stash::Specification in \\d+s, stats: index 1
 Resetting CountriesIndex
-  Imported CountriesIndex::Country in \\d+s, stats: index 2
-  Applying journal to \\[CountriesIndex::Country\\], 1 entries, stage 1
-  Imported CountriesIndex::Country in \\d+s, stats: index 1
-  Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
+  Imported CountriesIndex in \\d+s, stats: index 2
+  Applying journal to \\[CountriesIndex\\], 1 entries, stage 1
+  Imported CountriesIndex in \\d+s, stats: index 1
+  Imported Chewy::Stash::Specification in \\d+s, stats: index 1
 Resetting UsersIndex
-  Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
+  Imported UsersIndex in 1s, stats:\s
+  Imported Chewy::Stash::Specification in \\d+s, stats: index 1
 Total: \\d+s\\Z
       OUTPUT
     end
@@ -73,10 +73,10 @@ Total: \\d+s\\Z
         .to update_index(CitiesIndex)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AResetting CitiesIndex
-  Imported CitiesIndex::City in \\d+s, stats: index 3
-  Applying journal to \\[CitiesIndex::City\\], 2 entries, stage 1
-  Imported CitiesIndex::City in \\d+s, stats: index 2
-  Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
+  Imported CitiesIndex in \\d+s, stats: index 3
+  Applying journal to \\[CitiesIndex\\], 2 entries, stage 1
+  Imported CitiesIndex in \\d+s, stats: index 2
+  Imported Chewy::Stash::Specification in \\d+s, stats: index 1
 Total: \\d+s\\Z
       OUTPUT
     end
@@ -87,7 +87,8 @@ Total: \\d+s\\Z
         .not_to update_index(CitiesIndex)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AResetting UsersIndex
-  Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
+  Imported UsersIndex in 1s, stats:\s
+  Imported Chewy::Stash::Specification in \\d+s, stats: index 1
 Total: \\d+s\\Z
       OUTPUT
     end
@@ -100,13 +101,14 @@ Total: \\d+s\\Z
         .to update_index(CitiesIndex)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AResetting CitiesIndex
-  Imported CitiesIndex::City in \\d+s, stats: index 3
-  Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
+  Imported CitiesIndex in \\d+s, stats: index 3
+  Imported Chewy::Stash::Specification in \\d+s, stats: index 1
 Resetting CountriesIndex
-  Imported CountriesIndex::Country in \\d+s, stats: index 2
-  Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
+  Imported CountriesIndex in \\d+s, stats: index 2
+  Imported Chewy::Stash::Specification in \\d+s, stats: index 1
 Resetting UsersIndex
-  Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
+  Imported UsersIndex in 1s, stats:\s
+  Imported Chewy::Stash::Specification in \\d+s, stats: index 1
 Total: \\d+s\\Z
       OUTPUT
     end
@@ -125,7 +127,8 @@ Total: \\d+s\\Z
 \\ASkipping CitiesIndex, the specification didn't change
 Skipping CountriesIndex, the specification didn't change
 Resetting UsersIndex
-  Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
+  Imported UsersIndex in 1s, stats:\s
+  Imported Chewy::Stash::Specification in \\d+s, stats: index 1
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -136,7 +139,8 @@ Total: \\d+s\\Z
           .not_to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AResetting UsersIndex
-  Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
+  Imported UsersIndex in 1s, stats:\s
+  Imported Chewy::Stash::Specification in \\d+s, stats: index 1
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -165,6 +169,7 @@ Total: \\d+s\\Z
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\ASkipping CitiesIndex, it does not exists \\(use rake chewy:reset\\[cities\\] to create and update it\\)
 Skipping CountriesIndex, it does not exists \\(use rake chewy:reset\\[countries\\] to create and update it\\)
+Skipping UsersIndex, it does not exists \\(use rake chewy:reset\\[users\\] to create and update it\\)
 Total: \\d+s\\Z
       OUTPUT
     end
@@ -181,9 +186,10 @@ Total: \\d+s\\Z
           .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AUpdating CitiesIndex
-  Imported CitiesIndex::City in \\d+s, stats: index 3
+  Imported CitiesIndex in \\d+s, stats: index 3
 Updating CountriesIndex
-  Imported CountriesIndex::Country in \\d+s, stats: index 2
+  Imported CountriesIndex in \\d+s, stats: index 2
+Skipping UsersIndex, it does not exists \\(use rake chewy:reset\\[users\\] to create and update it\\)
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -194,7 +200,7 @@ Total: \\d+s\\Z
           .not_to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AUpdating CountriesIndex
-  Imported CountriesIndex::Country in \\d+s, stats: index 2
+  Imported CountriesIndex in \\d+s, stats: index 2
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -205,7 +211,8 @@ Total: \\d+s\\Z
           .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AUpdating CitiesIndex
-  Imported CitiesIndex::City in \\d+s, stats: index 3
+  Imported CitiesIndex in \\d+s, stats: index 3
+Skipping UsersIndex, it does not exists \\(use rake chewy:reset\\[users\\] to create and update it\\)
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -218,15 +225,19 @@ Total: \\d+s\\Z
       expect { described_class.sync(output: output) }
         .to update_index(CitiesIndex)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\ASynchronizing CitiesIndex::City
-  Imported CitiesIndex::City in \\d+s, stats: index 3
+\\ASynchronizing CitiesIndex
+  Imported CitiesIndex in \\d+s, stats: index 3
   Missing documents: \\[[^\\]]+\\]
   Took \\d+s
-Synchronizing CountriesIndex::Country
-  CountriesIndex::Country doesn't support outdated synchronization
-  Imported CountriesIndex::Country in \\d+s, stats: index 2
+Synchronizing CountriesIndex
+  CountriesIndex doesn't support outdated synchronization
+  Imported CountriesIndex in \\d+s, stats: index 2
   Missing documents: \\[[^\\]]+\\]
   Took \\d+s
+Synchronizing UsersIndex
+  UsersIndex doesn't support outdated synchronization
+  Skipping UsersIndex, up to date
+  Took \\d+s
 Total: \\d+s\\Z
       OUTPUT
     end
@@ -236,7 +247,6 @@ Total: \\d+s\\Z
         CitiesIndex.import(cities.first(2))
         CountriesIndex.import
 
-        sleep(1) if ActiveSupport::VERSION::STRING < '4.1.0'
         cities.first.update(name: 'Name5')
       end
 
@@ -245,14 +255,18 @@ Total: \\d+s\\Z
         expect { described_class.sync(output: output) }
           .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\ASynchronizing CitiesIndex::City
-  Imported CitiesIndex::City in \\d+s, stats: index 2
+\\ASynchronizing CitiesIndex
+  Imported CitiesIndex in \\d+s, stats: index 2
   Missing documents: \\["#{cities.last.id}"\\]
   Outdated documents: \\["#{cities.first.id}"\\]
   Took \\d+s
-Synchronizing CountriesIndex::Country
-  CountriesIndex::Country doesn't support outdated synchronization
-  Skipping CountriesIndex::Country, up to date
+Synchronizing CountriesIndex
+  CountriesIndex doesn't support outdated synchronization
+  Skipping CountriesIndex, up to date
+  Took \\d+s
+Synchronizing UsersIndex
+  UsersIndex doesn't support outdated synchronization
+  Skipping UsersIndex, up to date
   Took \\d+s
 Total: \\d+s\\Z
         OUTPUT
@@ -263,8 +277,8 @@ Total: \\d+s\\Z
         expect { described_class.sync(only: CitiesIndex, output: output) }
           .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\ASynchronizing CitiesIndex::City
-  Imported CitiesIndex::City in \\d+s, stats: index 2
+\\ASynchronizing CitiesIndex
+  Imported CitiesIndex in \\d+s, stats: index 2
   Missing documents: \\["#{cities.last.id}"\\]
   Outdated documents: \\["#{cities.first.id}"\\]
   Took \\d+s
@@ -277,9 +291,13 @@ Total: \\d+s\\Z
         expect { described_class.sync(except: ['cities'], output: output) }
           .not_to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\ASynchronizing CountriesIndex::Country
-  CountriesIndex::Country doesn't support outdated synchronization
-  Skipping CountriesIndex::Country, up to date
+\\ASynchronizing CountriesIndex
+  CountriesIndex doesn't support outdated synchronization
+  Skipping CountriesIndex, up to date
+  Took \\d+s
+Synchronizing UsersIndex
+  UsersIndex doesn't support outdated synchronization
+  Skipping UsersIndex, up to date
   Took \\d+s
 Total: \\d+s\\Z
         OUTPUT
@@ -308,9 +326,9 @@ Total: \\d+s\\Z
           .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AApplying journal entries created after [+-:\\d\\s]+
-  Applying journal to \\[CitiesIndex::City, CountriesIndex::Country\\], 3 entries, stage 1
-  Imported CitiesIndex::City in \\d+s, stats: index 2
-  Imported CountriesIndex::Country in \\d+s, stats: index 1
+  Applying journal to \\[CitiesIndex, CountriesIndex\\], 3 entries, stage 1
+  Imported CitiesIndex in \\d+s, stats: index 2
+  Imported CountriesIndex in \\d+s, stats: index 1
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -321,8 +339,8 @@ Total: \\d+s\\Z
           .not_to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AApplying journal entries created after [+-:\\d\\s]+
-  Applying journal to \\[CountriesIndex::Country\\], 1 entries, stage 1
-  Imported CountriesIndex::Country in \\d+s, stats: index 1
+  Applying journal to \\[CountriesIndex\\], 1 entries, stage 1
+  Imported CountriesIndex in \\d+s, stats: index 1
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -333,8 +351,8 @@ Total: \\d+s\\Z
           .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AApplying journal entries created after [+-:\\d\\s]+
-  Applying journal to \\[CitiesIndex::City\\], 2 entries, stage 1
-  Imported CitiesIndex::City in \\d+s, stats: index 2
+  Applying journal to \\[CitiesIndex\\], 2 entries, stage 1
+  Imported CitiesIndex in \\d+s, stats: index 2
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -345,8 +363,8 @@ Total: \\d+s\\Z
           .not_to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AApplying journal entries created after [+-:\\d\\s]+
-  Applying journal to \\[CountriesIndex::Country\\], 1 entries, stage 1
-  Imported CountriesIndex::Country in \\d+s, stats: index 1
+  Applying journal to \\[CountriesIndex\\], 1 entries, stage 1
+  Imported CountriesIndex in \\d+s, stats: index 1
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -393,4 +411,76 @@ Total: \\d+s\\Z
       OUTPUT
     end
   end
+
+  describe '.reindex' do
+    before do
+      journal
+      CitiesIndex.create!
+      CountriesIndex.create!
+    end
+
+    let(:source_index) { 'cities' }
+    let(:dest_index) { 'countries' }
+
+    context 'with correct arguments' do
+      specify do
+        output = StringIO.new
+        described_class.reindex(source: source_index, dest: dest_index, output: output)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\Source index is cities
+\\Destination index is countries
+cities index successfully reindexed with countries index data
+Total: \\d+s\\Z
+        OUTPUT
+      end
+    end
+
+    context 'with missing indexes' do
+      context 'without dest index' do
+        specify do
+          output = StringIO.new
+          expect { described_class.reindex(source: source_index, output: output) }
+            .to raise_error ArgumentError
+        end
+      end
+
+      context 'without source index' do
+        specify do
+          output = StringIO.new
+          expect { described_class.reindex(dest: dest_index, output: output) }
+            .to raise_error ArgumentError
+        end
+      end
+    end
+  end
+
+  describe '.update_mapping' do
+    before do
+      journal
+      CitiesIndex.create!
+    end
+
+    let(:index_name) { CitiesIndex.index_name }
+    let(:nonexistent_index) { 'wrong_index' }
+
+    context 'with existing index' do
+      specify do
+        output = StringIO.new
+        described_class.update_mapping(name: index_name, output: output)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\Index name is cities
+cities index successfully updated
+Total: \\d+s\\Z
+        OUTPUT
+      end
+    end
+
+    context 'with non-existent index name' do
+      specify do
+        output = StringIO.new
+        expect { described_class.update_mapping(name: nonexistent_index, output: output) }
+          .to raise_error NameError
+      end
+    end
+  end
 end