chewy 5.1.0 → 7.2.7

data/spec/chewy/type/import/bulk_builder_spec.rb

@@ -1,279 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type::Import::BulkBuilder do
-  before { Chewy.massacre }
-
-  subject { described_class.new(type, index: index, delete: delete, fields: fields) }
-  let(:type) { PlacesIndex::City }
-  let(:index) { [] }
-  let(:delete) { [] }
-  let(:fields) { [] }
-
-  describe '#bulk_body' do
-    context 'simple bulk', :orm do
-      before do
-        stub_model(:city)
-        stub_index(:places) do
-          define_type City do
-            field :name, :rating
-          end
-        end
-      end
-      let(:cities) { Array.new(3) { |i| City.create!(id: i + 1, name: "City#{i + 17}", rating: 42) } }
-
-      specify { expect(subject.bulk_body).to eq([]) }
-
-      context do
-        let(:index) { cities }
-        specify do
-          expect(subject.bulk_body).to eq([
-            {index: {_id: 1, data: {'name' => 'City17', 'rating' => 42}}},
-            {index: {_id: 2, data: {'name' => 'City18', 'rating' => 42}}},
-            {index: {_id: 3, data: {'name' => 'City19', 'rating' => 42}}}
-          ])
-        end
-      end
-
-      context do
-        let(:delete) { cities }
-        specify do
-          expect(subject.bulk_body).to eq([
-            {delete: {_id: 1}}, {delete: {_id: 2}}, {delete: {_id: 3}}
-          ])
-        end
-      end
-
-      context do
-        let(:index) { cities.first(2) }
-        let(:delete) { [cities.last] }
-        specify do
-          expect(subject.bulk_body).to eq([
-            {index: {_id: 1, data: {'name' => 'City17', 'rating' => 42}}},
-            {index: {_id: 2, data: {'name' => 'City18', 'rating' => 42}}},
-            {delete: {_id: 3}}
-          ])
-        end
-
-        context ':fields' do
-          let(:fields) { %w[name] }
-          specify do
-            expect(subject.bulk_body).to eq([
-              {update: {_id: 1, data: {doc: {'name' => 'City17'}}}},
-              {update: {_id: 2, data: {doc: {'name' => 'City18'}}}},
-              {delete: {_id: 3}}
-            ])
-          end
-        end
-      end
-    end
-
-    context 'parent-child relationship', :orm do
-      before do
-        stub_model(:country)
-        stub_model(:city)
-        adapter == :sequel ? City.many_to_one(:country) : City.belongs_to(:country)
-      end
-
-      before do
-        stub_index(:places) do
-          define_type Country do
-            field :name
-          end
-
-          define_type City do
-            root parent: 'country', parent_id: -> { country_id } do
-              field :name
-              field :rating
-            end
-          end
-        end
-      end
-
-      before { PlacesIndex::Country.import(country) }
-      let(:country) { Country.create!(id: 1, name: 'country') }
-      let(:another_country) { Country.create!(id: 2, name: 'another country') }
-      let(:city) { City.create!(id: 4, country_id: country.id, name: 'city', rating: 42) }
-
-      context 'indexing' do
-        let(:index) { [city] }
-
-        specify do
-          expect(subject.bulk_body).to eq([
-            {index: {_id: city.id, parent: country.id, data: {'name' => 'city', 'rating' => 42}}}
-          ])
-        end
-
-        context do
-          let(:fields) { %w[name] }
-
-          specify do
-            expect(subject.bulk_body).to eq([
-              {update: {_id: city.id, parent: country.id, data: {doc: {'name' => 'city'}}}}
-            ])
-          end
-        end
-      end
-
-      context 'updating parent' do
-        before do
-          PlacesIndex::City.import(city)
-          city.update_attributes(country_id: another_country.id)
-        end
-        let(:index) { [city] }
-
-        specify do
-          expect(subject.bulk_body).to eq([
-            {delete: {_id: city.id, parent: country.id.to_s}},
-            {index: {_id: city.id, parent: another_country.id, data: {'name' => 'city', 'rating' => 42}}}
-          ])
-        end
-
-        context do
-          let(:fields) { %w[name] }
-
-          specify do
-            expect(subject.bulk_body).to eq([
-              {delete: {_id: city.id, parent: country.id.to_s}},
-              {index: {_id: city.id, parent: another_country.id, data: {'name' => 'city', 'rating' => 42}}}
-            ])
-          end
-        end
-      end
-
-      context 'destroying' do
-        before { PlacesIndex::City.import(city) }
-        let(:delete) { [city] }
-
-        specify do
-          expect(subject.bulk_body).to eq([
-            {delete: {_id: city.id, parent: country.id.to_s}}
-          ])
-        end
-      end
-    end
-
-    context 'custom id', :orm do
-      before do
-        stub_model(:city)
-      end
-
-      before do
-        stub_index(:places) do
-          define_type City do
-            root id: -> { name } do
-              field :rating
-            end
-          end
-        end
-      end
-
-      let(:london) { City.create(id: 1, name: 'London', rating: 4) }
-
-      specify do
-        expect { PlacesIndex::City.import(london) }
-          .to update_index(PlacesIndex::City).and_reindex(london.name)
-      end
-
-      context 'indexing' do
-        let(:index) { [london] }
-
-        specify do
-          expect(subject.bulk_body).to eq([
-            {index: {_id: london.name, data: {'rating' => 4}}}
-          ])
-        end
-      end
-
-      context 'destroying' do
-        let(:delete) { [london] }
-
-        specify do
-          expect(subject.bulk_body).to eq([
-            {delete: {_id: london.name}}
-          ])
-        end
-      end
-    end
-
-    context 'crutches' do
-      before do
-        stub_index(:places) do
-          define_type :city do
-            crutch :names do |collection|
-              collection.map { |item| [item.id, "Name#{item.id}"] }.to_h
-            end
-
-            field :name, value: ->(o, c) { c.names[o.id] }
-          end
-        end
-      end
-
-      let(:index) { [double(id: 42)] }
-
-      specify do
-        expect(subject.bulk_body).to eq([
-          {index: {_id: 42, data: {'name' => 'Name42'}}}
-        ])
-      end
-
-      context 'witchcraft' do
-        before { PlacesIndex::City.witchcraft! }
-        specify do
-          expect(subject.bulk_body).to eq([
-            {index: {_id: 42, data: {'name' => 'Name42'}}}
-          ])
-        end
-      end
-    end
-
-    context 'empty ids' do
-      before do
-        stub_index(:places) do
-          define_type :city do
-            field :name
-          end
-        end
-      end
-
-      let(:index) { [{id: 1, name: 'Name0'}, double(id: '', name: 'Name1'), double(name: 'Name2')] }
-      let(:delete) { [double(id: '', name: 'Name3'), {name: 'Name4'}, '', 2] }
-
-      specify do
-        expect(subject.bulk_body).to eq([
-          {index: {_id: 1, data: {'name' => 'Name0'}}},
-          {index: {data: {'name' => 'Name1'}}},
-          {index: {data: {'name' => 'Name2'}}},
-          {delete: {_id: {'name' => 'Name4'}}},
-          {delete: {_id: 2}}
-        ])
-      end
-
-      context do
-        let(:fields) { %w[name] }
-
-        specify do
-          expect(subject.bulk_body).to eq([
-            {update: {_id: 1, data: {doc: {'name' => 'Name0'}}}},
-            {delete: {_id: {'name' => 'Name4'}}},
-            {delete: {_id: 2}}
-          ])
-        end
-      end
-    end
-  end
-
-  describe '#index_objects_by_id' do
-    before do
-      stub_index(:places) do
-        define_type :city do
-          field :name
-        end
-      end
-    end
-
-    let(:index) { [double(id: 1), double(id: 2), double(id: ''), double] }
-    let(:delete) { [double(id: 3)] }
-
-    specify { expect(subject.index_objects_by_id).to eq('1' => index.first, '2' => index.second) }
-  end
-end

data/spec/chewy/type/mapping_spec.rb

@@ -1,173 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type::Mapping do
-  let(:product) { ProductsIndex::Product }
-  let(:review)  { ProductsIndex::Review }
-
-  before do
-    stub_index(:products) do
-      define_type :product do
-        root do
-          field :name, 'surname'
-          field :title, type: 'text' do
-            field :subfield1
-          end
-          field 'price', type: 'float' do
-            field :subfield2
-          end
-          agg :named_agg do
-            {avg: {field: 'title.subfield1'}}
-          end
-        end
-      end
-      define_type :review do
-        field :title, :body
-        field :comments do
-          field :message
-          field :rating, type: 'long'
-        end
-        agg :named_agg do
-          {avg: {field: 'comments.rating'}}
-        end
-      end
-    end
-  end
-
-  context 'no root element call' do
-    before do
-      stub_index(:products) do
-        define_type :product do
-          field :title, type: 'text' do
-            field :subfield1
-          end
-        end
-      end
-    end
-
-    specify { expect(product.root.children.map(&:name)).to eq([:title]) }
-    specify { expect(product.root.children.map(&:parent)).to eq([product.root]) }
-    specify { expect(product.root.children[0].children.map(&:name)).to eq([:subfield1]) }
-    specify { expect(product.root.children[0].children.map(&:parent)).to eq([product.root.children[0]]) }
-
-    context 'default root options are set' do
-      around do |example|
-        previous_options = Chewy.default_root_options
-        Chewy.default_root_options = {_all: {enabled: false}}
-        example.run
-        Chewy.default_root_options = previous_options
-      end
-
-      specify { expect(product.mappings_hash[:product]).to include(_all: {enabled: false}) }
-    end
-  end
-
-  describe '.agg' do
-    specify { expect(product._agg_defs[:named_agg].call).to eq(avg: {field: 'title.subfield1'}) }
-    specify { expect(review._agg_defs[:named_agg].call).to eq(avg: {field: 'comments.rating'}) }
-  end
-
-  describe '.field' do
-    specify { expect(product.root.children.map(&:name)).to eq(%i[name surname title price]) }
-    specify { expect(product.root.children.map(&:parent)).to eq([product.root] * 4) }
-
-    specify { expect(product.root.children[0].children.map(&:name)).to eq([]) }
-    specify { expect(product.root.children[1].children.map(&:name)).to eq([]) }
-
-    specify { expect(product.root.children[2].children.map(&:name)).to eq([:subfield1]) }
-    specify { expect(product.root.children[2].children.map(&:parent)).to eq([product.root.children[2]]) }
-
-    specify { expect(product.root.children[3].children.map(&:name)).to eq([:subfield2]) }
-    specify { expect(product.root.children[3].children.map(&:parent)).to eq([product.root.children[3]]) }
-  end
-
-  describe '.mappings_hash' do
-    specify { expect(product.mappings_hash).to eq(product.root.mappings_hash) }
-
-    context 'root merging' do
-      context do
-        before do
-          stub_index(:products) do
-            define_type :product do
-              root _parent: 'project', other_option: 'nothing' do
-                field :name do
-                  field :last_name # will be redefined in the following root flock
-                end
-              end
-              root _parent: 'something_else'
-              root other_option: 'option_value' do
-                field :identifier
-                field :name, type: 'integer'
-              end
-            end
-          end
-        end
-
-        specify do
-          expect(product.mappings_hash).to eq(product: {
-            properties: {
-              name: {type: 'integer'},
-              identifier: {type: Chewy.default_field_type}
-            },
-            other_option: 'option_value',
-            _parent: {type: 'something_else'}
-          })
-        end
-      end
-    end
-
-    context 'parent-child relationship' do
-      context do
-        before do
-          stub_index(:products) do
-            define_type :product do
-              root _parent: 'project', parent_id: -> { project_id } do
-                field :name, 'surname'
-              end
-            end
-          end
-        end
-
-        specify { expect(product.mappings_hash[:product][:_parent]).to eq(type: 'project') }
-      end
-
-      context do
-        before do
-          stub_index(:products) do
-            define_type :product do
-              root parent: {'type' => 'project'}, parent_id: -> { project_id } do
-                field :name, 'surname'
-              end
-            end
-          end
-        end
-
-        specify { expect(product.mappings_hash[:product][:_parent]).to eq('type' => 'project') }
-      end
-    end
-  end
-
-  describe '.supports_outdated_sync?' do
-    def type(&block)
-      stub_index(:cities) do
-        define_type :city, &block
-      end
-      CitiesIndex::City
-    end
-
-    specify { expect(type.supports_outdated_sync?).to eq(false) }
-    specify { expect(type { field :updated_at }.supports_outdated_sync?).to eq(true) }
-    specify { expect(type { field :updated_at, value: -> {} }.supports_outdated_sync?).to eq(false) }
-    specify do
-      expect(type do
-        self.outdated_sync_field = :version
-        field :updated_at
-      end.supports_outdated_sync?).to eq(false)
-    end
-    specify do
-      expect(type do
-        self.outdated_sync_field = :version
-        field :version
-      end.supports_outdated_sync?).to eq(true)
-    end
-  end
-end

data/spec/chewy/type/observe_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type::Observe do
-  describe '.update_index' do
-    before do
-      stub_index(:dummies) do
-        define_type :dummy
-      end
-    end
-
-    let(:backreferenced) { Array.new(3) { |i| double(id: i) } }
-
-    specify do
-      expect { DummiesIndex::Dummy.update_index(backreferenced) }
-        .to raise_error Chewy::UndefinedUpdateStrategy
-    end
-    specify do
-      expect { DummiesIndex::Dummy.update_index([]) }
-        .not_to update_index('dummies#dummy')
-    end
-    specify do
-      expect { DummiesIndex::Dummy.update_index(nil) }
-        .not_to update_index('dummies#dummy')
-    end
-  end
-
-  context 'integration', :orm do
-    let(:update_condition) { true }
-
-    before do
-      city_countries_update_proc = if adapter == :sequel
-        ->(*) { previous_changes.try(:[], :country_id) || country }
-      else
-        ->(*) { changes['country_id'] || previous_changes['country_id'] || country }
-      end
-
-      stub_model(:city) do
-        update_index(->(city) { "cities##{city.class.name.underscore}" }) { self }
-        update_index 'countries#country', &city_countries_update_proc
-      end
-
-      stub_model(:country) do
-        update_index('cities#city', if: -> { update_condition }) { cities }
-        update_index(-> { "countries##{self.class.name.underscore}" }, :self)
-        attr_accessor :update_condition
-      end
-
-      if adapter == :sequel
-        City.many_to_one :country
-        Country.one_to_many :cities
-        City.plugin :dirty
-      else
-        if adapter == :mongoid && Mongoid::VERSION.start_with?('6')
-          City.belongs_to :country, optional: true
-        else
-          City.belongs_to :country
-        end
-        Country.has_many :cities
-      end
-
-      stub_index(:cities) do
-        define_type City
-      end
-
-      stub_index(:countries) do
-        define_type Country
-      end
-    end
-
-    context do
-      let!(:country1) { Chewy.strategy(:atomic) { Country.create!(id: 1, update_condition: update_condition) } }
-      let!(:country2) { Chewy.strategy(:atomic) { Country.create!(id: 2, update_condition: update_condition) } }
-      let!(:city) { Chewy.strategy(:atomic) { City.create!(id: 1, country: country1) } }
-
-      specify { expect { city.save! }.to update_index('cities#city').and_reindex(city).only }
-      specify { expect { city.save! }.to update_index('countries#country').and_reindex(country1).only }
-
-      specify { expect { city.update_attributes!(country: nil) }.to update_index('cities#city').and_reindex(city).only }
-      specify { expect { city.update_attributes!(country: nil) }.to update_index('countries#country').and_reindex(country1).only }
-
-      specify { expect { city.update_attributes!(country: country2) }.to update_index('cities#city').and_reindex(city).only }
-      specify { expect { city.update_attributes!(country: country2) }.to update_index('countries#country').and_reindex(country1, country2).only }
-    end
-
-    context do
-      let!(:country) do
-        Chewy.strategy(:atomic) do
-          cities = Array.new(2) { |i| City.create!(id: i) }
-          if adapter == :sequel
-            Country.create(id: 1, update_condition: update_condition).tap do |country|
-              cities.each { |city| country.add_city(city) }
-            end
-          else
-            Country.create!(id: 1, cities: cities, update_condition: update_condition)
-          end
-        end
-      end
-
-      specify { expect { country.save! }.to update_index('cities#city').and_reindex(country.cities).only }
-      specify { expect { country.save! }.to update_index('countries#country').and_reindex(country).only }
-
-      context 'conditional update' do
-        let(:update_condition) { false }
-        specify { expect { country.save! }.not_to update_index('cities#city') }
-      end
-    end
-  end
-
-  context 'transactions', :active_record do
-    context do
-      before { stub_model(:city) { update_index 'cities#city', :self } }
-      before { stub_index(:cities) { define_type City } }
-
-      specify do
-        Chewy.strategy(:urgent) do
-          ActiveRecord::Base.transaction do
-            expect { City.create! }.not_to update_index('cities#city')
-          end
-        end
-      end
-    end
-
-    context do
-      before { allow(Chewy).to receive_messages(use_after_commit_callbacks: false) }
-      before { stub_model(:city) { update_index 'cities#city', :self } }
-      before { stub_index(:cities) { define_type City } }
-
-      specify do
-        Chewy.strategy(:urgent) do
-          ActiveRecord::Base.transaction do
-            expect { City.create! }.to update_index('cities#city')
-          end
-        end
-      end
-    end
-  end
-end

data/spec/chewy/type/wrapper_spec.rb

@@ -1,98 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type::Wrapper do
-  before do
-    stub_class(:city)
-    stub_index(:cities) do
-      define_type City
-    end
-  end
-
-  let(:city_type) { CitiesIndex::City }
-
-  describe '.build' do
-    specify do
-      expect(city_type.build({}).attributes)
-        .to eq('id' => nil, '_score' => nil, '_explanation' => nil)
-    end
-    specify do
-      expect(city_type.build('_source' => {name: 'Martin'}).attributes)
-        .to eq('id' => nil, '_score' => nil, '_explanation' => nil, 'name' => 'Martin')
-    end
-    specify do
-      expect(city_type.build('_id' => 42).attributes)
-        .to eq('id' => 42, '_score' => nil, '_explanation' => nil)
-    end
-    specify do
-      expect(city_type.build('_id' => 42, '_source' => {'id' => 43}).attributes)
-        .to eq('id' => 43, '_score' => nil, '_explanation' => nil)
-    end
-    specify do
-      expect(city_type.build('_score' => 42, '_explanation' => {foo: 'bar'}).attributes)
-        .to eq('id' => nil, '_score' => 42, '_explanation' => {foo: 'bar'})
-    end
-    specify do
-      expect(city_type.build('_score' => 42, 'borogoves' => {foo: 'bar'})._data)
-        .to eq('_score' => 42, 'borogoves' => {foo: 'bar'})
-    end
-  end
-
-  describe '#initialize' do
-    subject(:city) { city_type.new(name: 'Martin', age: 42) }
-
-    it do
-      is_expected.to respond_to(:name)
-        .and respond_to(:age)
-        .and have_attributes(
-          name: 'Martin',
-          age: 42
-        )
-    end
-
-    it { expect { city.population }.to raise_error(NoMethodError) }
-
-    context 'highlight' do
-      subject(:city) do
-        city_type.new(name: 'Martin', age: 42)
-          .tap do |city|
-            city._data = {
-              'highlight' => {'name' => ['<b>Mar</b>tin']}
-            }
-          end
-      end
-
-      it do
-        is_expected.to respond_to(:name_highlight)
-          .and have_attributes(
-            name: 'Martin',
-            name_highlight: '<b>Mar</b>tin'
-          )
-      end
-    end
-  end
-
-  describe '#==' do
-    specify { expect(city_type.new(id: 42)).to eq(city_type.new(id: 42)) }
-    specify { expect(city_type.new(id: 42, age: 55)).to eq(city_type.new(id: 42, age: 54)) }
-    specify { expect(city_type.new(id: 42)).not_to eq(city_type.new(id: 43)) }
-    specify { expect(city_type.new(id: 42, age: 55)).not_to eq(city_type.new(id: 43, age: 55)) }
-    specify { expect(city_type.new(age: 55)).to eq(city_type.new(age: 55)) }
-    specify { expect(city_type.new(age: 55)).not_to eq(city_type.new(age: 54)) }
-
-    specify { expect(city_type.new(id: '42')).to eq(City.new.tap { |m| allow(m).to receive_messages(id: 42) }) }
-    specify { expect(city_type.new(id: 42)).not_to eq(City.new.tap { |m| allow(m).to receive_messages(id: 43) }) }
-    specify { expect(city_type.new(id: 42)).not_to eq(Class.new) }
-
-    context 'models', :orm do
-      before do
-        stub_model(:city)
-        stub_index(:cities) do
-          define_type City
-        end
-      end
-      specify { expect(city_type.new(id: '42')).to eq(City.new.tap { |m| allow(m).to receive_messages(id: 42) }) }
-      specify { expect(city_type.new(id: 42)).not_to eq(City.new.tap { |m| allow(m).to receive_messages(id: 43) }) }
-      specify { expect(city_type.new(id: 42)).not_to eq(Class.new) }
-    end
-  end
-end