chewy 0.8.4 → 7.3.4

data/spec/chewy/type/import_spec.rb

@@ -1,433 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type::Import do
-  before { Chewy.massacre }
-
-  before do
-    stub_model(:city)
-  end
-
-  before do
-    stub_index(:cities) do
-      define_type City do
-        field :name
-      end
-    end
-  end
-
-  let!(:dummy_cities) { 3.times.map { |i| City.create(id: i + 1, name: "name#{i}") } }
-  let(:city) { CitiesIndex::City }
-
-  describe '.import', :orm do
-    specify { expect(city.import).to eq(true) }
-    specify { expect(city.import([])).to eq(true) }
-    specify { expect(city.import(dummy_cities)).to eq(true) }
-    specify { expect(city.import(dummy_cities.map(&:id))).to eq(true) }
-
-    specify { expect { city.import([]) }.not_to update_index(city) }
-    specify { expect { city.import }.to update_index(city).and_reindex(dummy_cities) }
-    specify { expect { city.import dummy_cities }.to update_index(city).and_reindex(dummy_cities) }
-    specify { expect { city.import dummy_cities.map(&:id) }.to update_index(city).and_reindex(dummy_cities) }
-
-    describe 'criteria-driven importing' do
-      let(:names) { %w(name0 name1) }
-
-      context 'mongoid', :mongoid do
-        specify { expect { city.import(City.where(:name.in => names)) }.to update_index(city).and_reindex(dummy_cities.first(2)) }
-        specify { expect { city.import(City.where(:name.in => names).map(&:id)) }.to update_index(city).and_reindex(dummy_cities.first(2)) }
-      end
-
-      context 'active record', :active_record do
-        specify { expect { city.import(City.where(name: names)) }.to update_index(city).and_reindex(dummy_cities.first(2)) }
-        specify { expect { city.import(City.where(name: names).map(&:id)) }.to update_index(city).and_reindex(dummy_cities.first(2)) }
-      end
-    end
-
-    specify do
-      dummy_cities.first.destroy
-      expect { city.import dummy_cities }
-        .to update_index(city).and_reindex(dummy_cities.from(1)).and_delete(dummy_cities.first)
-    end
-
-    specify do
-      dummy_cities.first.destroy
-      expect { city.import dummy_cities.map(&:id) }
-        .to update_index(city).and_reindex(dummy_cities.from(1)).and_delete(dummy_cities.first)
-    end
-
-    specify do
-      dummy_cities.first.destroy
-
-      imported = []
-      allow(CitiesIndex.client).to receive(:bulk) { |params| imported << params[:body]; nil }
-
-      city.import dummy_cities.map(&:id), batch_size: 2
-      expect(imported.flatten).to match_array([
-        {index: {_id: 2, data: {'name' => 'name1'}}},
-        {index: {_id: 3, data: {'name' => 'name2'}}},
-        {delete: {_id: dummy_cities.first.id}}
-      ])
-    end
-
-    context ':bulk_size' do
-      specify do
-        dummy_cities.first.destroy
-
-        imported = []
-        allow(CitiesIndex.client).to receive(:bulk) { |params| imported << params[:body]; nil }
-
-        city.import dummy_cities.map(&:id), bulk_size: 1.2.kilobyte
-        expect(imported.flatten).to match_array([
-          %Q({"delete":{"_id":1}}),
-          %Q({"index":{"_id":2}}\n{"name":"name1"}\n{"index":{"_id":3}}\n{"name":"name2"})
-        ])
-      end
-
-      context do
-        let!(:dummy_cities) { 3.times.map { |i| City.create(id: i + 1, name: "name#{i}" * 20) } }
-
-        specify do
-          dummy_cities.first.destroy
-
-          imported = []
-          allow(CitiesIndex.client).to receive(:bulk) { |params| imported << params[:body]; nil }
-
-          city.import dummy_cities.map(&:id), bulk_size: 1.2.kilobyte
-          expect(imported.flatten).to match_array([
-            %Q({"delete":{"_id":1}}),
-            %Q({"index":{"_id":2}}\n{"name":"#{'name1' * 20}"}),
-            %Q({"index":{"_id":3}}\n{"name":"#{'name2' * 20}"})
-          ])
-        end
-
-        specify do
-          expect { city.import dummy_cities.map(&:id), bulk_size: 1.1.kilobyte }.to raise_error ArgumentError
-        end
-      end
-    end
-
-    specify do
-      expect(CitiesIndex.client).to receive(:bulk).with(hash_including(refresh: true))
-      city.import dummy_cities
-    end
-
-    specify do
-      expect(CitiesIndex.client).to receive(:bulk).with(hash_including(refresh: false))
-      city.import dummy_cities, refresh: false
-    end
-
-    context 'scoped' do
-      before do
-        names = %w(name0 name1)
-
-        criteria = case adapter
-        when :mongoid
-          { :name.in => names }
-        else
-          { name: names }
-        end
-
-        stub_index(:cities) do
-          define_type City.where(criteria) do
-            field :name
-          end
-        end
-      end
-
-      specify { expect { city.import }.to update_index(city).and_reindex(dummy_cities.first(2)) }
-
-      context 'mongoid', :mongoid do
-        specify do
-          expect { city.import City.where(_id: dummy_cities.first.id) }.to update_index(city).and_reindex(dummy_cities.first).only
-        end
-      end
-
-      context 'active record', :active_record do
-        specify do
-          expect { city.import City.where(id: dummy_cities.first.id) }.to update_index(city).and_reindex(dummy_cities.first).only
-        end
-      end
-    end
-
-    context 'instrumentation payload' do
-      specify do
-        outer_payload = nil
-        ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
-          outer_payload = payload
-        end
-
-        dummy_cities.first.destroy
-        city.import dummy_cities
-        expect(outer_payload).to eq({type: CitiesIndex::City, import: {delete: 1, index: 2}})
-      end
-
-      specify do
-        outer_payload = nil
-        ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
-          outer_payload = payload
-        end
-
-        dummy_cities.first.destroy
-        city.import dummy_cities, batch_size: 2
-        expect(outer_payload).to eq({type: CitiesIndex::City, import: {delete: 1, index: 2}})
-      end
-
-      specify do
-        outer_payload = nil
-        ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
-          outer_payload = payload
-        end
-
-        city.import dummy_cities, batch_size: 2
-        expect(outer_payload).to eq({type: CitiesIndex::City, import: {index: 3}})
-      end
-
-      context do
-        before do
-          stub_index(:cities) do
-            define_type City do
-              field :name, type: 'object'
-            end
-          end
-        end
-
-        specify do
-          skip_on_version_gte('2.0', 'format of exception changed in 2.x')
-          outer_payload = nil
-          ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
-            outer_payload = payload
-          end
-
-          city.import dummy_cities, batch_size: 2
-          expect(outer_payload).to eq({
-            type: CitiesIndex::City,
-            errors: {
-              index: {
-                "WriteFailureException; nested: MapperParsingException[object mapping for [city] tried to parse field [name] as object, but got EOF, has a concrete value been provided to it?]; " => ["1"],
-                "MapperParsingException[object mapping for [city] tried to parse field [name] as object, but got EOF, has a concrete value been provided to it?]" => ["2", "3"]
-              }
-            },
-            import: {index: 3}
-          })
-        end
-
-        specify do
-          skip_on_version_lt('2.0', 'format of exception was changed')
-          outer_payload = nil
-          ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
-            outer_payload = payload
-          end
-
-          city.import dummy_cities, batch_size: 2
-          expect(outer_payload).to eq({
-            type: CitiesIndex::City,
-            errors: {
-              index: {
-                {"type"=>"mapper_parsing_exception", "reason"=>"object mapping for [name] tried to parse field [name] as object, but found a concrete value"} => ["1", "2", "3"]
-              }
-            },
-            import: {index: 3}
-          })
-        end
-      end
-    end
-
-    context 'error handling' do
-      context do
-        before do
-          stub_index(:cities) do
-            define_type City do
-              field :name, type: 'object'
-            end
-          end
-        end
-
-        specify { expect(city.import(dummy_cities)).to eq(false) }
-        specify { expect(city.import(dummy_cities.map(&:id))).to eq(false) }
-        specify { expect(city.import(dummy_cities, batch_size: 1)).to eq(false) }
-      end
-
-      context do
-        before do
-          stub_index(:cities) do
-            define_type City do
-              field :name, type: 'object', value: ->{ name == 'name1' ? name : {name: name} }
-            end
-          end
-        end
-
-        specify { expect(city.import(dummy_cities)).to eq(false) }
-        specify { expect(city.import(dummy_cities.map(&:id))).to eq(false) }
-        specify { expect(city.import(dummy_cities, batch_size: 2)).to eq(false) }
-      end
-    end
-
-    context 'parent-child relationship', :orm do
-      let(:country) { Country.create(id: 1, name: 'country') }
-      let(:another_country) { Country.create(id: 2, name: 'another country') }
-
-      before do
-        stub_model(:country)
-        stub_model(:city)
-        adapter == :sequel ? City.many_to_one(:country) : City.belongs_to(:country)
-      end
-
-      before do
-        stub_index(:countries) do
-          define_type Country do
-            field :name
-          end
-
-          define_type City do
-            root parent: { type: 'country' }, parent_id: -> { country_id } do
-              field :name
-            end
-          end
-        end
-      end
-
-      before { CountriesIndex::Country.import(country) }
-
-      let(:child_city) { City.create(id: 4, country_id: country.id, name: 'city') }
-      let(:city) { CountriesIndex::City }
-
-      specify { expect(city.import(child_city)).to eq(true)  }
-      specify { expect { city.import child_city }.to update_index(city).and_reindex(child_city) }
-
-      specify do
-        expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-          body: [{ index: { _id: child_city.id, parent: country.id, data: { 'name' => 'city' } } }]
-        ))
-
-        city.import child_city
-      end
-
-      context 'updating or deleting' do
-        before { city.import child_city }
-
-        specify do
-          child_city.update_attributes(country_id: another_country.id)
-
-          expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-            body: [
-              { delete: { _id: child_city.id, parent: country.id.to_s } },
-              { index: { _id: child_city.id, parent: another_country.id, data: { 'name' => 'city' } } }
-            ]
-          ))
-
-          city.import child_city
-        end
-
-        specify do
-          child_city.destroy
-
-          expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-            body: [{ delete: { _id: child_city.id, parent: country.id.to_s } }]
-          ))
-
-          city.import child_city
-        end
-
-        specify do
-          child_city.destroy
-
-          expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-            body: [{ delete: { _id: child_city.id, parent: country.id.to_s } }]
-          ))
-
-          city.import child_city.id
-        end
-      end
-    end
-
-    context 'root id', :orm do
-      let(:canada) { Country.create(id: 1, name: 'Canada', country_code: 'CA', rating: 4) }
-      let(:country)  { CountriesIndex::Country }
-
-      before do
-        stub_model(:country)
-      end
-
-      before do
-        stub_index(:countries) do
-          define_type Country do
-            root _id: -> { country_code } do
-              field :name
-              field :rating
-            end
-          end
-        end
-      end
-
-      specify { expect(country.import(canada)).to eq(true)  }
-      specify { expect { country.import(canada) }.to update_index(country).and_reindex(canada.country_code) }
-
-      specify do
-        expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-          body: [{ index: { _id: canada.country_code, data: { 'name' => 'Canada', 'rating' => 4 } } }]
-        ))
-
-        country.import canada
-      end
-
-      specify do
-        canada.update_attributes(rating: 9)
-
-        expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-          body: [{ index: { _id: canada.country_code, data: { 'name' => 'Canada', 'rating' => 9 } } }]
-        ))
-
-        country.import canada
-      end
-
-      specify do
-        canada.destroy
-
-        expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
-          body: [{ delete: { _id: canada.country_code } }]
-        ))
-
-        country.import canada
-      end
-
-    end
-
-    context 'default_import_options is set' do
-      before do
-        CitiesIndex::City.default_import_options(batch_size: 500, bulk_size: 1.megabyte)
-      end
-
-      specify do
-        expect(CitiesIndex::City.adapter).to receive(:import).with(batch_size: 500, bulk_size: 1.megabyte)
-        CitiesIndex::City.import
-      end
-    end
-  end
-
-  describe '.import!', :orm do
-    specify { expect { city.import! }.not_to raise_error }
-
-    context do
-      before do
-        stub_index(:cities) do
-          define_type City do
-            field :name, type: 'object'
-          end
-        end
-      end
-
-      specify { expect { city.import!(dummy_cities) }.to raise_error Chewy::ImportFailed }
-    end
-
-    context 'when .import fails' do
-      before do
-        allow(city).to receive(:import) { raise }
-      end
-
-      specify do
-        expect(ActiveSupport::Notifications).to receive(:unsubscribe)
-        city.import!(dummy_cities) rescue nil
-      end
-    end
-  end
-end

data/spec/chewy/type/mapping_spec.rb

@@ -1,106 +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: 'string' 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
-
-  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_object.children.map(&:name)).to eq([:name, :surname, :title, :price]) }
-    specify { expect(product.root_object.children.map(&:parent)).to eq([product.root_object] * 4) }
-
-    specify { expect(product.root_object.children[0].children.map(&:name)).to eq([]) }
-    specify { expect(product.root_object.children[1].children.map(&:name)).to eq([]) }
-
-    specify { expect(product.root_object.children[2].children.map(&:name)).to eq([:subfield1]) }
-    specify { expect(product.root_object.children[2].children.map(&:parent)).to eq([product.root_object.children[2]]) }
-
-    specify { expect(product.root_object.children[3].children.map(&:name)).to eq([:subfield2]) }
-    specify { expect(product.root_object.children[3].children.map(&:parent)).to eq([product.root_object.children[3]]) }
-  end
-
-  describe '.mappings_hash' do
-    specify { expect(Class.new(Chewy::Type).mappings_hash).to eq({}) }
-    specify { expect(product.mappings_hash).to eq(product.root_object.mappings_hash) }
-
-    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
-
-  context "no root element call" do
-    before do
-      stub_index(:products) do
-        define_type :product do
-          field :title, type: 'string' do
-            field :subfield1
-          end
-        end
-      end
-    end
-
-    specify { expect(product.root_object.children.map(&:name)).to eq([:title]) }
-    specify { expect(product.root_object.children.map(&:parent)).to eq([product.root_object]) }
-    specify { expect(product.root_object.children[0].children.map(&:name)).to eq([:subfield1]) }
-    specify { expect(product.root_object.children[0].children.map(&:parent)).to eq([product.root_object.children[0]]) }
-  end
-end

data/spec/chewy/type/observe_spec.rb

@@ -1,127 +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) { 3.times.map { |i| double(id: i) } }
-
-    specify { expect { DummiesIndex::Dummy.update_index(backreferenced) }
-      .to raise_error Chewy::UndefinedUpdateStrategy }
-    specify { expect { DummiesIndex::Dummy.update_index([]) }
-      .not_to update_index('dummies#dummy') }
-    specify { expect { DummiesIndex::Dummy.update_index(nil) }
-      .not_to update_index('dummies#dummy') }
-  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
-        City.belongs_to :country
-        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 = 2.times.map { |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