mongoid 6.4.4 → 7.1.7

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

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
-describe Mongoid::Relations::Eager do
+describe Mongoid::Association::EagerLoadable do
 
   describe ".preload" do
 
@@ -122,12 +125,12 @@ describe Mongoid::Relations::Eager do
         Person.all.to_a
       end
 
-      let(:posts_metadata) do
+      let(:posts_association) do
         Person.reflect_on_association(:posts)
       end
 
       it "runs the has_many preload" do
-        expect(Mongoid::Relations::Eager::HasMany).to receive(:new).with([posts_metadata], docs).once.and_call_original
+        expect(Mongoid::Association::Referenced::HasMany::Eager).to receive(:new).with([posts_association], docs).once.and_call_original
 
         context.eager_load(docs)
       end
@@ -154,31 +157,31 @@ describe Mongoid::Relations::Eager do
         Person.all.to_a
       end
 
-      let(:posts_metadata) do
+      let(:posts_association) do
         Person.reflect_on_association(:posts)
       end
 
-      let(:houses_metadata) do
+      let(:houses_association) do
         Person.reflect_on_association(:houses)
       end
 
-      let(:cat_metadata) do
+      let(:cat_association) do
         Person.reflect_on_association(:cat)
       end
 
       it "runs the has_many preload" do
-        expect(Mongoid::Relations::Eager::HasMany).to receive(:new).with([posts_metadata], docs).once.and_call_original
+        expect(Mongoid::Association::Referenced::HasMany::Eager).to receive(:new).with([posts_association], docs).once.and_call_original
 
         context.eager_load(docs)
       end
 
       it "runs the has_one preload" do
-        expect(Mongoid::Relations::Eager::HasOne).to receive(:new).with([cat_metadata], docs).once.and_call_original
+        expect(Mongoid::Association::Referenced::HasOne::Eager).to receive(:new).with([cat_association], docs).once.and_call_original
         context.eager_load(docs)
       end
 
       it "runs the has_and_belongs_to_many preload" do
-        expect(Mongoid::Relations::Eager::HasAndBelongsToMany).to receive(:new).with([houses_metadata], docs).once.and_call_original
+        expect(Mongoid::Association::Referenced::HasAndBelongsToMany::Eager).to receive(:new).with([houses_association], docs).once.and_call_original
         context.eager_load(docs)
       end
 
@@ -233,16 +236,16 @@ describe Mongoid::Relations::Eager do
         Person.all.to_a
       end
 
-      let(:book_metadata) do
+      let(:book_association) do
         Person.reflect_on_association(:book)
       end
 
-      let(:cat_metadata) do
+      let(:cat_association) do
         Person.reflect_on_association(:cat)
       end
 
       it "runs the has_one preload" do
-        expect(Mongoid::Relations::Eager::HasOne).to receive(:new).with([book_metadata, cat_metadata], docs).once.and_call_original
+        expect(Mongoid::Association::Referenced::HasOne::Eager).to receive(:new).with([book_association, cat_association], docs).once.and_call_original
         context.eager_load(docs)
       end
     end

data/spec/mongoid/{relations → association/embedded}/cyclic_spec.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
-describe Mongoid::Relations::Cyclic do
+describe Mongoid::Association::Embedded::Cyclic do
 
   describe ".recursively_embeds_many" do
 

data/spec/mongoid/{relations → association}/embedded/dirty_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe "when initialize a model with an embedded model" do

data/spec/mongoid/{relations/bindings/embedded/in_spec.rb → association/embedded/embedded_in/binding_spec.rb}

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
-describe Mongoid::Relations::Bindings::Embedded::In do
+describe Mongoid::Association::Embedded::EmbeddedIn::Binding do
 
   let(:person) do
     Person.new
@@ -14,15 +17,15 @@ describe Mongoid::Relations::Bindings::Embedded::In do
     Address.new
   end
 
-  let(:name_metadata) do
+  let(:name_association) do
     Name.relations["namable"]
   end
 
-  let(:address_metadata) do
+  let(:address_association) do
     Address.relations["addressable"]
   end
 
-  let(:person_metadata) do
+  let(:person_association) do
     Person.relations["addresses"]
   end
 
@@ -31,7 +34,7 @@ describe Mongoid::Relations::Bindings::Embedded::In do
     context "when the child of an embeds one" do
 
       let(:binding) do
-        described_class.new(name, person, name_metadata)
+        described_class.new(name, person, name_association)
       end
 
       context "when the document is bindable" do
@@ -65,12 +68,12 @@ describe Mongoid::Relations::Bindings::Embedded::In do
     context "when the child of an embeds many" do
 
       let(:binding) do
-        described_class.new(address, person, address_metadata)
+        described_class.new(address, person, address_association)
       end
 
       context "when the document is bindable" do
 
-        context "when the base has no metadata" do
+        context "when the base has no association" do
 
           before do
             binding.bind_one
@@ -85,14 +88,14 @@ describe Mongoid::Relations::Bindings::Embedded::In do
           end
         end
 
-        context "when the base has metadata" do
+        context "when the base has an association" do
 
           before do
-            address.__metadata = person_metadata
+            address._association = person_association
           end
 
-          it "does not overwrite the existing metadata" do
-            expect(address).to receive(:__metadata=).never
+          it "does not overwrite the existing association" do
+            expect(address).to receive(:_association=).never
             binding.bind_one
           end
         end
@@ -117,7 +120,7 @@ describe Mongoid::Relations::Bindings::Embedded::In do
     context "when the child of an embeds one" do
 
       let(:binding) do
-        described_class.new(name, person, name_metadata)
+        described_class.new(name, person, name_association)
       end
 
       context "when the document is unbindable" do
@@ -144,7 +147,7 @@ describe Mongoid::Relations::Bindings::Embedded::In do
     context "when the child of an embeds many" do
 
       let(:binding) do
-        described_class.new(address, person, address_metadata)
+        described_class.new(address, person, address_association)
       end
 
       context "when the document is unbindable" do

data/spec/mongoid/association/embedded/embedded_in/buildable_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Association::Embedded::EmbeddedIn::Buildable do
+
+  describe "#build" do
+
+    let(:base) do
+      double
+    end
+
+    let(:options) do
+      { }
+    end
+
+    let(:association) do
+      Mongoid::Association::Embedded::EmbeddedIn.new(Person, :addresses, options)
+    end
+
+    context "when a document is provided" do
+
+      let(:object) do
+        double
+      end
+
+      let(:document) do
+        association.build(base, object)
+      end
+
+      it "returns the document" do
+        expect(document).to eq(object)
+      end
+    end
+  end
+end

data/spec/mongoid/{relations/embedded/in_spec.rb → association/embedded/embedded_in/proxy_spec.rb}

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
-describe Mongoid::Relations::Embedded::In do
+describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
 
   describe "#===" do
 
@@ -12,12 +15,12 @@ describe Mongoid::Relations::Embedded::In do
       Person.new
     end
 
-    let(:metadata) do
+    let(:association) do
       Name.relations["namable"]
     end
 
     let(:relation) do
-      described_class.new(base, target, metadata)
+      described_class.new(base, target, association)
     end
 
     context "when the proxied document is same class" do
@@ -354,29 +357,6 @@ describe Mongoid::Relations::Embedded::In do
     end
   end
 
-  describe ".builder" do
-
-    let(:builder_klass) do
-      Mongoid::Relations::Builders::Embedded::In
-    end
-
-    let(:base) do
-      Name.new
-    end
-
-    let(:target) do
-      Person.new
-    end
-
-    let(:metadata) do
-      Name.relations["namable"]
-    end
-
-    it "returns the embedded one builder" do
-      expect(described_class.builder(base, metadata, target)).to be_a(builder_klass)
-    end
-  end
-
   describe ".embedded?" do
 
     it "returns true" do
@@ -384,39 +364,6 @@ describe Mongoid::Relations::Embedded::In do
     end
   end
 
-  describe ".foreign_key_suffix" do
-
-    it "returns nil" do
-      expect(described_class.foreign_key_suffix).to be_nil
-    end
-  end
-
-  describe ".macro" do
-
-    it "returns embeds_one" do
-      expect(described_class.macro).to eq(:embedded_in)
-    end
-  end
-
-  describe ".nested_builder" do
-
-    let(:nested_builder_klass) do
-      Mongoid::Relations::Builders::NestedAttributes::One
-    end
-
-    let(:metadata) do
-      Name.relations["namable"]
-    end
-
-    let(:attributes) do
-      {}
-    end
-
-    it "returns the single nested builder" do
-      expect(described_class.nested_builder(metadata, attributes, {})).to be_a(nested_builder_klass)
-    end
-  end
-
   describe "#respond_to?" do
 
     let(:person) do
@@ -442,22 +389,6 @@ describe Mongoid::Relations::Embedded::In do
     end
   end
 
-  describe ".valid_options" do
-
-    it "returns the valid options" do
-      expect(described_class.valid_options).to eq(
-        [ :autobuild, :cyclic, :polymorphic, :touch ]
-      )
-    end
-  end
-
-  describe ".validation_default" do
-
-    it "returns false" do
-      expect(described_class.validation_default).to be false
-    end
-  end
-
   context "when creating the tree through initialization" do
 
     let!(:person) do
@@ -494,8 +425,8 @@ describe Mongoid::Relations::Embedded::In do
 
     it "has the locations in the association array" do
       expect(Person.last.addresses.last.locations).to eq(
-        [first_location, second_location]
-      )
+                                                          [first_location, second_location]
+                                                      )
     end
   end
 
@@ -576,4 +507,54 @@ describe Mongoid::Relations::Embedded::In do
       end
     end
   end
+
+  context "when the same class is embedded multiple times" do
+
+    let(:customer) do
+      Customer.new
+    end
+
+    context "assignment after saving" do
+
+      it "correctly sets the association for the embedded class" do
+        pending 'MONGOID-5039'
+
+        customer.home_address = CustomerAddress.new
+        customer.work_address = CustomerAddress.new
+
+        expect(customer.home_address._association.store_as).to eq("home_address")
+        expect(customer.work_address._association.store_as).to eq("work_address")
+
+        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
+        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+
+        customer.save!
+
+        customer.home_address = CustomerAddress.new
+        customer.work_address = CustomerAddress.new
+
+        expect(customer.home_address._association.store_as).to eq("home_address")
+        expect(customer.work_address._association.store_as).to eq("work_address")
+
+        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
+        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+      end
+    end
+
+    context "inverse assignment" do
+
+      it "correctly sets the association for the embedded class" do
+        pending 'MONGOID-5039'
+
+        customer.work_address = CustomerAddress.new
+        customer.work_address.addressable = customer
+
+        expect(customer.home_address._association.store_as).to eq("home_address")
+        expect(customer.work_address._association.store_as).to eq("work_address")
+
+        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
+        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+      end
+    end
+  end
 end

data/spec/mongoid/association/embedded/embedded_in_spec.rb

@@ -0,0 +1,904 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+require_relative './embeds_one_models'
+
+describe Mongoid::Association::Embedded::EmbeddedIn do
+
+  before do
+    class Container; include Mongoid::Document; end
+    class EmbeddedObject; include Mongoid::Document; end
+  end
+
+  after do
+    Object.send(:remove_const, :Container)
+    Object.send(:remove_const, :EmbeddedObject)
+  end
+
+  let(:embedded_class) do
+    EmbeddedObject
+  end
+
+  let(:name) do
+    :container
+  end
+
+  let(:association) do
+    embedded_class.embedded_in name, options
+  end
+
+  let(:options) do
+    { }
+  end
+
+  describe '#VALID_OPTIONS' do
+
+    it 'returns the SHARED options with the ASSOCIATION_OPTIONS' do
+      expect(association.class::VALID_OPTIONS).to match_array(Mongoid::Association::Relatable::SHARED_OPTIONS +
+                                                              association.class::ASSOCIATION_OPTIONS)
+    end
+  end
+
+  describe '#relation_complements' do
+
+    let(:expected_complements) do
+      [
+        Mongoid::Association::Embedded::EmbedsMany,
+        Mongoid::Association::Embedded::EmbedsOne
+      ]
+    end
+
+    it 'returns the relation complements' do
+      expect(association.send(:relation_complements)).to eq(expected_complements)
+    end
+  end
+
+  describe '#setup_instance_methods!' do
+
+    it 'sets up a getter for the relation' do
+      expect(Mongoid::Association::Accessors).to receive(:define_getter!).with(association)
+      association.send(:setup_instance_methods!)
+    end
+
+    it 'sets up a setter for the relation' do
+      expect(Mongoid::Association::Accessors).to receive(:define_setter!).with(association)
+      association.send(:setup_instance_methods!)
+    end
+
+    it 'sets up an existence check for the relation' do
+      expect(Mongoid::Association::Accessors).to receive(:define_existence_check!).with(association)
+      association.send(:setup_instance_methods!)
+    end
+  end
+
+  describe '#inverse_type_setter' do
+
+    context 'when polymorphic' do
+
+      let(:options) do
+        { polymorphic: true }
+      end
+
+      it 'returns nil' do
+        expect(association.inverse_type).to be_nil
+      end
+    end
+
+    context 'when not polymorphic' do
+
+      it 'returns nil' do
+        expect(association.inverse_type).to be_nil
+      end
+    end
+  end
+
+  describe '#embedded?' do
+
+    it 'returns true' do
+      expect(association.embedded?).to be(true)
+    end
+  end
+
+  describe '#relation' do
+
+    it 'returns Mongoid::Association::Embedded::EmbeddedIn::Proxy' do
+      expect(association.relation).to be(Mongoid::Association::Embedded::EmbeddedIn::Proxy)
+    end
+  end
+
+  describe '#validation_default' do
+
+    it 'returns false' do
+      expect(association.validation_default).to be(false)
+    end
+  end
+
+  describe '#name' do
+
+    it 'returns the name of the relation' do
+      expect(association.name).to be(name)
+    end
+  end
+
+  describe '#options' do
+
+    it 'returns the options' do
+      expect(association.options).to be(options)
+    end
+  end
+
+  describe '#cyclic?' do
+
+    context 'when :cyclic is specified in the options' do
+
+      let(:options) do
+        { cyclic: true }
+      end
+
+      it 'returns true' do
+        expect(association.cyclic?).to be(true)
+      end
+    end
+
+    context 'when :cyclic is not specified in the options' do
+
+      it 'returns false' do
+        expect(association.cyclic?).to be(false)
+      end
+    end
+  end
+
+  describe '#merge!' do
+
+  end
+
+
+  describe '#touchable?' do
+
+    context 'when :touch is in the options' do
+
+      let(:options) do
+        { touch: true}
+      end
+
+      it 'returns true' do
+        expect(association.send(:touchable?)).to be(true)
+      end
+    end
+
+    context 'when :touch is not in the options' do
+
+      it 'return false' do
+        expect(association.send(:touchable?)).to be(false)
+      end
+    end
+  end
+
+  describe '#polymorphic?' do
+
+    context 'when :polymorphic is specified in the options as true' do
+
+      let(:options) do
+        { polymorphic: true }
+      end
+
+      it 'returns true' do
+        expect(association.polymorphic?).to be(true)
+      end
+    end
+
+    context 'when :polymorphic is specified in the options as false' do
+
+      let(:options) do
+        { polymorphic: false }
+      end
+
+      it 'returns false' do
+        expect(association.polymorphic?).to be(false)
+      end
+    end
+
+    context 'when :polymorphic is not specified in the options' do
+
+      it 'returns false' do
+        expect(association.polymorphic?).to be(false)
+      end
+    end
+  end
+
+  describe '#bindable?' do
+
+    it 'returns false' do
+      expect(association.bindable?(Person.new)).to be(false)
+    end
+  end
+
+  describe '#inverses' do
+
+    context 'when polymorphic' do
+
+      let(:options) do
+        {
+          polymorphic: true
+        }
+      end
+
+      let(:name) do
+        :containable
+      end
+
+      context 'when another object is passed to the method' do
+
+        let(:instance_of_other_class) do
+          Container.new
+        end
+
+        context 'when the relation class has only one relation whose class matches the owning class' do
+
+          before do
+            Container.embeds_many :embedded_objects, as: :containable
+          end
+
+          context 'when :inverse_of is specified' do
+
+            before do
+              options.merge!(inverse_of: :inverse_name)
+            end
+
+            it 'returns the :inverse_of value' do
+              expect(association.inverses(instance_of_other_class)).to eq([ :inverse_name ])
+            end
+          end
+
+          context 'when inverse_of is not specified' do
+
+            it 'returns the list of relations whose :as attribute matches the name of this association' do
+              expect(association.inverses(instance_of_other_class)).to match_array([ :embedded_objects ])
+            end
+
+            context 'when the relation class has two associations with the same name' do
+
+              before do
+                Container.embeds_many :embedded_objects, as: :containable
+                Container.embeds_many :other_embedded_objects, as: :containable
+              end
+
+              it 'returns only the relations whose :as attribute and class match' do
+                expect(association.inverses(instance_of_other_class)).to match_array([ :embedded_objects ])
+              end
+            end
+          end
+        end
+
+        context 'when the relation class has more than one relation whose class matches the owning class' do
+
+          before do
+            Container.embeds_many :embedded_objects, as: :containable
+            Container.embeds_one :other_embedded_object, as: :containable, class_name: 'EmbeddedObject'
+          end
+
+          context 'when :inverse_of is specified' do
+
+            before do
+              options.merge!(inverse_of: :inverse_name)
+            end
+
+            it 'returns the :inverse_of value' do
+              expect(association.inverses(instance_of_other_class)).to eq([ :inverse_name ])
+            end
+          end
+
+          context 'when inverse_of is not specified' do
+
+            it 'returns the list of relations whose :as attribute matches the name of this association' do
+              expect(association.inverses(instance_of_other_class)).to match_array([ :embedded_objects,
+                                                                                     :other_embedded_object ])
+            end
+          end
+        end
+      end
+
+      context 'when another object is not passed to the method' do
+
+        context 'when inverse_of is specified' do
+
+          before do
+            options.merge!(inverse_of: :inverse_name)
+          end
+
+          it 'returns the :inverse_of value' do
+            expect(association.inverses).to eq([ :inverse_name ])
+          end
+        end
+
+        context 'when inverse_of is not specified' do
+
+          it 'returns nil' do
+            expect(association.inverses).to eq(nil)
+          end
+
+          context 'when class_name is given and is a plain string' do
+            let(:association) do
+              EomParent.relations['child']
+            end
+
+            it 'returns the inverse in an array' do
+              inverses = association.inverses
+              expect(inverses).to eq([:parent])
+            end
+          end
+
+          context 'when class_name is given and is a :: prefixed string' do
+            let(:association) do
+              EomCcChild.relations['parent']
+            end
+
+            it 'returns the inverse in an array' do
+              pending 'MONGOID-4751'
+
+              inverses = association.inverses
+              expect(inverses).to eq([:child])
+            end
+
+            context 'when other associations referencing unloaded classes exist' do
+              let(:association) do
+                EomDnlChild.relations['parent']
+              end
+
+              it 'does not load other classes' do
+                inverses = association.inverses
+                expect(inverses).to eq([:child])
+                expect(Object.const_defined?(:EoDnlMarker)).to be false
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context 'when not polymorphic' do
+
+      context 'when inverse_of is specified' do
+
+        before do
+          options.merge!(inverse_of: :inverse_name)
+        end
+
+        it 'returns the :inverse_of value' do
+          expect(association.inverses).to eq([ :inverse_name ])
+        end
+      end
+
+      context 'when inverse_of is not specified' do
+
+        before do
+          Container.embeds_many :embedded_objects
+        end
+
+        it 'uses the inverse class to find the inverse name' do
+          expect(association.inverses).to eq([ :embedded_objects ])
+        end
+      end
+
+      context 'when :cyclic is specified' do
+
+        it 'returns the cyclic inverse name' do
+
+        end
+      end
+
+      context 'when the inverse class has more than one relation with objects of the owner class' do
+
+        before do
+          Container.embeds_many :embedded_objects
+          Container.embeds_many :other_embedded_objects, class_name: 'EmbeddedObject'
+        end
+
+        it 'raises a Mongoid::Errors::AmbiguousRelationship exception' do
+          expect {
+            association.inverses
+          }.to raise_exception(Mongoid::Errors::AmbiguousRelationship)
+        end
+      end
+
+      context 'when the inverse class only has one relation with objects of the owner class' do
+
+        before do
+          Container.embeds_many :embedded_objects
+        end
+
+        it 'uses the inverse class to find the inverse name' do
+          expect(association.inverses).to eq([ :embedded_objects ])
+        end
+      end
+    end
+  end
+
+  describe '#inverse' do
+
+    context 'when polymorphic' do
+
+      let(:options) do
+        {
+          polymorphic: true
+        }
+      end
+
+      let(:name) do
+        :containable
+      end
+
+      context 'when another object is passed to the method' do
+
+        let(:instance_of_other_class) do
+          Container.new
+        end
+
+        context 'when the relation class has only one relation whose class matches the owning class' do
+
+          before do
+            Container.embeds_many :embedded_objects, as: :containable
+          end
+
+          context 'when :inverse_of is specified' do
+
+            before do
+              options.merge!(inverse_of: :inverse_name)
+            end
+
+            it 'returns the :inverse_of value' do
+              expect(association.inverse(instance_of_other_class)).to eq(:inverse_name)
+            end
+          end
+
+          context 'when inverse_of is not specified' do
+
+            it 'returns the list of relations whose :as attribute matches the name of this association' do
+              expect(association.inverse(instance_of_other_class)).to eq(:embedded_objects)
+            end
+          end
+        end
+
+        context 'when the relation class has more than one relation whose class matches the owning class' do
+
+          before do
+            Container.embeds_many :embedded_objects, as: :containable
+            Container.embeds_one :other_embedded_object, as: :containable
+          end
+
+          context 'when :inverse_of is specified' do
+
+            before do
+              options.merge!(inverse_of: :inverse_name)
+            end
+
+            it 'returns the :inverse_of value' do
+              expect(association.inverse(instance_of_other_class)).to eq(:inverse_name)
+            end
+          end
+
+          context 'when inverse_of is not specified' do
+
+            it 'returns the first candidate whose :as attribute matches the name of this association' do
+              expect(association.inverse(instance_of_other_class)).to eq(:embedded_objects)
+            end
+          end
+        end
+      end
+
+      context 'when another object is not passed to the method' do
+
+        context 'when inverse_of is specified' do
+
+          before do
+            options.merge!(inverse_of: :inverse_name)
+          end
+
+          it 'returns the :inverse_of value' do
+            expect(association.inverse).to eq(:inverse_name)
+          end
+        end
+
+        context 'when inverse_of is not specified' do
+
+          it 'returns nil' do
+            expect(association.inverse).to eq(nil)
+          end
+        end
+      end
+    end
+
+    context 'when not polymorphic' do
+
+      context 'when inverse_of is specified' do
+
+        before do
+          options.merge!(inverse_of: :inverse_name)
+        end
+
+        it 'returns the :inverse_of value' do
+          expect(association.inverse).to eq(:inverse_name)
+        end
+      end
+
+      context 'when inverse_of is not specified' do
+
+        before do
+          Container.embeds_many :embedded_objects
+        end
+
+        it 'uses the inverse class to find the inverse name' do
+          expect(association.inverse).to eq(:embedded_objects)
+        end
+      end
+
+      context 'when :cyclic is specified' do
+
+        it 'returns the cyclic inverse name' do
+
+        end
+      end
+
+      context 'when the inverse class has more than one relation with objects of the owner class' do
+
+        before do
+          Container.embeds_many :embedded_objects
+          Container.embeds_many :other_embedded_objects, class_name: 'EmbeddedObject'
+        end
+
+        it 'raises a Mongoid::Errors::AmbiguousRelationship exception' do
+          expect {
+            association.inverse
+          }.to raise_exception(Mongoid::Errors::AmbiguousRelationship)
+        end
+      end
+
+      context 'when the inverse class only has one relation with objects of the owner class' do
+
+        before do
+          Container.embeds_many :embedded_objects
+        end
+
+        it 'uses the inverse class to find the inverse name' do
+          expect(association.inverse).to eq(:embedded_objects)
+        end
+      end
+    end
+  end
+
+  describe '#inverse_association' do
+
+  end
+
+  describe '#autosave' do
+
+    it 'returns false' do
+      expect(association.autosave).to be(false)
+    end
+  end
+
+  describe '#relation_class_name' do
+
+    context 'when the :class_name option is specified' do
+
+      let(:options) do
+        { class_name: 'OtherContainer' }
+      end
+
+      it 'returns the class name option' do
+        expect(association.relation_class_name).to eq('OtherContainer')
+      end
+
+      context ':class_name is a :: prefixed string' do
+        let(:association) do
+          EomCcChild.relations['parent']
+        end
+
+        it 'returns the :: prefixed string' do
+          expect(association.relation_class_name).to eq('::EomCcParent')
+        end
+      end
+    end
+
+    context 'when the class_name option is not specified' do
+
+      it 'uses the name of the relation to deduce the class name' do
+        expect(association.relation_class_name).to eq('Container')
+      end
+    end
+
+    context 'when another association in the model is referencing a third model class' do
+      let(:association) do
+        EomDnlChild.relations['parent']
+      end
+
+      it 'does not attempt to load the third class' do
+        expect(association.relation_class_name).to eq('EomDnlParent')
+        expect(Object.const_defined?(:EoDnlMarker)).to be false
+      end
+    end
+  end
+
+  describe '#klass' do
+
+    context 'when the :class_name option is specified' do
+
+      let!(:_class) do
+        class OtherContainer; end
+        OtherContainer
+      end
+
+      let(:options) do
+        { class_name: 'OtherContainer' }
+      end
+
+      it 'returns the class name option' do
+        expect(association.klass).to eq(_class)
+      end
+    end
+
+    context 'when the class_name option is not specified' do
+
+      it 'uses the name of the relation to deduce the class name' do
+        expect(association.klass).to eq(Container)
+      end
+    end
+  end
+
+  describe '#inverse_class_name' do
+
+    it 'returns the name of the owner class' do
+      expect(association.inverse_class_name).to eq(embedded_class.name)
+    end
+  end
+
+  describe '#inverse_class' do
+
+    it 'returns the owner class' do
+      expect(association.inverse_class).to be(embedded_class)
+    end
+  end
+
+  describe '#inverse_of' do
+
+    context 'when :inverse_of is specified in the options' do
+
+      let(:options) do
+        { inverse_of: :a_container }
+      end
+
+      it 'returns the inverse_of value' do
+        expect(association.inverse_of).to eq(options[:inverse_of])
+      end
+    end
+
+    context 'when :inverse_of is not specified in the options' do
+
+      it 'returns nil' do
+        expect(association.inverse_of).to be_nil
+      end
+    end
+  end
+
+  describe '#key' do
+
+    it 'returns the name of the relation as a string' do
+      expect(association.key).to eq(name.to_s)
+    end
+  end
+
+  describe '#setter' do
+
+    it 'returns a string of the name followed by =' do
+      expect(association.setter).to eq("#{name}=")
+    end
+  end
+
+  describe '#validate?' do
+
+    context 'when :validate is specified in the options' do
+
+      context 'when validate is true' do
+
+        let(:options) do
+          { validate: true }
+        end
+
+        it 'returns true' do
+          expect(association.send(:validate?)).to be(true)
+        end
+      end
+
+      context 'when validate is false' do
+
+        let(:options) do
+          { validate: false }
+        end
+
+        it 'returns false' do
+          expect(association.send(:validate?)).to be(false)
+        end
+      end
+    end
+
+    context 'when :validate is not specified in the options' do
+
+      it 'returns the validation_default' do
+        expect(association.send(:validate?)).to eq(association.validation_default)
+      end
+    end
+  end
+
+  describe '#autobuilding?' do
+
+    context 'when :autobuild is specified in the options' do
+
+      context 'when autobuild is true' do
+
+        let(:options) do
+          { autobuild: true }
+        end
+
+        it 'returns true' do
+          expect(association.autobuilding?).to be(true)
+        end
+      end
+
+      context 'when autobuild is false' do
+
+        let(:options) do
+          { autobuild: false }
+        end
+
+        it 'returns true' do
+          expect(association.autobuilding?).to be(false)
+        end
+      end
+    end
+
+    context 'when :validate is not specified in the options' do
+
+      it 'returns false' do
+        expect(association.autobuilding?).to be(false)
+      end
+    end
+  end
+
+  describe '#forced_nil_inverse?' do
+
+    it 'returns false' do
+      expect(association.forced_nil_inverse?).to be(false)
+    end
+  end
+
+  describe '#stores_foreign_key?' do
+
+    it 'returns false' do
+      expect(association.stores_foreign_key?).to be(false)
+    end
+  end
+
+  describe '#inverse_setter' do
+
+    context 'when an inverse can be determined' do
+
+      before do
+        Container.embeds_many :embedded_objects
+      end
+
+      it 'returns the name of the inverse followed by =' do
+        expect(association.inverse_setter).to eq('embedded_objects=')
+      end
+    end
+
+    context 'when an inverse cannot be determined' do
+
+      it 'returns nil' do
+        expect(association.inverse_setter).to be_nil
+      end
+    end
+  end
+
+  describe '#extension' do
+
+    context 'when a block is passed' do
+
+      let(:association) do
+        embedded_class.embedded_in name, options do; end
+      end
+
+      it 'defines an extension module' do
+        expect(association.extension).to be_a(Module)
+      end
+
+      it 'returns the extension' do
+        expect(association.extension).to eq(
+          "#{embedded_class.name}::#{embedded_class.name}#{name.capitalize}RelationExtension".constantize)
+      end
+    end
+
+    context 'when an :extension is not specified in the options' do
+
+      it 'returns false' do
+        expect(association.extension).to be_nil
+      end
+    end
+  end
+
+  describe '#criteria' do
+
+    it 'does not respond to the method' do
+      expect {
+        association.criteria
+      }.to raise_exception(NoMethodError)
+    end
+  end
+
+  describe '#destructive?' do
+
+    it 'returns false' do
+      expect(association.destructive?).to be(false)
+    end
+  end
+
+  describe '#nested_builder' do
+
+    it 'returns an instance of Association::Nested::One' do
+      expect(association.nested_builder({}, {})).to be_a(Mongoid::Association::Nested::One)
+    end
+  end
+
+  describe '#cascading_callbacks?' do
+
+    context 'when cascade_callbacks is specified in the options' do
+
+      let(:options) do
+        {cascade_callbacks: true}
+      end
+
+      it 'raises a Mongoid::Errors::InvalidRelationOption exception' do
+        expect {
+          association.cascading_callbacks?
+        }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+      end
+    end
+
+    context 'when cascade_callbacks is not specified in the options' do
+
+      it 'returns false' do
+        expect(association.cascading_callbacks?).to be(false)
+      end
+    end
+  end
+
+  describe '#path' do
+
+    it 'returns an instance of Mongoid::Atomic::Paths::Root' do
+      expect(association.path({})).to be_a(Mongoid::Atomic::Paths::Root)
+    end
+  end
+
+  describe '#foreign_key_check' do
+
+    it 'returns nil' do
+      expect(association.foreign_key_check).to be_nil
+    end
+  end
+
+  describe '#create_relation' do
+
+    let(:owner) do
+      Container.new
+    end
+
+    let(:target) do
+      EmbeddedObject.new
+    end
+
+    it 'returns an instance of Mongoid::Association::Embedded::EmbeddedIn::Proxy' do
+      expect(Mongoid::Association::Embedded::EmbeddedIn::Proxy).to receive(:new).and_call_original
+      expect(association.create_relation(owner, target)).to be_a(EmbeddedObject)
+    end
+  end
+end