chewy 0.5.2 → 0.6.0

data/spec/chewy/type/mapping_spec.rb

@@ -20,19 +20,19 @@ describe Chewy::Type::Mapping do
   end
 
   describe '.field' do
-    specify { product.root_object.nested.keys.should =~ [:name, :surname, :title, :price] }
-    specify { product.root_object.nested.values.should satisfy { |v| v.all? { |f| f.is_a? Chewy::Fields::Base } } }
+    specify { expect(product.root_object.nested.keys).to match_array([:name, :surname, :title, :price]) }
+    specify { expect(product.root_object.nested.values).to satisfy { |v| v.all? { |f| f.is_a? Chewy::Fields::Base } } }
 
-    specify { product.root_object.nested[:title].nested.keys.should == [:subfield1] }
-    specify { product.root_object.nested[:title].nested[:subfield1].should be_a Chewy::Fields::Base }
+    specify { expect(product.root_object.nested[:title].nested.keys).to eq([:subfield1]) }
+    specify { expect(product.root_object.nested[:title].nested[:subfield1]).to be_a Chewy::Fields::Base }
 
-    specify { product.root_object.nested[:price].nested.keys.should == [:subfield2] }
-    specify { product.root_object.nested[:price].nested[:subfield2].should be_a Chewy::Fields::Base }
+    specify { expect(product.root_object.nested[:price].nested.keys).to eq([:subfield2]) }
+    specify { expect(product.root_object.nested[:price].nested[:subfield2]).to be_a Chewy::Fields::Base }
   end
 
   describe '.mappings_hash' do
-    specify { Class.new(Chewy::Type).mappings_hash.should == {} }
-    specify { product.mappings_hash.should == product.root_object.mappings_hash }
+    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
@@ -46,7 +46,7 @@ describe Chewy::Type::Mapping do
           end
         end
 
-        specify { product.mappings_hash[:product][:_parent].should == { type: 'project' } }
+        specify { expect(product.mappings_hash[:product][:_parent]).to eq({ type: 'project' }) }
       end
 
       context do
@@ -60,7 +60,7 @@ describe Chewy::Type::Mapping do
           end
         end
 
-        specify { product.mappings_hash[:product][:_parent].should == { 'type' => 'project' } }
+        specify { expect(product.mappings_hash[:product][:_parent]).to eq({ 'type' => 'project' }) }
       end
     end
   end
@@ -76,7 +76,7 @@ describe Chewy::Type::Mapping do
       end
     end
 
-    specify { product.root_object.nested[:title].nested.keys.should == [:subfield1] }
-    specify { product.root_object.nested[:title].nested[:subfield1].should be_a Chewy::Fields::Base }
+    specify { expect(product.root_object.nested[:title].nested.keys).to eq([:subfield1]) }
+    specify { expect(product.root_object.nested[:title].nested[:subfield1]).to be_a Chewy::Fields::Base }
   end
 end

data/spec/chewy/type/observe_spec.rb

@@ -10,8 +10,6 @@ describe Chewy::Type::Import do
 
     let(:backreferenced) { 3.times.map { |i| double(id: i) } }
 
-    specify { expect { DummiesIndex.dummy.update_index(backreferenced, urgent: true) }
-      .to update_index('dummies#dummy', atomic: false).and_reindex(backreferenced) }
     specify { expect { DummiesIndex.dummy.update_index(backreferenced) }
       .not_to update_index('dummies#dummy', atomic: false) }
     specify { expect { DummiesIndex.dummy.update_index([]) }
@@ -20,7 +18,7 @@ describe Chewy::Type::Import do
       .not_to update_index('dummies#dummy') }
   end
 
-  context 'integration' do
+  context 'integration', :orm do
     before do
       stub_model(:city) do
         belongs_to :country
@@ -31,7 +29,7 @@ describe Chewy::Type::Import do
       stub_model(:country) do
         has_many :cities
         update_index('cities#city') { cities }
-        update_index 'countries#country', :self, urgent: true
+        update_index 'countries#country', :self
       end
 
       stub_index(:cities) do
@@ -43,8 +41,8 @@ describe Chewy::Type::Import do
       end
     end
 
-    let(:city) { City.create!(country: Country.create!) }
-    let(:country) { Country.create!(cities: 2.times.map { City.create! }) }
+    let(:city) { City.create!(id: 1, country: Country.create!(id: 1)) }
+    let(:country) { Country.create!(id: 1, cities: 2.times.map { |i| City.create!(id: i) }) }
 
     specify { expect { city.save! }.not_to update_index('cities#city', atomic: false) }
     specify { expect { country.save! }.to update_index('countries#country').and_reindex(country) }
@@ -71,6 +69,7 @@ describe Chewy::Type::Import do
     end
 
     context do
+      before { allow(Chewy).to receive_messages(urgent_update: true) }
       let(:other_country) { Country.create! }
 
       specify do

data/spec/chewy/type/wrapper_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Chewy::Type::Wrapper do
   before do
-    stub_model(:city)
+    stub_class(:city)
     stub_index(:cities) do
       define_type City
     end
@@ -12,22 +12,22 @@ describe Chewy::Type::Wrapper do
 
   subject { city_type.new(name: 'Martin', age: 42) }
 
-  it { should respond_to :name }
-  it { should respond_to :age }
+  it { is_expected.to respond_to :name }
+  it { is_expected.to respond_to :age }
   its(:name) { should == 'Martin' }
   its(:age) { should == 42 }
 
   describe '#==' do
-    specify { city_type.new(id: 42).should == city_type.new(id: 42) }
-    specify { city_type.new(id: 42, age: 55).should == city_type.new(id: 42, age: 54) }
-    specify { city_type.new(id: 42).should_not == city_type.new(id: 43) }
-    specify { city_type.new(id: 42, age: 55).should_not == city_type.new(id: 43, age: 55) }
-    specify { city_type.new(age: 55).should == city_type.new(age: 55) }
-    specify { city_type.new(age: 55).should_not == city_type.new(age: 54) }
+    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 { city_type.new(id: '42').should == City.new.tap { |m| m.stub(id: 42) } }
-    specify { city_type.new(id: 42).should_not == City.new.tap { |m| m.stub(id: 43) } }
+    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 { city_type.new(id: 42).should_not == Class.new }
+    specify { expect(city_type.new(id: 42)).not_to eq(Class.new) }
   end
 end

data/spec/chewy_spec.rb

@@ -25,11 +25,11 @@ describe Chewy do
     specify { expect { described_class.derive_type('developers#borogoves') }.to raise_error Chewy::UnderivableType, /DevelopersIndex.*borogoves/ }
     specify { expect { described_class.derive_type('namespace/autocomplete') }.to raise_error Chewy::UnderivableType, /AutocompleteIndex.*namespace\/autocomplete#type_name/ }
 
-    specify { described_class.derive_type(DevelopersIndex.developer).should == DevelopersIndex.developer }
-    specify { described_class.derive_type('developers').should == DevelopersIndex.developer }
-    specify { described_class.derive_type('developers#developer').should == DevelopersIndex.developer }
-    specify { described_class.derive_type('namespace/autocomplete#developer').should == Namespace::AutocompleteIndex.developer }
-    specify { described_class.derive_type('namespace/autocomplete#company').should == Namespace::AutocompleteIndex.company }
+    specify { expect(described_class.derive_type(DevelopersIndex.developer)).to eq(DevelopersIndex.developer) }
+    specify { expect(described_class.derive_type('developers')).to eq(DevelopersIndex.developer) }
+    specify { expect(described_class.derive_type('developers#developer')).to eq(DevelopersIndex.developer) }
+    specify { expect(described_class.derive_type('namespace/autocomplete#developer')).to eq(Namespace::AutocompleteIndex.developer) }
+    specify { expect(described_class.derive_type('namespace/autocomplete#company')).to eq(Namespace::AutocompleteIndex.company) }
   end
 
   describe '.create_type' do
@@ -38,55 +38,55 @@ describe Chewy do
     context 'Symbol' do
       subject { described_class.create_type(CitiesIndex, :city) }
 
-      it { should be_a Class }
-      it { should be < Chewy::Type }
+      it { is_expected.to be_a Class }
+      it { is_expected.to be < Chewy::Type }
       its(:name) { should == 'CitiesIndex::City' }
       its(:index) { should == CitiesIndex }
       its(:type_name) { should == 'city' }
     end
 
-    context 'ActiveRecord model' do
-      before { stub_model(:city) }
+    context 'simple model' do
+      before { stub_class(:city) }
       subject { described_class.create_type(CitiesIndex, City) }
 
-      it { should be_a Class }
-      it { should be < Chewy::Type }
+      it { is_expected.to be_a Class }
+      it { is_expected.to be < Chewy::Type }
       its(:name) { should == 'CitiesIndex::City' }
       its(:index) { should == CitiesIndex }
       its(:type_name) { should == 'city' }
     end
 
-    context 'ActiveRecord scope' do
+    context 'model scope', :orm do
       before { stub_model(:city) }
       subject { described_class.create_type(CitiesIndex, City.includes(:country)) }
 
-      it { should be_a Class }
-      it { should be < Chewy::Type }
+      it { is_expected.to be_a Class }
+      it { is_expected.to be < Chewy::Type }
       its(:name) { should == 'CitiesIndex::City' }
       its(:index) { should == CitiesIndex }
       its(:type_name) { should == 'city' }
     end
 
     context 'Namespaced index' do
-      before { stub_model(:city) }
+      before { stub_class(:city) }
       before { stub_index('namespace/cities') }
 
       subject { described_class.create_type(Namespace::CitiesIndex, City) }
 
-      it { should be_a Class }
-      it { should be < Chewy::Type }
+      it { is_expected.to be_a Class }
+      it { is_expected.to be < Chewy::Type }
       its(:name) { should == 'Namespace::CitiesIndex::City' }
       its(:index) { should == Namespace::CitiesIndex }
       its(:type_name) { should == 'city' }
     end
 
     context 'Namespaced model' do
-      before { stub_model('namespace/city') }
+      before { stub_class('namespace/city') }
 
       subject { described_class.create_type(CitiesIndex, Namespace::City) }
 
-      it { should be_a Class }
-      it { should be < Chewy::Type }
+      it { is_expected.to be_a Class }
+      it { is_expected.to be < Chewy::Type }
       its(:name) { should == 'CitiesIndex::City' }
       its(:index) { should == CitiesIndex }
       its(:type_name) { should == 'city' }
@@ -94,22 +94,20 @@ describe Chewy do
   end
 
   describe '.massacre' do
-    before do
-      Chewy.client.indices.delete index: '*'
-    end
+    before { Chewy.massacre }
 
     before do
-      Chewy.configuration = Chewy.configuration.merge(prefix: 'prefix1')
+      allow(Chewy).to receive_messages(configuration: Chewy.configuration.merge(prefix: 'prefix1'))
       stub_index(:admins).create!
-      Chewy.configuration = Chewy.configuration.merge(prefix: 'prefix2')
+      allow(Chewy).to receive_messages(configuration: Chewy.configuration.merge(prefix: 'prefix2'))
       stub_index(:developers).create!
       stub_index(:companies).create!
 
       Chewy.massacre
     end
 
-    specify { AdminsIndex.exists?.should == true }
-    specify { DevelopersIndex.exists?.should == false }
-    specify { CompaniesIndex.exists?.should == false }
+    specify { expect(AdminsIndex.exists?).to eq(true) }
+    specify { expect(DevelopersIndex.exists?).to eq(false) }
+    specify { expect(CompaniesIndex.exists?).to eq(false) }
   end
 end

data/spec/spec_helper.rb

@@ -1,33 +1,22 @@
 require 'bundler'
+
 Bundler.require
+
+begin
+  require 'active_record'
+rescue LoadError
+end
+
 require 'rspec/its'
 require 'rspec/collection_matchers'
-require 'active_record'
-require 'database_cleaner'
+
+Kaminari::Hooks.init if defined?(::Kaminari)
 
 require 'support/fail_helpers'
 require 'support/class_helpers'
 
 require 'chewy/rspec'
 
-Kaminari::Hooks.init
-
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-ActiveRecord::Base.logger = Logger.new('/dev/null')
-
-ActiveRecord::Schema.define do
-  create_table :countries do |t|
-    t.column :name, :string
-    t.column :rating, :integer
-  end
-
-  create_table :cities do |t|
-    t.column :country_id, :integer
-    t.column :name, :string
-    t.column :rating, :integer
-  end
-end
-
 Chewy.configuration = {
   host: 'localhost:9250',
   wait_for_status: 'green',
@@ -42,17 +31,16 @@ RSpec.configure do |config|
 
   config.include FailHelpers
   config.include ClassHelpers
+end
 
-  config.before(:suite) do
-    DatabaseCleaner.clean_with :truncation
-    DatabaseCleaner.strategy = :transaction
-  end
-
-  config.before do
-    DatabaseCleaner.start
-  end
-
-  config.after do
-    DatabaseCleaner.clean
+if defined?(::ActiveRecord)
+  require 'support/active_record'
+elsif defined?(::Mongoid)
+  require 'support/mongoid'
+else
+  RSpec.configure do |config|
+    config.filter_run_excluding :orm
+    config.filter_run_excluding :mongoid
+    config.filter_run_excluding :active_record
   end
 end

data/spec/support/active_record.rb

@@ -0,0 +1,52 @@
+require 'database_cleaner'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Base.logger = Logger.new('/dev/null')
+
+ActiveRecord::Schema.define do
+  create_table :countries do |t|
+    t.column :name, :string
+    t.column :rating, :integer
+  end
+
+  create_table :cities do |t|
+    t.column :country_id, :integer
+    t.column :name, :string
+    t.column :rating, :integer
+  end
+end
+
+module ActiveRecordClassHelpers
+  extend ActiveSupport::Concern
+
+  def stub_model name, superclass = nil, &block
+    stub_class(name, superclass || ActiveRecord::Base, &block)
+  end
+
+  def active_record?
+    true
+  end
+
+  def mongoid?
+    false
+  end
+end
+
+RSpec.configure do |config|
+  config.include ActiveRecordClassHelpers
+
+  config.filter_run_excluding :mongoid
+
+  config.before(:suite) do
+    DatabaseCleaner.clean_with :truncation
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before do
+    DatabaseCleaner.start
+  end
+
+  config.after do
+    DatabaseCleaner.clean
+  end
+end

data/spec/support/class_helpers.rb

@@ -1,10 +1,6 @@
 module ClassHelpers
   extend ActiveSupport::Concern
 
-  def stub_model name, superclass = nil, &block
-    stub_class(name, superclass || ActiveRecord::Base, &block)
-  end
-
   def stub_index name, superclass = nil, &block
     stub_class("#{name.to_s.camelize}Index", superclass || Chewy::Index) { index_name = name }
       .tap { |i| i.class_eval(&block) if block }

data/spec/support/mongoid.rb

@@ -0,0 +1,87 @@
+require 'database_cleaner'
+
+CONFIG = {
+  sessions: {
+    default: {
+      uri: 'mongodb://127.0.0.1:27017/chewy_mongoid_test'
+    }
+  }
+}
+
+Mongoid.configure do |config|
+  config.load_configuration(CONFIG)
+end
+
+Mongoid.logger = Logger.new('/dev/null')
+
+module MongoidClassHelpers
+  extend ActiveSupport::Concern
+
+  def stub_model name, superclass = nil, &block
+    model = name.to_s.camelize.constantize rescue nil
+
+    if model
+      model.class_eval(&block) if block
+      model
+    else
+      klass = if superclass && superclass.ancestors.include?(Mongoid::Document)
+        superclass
+      else
+        Class.new(*([superclass].compact)) do
+          include Mongoid::Document
+          store_in collection: name.to_s.tableize
+        end
+      end
+
+      stub_class(name, klass, &block)
+    end
+  end
+
+  def active_record?
+    false
+  end
+
+  def mongoid?
+    true
+  end
+end
+
+RSpec.configure do |config|
+  config.include MongoidClassHelpers
+
+  config.filter_run_excluding :active_record
+
+  config.before(:suite) do
+    DatabaseCleaner.clean_with :truncation
+    DatabaseCleaner.strategy = :truncation
+  end
+
+  config.before do
+    Object.send(:remove_const, :City) if defined? City
+    Object.send(:remove_const, :Country) if defined? Country
+
+    class Country
+      include Mongoid::Document
+
+      field :name, type: String
+      field :rating, type: Integer
+
+      has_many :cities, order: :id.asc
+    end
+
+    class City
+      include Mongoid::Document
+
+      field :name, type: String
+      field :rating, type: Integer
+
+      belongs_to :country
+    end
+
+    DatabaseCleaner.start
+  end
+
+  config.after do
+    DatabaseCleaner.clean
+  end
+end