mongoid 8.1.6 → 9.0.0

data/spec/mongoid/indexable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -234,6 +235,10 @@ describe Mongoid::Indexable do
 
         field :a, as: :authentication_token
         field :username
+
+        alias_attribute :u, :username
+
+        embeds_many :addresses, store_as: :adrs
       end
     end
 
@@ -256,6 +261,21 @@ describe Mongoid::Indexable do
       end
     end
 
+    context "when indexing a field that is embedded" do
+
+      before do
+        klass.index({ 'addresses.house' => 1 }, unique: true)
+      end
+
+      let(:options) do
+        klass.index_specification('adrs.h': 1).options
+      end
+
+      it "sets the index with unique options" do
+        expect(options).to eq(unique: true)
+      end
+    end
+
     context "when providing unique options" do
 
       before do
@@ -597,22 +617,316 @@ describe Mongoid::Indexable do
       end
     end
 
-    context "when using a wildcard index" do
+    context "when using partial_filter_expression option" do
 
-      before do
-        klass.index({ '$**': 1 }, wildcard_projection: { _id: 1, username: 0 })
+      context 'when not using an alias' do
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: { username: { '$exists' => true } })
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(partial_filter_expression: { username: { '$exists' => true } })
+        end
       end
 
-      let(:spec) do
-        klass.index_specification('$**': 1)
+      context 'when using an alias via field :as option' do
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: { authentication_token: { '$exists' => true } })
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(partial_filter_expression: { a: { '$exists' => true } })
+        end
+      end
+
+      context 'when using an alias via alias_attribute' do
+
+        before do
+          klass.index({ u: 1 }, partial_filter_expression: { u: { '$exists' => true } })
+        end
+
+        let(:options) do
+          klass.index_specification(username: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(partial_filter_expression: { username: { '$exists' => true } })
+        end
+      end
+
+      context 'when using an embedded field' do
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: { 'addresses.house' => { '$exists' => true } })
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(partial_filter_expression: { 'adrs.h': { '$exists' => true } })
+        end
+      end
+
+      context 'when using nested $and operator' do
+        let(:partial_filter_expression) do
+          {
+            '$and' => [
+              { 'authentication_token' => { '$gte' => 0 } },
+              { 'authentication_token' => { '$type' => 16 } }
+            ]
+          }
+        end
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: partial_filter_expression)
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        let(:expected) do
+          {
+            '$and': [
+              { 'a': { '$gte' => 0 } },
+              { 'a': { '$type' => 16 } }
+            ]
+          }
+        end
+
+        it "resolves alias on $and option" do
+          expect(options[:partial_filter_expression]).to eq(expected)
+        end
+      end
+
+      context 'when using nested operators other than $and' do
+        let(:partial_filter_expression) do
+          {
+            'username' => { '$eq' => 'authentication_token' },
+            'addresses.house' => { '$exists' => true }
+          }
+        end
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: partial_filter_expression)
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        let(:expected) do
+          {
+            username: { '$eq' => 'authentication_token' },
+            'adrs.h': { '$exists' => true }
+          }
+        end
+
+        it "preserves other operators" do
+          expect(options[:partial_filter_expression]).to eq(expected)
+        end
+      end
+
+      context 'when using mixed nested operators' do
+        let(:partial_filter_expression) do
+          {
+            'username' => { '$eq' => 'authentication_token' },
+            'addresses.house' => { '$exists' => true },
+            '$and' => [
+              { 'authentication_token' => { '$gte' => 0 } },
+              { 'authentication_token' => { '$type' => 16 } }
+            ]
+          }
+        end
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: partial_filter_expression)
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        let(:expected) do
+          {
+            username: { '$eq' => 'authentication_token' },
+            'adrs.h': { '$exists' => true },
+            '$and': [
+              { 'a': { '$gte' => 0 } },
+              { 'a': { '$type' => 16 } }
+            ]
+          }
+        end
+
+        it "resolves aliases on $ operators" do
+          expect(options[:partial_filter_expression]).to eq(expected)
+        end
       end
 
-      it "creates the index" do
-        expect(spec).to be_a(Mongoid::Indexable::Specification)
+      context 'when using multiple levels of nonsensical nested operators' do
+        let(:partial_filter_expression) do
+          {
+            '$foo' => {
+              '$eq' => [{
+                '$bar' => {
+                  '$and' => [
+                    { 'authentication_token' => { '$gte' => { 'aliased_timestamp' => 16 } } },
+                    { 'authentication_token' => { 'aliased_timestamp' => 16 } },
+                    { 'addresses.house' => { 'authentication_token' => [{ 'aliased_timestamp' => 16 }] } }
+                  ]
+                }
+              }]
+            }
+          }
+        end
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: partial_filter_expression)
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        let(:expected) do
+          {
+            '$foo': {
+              '$eq': [{
+                '$bar': {
+                  '$and': [
+                    { a: { '$gte' => { 'aliased_timestamp' => 16 } } },
+                    { a: { 'aliased_timestamp' => 16 } },
+                    { 'adrs.h': { 'authentication_token' => [{ 'aliased_timestamp' => 16 }] } }
+                  ]
+                }
+              }]
+            }
+          }
+        end
+
+        it "resolves aliases recursively only on $ operators" do
+          expect(options[:partial_filter_expression]).to eq(expected)
+        end
       end
+    end
+
+    context "when using weights option" do
+
+      context 'when not using aliases' do
+
+        before do
+          klass.index({ authentication_token: 1 }, weights: { a: 1, username: 2 })
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(weights: { a: 1, username: 2 })
+        end
+      end
+
+      context 'when using aliases via field :as option' do
+
+        before do
+          klass.index({ authentication_token: 1 }, weights: { 'addresses.house' => 1, authentication_token: 2 })
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(weights: { 'adrs.h': 1, a: 2 })
+        end
+      end
+
+      context 'when using aliases via alias_attribute' do
+
+        before do
+          klass.index({ u: 1 }, weights: { 'addresses.n' => 1, u: 2 })
+        end
 
-      it "sets the index with correct options" do
-        expect(spec.options).to eq(wildcard_projection: { _id: 1, username: 0 })
+        let(:options) do
+          klass.index_specification(username: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(weights: { 'adrs.name': 1, username: 2 })
+        end
+      end
+    end
+
+    context "when using wildcard indexes" do
+
+      context 'when not using an alias' do
+
+        before do
+          klass.index({ '$**': 1 }, wildcard_projection: { _id: 1, username: 0 })
+        end
+
+        let(:spec) do
+          klass.index_specification('$**': 1)
+        end
+
+        it "creates the index" do
+          expect(spec).to be_a(Mongoid::Indexable::Specification)
+        end
+
+        it "sets the index with correct options" do
+          expect(spec.options).to eq(wildcard_projection: { _id: 1, username: 0 })
+        end
+      end
+
+      context 'when using an alias via field :as option' do
+
+        before do
+          klass.index({ 'addresses.$**': 1 }, wildcard_projection: { 'addresses.house' => 1 })
+        end
+
+        let(:spec) do
+          klass.index_specification('adrs.$**': 1)
+        end
+
+        it "creates the index" do
+          expect(spec).to be_a(Mongoid::Indexable::Specification)
+        end
+
+        it "sets the index with correct options" do
+          expect(spec.options).to eq(wildcard_projection: { 'adrs.h': 1 })
+        end
+      end
+
+      context 'when using aliases via alias_attribute' do
+
+        before do
+          klass.index({ 'addresses.$**': 1 }, wildcard_projection: { 'addresses.n' => 1 })
+        end
+
+        let(:spec) do
+          klass.index_specification('adrs.$**': 1)
+        end
+
+        it "creates the index" do
+          expect(spec).to be_a(Mongoid::Indexable::Specification)
+        end
+
+        it "sets the index with correct options" do
+          expect(spec.options).to eq(wildcard_projection: { 'adrs.name': 1 })
+        end
       end
     end
 

data/spec/mongoid/inspectable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -83,4 +84,84 @@ describe Mongoid::Inspectable do
       end
     end
   end
+
+  describe "#pretty_inspect" do
+
+    context "when not allowing dynamic fields" do
+
+      let(:person) do
+        Person.new(title: "CEO")
+      end
+
+      let(:pretty_inspected) do
+        person.pretty_inspect
+      end
+
+      it "includes the model type" do
+        expect(pretty_inspected).to include("#<Person")
+      end
+
+      it "displays the id" do
+        expect(pretty_inspected).to include("_id: #{person.id}")
+      end
+
+      it "displays defined fields" do
+        expect(pretty_inspected).to include(%q,title: "CEO",)
+      end
+
+      it "displays field aliases" do
+        expect(pretty_inspected).to include("t(test):")
+      end
+
+      it "displays the default discriminator key" do
+        expect(pretty_inspected).to include(%q,_type: "Person",)
+      end
+    end
+
+    context "when using a custom discriminator key" do
+
+      before do
+        Person.discriminator_key = "dkey"
+      end
+
+      after do
+        Person.discriminator_key = nil
+      end
+
+      let(:person) do
+        Person.new(title: "CEO")
+      end
+
+      let(:pretty_inspected) do
+        person.pretty_inspect
+      end
+
+      it "displays the new discriminator key" do
+        expect(pretty_inspected).to include(%q,dkey: "Person",)
+      end
+    end
+
+    context "when allowing dynamic fields" do
+
+      let(:person) do
+        Person.new(title: "CEO", some_attribute: "foo")
+      end
+
+      let(:pretty_inspected) do
+        person.pretty_inspect
+      end
+
+      it "includes dynamic attributes" do
+        expect(pretty_inspected).to include(%q,some_attribute: "foo",)
+      end
+    end
+
+    context 'when id is unaliased' do
+      let(:shirt) { Shirt.new(id: 1, _id: 2) }
+
+      it 'shows the correct _id and id values' do
+        shirt.pretty_inspect.should == "#<Shirt _id: 2, color: nil, id: \"1\">\n"
+      end
+    end
+  end
 end

data/spec/mongoid/interceptable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 require_relative './interceptable_spec_models'
@@ -2560,14 +2561,14 @@ describe Mongoid::Interceptable do
   # was fixed by using `.pluck` over `.only`. Look at MONGOID-5306 for a more
   # detailed explanation.
   context "when accessing _ids in validate and access an association in after_initialize" do
-    it "doesn't raise a MissingAttributeError" do
+    it "doesn't raise AttributeNotLoaded" do
       company = InterceptableCompany.create!
       shop = InterceptableShop.create!(company: company)
       user = InterceptableUser.new
       user.company = company
       expect do
         user.save!
-      end.to_not raise_error(ActiveModel::MissingAttributeError)
+      end.to_not raise_error(Mongoid::Errors::AttributeNotLoaded)
     end
   end
 

data/spec/mongoid/interceptable_spec_models.rb

@@ -1,3 +1,4 @@
+# rubocop:todo all
 module InterceptableSpec
   class CallbackRegistry
     def initialize

data/spec/mongoid/loading_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+require "ostruct"
+require "spec_helper"
+require "support/feature_sandbox"
+
+describe Mongoid::Loadable do
+  let(:model_root) do
+    File.absolute_path(
+      File.join(
+        File.dirname(__FILE__),
+        "../support/models/sandbox"
+      ))
+  end
+
+  let(:app_models_root) { File.join(model_root, "app/models") }
+  let(:lib_models_root) { File.join(model_root, "lib/models") }
+
+  describe "#model_paths" do
+    # reset model_paths to the default value
+    before { Mongoid.model_paths = nil }
+
+    context "when Rails is defined" do
+      around do |example|
+        FeatureSandbox.quarantine do
+          require "support/rails_mock"
+          require "rails/mongoid"
+          example.run
+        end
+      end
+
+      it "should return Rails' \"app/models\" paths" do
+        expect(Mongoid.model_paths).to be == %w( app/models )
+      end
+    end
+
+    context "when Rails is not defined" do
+      it "should return Mongoid's default model paths" do
+        expect(Mongoid.model_paths).to be == %w( ./app/models ./lib/models )
+      end
+    end
+
+    context "when explicitly set" do
+      before { Mongoid.model_paths = %w( /infra/models ) }
+      
+      it "should return the given value" do
+        expect(Mongoid.model_paths).to be == %w( /infra/models )
+      end
+    end
+  end
+
+  describe "#load_models" do
+    around :each do |example|
+      FeatureSandbox.quarantine do
+        Mongoid.model_paths = nil
+        example.run
+      end
+    end
+
+    context "when using default paths" do
+      around(:each) do |example|
+        $LOAD_PATH.concat [ app_models_root, lib_models_root ]
+
+        Dir.chdir(model_root) do
+          Mongoid.load_models
+          example.run
+        end
+      end
+
+      it "should find models in the default paths" do
+        expect(defined?(AppModelsMessage)).to be == "constant"
+        expect(defined?(LibModelsMessage)).to be == "constant"
+        expect(defined?(SandboxMessage)).to be_nil
+      end
+    end
+
+    context "when using custom model_paths" do
+      before do
+        Mongoid.model_paths = [ app_models_root ]
+        $LOAD_PATH.concat [ app_models_root ]
+        Mongoid.load_models
+      end
+
+      it "should find models in the specified paths" do
+        expect(defined?(AppModelsMessage)).to be == "constant"
+        expect(defined?(LibModelsMessage)).to be_nil
+        expect(defined?(SandboxMessage)).to be_nil
+      end
+    end
+
+    context "when passing paths directly" do
+      before do
+        $LOAD_PATH.concat [ model_root ]
+        Mongoid.load_models([ model_root ])
+      end
+
+      it "should find models in the specified paths" do
+        expect(defined?(AppModelsMessage)).to be == "constant"
+        expect(defined?(LibModelsMessage)).to be == "constant"
+        expect(defined?(SandboxMessage)).to be == "constant"
+        expect(defined?(SandboxComment)).to be == "constant"
+      end
+    end
+  end
+end
+
+module Mongoid::Loadable::RailsApplication
+  attr_accessor :application
+end

data/spec/mongoid/loggable_spec.rb

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

data/spec/mongoid/matcher/extract_attribute_spec.rb

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

data/spec/mongoid/mongoizable_spec.rb

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