chewy 0.8.4 → 7.3.4

data/spec/chewy/minitest/helpers_spec.rb

@@ -0,0 +1,198 @@
+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
+    Chewy.massacre
+  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
+
+      let(:unexpected_query_error_message) do
+        'got {:index=>["dummies"], :body=>{:query=>{:bool=>{:filter=>{:bool=>{:must=>{:match=>{:foo=>"bar"}}, :should=>{:multi_match=>{:foo=>"bar"}}}}}}}} instead of expected query.'
+      end
+
+      specify do
+        expect { assert_elasticsearch_query(query, unexpected_query) }
+          .to raise_error(RuntimeError, unexpected_query_error_message)
+      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

data/spec/chewy/minitest/search_index_receiver_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'chewy/minitest'
+
+describe :search_index_receiver do
+  def search_request(item_count = 2, verb: :index)
+    items = Array.new(item_count) do |i|
+      {
+        verb => {_id: i + 1, data: {}}
+      }
+    end
+
+    [
+      {
+        body: items
+      }
+    ]
+  end
+
+  def parse_request(request)
+    request.map { |r| r[:_id] }
+  end
+
+  let(:receiver) do
+    SearchIndexReceiver.new
+  end
+
+  before do
+    stub_index(:dummies) do
+      root value: ->(_o) { {} }
+    end
+
+    stub_index(:dummies2) do
+      root value: ->(_o) { {} }
+    end
+  end
+
+  context 'catch' do
+    specify 'archives more than one type' do
+      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
+      receiver.catch search_request(3), Dummies2Index
+    end
+
+    specify 'returns indexes for a specific type' do
+      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, 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
+      receiver.catch search_request(3, verb: :delete), Dummies2Index
+    end
+
+    specify 'returns deletes for a specific type' do
+      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, 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
+    end
+
+    specify 'validates that an object was indexed' do
+      dummy = OpenStruct.new(id: 1)
+      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)).to be(false)
+    end
+  end
+
+  context 'deleted?' do
+    before do
+      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)).to be(true)
+    end
+
+    specify 'doesn\'t validate than undeleted objects were deleted' do
+      dummy = OpenStruct.new(id: 2)
+      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
+      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

@@ -0,0 +1,84 @@
+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
+
+      index_scope City
+      field :name, type: 'keyword'
+      field :country_id, type: 'keyword'
+    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)
+      end
+    end
+  end
+end