novelys_mongo_mapper 0.6.10

data/test/unit/test_support.rb

@@ -0,0 +1,354 @@
+require 'test_helper'
+
+class SupportTest < Test::Unit::TestCase
+  context "Array#to_mongo" do
+    should "convert value to_a" do
+      Array.to_mongo([1, 2, 3, 4]).should == [1, 2, 3, 4]
+      Array.to_mongo('1').should == ['1']
+      Array.to_mongo({'1' => '2', '3' => '4'}).should == [['1', '2'], ['3', '4']]
+    end
+  end
+
+  context "Array#from_mongo" do
+    should "be array if array" do
+      Array.from_mongo([1, 2]).should == [1, 2]
+    end
+    
+    should "be empty array if nil" do
+      Array.from_mongo(nil).should == []
+    end
+  end
+  
+  context "Binary#to_mongo" do
+    should "convert to byte buffer if not byte buffer" do
+      Binary.to_mongo('asdfsadasdfs').is_a?(ByteBuffer).should be_true
+    end
+    
+    should "be byte buffer if byte buffer" do
+      Binary.to_mongo(ByteBuffer.new('asdfsadasdfs')).is_a?(ByteBuffer).should be_true
+    end
+    
+    should "be nil if nil" do
+      Binary.to_mongo(nil).should be_nil
+    end
+  end
+  
+  context "Binary#from_mongo" do
+    should "return value" do
+      buffer = ByteBuffer.new('asdfasdfasdf')
+      Binary.from_mongo(buffer).to_s.should == buffer.to_s
+    end
+  end
+  
+  context "Boolean#to_mongo" do
+    should "be true for true" do
+      Boolean.to_mongo(true).should be_true
+    end
+    
+    should "be false for false" do
+      Boolean.to_mongo(false).should be_false
+    end
+    
+    should "handle odd assortment of other values" do
+      Boolean.to_mongo('true').should be_true
+      Boolean.to_mongo('t').should be_true
+      Boolean.to_mongo('1').should be_true
+      Boolean.to_mongo(1).should be_true
+      
+      Boolean.to_mongo('false').should be_false
+      Boolean.to_mongo('f').should be_false
+      Boolean.to_mongo('0').should be_false
+      Boolean.to_mongo(0).should be_false
+    end
+  end
+  
+  context "Boolean#from_mongo" do
+    should "be true for true" do
+      Boolean.from_mongo(true).should be_true
+    end
+    
+    should "be false for false" do
+      Boolean.from_mongo(false).should be_false
+    end
+    
+    should "be false for nil" do
+      Boolean.from_mongo(nil).should be_false
+    end
+  end
+  
+  context "Date#to_mongo" do
+    should "be time if string" do
+      date = Date.to_mongo('10/1/2009')
+      date.should == Time.utc(2009, 10, 1)
+      date.should == date
+      date.month.should == 10
+      date.day.should == 1
+      date.year.should == 2009
+    end
+    
+    should "be time if date" do
+      Date.to_mongo(Date.new(2009, 10, 1)).should == Time.utc(2009, 10, 1)
+    end
+    
+    should "be date if time" do
+      Date.to_mongo(Time.parse("2009-10-1T12:30:00")).should == Time.utc(2009, 10, 1)
+    end
+    
+    should "be nil if bogus string" do
+      Date.to_mongo('jdsafop874').should be_nil
+    end
+    
+    should "be nil if empty string" do
+      Date.to_mongo('').should be_nil
+    end
+  end
+  
+  context "Date#from_mongo" do
+    should "be date if date" do
+      date = Date.new(2009, 10, 1)
+      from_date = Date.from_mongo(date)
+      from_date.should == date
+      from_date.month.should == 10
+      from_date.day.should == 1
+      from_date.year.should == 2009
+    end
+    
+    should "be date if time" do
+      time = Time.now
+      Date.from_mongo(time).should == time.to_date
+    end
+    
+    should "be nil if nil" do
+      Date.from_mongo(nil).should be_nil
+    end
+  end
+  
+  context "Float#to_mongo" do
+    should "convert value to_f" do
+      [21, 21.0, '21'].each do |value|
+        Float.to_mongo(value).should == 21.0
+      end
+    end
+  end
+  
+  context "Hash#from_mongo" do
+    should "convert hash to hash with indifferent access" do
+      hash = Hash.from_mongo(:foo => 'bar')
+      hash[:foo].should  == 'bar'
+      hash['foo'].should == 'bar'
+    end
+    
+    should "be hash if nil" do
+      hash = Hash.from_mongo(nil)
+      hash.should == {}
+      hash.is_a?(HashWithIndifferentAccess).should be_true
+    end
+  end
+  
+  context "Hash#to_mongo instance method" do
+    should "have instance method that returns self" do
+      hash = HashWithIndifferentAccess.new('foo' => 'bar')
+      hash.to_mongo.should == {'foo' => 'bar'}
+    end
+  end
+  
+  context "Integer#to_mongo" do
+    should "convert value to integer" do
+      [21, 21.0, '21'].each do |value|
+        Integer.to_mongo(value).should == 21
+      end
+    end
+    
+    should "work fine with big integers" do
+      [9223372036854775807, '9223372036854775807'].each do |value|
+        Integer.to_mongo(value).should == 9223372036854775807
+      end
+    end
+  end
+  
+  context "ObjectId#to_mongo" do
+    should "return nil for nil" do
+      ObjectId.to_mongo(nil).should be_nil
+    end
+    
+    should "return nil if blank string" do
+      ObjectId.to_mongo('').should be_nil
+    end
+    
+    should "return value if object id" do
+      id = Mongo::ObjectID.new
+      ObjectId.to_mongo(id).should be(id)
+    end
+    
+    should "return object id if string" do
+      id = Mongo::ObjectID.new
+      ObjectId.to_mongo(id.to_s).should be(id)
+    end
+  end
+  
+  context "ObjectId#from_mongo" do
+    should "return value" do
+      id = Mongo::ObjectID.new
+      ObjectId.from_mongo(id).should == id
+    end
+  end
+  
+  context "NilClass#to_mongo" do
+    should "return nil" do
+      nil.to_mongo(nil).should be_nil
+    end
+  end
+  
+  context "NilClass#from_mongo" do
+    should "return nil" do
+      nil.from_mongo(nil).should be_nil
+    end
+  end
+  
+  context "Object#to_mongo" do
+    should "return value" do
+      Object.to_mongo(21).should == 21
+      Object.to_mongo('21').should == '21'
+      Object.to_mongo(9223372036854775807).should == 9223372036854775807
+    end
+  end
+  
+  context "Object#from_mongo" do
+    should "return value" do
+      Object.from_mongo(21).should == 21
+      Object.from_mongo('21').should == '21'
+      Object.from_mongo(9223372036854775807).should == 9223372036854775807
+    end
+  end
+  
+  context "Set#to_mongo" do
+    should "convert value to_a" do
+      Set.to_mongo(Set.new([1,2,3])).should == [1,2,3]
+    end
+
+    should "convert to empty array if nil" do
+      Set.to_mongo(nil).should == []
+    end
+  end
+
+  context "Set#from_mongo" do
+    should "be a set if array" do
+      Set.from_mongo([1,2,3]).should == Set.new([1,2,3])
+    end
+
+    should "be empty set if nil" do
+      Set.from_mongo(nil).should == Set.new([])
+    end
+  end
+  
+  context "String#to_mongo" do
+    should "convert value to_s" do
+      [21, '21'].each do |value|
+        String.to_mongo(value).should == '21'
+      end
+    end
+    
+    should "be nil if nil" do
+      String.to_mongo(nil).should be_nil
+    end
+  end
+
+  context "String#from_mongo" do
+    should "be string if value present" do
+      String.from_mongo('Scotch! Scotch! Scotch!').should == 'Scotch! Scotch! Scotch!'
+    end
+    
+    should "return nil if nil" do
+      String.from_mongo(nil).should be_nil
+    end
+    
+    should "return empty string if blank" do
+      String.from_mongo('').should == ''
+    end
+  end
+  
+  context "Time#to_mongo without Time.zone" do
+    should "be time to milliseconds if string" do
+      Time.to_mongo('2000-01-01 01:01:01.123456').should == Time.local(2000, 1, 1, 1, 1, 1, 123000).utc
+    end
+    
+    should "be time in utc if time" do
+      Time.to_mongo(Time.local(2009, 8, 15, 0, 0, 0)).zone.should == 'UTC'
+    end
+    
+    should "be nil if blank string" do
+      Time.to_mongo('').should be_nil
+    end
+    
+    should "not be nil if nil" do
+      Time.to_mongo(nil).should be_nil
+    end
+  end
+  
+  context "Time#to_mongo with Time.zone" do
+    should "be time to milliseconds if time" do
+      Time.zone = 'Hawaii'
+      Time.to_mongo(Time.zone.local(2009, 8, 15, 14, 0, 0, 123456)).should == Time.utc(2009, 8, 16, 0, 0, 0, 123000)
+      Time.zone = nil
+    end
+
+    should "be time to milliseconds if string" do
+      Time.zone = 'Hawaii'
+      Time.to_mongo('2009-08-15 14:00:00.123456').should == Time.utc(2009, 8, 16, 0, 0, 0, 123000)
+      Time.zone = nil
+    end
+    
+    should "be nil if blank string" do
+      Time.zone = 'Hawaii'
+      Time.to_mongo('').should be_nil
+      Time.zone = nil
+    end
+    
+    should "be nil if nil" do
+      Time.zone = 'Hawaii'
+      Time.to_mongo(nil).should be_nil
+      Time.zone = nil
+    end
+  end
+  
+  context "Time#from_mongo without Time.zone" do
+    should "be time" do
+      time = Time.now
+      Time.from_mongo(time).should == time
+    end
+    
+    should "be nil if nil" do
+      Time.from_mongo(nil).should be_nil
+    end
+  end
+  
+  context "Time#from_mongo with Time.zone" do
+    should "be time in Time.zone" do
+      Time.zone = 'Hawaii'
+      
+      time = Time.from_mongo(Time.utc(2009, 10, 1))
+      time.should == Time.zone.local(2009, 9, 30, 14)
+      time.is_a?(ActiveSupport::TimeWithZone).should be_true
+      
+      Time.zone = nil
+    end
+    
+    should "be nil if nil" do
+      Time.zone = 'Hawaii'
+      Time.from_mongo(nil).should be_nil
+      Time.zone = nil
+    end
+  end
+  
+  context "Mongo::ObjectID.to_json" do
+    should "convert object id to string" do
+      id = Mongo::ObjectID.new
+      id.to_json.should == %Q("#{id}")
+    end
+    
+    should "support ruby driver syntax also" do
+      id = Mongo::ObjectID.new
+      id.original_to_json.should == %Q({"$oid": "#{id}"})
+    end
+  end
+end

data/test/unit/test_time_zones.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+class TimeZonesTest < Test::Unit::TestCase
+  context "An instance of an embedded document" do
+    setup do      
+      @document = EDoc do
+        key :name, String
+        key :created_at, Time
+      end
+    end
+    
+    should "work without Time.zone" do
+      Time.zone = nil
+      
+      doc = @document.new(:created_at => "2009-08-15 14:00:00")
+      doc.created_at.should == Time.local(2009, 8, 15, 14, 0, 0).utc
+    end
+    
+    should "work with Time.zone set to the (default) UTC" do
+      Time.zone = 'UTC'
+      
+      doc = @document.new(:created_at => "2009-08-15 14:00:00")
+      doc.created_at.is_a?(ActiveSupport::TimeWithZone).should be_true
+      doc.created_at.should == Time.utc(2009, 8, 15, 14)
+      
+      Time.zone = nil
+    end
+    
+    should "work with timezones that are not UTC" do
+      Time.zone = 'Hawaii'
+      
+      doc = @document.new(:created_at => "2009-08-15 14:00:00")
+      doc.created_at.is_a?(ActiveSupport::TimeWithZone).should be_true
+      doc.created_at.should == Time.utc(2009, 8, 16)
+      
+      Time.zone = nil
+    end
+  end
+end

data/test/unit/test_validations.rb

@@ -0,0 +1,544 @@
+require 'test_helper'
+
+class ValidationsTest < Test::Unit::TestCase
+  context "Validations" do
+    context "on a Document" do
+      setup do
+        @document = Doc()
+      end
+
+      context "Validating acceptance of" do
+        should "work with validates_acceptance_of macro" do
+          @document.key :terms, String
+          @document.validates_acceptance_of :terms
+          doc = @document.new(:terms => '')
+          doc.should have_error_on(:terms)
+          doc.terms = '1'
+          doc.should_not have_error_on(:terms)
+        end
+      end
+
+      context "validating confirmation of" do
+        should "work with validates_confirmation_of macro" do
+          @document.key :password, String
+          @document.validates_confirmation_of :password
+          doc = @document.new
+          doc.password = 'foobar'
+          doc.should have_error_on(:password)
+          doc.password_confirmation = 'foobar'
+          doc.should_not have_error_on(:password)
+        end
+      end
+
+      context "validating format of" do
+        should "work with validates_format_of macro" do
+          @document.key :name, String
+          @document.validates_format_of :name, :with => /.+/
+          doc = @document.new
+          doc.should have_error_on(:name)
+          doc.name = 'John'
+          doc.should_not have_error_on(:name)
+        end
+
+        should "work with :format shorcut key" do
+          @document.key :name, String, :format => /.+/
+          doc = @document.new
+          doc.should have_error_on(:name)
+          doc.name = 'John'
+          doc.should_not have_error_on(:name)
+        end
+      end
+
+      context "validating length of" do
+        should "work with validates_length_of macro" do
+          @document.key :name, String
+          @document.validates_length_of :name, :minimum => 5
+          doc = @document.new
+          doc.should have_error_on(:name)
+        end
+
+        context "with :length => integer shortcut" do
+          should "set maximum of integer provided" do
+            @document.key :name, String, :length => 5
+            doc = @document.new
+            doc.name = '123456'
+            doc.should have_error_on(:name)
+            doc.name = '12345'
+            doc.should_not have_error_on(:name)
+          end
+        end
+
+        context "with :length => range shortcut" do
+          setup do
+            @document.key :name, String, :length => 5..7
+          end
+
+          should "set minimum of range min" do
+            doc = @document.new
+            doc.should have_error_on(:name)
+            doc.name = '123456'
+            doc.should_not have_error_on(:name)
+          end
+
+          should "set maximum of range max" do
+            doc = @document.new
+            doc.should have_error_on(:name)
+            doc.name = '12345678'
+            doc.should have_error_on(:name)
+            doc.name = '123456'
+            doc.should_not have_error_on(:name)
+          end
+        end
+
+        context "with :length => hash shortcut" do
+          should "pass options through" do
+            @document.key :name, String, :length => {:minimum => 2}
+            doc = @document.new
+            doc.should have_error_on(:name)
+            doc.name = '12'
+            doc.should_not have_error_on(:name)
+          end
+        end
+      end # validates_length_of
+
+      context "Validating numericality of" do
+        should "work with validates_numericality_of macro" do
+          @document.key :age, Integer
+          @document.validates_numericality_of :age
+          doc = @document.new
+          doc.age = 'String'
+          doc.should have_error_on(:age)
+          doc.age = 23
+          doc.should_not have_error_on(:age)
+        end
+
+        context "with :numeric shortcut" do
+          should "work with integer or float" do
+            @document.key :weight, Float, :numeric => true
+            doc = @document.new
+            doc.weight = 'String'
+            doc.should have_error_on(:weight)
+            doc.weight = 23.0
+            doc.should_not have_error_on(:weight)
+            doc.weight = 23
+            doc.should_not have_error_on(:weight)
+          end
+        end
+
+        context "with :numeric shortcut on Integer key" do
+          should "only work with integers" do
+            @document.key :age, Integer, :numeric => true
+            doc = @document.new
+            doc.age = 'String'
+            doc.should have_error_on(:age)
+            doc.age = 23.1
+            doc.should have_error_on(:age)
+            doc.age = 23
+            doc.should_not have_error_on(:age)
+          end
+        end
+      end # numericality of
+
+      context "validating presence of" do
+        should "work with validates_presence_of macro" do
+          @document.key :name, String
+          @document.validates_presence_of :name
+          doc = @document.new
+          doc.should have_error_on(:name)
+        end
+
+        should "work with :required shortcut on key definition" do
+          @document.key :name, String, :required => true
+          doc = @document.new
+          doc.should have_error_on(:name)
+        end
+      end
+    
+      context "validating exclusion of" do
+        should "throw error if enumerator not provided" do
+          @document.key :action, String
+          lambda {
+            @document.validates_exclusion_of :action
+          }.should raise_error(ArgumentError)
+        end
+      
+        should "work with validates_exclusion_of macro" do
+          @document.key :action, String
+          @document.validates_exclusion_of :action, :within => %w(kick run)
+        
+          doc = @document.new
+          doc.should_not have_error_on(:action)
+        
+          doc.action = 'fart'
+          doc.should_not have_error_on(:action)
+        
+          doc.action = 'kick'
+          doc.should have_error_on(:action, 'is reserved')
+        end
+
+        should "work with :not_in shortcut on key definition" do
+          @document.key :action, String, :not_in => %w(kick run)
+        
+          doc = @document.new
+          doc.should_not have_error_on(:action)
+        
+          doc.action = 'fart'
+          doc.should_not have_error_on(:action)
+        
+          doc.action = 'kick'
+          doc.should have_error_on(:action, 'is reserved')
+        end
+
+        should "not have error if allow nil is true and value is nil" do
+          @document.key :action, String
+          @document.validates_exclusion_of :action, :within => %w(kick run), :allow_nil => true
+        
+          doc = @document.new
+          doc.should_not have_error_on(:action)
+        end
+
+        should "not have error if allow blank is true and value is blank" do
+          @document.key :action, String
+          @document.validates_exclusion_of :action, :within => %w(kick run), :allow_nil => true
+        
+          doc = @document.new(:action => '')
+          doc.should_not have_error_on(:action)
+        end
+      end
+
+      context "validating inclusion of" do
+        should "throw error if enumerator not provided" do
+          @document.key :action, String
+          lambda {
+            @document.validates_inclusion_of :action
+          }.should raise_error(ArgumentError)
+        end
+      
+        should "work with validates_inclusion_of macro" do
+          @document.key :action, String
+          @document.validates_inclusion_of :action, :within => %w(kick run)
+        
+          doc = @document.new
+          doc.should have_error_on(:action, 'is not in the list')
+        
+          doc.action = 'fart'
+          doc.should have_error_on(:action, 'is not in the list')
+        
+          doc.action = 'kick'
+          doc.should_not have_error_on(:action)
+        end
+
+        should "work with :in shortcut on key definition" do
+          @document.key :action, String, :in => %w(kick run)
+        
+          doc = @document.new
+          doc.should have_error_on(:action, 'is not in the list')
+        
+          doc.action = 'fart'
+          doc.should have_error_on(:action, 'is not in the list')
+        
+          doc.action = 'kick'
+          doc.should_not have_error_on(:action)
+        end
+      
+        should "not have error if allow nil is true and value is nil" do
+          @document.key :action, String
+          @document.validates_inclusion_of :action, :within => %w(kick run), :allow_nil => true
+        
+          doc = @document.new
+          doc.should_not have_error_on(:action)
+        end
+      
+        should "not have error if allow blank is true and value is blank" do
+          @document.key :action, String
+          @document.validates_inclusion_of :action, :within => %w(kick run), :allow_blank => true
+        
+          doc = @document.new(:action => '')
+          doc.should_not have_error_on(:action)
+        end
+      end
+      
+    end # End on a Document
+    
+    context "On an EmbeddedDocument" do
+      setup do
+        @embedded_doc = EDoc()
+      end
+
+      context "Validating acceptance of" do
+        should "work with validates_acceptance_of macro" do
+          @embedded_doc.key :terms, String
+          @embedded_doc.validates_acceptance_of :terms
+          doc = @embedded_doc.new(:terms => '')
+          doc.should have_error_on(:terms)
+          doc.terms = '1'
+          doc.should_not have_error_on(:terms)
+        end
+      end
+
+      context "validating confirmation of" do
+        should "work with validates_confirmation_of macro" do
+          @embedded_doc.key :password, String
+          @embedded_doc.validates_confirmation_of :password
+          doc = @embedded_doc.new
+          doc.password = 'foobar'
+          doc.should have_error_on(:password)
+          doc.password_confirmation = 'foobar'
+          doc.should_not have_error_on(:password)
+        end
+      end
+
+      context "validating format of" do
+        should "work with validates_format_of macro" do
+          @embedded_doc.key :name, String
+          @embedded_doc.validates_format_of :name, :with => /.+/
+          doc = @embedded_doc.new
+          doc.should have_error_on(:name)
+          doc.name = 'John'
+          doc.should_not have_error_on(:name)
+        end
+
+        should "work with :format shorcut key" do
+          @embedded_doc.key :name, String, :format => /.+/
+          doc = @embedded_doc.new
+          doc.should have_error_on(:name)
+          doc.name = 'John'
+          doc.should_not have_error_on(:name)
+        end
+      end
+
+      context "validating length of" do
+        should "work with validates_length_of macro" do
+          @embedded_doc.key :name, String
+          @embedded_doc.validates_length_of :name, :minimum => 5
+          doc = @embedded_doc.new
+          doc.should have_error_on(:name)
+        end
+
+        context "with :length => integer shortcut" do
+          should "set maximum of integer provided" do
+            @embedded_doc.key :name, String, :length => 5
+            doc = @embedded_doc.new
+            doc.name = '123456'
+            doc.should have_error_on(:name)
+            doc.name = '12345'
+            doc.should_not have_error_on(:name)
+          end
+        end
+
+        context "with :length => range shortcut" do
+          setup do
+            @embedded_doc.key :name, String, :length => 5..7
+          end
+
+          should "set minimum of range min" do
+            doc = @embedded_doc.new
+            doc.should have_error_on(:name)
+            doc.name = '123456'
+            doc.should_not have_error_on(:name)
+          end
+
+          should "set maximum of range max" do
+            doc = @embedded_doc.new
+            doc.should have_error_on(:name)
+            doc.name = '12345678'
+            doc.should have_error_on(:name)
+            doc.name = '123456'
+            doc.should_not have_error_on(:name)
+          end
+        end
+
+        context "with :length => hash shortcut" do
+          should "pass options through" do
+            @embedded_doc.key :name, String, :length => {:minimum => 2}
+            doc = @embedded_doc.new
+            doc.should have_error_on(:name)
+            doc.name = '12'
+            doc.should_not have_error_on(:name)
+          end
+        end
+      end # validates_length_of
+
+      context "Validating numericality of" do
+        should "work with validates_numericality_of macro" do
+          @embedded_doc.key :age, Integer
+          @embedded_doc.validates_numericality_of :age
+          doc = @embedded_doc.new
+          doc.age = 'String'
+          doc.should have_error_on(:age)
+          doc.age = 23
+          doc.should_not have_error_on(:age)
+        end
+
+        context "with :numeric shortcut" do
+          should "work with integer or float" do
+            @embedded_doc.key :weight, Float, :numeric => true
+            doc = @embedded_doc.new
+            doc.weight = 'String'
+            doc.should have_error_on(:weight)
+            doc.weight = 23.0
+            doc.should_not have_error_on(:weight)
+            doc.weight = 23
+            doc.should_not have_error_on(:weight)
+          end
+        end
+
+        context "with :numeric shortcut on Integer key" do
+          should "only work with integers" do
+            @embedded_doc.key :age, Integer, :numeric => true
+            doc = @embedded_doc.new
+            doc.age = 'String'
+            doc.should have_error_on(:age)
+            doc.age = 23.1
+            doc.should have_error_on(:age)
+            doc.age = 23
+            doc.should_not have_error_on(:age)
+          end
+        end
+      end # numericality of
+
+      context "validating presence of" do
+        should "work with validates_presence_of macro" do
+          @embedded_doc.key :name, String
+          @embedded_doc.validates_presence_of :name
+          doc = @embedded_doc.new
+          doc.should have_error_on(:name)
+        end
+
+        should "work with :required shortcut on key definition" do
+          @embedded_doc.key :name, String, :required => true
+          doc = @embedded_doc.new
+          doc.should have_error_on(:name)
+        end
+      end
+    
+      context "validating exclusion of" do
+        should "throw error if enumerator not provided" do
+          @embedded_doc.key :action, String
+          lambda {
+            @embedded_doc.validates_exclusion_of :action
+          }.should raise_error(ArgumentError)
+        end
+      
+        should "work with validates_exclusion_of macro" do
+          @embedded_doc.key :action, String
+          @embedded_doc.validates_exclusion_of :action, :within => %w(kick run)
+        
+          doc = @embedded_doc.new
+          doc.should_not have_error_on(:action)
+        
+          doc.action = 'fart'
+          doc.should_not have_error_on(:action)
+        
+          doc.action = 'kick'
+          doc.should have_error_on(:action, 'is reserved')
+        end
+
+        should "work with :not_in shortcut on key definition" do
+          @embedded_doc.key :action, String, :not_in => %w(kick run)
+        
+          doc = @embedded_doc.new
+          doc.should_not have_error_on(:action)
+        
+          doc.action = 'fart'
+          doc.should_not have_error_on(:action)
+        
+          doc.action = 'kick'
+          doc.should have_error_on(:action, 'is reserved')
+        end
+      
+        should "not have error if allow nil is true and value is nil" do
+          @embedded_doc.key :action, String
+          @embedded_doc.validates_exclusion_of :action, :within => %w(kick run), :allow_nil => true
+        
+          doc = @embedded_doc.new
+          doc.should_not have_error_on(:action)
+        end
+
+        should "not have error if allow blank is true and value is blank" do
+          @embedded_doc.key :action, String
+          @embedded_doc.validates_exclusion_of :action, :within => %w(kick run), :allow_nil => true
+        
+          doc = @embedded_doc.new(:action => '')
+          doc.should_not have_error_on(:action)
+        end
+      end
+
+      context "validating inclusion of" do
+        should "throw error if enumerator not provided" do
+          @embedded_doc.key :action, String
+          lambda {
+            @embedded_doc.validates_inclusion_of :action
+          }.should raise_error(ArgumentError)
+        end
+      
+        should "work with validates_inclusion_of macro" do
+          @embedded_doc.key :action, String
+          @embedded_doc.validates_inclusion_of :action, :within => %w(kick run)
+        
+          doc = @embedded_doc.new
+          doc.should have_error_on(:action, 'is not in the list')
+        
+          doc.action = 'fart'
+          doc.should have_error_on(:action, 'is not in the list')
+        
+          doc.action = 'kick'
+          doc.should_not have_error_on(:action)
+        end
+
+        should "work with :in shortcut on key definition" do
+          @embedded_doc.key :action, String, :in => %w(kick run)
+        
+          doc = @embedded_doc.new
+          doc.should have_error_on(:action, 'is not in the list')
+        
+          doc.action = 'fart'
+          doc.should have_error_on(:action, 'is not in the list')
+        
+          doc.action = 'kick'
+          doc.should_not have_error_on(:action)
+        end
+
+        should "not have error if allow nil is true and value is nil" do
+          @embedded_doc.key :action, String
+          @embedded_doc.validates_inclusion_of :action, :within => %w(kick run), :allow_nil => true
+        
+          doc = @embedded_doc.new
+          doc.should_not have_error_on(:action)
+        end
+      
+        should "not have error if allow blank is true and value is blank" do
+          @embedded_doc.key :action, String
+          @embedded_doc.validates_inclusion_of :action, :within => %w(kick run), :allow_blank => true
+        
+          doc = @embedded_doc.new(:action => '')
+          doc.should_not have_error_on(:action)
+        end
+      end
+
+    end # End on an EmbeddedDocument
+      
+  end # Validations
+   
+  context "Adding validation errors" do
+    setup do
+      @document = Doc do
+        key :action, String
+        def action_present
+          errors.add(:action, 'is invalid') if action.blank?
+        end
+      end
+    end
+
+    should "work with validate callback" do
+      @document.validate :action_present
+
+      doc = @document.new
+      doc.action = nil
+      doc.should have_error_on(:action)
+
+      doc.action = 'kick'
+      doc.should_not have_error_on(:action)
+    end
+  end
+end