mongomodel 0.5.5 → 0.5.6

data/spec/mongomodel/document_spec.rb

@@ -5,46 +5,46 @@ module MongoModel
     it "inherits from EmbeddedDocument" do
       Document.ancestors.should include(EmbeddedDocument)
     end
-    
+
     it "has an id property" do
       property = Document.properties[:id]
       property.name.should == :id
       property.as.should == '_id'
       property.default(double('instance', :generate_id => 'abc-123')).should == 'abc-123'
     end
-    
+
     describe "equality" do
       define_class(:DocumentA, Document)
       define_class(:DocumentB, Document)
-    
+
       subject { DocumentA.new(:id => 'test') }
-    
+
       it "is equal to another document of the same class with the same id" do
         subject.should == DocumentA.new(:id => 'test')
       end
-      
+
       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 "is not equal to another document of a different class with the same id" do
         subject.should_not == DocumentB.new(:id => 'test')
       end
     end
-    
+
     describe "single collection inheritance" do
       define_class(:Event, Document)
       define_class(:SpecialEvent, :Event)
       define_class(:VerySpecialEvent, :SpecialEvent)
       define_class(:SuperSpecialEvent, :VerySpecialEvent)
-      
+
       let(:missing) do
         e = Event.new
         e.type = 'MissingClass'
         e.save!
         e
       end
-      
+
       before(:each) do
         @event = Event.create!
         @special = SpecialEvent.create!
@@ -52,44 +52,44 @@ module MongoModel
         @super_special = SuperSpecialEvent.create!
         @missing = missing
       end
-      
+
       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 "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)
-        
+
         SpecialEvent.find(@special.id).should be_an_instance_of(SpecialEvent)
         SpecialEvent.find(@very_special.id).should be_an_instance_of(VerySpecialEvent)
-        
+
         VerySpecialEvent.find(@very_special.id).should be_an_instance_of(VerySpecialEvent)
       end
-      
+
       it "defaults to superclass type if type missing" do
         Event.find(@missing.id).should be_an_instance_of(Event)
       end
-      
+
       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 "loads all documents from root class" do
           Event.all.should include(@event, @special, @very_special, @super_special, @missing)
         end
-        
+
         it "only loads subclass documents from subclass" do
           SpecialEvent.all.should include(@special, @very_special, @super_special)
           SpecialEvent.all.should_not include(@event, @missing)
-          
+
           VerySpecialEvent.all.should include(@very_special, @super_special)
           VerySpecialEvent.all.should_not include(@event, @special, @missing)
-          
+
           SuperSpecialEvent.all.should == [@super_special]
         end
       end

data/spec/mongomodel/embedded_document_spec.rb

@@ -5,90 +5,90 @@ module MongoModel
     it "is an abstract class" do
       described_class.should be_an_abstract_class
     end
-    
+
     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 "is not an abstract class" do
         TestDocument.should_not be_an_abstract_class
       end
     end
   end
-  
+
   specs_for(EmbeddedDocument) do
     define_class(:Event, EmbeddedDocument)
     define_class(:SpecialEvent, :Event)
-    
+
     define_class(:Parent, Document) do
       property :event, Event
       property :events, Collection[Event], :default => []
     end
-    
+
     let(:event) { Event.new }
     let(:special) { SpecialEvent.new }
     let(:parent) { Parent.new(:event => special) }
     let(:reloaded) { parent.save!; Parent.find(parent.id) }
-    
+
     describe "equality" do
       define_class(:DocumentA, EmbeddedDocument) do
         property :name, String
       end
-      
+
       define_class(:DocumentB, EmbeddedDocument) do
         property :name, String
       end
-    
+
       subject { DocumentA.new(:id => 'test', :name => 'Test') }
-    
+
       it "is equal to another document of the same class with identical attributes" do
         subject.should == DocumentA.new(:id => 'test', :name => 'Test')
       end
-      
+
       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 "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 "does not typecast to parent type when assigning to property" do
         parent.event.should be_an_instance_of(SpecialEvent)
       end
-      
+
       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 "sets the parent document on the embedded document" do
           parent.event.parent_document.should == parent
         end
-      
+
         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 "sets the parent document on the collection" do
           parent.events.parent_document.should == parent
         end
-      
+
         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 "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

data/spec/mongomodel/mongomodel_spec.rb

@@ -3,8 +3,9 @@ require 'spec_helper'
 describe MongoModel do
   after(:all) do
     MongoModel.configuration = {}
+    MongoModel.logger = nil
   end
-  
+
   describe "setting a custom database configuration" do
     before(:each) do
       MongoModel.configuration = {
@@ -12,13 +13,13 @@ describe MongoModel do
         'database' => 'mydb'
       }
     end
-    
+
     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 "establishes database connection to given database" do
       database = MongoModel.database
       connection = database.connection
@@ -28,19 +29,19 @@ describe MongoModel do
       database.name.should == 'mydb'
     end
   end
-  
+
   describe "setting a custom database configuration as a URI string" do
     before(:each) do
       MongoModel.configuration = "mongodb://127.0.0.2:27019/mydb"
     end
-    
+
     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 "has a logger accessor" do
     logger = double('logger').as_null_object
     MongoModel.logger = logger

data/spec/mongomodel/support/collection_spec.rb

@@ -4,19 +4,19 @@ module MongoModel
   describe Collection do
     define_class(:TestDocument, EmbeddedDocument)
     let(:doc) { TestDocument.new }
-    
+
     subject { Collection }
-    
+
     it { should be_a_subclass_of(Array) }
-    
+
     it "has type Object" do
       subject.type.should == Object
     end
-    
+
     it "does not show its type when inspecting" do
       subject.inspect.should == "Collection"
     end
-    
+
     it "allows any object to be added to the collection" do
       collection = subject.new
       collection << 123
@@ -24,51 +24,51 @@ module MongoModel
       collection << doc
       collection.should == [123, "Hello", doc]
     end
-    
+
     it "converts to mongo representation" do
       collection = subject.new([123, "Hello", doc])
       collection.to_mongo.should == [123, "Hello", { "_type" => 'TestDocument' }]
     end
-    
+
     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 "caches collection types" do
       Collection[String].should equal(Collection[String])
       Collection[TestDocument].should equal(Collection[TestDocument])
     end
-    
+
     describe "a Collection of Strings" do
       subject { Collection[String] }
-      
+
       it { should be_a_subclass_of(Collection) }
       it { should be_a_subclass_of(Array) }
-      
+
       it "has type String" do
         subject.type.should == String
       end
-      
+
       it "shows its type when inspecting" do
         subject.inspect.should == "Collection[String]"
       end
-      
+
       it "converts to mongo representation" do
         collection = subject.new(["a", "bcd", "efg"])
         collection.to_mongo.should == ["a", "bcd", "efg"]
       end
-      
+
       it "loads from mongo representation" do
         collection = subject.from_mongo(["a", "bcd", "efg"])
         collection.should be_a(subject)
         collection.should == ["a", "bcd", "efg"]
       end
-      
+
       describe "casting" do
         subject { Collection[String].new }
-        
+
         it "casts elements when instantiating" do
           Collection[String].new(["abc", 123, 56.2]).should == ["abc", "123", "56.2"]
         end
@@ -79,62 +79,62 @@ module MongoModel
           subject << 56.2
           subject.should == ["abc", "123", "56.2"]
         end
-        
+
         it "casts elements on []=" do
           subject[0] = "abc"
           subject[1] = 123
           subject[2] = 56.2
           subject.should == ["abc", "123", "56.2"]
         end
-        
+
         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 "casts elements on concat" do
           subject.concat(["abc", 123, 56.2])
           subject.should == ["abc", "123", "56.2"]
         end
-        
+
         it "casts elements on delete" do
           subject.push("abc", 123, 56.2)
           subject.delete(123)
           subject.delete(56.2)
           subject.should == ["abc"]
         end
-        
+
         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 "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 "casts elements on push" do
           subject.push("abc", 123, 56.2)
           subject.should == ["abc", "123", "56.2"]
         end
-        
+
         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 "casts elements on unshift" do
           subject.unshift("abc")
           subject.unshift(123, 56.2)
           subject.should == ["123", "56.2", "abc"]
         end
-        
+
         it "casts elements on include?" do
           subject.push("abc", 123, 56.2)
           subject.should include(123)
@@ -143,58 +143,58 @@ module MongoModel
         end
       end
     end
-    
+
     describe "a Collection of embedded documents" do
       subject { Collection[TestDocument] }
-      
+
       it { should be_a_subclass_of(Collection) }
       it { should be_a_subclass_of(Array) }
-      
+
       it "has type TestDocument" do
         subject.type.should == TestDocument
       end
-      
+
       it "shows its type when inspecting" do
         subject.inspect.should == "Collection[TestDocument]"
       end
-      
+
       it "converts to mongo representation" do
         collection = subject.new([doc])
         collection.to_mongo.should == [{ "_type" => 'TestDocument' }]
       end
-      
+
       it "loads from mongo representation" do
         collection = subject.from_mongo([{ "_type" => 'TestDocument' }])
         collection.should be_a(subject)
         collection.should == [doc]
       end
     end
-    
+
     describe "a Collection of CustomClasses" do
       subject { Collection[CustomClass] }
-      
+
       it { should be_a_subclass_of(Collection) }
       it { should be_a_subclass_of(Array) }
-      
+
       it "has type CustomClass" do
         subject.type.should == CustomClass
       end
-      
+
       it "shows its type when inspecting" do
         subject.inspect.should == "Collection[CustomClass]"
       end
-      
+
       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 "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 "loads from mongo representation of single item" do
         collection = subject.from_mongo({ :name => "abc" })
         collection.should be_a(subject)
@@ -202,70 +202,70 @@ module MongoModel
       end
     end
   end
-  
+
   specs_for(Document, EmbeddedDocument) do
     describe "defining a Collection property with default value" do
       define_class(:TestDocument, described_class) do
         property :test_collection, Collection[CustomClass], :default => ['abc', 'def']
       end
-      
+
       subject { TestDocument.new }
-      
+
       it "casts items to collection type" do
         subject.test_collection.should == [CustomClass.new('abc'), CustomClass.new('def')]
       end
-      
+
       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 "does not share collections between instances" do
         subject.test_collection << '123'
         TestDocument.new.test_collection.should_not == subject.test_collection
       end
     end
-    
+
     describe "with a Collection containing EmbeddedDocuments" do
       define_class(:Embedded, EmbeddedDocument) do
         property :number, Integer
       end
-      
+
       define_class(:TestDocument, described_class) do
         property :embedded, Embedded
         property :embedded_collection, Collection[Embedded]
       end
-      
+
       let(:embedded1) { Embedded.new(:number => 1) }
       let(:embedded2) { Embedded.new(:number => 2) }
       let(:embedded3) { Embedded.new(:number => 3) }
-      
+
       let(:empty) { TestDocument.new }
       subject { TestDocument.new(:embedded => embedded1, :embedded_collection => [embedded2, embedded3]) }
-      
+
       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 "includes the embedded properties in the embedded documents list" do
         subject.embedded_documents.should include(embedded1)
       end
-      
+
       it "includes the elements in the collection in the embedded documents list" do
         subject.embedded_documents.should include(embedded2, embedded3)
       end
-      
+
       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 "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 "casts item to embedded document class when assigning attributes hash" do
         subject.embedded_collection = { :number => 8 }
         subject.embedded_collection.should == [ Embedded.new(:number => 8) ]