jnunemaker-mongomapper 0.2.0 → 0.3.0

data/test/unit/test_document.rb

@@ -0,0 +1,115 @@
+require 'test_helper'
+
+class DocumentTest < Test::Unit::TestCase
+  context "The Document Class" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+      end
+    end
+
+    should "track its descendants" do
+      MongoMapper::Document.descendants.should include(@document)
+    end
+
+    should "use default database by default" do
+      @document.database.should == MongoMapper.database
+    end
+
+    should "have a connection" do
+      @document.connection.should be_instance_of(XGen::Mongo::Driver::Mongo)
+    end
+
+    should "allow setting different connection without affecting the default" do
+      conn = XGen::Mongo::Driver::Mongo.new
+      @document.connection conn
+      @document.connection.should == conn
+      @document.connection.should_not == MongoMapper.connection
+    end
+
+    should "allow setting a different database without affecting the default" do
+      @document.database AlternateDatabase
+      @document.database.name.should == AlternateDatabase
+
+      another_document = Class.new do
+        include MongoMapper::Document
+      end
+      another_document.database.should == MongoMapper.database
+    end
+    
+    should "default collection name to class name tableized" do
+      class Item
+        include MongoMapper::Document
+      end
+      
+      Item.collection.should be_instance_of(XGen::Mongo::Driver::Collection)
+      Item.collection.name.should == 'items'
+    end
+
+    should "allow setting the collection name" do
+      @document.collection('foobar')
+      @document.collection.should be_instance_of(XGen::Mongo::Driver::Collection)
+      @document.collection.name.should == 'foobar'
+    end
+  end # Document class
+
+  context "An instance of a document" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+
+        key :name, String
+        key :age, Integer
+      end
+      @document.collection.clear
+    end
+
+    should "have access to the class's collection" do
+      doc = @document.new
+      doc.collection.should == @document.collection
+    end
+
+    should "automatically have an _id key" do
+      @document.keys.keys.should include('_id')
+    end
+
+    should "automatically have a created_at key" do
+      @document.keys.keys.should include('created_at')
+    end
+
+    should "automatically have an updated_at key" do
+      @document.keys.keys.should include('updated_at')
+    end
+
+    should "use default values if defined for keys" do
+      @document.key :active, Boolean, :default => true
+
+      @document.new.active.should be_true
+      @document.new(:active => false).active.should be_false
+    end
+
+    context "new?" do
+      should "be true if no id" do
+        @document.new.new?.should be(true)
+      end
+    end
+    
+    context "equality" do
+      should "be equal if id and class are the same" do
+        (@document.new('_id' => 1) == @document.new('_id' => 1)).should be(true)
+      end
+
+      should "not be equal if class same but id different" do
+        (@document.new('_id' => 1) == @document.new('_id' => 2)).should be(false)
+      end
+
+      should "not be equal if id same but class different" do
+        @another_document = Class.new do
+          include MongoMapper::Document
+        end
+
+        (@document.new('_id' => 1) == @another_document.new('_id' => 1)).should be(false)
+      end
+    end
+  end # instance of a document
+end # DocumentTest

data/test/{test_embedded_document.rb → unit/test_embedded_document.rb}

@@ -1,5 +1,25 @@
 require 'test_helper'
 
+class Grandparent
+  include MongoMapper::EmbeddedDocument
+  key :grandparent, String
+end
+
+class Parent < Grandparent
+  include MongoMapper::EmbeddedDocument
+  key :parent, String
+end
+
+class Child < Parent
+  include MongoMapper::EmbeddedDocument
+  key :child, String
+end
+
+class OtherChild < Parent
+  include MongoMapper::EmbeddedDocument
+  key :other_child, String
+end
+
 class EmbeddedDocumentTest < Test::Unit::TestCase
   context "Including MongoMapper::EmbeddedDocument" do
     setup do
@@ -7,33 +27,135 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         include MongoMapper::EmbeddedDocument
       end
     end
-        
+    
     should "clear out document default keys" do
       @klass.keys.size.should == 0
     end
   end
   
+  context "parent_model" do
+    should "be nil if none of parents ancestors include EmbeddedDocument" do
+      parent = Class.new
+      document = Class.new(parent) do
+        include MongoMapper::EmbeddedDocument
+      end
+      document.parent_model.should be_nil
+    end
+    
+    should "find parent" do
+      Parent.parent_model.should == Grandparent
+      Child.parent_model.should == Parent
+    end
+  end
+  
+  context "defining a key" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::EmbeddedDocument
+      end
+    end
+    
+    should "work" do
+      key = @document.key(:name, String)
+      key.name.should == 'name'
+      key.type.should == String
+      key.should be_instance_of(MongoMapper::Key)
+    end
+    
+    should "work with options" do
+      key = @document.key(:name, String, :required => true)
+      key.options[:required].should be(true)
+    end
+    
+    should "be tracked per document" do
+      @document.key(:name, String)
+      @document.key(:age, Integer)
+      @document.keys['name'].name.should == 'name'
+      @document.keys['name'].type.should == String
+      @document.keys['age'].name.should == 'age'
+      @document.keys['age'].type.should == Integer
+    end
+    
+    should "be redefinable" do
+      @document.key(:foo, String)
+      @document.keys['foo'].type.should == String
+      @document.key(:foo, Integer)
+      @document.keys['foo'].type.should == Integer
+    end
+    
+    should "create reader method" do
+      @document.new.should_not respond_to(:foo)
+      @document.key(:foo, String)
+      @document.new.should respond_to(:foo)
+    end
+    
+    should "create reader before typecast method" do
+      @document.new.should_not respond_to(:foo_before_typecast)
+      @document.key(:foo, String)
+      @document.new.should respond_to(:foo_before_typecast)
+    end
+    
+    should "create writer method" do
+      @document.new.should_not respond_to(:foo=)
+      @document.key(:foo, String)
+      @document.new.should respond_to(:foo=)
+    end
+    
+    should "create boolean method" do
+      @document.new.should_not respond_to(:foo?)
+      @document.key(:foo, String)
+      @document.new.should respond_to(:foo?)
+    end
+  end
+  
+  context "keys" do
+    should "be inherited" do
+      Grandparent.keys.keys.should == ['grandparent']
+      Parent.keys.keys.sort.should == ['grandparent', 'parent']
+      Child.keys.keys.sort.should  == ['child', 'grandparent', 'parent']
+    end
+    
+    should "propogate to subclasses if key added after class definition" do
+      Grandparent.key :_type, String
+      
+      Grandparent.keys.keys.sort.should == ['_type', 'grandparent']
+      Parent.keys.keys.sort.should      == ['_type', 'grandparent', 'parent']
+      Child.keys.keys.sort.should       == ['_type', 'child', 'grandparent', 'parent']
+    end
+  end
+  
+  context "subclasses" do
+    should "default to nil" do
+      Child.subclasses.should be_nil
+    end
+    
+    should "be recorded" do
+      Grandparent.subclasses.should == [Parent]
+      Parent.subclasses.should      == [Child, OtherChild]
+    end
+  end
+
   context "An instance of an embedded document" do
     setup do
       @document = Class.new do
         include MongoMapper::EmbeddedDocument
-        
+
         key :name, String
         key :age, Integer
       end
     end
-    
-    context "when initialized" do
+
+    context "being initialized" do
       should "accept a hash that sets keys and values" do
         doc = @document.new(:name => 'John', :age => 23)
         doc.attributes.should == {'name' => 'John', 'age' => 23}
       end
-      
+
       should "not throw error if initialized with nil" do
         doc = @document.new(nil)
       end
     end
-    
+
     context "mass assigning keys" do
       should "update values for keys provided" do
         doc = @document.new(:name => 'foobar', :age => 10)
@@ -49,22 +171,22 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         doc.attributes[:age].should == 10
       end
 
-      should "ignore keys that do not exist" do
+      should "raise undefined method if no key exists" do
         doc = @document.new(:name => 'foobar', :age => 10)
-        doc.attributes = {:name => 'new value', :foobar => 'baz'}
-        doc.attributes[:name].should == 'new value'
-        doc.attributes[:foobar].should be(nil)
+        lambda {
+          doc.attributes = {:name => 'new value', :foobar => 'baz'}
+        }.should raise_error(NoMethodError)
       end
-      
+
       should "not ignore keys that have methods defined" do
         @document.class_eval do
           attr_writer :password
-          
+
           def passwd
             @password
           end
         end
-        
+
         doc = @document.new(:name => 'foobar', :password => 'secret')
         doc.passwd.should == 'secret'
       end
@@ -76,7 +198,7 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
       end
     end
 
-    context "requesting keys" do
+    context "attributes" do
       should "default to empty hash" do
         doc = @document.new
         doc.attributes.should == {}
@@ -87,20 +209,20 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         doc.attributes.should == {'name' => 'string'}
       end
     end
-
-    context "key shorcuts" do
+    
+    context "key shorcut access" do
       should "be able to read key with []" do
         doc = @document.new(:name => 'string')
         doc[:name].should == 'string'
       end
-
+      
       should "be able to write key value with []=" do
         doc = @document.new
         doc[:name] = 'string'
         doc[:name].should == 'string'
       end
     end
-
+    
     context "indifferent access" do
       should "be enabled for keys" do
         doc = @document.new(:name => 'string')
@@ -119,47 +241,37 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         doc = @document.new
         lambda { doc.fart }.should raise_error(NoMethodError)
       end
-      
-      should "know if reader defined" do
-        doc = @document.new
-        doc.reader?('name').should be(true)
-        doc.reader?(:name).should be(true)
-        doc.reader?('age').should be(true)
-        doc.reader?(:age).should be(true)
-        doc.reader?('foobar').should be(false)
-        doc.reader?(:foobar).should be(false)
-      end
-      
+
       should "be accessible for use in the model" do
         @document.class_eval do
           def name_and_age
             "#{read_attribute(:name)} (#{read_attribute(:age)})"
           end
         end
-                
+
         doc = @document.new(:name => 'John', :age => 27)
         doc.name_and_age.should == 'John (27)'
       end
     end
-    
+
     context "reading an attribute before typcasting" do
       should "work for defined keys" do
         doc = @document.new(:name => 12)
         doc.name_before_typecast.should == 12
       end
-      
+
       should "raise no method error for undefined keys" do
         doc = @document.new
         lambda { doc.foo_before_typecast }.should raise_error(NoMethodError)
       end
-      
+
       should "be accessible for use in a document" do
         @document.class_eval do
           def untypcasted_name
             read_attribute_before_typecast(:name)
           end
         end
-                
+
         doc = @document.new(:name => 12)
         doc.name.should == '12'
         doc.untypcasted_name.should == 12
@@ -186,28 +298,15 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         doc.age.should == 21
       end
       
-      should "know if writer defined" do
-        doc = @document.new
-        doc.writer?('name').should be(true)
-        doc.writer?('name=').should be(true)
-        doc.writer?(:name).should be(true)
-        doc.writer?('age').should be(true)
-        doc.writer?('age=').should be(true)
-        doc.writer?(:age).should be(true)
-        doc.writer?('foobar').should be(false)
-        doc.writer?('foobar=').should be(false)
-        doc.writer?(:foobar).should be(false)
-      end
-      
       should "be accessible for use in the model" do
-        @document.class_eval do          
+        @document.class_eval do
           def name_and_age=(new_value)
             new_value.match(/([^\(\s]+) \((.*)\)/)
             write_attribute :name, $1
             write_attribute :age, $2
           end
         end
-                
+
         doc = @document.new
         doc.name_and_age = 'Frank (62)'
         doc.name.should == 'Frank'
@@ -215,24 +314,17 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
       end
     end # writing an attribute
     
-    context "respond_to?" do
-      setup do
-        @doc = @document.new
-      end
-      
-      should "work for readers" do
-        @doc.respond_to?(:name).should be_true
-        @doc.respond_to?('name').should be_true
-      end
-      
-      should "work for writers" do
-        @doc.respond_to?(:name=).should be_true
-        @doc.respond_to?('name=').should be_true
+    context "checking if an attributes value is present" do
+      should "work for defined keys" do
+        doc = @document.new
+        doc.name?.should be_false
+        doc.name = 'John'
+        doc.name?.should be_true
       end
       
-      should "work for readers before typecast" do
-        @doc.respond_to?(:name_before_typecast).should be_true
-        @doc.respond_to?('name_before_typecast').should be_true
+      should "raise no method error for undefined keys" do
+        doc = @document.new
+        lambda { doc.fart? }.should raise_error(NoMethodError)
       end
     end
     
@@ -242,7 +334,7 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
         doc2 = @document.new(:name => 'John', :age => 27)
         doc1.should == doc2
       end
-      
+
       should "be false if not all the keys and values are equal" do
         doc1 = @document.new(:name => 'Steve', :age => 27)
         doc2 = @document.new(:name => 'John', :age => 27)