chewy 6.0.0 → 7.5.1

data/spec/chewy/rake_helper_spec.rb

@@ -1,26 +1,29 @@
 require 'spec_helper'
+require 'rake'
 
 describe Chewy::RakeHelper, :orm do
   before { Chewy.massacre }
 
   before do
+    described_class.instance_variable_set(:@journal_exists, journal_exists)
+
     stub_model(:city)
     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)
 
     allow(described_class).to receive(:all_indexes) { [CitiesIndex, CountriesIndex, UsersIndex] }
   end
 
+  let(:journal_exists) { true }
   let!(:cities) { Array.new(3) { |i| City.create!(name: "Name#{i + 1}") } }
   let!(:countries) { Array.new(2) { |i| Country.create!(name: "Name#{i + 1}") } }
   let(:journal) do
@@ -52,17 +55,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 +77,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,10 +91,27 @@ 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
+
+    context 'when journal is missing' do
+      let(:journal_exists) { false }
+
+      specify do
+        output = StringIO.new
+        expect { described_class.reset(only: [CitiesIndex], output: output) }
+          .to update_index(CitiesIndex)
+        expect(output.string).to include(
+          "############################################################\n" \
+          "WARN: You are risking to lose some changes during the reset.\n      " \
+          "Please consider enabling journaling.\n      " \
+          'See https://github.com/toptal/chewy#journaling'
+        )
+      end
+    end
   end
 
   describe '.upgrade' do
@@ -100,13 +121,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 +147,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 +159,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 +189,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 +206,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 +220,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 +231,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 +245,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 +267,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 +275,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 +297,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 +311,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 +346,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 +359,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 +371,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 +383,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
@@ -392,5 +430,227 @@ Total: \\d+s\\Z
 Total: \\d+s\\Z
       OUTPUT
     end
+
+    it 'executes asynchronously' do
+      output = StringIO.new
+      expect(Chewy.client).to receive(:delete_by_query).with(
+        {
+          body: {query: {match_all: {}}},
+          index: ['chewy_journal'],
+          refresh: false,
+          requests_per_second: 10.0,
+          scroll_size: 200,
+          wait_for_completion: false
+        }
+      ).and_call_original
+      described_class.journal_clean(
+        output: output,
+        delete_by_query_options: {
+          wait_for_completion: false,
+          requests_per_second: 10.0,
+          scroll_size: 200
+        }
+      )
+
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ATask to cleanup the journal has been created, [^\\n]*
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    context 'execute "chewy:journal:clean" rake task' do
+      subject(:task) { Rake.application['chewy:journal:clean'] }
+      before do
+        Rake::DefaultLoader.new.load('lib/tasks/chewy.rake')
+        Rake::Task.define_task(:environment)
+      end
+      it 'does not raise error' do
+        expect { task.invoke }.to_not raise_error
+      end
+    end
+  end
+
+  describe '.create_missing_indexes!' do
+    before do
+      [CountriesIndex, Chewy::Stash::Specification].map(&:create!)
+
+      # To avoid flaky issues when previous specs were run
+      expect(Chewy::Index).to receive(:descendants).and_return(
+        [
+          UsersIndex,
+          CountriesIndex,
+          CitiesIndex,
+          Chewy::Stash::Specification,
+          Chewy::Stash::Journal
+        ]
+      )
+    end
+
+    specify do
+      output = StringIO.new
+      described_class.create_missing_indexes!(output: output)
+      expect(CitiesIndex.exists?).to be_truthy
+      expect(UsersIndex.exists?).to be_truthy
+      expect(Chewy::Stash::Journal.exists?).to be_falsey
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+UsersIndex index successfully created
+CitiesIndex index successfully created
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    context 'when verbose' do
+      specify do
+        output = StringIO.new
+        described_class.create_missing_indexes!(output: output, env: {'VERBOSE' => '1'})
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+UsersIndex index successfully created
+CountriesIndex already exists, skipping
+CitiesIndex index successfully created
+Chewy::Stash::Specification already exists, skipping
+Total: \\d+s\\Z
+        OUTPUT
+      end
+    end
+
+    context 'when journaling is enabled' do
+      before { Chewy.config.settings[:journal] = true }
+      after { Chewy.config.settings.delete(:journal) }
+      specify do
+        described_class.create_missing_indexes!(output: StringIO.new)
+        expect(Chewy::Stash::Journal.exists?).to be_truthy
+      end
+    end
+  end
+
+  describe '.journal_create' do
+    specify do
+      output = StringIO.new
+      described_class.journal_create(output: output)
+      expect(Chewy::Stash::Journal.exists?).to be_truthy
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+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
+
+  describe '.delete_by_query_options_from_env' do
+    subject(:options) { described_class.delete_by_query_options_from_env(env) }
+    let(:env) do
+      {
+        'WAIT_FOR_COMPLETION' => 'false',
+        'REQUESTS_PER_SECOND' => '10',
+        'SCROLL_SIZE' => '5000'
+      }
+    end
+
+    it 'parses the options' do
+      expect(options).to eq(
+        wait_for_completion: false,
+        requests_per_second: 10.0,
+        scroll_size: 5000
+      )
+    end
+
+    context 'with different boolean values' do
+      it 'parses the option correctly' do
+        %w[1 t true TRUE on ON].each do |v|
+          expect(described_class.delete_by_query_options_from_env({'WAIT_FOR_COMPLETION' => v}))
+            .to eq(wait_for_completion: true)
+        end
+
+        %w[0 f false FALSE off OFF].each do |v|
+          expect(described_class.delete_by_query_options_from_env({'WAIT_FOR_COMPLETION' => v}))
+            .to eq(wait_for_completion: false)
+        end
+      end
+    end
+
+    context 'with other env' do
+      let(:env) { {'SOME_ENV' => '123', 'REQUESTS_PER_SECOND' => '15'} }
+
+      it 'parses only the options' do
+        expect(options).to eq(requests_per_second: 15.0)
+      end
+    end
+  end
+
+  describe '.subscribed_task_stats' do
+    specify do
+      block_output = described_class.subscribed_task_stats(StringIO.new) { 'expected output' }
+      expect(block_output).to eq('expected output')
+    end
   end
 end

data/spec/chewy/rspec/build_query_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe :build_query do
+  before do
+    stub_model(:city)
+    stub_index(:cities) { index_scope City }
+    CitiesIndex.create
+  end
+
+  let(:expected_query) do
+    {
+      index: ['cities'],
+      body: {
+        query: {
+          match: {name: 'name'}
+        }
+      }
+    }
+  end
+  let(:dummy_query) { {match: {name: 'name'}} }
+  let(:unexpected_query) { {match: {name: 'name'}} }
+
+  context 'build expected query' do
+    specify do
+      expect(CitiesIndex.query(dummy_query)).to build_query(expected_query)
+    end
+  end
+
+  context 'not to build unexpected query' do
+    specify do
+      expect(CitiesIndex.query(dummy_query)).not_to build_query(unexpected_query)
+    end
+  end
+end

data/spec/chewy/rspec/helpers_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe :rspec_helper do
+  include Chewy::Rspec::Helpers
+
+  before do
+    stub_model(:city)
+    stub_index(:cities) { index_scope City }
+    CitiesIndex.create
+  end
+
+  let(:hits) do
+    [
+      {
+        '_index' => 'cities',
+        '_type' => '_doc',
+        '_id' => '1',
+        '_score' => 3.14,
+        '_source' => source
+      }
+    ]
+  end
+
+  let(:source) { {'name' => 'some_name'} }
+  let(:sources) { [source] }
+
+  context :mock_elasticsearch_response do
+    let(:raw_response) do
+      {
+        'took' => 4,
+        'timed_out' => false,
+        '_shards' => {
+          'total' => 1,
+          'successful' => 1,
+          'skipped' => 0,
+          'failed' => 0
+        },
+        'hits' => {
+          'total' => {
+            'value' => 1,
+            'relation' => 'eq'
+          },
+          'max_score' => 1.0,
+          'hits' => hits
+        }
+      }
+    end
+
+    specify do
+      mock_elasticsearch_response(CitiesIndex, raw_response)
+      expect(CitiesIndex.query({}).hits).to eq(hits)
+    end
+  end
+
+  context :mock_elasticsearch_response_sources do
+    specify do
+      mock_elasticsearch_response_sources(CitiesIndex, sources)
+      expect(CitiesIndex.query({}).hits).to eq(hits)
+    end
+  end
+end