mongomodel 0.4.6 → 0.4.7

data/spec/mongomodel/document/validations_spec.rb

@@ -14,7 +14,7 @@ module MongoModel
         subject { TestDocument.new }
     
         describe "#save" do
-          it "should return false" do
+          it "returns false" do
             subject.save.should be_false
           end
         end
@@ -24,23 +24,23 @@ module MongoModel
             subject.errors.stub!(:full_messages).and_return(["first error", "second error"])
           end
     
-          it "should raise a MongoModel::DocumentInvalid exception" do
+          it "raises a MongoModel::DocumentInvalid exception" do
             lambda { subject.save! }.should raise_error(MongoModel::DocumentInvalid, "Validation failed: first error, second error")
           end
         end
     
         shared_examples_for "saving without validation" do
-          it "should not validate the document" do
+          it "does not validate the document" do
             subject.should_not_receive(:valid?)
             save
           end
 
-          it "should save the document" do
+          it "saves the document" do
             subject.should_receive(:create_or_update).and_return(true)
             save
           end
 
-          it "should return true" do
+          it "returns true" do
             save.should be_true
           end
         end
@@ -67,11 +67,11 @@ module MongoModel
             TestDocument.validates_presence_of :title, :on => :custom
           end
           
-          it "should save in default context" do
+          it "saves in default context" do
             subject.save.should be_true
           end
           
-          it "should not save in custom context" do
+          it "does not save in custom context" do
             subject.save(:context => :custom).should be_false
           end
         end
@@ -86,17 +86,17 @@ module MongoModel
         end
   
         context "attributes hash" do
-          it "should pass attributes to instance" do
+          it "passes attributes to instance" do
             @user = User.create!(:name => 'Test', :age => 18)
             @user.name.should == 'Test'
             @user.age.should == 18
           end
   
-          it "should save! the instance" do
+          it "saves! the instance" do
             User.create!(:name => 'Test').should_not be_a_new_record
           end
   
-          it "should yield the instance to a given block before saving" do
+          it "yields the instance to a given block before saving" do
             block_called = false
       
             User.create!(:name => 'Test') do |u|
@@ -109,7 +109,7 @@ module MongoModel
             block_called.should be_true
           end
     
-          it "should raise an exception if the document is invalid" do
+          it "raises an exception if the document is invalid" do
             lambda { User.create! }.should raise_error(DocumentInvalid)
           end
         end
@@ -119,7 +119,7 @@ module MongoModel
             User.create!([{ :name => 'Test', :age => 18 }, { :name => 'Second', :age => 21 }], &block)
           end
     
-          it "should return instances in array with associated attributes" do
+          it "returns instances in array with associated attributes" do
             @users = create_users
             @users[0].name.should == 'Test'
             @users[0].age.should == 18
@@ -127,11 +127,11 @@ module MongoModel
             @users[1].age.should == 21
           end
     
-          it "should save! each instance" do
+          it "saves! each instance" do
             create_users.each { |user| user.should_not be_a_new_record }
           end
     
-          it "should yield each instance to a given block before saving" do
+          it "yields each instance to a given block before saving" do
             block_called = 0
       
             create_users do |u|
@@ -144,7 +144,7 @@ module MongoModel
             block_called.should == 2
           end
     
-          it "should raise an exception if a document is invalid" do
+          it "raises an exception if a document is invalid" do
             lambda { User.create!([ {}, {} ]) }.should raise_error(DocumentInvalid)
           end
         end
@@ -155,7 +155,7 @@ module MongoModel
       define_class(:TestDocument, Document)
       
       describe ":unique => true" do
-        it "should add a validates_uniqueness_of validation" do
+        it "adds a validates_uniqueness_of validation" do
           TestDocument.should_receive(:validates_uniqueness_of).with(:title)
           TestDocument.property :title, String, :unique => true
         end

data/spec/mongomodel/document_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 module MongoModel
   specs_for(Document) do
-    it "should inherit from EmbeddedDocument" do
+    it "inherits from EmbeddedDocument" do
       Document.ancestors.should include(EmbeddedDocument)
     end
     
-    it "should have an id property" do
+    it "has an id property" do
       property = Document.properties[:id]
       property.name.should == :id
       property.as.should == '_id'
@@ -19,15 +19,15 @@ module MongoModel
     
       subject { DocumentA.new(:id => 'test') }
     
-      it "should be equal to another document of the same class with the same id" do
+      it "is equal to another document of the same class with the same id" do
         subject.should == DocumentA.new(:id => 'test')
       end
       
-      it "should not be equal to another document of the same class with a different id" do
+      it "is not equal to another document of the same class with a different id" do
         subject.should_not == DocumentA.new(:id => 'not-test')
       end
       
-      it "should not be equal to another document of a different class with the same id" do
+      it "is not equal to another document of a different class with the same id" do
         subject.should_not == DocumentB.new(:id => 'test')
       end
     end
@@ -53,12 +53,12 @@ module MongoModel
         @missing = missing
       end
       
-      it "should belong to the same collection as its parent" do
+      it "belongs to the same collection as its parent" do
         SpecialEvent.collection_name.should == Event.collection_name
         VerySpecialEvent.collection_name.should == Event.collection_name
       end
       
-      it "should be an instance of the correct class when loaded" do
+      it "is an instance of the correct class when loaded" do
         Event.find(@event.id).should be_an_instance_of(Event)
         Event.find(@special.id).should be_an_instance_of(SpecialEvent)
         Event.find(@very_special.id).should be_an_instance_of(VerySpecialEvent)
@@ -69,21 +69,21 @@ module MongoModel
         VerySpecialEvent.find(@very_special.id).should be_an_instance_of(VerySpecialEvent)
       end
       
-      it "should default to superclass type if type missing" do
+      it "defaults to superclass type if type missing" do
         Event.find(@missing.id).should be_an_instance_of(Event)
       end
       
-      it "should consider document missing when finding from subclass using id of parent instance" do
+      it "considers document missing when finding from subclass using id of parent instance" do
         lambda { SpecialEvent.find(@event.id) }.should raise_error(MongoModel::DocumentNotFound)
         lambda { VerySpecialEvent.find(@special.id) }.should raise_error(MongoModel::DocumentNotFound)
       end
       
       describe "loading documents" do
-        it "should load all documents from root class" do
+        it "loads all documents from root class" do
           Event.all.should include(@event, @special, @very_special, @super_special, @missing)
         end
         
-        it "should only load subclass documents from subclass" do
+        it "only loads subclass documents from subclass" do
           SpecialEvent.all.should include(@special, @very_special, @super_special)
           SpecialEvent.all.should_not include(@event, @missing)
           

data/spec/mongomodel/embedded_document_spec.rb

@@ -2,18 +2,18 @@ require 'spec_helper'
 
 module MongoModel
   specs_for(EmbeddedDocument, Document) do
-    it "should be an abstract class" do
+    it "is an abstract class" do
       described_class.should be_an_abstract_class
     end
     
-    it "should instantiate with nil" do
+    it "instantiates with nil" do
       described_class.new(nil).should be_an_instance_of(described_class)
     end
     
     describe "subclasses" do
       define_class(:TestDocument, described_class)
       
-      it "should not be an abstract class" do
+      it "is not an abstract class" do
         TestDocument.should_not be_an_abstract_class
       end
     end
@@ -44,52 +44,52 @@ module MongoModel
     
       subject { DocumentA.new(:id => 'test', :name => 'Test') }
     
-      it "should be equal to another document of the same class with identical attributes" do
+      it "is equal to another document of the same class with identical attributes" do
         subject.should == DocumentA.new(:id => 'test', :name => 'Test')
       end
       
-      it "should not be equal to another document of the same class with different attributes" do
+      it "is not equal to another document of the same class with different attributes" do
         subject.should_not == DocumentA.new(:id => 'test', :name => 'Different')
         subject.should_not == DocumentA.new(:id => 'test', :name => 'Test', :special_attribute => 'Different')
       end
       
-      it "should not be equal to another document of a different class with identical attributes" do
+      it "is not equal to another document of a different class with identical attributes" do
         subject.should_not == DocumentB.new(:id => 'test', :name => 'Different')
       end
     end
     
     describe "single collection inheritance" do
-      it "should not typecast to parent type when assigning to property" do
+      it "does not typecast to parent type when assigning to property" do
         parent.event.should be_an_instance_of(SpecialEvent)
       end
       
-      it "should be an instance of the correct class when reloaded" do
+      it "is an instance of the correct class when reloaded" do
         reloaded.event.should be_an_instance_of(SpecialEvent)
       end
     end
     
     describe "parent document" do
       context "on an embedded document" do
-        it "should set the parent document on the embedded document" do
+        it "sets the parent document on the embedded document" do
           parent.event.parent_document.should == parent
         end
       
-        it "should set the parent document on the embedded document when loaded from database" do
+        it "sets the parent document on the embedded document when loaded from database" do
           reloaded.event.parent_document.should == reloaded
         end
       end
       
       context "on a collection" do
-        it "should set the parent document on the collection" do
+        it "sets the parent document on the collection" do
           parent.events.parent_document.should == parent
         end
       
-        it "should set the parent document on each item added to a collection" do
+        it "sets the parent document on each item added to a collection" do
           parent.events << special
           parent.events.first.parent_document.should == parent
         end
       
-        it "should set the parent document on each item in a collection when loaded from database" do
+        it "sets the parent document on each item in a collection when loaded from database" do
           parent.events << special
           reloaded.events.first.parent_document.should == parent
         end

data/spec/mongomodel/mongomodel_spec.rb

@@ -13,13 +13,13 @@ describe MongoModel do
       }
     end
     
-    it "should should merge configuration with defaults" do
+    it "shoulds merge configuration with defaults" do
       MongoModel.configuration.host.should == '127.0.0.1'
       MongoModel.configuration.port.should == 27017
       MongoModel.configuration.database.should == 'mydb'
     end
     
-    it "should establish database connection to given database" do
+    it "establishes database connection to given database" do
       database = MongoModel.database
       connection = database.connection
 
@@ -34,14 +34,14 @@ describe MongoModel do
       MongoModel.configuration = "mongodb://127.0.0.2:27019/mydb"
     end
     
-    it "should should merge configuration with defaults" do
+    it "shoulds merge configuration with defaults" do
       MongoModel.configuration.host.should == '127.0.0.2'
       MongoModel.configuration.port.should == 27019
       MongoModel.configuration.database.should == 'mydb'
     end
   end
   
-  it "should have a logger accessor" do
+  it "has a logger accessor" do
     logger = mock('logger').as_null_object
     MongoModel.logger = logger
     MongoModel.logger.should == logger

data/spec/mongomodel/support/collection_spec.rb

@@ -9,15 +9,15 @@ module MongoModel
     
     it { should be_a_subclass_of(Array) }
     
-    it "should have type Object" do
+    it "has type Object" do
       subject.type.should == Object
     end
     
-    it "should not show its type when inspecting" do
+    it "does not show its type when inspecting" do
       subject.inspect.should == "Collection"
     end
     
-    it "should allow any object to be added to the collection" do
+    it "allows any object to be added to the collection" do
       collection = subject.new
       collection << 123
       collection << "Hello"
@@ -25,18 +25,18 @@ module MongoModel
       collection.should == [123, "Hello", doc]
     end
     
-    it "should convert to mongo representation" do
+    it "converts to mongo representation" do
       collection = subject.new([123, "Hello", doc])
       collection.to_mongo.should == [123, "Hello", { "_type" => 'TestDocument' }]
     end
     
-    it "should load from mongo representation" do
+    it "loads from mongo representation" do
       collection = subject.from_mongo([123, "Hello", { "_type" => 'TestDocument' }])
       collection.should be_a(subject)
       collection.should == [123, "Hello", doc]
     end
     
-    it "should cache collection types" do
+    it "caches collection types" do
       Collection[String].should equal(Collection[String])
       Collection[TestDocument].should equal(Collection[TestDocument])
     end
@@ -47,20 +47,20 @@ module MongoModel
       it { should be_a_subclass_of(Collection) }
       it { should be_a_subclass_of(Array) }
       
-      it "should have type String" do
+      it "has type String" do
         subject.type.should == String
       end
       
-      it "should show its type when inspecting" do
+      it "shows its type when inspecting" do
         subject.inspect.should == "Collection[String]"
       end
       
-      it "should convert to mongo representation" do
+      it "converts to mongo representation" do
         collection = subject.new(["a", "bcd", "efg"])
         collection.to_mongo.should == ["a", "bcd", "efg"]
       end
       
-      it "should load from mongo representation" do
+      it "loads from mongo representation" do
         collection = subject.from_mongo(["a", "bcd", "efg"])
         collection.should be_a(subject)
         collection.should == ["a", "bcd", "efg"]
@@ -69,73 +69,73 @@ module MongoModel
       describe "casting" do
         subject { Collection[String].new }
         
-        it "should cast elements when instantiating" do
+        it "casts elements when instantiating" do
           Collection[String].new(["abc", 123, 56.2]).should == ["abc", "123", "56.2"]
         end
 
-        it "should cast elements on <<" do
+        it "casts elements on <<" do
           subject << "abc"
           subject << 123
           subject << 56.2
           subject.should == ["abc", "123", "56.2"]
         end
         
-        it "should cast elements on []=" do
+        it "casts elements on []=" do
           subject[0] = "abc"
           subject[1] = 123
           subject[2] = 56.2
           subject.should == ["abc", "123", "56.2"]
         end
         
-        it "should cast elements on +" do
+        it "casts elements on +" do
           result = subject + ["abc", 123, 56.2]
           result.should be_an_instance_of(Collection[String])
           result.should == ["abc", "123", "56.2"]
         end
         
-        it "should cast elements on concat" do
+        it "casts elements on concat" do
           subject.concat(["abc", 123, 56.2])
           subject.should == ["abc", "123", "56.2"]
         end
         
-        it "should cast elements on delete" do
+        it "casts elements on delete" do
           subject.push("abc", 123, 56.2)
           subject.delete(123)
           subject.delete(56.2)
           subject.should == ["abc"]
         end
         
-        it "should cast elements on index" do
+        it "casts elements on index" do
           subject.push("abc", 123, 56.2)
           subject.index(123).should == 1
           subject.index(56.2).should == 2
         end
         
-        it "should cast elements on insert" do
+        it "casts elements on insert" do
           subject.insert(0, 56.2)
           subject.insert(0, "abc")
           subject.insert(1, 123)
           subject.should == ["abc", "123", "56.2"]
         end
         
-        it "should cast elements on push" do
+        it "casts elements on push" do
           subject.push("abc", 123, 56.2)
           subject.should == ["abc", "123", "56.2"]
         end
         
-        it "should cast elements on rindex" do
+        it "casts elements on rindex" do
           subject.push("abc", 123, 56.2, 123)
           subject.rindex(123).should == 3
           subject.rindex(56.2).should == 2
         end
         
-        it "should cast elements on unshift" do
+        it "casts elements on unshift" do
           subject.unshift("abc")
           subject.unshift(123, 56.2)
           subject.should == ["123", "56.2", "abc"]
         end
         
-        it "should cast elements on include?" do
+        it "casts elements on include?" do
           subject.push("abc", 123, 56.2)
           subject.should include(123)
           subject.should include(56.2)
@@ -150,20 +150,20 @@ module MongoModel
       it { should be_a_subclass_of(Collection) }
       it { should be_a_subclass_of(Array) }
       
-      it "should have type TestDocument" do
+      it "has type TestDocument" do
         subject.type.should == TestDocument
       end
       
-      it "should show its type when inspecting" do
+      it "shows its type when inspecting" do
         subject.inspect.should == "Collection[TestDocument]"
       end
       
-      it "should convert to mongo representation" do
+      it "converts to mongo representation" do
         collection = subject.new([doc])
         collection.to_mongo.should == [{ "_type" => 'TestDocument' }]
       end
       
-      it "should load from mongo representation" do
+      it "loads from mongo representation" do
         collection = subject.from_mongo([{ "_type" => 'TestDocument' }])
         collection.should be_a(subject)
         collection.should == [doc]
@@ -176,26 +176,26 @@ module MongoModel
       it { should be_a_subclass_of(Collection) }
       it { should be_a_subclass_of(Array) }
       
-      it "should have type CustomClass" do
+      it "has type CustomClass" do
         subject.type.should == CustomClass
       end
       
-      it "should show its type when inspecting" do
+      it "shows its type when inspecting" do
         subject.inspect.should == "Collection[CustomClass]"
       end
       
-      it "should convert to mongo representation" do
+      it "converts to mongo representation" do
         collection = subject.new([CustomClass.new("abc"), CustomClass.new("123")])
         collection.to_mongo.should == [{ :name => "abc" }, { :name => "123" }]
       end
       
-      it "should load from mongo representation" do
+      it "loads from mongo representation" do
         collection = subject.from_mongo([{ :name => "abc" }, { :name => "123" }])
         collection.should be_a(subject)
         collection.should == [CustomClass.new("abc"), CustomClass.new("123")]
       end
       
-      it "should load from mongo representation of single item" do
+      it "loads from mongo representation of single item" do
         collection = subject.from_mongo({ :name => "abc" })
         collection.should be_a(subject)
         collection.should == [CustomClass.new("abc")]
@@ -211,16 +211,16 @@ module MongoModel
       
       subject { TestDocument.new }
       
-      it "should cast items to collection type" do
+      it "casts items to collection type" do
         subject.test_collection.should == [CustomClass.new('abc'), CustomClass.new('def')]
       end
       
-      it "should allow items to be added to collection" do
+      it "allows items to be added to collection" do
         subject.test_collection << '123'
         subject.test_collection.should == [CustomClass.new('abc'), CustomClass.new('def'), CustomClass.new('123')]
       end
       
-      it "should not share collections between instances" do
+      it "does not share collections between instances" do
         subject.test_collection << '123'
         TestDocument.new.test_collection.should_not == subject.test_collection
       end
@@ -243,30 +243,30 @@ module MongoModel
       let(:empty) { TestDocument.new }
       subject { TestDocument.new(:embedded => embedded1, :embedded_collection => [embedded2, embedded3]) }
       
-      it "should default to an empty collection" do
+      it "defaults to an empty collection" do
         empty.embedded_collection.should be_an_instance_of(Collection[Embedded])
         empty.embedded_collection.should be_empty
       end
       
-      it "should include the embedded properties in the embedded documents list" do
+      it "includes the embedded properties in the embedded documents list" do
         subject.embedded_documents.should include(embedded1)
       end
       
-      it "should include the elements in the collection in the embedded documents list" do
+      it "includes the elements in the collection in the embedded documents list" do
         subject.embedded_documents.should include(embedded2, embedded3)
       end
       
-      it "should cast items to embedded document class when assigning array of hashes" do
+      it "casts items to embedded document class when assigning array of hashes" do
         subject.embedded_collection = [ { :number => 5 }, { :number => 99 } ]
         subject.embedded_collection.should == [ Embedded.new(:number => 5), Embedded.new(:number => 99) ]
       end
       
-      it "should cast items to embedded document class when assigning collection hash" do
+      it "casts items to embedded document class when assigning collection hash" do
         subject.embedded_collection = { :_collection => true, :items => [ { :number => 49 }, { :number => 64 } ] }
         subject.embedded_collection.should == [ Embedded.new(:number => 49), Embedded.new(:number => 64) ]
       end
       
-      it "should cast item to embedded document class when assigning attributes hash" do
+      it "casts item to embedded document class when assigning attributes hash" do
         subject.embedded_collection = { :number => 8 }
         subject.embedded_collection.should == [ Embedded.new(:number => 8) ]
       end