mongoid 3.1.5 → 8.0.2

data/spec/mongoid/equality_spec.rb

@@ -1,4 +1,5 @@
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Equality do
@@ -20,7 +21,7 @@ describe Mongoid::Equality do
       end
 
       it "returns false" do
-        person.should_not eq(other)
+        expect(person).to_not eq(other)
       end
     end
 
@@ -39,7 +40,7 @@ describe Mongoid::Equality do
           end
 
           it "returns false" do
-            person.should_not eq(other)
+            expect(person).to_not eq(other)
           end
         end
 
@@ -54,7 +55,7 @@ describe Mongoid::Equality do
           end
 
           it "returns true" do
-            person.should eq(other)
+            expect(person).to eq(other)
           end
         end
       end
@@ -68,14 +69,14 @@ describe Mongoid::Equality do
         context "when the instances are the same" do
 
           it "returns true" do
-            person.should eq(person)
+            expect(person).to eq(person)
           end
         end
 
         context "when the instances are different" do
 
           it "returns false" do
-            person.should_not eq(other)
+            expect(person).to_not eq(other)
           end
         end
       end
@@ -84,92 +85,194 @@ describe Mongoid::Equality do
 
   describe ".===" do
 
-    context "when comparable is an instance of this document" do
+    context "when legacy_triple_equals is not set" do
+      config_override :legacy_triple_equals, false
+
+      context "when comparable is an instance of this document" do
 
-      it "returns true" do
-        (klass === person).should be_true
+        it "returns true" do
+          expect(klass === person).to be true
+        end
       end
-    end
 
-    context "when comparable is a relation of this document" do
+      context "when comparable is a relation of this document" do
+
+        let(:relation) do
+          Post.new(person: person).person
+        end
 
-      let(:relation) do
-        Post.new(person: person).person
+        it "returns true" do
+          expect(klass === relation).to be true
+        end
       end
 
-      it "returns true" do
-        (klass === relation).should be_true
+      context "when comparable is the same class" do
+
+        it "returns false" do
+          expect(klass === Person).to be false
+        end
       end
-    end
 
-    context "when comparable is the same class" do
+      context "when the comparable is a subclass" do
 
-      it "returns true" do
-        (klass === Person).should be_true
+        it "returns false" do
+          expect(Person === Doctor).to be false
+        end
       end
-    end
 
-    context "when the comparable is a subclass" do
+      context "when the comparable is an instance of a subclass" do
 
-      it "returns false" do
-        (Person === Doctor).should be_false
+        it "returns true" do
+          expect(Person === Doctor.new).to be true
+        end
       end
     end
 
-    context "when the comparable is an instance of a subclass" do
+    context "when legacy_triple_equals is set" do
+      config_override :legacy_triple_equals, true
+
+      context "when comparable is an instance of this document" do
 
-      it "returns true" do
-        (Person === Doctor.new).should be_true
+        it "returns true" do
+          expect(klass === person).to be true
+        end
       end
-    end
-  end
 
-  describe "#===" do
+      context "when comparable is a relation of this document" do
+
+        let(:relation) do
+          Post.new(person: person).person
+        end
+
+        it "returns true" do
+          expect(klass === relation).to be true
+        end
+      end
+
+      context "when comparable is the same class" do
 
-    context "when comparable is the same type" do
+        it "returns true" do
+          expect(klass === Person).to be true
+        end
+      end
 
-      context "when the instance is different" do
+      context "when the comparable is a subclass" do
 
         it "returns false" do
-          (person === Person.new).should be_false
+          expect(Person === Doctor).to be false
         end
       end
 
-      context "when the instance is the same" do
+      context "when the comparable is an instance of a subclass" do
 
         it "returns true" do
-          (person === person).should be_true
+          expect(Person === Doctor.new).to be true
         end
       end
     end
+  end
 
-    context "when the comparable is a subclass" do
+  describe "#===" do
 
-      it "returns false" do
-        (person === Doctor.new).should be_false
+    context "when legacy_triple_equals is set" do
+      config_override :legacy_triple_equals, true
+
+      context "when comparable is the same type" do
+
+        context "when the instance is different" do
+
+          it "returns false" do
+            expect(person === Person.new).to be false
+          end
+        end
+
+        context "when the instance is the same" do
+
+          it "returns true" do
+            expect(person === person).to be true
+          end
+        end
+      end
+
+      context "when the comparable is a subclass" do
+
+        it "returns false" do
+          expect(person === Doctor.new).to be false
+        end
+      end
+
+      context "when comparing to a class" do
+
+        context "when the class is the same" do
+
+          it "returns true" do
+            expect(person === Person).to be true
+          end
+        end
+
+        context "when the class is a subclass" do
+
+          it "returns false" do
+            expect(person === Doctor).to be false
+          end
+        end
+
+        context "when the class is a superclass" do
+
+          it "returns true" do
+            expect(Doctor.new === Person).to be true
+          end
+        end
       end
     end
 
-    context "when comparing to a class" do
+    context "when legacy_triple_equals is not set" do
+      config_override :legacy_triple_equals, false
 
-      context "when the class is the same" do
+      context "when comparable is the same type" do
 
-        it "returns true" do
-          (person === Person).should be_true
+        context "when the instance is different" do
+
+          it "returns false" do
+            expect(person === Person.new).to be false
+          end
+        end
+
+        context "when the instance is the same" do
+
+          it "returns true" do
+            expect(person === person).to be true
+          end
         end
       end
 
-      context "when the class is a subclass" do
+      context "when the comparable is a subclass" do
 
         it "returns false" do
-          (person === Doctor).should be_false
+          expect(person === Doctor.new).to be false
         end
       end
 
-      context "when the class is a superclass" do
+      context "when comparing to a class" do
+        context "when the class is the same" do
 
-        it "returns true" do
-          (Doctor.new === Person).should be_true
+          it "returns false" do
+            expect(person === Person).to be false
+          end
+        end
+
+        context "when the class is a subclass" do
+
+          it "returns false" do
+            expect(person === Doctor).to be false
+          end
+        end
+
+        context "when the class is a superclass" do
+
+          it "returns false" do
+            expect(Doctor.new === Person).to be false
+          end
         end
       end
     end
@@ -186,7 +289,7 @@ describe Mongoid::Equality do
     end
 
     it "compares based on the document id" do
-      (first <=> second ).should eq(-1)
+      expect(first <=> second).to eq(-1)
     end
   end
 
@@ -199,7 +302,7 @@ describe Mongoid::Equality do
       end
 
       it "returns false" do
-        person.should_not be_eql(other)
+        expect(person).to_not be_eql(other)
       end
     end
 
@@ -216,7 +319,7 @@ describe Mongoid::Equality do
         end
 
         it "returns true" do
-          person.should be_eql(other)
+          expect(person).to be_eql(other)
         end
       end
 
@@ -225,17 +328,17 @@ describe Mongoid::Equality do
         context "when the instances are the same" do
 
           it "returns true" do
-            person.should be_eql(person)
+            expect(person).to be_eql(person)
           end
         end
 
         context "when the instances are different" do
 
           it "returns false" do
-            person.should_not be_eql(other)
+            expect(person).to_not be_eql(other)
           end
         end
       end
     end
   end
-end
+end

data/spec/mongoid/errors/ambiguous_relationship_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Mongoid::Errors::AmbiguousRelationship do
@@ -9,20 +11,20 @@ describe Mongoid::Errors::AmbiguousRelationship do
     end
 
     it "contains the problem in the message" do
-      error.message.should include(
-        "Ambiguous relations :drugs, :evil_drugs defined on Person."
+      expect(error.message).to include(
+        "Ambiguous associations :drugs, :evil_drugs defined on Person."
       )
     end
 
     it "contains the summary in the message" do
-      error.message.should include(
-        "When Mongoid attempts to set an inverse document of a relation in memory"
+      expect(error.message).to include(
+        "When Mongoid attempts to set an inverse document of an association in memory"
       )
     end
 
     it "contains the resolution in the message" do
-      error.message.should include(
-        "On the :person relation on Drug you must add an :inverse_of option"
+      expect(error.message).to include(
+        "On the :person association on Drug you must add an :inverse_of option"
       )
     end
   end

data/spec/mongoid/errors/callback_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Errors::Callback do
@@ -9,19 +11,19 @@ describe Mongoid::Errors::Callback do
     end
 
     it "contains the problem in the message" do
-      error.message.should include(
+      expect(error.message).to include(
         "Calling create! on Post resulted in a false return from a callback."
       )
     end
 
     it "contains the summary in the message" do
-      error.message.should include(
+      expect(error.message).to include(
         "If a before callback returns false when using Document.create!"
       )
     end
 
     it "contains the resolution in the message" do
-      error.message.should include(
+      expect(error.message).to include(
         "Double check all before callbacks to make sure they are not"
       )
     end

data/spec/mongoid/errors/delete_restriction_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Errors::DeleteRestriction do
@@ -9,19 +11,19 @@ describe Mongoid::Errors::DeleteRestriction do
     end
 
     it "contains the problem in the message" do
-      error.message.should include(
-        "Cannot delete Person because of dependent 'drugs'."
+      expect(error.message).to include(
+        "Cannot destroy Person because of dependent 'drugs'."
       )
     end
 
     it "contains the summary in the message" do
-      error.message.should include(
-        "When defining 'drugs' with a :dependent => :restrict,"
+      expect(error.message).to include(
+        "When defining 'drugs' with a :dependent => :restrict_with_error,"
       )
     end
 
     it "contains the resolution in the message" do
-      error.message.should include(
+      expect(error.message).to include(
         "Don't attempt to delete the parent Person when it has children"
       )
     end

data/spec/mongoid/errors/document_not_destroyed_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Errors::DocumentNotDestroyed do
+
+  describe "#message" do
+
+    let(:post) do
+      Post.new
+    end
+
+    let(:error) do
+      described_class.new(post.id, Post)
+    end
+
+    it "contains the problem in the message" do
+      expect(error.message).to include(
+        "Post with id #{post.id.inspect} was not destroyed"
+      )
+    end
+
+    it "contains the summary in the message" do
+      expect(error.message).to include(
+        "When calling Post#destroy! and a callback halts the destroy callback"
+      )
+    end
+
+    it "contains the resolution in the message" do
+      expect(error.message).to include(
+        "Check the before/after destroy callbacks to ensure"
+      )
+    end
+  end
+end

data/spec/mongoid/errors/document_not_found_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Errors::DocumentNotFound do
@@ -11,19 +13,19 @@ describe Mongoid::Errors::DocumentNotFound do
       end
 
       it "contains the problem in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "Document(s) not found for class Person with id(s) 1."
         )
       end
 
       it "contains the summary in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "When calling Person.find with an id or array of ids"
         )
       end
 
       it "contains the resolution in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "Search for an id that is in the database or set the"
         )
       end
@@ -36,19 +38,19 @@ describe Mongoid::Errors::DocumentNotFound do
       end
 
       it "contains the problem in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "Document(s) not found for class Person with id(s) 1."
         )
       end
 
       it "contains the summary in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "When calling Person.find with an id or array of ids"
         )
       end
 
       it "contains the resolution in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "Search for an id that is in the database or set the"
         )
       end
@@ -61,23 +63,99 @@ describe Mongoid::Errors::DocumentNotFound do
       end
 
       it "contains the problem in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "Document not found for class Person with attributes {:name=>\"syd\"}."
         )
       end
 
       it "contains the summary in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "When calling Person.find_by with a hash of attributes"
         )
       end
 
       it "contains the resolution in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "Search for attributes that are in the database or set"
         )
       end
     end
+
+    context "when providing an _id and a shard key" do
+
+      let(:id) { BSON::ObjectId.new }
+      let(:doc) { { _id: id, a: "syd" } }
+      let(:error) do
+        described_class.new(Person, id, doc)
+      end
+
+      it "contains the problem in the message" do
+        expect(error.message).to include(
+          "Document not found for class Person with id #{id.to_s} and shard key a: syd."
+        )
+      end
+
+      it "contains the summary in the message" do
+        expect(error.message).to include(
+          "When calling Person.find with an id and a shard key"
+        )
+      end
+
+      it "contains the resolution in the message" do
+        expect(error.message).to include(
+          "Search for an id/shard key that is in the database or set"
+        )
+      end
+    end
+
+    context "when providing an id in a hash without a shard key" do
+
+      let(:error) do
+        described_class.new(Person, 1, { _id: 1 })
+      end
+
+      it "contains the problem in the message" do
+        expect(error.message).to include(
+          "Document(s) not found for class Person with id(s) 1."
+        )
+      end
+
+      it "contains the summary in the message" do
+        expect(error.message).to include(
+          "When calling Person.find with an id or array of ids"
+        )
+      end
+
+      it "contains the resolution in the message" do
+        expect(error.message).to include(
+          "Search for an id that is in the database or set the"
+        )
+      end
+    end
+
+    context "when not providing params or unmatched" do
+      let(:error) do
+        described_class.new(Person, nil, nil)
+      end
+
+      it "contains the problem in the message" do
+        expect(error.message).to include(
+          "Could not find a document of class Person."
+        )
+      end
+
+      it "contains the summary in the message" do
+        expect(error.message).to include(
+          "Mongoid attempted to find a document of the class Person but none exist."
+        )
+      end
+
+      it "contains the resolution in the message" do
+        expect(error.message).to include(
+          "Create a document of class Person or use a finder method that does not raise an exception when no documents are found."
+        )
+      end
+    end
   end
 
   describe "#params" do
@@ -87,7 +165,7 @@ describe Mongoid::Errors::DocumentNotFound do
     end
 
     it "returns the parameters passed to the find" do
-      error.params.should eq(1)
+      expect(error.params).to eq(1)
     end
   end
 
@@ -98,7 +176,7 @@ describe Mongoid::Errors::DocumentNotFound do
     end
 
     it "returns the model class" do
-      error.klass.should eq(Person)
+      expect(error.klass).to eq(Person)
     end
   end
 end

data/spec/mongoid/errors/invalid_collection_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Errors::InvalidCollection do
@@ -15,19 +17,19 @@ describe Mongoid::Errors::InvalidCollection do
       end
 
       it "contains the problem in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "Access to the collection for Address is not allowed."
         )
       end
 
       it "contains the summary in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "Address.collection was called, and Address is an embedded document"
         )
       end
 
       it "contains the resolution in the message" do
-        error.message.should include(
+        expect(error.message).to include(
           "For access to the collection that the embedded document is in"
         )
       end

data/spec/mongoid/errors/invalid_config_file_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Errors::InvalidConfigFile do
+
+  describe "#message" do
+
+    let(:error) do
+      described_class.new('/my/path')
+    end
+
+    it "contains the problem in the message" do
+      expect(error.message).to include(
+        "Invalid configuration file: /my/path."
+      )
+    end
+
+    it "contains the summary in the message" do
+      expect(error.message).to include(
+        "Your mongoid.yml configuration file does not contain the"
+      )
+    end
+
+    it "contains the resolution in the message" do
+      expect(error.message).to include(
+        "Ensure your configuration file contains the correct contents."
+      )
+    end
+  end
+end