mongoid 3.1.7 → 4.0.0.alpha1

data/spec/mongoid/relations/macros_spec.rb

@@ -18,20 +18,7 @@ describe Mongoid::Relations::Macros do
   describe ".embedded_in" do
 
     it "defines the macro" do
-      klass.should respond_to(:embedded_in)
-    end
-
-    context "when the document is versioned" do
-
-      it "raises an error" do
-        expect {
-          Class.new do
-            include Mongoid::Document
-            include Mongoid::Versioning
-            embedded_in :parent_class
-          end
-        }.to raise_error(Mongoid::Errors::VersioningNotOnRoot)
-      end
+      expect(klass).to respond_to(:embedded_in)
     end
 
     context "when defining the relation" do
@@ -41,25 +28,25 @@ describe Mongoid::Relations::Macros do
       end
 
       it "adds the metadata to the klass" do
-        klass.relations["person"].should_not be_nil
+        expect(klass.relations["person"]).to_not be_nil
       end
 
       it "defines the getter" do
-        klass.allocate.should respond_to(:person)
+        expect(klass.allocate).to respond_to(:person)
       end
 
       it "defines the setter" do
-        klass.allocate.should respond_to(:person=)
+        expect(klass.allocate).to respond_to(:person=)
       end
 
       it "creates the correct relation" do
-        klass.relations["person"].relation.should eq(
+        expect(klass.relations["person"].relation).to eq(
           Mongoid::Relations::Embedded::In
         )
       end
 
       it "does not add associated validations" do
-        klass._validators.should be_empty
+        expect(klass._validators).to be_empty
       end
 
       context "metadata properties" do
@@ -69,11 +56,11 @@ describe Mongoid::Relations::Macros do
         end
 
         it "automatically adds the name" do
-          metadata.name.should eq(:person)
+          expect(metadata.name).to eq(:person)
         end
 
         it "automatically adds the inverse class name" do
-          metadata.inverse_class_name.should eq("TestClass")
+          expect(metadata.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -82,7 +69,7 @@ describe Mongoid::Relations::Macros do
   describe ".embeds_many" do
 
     it "defines the macro" do
-      klass.should respond_to(:embeds_many)
+      expect(klass).to respond_to(:embeds_many)
     end
 
     context "when defining the relation" do
@@ -92,26 +79,26 @@ describe Mongoid::Relations::Macros do
       end
 
       it "adds the metadata to the klass" do
-        klass.relations["addresses"].should_not be_nil
+        expect(klass.relations["addresses"]).to_not be_nil
       end
 
       it "defines the getter" do
-        klass.allocate.should respond_to(:addresses)
+        expect(klass.allocate).to respond_to(:addresses)
       end
 
       it "defines the setter" do
-        klass.allocate.should respond_to(:addresses=)
+        expect(klass.allocate).to respond_to(:addresses=)
       end
 
       it "creates the correct relation" do
-        klass.relations["addresses"].relation.should eq(
+        expect(klass.relations["addresses"].relation).to eq(
           Mongoid::Relations::Embedded::Many
         )
       end
 
       it "adds an associated validation" do
-        klass._validators[:addresses].first.should be_a(
-          Mongoid::Validations::AssociatedValidator
+        expect(klass._validators[:addresses].first).to be_a(
+          Mongoid::Validatable::AssociatedValidator
         )
       end
 
@@ -122,11 +109,11 @@ describe Mongoid::Relations::Macros do
         end
 
         it "automatically adds the name" do
-          metadata.name.should eq(:addresses)
+          expect(metadata.name).to eq(:addresses)
         end
 
         it "automatically adds the inverse class name" do
-          metadata.inverse_class_name.should eq("TestClass")
+          expect(metadata.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -142,11 +129,11 @@ describe Mongoid::Relations::Macros do
       end
 
       it "adds metadata to klass" do
-        metadata.order.should_not be_nil
+        expect(metadata.order).to_not be_nil
       end
 
       it "returns Origin::Key" do
-        metadata.order.should be_kind_of(Origin::Key)
+        expect(metadata.order).to be_kind_of(Origin::Key)
       end
     end
 
@@ -157,7 +144,7 @@ describe Mongoid::Relations::Macros do
       end
 
       it "does not add associated validations" do
-        klass._validators.should be_empty
+        expect(klass._validators).to be_empty
       end
     end
   end
@@ -165,7 +152,7 @@ describe Mongoid::Relations::Macros do
   describe ".embeds_one" do
 
     it "defines the macro" do
-      klass.should respond_to(:embeds_one)
+      expect(klass).to respond_to(:embeds_one)
     end
 
     context "when defining the relation" do
@@ -175,34 +162,34 @@ describe Mongoid::Relations::Macros do
       end
 
       it "adds the metadata to the klass" do
-        klass.relations["name"].should_not be_nil
+        expect(klass.relations["name"]).to_not be_nil
       end
 
       it "defines the getter" do
-        klass.allocate.should respond_to(:name)
+        expect(klass.allocate).to respond_to(:name)
       end
 
       it "defines the setter" do
-        klass.allocate.should respond_to(:name=)
+        expect(klass.allocate).to respond_to(:name=)
       end
 
       it "defines the builder" do
-        klass.allocate.should respond_to(:build_name)
+        expect(klass.allocate).to respond_to(:build_name)
       end
 
       it "defines the creator" do
-        klass.allocate.should respond_to(:create_name)
+        expect(klass.allocate).to respond_to(:create_name)
       end
 
       it "creates the correct relation" do
-        klass.relations["name"].relation.should eq(
+        expect(klass.relations["name"].relation).to eq(
           Mongoid::Relations::Embedded::One
         )
       end
 
       it "adds an associated validation" do
-        klass._validators[:name].first.should be_a(
-          Mongoid::Validations::AssociatedValidator
+        expect(klass._validators[:name].first).to be_a(
+          Mongoid::Validatable::AssociatedValidator
         )
       end
 
@@ -213,11 +200,11 @@ describe Mongoid::Relations::Macros do
         end
 
         it "automatically adds the name" do
-          metadata.name.should eq(:name)
+          expect(metadata.name).to eq(:name)
         end
 
         it "automatically adds the inverse class name" do
-          metadata.inverse_class_name.should eq("TestClass")
+          expect(metadata.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -229,7 +216,7 @@ describe Mongoid::Relations::Macros do
       end
 
       it "does not add associated validations" do
-        klass._validators.should be_empty
+        expect(klass._validators).to be_empty
       end
     end
   end
@@ -237,7 +224,7 @@ describe Mongoid::Relations::Macros do
   describe ".belongs_to" do
 
     it "defines the macro" do
-      klass.should respond_to(:belongs_to)
+      expect(klass).to respond_to(:belongs_to)
     end
 
     context "when the relation is polymorphic" do
@@ -248,12 +235,12 @@ describe Mongoid::Relations::Macros do
           klass.belongs_to(:relatable, polymorphic: true, index: true)
         end
 
-        let(:indexes) do
-          klass.index_options
+        let(:index) do
+          klass.index_specifications.first
         end
 
         it "adds the background index to the definitions" do
-          expect(indexes).to eq({ relatable_id: 1, relatable_type: 1 } => { background: true })
+          expect(index.key).to eq(relatable_id: 1, relatable_type: 1)
         end
       end
     end
@@ -265,33 +252,33 @@ describe Mongoid::Relations::Macros do
       end
 
       it "adds the metadata to the klass" do
-        klass.relations["person"].should_not be_nil
+        expect(klass.relations["person"]).to_not be_nil
       end
 
       it "defines the getter" do
-        klass.allocate.should respond_to(:person)
+        expect(klass.allocate).to respond_to(:person)
       end
 
       it "defines the setter" do
-        klass.allocate.should respond_to(:person=)
+        expect(klass.allocate).to respond_to(:person=)
       end
 
       it "defines the builder" do
-        klass.allocate.should respond_to(:build_person)
+        expect(klass.allocate).to respond_to(:build_person)
       end
 
       it "defines the creator" do
-        klass.allocate.should respond_to(:create_person)
+        expect(klass.allocate).to respond_to(:create_person)
       end
 
       it "creates the correct relation" do
-        klass.relations["person"].relation.should eq(
+        expect(klass.relations["person"].relation).to eq(
           Mongoid::Relations::Referenced::In
         )
       end
 
       it "creates the field for the foreign key" do
-        klass.allocate.should respond_to(:person_id)
+        expect(klass.allocate).to respond_to(:person_id)
       end
 
       context "metadata properties" do
@@ -301,11 +288,11 @@ describe Mongoid::Relations::Macros do
         end
 
         it "automatically adds the name" do
-          metadata.name.should eq(:person)
+          expect(metadata.name).to eq(:person)
         end
 
         it "automatically adds the inverse class name" do
-          metadata.inverse_class_name.should eq("TestClass")
+          expect(metadata.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -314,7 +301,7 @@ describe Mongoid::Relations::Macros do
   describe ".has_many" do
 
     it "defines the macro" do
-      klass.should respond_to(:has_many)
+      expect(klass).to respond_to(:has_many)
     end
 
     context "when defining the relation" do
@@ -324,26 +311,26 @@ describe Mongoid::Relations::Macros do
       end
 
       it "adds the metadata to the klass" do
-        klass.relations["posts"].should_not be_nil
+        expect(klass.relations["posts"]).to_not be_nil
       end
 
       it "defines the getter" do
-        klass.allocate.should respond_to(:posts)
+        expect(klass.allocate).to respond_to(:posts)
       end
 
       it "defines the setter" do
-        klass.allocate.should respond_to(:posts=)
+        expect(klass.allocate).to respond_to(:posts=)
       end
 
       it "creates the correct relation" do
-        klass.relations["posts"].relation.should eq(
+        expect(klass.relations["posts"].relation).to eq(
           Mongoid::Relations::Referenced::Many
         )
       end
 
       it "adds an associated validation" do
-        klass._validators[:posts].first.should be_a(
-          Mongoid::Validations::AssociatedValidator
+        expect(klass._validators[:posts].first).to be_a(
+          Mongoid::Validatable::AssociatedValidator
         )
       end
 
@@ -354,11 +341,11 @@ describe Mongoid::Relations::Macros do
         end
 
         it "automatically adds the name" do
-          metadata.name.should eq(:posts)
+          expect(metadata.name).to eq(:posts)
         end
 
         it "automatically adds the inverse class name" do
-          metadata.inverse_class_name.should eq("TestClass")
+          expect(metadata.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -374,11 +361,11 @@ describe Mongoid::Relations::Macros do
       end
 
       it "adds metadata to klass" do
-        metadata.order.should_not be_nil
+        expect(metadata.order).to_not be_nil
       end
 
       it "returns Origin::Key" do
-        metadata.order.should be_kind_of(Origin::Key)
+        expect(metadata.order).to be_kind_of(Origin::Key)
       end
     end
 
@@ -389,7 +376,7 @@ describe Mongoid::Relations::Macros do
       end
 
       it "does not add associated validations" do
-        klass._validators.should be_empty
+        expect(klass._validators).to be_empty
       end
     end
   end
@@ -397,7 +384,7 @@ describe Mongoid::Relations::Macros do
   describe ".has_and_belongs_to_many" do
 
     it "defines the macro" do
-      klass.should respond_to(:has_and_belongs_to_many)
+      expect(klass).to respond_to(:has_and_belongs_to_many)
     end
 
     context "when defining the relation" do
@@ -407,25 +394,25 @@ describe Mongoid::Relations::Macros do
       end
 
       it "adds the metadata to the klass" do
-        klass.relations["preferences"].should_not be_nil
+        expect(klass.relations["preferences"]).to_not be_nil
       end
 
       it "defines the getter" do
-        klass.allocate.should respond_to(:preferences)
+        expect(klass.allocate).to respond_to(:preferences)
       end
 
       it "defines the setter" do
-        klass.allocate.should respond_to(:preferences=)
+        expect(klass.allocate).to respond_to(:preferences=)
       end
 
       it "creates the correct relation" do
-        klass.relations["preferences"].relation.should eq(
+        expect(klass.relations["preferences"].relation).to eq(
           Mongoid::Relations::Referenced::ManyToMany
         )
       end
 
       it "creates the field for the foreign key" do
-        klass.allocate.should respond_to(:preference_ids)
+        expect(klass.allocate).to respond_to(:preference_ids)
       end
 
       context 'when defining order on relation' do
@@ -439,11 +426,11 @@ describe Mongoid::Relations::Macros do
         end
 
         it "adds metadata to klass" do
-          metadata.order.should_not be_nil
+          expect(metadata.order).to_not be_nil
         end
 
         it "returns Origin::Key" do
-          metadata.order.should be_kind_of(Origin::Key)
+          expect(metadata.order).to be_kind_of(Origin::Key)
         end
       end
 
@@ -454,11 +441,11 @@ describe Mongoid::Relations::Macros do
         end
 
         it "automatically adds the name" do
-          metadata.name.should eq(:preferences)
+          expect(metadata.name).to eq(:preferences)
         end
 
         it "automatically adds the inverse class name" do
-          metadata.inverse_class_name.should eq("TestClass")
+          expect(metadata.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -467,7 +454,7 @@ describe Mongoid::Relations::Macros do
   describe ".has_one" do
 
     it "defines the macro" do
-      klass.should respond_to(:has_one)
+      expect(klass).to respond_to(:has_one)
     end
 
     context "when defining the relation" do
@@ -477,34 +464,34 @@ describe Mongoid::Relations::Macros do
       end
 
       it "adds the metadata to the klass" do
-        klass.relations["game"].should_not be_nil
+        expect(klass.relations["game"]).to_not be_nil
       end
 
       it "defines the getter" do
-        klass.allocate.should respond_to(:game)
+        expect(klass.allocate).to respond_to(:game)
       end
 
       it "defines the setter" do
-        klass.allocate.should respond_to(:game=)
+        expect(klass.allocate).to respond_to(:game=)
       end
 
       it "defines the builder" do
-        klass.allocate.should respond_to(:build_game)
+        expect(klass.allocate).to respond_to(:build_game)
       end
 
       it "defines the creator" do
-        klass.allocate.should respond_to(:create_game)
+        expect(klass.allocate).to respond_to(:create_game)
       end
 
       it "creates the correct relation" do
-        klass.relations["game"].relation.should eq(
+        expect(klass.relations["game"].relation).to eq(
           Mongoid::Relations::Referenced::One
         )
       end
 
       it "adds an associated validation" do
-        klass._validators[:game].first.should be_a(
-          Mongoid::Validations::AssociatedValidator
+        expect(klass._validators[:game].first).to be_a(
+          Mongoid::Validatable::AssociatedValidator
         )
       end
 
@@ -515,11 +502,11 @@ describe Mongoid::Relations::Macros do
         end
 
         it "automatically adds the name" do
-          metadata.name.should eq(:game)
+          expect(metadata.name).to eq(:game)
         end
 
         it "automatically adds the inverse class name" do
-          metadata.inverse_class_name.should eq("TestClass")
+          expect(metadata.inverse_class_name).to eq("TestClass")
         end
       end
     end
@@ -531,7 +518,7 @@ describe Mongoid::Relations::Macros do
       end
 
       it "does not add associated validations" do
-        klass._validators.should be_empty
+        expect(klass._validators).to be_empty
       end
     end
   end
@@ -543,16 +530,17 @@ describe Mongoid::Relations::Macros do
     end
 
     it "returns a hash of relations" do
-      klass.allocate.relations.should be_a_kind_of(Hash)
+      expect(klass.allocate.relations).to be_a_kind_of(Hash)
     end
 
     it "has keys that are the relation name" do
-      klass.allocate.relations.keys.first.should eq("name")
+      expect(klass.allocate.relations.keys.first).to eq("name")
     end
 
     it "has values that are metadata" do
-      klass.allocate.relations.values.first.should
-        be_a_kind_of(Mongoid::Relations::Metadata)
+      expect(
+        klass.allocate.relations.values.first
+      ).to be_a_kind_of(Mongoid::Relations::Metadata)
     end
   end
 
@@ -563,16 +551,17 @@ describe Mongoid::Relations::Macros do
     end
 
     it "returns a hash of relations" do
-      klass.relations.should be_a_kind_of(Hash)
+      expect(klass.relations).to be_a_kind_of(Hash)
     end
 
     it "has keys that are the relation name" do
-      klass.relations.keys.first.should eq("name")
+      expect(klass.relations.keys.first).to eq("name")
     end
 
     it "has values that are metadata" do
-      klass.relations.values.first.should
-        be_a_kind_of(Mongoid::Relations::Metadata)
+      expect(
+        klass.relations.values.first
+      ).to be_a_kind_of(Mongoid::Relations::Metadata)
     end
   end
 
@@ -590,6 +579,12 @@ describe Mongoid::Relations::Macros do
           "spec"
         end
       end
+
+      module AnotherExtension
+        def very_short_name
+          "spec"
+        end
+      end
     end
 
     let(:peep) do
@@ -607,7 +602,7 @@ describe Mongoid::Relations::Macros do
       end
 
       it "extends the relation" do
-        peep.handle.full_name.should eq("spec")
+        expect(peep.handle.full_name).to eq("spec")
       end
     end
 
@@ -618,7 +613,18 @@ describe Mongoid::Relations::Macros do
       end
 
       it "extends the relation" do
-        peep.handle.short_name.should eq("spec")
+        expect(peep.handle.short_name).to eq("spec")
+      end
+    end
+
+    context "when the extension is two modules" do
+
+      before do
+        Peep.embeds_one(:handle, extend: [ Handle::Extension, Handle::AnotherExtension ])
+      end
+
+      it "extends the relation" do
+        expect(peep.handle.very_short_name).to eq("spec")
       end
     end
   end