mongoid 7.5.4 → 8.1.9

data/spec/mongoid/document_fields_spec.rb

@@ -40,20 +40,167 @@ describe Mongoid::Document do
       end
 
       it 'assigns as a BSON::Binary object' do
-        pending 'https://jira.mongodb.org/browse/MONGOID-4823'
-
         registry.data.should be_a(BSON::Binary)
       end
 
       it 'persists' do
-        pending 'https://jira.mongodb.org/browse/MONGOID-4823'
-
         registry.save!
 
         _registry = Registry.find(registry.id)
         _registry.data.should == BSON::Binary.new(data)
       end
     end
+
+    context 'when assigned nil' do
+      let(:data) do
+        nil
+      end
+
+      let(:registry) do
+        Registry.new(data: data)
+      end
+
+      it 'assigns nil' do
+        registry.data.should be nil
+      end
+
+      it 'persists' do
+        registry.save!
+
+        _registry = Registry.find(registry.id)
+        _registry.data.should be nil
+      end
+    end
+
+    context 'when assigned an invalid type' do
+      let(:data) do
+        true
+      end
+
+      let(:registry) do
+        Registry.new(data: data)
+      end
+
+      it 'assigns nil' do
+        registry.data.should be nil
+      end
+
+      it 'persists' do
+        registry.save!
+
+        _registry = Registry.find(registry.id)
+        _registry.data.should be nil
+      end
+    end
+  end
+
+  describe 'BSON::ObjectId field' do
+    context 'when assigned a BSON::ObjectId instance' do
+      let(:obj_id) do
+        BSON::ObjectId.new
+      end
+
+      let(:registry) do
+        Registry.new(obj_id: obj_id)
+      end
+
+      it 'does not freeze the specified data' do
+        registry
+
+        obj_id.should_not be_frozen
+      end
+
+      it 'persists' do
+        registry.save!
+
+        _registry = Registry.find(registry.id)
+        _registry.obj_id.should == obj_id
+      end
+    end
+
+    context 'when assigned a valid string' do
+      let(:obj_id) do
+        BSON::ObjectId.new.to_s
+      end
+
+      let(:registry) do
+        Registry.new(obj_id: obj_id)
+      end
+
+      it 'assigns as a BSON::Binary object' do
+        registry.obj_id.should be_a(BSON::ObjectId)
+      end
+
+      it 'persists' do
+        registry.save!
+
+        _registry = Registry.find(registry.id)
+        _registry.obj_id.should == BSON::ObjectId.from_string(obj_id)
+      end
+    end
+
+    context 'when assigned nil' do
+      let(:obj_id) do
+        nil
+      end
+
+      let(:registry) do
+        Registry.new(obj_id: obj_id)
+      end
+
+      it 'assigns nil' do
+        registry.obj_id.should be nil
+      end
+
+      it 'persists' do
+        registry.save!
+
+        _registry = Registry.find(registry.id)
+        _registry.obj_id.should be nil
+      end
+    end
+
+    context 'when assigned an invalid string' do
+      let(:obj_id) do
+        "hello"
+      end
+
+      let(:registry) do
+        Registry.new(obj_id: obj_id)
+      end
+
+      it 'assigns nil' do
+        registry.obj_id.should == "hello"
+      end
+
+      it 'persists' do
+        registry.save!
+
+        _registry = Registry.find(registry.id)
+        _registry.obj_id.should == "hello"
+      end
+    end
+
+    context 'when assigned an invalid type' do
+      let(:obj_id) do
+        :sym
+      end
+
+      let(:registry) do
+        Registry.new(obj_id: obj_id)
+      end
+
+      it 'assigns nil' do
+        registry.obj_id.should == :sym
+      end
+
+      it 'persists' do
+        registry.save!
+
+        _registry = Registry.find(registry.id)
+        _registry.obj_id.should == :sym
+      end
+    end
   end
 
   describe 'Hash field' do
@@ -86,28 +233,30 @@ describe Mongoid::Document do
   end
 
   context 'Regexp field' do
-    shared_examples "persists strings as regexp" do |type|
-      it 'persists strings as regexp' do
-        mop = Mop.create!(regexp_field: 'foo')
-        expect(mop.regexp_field).to be_a Regexp
-        expect(Mop.find(mop.id).regexp_field).to be_a BSON::Regexp::Raw
-        expect(
-          Mop.collection.find(
-            "_id" => mop.id,
-            "regexp_field" => { "$type" => type }
-          ).count
-        ).to be == 1
-      end
-    end
-
-    context "< 3.2" do
-      max_server_version("3.1")
-      include_examples "persists strings as regexp", 11
+    it 'persists strings as regexp' do
+      mop = Mop.create!(regexp_field: 'foo')
+      expect(mop.regexp_field).to be_a Regexp
+      expect(Mop.find(mop.id).regexp_field).to be_a Regexp
+      expect(
+        Mop.collection.find(
+          "_id" => mop.id,
+          "regexp_field" => { "$type" => 'regex' }
+        ).count
+      ).to be == 1
     end
+  end
 
-    context ">= 3.2" do
-      min_server_version("3.2")
-      it_behaves_like "persists strings as regexp", "regex"
+  context 'BSON::Regexp::Raw field' do
+    it 'round-trips BSON::Regexp::Raws' do
+      mop = Mop.create!(bson_regexp_field: BSON::Regexp::Raw.new('foo'))
+      expect(mop.bson_regexp_field).to be_a BSON::Regexp::Raw
+      expect(Mop.find(mop.id).bson_regexp_field).to be_a BSON::Regexp::Raw
+      expect(
+        Mop.collection.find(
+          "_id" => mop.id,
+          "bson_regexp_field" => { "$type" => 'regex' }
+        ).count
+      ).to be == 1
     end
   end
 end

data/spec/mongoid/document_spec.rb

@@ -165,13 +165,40 @@ describe Mongoid::Document do
 
   describe "#attributes" do
 
-    let(:person) do
-      Person.new(title: "Sir")
+    let!(:person) do
+      Person.create!(title: "Sir")
     end
 
     it "returns the attributes with indifferent access" do
       expect(person[:title]).to eq("Sir")
     end
+
+    context "when instantiating a new document" do
+      it "returns a Hash" do
+        expect(person.attributes.class).to eq(Hash)
+      end
+    end
+
+    context "when retrieving a document from the database" do
+
+      let(:from_db) { Person.first }
+
+      context "when legacy_attributes is false" do
+        config_override :legacy_attributes, false
+
+        it "returns a Hash" do
+          expect(from_db.attributes.class).to eq(Hash)
+        end
+      end
+
+      context "when legacy_attributes is true" do
+        config_override :legacy_attributes, true
+
+        it "returns a BSON::Document" do
+          expect(from_db.attributes.class).to eq(BSON::Document)
+        end
+      end
+    end
   end
 
   describe "#identity" do
@@ -293,27 +320,6 @@ describe Mongoid::Document do
           expect(person.game.name).to eq("Ms. Pacman")
         end
       end
-
-      context "when instantiating model" do
-
-        let(:person) do
-          Person.instantiate("_id" => BSON::ObjectId.new, "title" => "Sir")
-        end
-
-        before do
-          Person.set_callback :initialize, :after do |doc|
-            doc.title = "Madam"
-          end
-        end
-
-        after do
-          Person.reset_callbacks(:initialize)
-        end
-
-        it "runs the callbacks" do
-          expect(person.title).to eq("Madam")
-        end
-      end
     end
 
     context "when defaults are defined" do
@@ -409,21 +415,6 @@ describe Mongoid::Document do
     end
   end
 
-  describe "#to_a" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:people) do
-      person.to_a
-    end
-
-    it "returns the document in an array" do
-      expect(people).to eq([ person ])
-    end
-  end
-
   describe "#as_json" do
 
     let!(:person) do
@@ -501,12 +492,12 @@ describe Mongoid::Document do
         end
 
         it 'logs a deprecation warning when :compact is given' do
-          expect_any_instance_of(Logger).to receive(:warn).with(message)
+          expect(Mongoid::Warnings).to receive(:warn_as_json_compact_deprecated)
           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)
+          expect(Mongoid::Warnings).to_not receive(:warn_as_json_compact_deprecated)
           church.as_json
         end
       end
@@ -600,6 +591,33 @@ describe Mongoid::Document do
       expect(person.as_document["addresses"].first).to have_key(:locations)
     end
 
+    context 'when modifying the returned object' do
+      let(:record) do
+        RootCategory.create(categories: [{ name: 'tests' }]).reload
+      end
+
+      shared_examples_for 'an object with protected internal state' do
+        it 'does not expose internal state' do
+          before_change = record.as_document.dup
+          record.categories.first.name = 'things'
+          after_change = record.as_document
+          expect(before_change['categories'].first['name']).not_to eq('things')
+        end
+      end
+
+      context 'when legacy_attributes is true' do
+        config_override :legacy_attributes, true
+
+        it_behaves_like 'an object with protected internal state'
+      end
+
+      context 'when legacy_attributes is false' do
+        config_override :legacy_attributes, false
+
+        it_behaves_like 'an object with protected internal state'
+      end
+    end
+
     context "with relation define store_as option in embeded_many" do
 
       let!(:phone) do
@@ -627,7 +645,7 @@ describe Mongoid::Document do
       end
 
       it "does not include the document in the hash" do
-        expect(person.as_document["addresses"]).to be_empty
+        expect(person.as_document).to_not have_key("addresses")
       end
     end
 

data/spec/mongoid/equality_spec.rb

@@ -291,6 +291,12 @@ describe Mongoid::Equality do
     it "compares based on the document id" do
       expect(first <=> second).to eq(-1)
     end
+    
+    it "doesn't break if one isn't a document" do
+      expect do
+        first <=> "Foo"
+      end.to_not raise_error
+    end
   end
 
   describe "#eql?" do

data/spec/mongoid/errors/document_not_found_spec.rb

@@ -81,10 +81,37 @@ describe Mongoid::Errors::DocumentNotFound do
       end
     end
 
+    context "when providing an _id and a shard key" do
+
+      let(:id) { BSON::ObjectId.new }
+      let(:doc) { { _id: id, a: "syd" } }
+      let(:error) do
+        described_class.new(Person, id, doc)
+      end
+
+      it "contains the problem in the message" do
+        expect(error.message).to include(
+          "Document not found for class Person with id #{id.to_s} and shard key a: syd."
+        )
+      end
+
+      it "contains the summary in the message" do
+        expect(error.message).to include(
+          "When calling Person.find with an id and a shard key"
+        )
+      end
+
+      it "contains the resolution in the message" do
+        expect(error.message).to include(
+          "Search for an id/shard key that is in the database or set"
+        )
+      end
+    end
+
     context "when providing an id in a hash without a shard key" do
 
       let(:error) do
-        described_class.new(Person, 1, 1)
+        described_class.new(Person, 1, { _id: 1 })
       end
 
       it "contains the problem in the message" do
@@ -125,7 +152,7 @@ describe Mongoid::Errors::DocumentNotFound do
 
       it "contains the resolution in the message" do
         expect(error.message).to include(
-          "Create a document of class Person or use a finder method that returns nil when no documents are found instead of raising an exception."
+          "Create a document of class Person or use a finder method that does not raise an exception when no documents are found."
         )
       end
     end

data/spec/mongoid/errors/invalid_field_spec.rb

@@ -15,7 +15,7 @@ describe Mongoid::Errors::InvalidField do
     end
 
     let(:error) do
-      described_class.new(Person, :crazy_method)
+      described_class.new(Person, :crazy_method, :crazy_method)
     end
 
     it "contains the problem in the message" do

data/spec/mongoid/errors/invalid_field_type_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Errors::InvalidFieldType do
+
+  describe "#message" do
+
+    let(:error) do
+      described_class.new(Person, :first_name, :stringgy)
+    end
+
+    context 'when type is a symbol' do
+      let(:error) do
+        described_class.new(Person, :first_name, :stringgy)
+      end
+
+      it "contains the problem in the message" do
+        expect(error.message).to include(
+          "Invalid field type :stringgy for field 'first_name' on model 'Person'."
+        )
+      end
+
+      it "contains the summary in the message" do
+        expect(error.message).to include(
+          "Model 'Person' defines a field 'first_name' with an unknown type value :stringgy."
+        )
+      end
+    end
+
+    context 'when type is a string' do
+      let(:error) do
+        described_class.new(Person, :first_name, 'stringgy')
+      end
+
+      it "contains the problem in the message" do
+        expect(error.message).to include(
+          %q,Invalid field type "stringgy" for field 'first_name' on model 'Person'.,
+        )
+      end
+
+      it "contains the summary in the message" do
+        expect(error.message).to include(
+          %q,Model 'Person' defines a field 'first_name' with an unknown type value "stringgy".,
+        )
+      end
+    end
+
+    it "contains the resolution in the message" do
+      expect(error.message).to include(
+        'Please provide a valid type value for the field.'
+      )
+    end
+  end
+end

data/spec/mongoid/errors/mongoid_error_spec.rb

@@ -9,7 +9,9 @@ describe Mongoid::Errors::MongoidError do
   let(:options) { {} }
 
   before do
-    if RUBY_VERSION >= '2.7'
+    # JRuby 9.3 RUBY_VERSION is set to 2.6.8, but the behavior matches Ruby 2.7.
+    # See https://github.com/jruby/jruby/issues/7184
+    if RUBY_VERSION >= '2.7' || (BSON::Environment.jruby? && JRUBY_VERSION >= '9.3')
       {"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

data/spec/mongoid/errors/no_environment_spec.rb

@@ -12,19 +12,19 @@ describe Mongoid::Errors::NoEnvironment do
 
     it "contains the problem in the message" do
       expect(error.message).to include(
-        "Could not load the configuration since no environment was defined."
+        "Mongoid could not determine the environment"
       )
     end
 
     it "contains the summary in the message" do
       expect(error.message).to include(
-        "Mongoid attempted to find the appropriate environment but no Rails.env"
+        "it was not specified in any of the following locations"
       )
     end
 
     it "contains the resolution in the message" do
       expect(error.message).to include(
-        "Make sure some environment is set from the mentioned options"
+        "Please ensure an environment is set"
       )
     end
   end

data/spec/mongoid/errors/readonly_document_spec.rb

@@ -12,13 +12,13 @@ describe Mongoid::Errors::ReadonlyDocument do
 
     it "contains the problem in the message" do
       expect(error.message).to include(
-        "Attempted to persist the readonly document 'Band'."
+        "Attempted to persist a readonly document of class 'Band'."
       )
     end
 
     it "contains the summary in the message" do
       expect(error.message).to include(
-        "Documents loaded from the database using #only"
+        "Documents that are marked readonly cannot be persisted"
       )
     end
 

data/spec/mongoid/errors/too_many_nested_attribute_records_spec.rb

@@ -12,7 +12,7 @@ describe Mongoid::Errors::TooManyNestedAttributeRecords do
 
     it "contains the problem in the message" do
       expect(error.message).to include(
-        "Accepting nested attributes for favorites is limited to 5 records."
+        "Accepting nested attributes for favorites is limited to 5 documents."
       )
     end
 

data/spec/mongoid/extensions/array_spec.rb

@@ -488,12 +488,12 @@ describe Mongoid::Extensions::Array do
       Date.new(2012, 1, 1)
     end
 
-    let(:array) do
+    let(:input) do
       [ date ]
     end
 
     let(:mongoized) do
-      Array.mongoize(array)
+      Array.mongoize(input)
     end
 
     it "mongoizes each element in the array" do
@@ -503,6 +503,20 @@ describe Mongoid::Extensions::Array do
     it "converts the elements properly" do
       expect(mongoized.first).to eq(Time.utc(2012, 1, 1, 0, 0, 0))
     end
+
+    context "when passing in a set" do
+      let(:input) do
+        [ date ].to_set
+      end
+
+      it "mongoizes to an array" do
+        expect(mongoized).to be_a(Array)
+      end
+
+      it "converts the elements properly" do
+        expect(mongoized.first).to eq(Time.utc(2012, 1, 1, 0, 0, 0))
+      end
+    end
   end
 
   describe "#mongoize" do