mongoid 5.4.1 → 6.0.0.beta

data/spec/mongoid/attributes_spec.rb

@@ -1105,6 +1105,69 @@ describe Mongoid::Attributes do
         expect(person.delayed_atomic_unsets).to be_empty
       end
     end
+
+    context "when the attribute is aliased" do
+
+      context 'when the database name is used' do
+
+        let(:person) do
+          Person.create(at: Time.now)
+        end
+
+        before do
+          person.remove_attribute(:at)
+        end
+
+        it "removes the attribute" do
+          expect(person.at).to be_nil
+        end
+
+        it "removes the key from the attributes hash" do
+          expect(person.has_attribute?(:at)).to be false
+        end
+
+        context "when saving after the removal" do
+
+          before do
+            person.save
+          end
+
+          it "persists the removal" do
+            expect(person.reload.has_attribute?(:at)).to be false
+          end
+        end
+      end
+
+      context 'when the alias is used' do
+
+        let(:person) do
+          Person.create(aliased_timestamp: Time.now)
+        end
+
+        before do
+          person.remove_attribute(:aliased_timestamp)
+        end
+
+        it "removes the attribute" do
+          expect(person.aliased_timestamp).to be_nil
+        end
+
+        it "removes the key from the attributes hash" do
+          expect(person.has_attribute?(:aliased_timestamp)).to be false
+        end
+
+        context "when saving after the removal" do
+
+          before do
+            person.save
+          end
+
+          it "persists the removal" do
+            expect(person.reload.has_attribute?(:aliased_timestamp)).to be false
+          end
+        end
+      end
+    end
   end
 
   describe "#respond_to?" do

data/spec/mongoid/cacheable_spec.rb

@@ -0,0 +1,112 @@
+require "spec_helper"
+
+describe Mongoid::Cacheable do
+
+  describe ".included" do
+
+    let(:klass) do
+      Class.new do
+        include Mongoid::Cacheable
+      end
+    end
+
+    it "adds an cache_timestamp_format accessor" do
+      expect(klass).to respond_to(:cache_timestamp_format)
+    end
+
+    it "defaults cache_timestamp_format to :nsec" do
+      expect(klass.cache_timestamp_format).to be(:nsec)
+    end
+  end
+
+  describe "#cache_key" do
+
+    let(:document) do
+      Dokument.new
+    end
+
+    context "when the document is new" do
+
+      it "has a new key name" do
+        expect(document.cache_key).to eq("dokuments/new")
+      end
+    end
+
+    context "when persisted" do
+
+      before do
+        document.save
+      end
+
+      context "with updated_at" do
+
+        context "with the default cache_timestamp_format" do
+
+          let!(:updated_at) do
+            document.updated_at.utc.to_s(:nsec)
+          end
+
+          it "has the id and updated_at key name" do
+            expect(document.cache_key).to eq("dokuments/#{document.id}-#{updated_at}")
+          end
+        end
+
+        context "with a different cache_timestamp_format" do
+
+          before do
+            Dokument.cache_timestamp_format = :number
+          end
+
+          after do
+            Dokument.cache_timestamp_format = :nsec
+          end
+
+          let!(:updated_at) do
+            document.updated_at.utc.to_s(:number)
+          end
+
+          it "has the id and updated_at key name" do
+            expect(document.cache_key).to eq("dokuments/#{document.id}-#{updated_at}")
+          end
+        end
+      end
+
+      context "without updated_at, with Timestamps" do
+
+        before do
+          document.updated_at = nil
+        end
+
+        it "has the id key name" do
+          expect(document.cache_key).to eq("dokuments/#{document.id}")
+        end
+      end
+    end
+
+    context "when model dont have Timestamps" do
+
+      let(:artist) do
+        Artist.create!
+      end
+
+      it "should have the id key name" do
+        expect(artist.cache_key).to eq("artists/#{artist.id}")
+      end
+    end
+
+    context "when model has Short Timestamps" do
+
+      let(:agent) do
+        ShortAgent.create!
+      end
+
+      let!(:updated_at) do
+        agent.updated_at.utc.to_s(:nsec)
+      end
+
+      it "has the id and updated_at key name" do
+        expect(agent.cache_key).to eq("short_agents/#{agent.id}-#{updated_at}")
+      end
+    end
+  end
+end

data/spec/mongoid/changeable_spec.rb

@@ -1289,6 +1289,64 @@ describe Mongoid::Changeable do
     end
   end
 
+  describe '#previously_changed?' do
+
+    let(:person) do
+      Person.new(title: "Grand Poobah")
+    end
+
+    before do
+      person.title = "Captain Obvious"
+    end
+
+    context "when the document has been saved" do
+
+      before do
+        person.save!
+      end
+
+      it "returns true" do
+        expect(person.title_previously_changed?).to be(true)
+      end
+    end
+
+    context "when the document has not been saved" do
+
+      it "returns false" do
+        expect(person.title_previously_changed?).to be(false)
+      end
+    end
+  end
+
+  describe '#previous_change' do
+
+    let(:person) do
+      Person.new(title: "Grand Poobah")
+    end
+
+    before do
+      person.title = "Captain Obvious"
+    end
+
+    context "when the document has been saved" do
+
+      before do
+        person.save!
+      end
+
+      it "returns the changes" do
+        expect(person.title_previous_change).to eq([ nil, "Captain Obvious" ])
+      end
+    end
+
+    context "when the document has not been saved" do
+
+      it "returns no changes" do
+        expect(person.title_previous_change).to eq(nil)
+      end
+    end
+  end
+
   context "when fields have been defined pre-dirty inclusion" do
 
     let(:document) do

data/spec/mongoid/clients/factory_spec.rb

@@ -36,10 +36,6 @@ describe Mongoid::Clients::Factory do
           it "sets the cluster's seeds" do
             expect(cluster.addresses.first.to_s).to eq("127.0.0.1:27017")
           end
-
-          it "sets the platform to Mongoid's platform constant" do
-            expect(client.options[:platform]).to eq(Mongoid::PLATFORM_DETAILS)
-          end
         end
 
         context "when the configuration has no ports" do
@@ -120,8 +116,8 @@ describe Mongoid::Clients::Factory do
 
             let(:config) do
               {
-                default: { hosts: [ "127.0.0.1:30000" ], database: database_id },
-                secondary: { uri: "mongodb://127.0.0.1:30000,127.0.0.1:30001/mongoid_test" }
+                default: { hosts: [ "127.0.0.1:27017" ], database: database_id },
+                secondary: { uri: "mongodb://127.0.0.1:27017,127.0.0.1:27018/mongoid_test" }
               }
             end
 
@@ -146,7 +142,7 @@ describe Mongoid::Clients::Factory do
             end
 
             it "sets the cluster's seeds" do
-              expect(seeds).to eq([ "127.0.0.1:30000", "127.0.0.1:30001" ])
+              expect(seeds).to eq([ "127.0.0.1:27017", "127.0.0.1:27018" ])
             end
           end
         end
@@ -284,9 +280,5 @@ describe Mongoid::Clients::Factory do
     it "sets the write concern" do
       expect(client.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
     end
-
-    it "sets the platform to Mongoid's platform constant" do
-      expect(client.options[:platform]).to eq(Mongoid::PLATFORM_DETAILS)
-    end
   end
 end

data/spec/mongoid/clients/options_spec.rb

@@ -2,185 +2,467 @@ require "spec_helper"
 
 describe Mongoid::Clients::Options do
 
-  describe "#with", if: non_legacy_server? do
+  describe '#with', if: non_legacy_server? do
 
-    context "when passing some options" do
+    context 'when passing some options' do
 
-      let(:options) { { database: 'test' } }
-
-      let!(:cluster) do
-        Band.mongo_client.cluster
+      let(:persistence_context) do
+        Band.with(options) do |klass|
+          klass.persistence_context
+        end
       end
 
-      let!(:klass) do
-        Band.with(options)
+      let(:options) { { database: 'other' } }
+
+      it 'sets the options on the client' do
+        expect(persistence_context.client.options['database']).to eq(options[:database])
       end
 
-      it "sets the options into the class" do
-        expect(klass.persistence_options).to eq(options)
+      it 'does not set the options on class level' do
+        expect(Band.persistence_context.client.options['database']).to eq('mongoid_test')
       end
 
-      it "sets the options into the instance" do
-        expect(klass.new.persistence_options).to eq(options)
+      context 'when the options are not valid mongo client options' do
+
+        let(:persistence_context) do
+          Band.with(invalid_options) do |klass|
+            klass.persistence_context
+          end
+        end
+
+        let(:invalid_options) { { bad: 'option' } }
+
+        it 'raises an error' do
+          expect {
+            persistence_context
+          }.to raise_exception(Mongoid::Errors::InvalidPersistenceOption)
+        end
+
+        it 'clears the persistence context' do
+          begin; persistence_context; rescue Mongoid::Errors::InvalidPersistenceOption; end
+          expect(Band.persistence_context).to eq(Mongoid::PersistenceContext.new(Band))
+        end
       end
 
-      it "doesnt set the options on class level" do
-        expect(Band.new.persistence_options).to be_nil
+      context 'when the options include a collection' do
+
+        let(:options) { { collection: 'another-collection' } }
+
+        it 'uses the collection' do
+          expect(persistence_context.collection_name).to eq(options[:collection].to_sym)
+          expect(persistence_context.collection.name).to eq(options[:collection])
+        end
+
+        it 'does not raise an error' do
+          expect(persistence_context.client).to be_a(Mongo::Client)
+        end
+
+        it 'does not include the collection option in the client options' do
+          expect(persistence_context.client.options[:collection]).to be_nil
+          expect(persistence_context.client.options['collection']).to be_nil
+        end
       end
 
-      context 'when passed a block', if: testing_locally? do
+      context 'when passing a block', if: testing_locally? do
 
         let!(:connections_before) do
           Band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
         end
 
-        it "can return results" do
-          Band.create(name: 'emily')
-          result = Band.with(:read => {:mode => :secondary_preferred}) do |klass|
+        let!(:connections_and_cluster_during) do
+          connections = nil
+          cluster = Band.with(options) do |klass|
             klass.where(name: 'emily').to_a
+            connections = Band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
           end
-          expect(result.length).to eq(1)
-          expect(result.first.name).to eq('emily')
+          [ connections, cluster ]
         end
 
-        before do
-          Band.with(options) do |klass|
-            klass.where(name: 'emily').to_a
-          end
+        let(:connections_during) do
+          connections_and_cluster_during[0]
+        end
+
+        let(:cluster_during) do
+          connections_and_cluster_during[1]
         end
 
         let(:connections_after) do
           Band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
         end
 
-        context 'when a new cluster is created by the driver' do
+        let!(:cluster_before) do
+          Band.persistence_context.cluster
+        end
 
-          let(:options) { { connect_timeout: 2 } }
+        let(:cluster_after) do
+          Band.persistence_context.cluster
+        end
 
-          it 'disconnects the new cluster' do
-            expect(connections_after).to eq(connections_before)
+        context 'when the options create a new cluster' do
+
+          let(:options) do
+            { connect_timeout: 2 }
+          end
+
+          it 'creates a new cluster' do
+            expect(connections_before).to be <(connections_during)
+            expect(cluster_before).not_to be(cluster_during)
+          end
+
+          it 'disconnects the new cluster when the block exits' do
+            expect(connections_before).to eq(connections_after)
           end
         end
 
-        context 'when the same cluster is used by the new client' do
+        context 'when the options do not create a new cluster' do
 
-          let(:options) { { database: 'same-cluster' } }
+          let(:options) do
+            { database: 'same-cluster' }
+          end
+
+          it 'does not create a new cluster' do
+            expect(connections_during).to eq(connections_before)
+          end
 
           it 'does not disconnect the original cluster' do
             expect(connections_after).to eq(connections_before)
+            expect(cluster_before).to be(cluster_after)
+          end
+        end
+
+        context 'when the client options were configured using a uri' do
+
+          let(:config) do
+            {
+                default: { hosts: [ "127.0.0.1:27017" ], database: database_id },
+                secondary: { uri: "mongodb://127.0.0.1:27017/secondary-db?connectTimeoutMS=3000" }
+            }
+          end
+
+          before do
+            Mongoid::Config.send(:clients=, config)
+          end
+
+          let(:persistence_context) do
+            Band.with(client: :secondary) do |klass|
+              klass.persistence_context
+            end
+          end
+
+          it 'uses the database specified in the uri' do
+            expect(persistence_context.database_name).to eq('secondary-db')
+            expect(persistence_context.client.database.name).to eq('secondary-db')
+          end
+
+          it 'uses the options specified in the uri' do
+            expect(persistence_context.client.options[:connect_timeout]).to eq(3)
           end
         end
       end
 
-      context "when calling .collection method" do
+      context 'when changing the collection' do
 
-        before do
-          klass.collection
+        let(:options) do
+          { collection: 'other' }
         end
 
-        it "keeps the options" do
-          expect(klass.persistence_options).to eq(options)
+        it 'uses that collection' do
+          expect(persistence_context.collection.name).to eq(options[:collection])
         end
+      end
 
-        context 'when changing the collection' do
+      context 'when returning a criteria' do
 
-          let(:options) do
-            { collection: 'other' }
+        let(:context_and_criteria) do
+          collection = nil
+          cxt = Band.with(read: :secondary) do |klass|
+            collection = klass.all.collection
+            klass.persistence_context
           end
+          [ cxt, collection ]
+        end
 
-          it 'uses that collection' do
-            expect(klass.collection.name).to eq(options[:collection])
-          end
+        let(:persistence_context) do
+          context_and_criteria[0]
+        end
+
+        let(:client) do
+          context_and_criteria[1].client
+        end
+
+        it 'applies the options to the criteria client' do
+          expect(client.options['read']).to eq(:secondary)
         end
       end
 
-      context "when returning a criteria" do
+      context 'when the object is shared between threads' do
 
-        let(:criteria) do
-          klass.all
+        before do
+          threads = []
+          100.times do |i|
+            threads << Thread.new do
+              if i % 2 == 0
+                Band.with(collection: 'British') do |klass|
+                  klass.create(name: 'realised')
+                end
+              else
+                Band.with(collection: 'American') do |klass|
+                  klass.create(name: 'realized')
+                end
+              end
+            end
+          end
+          threads.collect { |t| t.value }
         end
 
-        it "sets the options into the criteria object" do
-          expect(criteria.persistence_options).to eq(options)
+        let(:british_count) do
+          Band.with(collection: 'British') do |klass|
+            klass.all.count
+          end
         end
 
-        it "doesnt set the options on class level" do
-          expect(Band.new.persistence_options).to be_nil
+        let(:american_count) do
+          Band.with(collection: 'American') do |klass|
+            klass.all.count
+          end
+        end
+
+        it "does not share the persistence options" do
+          expect(british_count).to eq(50)
+          expect(american_count).to eq(50)
         end
       end
     end
-  end
 
-  describe ".with", if: non_legacy_server? do
+    context 'when passing a persistence context' do
 
-    let(:options) { { database: 'test' } }
+      let(:instance) do
+        Band.new
+      end
 
-    let(:instance) do
-      Band.new.with(options)
-    end
+      let(:persistence_context) do
+        instance.with(options) do |inst|
+          inst.persistence_context
+        end
+      end
 
-    it "sets the options into" do
-      expect(instance.persistence_options).to eq(options)
-    end
+      let(:options) { { database: 'other' } }
 
-    it "passes down the options to collection" do
-      expect(instance.collection.database.name).to eq('test')
+      it 'sets the persistence context on the object' do
+        Band.new.with(persistence_context) do |band_instance|
+          expect(band_instance.persistence_context.options).to eq(persistence_context.options)
+        end
+      end
     end
+  end
 
-    context "when the object is shared between threads" do
-
-      before do
-        threads = []
-        doc = Band.create(name: "Beatles")
-        100.times do |i|
-          threads << Thread.new do
-            if i % 2 == 0
-              doc.with(nil).set(name: "Rolling Stones")
-            else
-              doc.with(options).set(name: "Beatles")
-            end
+  describe '.with', if: non_legacy_server? do
+
+    context 'when passing some options' do
+
+      let(:options) do
+        { database: 'other' }
+      end
+
+      let(:band) do
+        Band.create
+      end
+
+      let(:persistence_context) do
+        band.with(options) do |object|
+          object.persistence_context
+        end
+      end
+
+      it 'sets the options on the client' do
+        expect(persistence_context.client.options['database']).to eq(options[:database])
+      end
+
+      it 'does not set the options on instance level' do
+        expect(band.persistence_context.client.database.name).to eq('mongoid_test')
+      end
+
+      context 'when the options are not valid mongo client options' do
+
+        let(:persistence_context) do
+          band.with(invalid_options) do |object|
+            object.persistence_context
           end
         end
-        threads.join
+
+        let(:invalid_options) { { bad: 'option' } }
+
+        it 'raises an error' do
+          expect {
+            persistence_context
+          }.to raise_exception(Mongoid::Errors::InvalidPersistenceOption)
+        end
+
+        it 'clears the persistence context' do
+          begin; persistence_context; rescue Mongoid::Errors::InvalidPersistenceOption; end
+          expect(band.persistence_context).to eq(Mongoid::PersistenceContext.new(band))
+        end
       end
 
-      it "does not share the persistence options" do
-        expect(Band.persistence_options).to eq(nil)
+      context 'when the client options were configured using a uri' do
+
+        let(:config) do
+          {
+              default: { hosts: [ "127.0.0.1:27017" ], database: database_id },
+              secondary: { uri: "mongodb://127.0.0.1:27017/secondary-db" }
+          }
+        end
+
+        before do
+          Mongoid::Config.send(:clients=, config)
+        end
+
+        let(:persistence_context) do
+          band.with(client: :secondary) do |object|
+            object.persistence_context
+          end
+        end
+
+        it 'uses the database specified in the uri' do
+          expect(persistence_context.database_name).to eq('secondary-db')
+          expect(persistence_context.client.database.name).to eq('secondary-db')
+        end
       end
-    end
-  end
 
-  describe "#persistence_options" do
+      context 'when passing a block', if: testing_locally? do
 
-    it "touches the thread local" do
-      expect(Thread.current).to receive(:[]).with("[mongoid][Band]:persistence-options").and_return({foo: :bar})
-      expect(Band.persistence_options).to eq({foo: :bar})
-    end
+        let!(:connections_before) do
+          band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
+        end
 
-    it "cannot force a value on thread local" do
-      expect {
-        Band.set_persistence_options(Band, {})
-      }.to raise_error(NoMethodError)
-    end
-  end
+        let!(:connections_and_cluster_during) do
+          connections = nil
+          cluster = band.with(options) do |b|
+            b.reload
+            connections = band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
+            b.persistence_context.cluster
+          end
+          [ connections, cluster ]
+        end
 
-  describe ".persistence_options" do
+        let(:connections_during) do
+          connections_and_cluster_during[0]
+        end
+
+        let(:cluster_during) do
+          connections_and_cluster_during[1]
+        end
+
+        let(:connections_after) do
+          band.mongo_client.database.command(serverStatus: 1).first['connections']['current']
+        end
+
+        let!(:cluster_before) do
+          band.persistence_context.cluster
+        end
+
+        let(:cluster_after) do
+          band.persistence_context.cluster
+        end
 
-    context "when options exist on the current thread" do
+        context 'when the options create a new cluster' do
 
-      let(:klass) do
-        Band.with(write: { w: 2 })
+          let(:options) do
+            { connect_timeout: 2 }
+          end
+
+          it 'creates a new cluster' do
+            expect(connections_before).to be <(connections_during)
+            expect(cluster_before).not_to be(cluster_during)
+          end
+
+          it 'disconnects the new cluster when the block exits' do
+            expect(connections_before).to eq(connections_after)
+          end
+        end
+
+        context 'when the options do not create a new cluster' do
+
+          let(:options) { { read: :secondary } }
+
+          it 'does not create a new cluster' do
+            expect(connections_during).to eq(connections_before)
+          end
+
+          it 'does not disconnect the original cluster' do
+            expect(connections_after).to eq(connections_before)
+            expect(cluster_before).to be(cluster_after)
+          end
+        end
+      end
+
+      context 'when changing the collection' do
+
+        let(:options) do
+          { collection: 'other' }
+        end
+
+        it 'uses that collection' do
+          expect(persistence_context.collection.name).to eq(options[:collection])
+        end
       end
 
-      it "returns the options" do
-        expect(klass.persistence_options).to eq(write: { w: 2 })
+      context 'when the object is shared between threads' do
+
+        before do
+          threads = []
+          100.times do |i|
+            band = Band.create
+            threads << Thread.new do
+              if i % 2 == 0
+                band.with(collection: 'British') do |b|
+                  b.name = 'realised'
+                  b.upsert
+                end
+              else
+                band.with(collection: 'American') do |b|
+                  b.name = 'realized'
+                  b.upsert
+                end
+              end
+            end
+          end
+          threads.collect { |t| t.value }
+        end
+
+        let(:british_count) do
+          Band.with(collection: 'British') do |klass|
+            klass.all.count
+          end
+        end
+
+        let(:american_count) do
+          Band.with(collection: 'British') do |klass|
+            klass.all.count
+          end
+        end
+
+        it 'does not share the persistence options' do
+          expect(british_count).to eq(50)
+          expect(american_count).to eq(50)
+        end
       end
     end
 
-    context "when there are no options on the current thread" do
+    context 'when passing a persistence context' do
 
-      it "returns nil" do
-        expect(Band.persistence_options).to be_nil
+      let(:persistence_context) do
+        Band.with(options) do |klass|
+          klass.persistence_context
+        end
+      end
+
+      let(:options) { { database: 'other' } }
+
+      it 'sets the persistence context on the object' do
+        Band.with(persistence_context) do |band_class|
+          expect(band_class.persistence_context.options).to eq(persistence_context.options)
+        end
       end
     end
   end