mongoid 6.4.8 → 7.0.0.beta

data/spec/mongoid/{relations/bindings/embedded/one_spec.rb → association/embedded/embeds_one/binding_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Relations::Bindings::Embedded::One do
+describe Mongoid::Association::Embedded::EmbedsOne::Binding do
 
   let(:person) do
     Person.new
@@ -10,14 +10,14 @@ describe Mongoid::Relations::Bindings::Embedded::One do
     Name.new
   end
 
-  let(:metadata) do
+  let(:association) do
     Person.relations["name"]
   end
 
   describe "#bind" do
 
     let(:binding) do
-      described_class.new(person, target, metadata)
+      described_class.new(person, target, association)
     end
 
     context "when the document is bindable" do
@@ -51,7 +51,7 @@ describe Mongoid::Relations::Bindings::Embedded::One do
   describe "#unbind" do
 
     let(:binding) do
-      described_class.new(person, target, metadata)
+      described_class.new(person, target, association)
     end
 
     context "when the document is unbindable" do

data/spec/mongoid/{relations/builders/embedded/one_spec.rb → association/embedded/embeds_one/buildable_spec.rb}

@@ -1,29 +1,29 @@
 require "spec_helper"
 
-describe Mongoid::Relations::Builders::Embedded::One do
+describe Mongoid::Association::Embedded::EmbedsOne::Buildable do
 
   let(:base) do
     double
   end
 
-  let(:builder) do
-    described_class.new(base, metadata, object)
+  let(:options) do
+    { }
   end
 
   describe "#build" do
 
-    context "when provided nil" do
+    let(:document) do
+      association.build(base, object)
+    end
 
-      let(:metadata) do
-        double(klass: Name, name: :name)
-      end
+    let(:association) do
+      Mongoid::Association::Embedded::EmbedsOne.new(Person, :name, options)
+    end
 
-      let(:builder) do
-        described_class.new(nil, metadata, nil)
-      end
+    context "when provided nil" do
 
-      let(:document) do
-        builder.build
+      let(:object) do
+        nil
       end
 
       it "returns nil" do
@@ -33,18 +33,10 @@ describe Mongoid::Relations::Builders::Embedded::One do
 
     context "when provided a document" do
 
-      let(:metadata) do
-        double(klass: Name, name: :name)
-      end
-
       let(:object) do
         Name.new
       end
 
-      let(:document) do
-        builder.build
-      end
-
       it "returns the document" do
         expect(document).to eq(object)
       end
@@ -52,18 +44,10 @@ describe Mongoid::Relations::Builders::Embedded::One do
 
     context "when no type is in the object" do
 
-      let(:metadata) do
-        double(klass: Name, name: :name)
-      end
-
       let(:object) do
         { "first_name" => "Corbin" }
       end
 
-      let(:document) do
-        builder.build
-      end
-
       it "creates the correct type of document" do
         expect(document).to be_a_kind_of(Name)
       end
@@ -75,18 +59,14 @@ describe Mongoid::Relations::Builders::Embedded::One do
 
     context "when a type is in the object" do
 
-      let(:metadata) do
-        double(klass: Writer, name: :writer)
+      let(:association) do
+        Mongoid::Association::Embedded::EmbedsOne.new(Person, :writer, options)
       end
 
       let(:object) do
         { "_type" => PdfWriter.name, "speed" => 100 }
       end
 
-      let(:document) do
-        builder.build
-      end
-
       it "creates the correct type of document" do
         expect(document).to be_a_kind_of(PdfWriter)
       end

data/spec/mongoid/{relations/embedded/one_spec.rb → association/embedded/embeds_one/proxy_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Relations::Embedded::One do
+describe Mongoid::Association::Embedded::EmbedsOne::Proxy do
 
   describe "#===" do
 
@@ -12,12 +12,12 @@ describe Mongoid::Relations::Embedded::One do
       Name.new
     end
 
-    let(:metadata) do
+    let(:association) do
       Person.relations["name"]
     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
@@ -168,7 +168,7 @@ describe Mongoid::Relations::Embedded::One do
             expect(name).to be_persisted
           end
 
-          context "when replacing an exising document" do
+          context "when replacing an existing document" do
 
             let(:pet_owner) do
               PetOwner.create
@@ -200,6 +200,29 @@ describe Mongoid::Relations::Embedded::One do
             end
           end
         end
+        
+        context 'when the original document does not need to be unset because it will be replaced by the $set' do
+
+          let!(:pet_owner) do
+            PetOwner.create(pet: pet_one)
+          end
+
+          let(:pet_one) do
+            Pet.new(name: 'kika')
+          end
+
+          let(:pet_two) do
+            Pet.new(name: 'tiksy')
+          end
+
+          before do
+            expect(Mongo::Logger.logger).to receive(:debug?).exactly(2).times
+          end
+
+          it 'does not execute an unnecessary unset for the relation' do
+            pet_owner.pet = pet_two
+          end
+        end
 
         context "when setting via the parent attributes" do
 
@@ -644,29 +667,6 @@ describe Mongoid::Relations::Embedded::One do
     end
   end
 
-  describe ".builder" do
-
-    let(:base) do
-      Person.new
-    end
-
-    let(:target) do
-      Name.new
-    end
-
-    let(:metadata) do
-      Person.relations["name"]
-    end
-
-    let(:builder_klass) do
-      Mongoid::Relations::Builders::Embedded::One
-    end
-
-    it "returns the embedded one builder" do
-      expect(described_class.builder(base, metadata, target)).to be_a(builder_klass)
-    end
-  end
-
   describe "#create_#\{name}" do
 
     context "when the parent is a new record" do
@@ -787,6 +787,12 @@ describe Mongoid::Relations::Embedded::One do
           ShipmentAddress.new
         end
 
+        after do
+          # Note that this is necessary, otherwise all further Address objects will be
+          # saved with a "_type" attributes. See Traversable#inherited for why.
+          Address.send(:remove_defaults, "_type")
+        end
+
         before do
           courier_job.drop_address = old_child
           courier_job.update_attribute(:drop_address, new_child)
@@ -807,41 +813,6 @@ describe Mongoid::Relations::Embedded::One 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(:embeds_one)
-    end
-  end
-
-  describe ".nested_builder" do
-
-    let(:nested_builder_klass) do
-      Mongoid::Relations::Builders::NestedAttributes::One
-    end
-
-    let(:metadata) do
-      Person.relations["name"]
-    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
@@ -871,22 +842,6 @@ describe Mongoid::Relations::Embedded::One do
     end
   end
 
-  describe ".valid_options" do
-
-    it "returns the valid options" do
-      expect(described_class.valid_options).to eq(
-        [ :autobuild, :as, :cascade_callbacks, :cyclic, :store_as ]
-      )
-    end
-  end
-
-  describe ".validation_default" do
-
-    it "returns true" do
-      expect(described_class.validation_default).to be true
-    end
-  end
-
   context "when the embedded document has an array field" do
 
     let!(:person) do
@@ -895,9 +850,9 @@ describe Mongoid::Relations::Embedded::One do
 
     let!(:name) do
       person.create_name(
-        first_name: "Syd",
-        last_name: "Vicious",
-        aliases: nil
+          first_name: "Syd",
+          last_name: "Vicious",
+          aliases: nil
       )
     end
 
@@ -980,7 +935,7 @@ describe Mongoid::Relations::Embedded::One do
 
       before do
         person.collection.find(_id: person.id).update_one(
-          "$pull" => { "addresses" => { _id: address_one.id }}
+            "$pull" => { "addresses" => { _id: address_one.id }}
         )
       end
 
@@ -1013,8 +968,8 @@ describe Mongoid::Relations::Embedded::One do
 
     before do
       band.collection.
-        find(_id: band.id).
-        update_one("$set" => { label: { name: "Mute" }})
+          find(_id: band.id).
+          update_one("$set" => { label: { name: "Mute" }})
     end
 
     context "when loading the documents" do

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

@@ -0,0 +1,908 @@
+require "spec_helper"
+
+describe Mongoid::Association::Embedded::EmbedsOne do
+
+  before do
+    class Container; include Mongoid::Document; end
+    class EmbeddedObject; include Mongoid::Document; end
+  end
+
+  after do
+    Container.relations.clear
+    EmbeddedObject.relations.clear
+  end
+
+  let(:embeds_one_class) do
+    Container
+  end
+
+  let(:name) do
+    :embedded_object
+  end
+
+  let(:association) do
+    embeds_one_class.embeds_one name, options
+  end
+
+  let(:options) do
+    { }
+  end
+
+  describe '#relation_complements' do
+
+    let(:expected_complements) do
+      [
+        Mongoid::Association::Embedded::EmbeddedIn,
+      ]
+    end
+
+    it 'returns the relation complements' do
+      expect(association.send(:relation_complements)).to eq(expected_complements)
+    end
+  end
+
+  describe '#setup!' do
+
+    it 'sets up a getter for the relation' do
+      expect(Mongoid::Association::Accessors).to receive(:define_getter!).with(association)
+      association.setup!
+    end
+
+    it 'sets up a setter for the relation' do
+      expect(Mongoid::Association::Accessors).to receive(:define_setter!).with(association)
+      association.setup!
+    end
+
+    it 'sets up an existence check for the relation' do
+      expect(Mongoid::Association::Accessors).to receive(:define_existence_check!).with(association)
+      association.setup!
+    end
+
+    it 'sets up the builder for the relation' do
+      expect(Mongoid::Association::Builders).to receive(:define_builder!).with(association)
+      association.setup!
+    end
+
+    it 'sets up the creator for the relation' do
+      expect(Mongoid::Association::Builders).to receive(:define_creator!).with(association)
+      association.setup!
+    end
+
+    context 'when the :validate option is true' do
+
+      let(:options) do
+        {
+            validate: true
+        }
+      end
+
+      let(:association) do
+        # Note that it is necessary to create the association directly, otherwise the
+        # setup! method will be called by the :embeds_one macro
+        described_class.new(embeds_one_class, name, options)
+      end
+
+      it 'sets up validation' do
+        expect(embeds_one_class).to receive(:validates_associated).with(name).and_call_original
+        association.setup!
+      end
+    end
+
+    context 'when the :validate option is false' do
+
+      let(:options) do
+        {
+            validate: false
+        }
+      end
+
+      it 'does not set up validation' do
+        expect(embeds_one_class).not_to receive(:validates_associated)
+        association.setup!
+      end
+    end
+
+    context 'when the :validate option is not provided' do
+
+      let(:association) do
+        # Note that it is necessary to create the association directly, otherwise the
+        # setup! method will be called by the :embeds_one macro
+        described_class.new(embeds_one_class, name, options)
+      end
+
+      it 'sets up the validation because it uses the validation default (true)' do
+        expect(embeds_one_class).to receive(:validates_associated).with(name).and_call_original
+        association.setup!
+      end
+    end
+  end
+
+  describe '#type' do
+
+    context 'when polymorphic' do
+
+      let(:options) do
+        { as: :containable }
+      end
+
+      it 'returns the as attribute followed by "_type"' do
+        expect(association.type).to eq("#{options[:as]}_type")
+      end
+    end
+
+    context 'when not polymorphic' do
+
+      it 'returns nil' do
+        expect(association.type).to be_nil
+      end
+    end
+  end
+
+  describe '#inverse_type' do
+
+    context 'when polymorphic' do
+
+      let(:options) do
+        { as: :containable }
+      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 '#inverse_type_setter' do
+
+    context 'when polymorphic' do
+
+      let(:options) do
+        { as: :containable }
+      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 '#primary_key' do
+
+    it 'returns nil' do
+      expect(association.primary_key).to be_nil
+    end
+  end
+
+  describe '#indexed?' do
+
+    it 'returns false' do
+      expect(association.indexed?).to be(false)
+    end
+  end
+
+  describe '#relation' do
+
+    it 'returns Mongoid::Association::Embedded::EmbedsOne::Proxy' do
+      expect(association.relation).to be(Mongoid::Association::Embedded::EmbedsOne::Proxy)
+    end
+  end
+
+  describe '#validation_default' do
+
+    it 'returns true' do
+      expect(association.validation_default).to be(true)
+    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 '#store_as' do
+
+    context 'when :store_as is specified in the options' do
+
+      let(:options) do
+        {
+          store_as: :baby_kangaroo
+        }
+      end
+
+      it 'returns the :store_as option as a String' do
+        expect(association.store_as).to eq(options[:store_as].to_s)
+      end
+    end
+
+    context 'when :store_as is not specified in the options' do
+
+      it 'returns name as a String' do
+        expect(association.store_as).to eq(name.to_s)
+      end
+    end
+  end
+
+  describe '#touchable?' do
+
+    it 'return false' do
+      expect(association.send(:touchable?)).to be(false)
+    end
+  end
+
+  describe '#order' do
+
+    it 'returns nil' do
+      expect(association.order).to be_nil
+    end
+  end
+
+  describe '#as' do
+
+    context 'when :as is specified in the options' do
+
+      let(:options) do
+        {
+          as: :containable
+        }
+      end
+
+      it 'returns the :as option' do
+        expect(association.as).to eq(options[:as])
+      end
+    end
+
+    context 'when :as is not specified in the options' do
+
+      it 'returns nil' do
+        expect(association.as).to be_nil
+      end
+    end
+  end
+
+  describe '#polymorphic?' do
+
+    context 'when :as is specified in the options' do
+
+      let(:options) do
+        {
+          as: :containable
+        }
+      end
+
+      it 'returns true' do
+        expect(association.polymorphic?).to be(true)
+      end
+
+    end
+
+    context 'when :as is not specified in the options' do
+
+      it 'returns false' do
+        expect(association.polymorphic?).to be(false)
+      end
+    end
+  end
+
+  describe '#type_setter' do
+
+    context 'when polymorphic' do
+
+      let(:options) do
+        { as: :containable }
+      end
+
+      it 'returns the type followed by = as a String' do
+        expect(association.type_setter).to eq("containable_type=")
+      end
+    end
+
+    context 'when not polymorphic' do
+
+      it 'returns nil' do
+        expect(association.type).to be_nil
+      end
+    end
+  end
+
+  describe '#dependent' do
+
+    it 'returns nil' do
+      expect(association.dependent).to be_nil
+    end
+  end
+
+  describe '#inverse_type' do
+
+    it 'returns nil' do
+      expect(association.inverse_type).to be_nil
+    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
+
+      before do
+        EmbeddedObject.embedded_in :containable, polymorphic: true
+      end
+
+      let(:options) do
+        {
+          as: :containable
+        }
+      end
+
+      context 'when another object is passed to the method' do
+
+        let(:instance_of_other_class) do
+          EmbeddedObject.new
+        end
+
+        context 'when the relation class has only one relation whose class matches the owning class' do
+
+          it 'returns the :as attribute of this association' do
+            expect(association.inverses(instance_of_other_class)).to match_array([ :containable ])
+          end
+        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 :as attribute of this association' do
+            expect(association.inverses(instance_of_other_class)).to match_array([ :containable ])
+          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 the :as attribute' do
+            expect(association.inverses).to eq([ :containable ])
+          end
+        end
+      end
+    end
+
+    context 'when not polymorphic' do
+
+      before do
+        EmbeddedObject.embedded_in :container
+      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).to eq([ :inverse_name ])
+        end
+      end
+
+      context 'when inverse_of is not specified' do
+
+        it 'uses the inverse class to find the inverse name' do
+          expect(association.inverses).to eq([ :container ])
+        end
+      end
+
+      context 'when :cyclic is specified' do
+
+        it 'returns the cyclic inverse name' do
+
+        end
+      end
+    end
+  end
+
+  describe '##inverse' do
+
+    context 'when polymorphic' do
+
+      before do
+        EmbeddedObject.embedded_in :containable, polymorphic: true
+      end
+
+      let(:options) do
+        {
+            as: :containable
+        }
+      end
+
+      context 'when another object is passed to the method' do
+
+        let(:instance_of_other_class) do
+          EmbeddedObject.new
+        end
+
+        context 'when the relation class has only one relation whose class matches the owning class' do
+
+          it 'returns the :as attribute of this association' do
+            expect(association.inverse(instance_of_other_class)).to eq(:containable)
+          end
+        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 :as attribute of this association' do
+            expect(association.inverse(instance_of_other_class)).to eq(:containable)
+          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 the :as attribute' do
+            expect(association.inverse).to eq(:containable)
+          end
+        end
+      end
+    end
+
+    context 'when not polymorphic' do
+
+      before do
+        EmbeddedObject.embedded_in :container
+      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).to eq(:inverse_name)
+        end
+      end
+
+      context 'when inverse_of is not specified' do
+
+        it 'uses the inverse class to find the inverse name' do
+          expect(association.inverse).to eq(:container)
+        end
+      end
+
+      context 'when :cyclic is specified' do
+
+        it 'returns the cyclic inverse name' do
+
+        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: 'OtherEmbeddedObject' }
+      end
+
+      it 'returns the class name option' do
+        expect(association.relation_class_name).to eq('OtherEmbeddedObject')
+      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('EmbeddedObject')
+      end
+    end
+  end
+
+  describe '#klass' do
+
+    context 'when the :class_name option is specified' do
+
+      let!(:_class) do
+        class OtherEmbeddedObject; end
+        OtherEmbeddedObject
+      end
+
+      let(:options) do
+        { class_name: 'OtherEmbeddedObject' }
+      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(EmbeddedObject)
+      end
+    end
+  end
+
+  describe '#inverse_class_name' do
+
+    it 'returns the name of the owner class' do
+      expect(association.inverse_class_name).to eq(Container.name)
+    end
+  end
+
+  describe '#inverse_class' do
+
+    it 'returns the owner class' do
+      expect(association.inverse_class).to be(Container)
+    end
+  end
+
+  describe '#inverse_of' do
+
+    context 'when :inverse_of is specified in the options' do
+
+      let(:options) do
+        { inverse_of: :objects_list }
+      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
+        EmbeddedObject.embedded_in :container
+      end
+
+      it 'returns the name of the inverse followed by =' do
+        expect(association.inverse_setter).to eq('container=')
+      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
+        embeds_one_class.embeds_one 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(
+          "#{embeds_one_class.name}::#{embeds_one_class.name}#{name.to_s.camelize}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
+
+      context 'when :cascade_callbacks is true' do
+
+        let(:options) do
+          { cascade_callbacks: true }
+        end
+
+        it 'returns true' do
+          expect(association.cascading_callbacks?).to be(true)
+        end
+      end
+
+      context 'when :cascade_callbacks is false' do
+
+        let(:options) do
+          { cascade_callbacks: false }
+        end
+
+        it 'returns false' do
+          expect(association.cascading_callbacks?).to be(false)
+        end
+      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(double( :_parent => true))).to be_a(Mongoid::Atomic::Paths::Embedded::One)
+    end
+  end
+
+  describe '#create_relation' do
+
+    let(:owner) do
+      Container.new
+    end
+
+    let(:target) do
+      EmbeddedObject.new
+    end
+
+    before do
+      association
+      EmbeddedObject.embedded_in :container
+    end
+
+    it 'returns an the target (EmbeddedObject)' do
+      expect(Mongoid::Association::Embedded::EmbedsOne::Proxy).to receive(:new).and_call_original
+      expect(association.create_relation(owner, target)).to be_a(EmbeddedObject)
+    end
+  end
+end