chewy 0.10.1 → 7.3.2

data/spec/chewy/minitest/helpers_spec.rb

@@ -12,14 +12,122 @@ describe :minitest_helper do
 
   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
-      define_type :dummy do
-        root value: ->(_o) { {} }
+      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
@@ -27,45 +135,45 @@ describe :minitest_helper do
   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,95 +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
 
-      define_type :buzz 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::Fizz
-      receiver.catch search_request(3), DummiesIndex::Buzz
-      expect(receiver.indexes.keys).to match_array([DummiesIndex::Fizz, DummiesIndex::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), DummiesIndex::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, DummiesIndex::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), DummiesIndex::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(DummiesIndex::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, DummiesIndex::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), DummiesIndex::Buzz
-      expect(receiver.updated_indexes).to match_array([DummiesIndex::Fizz, DummiesIndex::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

@@ -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