mongoid 4.0.2 → 5.0.0

data/spec/mongoid/attributes/readonly_spec.rb

@@ -19,6 +19,17 @@ describe Mongoid::Attributes::Readonly do
       end
     end
 
+    context "when providing a field alias" do
+
+      before do
+        Person.attr_readonly :aliased_timestamp
+      end
+
+      it "adds the database field name to readonly attributes" do
+        expect(Person.readonly_attributes.to_a).to eq([ "at" ])
+      end
+    end
+
     context "when providing multiple fields" do
 
       before do
@@ -33,54 +44,71 @@ describe Mongoid::Attributes::Readonly do
     context "when creating a new document with a readonly field" do
 
       before do
-        Person.attr_readonly :title, :terms
+        Person.attr_readonly :title, :terms, :aliased_timestamp
       end
 
       let(:person) do
-        Person.create(title: "sir", terms: true)
+        Person.create(title: "sir", terms: true, aliased_timestamp: Time.at(42))
       end
 
       it "sets the first readonly value" do
         expect(person.title).to eq("sir")
       end
 
-      it "sets subsequent readonly values" do
+      it "sets the second readonly value" do
         expect(person.terms).to be true
       end
 
+      it "sets the third readonly value" do
+        expect(person.aliased_timestamp).to eq(Time.at(42))
+      end
+
       it "persists the first readonly value" do
         expect(person.reload.title).to eq("sir")
       end
 
-      it "persists subsequent readonly values" do
+      it "persists the second readonly value" do
         expect(person.reload.terms).to be true
       end
+
+      it "persists the third readonly value" do
+        expect(person.reload.aliased_timestamp).to eq(Time.at(42))
+      end
     end
 
     context "when updating an existing readonly field" do
 
       before do
-        Person.attr_readonly :title, :terms, :score
+        Person.attr_readonly :title, :terms, :score, :aliased_timestamp
       end
 
       let(:person) do
-        Person.create(title: "sir", terms: true, score: 1)
+        Person.create(title: "sir", terms: true, score: 1, aliased_timestamp: Time.at(42))
       end
 
       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 field" do
+        it "does not update the first field" do
           expect(person.title).to eq("sir")
         end
 
-        it "does not persist the changes" do
+        it "does not update the second field" do
+          expect(person.aliased_timestamp).to eq(Time.at(42))
+        end
+
+        it "does not persist the first field" do
           expect(person.reload.title).to eq("sir")
         end
+
+        it "does not persist the second field" do
+          expect(person.reload.aliased_timestamp).to eq(Time.at(42))
+        end
       end
 
       context "when updating via inc" do
@@ -127,64 +155,98 @@ describe Mongoid::Attributes::Readonly do
 
         before do
           person[:title] = "mr"
+          person[:aliased_timestamp] = Time.at(43)
           person.save
         end
 
-        it "does not update the field" do
+        it "does not update the first field" do
           expect(person.title).to eq("sir")
         end
 
-        it "does not persist the changes" do
+        it "does not update the second field" do
+          expect(person.aliased_timestamp).to eq(Time.at(42))
+        end
+
+        it "does not persist the first field" do
           expect(person.reload.title).to eq("sir")
         end
+
+        it "does not persist the second field" do
+          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 field" do
+        it "does not update the first field" do
           expect(person.title).to eq("sir")
         end
 
-        it "does not persist the changes" do
+        it "does not update the second field" do
+          expect(person.aliased_timestamp).to eq(Time.at(42))
+        end
+
+        it "does not persist the first field" do
           expect(person.reload.title).to eq("sir")
         end
+
+        it "does not persist the second field" do
+          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")
+          person.update_attributes(title: "mr", aliased_timestamp: Time.at(43))
           person.save
         end
 
-        it "does not update the field" do
+        it "does not update the first field" do
           expect(person.title).to eq("sir")
         end
 
-        it "does not persist the changes" do
+        it "does not update the second field" do
+          expect(person.aliased_timestamp).to eq(Time.at(42))
+        end
+
+        it "does not persist the first field" do
           expect(person.reload.title).to eq("sir")
         end
+
+        it "does not persist the second field" do
+          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")
+          person.update_attributes!(title: "mr", aliased_timestamp: Time.at(43))
           person.save
         end
 
-        it "does not update the field" do
+        it "does not update the first field" do
           expect(person.title).to eq("sir")
         end
 
-        it "does not persist the changes" do
+        it "does not update the second field" do
+          expect(person.aliased_timestamp).to eq(Time.at(42))
+        end
+
+        it "does not persist the first field" do
           expect(person.reload.title).to eq("sir")
         end
+
+        it "does not persist the second field" do
+          expect(person.reload.aliased_timestamp).to eq(Time.at(42))
+        end
       end
 
       context "when updating via update_attribute" do

data/spec/mongoid/attributes_spec.rb

@@ -172,7 +172,7 @@ describe Mongoid::Attributes do
         before do
           person.collection
             .find({ _id: person.id })
-            .update({ "$unset" => { age: 1 }})
+            .update_one({ "$unset" => { age: 1 }})
         end
 
         context "when found" do
@@ -742,7 +742,7 @@ describe Mongoid::Attributes do
         before do
           person.collection
             .find({ _id: person.id })
-            .update({ "$unset" => { age: 1 }})
+            .update_one({ "$unset" => { age: 1 }})
           Mongoid.raise_not_found_error = false
           person.reload
           Mongoid.raise_not_found_error = true
@@ -829,7 +829,7 @@ describe Mongoid::Attributes do
         before do
           person.collection
             .find({ _id: person.id })
-            .update({ "$unset" => { age: 1 }})
+            .update_one({ "$unset" => { age: 1 }})
           Mongoid.raise_not_found_error = false
           person.reload
           Mongoid.raise_not_found_error = true

data/spec/mongoid/changeable_spec.rb

@@ -661,6 +661,24 @@ describe Mongoid::Changeable do
       it "returns an array of changed field names" do
         expect(person.changed).to include("title")
       end
+
+    end
+
+    context "When the document has changed but changed back to the original" do
+
+      let(:person) do
+        Person.instantiate(title: "Grand Poobah")
+      end
+
+      before do
+        person.title = "Captain Obvious"
+        person.title = nil
+      end
+
+      it "returns an array of changed field names" do
+        expect(person.changed).not_to include("title")
+      end
+
     end
 
     context "when the document has not changed" do
@@ -793,6 +811,58 @@ describe Mongoid::Changeable do
       end
     end
 
+    context "when changed? has been called before child elements size change" do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:address) do
+        person.addresses.create(street: "hobrecht")
+      end
+
+      let!(:location) do
+        address.locations.create(name: "home")
+      end
+
+      before do
+        person.changed?
+      end
+
+      context "when adding via new" do
+
+        before do
+          address.locations.new
+        end
+
+        it "returns true" do
+          expect(person).to be_changed
+        end
+      end
+
+      context "when adding via build" do
+
+        before do
+          address.locations.build
+        end
+
+        it "returns true" do
+          expect(person).to be_changed
+        end
+      end
+
+      context "when adding via create" do
+
+        before do
+          address.locations.create
+        end
+
+        it "returns false" do
+          expect(person).to_not be_changed
+        end
+      end
+    end
+
     context "when a deeply embedded child has changed" do
 
       let(:person) do
@@ -1555,4 +1625,90 @@ describe Mongoid::Changeable do
       expect(person.setters).to_not eq({ "addresses" => nil })
     end
   end
+
+  context 'when nesting deeply embedded documents' do
+
+    context 'when persisting the root document' do
+
+      let!(:person) do
+        Person.create
+      end
+
+      it 'is not marked as changed' do
+        expect(person).to_not be_changed
+      end
+
+      context 'when creating a new first level embedded document' do
+
+        let!(:address) do
+          person.addresses.new(street: 'goltzstr.')
+        end
+
+        it 'flags the root document as changed' do
+          expect(person).to be_changed
+        end
+
+        it 'flags the first level child as changed' do
+          expect(address).to be_changed
+        end
+
+        context 'when building the lowest level document' do
+
+          before do
+            person.save
+          end
+
+          let!(:code) do
+            address.build_code
+          end
+
+          it 'flags the root document as changed' do
+            expect(person).to be_changed
+          end
+
+          it 'flags the first level embedded document as changed' do
+            expect(address).to be_changed
+          end
+
+          it 'flags the lowest level embedded document as changed' do
+            expect(code).to be_changed
+          end
+
+          context 'when saving the hierarchy' do
+
+            before do
+              person.save
+            end
+
+            let(:reloaded) do
+              Person.find(person.id)
+            end
+
+            it 'saves the first embedded document' do
+              expect(reloaded.addresses.first).to eq(address)
+            end
+
+            it 'saves the lowest level embedded document' do
+              expect(reloaded.addresses.first.code).to eq(code)
+            end
+
+            context 'when embedding further' do
+
+              let!(:deepest) do
+                reloaded.addresses.first.code.build_deepest
+              end
+
+              before do
+                reloaded.save
+              end
+
+              it 'saves the deepest embedded document' do
+                expect(reloaded.reload.addresses.first.code.deepest).to eq(deepest)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
 end

data/spec/mongoid/clients/factory_spec.rb

@@ -0,0 +1,284 @@
+require "spec_helper"
+
+describe Mongoid::Clients::Factory do
+
+  describe ".create" do
+
+    context "when provided a name" do
+
+      context "when the configuration exists" do
+
+        context "when the configuration is standard" do
+
+          let(:config) do
+            {
+              default: { hosts: [ "127.0.0.1:27017" ], database: database_id },
+              secondary: { hosts: [ "127.0.0.1:27017" ], database: database_id }
+            }
+          end
+
+          before do
+            Mongoid::Config.send(:clients=, config)
+          end
+
+          let(:client) do
+            described_class.create(:secondary)
+          end
+
+          let(:cluster) do
+            client.cluster
+          end
+
+          it "returns a client" do
+            expect(client).to be_a(Mongo::Client)
+          end
+
+          it "sets the cluster's seeds" do
+            expect(cluster.addresses.first.to_s).to eq("127.0.0.1:27017")
+          end
+        end
+
+        context "when the configuration has no ports" do
+
+          let(:config) do
+            {
+              default: { hosts: [ "127.0.0.1" ], database: database_id },
+              secondary: { hosts: [ "127.0.0.1" ], database: database_id }
+            }
+          end
+
+          before do
+            Mongoid::Config.send(:clients=, config)
+          end
+
+          let(:client) do
+            described_class.create(:secondary)
+          end
+
+          let(:default) do
+            described_class.create(:default)
+          end
+
+          let(:cluster) do
+            client.cluster
+          end
+
+          it "returns a client" do
+            expect(client).to be_a(Mongo::Client)
+          end
+
+          it "sets the cluster's seed ports to 27017" do
+            expect(cluster.addresses.first.to_s).to eq("127.0.0.1:27017")
+          end
+
+          it "sets ips with no ports to 27017" do
+            expect(default.cluster.addresses.first.to_s).to eq("127.0.0.1:27017")
+          end
+        end
+
+        context "when configured via a uri" do
+
+          context "when the uri has a single host:port" do
+
+            let(:config) do
+              {
+                default: { hosts: [ "127.0.0.1:27017" ], database: database_id },
+                secondary: { uri: "mongodb://127.0.0.1:27017/mongoid_test" }
+              }
+            end
+
+            before do
+              Mongoid::Config.send(:clients=, config)
+            end
+
+            let(:client) do
+              described_class.create(:secondary)
+            end
+
+            let(:cluster) do
+              client.cluster
+            end
+
+            it "returns a client" do
+              expect(client).to be_a(Mongo::Client)
+            end
+
+            it "sets the cluster's seeds" do
+              expect(cluster.addresses.first.to_s).to eq("127.0.0.1:27017")
+            end
+
+            it "sets the database" do
+              expect(client.options[:database]).to eq("mongoid_test")
+            end
+          end
+
+          context "when the uri has multiple host:port pairs" do
+
+            let(:config) do
+              {
+                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
+
+            before do
+              Mongoid::Config.send(:clients=, config)
+            end
+
+            let(:client) do
+              described_class.create(:secondary)
+            end
+
+            let(:cluster) do
+              client.cluster
+            end
+
+            let(:seeds) do
+              cluster.addresses.map{ |address| address.to_s }
+            end
+
+            it "returns a client" do
+              expect(client).to be_a(Mongo::Client)
+            end
+
+            it "sets the cluster's seeds" do
+              expect(seeds).to eq([ "127.0.0.1:27017", "127.0.0.1:27018" ])
+            end
+          end
+        end
+      end
+
+      context "when the configuration does not exist" do
+
+        it "raises an error" do
+          expect {
+            described_class.create(:unknown)
+          }.to raise_error(Mongoid::Errors::NoClientConfig)
+        end
+      end
+    end
+
+    context "when no name is provided" do
+
+      let(:config) do
+        { default: { hosts: ["127.0.0.1:27017"], database: database_id }}
+      end
+
+      before do
+        Mongoid::Config.send(:clients=, config)
+      end
+
+      let(:client) do
+        described_class.create
+      end
+
+      let(:cluster) do
+        client.cluster
+      end
+
+      let(:seeds) do
+        cluster.addresses.map{ |address| address.to_s }
+      end
+
+      it "returns the default client" do
+        expect(client).to be_a(Mongo::Client)
+      end
+
+      it "sets the cluster's seeds" do
+        expect(seeds).to eq([ "127.0.0.1:27017" ])
+      end
+    end
+
+    context "when nil is provided and no default config" do
+
+      let(:config) { nil }
+
+      before do
+        Mongoid.clients[:default] = nil
+      end
+
+      it "raises NoClientsConfig error" do
+        expect{ Mongoid::Clients::Factory.create(config) }.to raise_error(Mongoid::Errors::NoClientsConfig)
+      end
+    end
+  end
+
+  describe ".default" do
+
+    let(:config) do
+      { default: { hosts: ["127.0.0.1:27017"], database: database_id }}
+    end
+
+    before do
+      Mongoid::Config.send(:clients=, config)
+    end
+
+    let(:client) do
+      described_class.default
+    end
+
+    let(:cluster) do
+      client.cluster
+    end
+
+    let(:seeds) do
+      cluster.addresses.map{ |address| address.to_s }
+    end
+
+    it "returns the default client" do
+      expect(client).to be_a(Mongo::Client)
+    end
+
+    it "sets the cluster's seeds" do
+      expect(seeds).to eq([ "127.0.0.1:27017" ])
+    end
+  end
+
+  context "when options are provided with string keys" do
+
+    let(:config) do
+      {
+        default: {
+          hosts: [ "127.0.0.1:27017" ],
+          database: database_id,
+          options: {
+            "server_selection_timeout" => 10,
+            "write" => { "w" => 1 }
+          }
+        }
+      }
+    end
+
+    before do
+      Mongoid::Config.send(:clients=, config)
+    end
+
+    let(:client) do
+      described_class.default
+    end
+
+    let(:cluster) do
+      client.cluster
+    end
+
+    let(:seeds) do
+      cluster.addresses.map{ |address| address.to_s }
+    end
+
+    it "returns the default client" do
+      expect(client).to be_a(Mongo::Client)
+    end
+
+    it "sets the cluster's seeds" do
+      expect(seeds).to eq([ "127.0.0.1:27017" ])
+    end
+
+    it "sets the server selection timeout" do
+      expect(cluster.options[:server_selection_timeout]).to eq(10)
+    end
+
+    it "sets the write concern" do
+      expect(client.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
+    end
+  end
+end