mongoid 7.1.11 → 7.2.0

data/spec/mongoid/criteria_spec.rb

@@ -786,12 +786,72 @@ describe Mongoid::Criteria do
 
   describe "#field_list" do
 
+    context "when using the default discriminator key" do
+      let(:criteria) do
+        Doctor.only(:_id)
+      end
+
+      it "returns the fields with required _id minus type" do
+        expect(criteria.field_list).to eq([ "_id" ])
+      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(:criteria) do
+        Doctor.only(:_id, :_type)
+      end
+
+      it "returns the fields with type without dkey" do
+        expect(criteria.field_list).to eq([ "_id", "_type" ])
+      end
+    end
+  end
+
+  describe "#find" do
+    let!(:depeche) do
+      Band.create!(name: "Depeche Mode")
+    end
+
     let(:criteria) do
-      Band.only(:name)
+      Band.where(name: "Depeche Mode")
     end
 
-    it "returns the fields with required _id minus type" do
-      expect(criteria.field_list).to eq([ "_id", "name" ])
+    context "when given a block" do
+      it "behaves as Enumerable" do
+        result = criteria.find { |c| c.name == "Depeche Mode" }
+        expect(result).to eq(depeche)
+      end
+    end
+
+    context "when given a Proc and a block" do
+      it "behaves as Enumerable" do
+        result = criteria.find(-> {"default"}) { |c| c.name == "Not Depeche Mode" }
+        expect(result).to eq("default")
+      end
+    end
+
+    context "when given a Proc" do
+      it "behaves as Enumerable" do
+        lambda do
+          criteria.find(-> {"default"})
+        # Proc is not serializable to a BSON type
+        end.should raise_error(BSON::Error::UnserializableClass)
+      end
+    end
+
+    context "when given an id" do
+      it "behaves as Findable" do
+        result = criteria.find(depeche.id)
+        expect(result).to eq(depeche)
+      end
     end
   end
 
@@ -2804,13 +2864,36 @@ describe Mongoid::Criteria do
     end
 
     context "when using inheritance" do
+      context "when using the default discriminator key" do
+        let(:criteria) do
+          Doctor.only(:_id)
+        end
 
-      let(:criteria) do
-        Doctor.only(:_id)
+        it "adds _type to the fields" do
+          expect(criteria.options[:fields]).to include("_type")
+        end
       end
 
-      it "adds _type to the fields" do
-        expect(criteria.options[:fields]["_type"]).to eq(1)
+      context "when setting a custom discriminator key" do
+        before do
+          Person.discriminator_key = "dkey"
+        end
+
+        after do
+          Person.discriminator_key = nil
+        end
+
+        let(:criteria) do
+          Doctor.only(:_id)
+        end
+
+        it "adds custom discriminator key to the fields" do
+          expect(criteria.options[:fields]).to include("dkey")
+        end
+
+        it "does not add _type to the fields" do
+          expect(criteria.options[:fields]).to_not include("_type")
+        end
       end
     end
 
@@ -3386,34 +3469,75 @@ describe Mongoid::Criteria do
   end
 
   describe "#type" do
+    context "when using the default discriminator_key" do
+      context "when the type is a string" do
 
-    context "when the type is a string" do
+        let!(:browser) do
+          Browser.create
+        end
 
-      let!(:browser) do
-        Browser.create
-      end
+        let(:criteria) do
+          Canvas.all.type("Browser")
+        end
 
-      let(:criteria) do
-        Canvas.all.type("Browser")
+        it "returns documents with the provided type" do
+          expect(criteria).to eq([ browser ])
+        end
       end
 
-      it "returns documents with the provided type" do
-        expect(criteria).to eq([ browser ])
+      context "when the type is an Array of type" do
+
+        let!(:browser) do
+          Firefox.create
+        end
+
+        let(:criteria) do
+          Canvas.all.type([ "Browser", "Firefox" ])
+        end
+
+        it "returns documents with the provided types" do
+          expect(criteria).to eq([ browser ])
+        end
       end
     end
 
-    context "when the type is an Array of type" do
+    context "when using a custom discriminator_key" do
+      before do
+        Canvas.discriminator_key = "dkey"
+      end
 
-      let!(:browser) do
-        Firefox.create
+      after do
+        Canvas.discriminator_key = nil
       end
 
-      let(:criteria) do
-        Canvas.all.type([ "Browser", "Firefox" ])
+      context "when the type is a string" do
+
+        let!(:browser) do
+          Browser.create
+        end
+
+        let(:criteria) do
+          Canvas.all.type("Browser")
+        end
+
+        it "returns documents with the provided type" do
+          expect(criteria).to eq([ browser ])
+        end
       end
 
-      it "returns documents with the provided types" do
-        expect(criteria).to eq([ browser ])
+      context "when the type is an Array of type" do
+
+        let!(:browser) do
+          Firefox.create
+        end
+
+        let(:criteria) do
+          Canvas.all.type([ "Browser", "Firefox" ])
+        end
+
+        it "returns documents with the provided types" do
+          expect(criteria).to eq([ browser ])
+        end
       end
     end
   end
@@ -3645,14 +3769,10 @@ describe Mongoid::Criteria do
 
       before do
         expect(Person).to receive(:minor).and_call_original
-        expect(Person).to receive(:older_than).and_call_original
       end
 
       it "calls the method on the class" do
         expect(criteria.minor).to be_empty
-        expect do
-          criteria.older_than(age: 25)
-        end.not_to raise_error
       end
     end
 
@@ -3739,7 +3859,7 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#geo_spacial" do
+  describe "#geo_spatial" do
 
     context "when checking within a polygon" do
 
@@ -3752,7 +3872,7 @@ describe Mongoid::Criteria do
       end
 
       let(:criteria) do
-        Bar.geo_spacial(
+        Bar.geo_spatial(
           :location.within_polygon => [[[ 50, 10 ], [ 50, 20 ], [ 60, 20 ], [ 60, 10 ], [ 50, 10 ]]]
         )
       end
@@ -3836,34 +3956,75 @@ describe Mongoid::Criteria do
   end
 
   describe "#type_selection" do
+    context "when using the default discriminator_key" do
+      context "when only one subclass exists" do
 
-    context "when only one subclass exists" do
+        let(:criteria) do
+          described_class.new(Firefox)
+        end
 
-      let(:criteria) do
-        described_class.new(Firefox)
-      end
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
 
-      let(:selection) do
-        criteria.send(:type_selection)
+        it "does not use an $in query" do
+          expect(selection).to eq({ _type: "Firefox" })
+        end
       end
 
-      it "does not use an $in query" do
-        expect(selection).to eq({ _type: "Firefox" })
+      context "when more than one subclass exists" do
+
+        let(:criteria) do
+          described_class.new(Browser)
+        end
+
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
+
+        it "does not use an $in query" do
+          expect(selection).to eq({ _type: { "$in" => [ "Firefox", "Browser" ]}})
+        end
       end
     end
 
-    context "when more than one subclass exists" do
+    context "when using a custom discriminator_key" do
+      before do
+        Canvas.discriminator_key = "dkey"
+      end
 
-      let(:criteria) do
-        described_class.new(Browser)
+      after do
+        Canvas.discriminator_key = nil
       end
 
-      let(:selection) do
-        criteria.send(:type_selection)
+      context "when only one subclass exists" do
+
+        let(:criteria) do
+          described_class.new(Firefox)
+        end
+
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
+
+        it "does not use an $in query" do
+          expect(selection).to eq({ dkey: "Firefox" })
+        end
       end
 
-      it "does not use an $in query" do
-        expect(selection).to eq({ _type: { "$in" => [ "Firefox", "Browser" ]}})
+      context "when more than one subclass exists" do
+
+        let(:criteria) do
+          described_class.new(Browser)
+        end
+
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
+
+        it "does not use an $in query" do
+          expect(selection).to eq({ dkey: { "$in" => [ "Firefox", "Browser" ]}})
+        end
       end
     end
   end

data/spec/mongoid/document_query_spec.rb

@@ -36,55 +36,4 @@ describe Mongoid::Document do
       expect(_person.age).to be 42
     end
   end
-
-  context 'when projecting with #without' do
-    before do
-      duck = Pet.new(name: 'Duck')
-      Person.create!(username: 'Dev', title: 'CEO', pet: duck)
-    end
-
-    let(:person) { Person.where(username: 'Dev').without(:title).first }
-
-      it 'allows access to attribute of embedded document' do
-      expect(person.pet.name).to eq 'Duck'
-    end
-
-    context 'when exclusion starts with association name but is not the association' do
-
-      let(:person) { Person.where(username: 'Dev').without(:pet_).first }
-
-      it 'allows access to attribute of embedded document' do
-        expect(person.pet.name).to eq 'Duck'
-      end
-    end
-
-    context 'when exclusion starts with prefix of association name' do
-
-      let(:person) { Person.where(username: 'Dev').without(:pe).first }
-
-      it 'allows access to attribute of embedded document' do
-        expect(person.pet.name).to eq 'Duck'
-      end
-    end
-
-    context 'when another attribute of the association is excluded' do
-
-      let(:person) { Person.where(username: 'Dev').without('pet.weight').first }
-
-      it 'allows access to non-excluded attribute of embedded document' do
-        expect(person.pet.name).to eq 'Duck'
-      end
-    end
-
-    context 'when the excluded attribute of the association is retrieved' do
-
-      let(:person) { Person.where(username: 'Dev').without('pet.name').first }
-
-      it 'prohibits the retrieval' do
-        lambda do
-          person.pet.name
-        end.should raise_error(ActiveModel::MissingAttributeError)
-      end
-    end
-  end
 end

data/spec/mongoid/document_spec.rb

@@ -116,7 +116,50 @@ describe Mongoid::Document do
       end
 
       it "should clear descendants' cache" do
-        expect(Person._types).to include(descendant.to_s)
+        expect(Person._types).to include(descendant.discriminator_value)
+      end
+    end
+  end
+
+  describe "._mongoid_clear_types" do
+
+    context "when changing the discriminator_value" do
+      
+      before do 
+        Kangaroo._types
+        Kangaroo.discriminator_value = "dvalue"
+      end
+
+      after do 
+        Kangaroo.discriminator_value = nil
+      end
+
+      it "has the correct _types" do
+        expect(Kangaroo._types).to eq(["dvalue"])
+      end
+    end
+
+    context "when changing the discriminator_value in child" do
+      
+      before do 
+        Shape._types
+        Circle.discriminator_value = "dvalue"
+      end
+
+      after do 
+        Circle.discriminator_value = nil
+      end
+
+      it "has the correct _types" do
+        expect(Circle._types).to eq(["dvalue"])
+      end
+
+      it "has the new Circle discriminator value" do
+        expect(Shape._types).to include("dvalue")
+      end
+
+      it "doesn't have the old Circle discriminator value" do
+        expect(Shape._types).to_not include("Cirlce")
       end
     end
   end
@@ -458,7 +501,7 @@ describe Mongoid::Document do
       end
     end
 
-    context 'deprecated :compact option' do
+    context ':compact option' do
       # Since rails 6 differs in how it treats id fields,
       # run this test on one version of rails. Currently rails 6 is in beta,
       # when it is released this version should be changed to 6.
@@ -470,26 +513,6 @@ describe Mongoid::Document do
         expect(church.as_json.keys.sort).to eq(%w(_id location name))
       end
 
-      context 'deprecation' do
-        let(:church) do
-          Church.create!(name: 'St. Basil')
-        end
-
-        let(:message) do
-          '#as_json :compact option is deprecated. Please call #compact on the returned Hash object instead.'
-        end
-
-        it 'logs a deprecation warning when :compact is given' do
-          expect_any_instance_of(Logger).to receive(:warn).with(message)
-          church.as_json(compact: true)
-        end
-
-        it 'does not log a deprecation warning when :compact is not given' do
-          expect_any_instance_of(Logger).to_not receive(:warn).with(message)
-          church.as_json
-        end
-      end
-
       context 'there is a nil valued attribute' do
         let(:church) do
           Church.create!(name: 'St. Basil')
@@ -901,27 +924,58 @@ describe Mongoid::Document do
       end
 
       context "when no embedded documents are present" do
+        context "when using the default discriminator key" do 
+          let(:person) do
+            manager.becomes(Person)
+          end
 
-        let(:person) do
-          manager.becomes(Person)
-        end
+          it "copies attributes" do
+            expect(person.title).to eq('Sir')
+          end
 
-        it "copies attributes" do
-          expect(person.title).to eq('Sir')
-        end
+          it "keeps the same object id" do
+            expect(person.id).to eq(manager.id)
+          end
 
-        it "keeps the same object id" do
-          expect(person.id).to eq(manager.id)
+          it "sets the class type" do
+            expect(person._type).to eq("Person")
+          end
+
+          it "raises an error when inappropriate class is provided" do
+            expect {
+              manager.becomes(String)
+            }.to raise_error(ArgumentError, /A class which includes Mongoid::Document is expected/)
+          end
         end
 
-        it "sets the class type" do
-          expect(person._type).to eq("Person")
+        context "when using a custom discriminator key" do 
+          before do 
+            Person.discriminator_key = "dkey"
+          end
+
+          after do 
+            Person.discriminator_key = nil
+          end
+
+          it "sets the class type with new discriminator key" do
+            expect(person.dkey).to eq("Person")
+          end
         end
 
-        it "raises an error when inappropriate class is provided" do
-          expect {
-            manager.becomes(String)
-          }.to raise_error(ArgumentError)
+        context "when using a custom discriminator key and discriminator value" do 
+          before do 
+            Person.discriminator_key = "dkey"
+            Person.discriminator_value = "dvalue"
+          end
+
+          after do 
+            Person.discriminator_key = nil
+            Person.discriminator_value = nil
+          end
+
+          it "sets the class type with new discriminator key" do
+            expect(person.dkey).to eq("dvalue")
+          end
         end
       end
 

data/spec/mongoid/equality_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
-# -*- coding: utf-8 -*-
 require "spec_helper"
 
 describe Mongoid::Equality do

data/spec/mongoid/errors/delete_restriction_spec.rb

@@ -19,7 +19,7 @@ describe Mongoid::Errors::DeleteRestriction do
 
     it "contains the summary in the message" do
       expect(error.message).to include(
-        "When defining 'drugs' with a :dependent => :restrict,"
+        "When defining 'drugs' with a :dependent => :restrict_with_error,"
       )
     end
 

data/spec/mongoid/errors/mongoid_error_spec.rb

@@ -10,26 +10,14 @@ describe Mongoid::Errors::MongoidError do
   let(:options) { {} }
 
   before do
-    if RUBY_VERSION.start_with?('3.', '2.7')
-      {"message_title" => "message", "summary_title" => "summary", "resolution_title" => "resolution"}.each do |key, name|
-        expect(::I18n).to receive(:translate).with("mongoid.errors.messages.#{key}", **{}).and_return(name)
-      end
-
-      ["message", "summary", "resolution"].each do |name|
-        expect(::I18n).to receive(:translate).
-          with("mongoid.errors.messages.#{key}.#{name}", **{}).
-          and_return(name)
-      end
-    else
-      {"message_title" => "message", "summary_title" => "summary", "resolution_title" => "resolution"}.each do |key, name|
-        expect(::I18n).to receive(:translate).with("mongoid.errors.messages.#{key}", {}).and_return(name)
-      end
-
-      ["message", "summary", "resolution"].each do |name|
-        expect(::I18n).to receive(:translate).
-          with("mongoid.errors.messages.#{key}.#{name}", {}).
-          and_return(name)
-      end
+    {"message_title" => "message", "summary_title" => "summary", "resolution_title" => "resolution"}.each do |key, name|
+      expect(::I18n).to receive(:translate).with("mongoid.errors.messages.#{key}", {}).and_return(name)
+    end
+
+    ["message", "summary", "resolution"].each do |name|
+      expect(::I18n).to receive(:translate).
+        with("mongoid.errors.messages.#{key}.#{name}", {}).
+      and_return(name)
     end
 
     error.compose_message(key, options)

data/spec/mongoid/extensions/stringified_symbol_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::StringifiedSymbol do
+
+  describe ".demongoize" do
+
+    context "when the object is not a symbol" do
+
+      it "returns the symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize("test")).to eq(:test)
+      end
+    end
+
+    context "when the object is a symbol" do
+
+      it "returns the symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize(:test)).to eq(:test)
+      end
+    end
+
+    context "when the object is a BSON Symbol" do
+
+      it "returns a symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize(BSON::Symbol::Raw.new(:test))).to eq(:test)
+      end
+    end
+
+
+    context "when the object is an integer" do
+
+      it "returns a symbol" do
+        expect(Mongoid::StringifiedSymbol.demongoize(14)).to eq(:"14")
+      end
+    end
+
+    context "when the object is nil" do
+
+      it "returns nil" do
+        expect(Mongoid::StringifiedSymbol.demongoize(nil)).to be_nil
+      end
+    end
+  end
+
+  describe ".mongoize" do
+
+    context "when the object is not a symbol" do
+
+      it "returns the object" do
+        expect(Mongoid::StringifiedSymbol.mongoize("test")).to eq("test")
+      end
+
+      it "returns the string" do
+        expect(Mongoid::StringifiedSymbol.mongoize([0,1,2])).to eq("[0, 1, 2]")
+      end
+
+      it "returns the string" do
+        expect(Mongoid::StringifiedSymbol.mongoize(2)).to eq("2")
+      end
+    end
+
+    context "when the object is a symbol" do
+
+      it "returns a string" do
+        expect(Mongoid::StringifiedSymbol.mongoize(:test)).to eq("test")
+      end
+    end
+
+    context "when the object is nil" do
+
+      it "returns nil" do
+        expect(Mongoid::StringifiedSymbol.mongoize(nil)).to be_nil
+      end
+    end
+  end
+
+  describe "#mongoize" do
+
+    it "returns self" do
+      expect(:test.mongoize).to eq(:test)
+    end
+  end
+end