chewy 0.9.0 → 0.10.0

data/spec/chewy/search/response_spec.rb

@@ -0,0 +1,192 @@
+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 { expect(subject.took).to be > 100 }
+    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 { expect(subject.timed_out?).to eq(true) }
+    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,16 +55,16 @@ 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
 
           field :name, index: 'not_analyzed'

data/spec/chewy/stash_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Chewy::Stash::Journal, :orm do
+  def fetch_deleted_number(response)
+    response['deleted'] || response['_indices']['_all']['deleted']
+  end
+
+  before { Chewy.massacre }
+
+  before do
+    stub_model(:city)
+    stub_index(:places) do
+      define_type City
+      define_type :country
+    end
+    stub_index(:users) { define_type :user }
+    stub_index(:borogoves)
+  end
+
+  before { Timecop.freeze }
+  after { Timecop.return }
+
+  before do
+    PlacesIndex::City.import!(City.new(id: 1, name: 'City'), journal: true)
+    Timecop.travel(Time.now + 1.minute) do
+      PlacesIndex::Country.import!([id: 2, name: 'Country'], journal: true)
+    end
+    Timecop.travel(Time.now + 2.minutes) do
+      UsersIndex::User.import!([id: 3, name: 'User'], journal: true)
+    end
+  end
+
+  describe '.entries' do
+    specify do
+      expect(described_class.entries(Time.now - 30.seconds).map(&:references))
+        .to contain_exactly([1], [{'id' => 2, 'name' => 'Country'}], [{'id' => 3, 'name' => 'User'}])
+    end
+    specify do
+      expect(described_class.entries(Time.now + 30.seconds).map(&:references))
+        .to contain_exactly([{'id' => 2, 'name' => 'Country'}], [{'id' => 3, 'name' => 'User'}])
+    end
+    specify do
+      expect(described_class.entries(Time.now + 90.seconds).map(&:references))
+        .to contain_exactly([{'id' => 3, 'name' => 'User'}])
+    end
+
+    specify do
+      expect(described_class.entries(Time.now - 30.seconds, only: UsersIndex).map(&:references))
+        .to contain_exactly([{'id' => 3, 'name' => 'User'}])
+    end
+    specify do
+      expect(described_class.entries(Time.now - 30.seconds, only: [PlacesIndex::City, UsersIndex]).map(&:references))
+        .to contain_exactly([1], [{'id' => 3, 'name' => 'User'}])
+    end
+    specify do
+      expect(described_class.entries(Time.now + 30.seconds, only: [PlacesIndex::City, UsersIndex]).map(&:references))
+        .to contain_exactly([{'id' => 3, 'name' => 'User'}])
+    end
+    specify do
+      expect(described_class.entries(Time.now + 30.seconds, only: [BorogovesIndex])).to eq([])
+    end
+  end
+
+  describe '.clean' do
+    specify { expect(fetch_deleted_number(described_class.clean)).to eq(3) }
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now - 30.seconds))).to eq(0) }
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds))).to eq(1) }
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 90.seconds))).to eq(2) }
+    specify { expect(fetch_deleted_number(described_class.clean(only: BorogovesIndex))).to eq(0) }
+    specify { expect(fetch_deleted_number(described_class.clean(only: UsersIndex))).to eq(1) }
+    specify { expect(fetch_deleted_number(described_class.clean(only: [PlacesIndex::City, UsersIndex]))).to eq(2) }
+
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: PlacesIndex::Country))).to eq(0) }
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: PlacesIndex::City))).to eq(1) }
+  end
+
+  describe '.for' do
+    specify { expect(described_class.for(UsersIndex).map(&:index_name)).to eq(['users']) }
+    specify { expect(described_class.for(PlacesIndex).map(&:type_name)).to contain_exactly('city', 'country') }
+    specify { expect(described_class.for(PlacesIndex::City, UsersIndex).map(&:index_name)).to contain_exactly('places', 'users') }
+  end
+
+  describe '#type' do
+    let(:index_name) { 'users' }
+    let(:type_name) { 'city' }
+    subject { described_class.new('index_name' => index_name, 'type_name' => type_name).type }
+
+    specify { expect { subject }.to raise_error(Chewy::UnderivableType) }
+
+    context do
+      let(:index_name) { 'places' }
+      it { is_expected.to eq(PlacesIndex::City) }
+    end
+  end
+end