chewy 5.0.0 → 7.0.1

data/spec/chewy/index/aliases_spec.rb

@@ -10,13 +10,13 @@ describe Chewy::Index::Aliases do
 
     context do
       before { DummiesIndex.create! }
-      specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
     end
 
     context do
       before { DummiesIndex.create! }
       before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2013' }
-      specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
     end
 
     context do
@@ -43,7 +43,7 @@ describe Chewy::Index::Aliases do
 
     context do
       before { DummiesIndex.create! '2013' }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
     end
   end
 end

data/spec/chewy/index_spec.rb

@@ -12,8 +12,11 @@ describe Chewy::Index do
       stub_model(:city)
       stub_model(:country)
 
-      stub_index(:places) do
+      stub_index(:cities) do
         define_type City
+      end
+
+      stub_index(:countries) do
         define_type Country
       end
     end
@@ -22,23 +25,23 @@ describe Chewy::Index do
     let!(:countries) { Array.new(2) { |i| Country.create! id: i + 1 } }
 
     specify do
-      expect { PlacesIndex.import }.to update_index(PlacesIndex::City).and_reindex(cities)
-      expect { PlacesIndex.import }.to update_index(PlacesIndex::Country).and_reindex(countries)
+      expect { CitiesIndex.import }.to update_index(CitiesIndex).and_reindex(cities)
+      expect { CountriesIndex.import }.to update_index(CountriesIndex).and_reindex(countries)
     end
 
     specify do
-      expect { PlacesIndex.import city: cities.first }.to update_index(PlacesIndex::City).and_reindex(cities.first).only
-      expect { PlacesIndex.import city: cities.first }.to update_index(PlacesIndex::Country).and_reindex(countries)
+      expect { CitiesIndex.import city: cities.first }.to update_index(CitiesIndex).and_reindex(cities.first).only
+      expect { CountriesIndex.import city: cities.first }.to update_index(CountriesIndex).and_reindex(countries)
     end
 
     specify do
-      expect { PlacesIndex.import city: cities.first, country: countries.last }.to update_index(PlacesIndex::City).and_reindex(cities.first).only
-      expect { PlacesIndex.import city: cities.first, country: countries.last }.to update_index(PlacesIndex::Country).and_reindex(countries.last).only
+      expect { CitiesIndex.import city: cities.first, country: countries.last }.to update_index(CitiesIndex).and_reindex(cities.first).only
+      expect { CountriesIndex.import city: cities.first, country: countries.last }.to update_index(CountriesIndex).and_reindex(countries.last).only
     end
 
     specify do
-      expect(PlacesIndex.client).to receive(:bulk).with(hash_including(refresh: false)).twice
-      PlacesIndex.import city: cities.first, refresh: false
+      expect(CitiesIndex.client).to receive(:bulk).with(hash_including(refresh: false)).once
+      CitiesIndex.import city: cities.first, refresh: false
     end
   end
 
@@ -101,43 +104,27 @@ describe Chewy::Index do
 
     context do
       before { stub_class('City') }
-      before { stub_class('City::District', City) }
+      before { stub_class('Country') }
 
       specify do
         expect do
           Kernel.eval <<-DUMMY_CITY_INDEX
-            class DummyCityIndex < Chewy::Index
+            class DummyCityIndex2 < Chewy::Index
               define_type City
-              define_type City::District
+              define_type Country
             end
           DUMMY_CITY_INDEX
-        end.not_to raise_error
-      end
+        end.to raise_error(/Multiple types are deprecated/)
 
-      specify do
         expect do
           Kernel.eval <<-DUMMY_CITY_INDEX
             class DummyCityIndex2 < Chewy::Index
-              define_type City
               define_type City::Nothing
             end
           DUMMY_CITY_INDEX
         end.to raise_error(NameError)
       end
     end
-
-    context 'type methods should be deprecated and can\'t redefine existing ones' do
-      before do
-        stub_index(:places) do
-          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 }
-    end
   end
 
   describe '.type_hash' do
@@ -248,16 +235,6 @@ describe Chewy::Index do
                end
              end.mappings_hash).to eq(mappings: {document: {properties: {date: {type: 'date'}}}})
     end
-    specify do
-      expect(stub_index(:documents) do
-               define_type :document do
-                 field :name
-               end
-               define_type :document2 do
-                 field :name
-               end
-             end.mappings_hash[:mappings].keys).to match_array(%i[document document2])
-    end
   end
 
   describe '.specification_hash' do

data/spec/chewy/journal_spec.rb

@@ -6,16 +6,18 @@ describe Chewy::Journal do
       context namespace.present? ? 'with namespace' : 'without namespace' do
         before do
           stub_model(:city) do
-            update_index "#{namespace}places#city", :self
+            update_index "#{namespace}cities", :self
           end
           stub_model(:country) do
-            update_index "#{namespace}places#country", :self
+            update_index "#{namespace}countries", :self
           end
 
-          stub_index("#{namespace}places") do
+          stub_index("#{namespace}cities") do
             define_type City do
               default_import_options journal: true
             end
+          end
+          stub_index("#{namespace}countries") do
             define_type Country do
               default_import_options journal: true
             end
@@ -41,7 +43,8 @@ describe Chewy::Journal do
         end
 
         specify do
-          places_index = namespace.present? ? Namespace::PlacesIndex : PlacesIndex
+          cities_index = namespace.present? ? Namespace::CitiesIndex : CitiesIndex
+          countries_index = namespace.present? ? Namespace::CountriesIndex : CountriesIndex
           Chewy.strategy(:urgent) do
             cities = Array.new(2) { |i| City.create!(id: i + 1) }
             countries = Array.new(2) { |i| Country.create!(id: i + 1) }
@@ -49,12 +52,13 @@ describe Chewy::Journal do
 
             Timecop.freeze(import_time)
 
-            places_index.import
+            cities_index.import
+            countries_index.import
 
             expect(Chewy::Stash::Journal.exists?).to eq true
 
             Timecop.freeze(update_time)
-            cities.first.update_attributes!(name: 'Supername')
+            cities.first.update!(name: 'Supername')
 
             Timecop.freeze(destroy_time)
             countries.last.destroy
@@ -62,63 +66,63 @@ describe Chewy::Journal do
             journal_entries = Chewy::Stash::Journal.order(:created_at).hits.map { |r| r['_source'] }
             expected_journal = [
               {
-                'index_name' => "#{namespace}places",
+                'index_name' => "#{namespace}cities",
                 'type_name' => 'city',
                 'action' => 'index',
                 'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
+                'index_name' => "#{namespace}cities",
                 'type_name' => 'city',
                 'action' => 'index',
                 'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
+                'index_name' => "#{namespace}countries",
                 'type_name' => 'country',
                 'action' => 'index',
                 'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
+                'index_name' => "#{namespace}countries",
                 'type_name' => 'country',
                 'action' => 'index',
                 'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
+                'index_name' => "#{namespace}countries",
                 'type_name' => 'country',
                 'action' => 'index',
                 'references' => ['3'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
+                'index_name' => "#{namespace}cities",
                 'type_name' => 'city',
                 'action' => 'index',
                 'references' => %w[1 2].map(&Base64.method(:encode64)),
                 'created_at' => import_time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
+                'index_name' => "#{namespace}countries",
                 'type_name' => 'country',
                 'action' => 'index',
                 'references' => %w[1 2 3].map(&Base64.method(:encode64)),
                 'created_at' => import_time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
+                'index_name' => "#{namespace}cities",
                 'type_name' => 'city',
                 'action' => 'index',
                 'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => update_time.utc.as_json
               },
               {
-                'index_name' => "#{namespace}places",
+                'index_name' => "#{namespace}countries",
                 'type_name' => 'country',
                 'action' => 'delete',
                 'references' => ['2'].map(&Base64.method(:encode64)),
@@ -133,11 +137,11 @@ describe Chewy::Journal do
             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.count).to eq 1
+            Chewy.client.delete(index: "#{Chewy.settings[:prefix]}_cities", type: 'city', id: 1, refresh: true)
+            expect(cities_index.count).to eq 1
 
             described_class.new.apply(time)
-            expect(places_index::City.count).to eq 2
+            expect(cities_index.count).to eq 2
 
             clean_response = described_class.new.clean(import_time)
             expect(clean_response['deleted'] || clean_response['_indices']['_all']['deleted']).to eq 7

data/spec/chewy/minitest/search_index_receiver_spec.rb

@@ -29,7 +29,9 @@ describe :search_index_receiver do
       define_type :fizz do
         root value: ->(_o) { {} }
       end
+    end
 
+    stub_index(:dummies2) do
       define_type :buzz do
         root value: ->(_o) { {} }
       end
@@ -39,15 +41,15 @@ describe :search_index_receiver do
   context 'catch' do
     specify 'archives more than one type' do
       receiver.catch search_request(2), DummiesIndex::Fizz
-      receiver.catch search_request(3), DummiesIndex::Buzz
-      expect(receiver.indexes.keys).to match_array([DummiesIndex::Fizz, DummiesIndex::Buzz])
+      receiver.catch search_request(3), Dummies2Index::Buzz
+      expect(receiver.indexes.keys).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
     end
   end
 
   context 'indexes_for' do
     before do
       receiver.catch search_request(2), DummiesIndex::Fizz
-      receiver.catch search_request(3), DummiesIndex::Buzz
+      receiver.catch search_request(3), Dummies2Index::Buzz
     end
 
     specify 'returns indexes for a specific type' do
@@ -56,7 +58,7 @@ describe :search_index_receiver do
 
     specify 'returns only indexes for all types' do
       index_responses = receiver.indexes
-      expect(index_responses.keys).to match_array([DummiesIndex::Fizz, DummiesIndex::Buzz])
+      expect(index_responses.keys).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
       expect(parse_request(index_responses.values.flatten)).to match_array([1, 2, 1, 2, 3])
     end
   end
@@ -64,16 +66,16 @@ describe :search_index_receiver do
   context 'deletes_for' do
     before do
       receiver.catch search_request(2, verb: :delete), DummiesIndex::Fizz
-      receiver.catch search_request(3, verb: :delete), DummiesIndex::Buzz
+      receiver.catch search_request(3, verb: :delete), Dummies2Index::Buzz
     end
 
     specify 'returns deletes for a specific type' do
-      expect(receiver.deletes_for(DummiesIndex::Buzz)).to match_array([1, 2, 3])
+      expect(receiver.deletes_for(Dummies2Index::Buzz)).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, DummiesIndex::Buzz])
+      expect(deletes.keys).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
       expect(deletes.values.flatten).to match_array([1, 2, 1, 2, 3])
     end
   end
@@ -113,8 +115,8 @@ describe :search_index_receiver do
   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), DummiesIndex::Buzz
-      expect(receiver.updated_indexes).to match_array([DummiesIndex::Fizz, DummiesIndex::Buzz])
+      receiver.catch search_request(3, verb: :delete), Dummies2Index::Buzz
+      expect(receiver.updated_indexes).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
     end
   end
 end

data/spec/chewy/multi_search_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'chewy/multi_search'
+
+describe Chewy::MultiSearch do
+  before { Chewy.massacre }
+
+  before do
+    stub_model(:city)
+    stub_model(:country)
+
+    stub_index(:cities) do
+      def self.aggregate_by_country
+        aggs(country: {terms: {field: :country_id}})
+      end
+
+      define_type City do
+        field :name, type: 'keyword'
+        field :country_id, type: 'keyword'
+      end
+    end
+  end
+
+  let(:places_query) { CitiesIndex.all }
+
+  describe '#queries' do
+    specify 'returns the queries that are a part of the multi search' do
+      multi_search = described_class.new([places_query])
+      expect(multi_search.queries).to contain_exactly(places_query)
+    end
+  end
+
+  describe '#add_query' do
+    specify 'adds a query to the multi search' do
+      multi_search = described_class.new([])
+      expect do
+        multi_search.add_query(places_query)
+      end.to change {
+        multi_search.queries
+      }.from([]).to([places_query])
+    end
+  end
+
+  context 'when given two queries' do
+    let(:queries) { [aggregates, results] }
+    let(:aggregates) { CitiesIndex.aggregate_by_country.limit(0) }
+    let(:results) { CitiesIndex.limit(10) }
+    let(:multi_search) { described_class.new(queries) }
+    let(:cities) { Array.new(3) { |i| City.create! name: "Name#{i + 2}", country_id: i + 1 } }
+    before { CitiesIndex.import! city: cities }
+
+    describe '#perform' do
+      specify 'performs each query' do
+        expect { multi_search.perform }
+          .to change(aggregates, :performed?).from(false).to(true)
+          .and change(results, :performed?).from(false).to(true)
+      end
+
+      specify 'issues a single request using the msearch endpoint', :aggregate_failures do
+        expect(Chewy.client).to receive(:msearch).once.and_return('responses' => [])
+        expect(Chewy.client).to_not receive(:search)
+        multi_search.perform
+      end
+    end
+
+    describe '#responses' do
+      subject(:responses) { multi_search.responses }
+
+      context 'on a previously performed multi search' do
+        before { multi_search.perform }
+
+        it 'does not perform the query again' do
+          expect(Chewy.client).to_not receive(:msearch)
+          multi_search.responses
+        end
+      end
+
+      specify 'returns the results of each query', :aggregate_failures 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)
+      end
+    end
+  end
+end

data/spec/chewy/rake_helper_spec.rb

@@ -7,16 +7,18 @@ describe Chewy::RakeHelper, :orm do
     stub_model(:city)
     stub_model(:country)
 
-    stub_index(:places) do
+    stub_index(:cities) do
       define_type City do
         field :name
         field :updated_at, type: 'date'
       end
+    end
+    stub_index(:countries) do
       define_type Country
     end
     stub_index(:users)
 
-    allow(described_class).to receive(:all_indexes) { [PlacesIndex, UsersIndex] }
+    allow(described_class).to receive(:all_indexes) { [CitiesIndex, CountriesIndex, UsersIndex] }
   end
 
   let!(:cities) { Array.new(3) { |i| City.create!(name: "Name#{i + 1}") } }
@@ -24,7 +26,7 @@ describe Chewy::RakeHelper, :orm do
   let(:journal) do
     Chewy::Stash::Journal.import([
       {
-        index_name: 'places',
+        index_name: 'cities',
         type_name: 'city',
         action: 'index',
         references: cities.first(2).map(&:id).map(&:to_s)
@@ -32,7 +34,7 @@ describe Chewy::RakeHelper, :orm do
         created_at: 2.minutes.since
       },
       {
-        index_name: 'places',
+        index_name: 'countries',
         type_name: 'country',
         action: 'index',
         references: [Base64.encode64(countries.first.id.to_s.to_json)],
@@ -47,14 +49,17 @@ describe Chewy::RakeHelper, :orm do
     specify do
       output = StringIO.new
       expect { described_class.reset(output: output) }
-        .to update_index(PlacesIndex::City)
+        .to update_index(CitiesIndex)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\AResetting PlacesIndex
-  Imported PlacesIndex::City in \\d+s, stats: index 3
-  Imported PlacesIndex::Country in \\d+s, stats: index 2
-  Applying journal to \\[PlacesIndex::City, PlacesIndex::Country\\], 3 entries, stage 1
-  Imported PlacesIndex::City in \\d+s, stats: index 2
-  Imported PlacesIndex::Country in \\d+s, stats: index 1
+\\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
+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
 Resetting UsersIndex
   Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
@@ -64,15 +69,13 @@ Total: \\d+s\\Z
 
     specify do
       output = StringIO.new
-      expect { described_class.reset(only: 'places', output: output) }
-        .to update_index(PlacesIndex::City)
+      expect { described_class.reset(only: 'cities', output: output) }
+        .to update_index(CitiesIndex)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\AResetting PlacesIndex
-  Imported PlacesIndex::City in \\d+s, stats: index 3
-  Imported PlacesIndex::Country in \\d+s, stats: index 2
-  Applying journal to \\[PlacesIndex::City, PlacesIndex::Country\\], 3 entries, stage 1
-  Imported PlacesIndex::City in \\d+s, stats: index 2
-  Imported PlacesIndex::Country in \\d+s, stats: index 1
+\\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
 Total: \\d+s\\Z
       OUTPUT
@@ -80,8 +83,8 @@ Total: \\d+s\\Z
 
     specify do
       output = StringIO.new
-      expect { described_class.reset(except: PlacesIndex, output: output) }
-        .not_to update_index(PlacesIndex::City)
+      expect { described_class.reset(except: [CitiesIndex, CountriesIndex], output: output) }
+        .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
@@ -94,11 +97,13 @@ Total: \\d+s\\Z
     specify do
       output = StringIO.new
       expect { described_class.upgrade(output: output) }
-        .to update_index(PlacesIndex::City)
+        .to update_index(CitiesIndex)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\AResetting PlacesIndex
-  Imported PlacesIndex::City in \\d+s, stats: index 3
-  Imported PlacesIndex::Country in \\d+s, stats: index 2
+\\AResetting CitiesIndex
+  Imported CitiesIndex::City in \\d+s, stats: index 3
+  Imported Chewy::Stash::Specification::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
 Resetting UsersIndex
   Imported Chewy::Stash::Specification::Specification in \\d+s, stats: index 1
@@ -107,14 +112,18 @@ Total: \\d+s\\Z
     end
 
     context do
-      before { PlacesIndex.reset! }
+      before do
+        CitiesIndex.reset!
+        CountriesIndex.reset!
+      end
 
       specify do
         output = StringIO.new
         expect { described_class.upgrade(output: output) }
-          .not_to update_index(PlacesIndex::City)
+          .not_to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\ASkipping PlacesIndex, the specification didn't change
+\\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
 Total: \\d+s\\Z
@@ -123,8 +132,8 @@ Total: \\d+s\\Z
 
       specify do
         output = StringIO.new
-        expect { described_class.upgrade(except: PlacesIndex, output: output) }
-          .not_to update_index(PlacesIndex::City)
+        expect { described_class.upgrade(except: [CitiesIndex, CountriesIndex], output: output) }
+          .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
@@ -137,8 +146,8 @@ Total: \\d+s\\Z
 
         specify do
           output = StringIO.new
-          expect { described_class.upgrade(except: ['places'], output: output) }
-            .not_to update_index(PlacesIndex::City)
+          expect { described_class.upgrade(except: %w[cities countries], output: output) }
+            .not_to update_index(CitiesIndex)
           expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\ANo index specification was changed
 Total: \\d+s\\Z
@@ -152,45 +161,51 @@ Total: \\d+s\\Z
     specify do
       output = StringIO.new
       expect { described_class.update(output: output) }
-        .not_to update_index(PlacesIndex::City)
+        .not_to update_index(CitiesIndex)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\ASkipping PlacesIndex, it does not exists \\(use rake chewy:reset\\[places\\] to create and update it\\)
+\\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\\)
+Total: \\d+s\\Z
       OUTPUT
     end
 
     context do
-      before { PlacesIndex.reset! }
+      before do
+        CitiesIndex.reset!
+        CountriesIndex.reset!
+      end
 
       specify do
         output = StringIO.new
         expect { described_class.update(output: output) }
-          .to update_index(PlacesIndex::City)
+          .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\AUpdating PlacesIndex
-  Imported PlacesIndex::City in \\d+s, stats: index 3
-  Imported PlacesIndex::Country in \\d+s, stats: index 2
+\\AUpdating CitiesIndex
+  Imported CitiesIndex::City in \\d+s, stats: index 3
+Updating CountriesIndex
+  Imported CountriesIndex::Country in \\d+s, stats: index 2
 Total: \\d+s\\Z
         OUTPUT
       end
 
       specify do
         output = StringIO.new
-        expect { described_class.update(only: 'places#country', output: output) }
-          .not_to update_index(PlacesIndex::City)
+        expect { described_class.update(only: 'countries', output: output) }
+          .not_to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\AUpdating PlacesIndex
-  Imported PlacesIndex::Country in \\d+s, stats: index 2
+\\AUpdating CountriesIndex
+  Imported CountriesIndex::Country in \\d+s, stats: index 2
 Total: \\d+s\\Z
         OUTPUT
       end
 
       specify do
         output = StringIO.new
-        expect { described_class.update(except: PlacesIndex::Country, output: output) }
-          .to update_index(PlacesIndex::City)
+        expect { described_class.update(except: CountriesIndex, output: output) }
+          .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\AUpdating PlacesIndex
-  Imported PlacesIndex::City in \\d+s, stats: index 3
+\\AUpdating CitiesIndex
+  Imported CitiesIndex::City in \\d+s, stats: index 3
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -201,15 +216,15 @@ Total: \\d+s\\Z
     specify do
       output = StringIO.new
       expect { described_class.sync(output: output) }
-        .to update_index(PlacesIndex::City)
+        .to update_index(CitiesIndex)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\ASynchronizing PlacesIndex::City
-  Imported PlacesIndex::City in \\d+s, stats: index 3
+\\ASynchronizing CitiesIndex::City
+  Imported CitiesIndex::City in \\d+s, stats: index 3
   Missing documents: \\[[^\\]]+\\]
   Took \\d+s
-Synchronizing PlacesIndex::Country
-  PlacesIndex::Country doesn't support outdated synchronization
-  Imported PlacesIndex::Country in \\d+s, stats: index 2
+Synchronizing CountriesIndex::Country
+  CountriesIndex::Country doesn't support outdated synchronization
+  Imported CountriesIndex::Country in \\d+s, stats: index 2
   Missing documents: \\[[^\\]]+\\]
   Took \\d+s
 Total: \\d+s\\Z
@@ -218,8 +233,8 @@ Total: \\d+s\\Z
 
     context do
       before do
-        PlacesIndex::City.import(cities.first(2))
-        PlacesIndex::Country.import
+        CitiesIndex.import(cities.first(2))
+        CountriesIndex.import
 
         sleep(1) if ActiveSupport::VERSION::STRING < '4.1.0'
         cities.first.update(name: 'Name5')
@@ -228,16 +243,16 @@ Total: \\d+s\\Z
       specify do
         output = StringIO.new
         expect { described_class.sync(output: output) }
-          .to update_index(PlacesIndex::City)
+          .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\ASynchronizing PlacesIndex::City
-  Imported PlacesIndex::City in \\d+s, stats: index 2
+\\ASynchronizing CitiesIndex::City
+  Imported CitiesIndex::City in \\d+s, stats: index 2
   Missing documents: \\["#{cities.last.id}"\\]
   Outdated documents: \\["#{cities.first.id}"\\]
   Took \\d+s
-Synchronizing PlacesIndex::Country
-  PlacesIndex::Country doesn't support outdated synchronization
-  Skipping PlacesIndex::Country, up to date
+Synchronizing CountriesIndex::Country
+  CountriesIndex::Country doesn't support outdated synchronization
+  Skipping CountriesIndex::Country, up to date
   Took \\d+s
 Total: \\d+s\\Z
         OUTPUT
@@ -245,11 +260,11 @@ Total: \\d+s\\Z
 
       specify do
         output = StringIO.new
-        expect { described_class.sync(only: PlacesIndex::City, output: output) }
-          .to update_index(PlacesIndex::City)
+        expect { described_class.sync(only: CitiesIndex, output: output) }
+          .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\ASynchronizing PlacesIndex::City
-  Imported PlacesIndex::City in \\d+s, stats: index 2
+\\ASynchronizing CitiesIndex::City
+  Imported CitiesIndex::City in \\d+s, stats: index 2
   Missing documents: \\["#{cities.last.id}"\\]
   Outdated documents: \\["#{cities.first.id}"\\]
   Took \\d+s
@@ -259,12 +274,12 @@ Total: \\d+s\\Z
 
       specify do
         output = StringIO.new
-        expect { described_class.sync(except: ['places#city'], output: output) }
-          .not_to update_index(PlacesIndex::City)
+        expect { described_class.sync(except: ['cities'], output: output) }
+          .not_to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
-\\ASynchronizing PlacesIndex::Country
-  PlacesIndex::Country doesn't support outdated synchronization
-  Skipping PlacesIndex::Country, up to date
+\\ASynchronizing CountriesIndex::Country
+  CountriesIndex::Country doesn't support outdated synchronization
+  Skipping CountriesIndex::Country, up to date
   Took \\d+s
 Total: \\d+s\\Z
         OUTPUT
@@ -290,12 +305,12 @@ Total: \\d+s\\Z
       specify do
         output = StringIO.new
         expect { described_class.journal_apply(time: Time.now, output: output) }
-          .to update_index(PlacesIndex::City)
+          .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AApplying journal entries created after [+-:\\d\\s]+
-  Applying journal to \\[PlacesIndex::City, PlacesIndex::Country\\], 3 entries, stage 1
-  Imported PlacesIndex::City in \\d+s, stats: index 2
-  Imported PlacesIndex::Country in \\d+s, stats: index 1
+  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
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -303,35 +318,35 @@ Total: \\d+s\\Z
       specify do
         output = StringIO.new
         expect { described_class.journal_apply(time: 3.minutes.since, output: output) }
-          .not_to update_index(PlacesIndex::City)
+          .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 \\[PlacesIndex::Country\\], 1 entries, stage 1
-  Imported PlacesIndex::Country in \\d+s, stats: index 1
+  Applying journal to \\[CountriesIndex::Country\\], 1 entries, stage 1
+  Imported CountriesIndex::Country in \\d+s, stats: index 1
 Total: \\d+s\\Z
         OUTPUT
       end
 
       specify do
         output = StringIO.new
-        expect { described_class.journal_apply(time: Time.now, only: PlacesIndex::City, output: output) }
-          .to update_index(PlacesIndex::City)
+        expect { described_class.journal_apply(time: Time.now, only: CitiesIndex, output: output) }
+          .to update_index(CitiesIndex)
         expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\AApplying journal entries created after [+-:\\d\\s]+
-  Applying journal to \\[PlacesIndex::City\\], 2 entries, stage 1
-  Imported PlacesIndex::City in \\d+s, stats: index 2
+  Applying journal to \\[CitiesIndex::City\\], 2 entries, stage 1
+  Imported CitiesIndex::City in \\d+s, stats: index 2
 Total: \\d+s\\Z
         OUTPUT
       end
 
       specify do
         output = StringIO.new
-        expect { described_class.journal_apply(time: Time.now, except: PlacesIndex::City, output: output) }
-          .not_to update_index(PlacesIndex::City)
+        expect { described_class.journal_apply(time: Time.now, except: CitiesIndex, output: output) }
+          .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 \\[PlacesIndex::Country\\], 1 entries, stage 1
-  Imported PlacesIndex::Country in \\d+s, stats: index 1
+  Applying journal to \\[CountriesIndex::Country\\], 1 entries, stage 1
+  Imported CountriesIndex::Country in \\d+s, stats: index 1
 Total: \\d+s\\Z
         OUTPUT
       end
@@ -362,7 +377,7 @@ Total: \\d+s\\Z
 
     specify do
       output = StringIO.new
-      described_class.journal_clean(only: PlacesIndex::City, output: output)
+      described_class.journal_clean(only: CitiesIndex, output: output)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\ACleaned up 1 journal entries
 Total: \\d+s\\Z
@@ -371,7 +386,7 @@ Total: \\d+s\\Z
 
     specify do
       output = StringIO.new
-      described_class.journal_clean(except: PlacesIndex::City, output: output)
+      described_class.journal_clean(except: CitiesIndex, output: output)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\ACleaned up 1 journal entries
 Total: \\d+s\\Z