mongoid 5.4.1 → 6.0.0.beta

data/spec/mongoid/persistable/updatable_spec.rb

@@ -168,7 +168,7 @@ describe Mongoid::Persistable::Updatable do
         it "raises an error" do
           expect {
             post.update_attribute(:title, "something")
-          }.to raise_error
+          }.to raise_error(RuntimeError)
         end
       end
     end
@@ -269,6 +269,167 @@ describe Mongoid::Persistable::Updatable do
         expect(from_db.reload.name).to eq("home")
       end
     end
+
+    context 'when the field is read-only' do
+
+      before do
+        Person.attr_readonly :species
+      end
+
+      after do
+        Person.readonly_attributes.reject! { |a| a.to_s == 'species' }
+      end
+
+      let(:person) do
+        Person.create(species: :human)
+      end
+
+      it 'raises an error when trying to set the attribute' do
+        expect {
+          person.update_attribute(:species, :reptile)
+        }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+      end
+
+      context 'when referring to the attribute with a string' do
+
+        it 'raises an error when trying to set the attribute' do
+          expect {
+            person.update_attribute('species', :reptile)
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+        end
+      end
+
+      context 'when the field is aliased' do
+
+        before do
+          Person.attr_readonly :at
+        end
+
+        after do
+          Person.readonly_attributes.reject! { |a| a.to_s == 'at' }
+        end
+
+        it 'raises an error when trying to set the attribute using the db name' do
+          expect {
+            person.update_attribute(:at, Time.now)
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+        end
+
+        it 'raises an error when trying to set the attribute using the aliased name' do
+          expect {
+            person.update_attribute(:aliased_timestamp, Time.now)
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+        end
+      end
+    end
+
+    context 'when the field is loaded explicitly' do
+
+      before do
+        Person.create(title: 'Captain')
+      end
+
+      context 'when the loaded attribute is updated' do
+
+        let(:person) do
+          Person.only(:title).first.tap do |_person|
+            _person.update_attribute(:title, 'Esteemed')
+          end
+        end
+
+        it 'allows the field to be updated' do
+          expect(person.title).to eq('Esteemed')
+        end
+
+        it 'persists the updated field' do
+          expect(person.reload.title).to eq('Esteemed')
+        end
+      end
+
+      context 'when the an attribute other than the loaded one is updated' do
+
+        let(:person) do
+          Person.only(:title).first
+        end
+
+        it 'does not allow the field to be updated' do
+          expect {
+            person.update_attribute(:age, 20)
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+        end
+
+        it 'does not persist the change' do
+          expect(person.reload.age).to eq(100)
+        end
+
+        context 'when referring to the attribute with a string' do
+
+          it 'does not allow the field to be updated' do
+            expect {
+              person.update_attribute('age', 20)
+            }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
+          end
+
+          it 'does not persist the change' do
+            expect(person.reload.age).to eq(100)
+          end
+        end
+      end
+    end
+
+    context 'when fields are explicitly not loaded' do
+
+      before do
+        Person.create(title: 'Captain')
+      end
+
+      context 'when the loaded attribute is updated' do
+
+        let(:person) do
+          Person.without(:age).first.tap do |_person|
+            _person.update_attribute(:title, 'Esteemed')
+          end
+        end
+
+        it 'allows the field to be updated' do
+          expect(person.title).to eq('Esteemed')
+        end
+
+        it 'persists the updated field' do
+          expect(person.reload.title).to eq('Esteemed')
+        end
+      end
+
+      context 'when the non-loaded attribute is updated' do
+
+        let(:person) do
+          Person.without(:title).first
+        end
+
+        it 'does not allow the field to be updated' do
+          expect {
+            person.update_attribute(:title, 'Esteemed')
+          }.to raise_exception(ActiveModel::MissingAttributeError)
+        end
+
+        it 'does not persist the change' do
+          expect(person.reload.title).to eq('Captain')
+        end
+
+        context 'when referring to the attribute with a string' do
+
+          it 'does not allow the field to be updated' do
+            expect {
+              person.update_attribute('title', 'Esteemed')
+            }.to raise_exception(ActiveModel::MissingAttributeError)
+          end
+
+          it 'does not persist the change' do
+            expect(person.reload.title).to eq('Captain')
+          end
+        end
+      end
+    end
   end
 
   [:update_attributes, :update].each do |method|
@@ -283,7 +444,7 @@ describe Mongoid::Persistable::Updatable do
 
         it "raises an error" do
           expect {
-            person.update_attributes(map: { "$bad.key" => "value" })
+            person.update_attributes(map: { "bad.key" => "value" })
           }.to raise_error(Mongo::Error::OperationFailure)
         end
       end
@@ -319,7 +480,7 @@ describe Mongoid::Persistable::Updatable do
 
         it "raises an error" do
           expect {
-            person.send(method, map: { "$bad.key" => "value" })
+            person.send(method, map: { "bad.key" => "value" })
           }.to raise_error(Mongo::Error::OperationFailure)
         end
       end
@@ -360,7 +521,7 @@ describe Mongoid::Persistable::Updatable do
         it "raises an error" do
           expect {
             person.send(method, title: "something")
-          }.to raise_error
+          }.to raise_error(RuntimeError)
         end
       end
 
@@ -543,7 +704,7 @@ describe Mongoid::Persistable::Updatable do
 
   describe "#update!" do
 
-    context "when a callback returns false" do
+    context "when a callback aborts the callback chain" do
 
       let(:oscar) do
         Oscar.new

data/spec/mongoid/persistence_context_spec.rb

@@ -0,0 +1,654 @@
+require "spec_helper"
+
+describe Mongoid::PersistenceContext do
+
+  let(:persistence_context) do
+    described_class.new(object, options)
+  end
+
+  let(:object) do
+    Band
+  end
+
+  describe '.set' do
+
+    let(:options) do
+      { collection: :other }
+    end
+
+    context 'when the persistence context is set on the thread' do
+
+      let!(:persistence_context) do
+        described_class.set(object, options)
+      end
+
+      it 'sets the persistence context for the object on the current thread' do
+        expect(described_class.get(object)).to be(persistence_context)
+        expect(described_class.get(object)).not_to be(nil)
+        expect(described_class.get(object).collection.name).to eq('other')
+      end
+
+      it 'only sets persistence context for the object on the current thread' do
+         Thread.new do
+          expect(described_class.get(object)).not_to be(persistence_context)
+          expect(described_class.get(object)).to be(nil)
+        end.value
+      end
+    end
+  end
+
+
+  describe '.get' do
+
+    let(:options) do
+      { collection: :other }
+    end
+
+    context 'when there has been a persistence context set on the current thread' do
+
+      let!(:persistence_context) do
+        described_class.set(object, options)
+      end
+
+      it 'gets the persistence context for the object on the current thread' do
+        expect(described_class.get(object)).to be(persistence_context)
+        expect(described_class.get(object).collection.name).to eq('other')
+      end
+
+      it 'does not get persistence context for the object from another thread' do
+        Thread.new do
+          expect(described_class.get(object)).not_to be(persistence_context)
+          expect(described_class.get(object)).to be(nil)
+        end.value
+      end
+    end
+  end
+
+  describe '.clear' do
+
+    let(:options) do
+      { collection: :other }
+    end
+
+    context 'when there has been a persistence context set on the current thread' do
+
+      let!(:persistence_context) do
+        described_class.set(object, options)
+      end
+
+      context 'when no cluster is passed to the method' do
+
+        before do
+          described_class.clear(object)
+        end
+
+        it 'clears the persistence context for the object on the current thread' do
+          expect(described_class.get(object)).to be(nil)
+        end
+      end
+
+      context 'when a cluster is passed to the method' do
+
+        context 'when the cluster is the same as that of the persistence context on the current thread' do
+
+          let(:client) do
+            persistence_context.client
+          end
+
+          before do
+            described_class.clear(object, client.cluster)
+          end
+
+          it 'does not close the cluster' do
+            expect(client).not_to receive(:close)
+            described_class.clear(object, client.cluster.dup)
+          end
+        end
+
+        context 'when the cluster is not the same as that of the persistence context on the current thread' do
+
+          let!(:client) do
+            persistence_context.client
+          end
+
+          it 'closes the client' do
+            expect(client).to receive(:close).and_call_original
+            described_class.clear(object, client.cluster.dup)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#initialize' do
+
+    let(:options) do
+      { collection: 'other' }
+    end
+
+    context 'when an object is passed' do
+
+      context 'when the object is a klass' do
+
+        it 'sets the object on the persistence context' do
+          expect(persistence_context.instance_variable_get(:@object)).to eq(object)
+        end
+      end
+
+      context 'when the object is a model instance' do
+
+        let(:object) do
+          Band.new
+        end
+
+        it 'sets the object on the persistence context' do
+          expect(persistence_context.instance_variable_get(:@object)).to eq(object)
+        end
+      end
+    end
+
+    context 'when options are passed' do
+
+      let(:options) do
+        { connect_timeout: 3 }
+      end
+
+      context 'when the options are valid client options' do
+
+        it 'sets the options on the persistence context object' do
+          expect(persistence_context.options).to eq(options)
+        end
+      end
+
+      context 'when the options are not valid client options' do
+
+        context 'when the options are valid extra options' do
+
+          let(:options) do
+            { collection: 'other' }
+          end
+
+          it 'sets the options on the persistence context object' do
+            expect(persistence_context.collection_name).to eq(options[:collection].to_sym)
+          end
+        end
+
+        context 'when the options are not valid extra options' do
+
+          let(:options) do
+            { invalid: 'option' }
+          end
+
+          it 'raises an InvalidPersistenceOption error' do
+            expect {
+              persistence_context
+            }.to raise_error(Mongoid::Errors::InvalidPersistenceOption)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#collection' do
+
+    let(:persistence_context) do
+      described_class.new(object, options)
+    end
+
+    let(:options) do
+      { read: { 'mode' => :secondary } }
+    end
+
+    context 'when a parent object is passed' do
+
+      it 'uses the collection of the parent object' do
+        expect(persistence_context.collection(Person.new).name).to eq('people')
+      end
+
+      it 'does not memoize the collection' do
+        persistence_context.collection
+        expect(persistence_context.collection(Person.new).name).to eq('people')
+      end
+
+      it 'keeps the other options of the persistence context' do
+        expect(persistence_context.collection(Person.new).client.options[:read]).to eq(options[:read])
+      end
+    end
+
+    context 'when a parent object is not passed' do
+
+      it 'uses the collection of the object' do
+        expect(persistence_context.collection.name).to eq('bands')
+      end
+
+      it 'does not memoize the collection' do
+        persistence_context.collection(Person.new)
+        expect(persistence_context.collection.name).to eq('bands')
+      end
+
+      it 'keeps the other options of the persistence context' do
+        expect(persistence_context.collection.client.options[:read]).to eq(options[:read])
+      end
+    end
+  end
+
+  describe '#collection_name' do
+
+    let(:persistence_context) do
+      described_class.new(object, options)
+    end
+
+    let(:options) do
+      { collection: 'other' }
+    end
+
+    context 'when storage options are set on the object' do
+
+      context 'when there are no options passed to the Persistence Context' do
+
+        let(:options) do
+          { }
+        end
+
+        after do
+          object.reset_storage_options!
+        end
+
+        context 'when the storage options is static' do
+
+          before do
+            object.store_in collection: :schmands
+          end
+
+          it 'uses the storage options' do
+            expect(persistence_context.collection_name).to eq(:schmands)
+          end
+        end
+
+        context 'when the storage options is a block' do
+
+          before do
+            object.store_in collection: ->{ :schmands }
+          end
+
+          it 'uses the storage options' do
+            expect(persistence_context.collection_name).to eq(:schmands)
+          end
+        end
+      end
+
+      context 'when there are options passed to the Persistence Context' do
+
+        let(:options) do
+          { collection: 'other' }
+        end
+
+        after do
+          object.reset_storage_options!
+        end
+
+        context 'when the storage options is static' do
+
+          before do
+            object.store_in collection: :schmands
+          end
+
+          it 'uses the persistence context options' do
+            expect(persistence_context.collection_name).to eq(:other)
+          end
+        end
+
+        context 'when the storage options is a block' do
+
+          before do
+            object.store_in collection: ->{ :schmands }
+          end
+
+          it 'uses the persistence context options' do
+            expect(persistence_context.collection_name).to eq(:other)
+          end
+        end
+      end
+    end
+
+    context 'when storage options are not set on the object' do
+
+      context 'when there are options passed to the Persistence Context' do
+
+        let(:options) do
+          { collection: 'other' }
+        end
+
+        it 'uses the persistence context options' do
+          expect(persistence_context.collection_name).to eq(:other)
+        end
+      end
+    end
+  end
+
+  describe '#database_name' do
+
+    let(:persistence_context) do
+      described_class.new(object, options)
+    end
+
+    let(:options) do
+      { database: 'other' }
+    end
+
+    context 'when storage options are set on the object' do
+
+      context 'when there are no options passed to the Persistence Context' do
+
+        let(:options) do
+          { }
+        end
+
+        after do
+          object.reset_storage_options!
+        end
+
+        context 'when there is a database override' do
+
+          before do
+            object.store_in database: :musique
+          end
+
+          before do
+            Mongoid::Threaded.database_override = :other
+          end
+
+          after do
+            Mongoid::Threaded.database_override = nil
+          end
+
+          it 'uses the override' do
+            expect(persistence_context.database_name).to eq(:other)
+          end
+        end
+
+        context 'when the storage options is static' do
+
+          before do
+            object.store_in database: :musique
+          end
+
+          it 'uses the storage options' do
+            expect(persistence_context.database_name).to eq(:musique)
+          end
+        end
+
+        context 'when the storage options is a block' do
+
+          before do
+            object.store_in database: ->{ :musique }
+          end
+          it 'uses the storage options' do
+            expect(persistence_context.database_name).to eq(:musique)
+          end
+        end
+      end
+
+      context 'when there are options passed to the Persistence Context' do
+
+        let(:options) do
+          { database: 'musique' }
+        end
+
+        context 'when there is a database override' do
+
+          before do
+            Mongoid::Threaded.database_override = :other
+          end
+
+          after do
+            Mongoid::Threaded.database_override = nil
+          end
+
+          it 'uses the persistence context options' do
+            expect(persistence_context.database_name).to eq(:musique)
+          end
+        end
+
+        context 'when the storage options is static' do
+
+          before do
+            object.store_in database: :sounds
+          end
+
+          after do
+            object.reset_storage_options!
+          end
+
+          it 'uses the persistence context options' do
+            expect(persistence_context.database_name).to eq(:musique)
+          end
+        end
+
+        context 'when the storage options is a block' do
+
+          before do
+            object.store_in database: ->{ :sounds }
+          end
+
+          after do
+            object.reset_storage_options!
+          end
+
+          it 'uses the persistence context options' do
+            expect(persistence_context.database_name).to eq(:musique)
+          end
+        end
+      end
+    end
+
+    context 'when storage options are not set on the object' do
+
+      context 'when there are options passed to the Persistence Context' do
+
+        let(:options) do
+          { database: 'musique' }
+        end
+
+        it 'uses the persistence context options' do
+          expect(persistence_context.database_name).to eq(:musique)
+        end
+
+        context 'when there is a database override' do
+
+          before do
+            Mongoid::Threaded.database_override = :other
+          end
+
+          after do
+            Mongoid::Threaded.database_override = nil
+          end
+
+          it 'uses the persistence context options' do
+            expect(persistence_context.database_name).to eq(:musique)
+          end
+        end
+      end
+
+      context 'when there are no options passed to the Persistence Context' do
+
+        context 'when there is a database override' do
+
+          before do
+            Mongoid::Threaded.database_override = :other
+          end
+
+          after do
+            Mongoid::Threaded.database_override = nil
+          end
+
+          it 'uses the database override options' do
+            expect(persistence_context.database_name).to eq(Mongoid::Threaded.database_override)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#client' do
+
+    let(:persistence_context) do
+      described_class.new(object, options)
+    end
+
+    let(:options) do
+      { }
+    end
+
+    before do
+      Mongoid.clients[:alternative] = { database: :mongoid_test, hosts: [ "#{HOST}:#{PORT}" ] }
+    end
+
+    after do
+      Mongoid.clients.delete(:alternative)
+    end
+
+    context 'when the client is set in the options' do
+
+      let(:options) do
+        { client: :alternative }
+      end
+
+      it 'uses the client option' do
+        expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+      end
+
+      context 'when there is a client override' do
+
+        before do
+          Mongoid::Threaded.client_override = :other
+        end
+
+        after do
+          Mongoid::Threaded.client_override = nil
+        end
+
+        it 'uses the client option' do
+          expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+        end
+      end
+
+      context 'when there are storage options set' do
+
+        after do
+          object.reset_storage_options!
+        end
+
+        context 'when the storage options is static' do
+
+          before do
+            object.store_in client: :other
+          end
+
+          it 'uses the persistence context options' do
+            expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+          end
+        end
+
+        context 'when the storage options is a block' do
+
+          before do
+            object.store_in client: ->{ :other }
+          end
+
+          it 'uses the persistence context options' do
+            expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+          end
+        end
+      end
+    end
+
+    context 'when there is no client option set' do
+
+      let(:options) do
+        { }
+      end
+
+      context 'when there is a client override' do
+
+        before do
+          Mongoid::Threaded.client_override = :alternative
+        end
+
+        after do
+          Mongoid::Threaded.client_override = nil
+        end
+
+        it 'uses the client override' do
+          expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+        end
+      end
+
+      context 'when there are storage options set' do
+
+        after do
+          object.reset_storage_options!
+        end
+
+        context 'when the storage options is static' do
+
+          before do
+            object.store_in client: :alternative
+          end
+
+          it 'uses the client storage option' do
+            expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+          end
+        end
+
+        context 'when the storage options is a block' do
+
+          before do
+            object.store_in client: ->{ :alternative }
+          end
+
+          it 'uses the client storage option' do
+            expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+          end
+        end
+
+        context 'when there is a client override' do
+
+          before do
+            Mongoid::Threaded.client_override = :alternative
+          end
+
+          after do
+            Mongoid::Threaded.client_override = nil
+          end
+
+          it 'uses the client override' do
+            expect(persistence_context.client).to eq(Mongoid::Clients.with_name(:alternative))
+          end
+        end
+      end
+    end
+
+    context 'when there are client options set' do
+
+      let(:options) do
+        { connect_timeout: 3 }
+      end
+
+      it 'applies the options to the client' do
+        expect(persistence_context.client.options[:connect_timeout]).to eq(options[:connect_timeout])
+      end
+    end
+
+    context 'when there is a database name set in the options' do
+
+      let(:options) do
+        { database: 'other' }
+      end
+
+      it 'uses the database from the options' do
+        expect(persistence_context.client.database.name).to eq(options[:database])
+      end
+    end
+  end
+end