chewy 8.0.0 → 8.1.0

data/spec/chewy/index_spec.rb

@@ -1,269 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Index do
-  before do
-    stub_index(:dummies)
-  end
-
-  describe '.import', :orm do
-    before do
-      stub_model(:city)
-      stub_model(:country)
-
-      stub_index(:cities) do
-        index_scope City
-      end
-
-      stub_index(:countries) do
-        index_scope Country
-      end
-    end
-
-    let!(:cities) { Array.new(2) { |i| City.create! id: i + 1 } }
-    let!(:countries) { Array.new(2) { |i| Country.create! id: i + 1 } }
-
-    specify do
-      expect { CitiesIndex.import }.to update_index(CitiesIndex).and_reindex(cities)
-      expect { CountriesIndex.import }.to update_index(CountriesIndex).and_reindex(countries)
-    end
-
-    specify do
-      expect { CitiesIndex.import cities.first }.to update_index(CitiesIndex).and_reindex(cities.first).only
-      expect { CountriesIndex.import countries.last }.to update_index(CountriesIndex).and_reindex(countries.last).only
-    end
-
-    specify do
-      expect(CitiesIndex.client).to receive(:bulk).with(hash_including(refresh: false)).once
-      CitiesIndex.import cities.first, refresh: false
-    end
-  end
-
-  describe '.client' do
-    specify { expect(stub_index(:dummies1).client).to eq(stub_index(:dummies2).client) }
-
-    context do
-      before do
-        stub_index(:dummies1)
-        stub_index(:dummies2, Dummies1Index)
-      end
-
-      specify { expect(Dummies1Index.client).to eq(Dummies2Index.client) }
-    end
-  end
-
-  describe '.index_name' do
-    specify { expect { Class.new(Chewy::Index).index_name }.to raise_error Chewy::UndefinedIndex }
-    specify { expect(Class.new(Chewy::Index) { index_name :myindex }.index_name).to eq('myindex') }
-    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 do
-      expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '')).to eq('developers')
-    end
-    specify do
-      expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '2013')).to eq('developers_2013')
-    end
-    specify do
-      expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: '')).to eq('developers')
-    end
-    specify do
-      expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: 'test')).to eq('test_developers')
-    end
-
-    context do
-      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 '.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 '.index_scope' do
-    specify { expect(DummiesIndex.adapter.name).to eq('Default') }
-
-    context do
-      before { stub_index(:dummies) { index_scope :dummy, name: :borogoves } }
-      specify { expect(DummiesIndex.adapter.name).to eq('Borogoves') }
-    end
-
-    context do
-      before { stub_class(:city) }
-      before { stub_index(:dummies) { index_scope City, name: :country } }
-      specify { expect(DummiesIndex.adapter.name).to eq('Country') }
-    end
-
-    context do
-      before { stub_class('City') }
-      before { stub_class('Country') }
-
-      specify do
-        expect do
-          Kernel.eval <<-DUMMY_CITY_INDEX
-            class DummyCityIndex2 < Chewy::Index
-              index_scope City
-              index_scope Country
-            end
-          DUMMY_CITY_INDEX
-        end.to raise_error(/Index scope is already defined/)
-
-        expect do
-          Kernel.eval <<-DUMMY_CITY_INDEX
-            class DummyCityIndex2 < Chewy::Index
-              index_scope City::Nothing
-            end
-          DUMMY_CITY_INDEX
-        end.to raise_error(NameError)
-      end
-    end
-  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 :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) do
-      stub_index(:documents) do
-        settings analysis: {analyzer: [:name, :phone, {sorted: {option: :baz}}]}
-      end
-    end
-
-    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}}
-      }})
-    end
-  end
-
-  describe '.scopes' do
-    before do
-      stub_index(:places) do
-        def self.by_rating; end
-
-        def self.colors(*colors)
-          filter(terms: {colors: colors.flatten(1).map(&:to_s)})
-        end
-
-        def self.by_id; end
-        field :colors
-      end
-    end
-
-    specify { expect(described_class.scopes).to eq([]) }
-    specify { expect(PlacesIndex.scopes).to match_array(%i[by_rating colors by_id]) }
-
-    context do
-      before do
-        drop_indices
-        PlacesIndex.import!(
-          double(colors: ['red']),
-          double(colors: %w[red green]),
-          double(colors: %w[green yellow])
-        )
-      end
-
-      specify do
-        expect(PlacesIndex.colors(:green).map(&:colors))
-          .to contain_exactly(%w[red green], %w[green yellow])
-      end
-
-      specify do
-        expect(PlacesIndex.colors(:green).map(&:colors))
-          .to contain_exactly(%w[red green], %w[green yellow])
-      end
-    end
-  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 do
-      expect(stub_index(:documents) do
-               settings number_of_shards: 1
-             end.settings_hash).to eq(settings: {number_of_shards: 1})
-    end
-  end
-
-  describe '.mappings_hash' do
-    specify { expect(stub_index(:documents).mappings_hash).to eq({}) }
-    specify { expect(stub_index(:documents) { index_scope :document }.mappings_hash).to eq({}) }
-    specify do
-      expect(stub_index(:documents) do
-               field :date, type: 'date'
-             end.mappings_hash).to eq(mappings: {properties: {date: {type: 'date'}}})
-    end
-  end
-
-  describe '.specification_hash' do
-    before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
-
-    specify { expect(stub_index(:documents).specification_hash).to eq({}) }
-    specify do
-      expect(stub_index(:documents) do
-               settings number_of_shards: 1
-             end.specification_hash.keys).to eq([:settings])
-    end
-    specify do
-      expect(stub_index(:documents) do
-               field :name
-             end.specification_hash.keys).to eq([:mappings])
-    end
-    specify do
-      expect(stub_index(:documents) do
-               settings number_of_shards: 1
-               field :name
-             end.specification_hash.keys).to match_array(%i[mappings settings])
-    end
-  end
-
-  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 'index call inside index', :orm do
-    before do
-      stub_index(:cities) do
-        field :country_name, value: (lambda do |city|
-          CountriesIndex.filter(term: {_id: city.country_id}).first.name
-        end)
-      end
-
-      stub_index(:countries) do
-        field :name
-      end
-
-      CountriesIndex.import!(double(id: 1, name: 'Country'))
-    end
-
-    specify do
-      expect { CitiesIndex.import!(double(country_id: 1)) }
-        .to update_index(CitiesIndex).and_reindex(country_name: 'Country')
-    end
-  end
-end

data/spec/chewy/journal_spec.rb

@@ -1,223 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Journal do
-  context 'journaling', :orm do
-    ['', 'namespace/'].each do |namespace|
-      context namespace.present? ? 'with namespace' : 'without namespace' do
-        before do
-          stub_model(:city) do
-            update_index "#{namespace}cities", :self
-          end
-          stub_model(:country) do
-            update_index "#{namespace}countries", :self
-          end
-
-          stub_index("#{namespace}cities") do
-            index_scope City
-            default_import_options journal: true
-          end
-          stub_index("#{namespace}countries") do
-            index_scope Country
-            default_import_options journal: true
-          end
-
-          drop_indices
-          Chewy.settings[:prefix] = 'some_prefix'
-          Timecop.freeze(time)
-        end
-
-        after do
-          Chewy.settings[:prefix] = nil
-          Timecop.return
-        end
-
-        let(:time) { Time.now }
-        let(:import_time) { time + 1 }
-        let(:update_time) { time + 2 }
-        let(:destroy_time) { time + 3 }
-
-        def timestamp(time)
-          time.to_i
-        end
-
-        specify do
-          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) }
-            Country.create!(id: 3)
-
-            Timecop.freeze(import_time)
-
-            cities_index.import
-            countries_index.import
-
-            expect(Chewy::Stash::Journal.exists?).to eq true
-
-            Timecop.freeze(update_time)
-            cities.first.update!(name: 'Supername')
-
-            Timecop.freeze(destroy_time)
-            countries.last.destroy
-
-            journal_entries = Chewy::Stash::Journal.order(:created_at).hits.map { |r| r['_source'] }
-            expected_journal = [
-              {
-                'index_name' => "#{namespace}cities",
-                'action' => 'index',
-                'references' => ['1'].map(&Base64.method(:encode64)),
-                'created_at' => time.utc.as_json
-              },
-              {
-                'index_name' => "#{namespace}cities",
-                'action' => 'index',
-                'references' => ['2'].map(&Base64.method(:encode64)),
-                'created_at' => time.utc.as_json
-              },
-              {
-                'index_name' => "#{namespace}countries",
-                'action' => 'index',
-                'references' => ['1'].map(&Base64.method(:encode64)),
-                'created_at' => time.utc.as_json
-              },
-              {
-                'index_name' => "#{namespace}countries",
-                'action' => 'index',
-                'references' => ['2'].map(&Base64.method(:encode64)),
-                'created_at' => time.utc.as_json
-              },
-              {
-                'index_name' => "#{namespace}countries",
-                'action' => 'index',
-                'references' => ['3'].map(&Base64.method(:encode64)),
-                'created_at' => time.utc.as_json
-              },
-              {
-                'index_name' => "#{namespace}cities",
-                'action' => 'index',
-                'references' => %w[1 2].map(&Base64.method(:encode64)),
-                'created_at' => import_time.utc.as_json
-              },
-              {
-                'index_name' => "#{namespace}countries",
-                'action' => 'index',
-                'references' => %w[1 2 3].map(&Base64.method(:encode64)),
-                'created_at' => import_time.utc.as_json
-              },
-              {
-                'index_name' => "#{namespace}cities",
-                'action' => 'index',
-                'references' => ['1'].map(&Base64.method(:encode64)),
-                'created_at' => update_time.utc.as_json
-              },
-              {
-                'index_name' => "#{namespace}countries",
-                'action' => 'delete',
-                'references' => ['2'].map(&Base64.method(:encode64)),
-                'created_at' => destroy_time.utc.as_json
-              }
-            ]
-
-            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]}_cities", id: 1, refresh: true)
-            expect(cities_index.count).to eq 1
-
-            described_class.new.apply(time)
-            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
-            Chewy.client.indices.refresh
-            expect(Chewy::Stash::Journal.count).to eq 2
-
-            Timecop.return
-          end
-        end
-      end
-    end
-  end
-
-  context do
-    before { drop_indices }
-    before do
-      stub_model(:city) do
-        update_index 'cities', :self
-      end
-      stub_model(:country) do
-        update_index 'countries', :self
-      end
-
-      stub_index(:cities) do
-        index_scope City
-        default_import_options journal: true
-      end
-      stub_index(:countries) do
-        index_scope Country
-        default_import_options journal: true
-      end
-    end
-
-    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) }
-
-            # simulate lost data
-            Chewy.client.delete(index: 'cities', id: 1, refresh: true)
-            Chewy.client.delete(index: 'countries', 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', 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 'when order is not preserved' do
-        let(:time) { Time.now }
-
-        it 'paginates properly through all items' do
-          Chewy.strategy(:urgent) do
-            Timecop.travel(time + 1.minute) { City.create!(id: 2) }
-            Timecop.travel(time + 3.minute) { City.create!(id: 4) }
-            Timecop.travel(time + 2.minute) { City.create!(id: 1) }
-            Timecop.travel(time + 4.minute) { City.create!(id: 3) }
-          end
-
-          CitiesIndex.purge!
-          expect(CitiesIndex.all.to_a.length).to eq 0
-
-          # Replay on specific index
-          expect(described_class.new(CitiesIndex).apply(time, fetch_limit: 2)).to eq(4)
-          expect(CitiesIndex.all.to_a.map(&:id).sort).to eq([1, 2, 3, 4])
-        end
-      end
-    end
-  end
-end

data/spec/chewy/minitest/helpers_spec.rb

@@ -1,194 +0,0 @@
-require 'spec_helper'
-require 'chewy/minitest'
-
-describe :minitest_helper do
-  class << self
-    alias_method :teardown, :after
-  end
-
-  def assert_includes(haystack, needle, _comment)
-    expect(haystack).to include(needle)
-  end
-
-  include Chewy::Minitest::Helpers
-
-  def assert_equal(expected, actual, message)
-    raise message unless expected == actual
-  end
-
-  before do
-    drop_indices
-  end
-
-  before do
-    stub_index(:dummies) do
-      root value: ->(_o) { {} }
-    end
-  end
-
-  describe 'mock_elasticsearch_response' do
-    let(:hits) do
-      [
-        {
-          '_index' => 'dummies',
-          '_type' => '_doc',
-          '_id' => '2',
-          '_score' => 3.14,
-          '_source' => source
-        }
-      ]
-    end
-
-    let(:source) { {'name' => 'some_name', id: '2'} }
-    let(:sources) { [source] }
-
-    context 'mocks by raw 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(DummiesIndex, raw_response) do
-          expect(DummiesIndex.query({}).hits).to eq(hits)
-        end
-      end
-    end
-
-    context 'mocks by response sources' do
-      specify do
-        mock_elasticsearch_response_sources(DummiesIndex, sources) do
-          expect(DummiesIndex.query({}).hits).to eq(hits)
-        end
-      end
-    end
-  end
-
-  describe 'assert correct elasticsearch query' do
-    let(:query) do
-      DummiesIndex.filter.should { multi_match foo: 'bar' }.filter { match foo: 'bar' }
-    end
-
-    let(:expected_query) do
-      {
-        index: ['dummies'],
-        body: {
-          query: {
-            bool: {
-              filter: {
-                bool: {
-                  must: {
-                    match: {foo: 'bar'}
-                  },
-                  should: {
-                    multi_match: {foo: 'bar'}
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    end
-
-    context 'will be built' do
-      specify do
-        expect { assert_elasticsearch_query(query, expected_query) }.not_to raise_error
-      end
-    end
-
-    context 'will not be built' do
-      let(:unexpected_query) do
-        {
-          index: ['what?'],
-          body: {}
-        }
-      end
-
-      specify do
-        expect { assert_elasticsearch_query(query, unexpected_query) }
-          .to raise_error(RuntimeError, /instead of expected query\./)
-      end
-    end
-  end
-
-  context 'assert_indexes' do
-    specify 'doesn\'t fail when index updates correctly' do
-      expect do
-        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 do
-        end
-      end.to raise_error(RSpec::Expectations::ExpectationNotMetError)
-    end
-
-    specify 'SearchIndexReceiver catches the indexes' do
-      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)
-                .map { |index| index[:_id] }
-      ).to match_array([41, 42])
-    end
-
-    specify 'Real index is bypassed when asserting' do
-      expect(DummiesIndex).not_to receive(:bulk)
-
-      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).to receive(:bulk)
-
-      assert_indexes DummiesIndex, bypass_actual_index: false do
-        DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
-      end
-    end
-  end
-
-  context 'run_indexing' do
-    specify 'pushes onto the chewy strategy stack' do
-      Chewy.strategy :bypass do
-        run_indexing do
-          expect(Chewy.strategy.current.name).to be(:atomic)
-        end
-      end
-    end
-
-    specify 'allows tester to specify the strategy' do
-      Chewy.strategy :atomic do
-        run_indexing strategy: :bypass do
-          expect(Chewy.strategy.current.name).to be(:bypass)
-        end
-      end
-    end
-  end
-end