sam-dm-core 0.9.6

data/spec/unit/naming_conventions_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe "DataMapper::NamingConventions" do
+  describe "Resource" do
+    it "should coerce a string into the Underscored convention" do
+      DataMapper::NamingConventions::Resource::Underscored.call('User').should == 'user'
+      DataMapper::NamingConventions::Resource::Underscored.call('UserAccountSetting').should == 'user_account_setting'
+    end
+
+    it "should coerce a string into the UnderscoredAndPluralized convention" do
+      DataMapper::NamingConventions::Resource::UnderscoredAndPluralized.call('User').should == 'users'
+      DataMapper::NamingConventions::Resource::UnderscoredAndPluralized.call('UserAccountSetting').should == 'user_account_settings'
+    end
+
+    it "should coerce a string into the UnderscoredAndPluralized convention joining namespace with underscore" do
+      DataMapper::NamingConventions::Resource::UnderscoredAndPluralized.call('Model::User').should == 'model_users'
+      DataMapper::NamingConventions::Resource::UnderscoredAndPluralized.call('Model::UserAccountSetting').should == 'model_user_account_settings'
+    end
+
+    it "should coerce a string into the  UnderscoredAndPluralizedWithoutModule convention" do
+      DataMapper::NamingConventions::Resource::UnderscoredAndPluralizedWithoutModule.call('Model::User').should == 'users'
+      DataMapper::NamingConventions::Resource::UnderscoredAndPluralizedWithoutModule.call('Model::UserAccountSetting').should == 'user_account_settings'
+    end
+
+    it "should coerce a string into the Yaml convention" do
+      DataMapper::NamingConventions::Resource::Yaml.call('UserSetting').should == 'user_settings.yaml'
+      DataMapper::NamingConventions::Resource::Yaml.call('User').should == 'users.yaml'
+    end
+  end
+
+  describe "Field" do
+    it "should accept a property as input" do
+      DataMapper::NamingConventions::Field::Underscored.call(Article.blog_id).should == 'blog_id'
+    end
+  end
+end

data/spec/unit/property_set_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+class Icon
+      include DataMapper::Resource
+
+      property :id, Serial
+      property :name, String
+      property :width, Integer, :lazy => true
+      property :height, Integer, :lazy => true
+end
+
+class Boat
+      include DataMapper::Resource
+      property :name, String  #not lazy
+      property :text, DataMapper::Types::Text    #Lazy by default
+      property :notes, String, :lazy => true
+      property :a1, String, :lazy => [:ctx_a,:ctx_c]
+      property :a2, String, :lazy => [:ctx_a,:ctx_b]
+      property :a3, String, :lazy => [:ctx_a]
+      property :b1, String, :lazy => [:ctx_b]
+      property :b2, String, :lazy => [:ctx_b]
+      property :b3, String, :lazy => [:ctx_b]
+end
+
+describe DataMapper::PropertySet do
+  before :each do
+    @properties = Icon.properties(:default)
+  end
+
+  it "#slice should find properties" do
+    @properties.slice(:name, 'width').should have(2).entries
+  end
+
+  it "#select should find properties" do
+    @properties.select { |property| property.primitive == Integer }.should have(3).entries
+  end
+
+  it "#[] should find properties by name (Symbol or String)" do
+    default_properties = [ :id, 'name', :width, 'height' ]
+    @properties.each_with_index do |property,i|
+      property.should == @properties[default_properties[i]]
+    end
+  end
+
+  it "should provide defaults" do
+    @properties.defaults.should have(2).entries
+    @properties.should have(4).entries
+  end
+
+  it 'should add a property for lazy loading  to the :default context if a context is not supplied' do
+    Boat.properties(:default).lazy_context(:default).length.should == 2 # text & notes
+  end
+
+  it 'should return a list of contexts that a given field is in' do
+    props = Boat.properties(:default)
+    set = props.property_contexts(:a1)
+    set.include?(:ctx_a).should == true
+    set.include?(:ctx_c).should == true
+    set.include?(:ctx_b).should == false
+  end
+
+  it 'should return a list of expanded fields that should be loaded with a given field' do
+    props =  Boat.properties(:default)
+    set = props.lazy_load_context(:a2)
+    expect = [:a1,:a2,:a3,:b1,:b2,:b3]
+    expect.should == set.sort! {|a,b| a.to_s <=> b.to_s}
+  end
+
+  describe 'when dup\'ed' do
+    it 'should duplicate the @entries ivar' do
+      @properties.dup.entries.should_not equal(@properties.entries)
+    end
+
+    it 'should reinitialize @properties_for' do
+      # force @properties_for to hold a property
+      Icon.properties(:default)[:name].should_not be_nil
+      @properties = Icon.properties(:default)
+
+      @properties.instance_variable_get("@property_for").should_not be_empty
+      @properties.dup.instance_variable_get("@property_for").should be_empty
+    end
+  end
+end

data/spec/unit/property_spec.rb

@@ -0,0 +1,753 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe DataMapper::Property do
+  before :each do
+    Object.send(:remove_const, :Zoo) if defined?(Zoo)
+    class Zoo
+      include DataMapper::Resource
+
+      property :id, DataMapper::Types::Serial
+    end
+
+    Object.send(:remove_const, :Name) if defined?(Name)
+    class Name < DataMapper::Type
+      primitive String
+      track :hash
+
+      def self.load(value, property)
+        value.split(", ").reverse
+      end
+
+      def self.dump(value, property)
+        value && value.reverse.join(", ")
+      end
+
+      def self.typecast(value, property)
+        value
+      end
+    end
+
+    Object.send(:remove_const, :Tomato) if defined?(Tomato)
+    class Tomato
+      include DataMapper::Resource
+    end
+  end
+
+  describe '.new' do
+    [ Float, BigDecimal ].each do |primitive|
+      describe "with a #{primitive} primitive" do
+        it 'should raise an ArgumentError if precision is 0' do
+          lambda {
+            Zoo.class_eval <<-RUBY
+              property :test, #{primitive}, :precision => 0
+            RUBY
+          }.should raise_error(ArgumentError)
+        end
+
+        it "raises an ArgumentError if precision is less than 0" do
+          lambda {
+            Zoo.class_eval <<-RUBY
+              property :test, #{primitive}, :precision => -1
+            RUBY
+          }.should raise_error(ArgumentError)
+        end
+
+        it 'should raise an ArgumentError if scale is less than 0' do
+          lambda {
+            Zoo.class_eval <<-RUBY
+              property :test, #{primitive}, :scale => -1
+            RUBY
+          }.should raise_error(ArgumentError)
+        end
+
+        it 'should raise an ArgumentError if precision is less than scale' do
+          lambda {
+            Zoo.class_eval <<-RUBY
+              property :test, #{primitive}, :precision => 1, :scale => 2
+            RUBY
+          }.should raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  describe '#field' do
+    before(:each) do
+      Zoo.class_eval do
+        property :location, String, :field => "City"
+
+        repository(:mock) do
+          property :location, String, :field => "MockCity"
+        end
+      end
+    end
+
+    it 'should accept a custom field' do
+      Zoo.properties[:location].field.should == 'City'
+    end
+
+    # How is this supposed to work?
+    it 'should use repository name if passed in' do
+      pending
+      Zoo.properties[:location].field(:mock).should == 'MockCity'
+    end
+  end
+
+  describe '#get' do
+    before do
+      Zoo.class_eval do
+        property :name, String, :default => "San Diego"
+        property :address, String
+      end
+      @resource        = Zoo.new
+    end
+
+    describe 'when setting the default on initial access' do
+      it 'should set the ivar to the default' do
+        @resource.name.should == 'San Diego'
+      end
+
+      it 'should set the original value to nil' do
+        @resource.original_values[:name].should == nil
+      end
+    end
+
+    it "should not reload the default if you set the property to nil" do
+      @resource.name = nil
+      @resource.name.should == nil
+    end
+  end
+
+  describe '#get, when tracking via :hash' do
+    before do
+      Zoo.class_eval do
+        property :name, String, :lazy => true, :track => :hash
+      end
+      Zoo.auto_migrate!
+      @resource = Zoo.create(:name => "San Diego")
+    end
+
+    describe 'when setting the default on initial access' do
+      it 'should set the ivar to the default' do
+        @resource.name.should == "San Diego"
+      end
+
+      it 'should set the original value to nil' do
+        @resource.name
+        @resource.original_values[:name].should == "San Diego".hash
+      end
+
+      it "should know it's dirty if a change was made to the object" do
+        @resource.name.upcase!
+        @resource.should be_dirty
+      end
+    end
+  end
+
+  describe '#get, when tracking via :get' do
+    before do
+      Zoo.class_eval do
+        property :name, String
+      end
+      Zoo.auto_migrate!
+      @resource = Zoo.create(:name => "San Diego")
+    end
+
+    describe 'when setting the default on initial access' do
+      it 'should set the ivar to the default' do
+        @resource.name.should == "San Diego"
+      end
+
+      it 'should set the original value to "San Diego"' do
+        @resource.name
+        @resource.original_values[:name].should == "San Diego"
+      end
+    end
+
+    it "should know it's dirty if a change was made to the object" do
+      @resource.name.upcase!
+      @resource.name
+      @resource.should be_dirty
+      @resource.original_values[:name].should == "San Diego"
+    end
+  end
+
+  describe 'with Proc defaults' do
+    it "calls the proc" do
+      Zoo.class_eval do
+        property :name, String, :default => proc {|r,p| "San Diego"}
+        property :address, String
+      end
+
+      Zoo.new.name.should == "San Diego"
+    end
+
+    it "provides the resource to the proc" do
+      Zoo.class_eval do
+        property :name, String, :default => proc {|r,p| r.address}
+        property :address, String
+      end
+
+      zoo = Zoo.new
+      zoo.address = "San Diego"
+      zoo.name.should == "San Diego"
+    end
+
+    it "provides the property to the proc" do
+      Zoo.class_eval do
+        property :name, String, :default => proc {|r,p| p.name.to_s}
+      end
+
+      zoo = Zoo.new
+      zoo.name.should == "name"
+    end
+  end
+
+
+  describe '#get!' do
+    it 'should get the resource' do
+      Zoo.class_eval do
+        property :name, String
+      end
+
+      resource = Zoo.new(:name => "Portland Zoo")
+      resource.name.should == "Portland Zoo"
+    end
+  end
+
+  describe '#set' do
+    before(:each) do
+      Zoo.class_eval do
+        property :name, String
+        property :age, Integer
+        property :description, String, :lazy => true
+      end
+      Zoo.auto_migrate!
+      Zoo.create(:name => "San Diego Zoo", :age => 888,
+        :description => "Great Zoo")
+      @resource = Zoo.new
+    end
+
+    it 'should typecast the value' do
+      @resource.age = "888"
+      @resource.age.should == 888
+    end
+
+    it "should lazy load itself first" do
+      resource = Zoo.first
+      resource.description = "Still a Great Zoo"
+      resource.original_values[:description].should == "Great Zoo"
+    end
+
+    it "should only set original_values once" do
+      resource = Zoo.first
+      resource.description = "Still a Great Zoo"
+      resource.description = "What can I say. This is one great Zoo"
+      resource.original_values[:description].should == "Great Zoo"
+    end
+  end
+
+  describe '#set!' do
+    before do
+      Zoo.class_eval do
+        property :name, String
+        property :age, Integer
+      end
+    end
+
+    it 'should set the resource' do
+      resource = Zoo.new
+      resource.name = "Seattle Zoo"
+      resource.name.should == "Seattle Zoo"
+    end
+  end
+
+  # What is this for?
+  # ---
+  # it "should evaluate two similar properties as equal" do
+  #   p1 = DataMapper::Property.new(Zoo, :name, String, { :size => 30 })
+  #   p2 = DataMapper::Property.new(Zoo, :name, String, { :size => 30 })
+  #   p3 = DataMapper::Property.new(Zoo, :title, String, { :size => 30 })
+  #   p1.eql?(p2).should == true
+  #   p1.hash.should == p2.hash
+  #   p1.eql?(p3).should == false
+  #   p1.hash.should_not == p3.hash
+  # end
+
+  it "should create a String property" do
+    Zoo.class_eval do
+      property :name, String, :size => 30
+    end
+
+    resource = Zoo.new
+    resource.name = 100
+    resource.name.should == "100"
+  end
+
+  it "should not have key that is lazy" do
+    Zoo.class_eval do
+      property :id, DataMapper::Types::Text, :key => true
+      property :name, String, :lazy => true
+    end
+    Zoo.auto_migrate!
+
+    Zoo.create(:id => "100", :name => "San Diego Zoo")
+    zoo = Zoo.first
+
+    # Do we mean for attribute_loaded? to be public?
+    zoo.attribute_loaded?(:id).should == true
+  end
+
+  it "should lazily load other non-loaded, non-lazy fields" do
+    # This somewhat contorted setup is to successfully test that
+    # the list of eager properties to be loaded when it's initially
+    # missing is, in fact, repository-scoped
+    Zoo.class_eval do
+      property :id, DataMapper::Types::Serial
+      property :name, String, :lazy => true
+      property :address, String, :lazy => true
+
+      repository(:default2) do
+        property :name, String
+        property :address, String
+      end
+    end
+
+    repository(:default2) do
+      Zoo.auto_migrate!
+      Zoo.create(:name => "San Diego Zoo", :address => "San Diego")
+    end
+    repository(:default2) do
+      zoo = Zoo.first(:fields => [:id])
+
+      zoo.attribute_loaded?(:name).should == false
+      zoo.attribute_loaded?(:address).should == false
+      zoo.name
+      zoo.attribute_loaded?(:name).should == true
+      zoo.attribute_loaded?(:address).should == true
+    end
+  end
+
+  it "should use a custom type Name property" do
+    Zoo.class_eval do
+      property :name, Name
+    end
+
+    Zoo.auto_migrate!
+
+    zoo = Zoo.create(:name => %w(Zoo San\ Diego))
+    Zoo.first.name.should == %w(Zoo San\ Diego)
+  end
+
+  it "should override type options with property options" do
+    Zoo.class_eval do
+      property :name, Name, :track => :get
+    end
+
+    Zoo.auto_migrate!
+
+    Zoo.create(:name => %w(Awesome Person\ Dude))
+    zoo = Zoo.first
+    zoo.name = %w(Awesome Person\ Dude)
+
+    # If we were tracking by hash, this would cause zoo to be dirty,
+    # as its hash would not match the original. Since we've overridden
+    # and are tracking by :get, it won't be dirty
+    zoo.name.stub!(:hash).and_return(1)
+    zoo.should_not be_dirty
+  end
+
+  describe "public details" do
+    before do
+      Zoo.class_eval do
+        property :botanical_name, String, :nullable => true, :lazy => true
+        property :colloquial_name, DataMapper::Types::Text, :default => "Tomato"
+      end
+      Zoo.auto_migrate!
+    end
+
+    it "should determine nullness" do
+      Zoo.properties[:botanical_name].options[:nullable].should be_true
+    end
+
+    it "should determine its name"  do
+      Zoo.properties[:botanical_name].name.should == :botanical_name
+    end
+
+    # lazy? is not exposed to or used by the adapters, so it should be tested indirectly
+    it "should determine laziness" do
+      Zoo.create(:botanical_name => "Calystegia sepium")
+      Zoo.first.attribute_loaded?(:botanical_name).should be_false
+    end
+
+    it "should automatically set laziness to true on text fields" do
+      Zoo.create(:colloquial_name => "American hedge bindweed")
+      Zoo.first.attribute_loaded?(:colloquial_name).should be_false
+    end
+
+    it "should determine whether it is a key" do
+      zoo = Zoo.create(:botanical_name => "Calystegia sepium")
+      id = zoo.id
+      Zoo.first.id.should == id
+    end
+
+    it "should determine whether it is serial" do
+      zoo = Zoo.create(:botanical_name => "Calystegia sepium")
+      zoo.id.should_not be_nil
+    end
+
+    it "should determine a default value" do
+      zoo = Zoo.new
+      zoo.colloquial_name.should == "Tomato"
+    end
+  end
+
+  describe "reader and writer visibility" do
+    # parameter passed to Property.new                    # reader | writer visibility
+    {
+      {}                                                 => [:public,    :public],
+      { :accessor => :public }                           => [:public,    :public],
+      { :accessor => :protected }                        => [:protected, :protected],
+      { :accessor => :private }                          => [:private,   :private],
+      { :reader => :public }                             => [:public,    :public],
+      { :reader => :protected }                          => [:protected, :public],
+      { :reader => :private }                            => [:private,   :public],
+      { :writer => :public }                             => [:public,    :public],
+      { :writer => :protected }                          => [:public,    :protected],
+      { :writer => :private }                            => [:public,    :private],
+      { :reader => :public, :writer => :public }         => [:public,    :public],
+      { :reader => :public, :writer => :protected }      => [:public,    :protected],
+      { :reader => :public, :writer => :private }        => [:public,    :private],
+      { :reader => :protected, :writer => :public }      => [:protected, :public],
+      { :reader => :protected, :writer => :protected }   => [:protected, :protected],
+      { :reader => :protected, :writer => :private }     => [:protected, :private],
+      { :reader => :private, :writer => :public }        => [:private,   :public],
+      { :reader => :private, :writer => :protected }     => [:private,   :protected],
+      { :reader => :private, :writer => :private }       => [:private,   :private],
+    }.each do |input, output|
+      it "#{input.inspect} should make reader #{output[0]} and writer #{output[1]}" do
+        Tomato.class_eval <<-RUBY
+          property :botanical_name, String, #{input.inspect}
+        RUBY
+        Tomato.send("#{output[0]}_instance_methods").should include("botanical_name")
+        Tomato.send("#{output[1]}_instance_methods").should include("botanical_name=")
+      end
+    end
+
+    [
+      { :accessor => :junk },
+      { :reader   => :junk },
+      {                          :writer => :junk },
+      { :reader   => :public,    :writer => :junk },
+      { :reader   => :protected, :writer => :junk },
+      { :reader   => :private,   :writer => :junk },
+      { :reader   => :junk,      :writer => :public },
+      { :reader   => :junk,      :writer => :protected },
+      { :reader   => :junk,      :writer => :private },
+      { :reader   => :junk,      :writer => :junk },
+      { :reader   => :junk,      :writer => :junk },
+      { :reader   => :junk,      :writer => :junk },
+    ].each do |input|
+      it "#{input.inspect} should raise ArgumentError" do
+        lambda {
+          Tomato.class_eval <<-RUBY
+            property :family, String, #{input.inspect}
+          RUBY
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  # This is handled by get!
+  # ---
+  # it "should return an instance variable name" do
+  #  DataMapper::Property.new(Tomato, :flavor, String, {}).instance_variable_name.should == '@flavor'
+  #  DataMapper::Property.new(Tomato, :ripe, TrueClass, {}).instance_variable_name.should == '@ripe' #not @ripe?
+  # end
+
+  it "should append ? to TrueClass property reader methods" do
+    class Potato
+      include DataMapper::Resource
+      property :id, Integer, :key => true
+      property :fresh, TrueClass
+      property :public, TrueClass
+    end
+
+    Potato.new(:fresh => true).should be_fresh
+  end
+
+  it "should move unknown options into Property#extra_options" do
+    Tomato.class_eval do
+      property :botanical_name, String, :foo => :bar
+    end
+    Tomato.properties[:botanical_name].extra_options.should == {:foo => :bar}
+  end
+
+  it 'should provide #custom?' do
+    Zoo.class_eval do
+      property :name, Name, :size => 50
+      property :state, String, :size => 2
+    end
+    Zoo.properties[:name].should be_custom
+    Zoo.properties[:state].should_not be_custom
+  end
+
+  it "should set the field to the correct field_naming_convention" do
+    Zoo.class_eval { property :species, String }
+    Tomato.class_eval { property :genetic_history, DataMapper::Types::Text }
+
+    Zoo.properties[:species].field.should == "species"
+    Tomato.properties[:genetic_history].field.should == "genetic_history"
+  end
+
+  it "should provide the primitive mapping" do
+    Zoo.class_eval do
+      property :poverty, String
+      property :fortune, DataMapper::Types::Text
+    end
+
+    Zoo.properties[:poverty].primitive.should == String
+    Zoo.properties[:fortune].primitive.should == String
+  end
+
+  it "should make it possible to define an integer size" do
+    Zoo.class_eval { property :cleanliness, String, :size => 100 }
+    Zoo.properties[:cleanliness].size.should == 100
+  end
+
+  it "should make it possible to define an integer length (which defines size)" do
+    Zoo.class_eval { property :cleanliness, String, :length => 100 }
+    Zoo.properties[:cleanliness].size.should == 100
+  end
+
+  it "should make it possible to define a range size" do
+    Zoo.class_eval { property :cleanliness, String, :size => 0..100 }
+    Zoo.properties[:cleanliness].size.should == 100
+  end
+
+  it "should make it possible to define a range length (which defines size)" do
+    Zoo.class_eval { property :cleanliness, String, :length => 0..100 }
+    Zoo.properties[:cleanliness].size.should == 100
+  end
+
+  describe '#typecast' do
+    def self.format(value)
+      case value
+        when BigDecimal             then "BigDecimal(#{value.to_s('F').inspect})"
+        when Float, Integer, String then "#{value.class}(#{value.inspect})"
+        else value.inspect
+      end
+    end
+
+    it 'should pass through the value if it is the same type when typecasting' do
+      Zoo.class_eval do
+        property :name, String
+      end
+      zoo = Zoo.new
+      value = "San Diego"
+      def value.to_s() "San Francisco" end
+      zoo.name = value
+      zoo.name.should == "San Diego"
+    end
+
+    it 'should pass through the value nil when typecasting' do
+      Zoo.class_eval do
+        property :name, String
+      end
+
+      zoo = Zoo.new
+      zoo.name = nil
+      zoo.name.should == nil
+    end
+
+    it 'should pass through the value for an Object property' do
+      value = Object.new
+      Zoo.class_eval do
+        property :object, Object
+      end
+
+      zoo = Zoo.new
+      zoo.object = value
+      zoo.object.object_id.should == value.object_id
+    end
+
+    [ true, 'true', 'TRUE', 1, '1', 't', 'T' ].each do |value|
+      it "should typecast #{value.inspect} to true for a TrueClass property" do
+        Zoo.class_eval do
+          property :boolean, TrueClass
+        end
+
+        zoo = Zoo.new
+        zoo.boolean = value
+        zoo.boolean.should == true
+      end
+    end
+
+    [ false, 'false', 'FALSE', 0, '0', 'f', 'F' ].each do |value|
+      it "should typecast #{value.inspect} to false for a Boolean property" do
+        Zoo.class_eval do
+          property :boolean, TrueClass
+        end
+
+        zoo = Zoo.new
+        zoo.boolean = value
+        zoo.boolean.should == false
+      end
+    end
+
+    it 'should typecast nil to nil for a Boolean property' do
+      Zoo.class_eval do
+        property :boolean, TrueClass
+      end
+
+      zoo = Zoo.new
+      zoo.boolean = nil
+      zoo.boolean.should == nil
+    end
+
+    it 'should typecast "0" to "0" for a String property' do
+      Zoo.class_eval do
+        property :string, String
+      end
+
+      zoo = Zoo.new
+      zoo.string = "0"
+      zoo.string.should == "0"
+    end
+
+    { '0' => 0.0, '0.0' => 0.0, 0 => 0.0, 0.0 => 0.0, BigDecimal('0.0') => 0.0 }.each do |value,expected|
+      it "should typecast #{format(value)} to #{format(expected)} for a Float property" do
+        Zoo.class_eval do
+          property :float, Float
+        end
+
+        zoo = Zoo.new
+        zoo.float = value
+        zoo.float.should == expected
+      end
+    end
+
+    { '-8' => -8, '-8.0' => -8, -8 => -8, -8.0 => -8, BigDecimal('8.0') => 8,
+      '0' => 0, '0.0' => 0, 0 => 0, 0.0 => 0, BigDecimal('0.0') => 0,
+      '5' => 5, '5.0' => 5, 5 => 5, 5.0 => 5, BigDecimal('5.0') => 5,
+      'none' => nil, 'almost 5' => nil, '-3 change' => -3, '9 items' => 9}.each do |value,expected|
+      it "should typecast #{format(value)} to #{format(expected)} for an Integer property" do
+        Zoo.class_eval do
+          property :int, Integer
+        end
+
+        zoo = Zoo.new
+        zoo.int = value
+        zoo.int.should == expected
+      end
+    end
+
+    { '0' => BigDecimal('0'), '0.0' => BigDecimal('0.0'), 0.0 => BigDecimal('0.0'), BigDecimal('0.0') => BigDecimal('0.0') }.each do |value,expected|
+      it "should typecast #{format(value)} to #{format(expected)} for a BigDecimal property" do
+        Zoo.class_eval do
+          property :big_decimal, BigDecimal
+        end
+
+        zoo = Zoo.new
+        zoo.big_decimal = value
+        zoo.big_decimal.should == expected
+      end
+    end
+
+    it 'should typecast value for a DateTime property' do
+      Zoo.class_eval { property :date_time, DateTime }
+      zoo = Zoo.new
+      zoo.date_time = '2000-01-01 00:00:00'
+      zoo.date_time.should == DateTime.new(2000, 1, 1, 0, 0, 0)
+    end
+
+    it 'should typecast value for a Date property' do
+      Zoo.class_eval { property :date, Date }
+      zoo = Zoo.new
+      zoo.date = '2000-01-01'
+      zoo.date.should == Date.new(2000, 1, 1)
+    end
+
+    it 'should typecast value for a Time property' do
+      Zoo.class_eval { property :time, Time }
+      zoo = Zoo.new
+      zoo.time = '2000-01-01 01:01:01.123456'
+      zoo.time.should == Time.local(2000, 1, 1, 1, 1, 1, 123456)
+    end
+
+    it 'should typecast Hash for a Time property' do
+      Zoo.class_eval { property :time, Time }
+      zoo = Zoo.new
+      zoo.time = {:year => 2002, "month" => 1, :day => 1, "hour" => 12, :min => 0, :sec => 0}
+      zoo.time.should == Time.local(2002, 1, 1, 12, 0, 0)
+    end
+
+    it 'should typecast Hash for a Date property' do
+      Zoo.class_eval { property :date, Date }
+      zoo = Zoo.new
+      zoo.date = {:year => 2002, "month" => 1, :day => 1}
+      zoo.date.should == Date.new(2002, 1, 1)
+    end
+
+    it 'should typecast Hash for a DateTime property' do
+      Zoo.class_eval { property :date_time, DateTime }
+      zoo = Zoo.new
+      zoo.date_time = {:year => 2002, :month => 1, :day => 1, "hour" => 12, :min => 0, "sec" => 0}
+      zoo.date_time.should == DateTime.new(2002, 1, 1, 12, 0, 0)
+    end
+
+    it 'should use now as defaults for missing parts of a Hash to Time typecast' do
+      now = Time.now
+      Zoo.class_eval { property :time, Time }
+      zoo = Zoo.new
+      zoo.time = {:month => 1, :day => 1}
+      zoo.time.should == Time.local(now.year, 1, 1, now.hour, now.min, now.sec)
+    end
+
+    it 'should use now as defaults for missing parts of a Hash to Date typecast' do
+      now = Time.now
+      Zoo.class_eval { property :date, Date }
+      zoo = Zoo.new
+      zoo.date = {:month => 1, :day => 1}
+      zoo.date.should == Date.new(now.year, 1, 1)
+    end
+
+    it 'should use now as defaults for missing parts of a Hash to DateTime typecast' do
+      now = Time.now
+      Zoo.class_eval { property :date_time, DateTime }
+      zoo = Zoo.new
+      zoo.date_time = {:month => 1, :day => 1}
+      zoo.date_time.should == DateTime.new(now.year, 1, 1, now.hour, now.min, now.sec)
+    end
+
+    it 'should rescue after trying to typecast an invalid Date value from a hash' do
+      now = Time.now
+      Zoo.class_eval { property :date, Date }
+      zoo = Zoo.new
+      zoo.date = {:year => 2002, :month => 2, :day => 31}
+      zoo.date.should == Date.new(2002, 3, 3)
+    end
+
+    it 'should rescue after trying to typecast an invalid DateTime value from a hash' do
+      now = Time.now
+      Zoo.class_eval { property :date_time, DateTime }
+      zoo = Zoo.new
+      zoo.date_time = {
+        :year => 2002, :month => 2, :day => 31, :hour => 12, :min => 0, :sec => 0
+      }
+      zoo.date_time.should == DateTime.new(2002, 3, 3, 12, 0, 0)
+    end
+
+    it 'should typecast value for a Class property' do
+      Zoo.class_eval { property :klass, Class }
+      zoo = Zoo.new
+      zoo.klass = "Zoo"
+      zoo.klass.should == Zoo
+    end
+  end
+
+  it 'should return an abbreviated representation of the property when inspected' do
+    Zoo.class_eval { property :name, String }
+    Zoo.properties[:name].inspect.should == '#<Property:Zoo:name>'
+  end
+end