chewy 6.0.0 → 7.6.0

data/spec/chewy/type/mapping_spec.rb

@@ -1,175 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type::Mapping do
-  let(:product) { ProductsIndex::Product }
-  let(:review)  { ReviewsIndex::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
-    end
-    stub_index(:reviews) do
-      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!(country: nil) }.to update_index('cities#city').and_reindex(city).only }
-      specify { expect { city.update!(country: nil) }.to update_index('countries#country').and_reindex(country1).only }
-
-      specify { expect { city.update!(country: country2) }.to update_index('cities#city').and_reindex(city).only }
-      specify { expect { city.update!(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,100 +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 respond_to(:name_highlights)
-          .and have_attributes(
-            name: 'Martin',
-            name_highlight: '<b>Mar</b>tin',
-            name_highlights: ['<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

data/spec/chewy/type_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type do
-  describe '.derivable_name' do
-    specify { expect { Class.new(Chewy::Type).derivable_name }.to raise_error NotImplementedError }
-
-    specify do
-      index = Class.new(Chewy::Index) { define_type :city }
-      expect(index::City.derivable_name).to be_nil
-    end
-
-    specify do
-      stub_index(:places) { define_type :city }
-      expect(PlacesIndex::City.derivable_name).to eq('places#city')
-    end
-
-    specify do
-      stub_index('namespace/places') { define_type :city }
-      expect(Namespace::PlacesIndex::City.derivable_name).to eq('namespace/places#city')
-    end
-  end
-
-  describe '.types' do
-    subject { Class.new(Chewy::Type) }
-    specify { expect(subject.types).to eq([subject]) }
-  end
-
-  describe '.scopes' do
-    before do
-      stub_index(:places) do
-        def self.by_id; end
-
-        define_type :city do
-          def self.by_rating; end
-
-          def self.by_name; end
-        end
-      end
-    end
-
-    specify { expect(described_class.scopes).to eq([]) }
-    specify { expect(PlacesIndex::City.scopes).to match_array(%i[by_rating by_name]) }
-    specify { expect { PlacesIndex::City.non_existing_method_call }.to raise_error(NoMethodError) }
-
-    specify { expect(PlacesIndex::City._default_import_options).to eq({}) }
-    specify { expect { PlacesIndex::City.default_import_options(invalid_option: 'Yeah!') }.to raise_error(ArgumentError) }
-
-    context 'default_import_options is set' do
-      let(:converter) { -> {} }
-      before { PlacesIndex::City.default_import_options(batch_size: 500, raw_import: converter) }
-
-      specify { expect(PlacesIndex::City._default_import_options).to eq(batch_size: 500, raw_import: converter) }
-    end
-  end
-end

data/spec/support/mongoid.rb

@@ -1,93 +0,0 @@
-require 'database_cleaner'
-
-CONFIG = {
-  sessions: {
-    default: {
-      uri: 'mongodb://127.0.0.1:27017/chewy_mongoid_test'
-    }
-  },
-  clients: {
-    default: {
-      uri: 'mongodb://127.0.0.1:27017/chewy_mongoid_test'
-    }
-  }
-}.freeze
-
-Mongoid.configure do |config|
-  config.load_configuration(CONFIG)
-end
-
-Mongoid.logger = Logger.new('/dev/null')
-
-module MongoidClassHelpers
-  extend ActiveSupport::Concern
-
-  module Document
-    def serializable_hash(options = nil)
-      hash = super(options)
-      hash['id'] = hash.delete('_id') if hash.key?('_id')
-      hash
-    end
-  end
-
-  module Country
-    extend ActiveSupport::Concern
-
-    included do
-      include Mongoid::Document
-      include Mongoid::Timestamps::Updated
-      include Document
-
-      field :name, type: String
-      field :country_code, type: String
-      field :rating, type: Integer
-    end
-  end
-
-  module City
-    extend ActiveSupport::Concern
-
-    included do
-      include Mongoid::Document
-      include Mongoid::Timestamps::Updated
-      include Document
-
-      field :name, type: String
-      field :rating, type: Integer
-    end
-  end
-
-  def adapter
-    :mongoid
-  end
-
-  def stub_model(name, superclass = nil, &block)
-    mixin = "MongoidClassHelpers::#{name.to_s.camelize}".safe_constantize || Mongoid::Document
-
-    model = stub_class(name, superclass) do
-      include mixin
-      store_in collection: name.to_s.tableize
-    end
-    model.tap { |i| i.class_eval(&block) if block }
-  end
-end
-
-RSpec.configure do |config|
-  config.include MongoidClassHelpers
-
-  config.filter_run_excluding :active_record
-  config.filter_run_excluding :sequel
-
-  config.before(:suite) do
-    DatabaseCleaner.clean_with :truncation
-    DatabaseCleaner.strategy = :truncation
-  end
-
-  config.before do
-    DatabaseCleaner.start
-  end
-
-  config.after do
-    DatabaseCleaner.clean
-  end
-end

data/spec/support/sequel.rb

@@ -1,80 +0,0 @@
-require 'database_cleaner'
-
-DB = Sequel.sqlite # logger: Logger.new(STDERR)
-Sequel::Deprecation.output = false
-
-DB.create_table :countries do
-  primary_key :id
-  column :name, :string
-  column :country_code, :string
-  column :rating, :integer
-  column :updated_at, :datetime
-end
-
-DB.create_table :cities do
-  primary_key :id
-  column :country_id, :integer
-  column :name, :string
-  column :rating, :integer
-  column :updated_at, :datetime
-end
-
-DB.create_table :rating_cities do
-  primary_key :rating
-  column :country_id, :integer
-  column :name, :string
-  column :updated_at, :datetime
-end
-
-Sequel::Model.plugin :timestamps, update_on_create: true
-Sequel::Model.plugin :chewy_observe
-
-module SequelClassHelpers
-  extend ActiveSupport::Concern
-
-  class AdaptedSequelModel < Sequel::Model
-    # Allow to set primary key using mass assignment.
-    unrestrict_primary_key
-
-    # Aliases for compatibility with specs that were written with ActiveRecord in mind...
-    alias_method :save!, :save
-    alias_method :update_attributes, :update
-    alias_method :update_attributes!, :update
-
-    class << self
-      alias_method :create!, :create
-    end
-  end
-
-  def adapter
-    :sequel
-  end
-
-  def stub_model(name, &block)
-    stub_class(name, AdaptedSequelModel, &block).tap do |klass|
-      # Sequel doesn't work well with dynamically created classes,
-      # so we must set the dataset (table) name manually.
-      klass.dataset = name.to_s.pluralize.to_sym
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include SequelClassHelpers
-
-  config.filter_run_excluding :active_record
-  config.filter_run_excluding :mongoid
-
-  config.before(:suite) do
-    DatabaseCleaner.clean_with :truncation
-    DatabaseCleaner.strategy = :truncation
-  end
-
-  config.before do
-    DatabaseCleaner.start
-  end
-
-  config.after do
-    DatabaseCleaner.clean
-  end
-end