mongoid 6.4.8 → 7.0.0.beta

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

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Relations::Macros do
+describe Mongoid::Association::Macros do
 
   class TestClass
     include Mongoid::Document
@@ -20,26 +20,6 @@ describe Mongoid::Relations::Macros do
     klass.validators.clear
   end
 
-  describe 'Model loading' do
-
-    let(:model_associations) do
-      class TestModel
-        include Mongoid::Document
-        field :associations
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :TestModel)
-    end
-
-    it 'prohibits the use of :associations as an attribute' do
-      expect {
-        model_associations
-      }.to raise_exception(Mongoid::Errors::InvalidField)
-    end
-  end
-
   describe ".embedded_in" do
 
     it "defines the macro" do
@@ -65,7 +45,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 +58,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 +67,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
 
-        let(:metadata) 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(: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 +118,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 +131,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 +142,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 +173,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 +223,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 +244,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 +255,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 +335,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 +636,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 +657,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 +666,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 +708,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 +721,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 +732,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 +763,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 +809,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 +835,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 +850,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 +901,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 +935,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 +946,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 +980,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 keys that can be accessed by a String" do
+      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 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 +1009,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 can be accessed by a String" 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 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