mongoid 5.4.0 → 6.4.8

data/spec/mongoid/attributes/readonly_spec.rb

@@ -2,49 +2,56 @@ require "spec_helper"
 
 describe Mongoid::Attributes::Readonly do
 
-  describe ".attr_readonly" do
+  before do
+    Person.attr_readonly(*attributes)
+  end
 
-    after do
-      Person.readonly_attributes.clear
+  after do
+    Person.readonly_attributes.reject! do |a|
+      [ attributes ].flatten.include?(a.to_sym) ||
+        [ attributes ].flatten.include?(Person.aliased_fields.key(a).to_sym)
     end
+  end
+
+  describe ".attr_readonly" do
 
     context "when providing a single field" do
 
-      before do
-        Person.attr_readonly :title
+      let(:attributes) do
+        :title
       end
 
       it "adds the field to readonly attributes" do
-        expect(Person.readonly_attributes.to_a).to eq([ "title" ])
+        expect(Person.readonly_attributes.to_a).to include("title")
       end
     end
 
     context "when providing a field alias" do
 
-      before do
-        Person.attr_readonly :aliased_timestamp
+      let(:attributes) do
+        :aliased_timestamp
       end
 
       it "adds the database field name to readonly attributes" do
-        expect(Person.readonly_attributes.to_a).to eq([ "at" ])
+        expect(Person.readonly_attributes.to_a).to include("at")
       end
     end
 
     context "when providing multiple fields" do
 
-      before do
-        Person.attr_readonly :title, :terms
+      let(:attributes) do
+        [ :title, :terms ]
       end
 
       it "adds the fields to readonly attributes" do
-        expect(Person.readonly_attributes.to_a).to eq([ "title", "terms" ])
+        expect(Person.readonly_attributes.to_a).to include("title", "terms")
       end
     end
 
     context "when creating a new document with a readonly field" do
 
-      before do
-        Person.attr_readonly :title, :terms, :aliased_timestamp
+      let(:attributes) do
+        [ :title, :terms, :aliased_timestamp ]
       end
 
       let(:person) do
@@ -78,8 +85,8 @@ describe Mongoid::Attributes::Readonly do
 
     context "when updating an existing readonly field" do
 
-      before do
-        Person.attr_readonly :title, :terms, :score, :aliased_timestamp
+      let(:attributes) do
+        [ :title, :terms, :score, :aliased_timestamp ]
       end
 
       let(:person) do
@@ -88,25 +95,31 @@ describe Mongoid::Attributes::Readonly do
 
       context "when updating via the setter" do
 
-        before do
-          person.title = "mr"
-          person.aliased_timestamp = Time.at(43)
-          person.save
-        end
-
         it "does not update the first field" do
+          expect {
+            person.title = 'mr'
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.title).to eq("sir")
         end
 
         it "does not update the second field" do
+          expect {
+            person.aliased_timestamp = Time.at(43)
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.aliased_timestamp).to eq(Time.at(42))
         end
 
         it "does not persist the first field" do
+          expect {
+            person.title = 'mr'
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.reload.title).to eq("sir")
         end
 
         it "does not persist the second field" do
+          expect {
+            person.aliased_timestamp = Time.at(43)
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.reload.aliased_timestamp).to eq(Time.at(42))
         end
       end
@@ -114,6 +127,7 @@ describe Mongoid::Attributes::Readonly do
       context "when updating via inc" do
 
         context 'with single field operation' do
+
           it "raises an error " do
             expect {
               person.inc(score: 1)
@@ -122,6 +136,7 @@ describe Mongoid::Attributes::Readonly do
         end
 
         context 'with multiple fields operation' do
+
           it "raises an error " do
             expect {
               person.inc(score: 1, age: 1)
@@ -133,6 +148,7 @@ describe Mongoid::Attributes::Readonly do
       context "when updating via bit" do
 
         context 'with single field operation' do
+
           it "raises an error " do
             expect {
               person.bit(score: { or: 13 })
@@ -141,6 +157,7 @@ describe Mongoid::Attributes::Readonly do
         end
 
         context 'with multiple fields operation' do
+
           it "raises an error " do
             expect {
               person.bit(
@@ -153,98 +170,124 @@ describe Mongoid::Attributes::Readonly do
 
       context "when updating via []=" do
 
-        before do
-          person[:title] = "mr"
-          person[:aliased_timestamp] = Time.at(43)
-          person.save
-        end
-
         it "does not update the first field" do
+          expect {
+            person[:title] = "mr"
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.title).to eq("sir")
         end
 
         it "does not update the second field" do
+          expect {
+            person[:aliased_timestamp] = Time.at(43)
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.aliased_timestamp).to eq(Time.at(42))
         end
 
         it "does not persist the first field" do
+          expect {
+            person[:title] = "mr"
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.reload.title).to eq("sir")
         end
 
         it "does not persist the second field" do
+          expect {
+            person[:aliased_timestamp] = Time.at(43)
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.reload.aliased_timestamp).to eq(Time.at(42))
         end
       end
 
       context "when updating via write_attribute" do
 
-        before do
-          person.write_attribute(:title, "mr")
-          person.write_attribute(:aliased_timestamp, Time.at(43))
-          person.save
-        end
-
         it "does not update the first field" do
+          expect {
+            person.write_attribute(:title, "mr")
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.title).to eq("sir")
         end
 
         it "does not update the second field" do
+          expect {
+            person.write_attribute(:aliased_timestamp, Time.at(43))
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.aliased_timestamp).to eq(Time.at(42))
         end
 
         it "does not persist the first field" do
+          expect {
+            person.write_attribute(:title, "mr")
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.reload.title).to eq("sir")
         end
 
         it "does not persist the second field" do
+          expect {
+            person.write_attribute(:aliased_timestamp, Time.at(43))
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.reload.aliased_timestamp).to eq(Time.at(42))
         end
       end
 
       context "when updating via update_attributes" do
 
-        before do
-          person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
-          person.save
-        end
-
         it "does not update the first field" do
+          expect {
+            person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.title).to eq("sir")
         end
 
         it "does not update the second field" do
+          expect {
+            person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.aliased_timestamp).to eq(Time.at(42))
         end
 
         it "does not persist the first field" do
+          expect {
+            person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.reload.title).to eq("sir")
         end
 
         it "does not persist the second field" do
+          expect {
+            person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.reload.aliased_timestamp).to eq(Time.at(42))
         end
       end
 
       context "when updating via update_attributes!" do
 
-        before do
-          person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
-          person.save
-        end
-
         it "does not update the first field" do
+          expect {
+            person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.title).to eq("sir")
         end
 
         it "does not update the second field" do
+          expect {
+            person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.aliased_timestamp).to eq(Time.at(42))
         end
 
         it "does not persist the first field" do
+          expect {
+            person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.reload.title).to eq("sir")
         end
 
         it "does not persist the second field" do
+          expect {
+            person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
+          }.to raise_exception(Mongoid::Errors::ReadonlyAttribute)
           expect(person.reload.aliased_timestamp).to eq(Time.at(42))
         end
       end

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
@@ -1322,6 +1385,21 @@ describe Mongoid::Attributes do
     end
   end
 
+  describe "#typed_attributes"  do
+    
+    let(:date_time) do
+      DateTime.current
+    end
+
+    let(:user) do
+      User.new(last_login: date_time)
+    end
+
+    it 'returns typecasted attributes' do
+      expect(user.typed_attributes).to include("last_login" => date_time)
+    end
+  end
+
   [:attributes=, :write_attributes].each do |method|
 
     describe "##{method}" do
@@ -1709,15 +1787,22 @@ describe Mongoid::Attributes do
 
     context 'when the attribute is localized' do
       let(:person) do
-        Person.create(desc: 'localized')
+        Person.create
       end
 
-      before do
-        person.desc = nil
+      context 'after initialization when the field is nil' do
+
+        it 'returns false' do
+          expect(person.desc?).to be(false)
+        end
       end
 
-      it 'applies the localization when checking the attribute' do
-        expect(person.desc?).to be(false)
+      context 'when setting the field to nil' do
+
+        it 'applies the localization when checking the attribute' do
+          person.desc = nil
+          expect(person.desc?).to be(false)
+        end
       end
 
       context 'when the field is a boolean' 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