mongoid 6.4.4 → 7.1.7

data/spec/mongoid/{relations → association}/macros_spec.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
-describe Mongoid::Relations::Macros do
+describe Mongoid::Association::Macros do
 
   class TestClass
     include Mongoid::Document
@@ -65,7 +68,7 @@ describe Mongoid::Relations::Macros do
         klass.embedded_in(:person)
       end
 
-      it "adds the metadata to the klass" do
+      it "adds the association to the klass" do
         expect(klass.relations["person"]).to_not be_nil
       end
 
@@ -78,8 +81,8 @@ describe Mongoid::Relations::Macros do
       end
 
       it "creates the correct relation" do
-        expect(klass.relations["person"].relation).to eq(
-          Mongoid::Relations::Embedded::In
+        expect(klass.relations["person"]).to be_a(
+          Mongoid::Association::Embedded::EmbeddedIn
         )
       end
 
@@ -87,18 +90,27 @@ describe Mongoid::Relations::Macros do
         expect(klass._validators).to be_empty
       end
 
-      context "metadata properties" do
+      context 'when an invalid option is provided' do
+
+        it 'raises an InvalidRelationOption exception' do
+          expect {
+            klass.embedded_in(:person, sandwich: true)
+          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+        end
+      end
+
+      context "association properties" do
 
-        let(:metadata) do
+        let(:association) do
           klass.relations["person"]
         end
 
         it "automatically adds the name" do
-          expect(metadata.name).to eq(:person)
+          expect(association.name).to eq(:person)
         end
 
         it "automatically adds the inverse class name" do
-          expect(metadata.inverse_class_name).to eq("TestClass")
+          expect(association.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -129,7 +141,7 @@ describe Mongoid::Relations::Macros do
         klass.embeds_many(:addresses)
       end
 
-      it "adds the metadata to the klass" do
+      it "adds the association to the klass" do
         expect(klass.relations["addresses"]).to_not be_nil
       end
 
@@ -142,8 +154,8 @@ describe Mongoid::Relations::Macros do
       end
 
       it "creates the correct relation" do
-        expect(klass.relations["addresses"].relation).to eq(
-          Mongoid::Relations::Embedded::Many
+        expect(klass.relations["addresses"]).to be_a(
+          Mongoid::Association::Embedded::EmbedsMany
         )
       end
 
@@ -153,18 +165,27 @@ describe Mongoid::Relations::Macros do
         )
       end
 
-      context "metadata properties" do
+      context 'when an invalid option is provided' do
+
+        it 'raises an InvalidRelationOption exception' do
+          expect {
+            klass.embeds_many(:addresses, sandwich: true)
+          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+        end
+      end
+
+      context "association properties" do
 
-        let(:metadata) do
+        let(:association) do
           klass.relations["addresses"]
         end
 
         it "automatically adds the name" do
-          expect(metadata.name).to eq(:addresses)
+          expect(association.name).to eq(:addresses)
         end
 
         it "automatically adds the inverse class name" do
-          expect(metadata.inverse_class_name).to eq("TestClass")
+          expect(association.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -175,16 +196,16 @@ describe Mongoid::Relations::Macros do
         klass.embeds_many(:addresses, order: :number.asc)
       end
 
-      let(:metadata) do
+      let(:association) do
         klass.relations["addresses"]
       end
 
-      it "adds metadata to klass" do
-        expect(metadata.order).to_not be_nil
+      it "adds association to klass" do
+        expect(association.order).to_not be_nil
       end
 
       it "returns Mongoid::Criteria::Queryable::Key" do
-        expect(metadata.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
+        expect(association.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
       end
     end
 
@@ -225,7 +246,7 @@ describe Mongoid::Relations::Macros do
         klass.embeds_one(:name)
       end
 
-      it "adds the metadata to the klass" do
+      it "adds the association to the klass" do
         expect(klass.relations["name"]).to_not be_nil
       end
 
@@ -246,8 +267,8 @@ describe Mongoid::Relations::Macros do
       end
 
       it "creates the correct relation" do
-        expect(klass.relations["name"].relation).to eq(
-          Mongoid::Relations::Embedded::One
+        expect(klass.relations["name"]).to be_a(
+          Mongoid::Association::Embedded::EmbedsOne
         )
       end
 
@@ -257,18 +278,27 @@ describe Mongoid::Relations::Macros do
         )
       end
 
-      context "metadata properties" do
+      context 'when an invalid option is provided' do
 
-        let(:metadata) do
+        it 'raises an InvalidRelationOption exception' do
+          expect {
+            klass.embeds_one(:name, sandwich: true)
+          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+        end
+      end
+
+      context "association properties" do
+
+        let(:association) do
           klass.relations["name"]
         end
 
         it "automatically adds the name" do
-          expect(metadata.name).to eq(:name)
+          expect(association.name).to eq(:name)
         end
 
         it "automatically adds the inverse class name" do
-          expect(metadata.inverse_class_name).to eq("TestClass")
+          expect(association.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -328,6 +358,15 @@ describe Mongoid::Relations::Macros do
 
     context 'when the relation has options' do
 
+      context 'when an invalid option is provided' do
+
+        it 'raises an InvalidRelationOption exception' do
+          expect {
+            klass.belongs_to(:person, sandwich: true)
+          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+        end
+      end
+
       context 'when the relation has the option :required' do
 
         context 'when the relation does not have the :optional option' do
@@ -620,7 +659,7 @@ describe Mongoid::Relations::Macros do
         klass.belongs_to(:person)
       end
 
-      it "adds the metadata to the klass" do
+      it "adds the association to the klass" do
         expect(klass.relations["person"]).to_not be_nil
       end
 
@@ -641,8 +680,8 @@ describe Mongoid::Relations::Macros do
       end
 
       it "creates the correct relation" do
-        expect(klass.relations["person"].relation).to eq(
-          Mongoid::Relations::Referenced::In
+        expect(klass.relations["person"]).to be_a(
+          Mongoid::Association::Referenced::BelongsTo
         )
       end
 
@@ -650,18 +689,18 @@ describe Mongoid::Relations::Macros do
         expect(klass.allocate).to respond_to(:person_id)
       end
 
-      context "metadata properties" do
+      context "association properties" do
 
-        let(:metadata) do
+        let(:association) do
           klass.relations["person"]
         end
 
         it "automatically adds the name" do
-          expect(metadata.name).to eq(:person)
+          expect(association.name).to eq(:person)
         end
 
         it "automatically adds the inverse class name" do
-          expect(metadata.inverse_class_name).to eq("TestClass")
+          expect(association.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -692,7 +731,7 @@ describe Mongoid::Relations::Macros do
         klass.has_many(:posts)
       end
 
-      it "adds the metadata to the klass" do
+      it "adds the association to the klass" do
         expect(klass.relations["posts"]).to_not be_nil
       end
 
@@ -705,8 +744,8 @@ describe Mongoid::Relations::Macros do
       end
 
       it "creates the correct relation" do
-        expect(klass.relations["posts"].relation).to eq(
-          Mongoid::Relations::Referenced::Many
+        expect(klass.relations["posts"]).to be_a(
+          Mongoid::Association::Referenced::HasMany
         )
       end
 
@@ -716,18 +755,27 @@ describe Mongoid::Relations::Macros do
         )
       end
 
-      context "metadata properties" do
+      context "association properties" do
 
-        let(:metadata) do
+        let(:association) do
           klass.relations["posts"]
         end
 
         it "automatically adds the name" do
-          expect(metadata.name).to eq(:posts)
+          expect(association.name).to eq(:posts)
         end
 
         it "automatically adds the inverse class name" do
-          expect(metadata.inverse_class_name).to eq("TestClass")
+          expect(association.inverse_class_name).to eq("TestClass")
+        end
+      end
+
+      context 'when an invalid option is provided' do
+
+        it 'raises an InvalidRelationOption exception' do
+          expect {
+            klass.has_many(:names, sandwich: true)
+          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
         end
       end
     end
@@ -738,16 +786,16 @@ describe Mongoid::Relations::Macros do
         klass.has_many(:posts, order: :rating.asc)
       end
 
-      let(:metadata) do
+      let(:association) do
         klass.relations["posts"]
       end
 
-      it "adds metadata to klass" do
-        expect(metadata.order).to_not be_nil
+      it "adds association to klass" do
+        expect(association.order).to_not be_nil
       end
 
       it "returns Mongoid::Criteria::Queryable::Key" do
-        expect(metadata.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
+        expect(association.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
       end
     end
 
@@ -784,11 +832,20 @@ describe Mongoid::Relations::Macros do
         end
       end
 
+      context 'when an invalid option is provided' do
+
+        it 'raises an InvalidRelationOption exception' do
+          expect {
+            klass.has_and_belongs_to_many(:fields, sandwich: true)
+          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+        end
+      end
+
       before do
         klass.has_and_belongs_to_many(:preferences)
       end
 
-      it "adds the metadata to the klass" do
+      it "adds the association to the klass" do
         expect(klass.relations["preferences"]).to_not be_nil
       end
 
@@ -801,8 +858,8 @@ describe Mongoid::Relations::Macros do
       end
 
       it "creates the correct relation" do
-        expect(klass.relations["preferences"].relation).to eq(
-          Mongoid::Relations::Referenced::ManyToMany
+        expect(klass.relations["preferences"]).to be_a(
+          Mongoid::Association::Referenced::HasAndBelongsToMany
         )
       end
 
@@ -816,31 +873,31 @@ describe Mongoid::Relations::Macros do
           klass.has_and_belongs_to_many(:preferences, order: :ranking.asc)
         end
 
-        let(:metadata) do
+        let(:association) do
           klass.relations["preferences"]
         end
 
-        it "adds metadata to klass" do
-          expect(metadata.order).to_not be_nil
+        it "adds association to klass" do
+          expect(association.order).to_not be_nil
         end
 
         it "returns Mongoid::Criteria::Queryable::Key" do
-          expect(metadata.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
+          expect(association.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
         end
       end
 
-      context "metadata properties" do
+      context "association properties" do
 
-        let(:metadata) do
+        let(:association) do
           klass.relations["preferences"]
         end
 
         it "automatically adds the name" do
-          expect(metadata.name).to eq(:preferences)
+          expect(association.name).to eq(:preferences)
         end
 
         it "automatically adds the inverse class name" do
-          expect(metadata.inverse_class_name).to eq("TestClass")
+          expect(association.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -867,11 +924,20 @@ describe Mongoid::Relations::Macros do
         end
       end
 
+      context 'when an invalid option is provided' do
+
+        it 'raises an InvalidRelationOption exception' do
+          expect {
+            klass.has_one(:game, sandwich: true)
+          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+        end
+      end
+
       before do
         klass.has_one(:game)
       end
 
-      it "adds the metadata to the klass" do
+      it "adds the association to the klass" do
         expect(klass.relations["game"]).to_not be_nil
       end
 
@@ -892,8 +958,8 @@ describe Mongoid::Relations::Macros do
       end
 
       it "creates the correct relation" do
-        expect(klass.relations["game"].relation).to eq(
-          Mongoid::Relations::Referenced::One
+        expect(klass.relations["game"]).to be_a(
+          Mongoid::Association::Referenced::HasOne
         )
       end
 
@@ -903,18 +969,18 @@ describe Mongoid::Relations::Macros do
         )
       end
 
-      context "metadata properties" do
+      context "association properties" do
 
-        let(:metadata) do
+        let(:association) do
           klass.relations["game"]
         end
 
         it "automatically adds the name" do
-          expect(metadata.name).to eq(:game)
+          expect(association.name).to eq(:game)
         end
 
         it "automatically adds the inverse class name" do
-          expect(metadata.inverse_class_name).to eq("TestClass")
+          expect(association.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -937,18 +1003,26 @@ describe Mongoid::Relations::Macros do
       klass.embeds_one(:name)
     end
 
-    it "returns a hash of relations" do
-      expect(klass.allocate.relations).to be_a_kind_of(Hash)
+    it "returns a bson document of relations" do
+      expect(klass.allocate.relations).to be_a_kind_of(BSON::Document)
     end
 
     it "has keys that are the relation name" do
-      expect(klass.allocate.relations.keys.first).to eq("name")
+      expect(klass.allocate.relations['name']).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
 
-    it "has values that are metadata" do
+    it "has keys that can be accessed by a String" do
+      expect(klass.allocate.relations['name']).to be_a(Mongoid::Association::Embedded::EmbedsOne)
+    end
+
+    it "has keys that can be accessed by a Symbol" do
+      expect(klass.allocate.relations[:name]).to be_a(Mongoid::Association::Embedded::EmbedsOne)
+    end
+
+    it "has values that are association" do
       expect(
         klass.allocate.relations.values.first
-      ).to be_a_kind_of(Mongoid::Relations::Metadata)
+      ).to be_a_kind_of(Mongoid::Association::Embedded::EmbedsOne)
     end
   end
 
@@ -958,18 +1032,22 @@ describe Mongoid::Relations::Macros do
       klass.embeds_one(:name)
     end
 
-    it "returns a hash of relations" do
-      expect(klass.relations).to be_a_kind_of(Hash)
+    it "has keys that are the relation name" do
+      expect(klass.allocate.relations['name']).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
 
-    it "has keys that are the relation name" do
-      expect(klass.relations.keys.first).to eq("name")
+    it "has keys that can be accessed by a String" do
+      expect(klass.allocate.relations['name']).to be_a(Mongoid::Association::Embedded::EmbedsOne)
+    end
+
+    it "has keys that can be accessed by a Symbol" do
+      expect(klass.allocate.relations[:name]).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
 
-    it "has values that are metadata" do
+    it "has values that are association" do
       expect(
         klass.relations.values.first
-      ).to be_a_kind_of(Mongoid::Relations::Metadata)
+      ).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
   end