dm-core 0.9.11 → 0.10.0

data/spec/public/model_spec.rb

@@ -0,0 +1,159 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+# TODO: move these specs into shared specs for #copy
+describe DataMapper::Model do
+  before :all do
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+
+        property :id,      Serial
+        property :title,   String, :nullable => false
+        property :content, Text
+        property :subtitle, String
+        property :author,  String, :nullable => false
+
+        belongs_to :original, self, :nullable => true
+        has n, :revisions, self, :child_key => [ :original_id ]
+        has 1, :previous,  self, :child_key => [ :original_id ], :order => [ :id.desc ]
+      end
+    end
+
+    @article_model = Blog::Article
+  end
+
+  supported_by :all do
+    before :all do
+      @author = 'Dan Kubb'
+
+      @original = @article_model.create(:title => 'Original Article',                                               :author => @author)
+      @article  = @article_model.create(:title => 'Sample Article',   :content => 'Sample', :original => @original, :author => @author)
+      @other    = @article_model.create(:title => 'Other Article',    :content => 'Other',                          :author => @author)
+    end
+
+    it { @article_model.should respond_to(:copy) }
+
+    describe '#copy' do
+      with_alternate_adapter do
+        describe 'between identical models' do
+          before :all do
+            @return = @resources = @article_model.copy(@repository.name, @alternate_adapter.name)
+          end
+
+          it 'should return an Enumerable' do
+            @return.should be_a_kind_of(Enumerable)
+          end
+
+          it 'should return Resources' do
+            @return.each { |resource| resource.should be_a_kind_of(DataMapper::Resource) }
+          end
+
+          it 'should have each Resource set to the expected Repository' do
+            @resources.each { |resource| resource.repository.name.should == @alternate_adapter.name }
+          end
+
+          it 'should create the Resources in the expected Repository' do
+            @article_model.all(:repository => DataMapper.repository(@alternate_adapter.name)).should == @resources
+          end
+        end
+
+        describe 'between different models' do
+          before :all do
+            @other.destroy
+            @article.destroy
+            @original.destroy
+
+            # make sure the default repository is empty
+            @article_model.all(:repository => @repository).should be_empty
+
+            # add an extra property to the alternate model
+            DataMapper.repository(@alternate_adapter.name) do
+              @article_model.property :status, String, :default => 'new'
+            end
+
+            if @article_model.respond_to?(:auto_migrate!)
+              @article_model.auto_migrate!(@alternate_adapter.name)
+            end
+
+            # add new resources to the alternate repository
+            DataMapper.repository(@alternate_adapter.name) do
+              @heff1 = @article_model.create(:title => 'Alternate Repository', :author => @author)
+            end
+
+            # copy from the alternate to the default repository
+            @return = @resources = @article_model.copy(@alternate_adapter.name, :default)
+          end
+
+          it 'should return an Enumerable' do
+            @return.should be_a_kind_of(Enumerable)
+          end
+
+          it 'should return Resources' do
+            @return.each { |resource| resource.should be_a_kind_of(DataMapper::Resource) }
+          end
+
+          it 'should have each Resource set to the expected Repository' do
+            @resources.each { |resource| resource.repository.name.should == :default }
+          end
+
+          it 'should create the Resources in the expected Repository' do
+            @article_model.all.should == @resources
+          end
+        end
+      end
+    end
+  end
+end
+
+describe DataMapper::Model do
+  extend DataMapper::Spec::CollectionHelpers::GroupMethods
+
+  self.loaded = false
+
+  before :all do
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+
+        property :id,      Serial
+        property :title,   String
+        property :content, Text
+        property :subtitle, String
+
+        belongs_to :original, self, :nullable => true
+        has n, :revisions, self, :child_key => [ :original_id ]
+        has 1, :previous,  self, :child_key => [ :original_id ], :order => [ :id.desc ]
+        has n, :publications, :through => Resource
+      end
+
+      class Publication
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :name, String
+
+        has n, :articles, :through => Resource
+      end
+    end
+
+    @article_model     = Blog::Article
+    @publication_model = Blog::Publication
+  end
+
+  supported_by :all do
+    # model cannot be a kicker
+    def should_not_be_a_kicker; end
+
+    def model?; true end
+
+    before :all do
+      @articles = @article_model
+
+      @original = @articles.create(:title => 'Original Article')
+      @article  = @articles.create(:title => 'Sample Article', :content => 'Sample', :original => @original)
+      @other    = @articles.create(:title => 'Other Article',  :content => 'Other')
+    end
+
+    it_should_behave_like 'Finder Interface'
+  end
+end

data/spec/public/property_spec.rb

@@ -0,0 +1,829 @@
+# -*- coding: utf-8 -*-
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe DataMapper::Property do
+
+  # define the model prior to supported_by
+  before :all do
+    class ::Track
+      include DataMapper::Resource
+
+      property :id,               Serial
+      property :artist,           String, :lazy => false, :index => :artist_album
+      property :title,            String, :field => 'name', :index => true
+      property :album,            String, :index => :artist_album
+      property :musicbrainz_hash, String, :unique => true, :unique_index => true
+    end
+
+    class ::Image
+      include DataMapper::Resource
+
+      property :md5hash,      String, :key => true, :length => 32
+      property :title,        String, :nullable => false, :unique => true
+      property :description,  Text,   :length => 1..1024, :lazy => [ :detail ]
+
+      property :format,       String, :default => 'jpeg'
+      # WxH, stored as a dumped Ruby pair
+      property :size,         Object
+      property :filesize,     Float
+      property :width,        Integer
+      property :quality,      BigDecimal
+
+      property :taken_on,     Date
+      property :taken_at,     Time, :default => lambda { |resource, property| Time.now }
+      property :retouched_at, DateTime
+      property :type,         Class
+      property :visible,      Boolean, :default => true
+    end
+  end
+
+  supported_by :all do
+    describe '#field' do
+      it 'returns @field value if it is present' do
+        Track.properties[:title].field.should eql('name')
+      end
+
+      it 'returns field for specific repository when it is present'
+
+      it 'sets field value using field naming convention on first reference'
+    end
+
+    describe '#custom?' do
+      it 'is true for custom type fields (not provided by dm-core)'
+
+      it 'is false for core type fields (provided by dm-core)'
+    end
+
+    describe '#default_for' do
+      it 'returns default value for non-callables' do
+        Image.properties[:format].default_for(Image.new).should == 'jpeg'
+      end
+
+      it 'returns result of a call for callable values' do
+        Image.properties[:taken_at].default_for(Image.new).year.should == Time.now.year
+      end
+    end
+
+    describe '#eql?' do
+      it 'is true for properties with the same model and name' do
+        Track.properties[:title].should eql(Track.properties[:title])
+      end
+
+
+      it 'is false for properties of different models' do
+        Track.properties[:title].should_not eql(Image.properties[:title])
+      end
+
+      it 'is false for properties with different names' do
+        Track.properties[:title].should_not eql(Track.properties[:id])
+      end
+    end
+
+    describe '#get' do
+      before :all do
+        @image = Image.create(:md5hash     => '5268f0f3f452844c79843e820f998869',
+                              :title       => 'Rome at the sunset',
+                              :description => 'Just wow')
+
+        @image.should be_saved
+
+        @image = Image.first(:fields => [ :md5hash, :title ], :md5hash => @image.md5hash)
+      end
+
+      it 'triggers loading for lazy loaded properties' do
+        Image.properties[:description].get(@image)
+        Image.properties[:description].loaded?(@image).should be(true)
+      end
+
+      it 'assigns loaded value to @ivar' do
+        Image.properties[:description].get(@image)
+        @image.instance_variable_get(:@description).should == 'Just wow'
+      end
+
+      it 'sets default value for new records with nil value' do
+        Image.properties[:format].get(@image).should == 'jpeg'
+      end
+
+      it 'returns property value' do
+        Image.properties[:description].get(@image).should == 'Just wow'
+      end
+    end
+
+    describe '#get!' do
+      before :all do
+        @image = Image.new
+
+        # now some dark Ruby magic
+        @image.instance_variable_set(:@description, 'Is set by magic')
+      end
+
+      it 'gets instance variable value from the resource directly' do
+        # if you know a better way to test direct instance variable access,
+        # go ahead and make changes to this example
+        Image.properties[:description].get!(@image).should == 'Is set by magic'
+      end
+    end
+
+    describe '#index' do
+      it 'returns true when property has an index' do
+        Track.properties[:title].index.should be_true
+      end
+
+      it 'returns index name when property has a named index' do
+        Track.properties[:album].index.should eql(:artist_album)
+      end
+
+      it 'returns nil when property has no index' do
+        Track.properties[:musicbrainz_hash].index.should be_nil
+      end
+    end
+
+    describe '#initialize' do
+      describe 'when tracking strategy is explicitly given' do
+        it 'uses tracking strategy from options'
+      end
+
+      describe 'when custom type has tracking stragegy' do
+        it 'uses tracking strategy from type'
+      end
+    end
+
+    describe '#inspect' do
+      before :all do
+        @str = Track.properties[:title].inspect
+      end
+
+      it 'features model name' do
+        @str.should =~ /@model=Track/
+      end
+
+      it 'features property name' do
+        @str.should =~ /@name=:title/
+      end
+    end
+
+    describe '#key?' do
+      describe 'returns true when property is a ' do
+        it 'serial key' do
+          Track.properties[:id].key?.should be_true
+        end
+        it 'natural key' do
+          Image.properties[:md5hash].key?.should be_true
+        end
+      end
+
+      it 'returns true when property is a part of composite key'
+
+      it 'returns false when property does not relate to a key' do
+        Track.properties[:title].key?.should be_false
+      end
+    end
+
+    describe '#lazy?' do
+      it 'returns true when property is lazy loaded' do
+        Image.properties[:description].lazy?.should be_true
+      end
+
+      it 'returns false when property is not lazy loaded' do
+        Track.properties[:artist].lazy?.should be_false
+      end
+    end
+
+    describe '#length' do
+      it 'returns upper bound for Range values' do
+        Image.properties[:description].length.should eql(1024)
+      end
+
+      it 'returns value as is for integer values' do
+        Image.properties[:md5hash].length.should eql(32)
+      end
+    end
+
+    describe '#min' do
+      describe 'when :min and :max options not provided to constructor' do
+        before do
+          @property = Image.property(:integer_with_nil_min, Integer)
+        end
+
+        it 'should be nil' do
+          @property.min.should be_nil
+        end
+      end
+
+      describe 'when :min option not provided to constructor, but :max is provided' do
+        before do
+          @property = Image.property(:integer_with_default_min, Integer, :max => 1)
+        end
+
+        it 'should be the default value' do
+          @property.min.should == 0
+        end
+      end
+
+      describe 'when :min and :max options provided to constructor' do
+        before do
+          @min = 1
+          @property = Image.property(:integer_with_explicit_min, Integer, :min => @min, :max => 2)
+        end
+
+        it 'should be the expected value' do
+          @property.min.should == @min
+        end
+      end
+    end
+
+    describe '#max' do
+      describe 'when :min and :max options not provided to constructor' do
+        before do
+          @property = Image.property(:integer_with_nil_max, Integer)
+        end
+
+        it 'should be nil' do
+          @property.max.should be_nil
+        end
+      end
+
+      describe 'when :max option not provided to constructor, but :min is provided' do
+        before do
+          @property = Image.property(:integer_with_default_max, Integer, :min => 1)
+        end
+
+        it 'should be the default value' do
+          @property.max.should == 2**31-1
+        end
+      end
+
+      describe 'when :min and :max options provided to constructor' do
+        before do
+          @max = 2
+          @property = Image.property(:integer_with_explicit_max, Integer, :min => 1, :max => @max)
+        end
+
+        it 'should be the expected value' do
+          @property.max.should == @max
+        end
+      end
+    end
+
+    describe '#nullable?' do
+      it 'returns true when property can accept nil as its value' do
+        Track.properties[:artist].nullable?.should be_true
+      end
+
+      it 'returns false when property nil value is prohibited for this property' do
+        Image.properties[:title].nullable?.should be_false
+      end
+    end
+
+    describe '#serial?' do
+      it 'returns true when property is serial (auto incrementing)' do
+        Track.properties[:id].serial?.should be_true
+      end
+
+      it 'returns false when property is NOT serial (auto incrementing)' do
+        Image.properties[:md5hash].serial?.should be_false
+      end
+    end
+
+    # What's going on here:
+    #
+    # we first set original value and make an assertion on it
+    # then we try to set it again, which clears original value
+    # (since original value is set, property is no longer dirty)
+    describe '#set_original_value' do
+      before :all do
+        @image = Image.create(:md5hash     => '5268f0f3f452844c79843e820f998869',
+                              :title       => 'Rome at the sunset',
+                              :description => 'Just wow')
+        @image.reload
+        @property = Image.properties[:title]
+      end
+
+      describe 'when value changes' do
+        before :all do
+          @property.set_original_value(@image, 'Rome at the sunset')
+        end
+
+        it 'sets original value of the property' do
+          @image.original_attributes[@property].should == 'Rome at the sunset'
+        end
+      end
+
+      describe 'when value stays the same' do
+        before :all do
+          @property.set_original_value(@image, 'Rome at the sunset')
+        end
+
+        it 'only sets original value when it has changed' do
+          @property.set_original_value(@image, 'Rome at the sunset')
+          @image.original_attributes[@property].should be_blank
+        end
+      end
+    end
+
+    describe '#set' do
+      before :all do
+        # keep in mind we must run these examples with a
+        # saved model instance
+        @image = Image.create(:md5hash     => '5268f0f3f452844c79843e820f998869',
+                              :title       => 'Rome at the sunset',
+                              :description => 'Just wow')
+        @image.reload
+        @property = Image.properties[:title]
+      end
+
+      it 'triggers lazy loading for given resource'
+
+      it 'type casts given value' do
+        # set it to a float
+        @property.set(@image, 1.0)
+        # get a string that has been typecasted
+        @image.title.should == '1.0'
+      end
+
+      it 'stores original value' do
+        @property.set(@image, 'Updated value')
+        @image.original_attributes[@property].should == 'Rome at the sunset'
+      end
+
+      it 'sets new property value' do
+        @property.set(@image, 'Updated value')
+        @image.title.should == 'Updated value'
+      end
+    end
+
+    describe '#set!' do
+      before :all do
+        @image = Image.new(:md5hash      => '5268f0f3f452844c79843e820f998869',
+                           :title       => 'Rome at the sunset',
+                           :description => 'Just wow')
+
+        @property = Image.properties[:title]
+      end
+
+      it 'directly sets instance variable on given resource' do
+        @property.set!(@image, 'Set with dark Ruby magic')
+        @image.title.should == 'Set with dark Ruby magic'
+      end
+    end
+
+    describe '#typecast' do
+      describe "when type is able to do typecasting on it's own" do
+        it 'delegates all the work to the type'
+      end
+
+      describe 'when value is nil' do
+        it 'returns value unchanged' do
+          Image.properties[:size].typecast(nil).should be(nil)
+        end
+      end
+
+      describe 'when value is a Ruby primitive' do
+        it 'returns value unchanged' do
+          Image.properties[:size].typecast([3200, 2400]).should == [3200, 2400]
+        end
+      end
+
+      describe 'when type primitive is a String' do
+        before :all do
+          @property = Image.properties[:title]
+        end
+
+        it 'returns same value if a string' do
+          @value = '1.0'
+          @property.typecast(@value).should equal(@value)
+        end
+
+        it 'returns string representation of the new value' do
+          @property.typecast(1.0).should eql('1.0')
+        end
+      end
+
+      describe 'when type primitive is a Float' do
+        before :all do
+          @property = Image.properties[:filesize]
+        end
+
+        it 'returns same value if a float' do
+          @value = 24.0
+          @property.typecast(@value).should equal(@value)
+        end
+
+        it 'returns float representation of a zero string integer' do
+          @property.typecast('0').should eql(0.0)
+        end
+
+        it 'returns float representation of a positive string integer' do
+          @property.typecast('24').should eql(24.0)
+        end
+
+        it 'returns float representation of a negative string integer' do
+          @property.typecast('-24').should eql(-24.0)
+        end
+
+        it 'returns float representation of a zero string float' do
+          @property.typecast('0.0').should eql(0.0)
+        end
+
+        it 'returns float representation of a positive string float' do
+          @property.typecast('24.35').should eql(24.35)
+        end
+
+        it 'returns float representation of a negative string float' do
+          @property.typecast('-24.35').should eql(-24.35)
+        end
+
+        it 'returns float representation of a zero string float, with no leading digits' do
+          @property.typecast('.0').should eql(0.0)
+        end
+
+        it 'returns float representation of a positive string float, with no leading digits' do
+          @property.typecast('.41').should eql(0.41)
+        end
+
+        it 'returns float representation of a zero integer' do
+          @property.typecast(0).should eql(0.0)
+        end
+
+        it 'returns float representation of a positive integer' do
+          @property.typecast(24).should eql(24.0)
+        end
+
+        it 'returns float representation of a negative integer' do
+          @property.typecast(-24).should eql(-24.0)
+        end
+
+        it 'returns float representation of a zero decimal' do
+          @property.typecast(BigDecimal('0.0')).should eql(0.0)
+        end
+
+        it 'returns float representation of a positive decimal' do
+          @property.typecast(BigDecimal('24.35')).should eql(24.35)
+        end
+
+        it 'returns float representation of a negative decimal' do
+          @property.typecast(BigDecimal('-24.35')).should eql(-24.35)
+        end
+
+        [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |value|
+          it "does not typecast non-numeric value #{value.inspect}" do
+            @property.typecast(value).should equal(value)
+          end
+        end
+      end
+
+      describe 'when type primitive is a Integer' do
+        before :all do
+          @property = Image.properties[:width]
+        end
+
+        it 'returns same value if an integer' do
+          @value = 24
+          @property.typecast(@value).should equal(@value)
+        end
+
+        it 'returns integer representation of a zero string integer' do
+          @property.typecast('0').should eql(0)
+        end
+
+        it 'returns integer representation of a positive string integer' do
+          @property.typecast('24').should eql(24)
+        end
+
+        it 'returns integer representation of a negative string integer' do
+          @property.typecast('-24').should eql(-24)
+        end
+
+        it 'returns integer representation of a zero string float' do
+          @property.typecast('0.0').should eql(0)
+        end
+
+        it 'returns integer representation of a positive string float' do
+          @property.typecast('24.35').should eql(24)
+        end
+
+        it 'returns integer representation of a negative string float' do
+          @property.typecast('-24.35').should eql(-24)
+        end
+
+        it 'returns integer representation of a zero string float, with no leading digits' do
+          @property.typecast('.0').should eql(0)
+        end
+
+        it 'returns integer representation of a positive string float, with no leading digits' do
+          @property.typecast('.41').should eql(0)
+        end
+
+        it 'returns integer representation of a zero float' do
+          @property.typecast(0.0).should eql(0)
+        end
+
+        it 'returns integer representation of a positive float' do
+          @property.typecast(24.35).should eql(24)
+        end
+
+        it 'returns integer representation of a negative float' do
+          @property.typecast(-24.35).should eql(-24)
+        end
+
+        it 'returns integer representation of a zero decimal' do
+          @property.typecast(BigDecimal('0.0')).should eql(0)
+        end
+
+        it 'returns integer representation of a positive decimal' do
+          @property.typecast(BigDecimal('24.35')).should eql(24)
+        end
+
+        it 'returns integer representation of a negative decimal' do
+          @property.typecast(BigDecimal('-24.35')).should eql(-24)
+        end
+
+        [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |value|
+          it "does not typecast non-numeric value #{value.inspect}" do
+            @property.typecast(value).should equal(value)
+          end
+        end
+      end
+
+      describe 'when type primitive is a BigDecimal' do
+        before :all do
+          @property = Image.properties[:quality]
+        end
+
+        it 'returns same value if a decimal' do
+          @value = BigDecimal('24.0')
+          @property.typecast(@value).should equal(@value)
+        end
+
+        it 'returns decimal representation of a zero string integer' do
+          @property.typecast('0').should eql(BigDecimal('0.0'))
+        end
+
+        it 'returns decimal representation of a positive string integer' do
+          @property.typecast('24').should eql(BigDecimal('24.0'))
+        end
+
+        it 'returns decimal representation of a negative string integer' do
+          @property.typecast('-24').should eql(BigDecimal('-24.0'))
+        end
+
+        it 'returns decimal representation of a zero string float' do
+          @property.typecast('0.0').should eql(BigDecimal('0.0'))
+        end
+
+        it 'returns decimal representation of a positive string float' do
+          @property.typecast('24.35').should eql(BigDecimal('24.35'))
+        end
+
+        it 'returns decimal representation of a negative string float' do
+          @property.typecast('-24.35').should eql(BigDecimal('-24.35'))
+        end
+
+        it 'returns decimal representation of a zero string float, with no leading digits' do
+          @property.typecast('.0').should eql(BigDecimal('0.0'))
+        end
+
+        it 'returns decimal representation of a positive string float, with no leading digits' do
+          @property.typecast('.41').should eql(BigDecimal('0.41'))
+        end
+
+        it 'returns decimal representation of a zero integer' do
+          @property.typecast(0).should eql(BigDecimal('0.0'))
+        end
+
+        it 'returns decimal representation of a positive integer' do
+          @property.typecast(24).should eql(BigDecimal('24.0'))
+        end
+
+        it 'returns decimal representation of a negative integer' do
+          @property.typecast(-24).should eql(BigDecimal('-24.0'))
+        end
+
+        it 'returns decimal representation of a zero float' do
+          @property.typecast(0.0).should eql(BigDecimal('0.0'))
+        end
+
+        it 'returns decimal representation of a positive float' do
+          @property.typecast(24.35).should eql(BigDecimal('24.35'))
+        end
+
+        it 'returns decimal representation of a negative float' do
+          @property.typecast(-24.35).should eql(BigDecimal('-24.35'))
+        end
+
+        [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |value|
+          it "does not typecast non-numeric value #{value.inspect}" do
+            @property.typecast(value).should equal(value)
+          end
+        end
+      end
+
+      describe 'when type primitive is a DateTime' do
+        before do
+          @property = Image.properties[:retouched_at]
+        end
+
+        describe 'and value given as a hash with keys like :year, :month, etc' do
+          it 'builds a DateTime instance from hash values' do
+            result = @property.typecast(
+              'year'  => '2006',
+              'month' => '11',
+              'day'   => '23',
+              'hour'  => '12',
+              'min'   => '0',
+              'sec'   => '0'
+            )
+
+            result.should be_kind_of(DateTime)
+            result.year.should eql(2006)
+            result.month.should eql(11)
+            result.day.should eql(23)
+            result.hour.should eql(12)
+            result.min.should eql(0)
+            result.sec.should eql(0)
+          end
+        end
+
+        describe 'and value is a string' do
+          it 'parses the string' do
+            Image.properties[:retouched_at].typecast('Dec, 2006').month.should == 12
+          end
+        end
+
+        it 'does not typecast non-datetime values' do
+          @property.typecast('not-datetime').should eql('not-datetime')
+        end
+      end
+
+      describe 'when type primitive is a Date' do
+        before do
+          @property = Image.properties[:taken_on]
+        end
+
+        describe 'and value given as a hash with keys like :year, :month, etc' do
+          it 'builds a Date instance from hash values' do
+            result = @property.typecast(
+              'year'  => '2007',
+              'month' => '3',
+              'day'   => '25'
+            )
+
+            result.should be_kind_of(Date)
+            result.year.should eql(2007)
+            result.month.should eql(3)
+            result.day.should eql(25)
+          end
+        end
+
+        describe 'and value is a string' do
+          it 'parses the string' do
+            result = @property.typecast('Dec 20th, 2006')
+            result.month.should == 12
+            result.day.should == 20
+            result.year.should == 2006
+          end
+        end
+
+        it 'does not typecast non-date values' do
+          @property.typecast('not-date').should eql('not-date')
+        end
+      end
+
+      describe 'when type primitive is a Time' do
+        before do
+          @property = Image.properties[:taken_at]
+        end
+
+        describe 'and value given as a hash with keys like :year, :month, etc' do
+          it 'builds a Time instance from hash values' do
+            result = @property.typecast(
+              'year'  => '2006',
+              'month' => '11',
+              'day'   => '23',
+              'hour'  => '12',
+              'min'   => '0',
+              'sec'   => '0'
+            )
+
+            result.should be_kind_of(Time)
+            result.year.should  eql(2006)
+            result.month.should eql(11)
+            result.day.should   eql(23)
+            result.hour.should  eql(12)
+            result.min.should   eql(0)
+            result.sec.should   eql(0)
+          end
+        end
+
+        describe 'and value is a string' do
+          it 'parses the string' do
+            result = @property.typecast('22:24')
+            result.hour.should eql(22)
+            result.min.should eql(24)
+          end
+        end
+
+        it 'does not typecast non-time values' do
+          pending 'Time#parse is too permissive' do
+            @property.typecast('not-time').should eql('not-time')
+          end
+        end
+      end
+
+      describe 'when type primitive is a Class' do
+        before do
+          @property = Image.properties[:type]
+        end
+
+        it 'returns same value if a class' do
+          @value = Image
+          @property.typecast(@value).should equal(@value)
+        end
+
+        it 'returns the class if found' do
+          @property.typecast('Image').should eql(Image)
+        end
+
+        it 'does not typecast non-class values' do
+          @property.typecast('NoClass').should eql('NoClass')
+        end
+      end
+
+      describe 'when type primitive is a Boolean' do
+        before do
+          @property = Image.properties[:visible]
+        end
+
+        [ true, 'true', 'TRUE', '1', 1, 't', 'T' ].each do |value|
+          it "returns true when value is #{value.inspect}" do
+            @property.typecast(value).should be_true
+          end
+        end
+
+        [ false, 'false', 'FALSE', '0', 0, 'f', 'F' ].each do |value|
+          it "returns false when value is #{value.inspect}" do
+            @property.typecast(value).should be_false
+          end
+        end
+
+        [ 'string', 2, 1.0, BigDecimal('1.0'), DateTime.now, Time.now, Date.today, Class, Object.new, ].each do |value|
+          it "does not typecast value #{value.inspect}" do
+            @property.typecast(value).should equal(value)
+          end
+        end
+      end
+    end # #typecase
+
+    describe '#unique?' do
+      it 'is true for fields that explicitly given uniq index' do
+        Track.properties[:musicbrainz_hash].unique?.should be_true
+      end
+
+      it 'is true for serial fields' do
+        pending do
+          Track.properties[:title].unique?.should be_true
+        end
+      end
+
+      it 'is true for keys' do
+        Image.properties[:md5hash].unique?.should be_true
+      end
+    end
+
+    describe '#unique_index' do
+      it 'returns true when property has unique index' do
+        Track.properties[:musicbrainz_hash].unique_index.should be_true
+      end
+
+      it 'returns nil when property has no unique index' do
+        Image.properties[:title].unique_index.should be_nil
+      end
+    end
+
+    describe '#valid?' do
+      describe 'when type primitive is a Boolean' do
+        before do
+          @property = Image.properties[:visible]
+        end
+
+        [ true, false ].each do |value|
+          it "returns true when value is #{value.inspect}" do
+            @property.valid?(value).should be_true
+          end
+        end
+
+        [ 'true', 'TRUE', '1', 1, 't', 'T', 'false', 'FALSE', '0', 0, 'f', 'F' ].each do |value|
+          it "returns false for #{value.inspect}" do
+            @property.valid?(value).should be_false
+          end
+        end
+      end
+    end
+
+    describe '#value' do
+      it 'returns value for core types'
+
+      it 'triggers dump operation for custom types'
+    end
+  end
+end # DataMapper::Property