chewy 0.9.0 → 5.2.0

data/spec/chewy/search/response_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+describe Chewy::Search::Response, :orm do
+  before { Chewy.massacre }
+
+  before do
+    stub_model(:city)
+    stub_model(:country)
+
+    stub_index(:places) do
+      define_type City do
+        field :name
+        field :rating, type: 'integer'
+      end
+
+      define_type Country do
+        field :name
+        field :rating, type: 'integer'
+      end
+    end
+  end
+
+  before { PlacesIndex.import!(cities: cities, countries: countries) }
+
+  let(:cities) { Array.new(2) { |i| City.create!(rating: i, name: "city #{i}") } }
+  let(:countries) { Array.new(2) { |i| Country.create!(rating: i + 2, name: "country #{i}") } }
+
+  let(:request) { Chewy::Search::Request.new(PlacesIndex).order(:rating) }
+  let(:raw_response) { request.send(:perform) }
+  let(:load_options) { {} }
+  let(:loader) { Chewy::Search::Loader.new(indexes: [PlacesIndex], **load_options) }
+  subject { described_class.new(raw_response, loader) }
+
+  describe '#hits' do
+    specify { expect(subject.hits).to be_a(Array) }
+    specify { expect(subject.hits).to have(4).items }
+    specify { expect(subject.hits).to all be_a(Hash) }
+    specify do
+      expect(subject.hits.flat_map(&:keys).uniq)
+        .to match_array(%w[_id _index _type _score _source sort])
+    end
+
+    context do
+      let(:raw_response) { {} }
+      specify { expect(subject.hits).to eq([]) }
+    end
+  end
+
+  describe '#total' do
+    specify { expect(subject.total).to eq(4) }
+
+    context do
+      let(:raw_response) { {} }
+      specify { expect(subject.total).to eq(0) }
+    end
+  end
+
+  describe '#max_score' do
+    specify { expect(subject.max_score).to be_nil }
+
+    context do
+      let(:request) { Chewy::Search::Request.new(PlacesIndex).query(range: {rating: {lte: 42}}) }
+      specify { expect(subject.max_score).to eq(1.0) }
+    end
+  end
+
+  describe '#took' do
+    specify { expect(subject.took).to be >= 0 }
+
+    context do
+      let(:request) do
+        Chewy::Search::Request.new(PlacesIndex)
+          .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}})
+      end
+      specify do
+        pending
+        expect(subject.took).to be > 100
+      end
+    end
+  end
+
+  describe '#timed_out?' do
+    specify { expect(subject.timed_out?).to eq(false) }
+
+    context do
+      let(:request) do
+        Chewy::Search::Request.new(PlacesIndex)
+          .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}}).timeout('10ms')
+      end
+      specify do
+        pending
+        expect(subject.timed_out?).to eq(true)
+      end
+    end
+  end
+
+  describe '#suggest' do
+    specify { expect(subject.suggest).to eq({}) }
+
+    context do
+      let(:request) do
+        Chewy::Search::Request.new(PlacesIndex).suggest(
+          my_suggestion: {
+            text: 'city country',
+            term: {
+              field: 'name'
+            }
+          }
+        )
+      end
+      specify do
+        expect(subject.suggest).to eq(
+          'my_suggestion' => [
+            {'text' => 'city', 'offset' => 0, 'length' => 4, 'options' => []},
+            {'text' => 'country', 'offset' => 5, 'length' => 7, 'options' => []}
+          ]
+        )
+      end
+    end
+  end
+
+  describe '#aggs' do
+    specify { expect(subject.aggs).to eq({}) }
+
+    context do
+      let(:request) { Chewy::Search::Request.new(PlacesIndex).aggs(avg_rating: {avg: {field: :rating}}) }
+      specify { expect(subject.aggs).to eq('avg_rating' => {'value' => 1.5}) }
+    end
+  end
+
+  describe '#wrappers' do
+    specify { expect(subject.wrappers).to be_a(Array) }
+    specify { expect(subject.wrappers).to have(4).items }
+    specify do
+      expect(subject.wrappers.map(&:class).uniq)
+        .to contain_exactly(PlacesIndex::City, PlacesIndex::Country)
+    end
+    specify { expect(subject.wrappers.map(&:_data)).to eq(subject.hits) }
+
+    context do
+      let(:raw_response) { {} }
+      specify { expect(subject.wrappers).to eq([]) }
+    end
+
+    context do
+      let(:raw_response) { {'hits' => {}} }
+      specify { expect(subject.wrappers).to eq([]) }
+    end
+
+    context do
+      let(:raw_response) { {'hits' => {'hits' => []}} }
+      specify { expect(subject.wrappers).to eq([]) }
+    end
+
+    context do
+      let(:raw_response) do
+        {'hits' => {'hits' => [
+          {'_index' => 'places',
+           '_type' => 'city',
+           '_id' => '1',
+           '_score' => 1.3,
+           '_source' => {'id' => 2, 'rating' => 0}}
+        ]}}
+      end
+      specify { expect(subject.wrappers.first).to be_a(PlacesIndex::City) }
+      specify { expect(subject.wrappers.first.id).to eq(2) }
+      specify { expect(subject.wrappers.first.rating).to eq(0) }
+      specify { expect(subject.wrappers.first._score).to eq(1.3) }
+      specify { expect(subject.wrappers.first._explanation).to be_nil }
+    end
+
+    context do
+      let(:raw_response) do
+        {'hits' => {'hits' => [
+          {'_index' => 'places',
+           '_type' => 'country',
+           '_id' => '2',
+           '_score' => 1.2,
+           '_explanation' => {foo: 'bar'}}
+        ]}}
+      end
+      specify { expect(subject.wrappers.first).to be_a(PlacesIndex::Country) }
+      specify { expect(subject.wrappers.first.id).to eq('2') }
+      specify { expect(subject.wrappers.first.rating).to be_nil }
+      specify { expect(subject.wrappers.first._score).to eq(1.2) }
+      specify { expect(subject.wrappers.first._explanation).to eq(foo: 'bar') }
+    end
+  end
+
+  describe '#objects' do
+    specify { expect(subject.objects).to eq([*cities, *countries]) }
+  end
+
+  describe '#object_hash' do
+    specify { expect(subject.object_hash.keys).to eq(subject.wrappers) }
+    specify { expect(subject.object_hash.values).to eq(subject.objects) }
+  end
+end

data/spec/chewy/search/scrolling_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Chewy::Search::Scrolling, :orm do
+  before { Chewy.massacre }
+
+  before do
+    stub_model(:city)
+    stub_model(:country)
+
+    stub_index(:places) do
+      define_type City do
+        field :name
+        field :rating, type: 'integer'
+      end
+
+      define_type Country do
+        field :name
+        field :rating, type: 'integer'
+      end
+    end
+  end
+
+  let(:request) { Chewy::Search::Request.new(PlacesIndex).order(:rating) }
+
+  specify { expect(request.scroll_batches.to_a).to eq([]) }
+
+  context do
+    before { PlacesIndex.import!(cities: cities, countries: countries) }
+
+    let(:cities) { Array.new(2) { |i| City.create!(rating: i, name: "city #{i}") } }
+    let(:countries) { Array.new(3) { |i| Country.create!(rating: i + 2, name: "country #{i}") } }
+
+    describe '#scroll_batches' do
+      context do
+        before { expect(Chewy.client).to receive(:scroll).twice.and_call_original }
+        specify do
+          expect(request.scroll_batches(batch_size: 2).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1], [2, 3], [4]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).to receive(:scroll).once.and_call_original }
+        specify do
+          expect(request.scroll_batches(batch_size: 3).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1, 2], [3, 4]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).to receive(:scroll).once.and_call_original }
+        it 'respects limit' do
+          expect(request.limit(4).scroll_batches(batch_size: 3).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1, 2], [3]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).not_to receive(:scroll) }
+        it 'respects limit and terminate_after' do
+          expect(request.terminate_after(2).limit(4).scroll_batches(batch_size: 3).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).not_to receive(:scroll) }
+        it 'respects limit' do
+          expect(request.limit(3).scroll_batches(batch_size: 3).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1, 2]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).not_to receive(:scroll) }
+        it 'respects limit' do
+          expect(request.limit(2).scroll_batches(batch_size: 3).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).not_to receive(:scroll) }
+        specify do
+          expect(request.scroll_batches(batch_size: 5).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1, 2, 3, 4]])
+        end
+      end
+
+      context do
+        before { expect(Chewy.client).not_to receive(:scroll) }
+        specify do
+          expect(request.scroll_batches(batch_size: 10).map do |batch|
+            batch.map { |hit| hit['_source']['rating'] }
+          end).to eq([[0, 1, 2, 3, 4]])
+        end
+      end
+
+      context 'instrumentation' do
+        specify do
+          outer_payload = []
+          ActiveSupport::Notifications.subscribe('search_query.chewy') do |_name, _start, _finish, _id, payload|
+            outer_payload << payload
+          end
+          request.scroll_batches(batch_size: 3).to_a
+
+          expect(outer_payload).to match_array([
+            hash_including(
+              index: PlacesIndex,
+              indexes: [PlacesIndex],
+              request: {index: ['places'], type: %w[city country], body: {sort: ['rating']}, size: 3, scroll: '1m'},
+              type: [PlacesIndex::City, PlacesIndex::Country],
+              types: [PlacesIndex::City, PlacesIndex::Country]
+            ),
+            hash_including(
+              index: PlacesIndex,
+              indexes: [PlacesIndex],
+              request: {scroll: '1m', scroll_id: an_instance_of(String)},
+              type: [PlacesIndex::City, PlacesIndex::Country],
+              types: [PlacesIndex::City, PlacesIndex::Country]
+            )
+          ])
+        end
+      end
+    end
+
+    describe '#scroll_hits' do
+      before { expect(Chewy.client).to receive(:scroll).twice.and_call_original }
+      specify do
+        expect(request.scroll_hits(batch_size: 2).map do |hit|
+          hit['_source']['rating']
+        end).to eq([0, 1, 2, 3, 4])
+      end
+    end
+
+    describe '#scroll_wrappers' do
+      before { expect(Chewy.client).to receive(:scroll).twice.and_call_original }
+
+      specify do
+        expect(request.scroll_wrappers(batch_size: 2).map(&:rating))
+          .to eq([0, 1, 2, 3, 4])
+      end
+      specify do
+        expect(request.scroll_wrappers(batch_size: 2).map(&:class).uniq)
+          .to eq([PlacesIndex::City, PlacesIndex::Country])
+      end
+    end
+
+    describe '#scroll_objects' do
+      before { expect(Chewy.client).to receive(:scroll).twice.and_call_original }
+
+      specify do
+        expect(request.scroll_objects(batch_size: 2).map(&:rating))
+          .to eq([0, 1, 2, 3, 4])
+      end
+      specify do
+        expect(request.scroll_objects(batch_size: 2).map(&:class).uniq)
+          .to eq([City, Country])
+      end
+    end
+  end
+end

data/spec/chewy/search_spec.rb

@@ -13,8 +13,15 @@ describe Chewy::Search do
   let(:product) { ProductsIndex::Product }
 
   describe '.all' do
-    specify { expect(ProductsIndex.all).to be_a(Chewy::Query) }
-    specify { expect(product.all).to be_a(Chewy::Query) }
+    specify { expect(ProductsIndex.all).to be_a(Chewy::Search::Request) }
+    specify { expect(product.all).to be_a(Chewy::Search::Request) }
+
+    context do
+      before { allow(Chewy).to receive_messages(search_class: Chewy::Search::Request) }
+
+      specify { expect(ProductsIndex.all).to be_a(Chewy::Search::Request) }
+      specify { expect(product.all).to be_a(Chewy::Search::Request) }
+    end
   end
 
   describe '.search_string' do
@@ -31,7 +38,7 @@ describe Chewy::Search do
     end
 
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: []))
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: %w[product product2]))
       ProductsIndex.search_string('hello')
     end
 
@@ -48,52 +55,62 @@ describe Chewy::Search do
 
       stub_index(:places) do
         def self.by_rating(value)
-          filter { rating == value }
+          filter { match rating: value }
         end
 
         def self.by_name(index)
-          filter { name == "Name#{index}" }
+          filter { match name: "Name#{index}" }
         end
 
         define_type City do
           def self.by_rating
-            filter { rating == yield }
+            filter { match rating: yield }
+          end
+
+          def self.by_index(index)
+            filter { match name: "Name#{index}" }
           end
 
-          field :name, index: 'not_analyzed'
+          field :name, **KEYWORD_FIELD
           field :rating, type: :integer
         end
 
         define_type Country do
-          field :name, index: 'not_analyzed'
+          field :name, **KEYWORD_FIELD
           field :rating, type: :integer
         end
       end
     end
 
-    let!(:cities) { Array.new(3) { |i| City.create! rating: i + 1, name: "Name#{i + 1}" } }
-    let!(:countries) { Array.new(3) { |i| Country.create! rating: i + 1, name: "Name#{i + 4}" } }
+    let!(:cities) { Array.new(3) { |i| City.create! rating: i + 1, name: "Name#{i + 2}" } }
+    let!(:countries) { Array.new(3) { |i| Country.create! rating: i + 1, name: "Name#{i + 3}" } }
 
     before { PlacesIndex.import! city: cities, country: countries }
 
     specify { expect(PlacesIndex.by_rating(1).map(&:rating)).to eq([1, 1]) }
     specify { expect(PlacesIndex.by_rating(1).map(&:class)).to match_array([PlacesIndex::City, PlacesIndex::Country]) }
-    specify { expect(PlacesIndex.by_rating(1).by_name(1).map(&:rating)).to eq([1]) }
-    specify { expect(PlacesIndex.by_rating(1).by_name(1).map(&:class)).to eq([PlacesIndex::City]) }
+    specify { expect(PlacesIndex.by_rating(1).by_name(2).map(&:rating)).to eq([1]) }
+    specify { expect(PlacesIndex.by_rating(1).by_name(2).map(&:class)).to eq([PlacesIndex::City]) }
+    specify { expect(PlacesIndex.by_name(3).map(&:rating)).to eq([2, 1]) }
+    specify { expect(PlacesIndex.by_name(3).map(&:class)).to eq([PlacesIndex::City, PlacesIndex::Country]) }
     specify { expect(PlacesIndex.order(:name).by_rating(1).map(&:rating)).to eq([1, 1]) }
     specify { expect(PlacesIndex.order(:name).by_rating(1).map(&:class)).to match_array([PlacesIndex::City, PlacesIndex::Country]) }
 
     specify { expect(PlacesIndex::City.by_rating { 2 }.map(&:rating)).to eq([2]) }
     specify { expect(PlacesIndex::City.by_rating { 2 }.map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex::City.by_rating { 2 }.by_name(2).map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.by_rating { 2 }.by_name(2).map(&:class)).to eq([PlacesIndex::City]) }
+    specify { expect(PlacesIndex::City.by_rating { 2 }.by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(PlacesIndex::City.by_rating { 2 }.by_name(3).map(&:class)).to eq([PlacesIndex::City]) }
+    specify { expect(PlacesIndex::City.by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(PlacesIndex::City.by_index(3).map(&:rating)).to eq([2]) }
+    specify { expect(PlacesIndex::City.order(:name).by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(PlacesIndex::City.order(:name).by_index(3).map(&:rating)).to eq([2]) }
     specify { expect(PlacesIndex::City.order(:name).by_rating { 2 }.map(&:rating)).to eq([2]) }
     specify { expect(PlacesIndex::City.order(:name).by_rating { 2 }.map(&:class)).to eq([PlacesIndex::City]) }
 
     specify { expect(PlacesIndex::Country.by_rating(3).map(&:rating)).to eq([3]) }
     specify { expect(PlacesIndex::Country.by_rating(3).map(&:class)).to eq([PlacesIndex::Country]) }
-    specify { expect(PlacesIndex::Country.by_rating(3).by_name(6).map(&:rating)).to eq([3]) }
-    specify { expect(PlacesIndex::Country.by_rating(3).by_name(6).map(&:class)).to eq([PlacesIndex::Country]) }
+    specify { expect(PlacesIndex::Country.by_rating(3).by_name(5).map(&:rating)).to eq([3]) }
+    specify { expect(PlacesIndex::Country.by_rating(3).by_name(5).map(&:class)).to eq([PlacesIndex::Country]) }
     specify { expect(PlacesIndex::Country.order(:name).by_rating(3).map(&:rating)).to eq([3]) }
     specify { expect(PlacesIndex::Country.order(:name).by_rating(3).map(&:class)).to eq([PlacesIndex::Country]) }
   end