dm-core 0.9.2 → 0.9.3

data/spec/unit/associations/relationship_spec.rb

@@ -1,6 +1,9 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
 
 describe DataMapper::Associations::Relationship do
+
+  load_models_for_metaphor :vehicles
+
   it "should describe an association" do
     belongs_to = DataMapper::Associations::Relationship.new(
       :manufacturer,
@@ -11,50 +14,51 @@ describe DataMapper::Associations::Relationship do
     )
 
     belongs_to.should respond_to(:name)
-    belongs_to.should respond_to(:repository_name)
+    belongs_to.should respond_to(:with_repository)
     belongs_to.should respond_to(:child_key)
     belongs_to.should respond_to(:parent_key)
   end
 
   it "should map properties explicitly when an association method passes them in its options" do
-    repository_name = :mock
-
     belongs_to = DataMapper::Associations::Relationship.new(
       :manufacturer,
-      repository_name,
+      :mock,
       'Vehicle',
       'Manufacturer',
       { :child_key => [ :manufacturer_id ], :parent_key => [ :id ] }
     )
 
     belongs_to.name.should == :manufacturer
-    belongs_to.repository_name.should == repository_name
+    belongs_to.with_repository do |r|
+      r.name.should == :mock
+    end
 
     belongs_to.child_key.should be_a_kind_of(DataMapper::PropertySet)
     belongs_to.parent_key.should be_a_kind_of(DataMapper::PropertySet)
 
-    belongs_to.child_key.to_a.should == Vehicle.properties(repository_name).slice(:manufacturer_id)
-    belongs_to.parent_key.to_a.should == Manufacturer.properties(repository_name).key
+    belongs_to.child_key.to_a.should == Vehicle.properties(:mock).slice(:manufacturer_id)
+    belongs_to.parent_key.to_a.should == Manufacturer.properties(:mock).key
   end
 
   it "should infer properties when options aren't passed" do
-    repository_name = :mock
-
     has_many = DataMapper::Associations::Relationship.new(
       :models,
-      repository_name,
+      :mock,
       'Vehicle',
-      'Manufacturer'
+      'Manufacturer',
+      { :child_key => [:model_id] }
     )
 
     has_many.name.should == :models
-    has_many.repository_name.should == repository_name
+    has_many.with_repository do |r|
+      r.name.should == :mock
+    end
 
     has_many.child_key.should be_a_kind_of(DataMapper::PropertySet)
     has_many.parent_key.should be_a_kind_of(DataMapper::PropertySet)
-
-    has_many.child_key.to_a.should == Vehicle.properties(repository_name).slice(:models_id)
-    has_many.parent_key.to_a.should == Manufacturer.properties(repository_name).key
+    # Vehicle.has n, :models, :class_name => 'Manufacturer', :child_key => "models_id"
+    has_many.child_key.to_a.should == Vehicle.properties(:mock).slice(:model_id)
+    has_many.parent_key.to_a.should == Manufacturer.properties(:mock).key
   end
 
   it "should generate child properties with a safe subset of the parent options" do

data/spec/unit/associations_spec.rb

@@ -1,6 +1,9 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
 describe "DataMapper::Associations" do
+
+  load_models_for_metaphor :vehicles
+
   before do
     @relationship = mock(DataMapper::Associations::Relationship)
     @n = 1.0/0
@@ -8,6 +11,40 @@ describe "DataMapper::Associations" do
     Manufacturer.mock_relationship = Vehicle.mock_relationship = @relationship
   end
 
+  describe "#many_to_one_relationships" do
+    before :all do
+      module MTORelationships
+        class A
+          include DataMapper::Resource
+          def self.default_repository_name
+            :a_db
+          end
+          repository(:b_db) do
+            belongs_to :b
+          end
+          repository(:c_db) do
+            belongs_to :c
+          end
+        end
+        class B
+          include DataMapper::Resource
+          def self.default_repository_name
+            :b_db
+          end
+        end
+        class C
+          include DataMapper::Resource
+          def self.default_repository_name
+            :c_db
+          end
+        end
+      end
+    end
+    it "should list all relationships that are one-to-many" do
+      MTORelationships::A.many_to_one_relationships.sort_by { |r| r.name.to_s }.should == [MTORelationships::A.relationships(:b_db)[:b], MTORelationships::A.relationships(:c_db)[:c]]
+    end
+  end
+
   describe ".relationships" do
     class B
       include DataMapper::Resource

data/spec/unit/collection_spec.rb

@@ -24,6 +24,10 @@ describe DataMapper::Collection do
     @collection.should respond_to(:at)
   end
 
+  it 'should provide #build' do
+    @collection.should respond_to(:build)
+  end
+
   it 'should provide #clear' do
     @collection.should respond_to(:clear)
   end
@@ -72,6 +76,10 @@ describe DataMapper::Collection do
     @collection.should respond_to(:first)
   end
 
+  it 'should provide #freeze' do
+    @collection.should respond_to(:freeze)
+  end
+
   it 'should provide #get' do
     @collection.should respond_to(:get)
   end

data/spec/unit/data_mapper_spec.rb

@@ -1,6 +1,20 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
 describe DataMapper do
+  describe ".dependency_queue" do
+    before(:all) do
+      @q = DataMapper.dependency_queue
+    end
+
+    it "should return a dependency queue" do
+      @q.should be_a_kind_of(DataMapper::DependencyQueue)
+    end
+
+    it "should only create one dependency queue" do
+      @q.should == DataMapper.dependency_queue
+    end
+  end
+
   describe ".prepare" do
     it "should pass the default repository to the block if no argument is given" do
       DataMapper.should_receive(:repository).with(no_args).and_return :default_repo

data/spec/unit/model_spec.rb

@@ -205,11 +205,11 @@ describe 'DataMapper::Model' do
       @standard_resource_inclusions = DataMapper::Resource.instance_variable_get('@extra_inclusions')
       @standard_model_extensions = DataMapper::Model.instance_variable_get('@extra_extensions')
     end
-    
+
     before(:each) do
       DataMapper::Resource.instance_variable_set('@extra_inclusions', [])
       DataMapper::Model.instance_variable_set('@extra_extensions', [])
-      
+
       @module = Module.new do
         def greet
           hi_mom!

data/spec/unit/property_set_spec.rb

@@ -79,18 +79,5 @@ describe DataMapper::PropertySet do
       @properties.instance_variable_get("@property_for").should_not be_empty
       @properties.dup.instance_variable_get("@property_for").should be_empty
     end
-
-    it 'should be able to retarget a new model' do
-      copy = Icon.properties.dup(Boat)
-      copy.should have(4).entries
-
-      copy.each do |property|
-        property.model.should == Boat
-      end
-
-      copy << DataMapper::Property.new(Icon, :z_index, Integer, {})
-      copy.should have(5).entries
-      Icon.properties.should have(4).entries
-    end
   end
 end

data/spec/unit/property_spec.rb

@@ -52,6 +52,25 @@ describe DataMapper::Property do
     end
   end
 
+  it 'should provide #field' do
+    @property.should respond_to(:field)
+  end
+
+  describe '#field' do
+    it 'should accept a custom field' do
+      property = DataMapper::Property.new(Zoo, :location, String, :field => 'City')
+      property.field.should == 'City'
+    end
+
+    it 'should use repository name if passed in' do
+      @property.field(:default).should == 'name'
+    end
+
+    it 'should return default field if no repository name passed in' do
+      @property.field.should == 'name'
+    end
+  end
+
   it 'should provide #get' do
     @property.should respond_to(:get)
   end
@@ -105,7 +124,7 @@ describe DataMapper::Property do
   describe '#set' do
     before do
       @original_values = {}
-      @resource        = mock('resource', :kind_of? => true, :original_values => @original_values)
+      @resource        = mock('resource', :kind_of? => true, :original_values => @original_values, :new_record? => true)
     end
 
     it 'should typecast the value' do
@@ -199,18 +218,56 @@ describe DataMapper::Property do
     property.default_for(resource).should == 'Tomato'
   end
 
-  it "should determine visibility of readers and writers" do
-    name = DataMapper::Property.new(Tomato,:botanical_name,String,{})
-    name.reader_visibility.should == :public
-    name.writer_visibility.should == :public
-
-    seeds = DataMapper::Property.new(Tomato,:seeds,TrueClass,{:accessor=>:private})
-    seeds.reader_visibility.should == :private
-    seeds.writer_visibility.should == :private
+  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
+        property = DataMapper::Property.new(Tomato, :botanical_name, String, input)
+        property.reader_visibility.should == output[0]
+        property.writer_visibility.should == output[1]
+      end
+    end
 
-    family = DataMapper::Property.new(Tomato,:family,String,{:reader => :public, :writer => :private })
-    family.reader_visibility.should == :public
-    family.writer_visibility.should == :private
+    [
+      { :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 {
+          property = DataMapper::Property.new(Tomato, :family, String, input)
+        }.should raise_error(ArgumentError)
+      end
+    end
   end
 
   it "should return an instance variable name" do
@@ -263,8 +320,8 @@ describe DataMapper::Property do
   end
 
   it "should set the field to the correct field_naming_convention" do
-    DataMapper::Property.new(Zoo, :species, String, {}).field.should == 'species'
-    DataMapper::Property.new(Tomato, :genetic_history, DataMapper::Types::Text, {}).field.should == "genetic_history"
+    DataMapper::Property.new(Zoo, :species, String, {}).field(:default).should == 'species'
+    DataMapper::Property.new(Tomato, :genetic_history, DataMapper::Types::Text, {}).field(:default).should == "genetic_history"
   end
 
   it "should provide the primitive mapping" do
@@ -340,6 +397,13 @@ describe DataMapper::Property do
       end
     end
 
+    { '-8' => -8, '-8.0' => -8, -8 => -8, -8.0 => -8, BigDecimal('8.0') => 8 }.each do |value,expected|
+      it "should typecast #{format(value)} to #{format(expected)} for an Integer property" do
+        property = DataMapper::Property.new(Zoo, :integer, Integer)
+        property.typecast(value).should == expected
+      end
+    end
+
     { '0' => 0, '0.0' => 0, 0 => 0, 0.0 => 0, BigDecimal('0.0') => 0 }.each do |value,expected|
       it "should typecast #{format(value)} to #{format(expected)} for an Integer property" do
         property = DataMapper::Property.new(Zoo, :integer, Integer)
@@ -347,6 +411,20 @@ describe DataMapper::Property do
       end
     end
 
+    { '5' => 5, '5.0' => 5, 5 => 5, 5.0 => 5, BigDecimal('5.0') => 5 }.each do |value,expected|
+      it "should typecast #{format(value)} to #{format(expected)} for an Integer property" do
+        property = DataMapper::Property.new(Zoo, :integer, Integer)
+        property.typecast(value).should == expected
+      end
+    end
+
+    { '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
+        property = DataMapper::Property.new(Zoo, :integer, Integer)
+        property.typecast(value).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
         property = DataMapper::Property.new(Zoo, :big_decimal, BigDecimal)
@@ -434,13 +512,6 @@ describe DataMapper::Property do
     DataMapper::Property.new(Zoo, :name, String).should respond_to(:inspect)
   end
 
-  it "should use the Repository of its @model" do
-    p = DataMapper::Property.new(Zoo, :name, String)
-    repo = mock("repository")
-    Zoo.should_receive(:repository).and_return(repo)
-    p.repository.should == repo
-  end
-
   it 'should return an abbreviated representation of the property when inspected' do
     DataMapper::Property.new(Zoo, :name, String).inspect.should == '#<Property:Zoo:name>'
   end

data/spec/unit/query_spec.rb

@@ -17,8 +17,8 @@ BAD_OPTIONS = {
   :reload     => 'true',
   :offset     => -1,
   :limit      => 0,
-  :order      => [],
-  :fields     => [],
+#  :order      => [],  # TODO: spec conditions where :order may be empty
+#  :fields     => [],  # TODO: spec conditions where :fields may be empty
   :links      => [],
   :includes   => [],
   :conditions => [],
@@ -110,7 +110,7 @@ describe DataMapper::Query do
           query.conditions.should == [ [ :eql, Article.properties[:author], 'dkubb' ] ]
         end
 
-        it 'when a Symbol::Operator object is a key' do
+        it 'when a Query::Operator object is a key' do
           query = DataMapper::Query.new(@repository, Article, :author.like => /\Ad(?:an\.)kubb\z/)
           query.conditions.should == [ [ :like, Article.properties[:author], /\Ad(?:an\.)kubb\z/ ] ]
         end
@@ -161,7 +161,7 @@ describe DataMapper::Query do
         end
       end
 
-      it 'when unknown options use something that is not a Symbol::Operator, Symbol or String is a key' do
+      it 'when unknown options use something that is not a Query::Operator, Symbol or String is a key' do
         lambda {
           DataMapper::Query.new(@repository, Article, nil => nil)
         }.should raise_error(ArgumentError)
@@ -483,3 +483,48 @@ describe DataMapper::Query do
     end
   end
 end
+
+describe DataMapper::Query::Operator do
+  before do
+    @operator = :thing.gte
+  end
+
+  it 'should provide #==' do
+    @operator.should respond_to(:==)
+  end
+
+  describe '#==' do
+    describe 'should be equal' do
+      it 'when other is same object' do
+        @operator.should == @operator
+      end
+
+      it 'when other has the same target and operator' do
+        other = :thing.gte
+        @operator.target.should == other.target
+        @operator.operator.should == other.operator
+        @operator.should == other
+      end
+    end
+
+    describe 'should be different' do
+      it 'when other class is not a descendant of self.class' do
+        other = :thing
+        other.class.should_not be_kind_of(@operator.class)
+        @operator.should_not == other
+      end
+
+      it 'when other has a different target' do
+        other = :other.gte
+        @operator.target.should_not == other.target
+        @operator.should_not == other
+      end
+
+      it 'when other has a different operator' do
+        other = :thing.gt
+        @operator.operator.should_not == other.operator
+        @operator.should_not == other
+      end
+    end
+  end
+end

data/spec/unit/resource_spec.rb

@@ -1,5 +1,52 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
+# rSpec completely FUBARs everything if you give it a Module here.
+# So we give it a String of the module name instead.
+# DO NOT CHANGE THIS!
+describe "DataMapper::Resource" do
+
+  load_models_for_metaphor :zoo
+
+  describe '#attributes' do
+    it 'should return a hash of attribute-names and values' do
+      zoo = Zoo.new
+      zoo.name = "San Francisco"
+      zoo.description = "This is a pretty awesome zoo"
+      zoo.attributes.should == {
+        :name => "San Francisco", :description => "This is a pretty awesome zoo",
+        :id => nil, :inception => nil, :open => false, :size => nil
+      }
+    end
+
+    it "should return a hash with all nil values if the instance is new and has no default values" do
+      Species.new.attributes.should == { :id => nil, :name => nil }
+    end
+
+    it 'should not include private attributes' do
+      Species.new.attributes.should == { :id => nil, :name => nil }
+    end
+  end
+
+# ---------- REPOSITORY WRITE METHODS ---------------
+
+  describe '#save' do
+
+    describe 'with a new resource' do
+      it 'should set defaults before create'
+      it 'should create when dirty'
+      it 'should create when non-dirty, and it has a serial key'
+    end
+
+    describe 'with an existing resource' do
+      it 'should update'
+    end
+
+  end
+end
+
+
+# ---------- Old specs... BOOOOOOOOOO ---------------
+
 class Planet
   include DataMapper::Resource
 
@@ -8,7 +55,7 @@ class Planet
   property :id, Integer, :key => true
   property :name, String
   property :age, Integer
-  property :core, String, :private => true
+  property :core, String, :accessor => :private
   property :type, Discriminator
   property :data, Object
 
@@ -25,9 +72,6 @@ class Planet
   end
 end
 
-class Moon
-end
-
 class BlackHole
   include DataMapper::Resource
 
@@ -74,54 +118,16 @@ class Banana < Fruit
   property :type, Discriminator
 end
 
+class Cyclist
+  include DataMapper::Resource
+  property :id,         Integer, :serial => true
+  property :victories,  Integer
+end
+
 # rSpec completely FUBARs everything if you give it a Module here.
 # So we give it a String of the module name instead.
 # DO NOT CHANGE THIS!
 describe "DataMapper::Resource" do
-  it 'should provide #attribute_get' do
-    Planet.new.should respond_to(:attribute_get)
-  end
-
-  describe '#attribute_get' do
-    it 'should delegate to Property#get' do
-      planet = Planet.new
-      Planet.properties[:age].should_receive(:get).with(planet).and_return(1)
-      planet.age.should == 1
-    end
-  end
-
-  it 'should provide #attribute_set' do
-    Planet.new.should respond_to(:attribute_set)
-  end
-
-  describe '#attribute_set' do
-    it 'should typecast the value' do
-      Planet.properties[:age].should_receive(:typecast).with('1').and_return(1)
-      planet = Planet.new
-      planet.age = '1'
-      planet.age.should == 1
-    end
-
-    it 'should delegate to Property#set' do
-      planet = Planet.new
-      Planet.properties[:age].should_receive(:set).with(planet, 1).and_return(1)
-      planet.age = 1
-    end
-  end
-
-  describe '#attributes' do
-    it 'should return a hash of attribute-names and values' do
-      vegetable = Vegetable.new
-      vegetable.attributes.should == {:name => nil, :id => nil}
-      vegetable.name = "carot"
-      vegetable.attributes.should == {:name => "carot", :id => nil}
-    end
-
-    it 'should not include private attributes' do
-      hole = BlackHole.new
-      hole.attributes.should == {:id => nil}
-    end
-  end
 
   it 'should provide #save' do
     Planet.new.should respond_to(:save)
@@ -181,6 +187,46 @@ describe "DataMapper::Resource" do
 
         resource.save.should be_false
       end
+
+      describe 'for integer fields' do
+
+        it "should save strings without digits as nil" do
+          resource = Cyclist.new
+          resource.victories = "none"
+          resource.save.should be_true
+          resource.victories.should be_nil
+        end
+
+        it "should save strings beginning with non-digits as nil" do
+          resource = Cyclist.new
+          resource.victories = "almost 5"
+          resource.save.should be_true
+          resource.victories.should be_nil
+        end
+
+        it 'should save strings beginning with negative numbers as that number' do
+          resource = Cyclist.new
+          resource.victories = "-4 victories"
+          resource.save.should be_true
+          resource.victories.should == -4
+        end
+
+        it 'should save strings beginning with 0 as 0' do
+          resource = Cyclist.new
+          resource.victories = "0 victories"
+          resource.save.should be_true
+          resource.victories.should == 0
+        end
+
+        it 'should save strings beginning with positive numbers as that number' do
+          resource = Cyclist.new
+          resource.victories = "23 victories"
+          resource.save.should be_true
+          resource.victories.should == 23
+        end
+
+      end
+
     end
 
     describe 'with an existing resource' do
@@ -245,7 +291,7 @@ describe "DataMapper::Resource" do
   end
 
   it "should return an instance of the created object" do
-    Planet.create!(:name => 'Venus', :age => 1_000_000, :core => nil, :id => 42).should be_a_kind_of(Planet)
+    Planet.create(:name => 'Venus', :age => 1_000_000, :id => 42).should be_a_kind_of(Planet)
   end
 
   it 'should provide persistance methods' do
@@ -256,31 +302,47 @@ describe "DataMapper::Resource" do
   end
 
   it "should have attributes" do
-    attributes = { :name => 'Jupiter', :age => 1_000_000, :core => nil, :id => 42, :type => Planet, :data => nil }
+    attributes = { :name => 'Jupiter', :age => 1_000_000, :id => 42, :type => Planet, :data => nil }
     jupiter = Planet.new(attributes)
     jupiter.attributes.should == attributes
   end
 
   it "should be able to set attributes" do
-    attributes = { :name => 'Jupiter', :age => 1_000_000, :core => nil, :id => 42, :type => Planet, :data => nil }
+    attributes = { :name => 'Jupiter', :age => 1_000_000, :id => 42, :type => Planet, :data => nil }
     jupiter = Planet.new(attributes)
     jupiter.attributes.should == attributes
-    jupiter.attributes = attributes.merge(:core => 'Magma')
+
+    new_attributes = attributes.merge( :age => 2_500_000 )
+    jupiter.attributes = new_attributes
+    jupiter.attributes.should == new_attributes
+  end
+
+  it "should be able to set attributes using update_attributes" do
+    attributes = { :name => 'Jupiter', :age => 1_000_000, :id => 42, :type => Planet, :data => nil }
+    jupiter = Planet.new(attributes)
     jupiter.attributes.should == attributes
 
-    jupiter.update_attributes({ :core => "Toast", :type => "Bob" }, :core).should be_true
-    jupiter.core.should == "Toast"
-    jupiter.type.should_not == "Bob"
+    new_age = { :age => 3_700_000 }
+    jupiter.update_attributes(new_age).should be_true
+    jupiter.age.should == 3_700_000
+    jupiter.attributes.should == attributes.merge(new_age)
+  end
+
+  # :core is a private accessor so Ruby should raise NameError
+  it "should not be able to set private attributes" do
+    lambda {
+      jupiter = Planet.new({ :core => "Molten Metal" })
+    }.should raise_error(NameError)
   end
 
-  it "should not mark attributes dirty if there similar after update" do
-    jupiter = Planet.new(:name => 'Jupiter', :age => 1_000_000, :core => nil, :id => 42, :data => { :a => "Yeah!" })
+  it "should not mark attributes dirty if they are similar after update" do
+    jupiter = Planet.new(:name => 'Jupiter', :age => 1_000_000, :id => 42, :data => { :a => "Yeah!" })
     jupiter.save.should be_true
 
     # discriminator will be set automatically
     jupiter.type.should == Planet
 
-    jupiter.attributes = { :name => 'Jupiter', :age => 1_000_000, :core => nil, :data => { :a => "Yeah!" } }
+    jupiter.attributes = { :name => 'Jupiter', :age => 1_000_000, :data => { :a => "Yeah!" } }
 
     jupiter.attribute_dirty?(:name).should be_false
     jupiter.attribute_dirty?(:age).should be_false
@@ -291,7 +353,7 @@ describe "DataMapper::Resource" do
   end
 
   it "should not mark attributes dirty if they are similar after typecasting" do
-    jupiter = Planet.new(:name => 'Jupiter', :age => 1_000_000, :core => nil, :id => 42, :type => nil)
+    jupiter = Planet.new(:name => 'Jupiter', :age => 1_000_000, :id => 42, :type => nil)
     jupiter.save.should be_true
     jupiter.dirty?.should be_false
 
@@ -378,7 +440,7 @@ describe "DataMapper::Resource" do
 
   it 'should store and retrieve default values' do
     Planet.property(:satellite_count, Integer, :default => 0)
-    # stupid example but it's realiable and works
+    # stupid example but it's reliable and works
     Planet.property(:orbit_period, Float, :default => lambda { |r,p| p.name.to_s.length })
     earth = Planet.new(:name => 'Earth')
     earth.satellite_count.should == 0