mongoid 6.4.2 → 7.0.3

data/spec/mongoid/persistable_spec.rb

@@ -57,7 +57,7 @@ describe Mongoid::Persistable do
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
             "$unset" => { "origin" => true }},
-           { session: nil }]
+            { :session => nil } ]
         end
 
         before do
@@ -83,8 +83,8 @@ describe Mongoid::Persistable do
             "$inc" => { "member_count" => 10 },
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
-            "$unset" => { "origin" => true }},
-           { :session => nil } ]
+            "$unset" => { "origin" => true } },
+            { :session => nil } ]
         end
 
         before do
@@ -107,12 +107,12 @@ describe Mongoid::Persistable do
       context "when given multiple operations of the same type" do
 
         let(:operations) do
-          [{
+         [{
             "$inc" => { "member_count" => 10, "other_count" => 10 },
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
             "$unset" => { "origin" => true }},
-            { session: nil }]
+            { :session => nil } ]
         end
 
         before do
@@ -149,7 +149,7 @@ describe Mongoid::Persistable do
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
             "$unset" => { "origin" => true }},
-            { session: nil }]
+            { :session => nil } ]
         end
 
         before do
@@ -200,6 +200,21 @@ describe Mongoid::Persistable do
         expect(document.atomically).to be true
       end
     end
+
+    context "when the block has no operations" do
+        before do
+          expect_any_instance_of(Mongo::Collection::View).to_not receive(:update_one)
+        end
+
+        let!(:update) do
+          document.atomically do
+          end
+        end
+
+        it "doesn't update the document" do
+          expect(document.reload.origin).to eq("London")
+        end
+    end
   end
 
   describe "#fail_due_to_valiation!" do

data/spec/mongoid/persistence_context_spec.rb

@@ -536,7 +536,7 @@ describe Mongoid::PersistenceContext do
     end
 
     before do
-      Mongoid.clients[:alternative] = { database: :mongoid_test, hosts: [ "#{HOST}:#{PORT}" ] }
+      Mongoid.clients[:alternative] = { database: :mongoid_test, hosts: SpecConfig.instance.addresses }
     end
 
     after do

data/spec/mongoid/query_cache_spec.rb

@@ -31,28 +31,14 @@ describe Mongoid::QueryCache do
         :posts
       end
 
-      context 'when query cache is disabled' do
+      context 'does not query for the relation and instead sets the base' do
 
         before do
           Mongoid::QueryCache.enabled = false
         end
 
         it 'queries for each access to the base' do
-          expect(server).to receive(:with_connection).exactly(relations.size).times.and_call_original
-          relations.each do |object|
-            object.person
-          end
-        end
-      end
-
-      context 'when query cache is enabled' do
-
-        before do
-          Mongoid::QueryCache.enabled = true
-        end
-
-        it 'queries only once for the base' do
-          expect(server).to receive(:with_connection).exactly(1).times.and_call_original
+          expect(server).to receive(:with_connection).exactly(0).times.and_call_original
           relations.each do |object|
             object.person
           end
@@ -137,6 +123,36 @@ describe Mongoid::QueryCache do
     end
   end
 
+  context 'querying all documents after a single document' do
+    before do
+      3.times do
+        Person.create
+      end
+    end
+
+    it 'returns all documents' do
+      expect(Person.all.to_a.count).to eq(3)
+      Person.first
+      expect(Person.all.to_a.count).to eq(3)
+    end
+
+    context 'with conditions specified' do
+      it 'returns all documents' do
+        expect(Person.gt(age: 0).to_a.count).to eq(3)
+        Person.gt(age: 0).first
+        expect(Person.gt(age: 0).to_a.count).to eq(3)
+      end
+    end
+
+    context 'with order specified' do
+      it 'returns all documents' do
+        expect(Person.order_by(name: 1).to_a.count).to eq(3)
+        Person.order_by(name: 1).first
+        expect(Person.order_by(name: 1).to_a.count).to eq(3)
+      end
+    end
+  end
+
   context "when querying in the same collection" do
 
     before do
@@ -425,18 +441,18 @@ describe Mongoid::QueryCache do
     end
   end
 
-  context "when querying a very large collection" do
+  context "when querying collection smaller than the batch size" do
 
     before do
-      123.times { Band.create! }
+      99.times { Band.create! }
     end
 
     it "returns the right number of records" do
-      expect(Band.all.to_a.length).to eq(123)
+      expect(Band.all.to_a.length).to eq(99)
     end
 
     it "#pluck returns the same count of objects" do
-      expect(Band.pluck(:name).length).to eq(123)
+      expect(Band.pluck(:name).length).to eq(99)
     end
 
     context "when loading all the documents" do
@@ -447,12 +463,12 @@ describe Mongoid::QueryCache do
 
       it "caches the complete result of the query" do
         expect_no_queries do
-          expect(Band.all.to_a.length).to eq(123)
+          expect(Band.all.to_a.length).to eq(99)
         end
       end
 
       it "returns the same count of objects when using #pluck" do
-        expect(Band.pluck(:name).length).to eq(123)
+        expect(Band.pluck(:name).length).to eq(99)
       end
     end
   end
@@ -464,6 +480,29 @@ describe Mongoid::QueryCache do
       Band.collection.indexes.create_one(name: 1)
     end
   end
+
+  context 'when the initial query does not exhaust the results' do
+    before do
+      Mongoid::QueryCache.enabled = true
+      10.times { Band.create! }
+
+      Band.batch_size(4).all.any?
+    end
+
+    it 'does not cache the result' do
+      expect(Band.all.map(&:id).size).to eq(10)
+    end
+
+    context 'when a batch size smaller than the result set is specified' do
+      let(:batch_size) do
+        4
+      end
+
+      it 'does not cache the result' do
+        expect(Band.batch_size(batch_size).all.map(&:id).size).to eq(10)
+      end
+    end
+  end
 end
 
 describe Mongoid::QueryCache::Middleware do

data/spec/mongoid/relations/proxy_spec.rb

@@ -1,124 +1,124 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Proxy do
-
-  describe '#with', if: non_legacy_server? do
-
-    let(:circus) do
-      Circus.new
-    end
-
-    let(:animal) do
-      Animal.new
-    end
-
-    before do
-      circus.animals << animal
-      circus.save
-    end
-
-    it 'uses the new persistence options' do
-      expect {
-        animal.with(write: { w: 100 }) do |an|
-          an.update_attribute(:name, 'kangaroo')
-        end
-      }.to raise_exception(Mongo::Error::OperationFailure)
-    end
-  end
-
-  describe "#find" do
-    let(:person) do
-      Person.create
-    end
-
-    let(:messages) do
-      person.messages
-    end
-
-    let(:msg1) do
-      messages.create(body: 'msg1')
-    end
-
-    it "returns nil with no arguments" do
-      expect(messages.find).to be_nil
-      expect(messages.send(:find)).to be_nil
-      expect(messages.__send__(:find)).to be_nil
-      expect(messages.public_send(:find)).to be_nil
-    end
-
-    it "returns the object corresponding to the id" do
-      expect(messages.find(msg1.id)).to eq(msg1)
-      expect(messages.send(:find, msg1.id)).to eq(msg1)
-      expect(messages.__send__(:find, msg1.id)).to eq(msg1)
-      expect(messages.public_send(:find, msg1.id)).to eq(msg1)
-    end
-  end
-
-  describe "#extend" do
-
-    before(:all) do
-      Person.reset_callbacks(:validate)
-      module Testable
-      end
-    end
-
-    after(:all) do
-      Object.send(:remove_const, :Testable)
-    end
-
-    let(:person) do
-      Person.create
-    end
-
-    let(:name) do
-      person.build_name
-    end
-
-    before do
-      name.namable.extend(Testable)
-    end
-
-    it "extends the proxied object" do
-      expect(person).to be_a(Testable)
-    end
-
-    context "when extending from the relation definition" do
-
-      let!(:address) do
-        person.addresses.create(street: "hobrecht")
-      end
-
-      let(:found) do
-        person.addresses.find_by_street("hobrecht")
-      end
-
-      it "extends the proxy" do
-        expect(found).to eq(address)
-      end
-    end
-  end
-
-  describe "equality" do
-    let(:messages) do
-      Person.create.messages
-    end
-
-    it "is #equal? to itself" do
-      expect(messages.equal?(messages)).to eq(true)
-    end
-
-    it "is == to itself" do
-      expect(messages == messages).to eq(true)
-    end
-
-    it "is not #equal? to its target" do
-      expect(messages.equal?(messages.target)).to eq(false)
-      expect(messages.target.equal?(messages)).to eq(false)
-    end
-
-    it "is == to its target" do
-      expect(messages == messages.target).to eq(true)
-      expect(messages.target == messages).to eq(true)
-    end
-  end
-end
+# require "spec_helper"
+#
+# describe Mongoid::Relations::Proxy do
+#
+#   describe '#with', if: non_legacy_server? do
+#
+#     let(:circus) do
+#       Circus.new
+#     end
+#
+#     let(:animal) do
+#       Animal.new
+#     end
+#
+#     before do
+#       circus.animals << animal
+#       circus.save
+#     end
+#
+#     it 'uses the new persistence options' do
+#       expect {
+#         animal.with(write: { w: 100 }) do |an|
+#           an.update_attribute(:name, 'kangaroo')
+#         end
+#       }.to raise_exception(Mongo::Error::OperationFailure)
+#     end
+#   end
+#
+#   describe "#find" do
+#     let(:person) do
+#       Person.create
+#     end
+#
+#     let(:messages) do
+#       person.messages
+#     end
+#
+#     let(:msg1) do
+#       messages.create(body: 'msg1')
+#     end
+#
+#     it "returns nil with no arguments" do
+#       expect(messages.find).to be_nil
+#       expect(messages.send(:find)).to be_nil
+#       expect(messages.__send__(:find)).to be_nil
+#       expect(messages.public_send(:find)).to be_nil
+#     end
+#
+#     it "returns the object corresponding to the id" do
+#       expect(messages.find(msg1.id)).to eq(msg1)
+#       expect(messages.send(:find, msg1.id)).to eq(msg1)
+#       expect(messages.__send__(:find, msg1.id)).to eq(msg1)
+#       expect(messages.public_send(:find, msg1.id)).to eq(msg1)
+#     end
+#   end
+#
+#   describe "#extend" do
+#
+#     before(:all) do
+#       Person.reset_callbacks(:validate)
+#       module Testable
+#       end
+#     end
+#
+#     after(:all) do
+#       Object.send(:remove_const, :Testable)
+#     end
+#
+#     let(:person) do
+#       Person.create
+#     end
+#
+#     let(:name) do
+#       person.build_name
+#     end
+#
+#     before do
+#       name.namable.extend(Testable)
+#     end
+#
+#     it "extends the proxied object" do
+#       expect(person).to be_a(Testable)
+#     end
+#
+#     context "when extending from the relation definition" do
+#
+#       let!(:address) do
+#         person.addresses.create(street: "hobrecht")
+#       end
+#
+#       let(:found) do
+#         person.addresses.find_by_street("hobrecht")
+#       end
+#
+#       it "extends the proxy" do
+#         expect(found).to eq(address)
+#       end
+#     end
+#   end
+#
+#   describe "equality" do
+#     let(:messages) do
+#       Person.create.messages
+#     end
+#
+#     it "is #equal? to itself" do
+#       expect(messages.equal?(messages)).to eq(true)
+#     end
+#
+#     it "is == to itself" do
+#       expect(messages == messages).to eq(true)
+#     end
+#
+#     it "is not #equal? to its target" do
+#       expect(messages.equal?(messages.target)).to eq(false)
+#       expect(messages.target.equal?(messages)).to eq(false)
+#     end
+#
+#     it "is == to its target" do
+#       expect(messages == messages.target).to eq(true)
+#       expect(messages.target == messages).to eq(true)
+#     end
+#   end
+# end

data/spec/mongoid/scopable_spec.rb

@@ -1130,6 +1130,19 @@ describe Mongoid::Scopable do
     it "sets the threading options" do
       Band.without_default_scope do
         expect(Mongoid::Threaded).to be_executing(:without_default_scope)
+        expect(Mongoid::Threaded.without_default_scope?(Band)).to be(true)
+      end
+    end
+
+    it "suppresses default scope on the given model within the given block" do
+      Appointment.without_default_scope do
+        expect(Appointment.all.selector).to be_empty
+      end
+    end
+
+    it "does not affect other models' default scopes within the given block" do
+      Appointment.without_default_scope do
+        expect(Audio.all.selector).not_to be_empty
       end
     end
   end

data/spec/mongoid/shardable_spec.rb

@@ -49,23 +49,43 @@ describe Mongoid::Shardable do
     end
   end
 
-  describe "#shard_key_selector" do
+  describe '#shard_key_selector' do
+    subject { instance.shard_key_selector }
+    let(:klass) { Band }
+    let(:value) { 'a-brand-name' }
 
-    let(:klass) do
-      Band
-    end
+    before { klass.shard_key(:name) }
 
-    let(:object) do
-      klass.new
-    end
+    context 'when record is new' do
+      let(:instance) { klass.new(name: value) }
 
-    before do
-      klass.shard_key(:name)
-      object.name = "Jo"
+      it { is_expected.to eq({ 'name' => value }) }
+
+      context 'changing shard key value' do
+        let(:new_value) { 'a-new-value' }
+
+        before do
+          instance.name = new_value
+        end
+
+        it { is_expected.to eq({ 'name' => new_value }) }
+      end
     end
 
-    it "returns a hash of shard key names and values" do
-      expect(object.shard_key_selector).to eq({ "name" => "Jo" })
+    context 'when record is persisted' do
+      let(:instance) { klass.create(name: value) }
+
+      it { is_expected.to eq({ 'name' => value }) }
+
+      context 'changing shard key value' do
+        let(:new_value) { 'a-new-value' }
+
+        before do
+          instance.name = new_value
+        end
+
+        it { is_expected.to eq({ 'name' => value }) }
+      end
     end
   end
 end

data/spec/mongoid/threaded_spec.rb

@@ -233,4 +233,72 @@ describe Mongoid::Threaded do
       end
     end
   end
+
+  describe "#begin_without_default_scope" do
+
+    let(:klass) do
+      Appointment
+    end
+
+    after do
+      described_class.exit_without_default_scope(klass)
+    end
+
+    it "adds the given class to the without_default_scope stack" do
+      described_class.begin_without_default_scope(klass)
+
+      expect(described_class.stack(:without_default_scope)).to include(klass)
+    end
+  end
+
+  describe "#exit_without_default_scope" do
+
+    let(:klass) do
+      Appointment
+    end
+
+    before do
+      described_class.begin_without_default_scope(klass)
+    end
+
+    it "removes the given class from the without_default_scope stack" do
+      described_class.exit_without_default_scope(klass)
+
+      expect(described_class.stack(:without_default_scope)).not_to include(klass)
+    end
+  end
+
+  describe "#without_default_scope?" do
+
+    let(:klass) do
+      Appointment
+    end
+
+    context "when klass has begun without_default_scope" do
+
+      before do
+        described_class.begin_without_default_scope(klass)
+      end
+
+      after do
+        described_class.exit_without_default_scope(klass)
+      end
+
+      it "returns true" do
+        expect(described_class.without_default_scope?(klass)).to be(true)
+      end
+    end
+
+    context "when klass has exited without_default_scope" do
+
+      before do
+        described_class.begin_without_default_scope(klass)
+        described_class.exit_without_default_scope(klass)
+      end
+
+      it "returns false" do
+        expect(described_class.without_default_scope?(klass)).to be(false)
+      end
+    end
+  end
 end

data/spec/mongoid/{relations/touchable_spec.rb → touchable_spec.rb}

@@ -1,11 +1,36 @@
 require "spec_helper"
 
-describe Mongoid::Relations::Touchable do
+describe Mongoid::Touchable do
 
   describe "#touch" do
 
+    context "when the document has no associations" do
+      let(:updatable) do
+        Updatable.create
+      end
+
+      it "responds to #touch" do
+        expect(updatable).to respond_to(:touch)
+      end
+
+      it "updates the timestamp when called" do
+        expect(updatable.updated_at).to be_nil
+
+        updatable.touch
+        updated_at = updatable.updated_at
+        expect(updated_at).not_to be_nil
+
+        updatable.touch
+        expect(updatable.updated_at).to be > updated_at
+      end
+    end
+
     context "when the document is embedded" do
 
+      before do
+        Label.send(:include, Mongoid::Touchable::InstanceMethods)
+      end
+
       let(:band) do
         Band.create(name: "Placebo")
       end
@@ -29,6 +54,11 @@ describe Mongoid::Relations::Touchable do
 
     context "when no relations have touch options" do
 
+      before do
+        Person.send(:include, Mongoid::Touchable::InstanceMethods)
+        Agent.send(:include, Mongoid::Touchable::InstanceMethods)
+      end
+
       context "when no updated at is defined" do
 
         let(:person) do
@@ -209,6 +239,11 @@ describe Mongoid::Relations::Touchable do
 
       context "when the relation is a parent of an embedded doc" do
 
+        before do
+          Page.send(:include, Mongoid::Touchable::InstanceMethods)
+          Edit.send(:include, Mongoid::Touchable::InstanceMethods)
+        end
+
         let(:page) do
           WikiPage.create(title: "test")
         end
@@ -229,6 +264,10 @@ describe Mongoid::Relations::Touchable do
 
       context "when the parent of embedded doc has cascade callbacks" do
 
+        before do
+          Band.send(:include, Mongoid::Touchable::InstanceMethods)
+        end
+
         let!(:book) do
           Book.new
         end

data/spec/mongoid/validatable/associated_spec.rb

@@ -171,7 +171,7 @@ describe Mongoid::Validatable::AssociatedValidator do
         end
       end
 
-      context "when the assocation has all valid documents" do
+      context "when the association has all valid documents" do
 
         let(:associated) do
           double(valid?: true, flagged_for_destroy?: false)