mongoid 7.2.1 → 9.0.0

data/spec/mongoid/document_fields_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -41,20 +41,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
@@ -85,4 +232,32 @@ describe Mongoid::Document do
       end
     end
   end
+
+  context 'Regexp field' do
+    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 '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_persistence_context_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -30,4 +30,80 @@ describe Mongoid::Document do
       Person.collection_name.should == :people
     end
   end
+
+  context 'when loaded with an overridden persistence context' do
+    let(:options) { { collection: 'extra_people' } }
+    let(:person) { Person.with(options) { Person.create username: 'zyg14' } }
+
+    # Mongoid 9+ default persistence behavior
+    context 'when Mongoid.legacy_persistence_context_behavior is false' do
+      config_override :legacy_persistence_context_behavior, false
+
+      it 'remembers its persistence context when created' do
+        expect(person.collection_name).to be == :extra_people
+      end
+
+      it 'remembers its context when queried specifically' do
+        person_by_id = Person.with(options) { Person.find(_id: person._id) }
+        expect(person_by_id.collection_name).to be == :extra_people
+      end
+
+      it 'remembers its context when queried generally' do
+        person # force the person to be created
+        person_generally = Person.with(options) { Person.all[0] }
+        expect(person_generally.collection_name).to be == :extra_people
+      end
+
+      it 'can be reloaded without specifying the context' do
+        expect { person.reload }.not_to raise_error
+        expect(person.collection_name).to be == :extra_people
+      end
+
+      it 'can be updated without specifying the context' do
+        person.update username: 'zyg15'
+        expect(Person.with(options) { Person.first.username }).to be == 'zyg15'
+      end
+
+      it 'an explicit context takes precedence over a remembered context when persisting' do
+        person.username = 'bob'
+        # should not actually save -- the person does not exist in the
+        # `other` collection and so cannot be updated.
+        Person.with(collection: 'other') { person.save! }
+        expect(person.reload.username).to eq 'zyg14'
+      end
+
+      it 'an explicit context takes precedence over a remembered context when reloading' do
+        expect { Person.with(collection: 'other') { person.reload } }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+
+    # pre-9.0 default persistence behavior
+    context 'when Mongoid.legacy_persistence_context_behavior is true' do
+      config_override :legacy_persistence_context_behavior, true
+
+      it 'does not remember its persistence context when created' do
+        expect(person.collection_name).to be == :people
+      end
+
+      it 'does not remember its context when queried specifically' do
+        person_by_id = Person.with(options) { Person.find(_id: person._id) }
+        expect(person_by_id.collection_name).to be == :people
+      end
+
+      it 'does not remember its context when queried generally' do
+        person # force the person to be created
+        person_generally = Person.with(options) { Person.all[0] }
+        expect(person_generally.collection_name).to be == :people
+      end
+
+      it 'cannot be reloaded without specifying the context' do
+        expect { person.reload }.to raise_error
+      end
+
+      it 'cannot be updated without specifying the context' do
+        person.update username: 'zyg15'
+        expect(Person.with(options) { Person.first.username }).to be == 'zyg14'
+      end
+    end
+  end
 end

data/spec/mongoid/document_query_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -15,11 +15,11 @@ describe Mongoid::Document do
     it 'populates specified fields only' do
       expect do
         person.title
-      end.to raise_error(ActiveModel::MissingAttributeError)
+      end.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'title' on Person which was not loaded/)
       # has a default value specified in the model
       expect do
         person.age
-      end.to raise_error(ActiveModel::MissingAttributeError)
+      end.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'age' on Person which was not loaded/)
       expect(person.attributes.keys).to eq(['_id', 'username'])
     end
 
@@ -28,7 +28,7 @@ describe Mongoid::Document do
 
       expect do
         person.age
-      end.to raise_error(ActiveModel::MissingAttributeError)
+      end.to raise_error(Mongoid::Errors::AttributeNotLoaded)
       person.age = 42
       expect(person.age).to be 42
       person.save!
@@ -36,4 +36,55 @@ 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(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'name' on Animal which was not loaded/)
+      end
+    end
+  end
 end