mongoid 8.1.5 → 9.0.0

data/spec/mongoid/scopable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -52,6 +53,37 @@ describe Mongoid::Scopable do
       end
     end
 
+    context "when a class method" do
+      let(:criteria) do
+        Band.where(name: "Depeche Mode")
+      end
+
+      before do
+        class DefaultScopeAsClassMethod
+          include Mongoid::Document
+
+          def self.default_scope
+            criteria
+          end
+        end
+      end
+
+      after do
+        Mongoid.deregister_model(DefaultScopeAsClassMethod)
+        Object.send(:remove_const, :DefaultScopeAsClassMethod)
+      end
+
+      it "adds the default scope to the class" do
+        pending 'https://jira.mongodb.org/browse/MONGOID-5483'
+        expect(DefaultScopeAsClassMethod.default_scoping.call).to eq(criteria)
+      end
+
+      it "flags as being default scoped" do
+        pending 'https://jira.mongodb.org/browse/MONGOID-5483'
+        expect(DefaultScopeAsClassMethod).to be_default_scoping
+      end
+    end
+
     context "when provided a non proc" do
 
       it "raises an error" do
@@ -311,7 +343,6 @@ describe Mongoid::Scopable do
     context "when provided a criteria" do
 
       context 'when a collation is defined on the criteria' do
-        min_server_version '3.4'
 
         before do
           Band.scope(:tests, ->{ Band.where(name: 'TESTING').collation(locale: 'en_US', strength: 2) })
@@ -323,25 +354,6 @@ describe Mongoid::Scopable do
         end
       end
 
-      context "when the lambda includes a geo_near query" do
-
-        before do
-          Bar.scope(:near_by, lambda{ |location| geo_near(location) })
-        end
-
-        after do
-          class << Bar
-            undef_method :near_by
-          end
-          Bar._declared_scopes.clear
-        end
-
-        it "allows the scope to be defined" do
-          expect(Bar.near_by([ 51.545099, -0.0106 ])).to be_a(Mongoid::Contextual::GeoNear)
-        end
-
-      end
-
       context "when a block is provided" do
 
         before do
@@ -1224,39 +1236,18 @@ describe Mongoid::Scopable do
       let(:c1) { Band.where(active: true) }
       let(:c2) { Band.where(active: false) }
 
-      context "when the broken_scoping is not set" do
-        config_override :broken_scoping, false
-
-        it 'restores previous scope' do
-          Band.with_scope(c1) do |crit|
-            Band.with_scope(c2) do |crit2|
-              Mongoid::Threaded.current_scope(Band).selector.should == {
-                'active' => true,
-                '$and' => ['active' => false],
-              }
-            end
-
+      it 'restores previous scope' do
+        Band.with_scope(c1) do |crit|
+          Band.with_scope(c2) do |crit2|
             Mongoid::Threaded.current_scope(Band).selector.should == {
               'active' => true,
+              '$and' => ['active' => false],
             }
           end
-        end
-      end
-
-      context "when the broken_scoping is set" do
-        config_override :broken_scoping, true
-
-        it 'does not restore previous scope' do
-          Band.with_scope(c1) do |crit|
-            Band.with_scope(c2) do |crit2|
-              Mongoid::Threaded.current_scope(Band).selector.should == {
-                'active' => true,
-                '$and' => ['active' => false],
-              }
-            end
 
-            Mongoid::Threaded.current_scope(Band).should be_nil
-          end
+          Mongoid::Threaded.current_scope(Band).selector.should == {
+            'active' => true,
+          }
         end
       end
     end
@@ -1265,8 +1256,6 @@ describe Mongoid::Scopable do
       let(:c1) { Band.where(active: true) }
 
       it 'restores previous scope' do
-        pending 'MONGOID-5214'
-
         Band.with_scope(c1) do |crit|
           Band.unscoped do |crit2|
             Mongoid::Threaded.current_scope(Band).should be nil

data/spec/mongoid/search_indexable_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class SearchIndexHelper
+  attr_reader :model
+
+  def initialize(model)
+    @model = model
+    model.collection.drop
+    model.collection.create
+  end
+
+  def collection
+    model.collection
+  end
+
+  # Wait for all of the indexes with the given names to be ready; then return
+  # the list of index definitions corresponding to those names.
+  def wait_for(*names, &condition)
+    names.flatten!
+
+    timeboxed_wait do
+      result = collection.search_indexes
+      return filter_results(result, names) if names.all? { |name| ready?(result, name, &condition) }
+    end
+  end
+
+  # Wait until all of the indexes with the given names are absent from the
+  # search index list.
+  def wait_for_absense_of(*names)
+    names.flatten.each do |name|
+      timeboxed_wait do
+        break if collection.search_indexes(name: name).empty?
+      end
+    end
+  end
+
+  private
+
+  def timeboxed_wait(step: 5, max: 300)
+    start = Mongo::Utils.monotonic_time
+
+    loop do
+      yield
+
+      sleep step
+      raise Timeout::Error, 'wait took too long' if Mongo::Utils.monotonic_time - start > max
+    end
+  end
+
+  # Returns true if the list of search indexes includes one with the given name,
+  # which is ready to be queried.
+  def ready?(list, name, &condition)
+    condition ||= ->(index) { index['queryable'] }
+    list.any? { |index| index['name'] == name && condition[index] }
+  end
+
+  def filter_results(result, names)
+    result.select { |index| names.include?(index['name']) }
+  end
+end
+
+# rubocop:disable RSpec/MultipleMemoizedHelpers
+describe Mongoid::SearchIndexable do
+  before do
+    skip "#{described_class} requires at Atlas environment (set ATLAS_URI)" if ENV['ATLAS_URI'].nil?
+  end
+
+  let(:model) do
+    Class.new do
+      include Mongoid::Document
+      store_in collection: BSON::ObjectId.new.to_s
+
+      search_index mappings: { dynamic: false }
+      search_index :with_dynamic_mappings, mappings: { dynamic: true }
+    end
+  end
+
+  let(:helper) { SearchIndexHelper.new(model) }
+
+  describe '.search_index_specs' do
+    context 'when no search indexes have been defined' do
+      it 'has no search index specs' do
+        expect(Person.search_index_specs).to be_empty
+      end
+    end
+
+    context 'when search indexes have been defined' do
+      it 'has search index specs' do
+        expect(model.search_index_specs).to be == [
+          { definition: { mappings: { dynamic: false } } },
+          { name: 'with_dynamic_mappings', definition: { mappings: { dynamic: true } } }
+        ]
+      end
+    end
+  end
+
+  context 'when needing to first create search indexes' do
+    let(:requested_definitions) { model.search_index_specs.map { |spec| spec[:definition].with_indifferent_access } }
+    let(:index_names) { model.create_search_indexes }
+    let(:actual_indexes) { helper.wait_for(*index_names) }
+    let(:actual_definitions) { actual_indexes.map { |i| i['latestDefinition'] } }
+
+    describe '.create_search_indexes' do
+      it 'creates the indexes' do
+        expect(actual_definitions).to be == requested_definitions
+      end
+    end
+
+    describe '.search_indexes' do
+      before { actual_indexes } # wait for the indices to be created
+
+      let(:queried_definitions) { model.search_indexes.map { |i| i['latestDefinition'] } }
+
+      it 'queries the available search indexes' do
+        expect(queried_definitions).to be == requested_definitions
+      end
+    end
+
+    describe '.remove_search_index' do
+      let(:target_index) { actual_indexes.first }
+
+      before do
+        model.remove_search_index id: target_index['id']
+        helper.wait_for_absense_of target_index['name']
+      end
+
+      it 'removes the requested index' do
+        expect(model.search_indexes(id: target_index['id'])).to be_empty
+      end
+    end
+
+    describe '.remove_search_indexes' do
+      before do
+        actual_indexes # wait for the indexes to be created
+        model.remove_search_indexes
+        helper.wait_for_absense_of(actual_indexes.map { |i| i['name'] })
+      end
+
+      it 'removes the indexes' do
+        expect(model.search_indexes).to be_empty
+      end
+    end
+  end
+end
+# rubocop:enable RSpec/MultipleMemoizedHelpers

data/spec/mongoid/selectable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/serializable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/shardable_models.rb

@@ -1,3 +1,4 @@
+# rubocop:todo all
 class SmMovie
   include Mongoid::Document
 

data/spec/mongoid/shardable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 require_relative './shardable_models'

data/spec/mongoid/stateful_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/tasks/database_rake_spec.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "rake"
 require "spec_helper"
-
-unless defined?(Rails)
-  module Rails
-  end
-end
+require "support/feature_sandbox"
 
 shared_context "rake task" do
   let(:task_name) { self.class.top_level_description }
@@ -14,9 +11,7 @@ shared_context "rake task" do
   let(:task_file) { "mongoid/tasks/database" }
 
   let(:logger) do
-    double("logger").tap do |log|
-      allow(log).to receive(:info)
-    end
+    Logger.new(STDOUT, level: :error, formatter: ->(_sev, _dt, _prog, msg) { msg })
   end
 
   before do
@@ -36,6 +31,34 @@ shared_context "rake task" do
     end
   end
 
+  shared_examples_for 'create_search_indexes' do
+    [ nil, *%w( 1 true yes on ) ].each do |truthy|
+      context "when WAIT_FOR_SEARCH_INDEXES is #{truthy.inspect}" do
+        local_env 'WAIT_FOR_SEARCH_INDEXES' => truthy
+
+        it 'receives create_search_indexes with wait: true' do
+          expect(Mongoid::Tasks::Database)
+            .to receive(:create_search_indexes)
+            .with(wait: true)
+          task.invoke
+        end
+      end
+    end
+
+    %w( 0 false no off bogus ).each do |falsey|
+      context "when WAIT_FOR_SEARCH_INDEXES is #{falsey.inspect}" do
+        local_env 'WAIT_FOR_SEARCH_INDEXES' => falsey
+
+        it 'receives create_search_indexes with wait: false' do
+          expect(Mongoid::Tasks::Database)
+            .to receive(:create_search_indexes)
+            .with(wait: false)
+          task.invoke
+        end
+      end
+    end
+  end
+
   shared_examples_for "create_collections" do
 
     it "receives create_collections" do
@@ -56,10 +79,11 @@ end
 shared_context "rails rake task" do
   let(:task_file) { "mongoid/railties/database" }
 
-  let(:application) do
-    app = double("application")
-    allow(app).to receive(:eager_load!)
-    app
+  around do |example|
+    FeatureSandbox.quarantine do
+      require "support/rails_mock"
+      example.run
+    end
   end
 end
 
@@ -98,7 +122,6 @@ describe "db:seed" do
   end
 
   it "works" do
-    expect(Rails).to receive(:root).and_return(".")
     task.invoke
   end
 end
@@ -123,19 +146,11 @@ describe "db:setup" do
     expect(task.prerequisites).to include("db:seed")
   end
 
-  it_behaves_like "create_indexes" do
-
-    before do
-      expect(Rails).to receive(:root).and_return(".")
-      expect(Rails).to receive(:application).and_return(application)
-    end
-  end
+  it_behaves_like "create_indexes"
 
   it "works" do
     expect(Mongoid::Tasks::Database).to receive(:create_indexes)
     expect(Mongoid::Tasks::Database).to receive(:create_collections)
-    expect(Rails).to receive(:root).and_return(".")
-    expect(Rails).to receive(:application).and_return(application)
     task.invoke
   end
 end
@@ -153,7 +168,6 @@ describe "db:reset" do
   end
 
   it "works" do
-    expect(Rails).to receive(:root).and_return(".")
     task.invoke
   end
 end
@@ -180,11 +194,7 @@ describe "db:test:prepare" do
   include_context "rake task"
   include_context "rails rake task"
 
-  it_behaves_like "create_indexes" do
-    before do
-      expect(Rails).to receive(:application).and_return(application)
-    end
-  end
+  it_behaves_like "create_indexes"
 
   it "calls mongoid:create_indexes" do
     expect(task.prerequisites).to include("mongoid:create_indexes")
@@ -195,7 +205,6 @@ describe "db:test:prepare" do
   end
 
   it "works" do
-    expect(Rails).to receive(:application).and_return(application)
     expect(Mongoid::Tasks::Database).to receive(:create_indexes)
     expect(Mongoid::Tasks::Database).to receive(:create_collections)
     task.invoke
@@ -218,14 +227,30 @@ describe "db:mongoid:create_indexes" do
   context "when using rails task" do
     include_context "rails rake task"
 
-    before do
-      expect(Rails).to receive(:application).and_return(application)
-    end
-
     it_behaves_like "create_indexes"
   end
 end
 
+describe 'db:mongoid:create_search_indexes' do
+  include_context 'rake task'
+
+  it_behaves_like 'create_search_indexes'
+
+  it 'calls load_models' do
+    expect(task.prerequisites).to include('load_models')
+  end
+
+  it 'calls environment' do
+    expect(task.prerequisites).to include('environment')
+  end
+
+  context 'when using rails task' do
+    include_context 'rails rake task'
+
+    it_behaves_like 'create_search_indexes'
+  end
+end
+
 describe "db:mongoid:create_collections" do
   include_context "rake task"
 
@@ -242,10 +267,6 @@ describe "db:mongoid:create_collections" do
   context "when using rails task" do
     include_context "rails rake task"
 
-    before do
-      expect(Rails).to receive(:application).and_return(application)
-    end
-
     it_behaves_like "create_collections"
   end
 end
@@ -266,10 +287,6 @@ describe "db:mongoid:create_collections:force" do
   context "when using rails task" do
     include_context "rails rake task"
 
-    before do
-      expect(Rails).to receive(:application).and_return(application)
-    end
-
     it_behaves_like "force create_collections"
   end
 end
@@ -289,10 +306,6 @@ describe "db:mongoid:remove_undefined_indexes" do
   context "when using rails task" do
     include_context "rails rake task"
 
-    before do
-      expect(Rails).to receive(:application).and_return(application)
-    end
-
     it "receives remove_undefined_indexes" do
       expect(Mongoid::Tasks::Database).to receive(:remove_undefined_indexes)
       task.invoke
@@ -315,10 +328,6 @@ describe "db:mongoid:remove_indexes" do
   context "when using rails task" do
     include_context "rails rake task"
 
-    before do
-      expect(Rails).to receive(:application).and_return(application)
-    end
-
     it "receives remove_indexes" do
       expect(Mongoid::Tasks::Database).to receive(:remove_indexes)
       task.invoke
@@ -326,6 +335,28 @@ describe "db:mongoid:remove_indexes" do
   end
 end
 
+describe 'db:mongoid:remove_search_indexes' do
+  include_context 'rake task'
+
+  it 'receives remove_search_indexes' do
+    expect(Mongoid::Tasks::Database).to receive(:remove_search_indexes)
+    task.invoke
+  end
+
+  it 'calls environment' do
+    expect(task.prerequisites).to include('environment')
+  end
+
+  context 'when using rails task' do
+    include_context 'rails rake task'
+
+    it 'receives remove_search_indexes' do
+      expect(Mongoid::Tasks::Database).to receive(:remove_search_indexes)
+      task.invoke
+    end
+  end
+end
+
 describe "db:mongoid:drop" do
   include_context "rake task"
 
@@ -359,3 +390,50 @@ describe "db:mongoid:purge" do
     end
   end
 end
+
+describe "db:mongoid:encryption:create_data_key" do
+  require_enterprise
+  require_libmongocrypt
+  include_context 'with encryption'
+  restore_config_clients
+  include_context "rake task"
+
+  let(:task_file) { "mongoid/tasks/encryption" }
+
+  let(:config) do
+    {
+      default: {
+        hosts: SpecConfig.instance.addresses,
+        database: database_id,
+        options: {
+          auto_encryption_options: {
+            kms_providers: kms_providers,
+            key_vault_namespace: key_vault_namespace,
+            extra_options: extra_options
+          }
+        }
+      }
+    }
+  end
+
+  before do
+    Mongoid::Config.send(:clients=, config)
+
+    expect_any_instance_of(Mongo::ClientEncryption)
+      .to receive(:create_data_key)
+      .with('local', {})
+      .and_call_original
+  end
+
+  it "creates the key" do
+    task.invoke
+  end
+
+  context "when using rails task" do
+    include_context "rails rake task"
+
+    it "creates the key" do
+      task.invoke
+    end
+  end
+end

data/spec/mongoid/tasks/database_spec.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
-describe "Mongoid::Tasks::Database" do
+describe Mongoid::Tasks::Database do
 
   before(:all) do
     module DatabaseSpec
@@ -212,6 +213,52 @@ describe "Mongoid::Tasks::Database" do
     end
   end
 
+  describe '.create_search_indexes' do
+    let(:searchable_model) do
+      Class.new do
+        include Mongoid::Document
+        store_in collection: BSON::ObjectId.new.to_s
+
+        search_index mappings: { dynamic: true }
+      end
+    end
+
+    let(:index_names) { %w[ name1 name2 ] }
+    let(:searchable_model_spy) do
+      class_spy(searchable_model,
+                create_search_indexes: index_names,
+                search_index_specs: [ { mappings: { dynamic: true } } ])
+    end
+
+    context 'when wait is true' do
+      it 'invokes both create_search_indexes and wait_for_search_indexes' do
+        expect(searchable_model_spy).to receive(:create_search_indexes)
+        expect(described_class).to receive(:wait_for_search_indexes).with({ searchable_model_spy => index_names })
+
+        described_class.create_search_indexes([searchable_model_spy], wait: true)
+      end
+    end
+
+    context 'when wait is false' do
+      it 'invokes only create_search_indexes' do
+        expect(searchable_model_spy).to receive(:create_search_indexes)
+        expect(described_class).to_not receive(:wait_for_search_indexes)
+
+        described_class.create_search_indexes([searchable_model_spy], wait: false)
+      end
+    end
+  end
+
+  describe '.remove_search_indexes' do
+    it 'calls remove_search_indexes on all non-embedded models' do
+      models.each do |model|
+        expect(model).to receive(:remove_search_indexes) unless model.embedded?
+      end
+
+      described_class.remove_search_indexes(models)
+    end
+  end
+
   describe ".undefined_indexes" do
 
     before(:each) do