datamapper 0.2.5 → 0.3.0

data/spec/postgres_spec.rb

@@ -5,24 +5,66 @@ require File.dirname(__FILE__) + "/spec_helper"
 if ENV['ADAPTER'] == 'postgresql'
 
   describe DataMapper::Adapters::PostgresqlAdapter::Mappings::Column do
+    before(:all) do
+      @mappings = DataMapper::Adapters::PostgresqlAdapter::Mappings
+      @table    = @mappings::Table.new(database(:mock).adapter, "Zebu")      
+    end
+    
     it "should be able to set check-constraints on columns" do
-      mappings = DataMapper::Adapters::PostgresqlAdapter::Mappings
-      table    = mappings::Table.new(database(:mock).adapter, "Zebu")
-      column   = mappings::Column.new(database(:mock).adapter, table, :age,
+      column   = @mappings::Column.new(database(:mock).adapter, @table, :age,
                    :integer, 1, { :check => "age > 18"})
       column.to_long_form.should match(/CHECK \(age > 18\)/)
     end
+    
+    it "should not set varchar length if none is specified" do
+      column   = @mappings::Column.new(database(:mock).adapter, @table,
+                   :varchar_len_test, :string, 1, { })
+      column.size.should == nil
+      column.to_long_form.should match(/.varchar_len_test. varchar/)
+    end
+    
+    it "should set varchar length when it is specified" do
+      column   = @mappings::Column.new(database(:mock).adapter, @table,
+                   :varchar_len_test, :string, 1, { :length => 100 })
+      column.size.should == 100
+      column.to_long_form.should match(/.varchar_len_test. varchar\(100\)/)
+    end
+    
+    it "should accept :size as alternative to :length" do
+      column   = @mappings::Column.new(database(:mock).adapter, @table,
+                   :varchar_len_test, :string, 1, { :size => 100 })
+      column.size.should == 100
+      column.to_long_form.should match(/.varchar_len_test. varchar\(100\)/)
+    end
+    
+    it "should have size of nil when length of integer is specified" do
+      column   = @mappings::Column.new(database(:mock).adapter, @table,
+                   :integer_len_test, :integer, 1, { :length => 1 })
+      column.size.should == nil
+      column.to_long_form.should match(/.integer_len_test./)
+    end
+    
+    it "should have size of nil when length of integer is not specified, overriding the default" do
+      column   = @mappings::Column.new(database(:mock).adapter, @table,
+                   :integer_len_test, :integer, 1)
+      column.size.should == nil
+      column.to_long_form.should match(/.integer_len_test./)
+    end
   end
 
   describe DataMapper::Adapters::PostgresqlAdapter::Mappings::Table do
     
     before(:all) do
-      class Cage < DataMapper::Base
+      class Cage #< DataMapper::Base # please do not remove this
+        include DataMapper::Base
+
         set_table_name "cages"
         property :name, :string
       end
   
-      class CageInSchema < DataMapper::Base
+      class CageInSchema #< DataMapper::Base # please do not remove this
+        include DataMapper::Base
+
         set_table_name "my_schema.cages"
         property :name, :string
       end
@@ -51,4 +93,4 @@ if ENV['ADAPTER'] == 'postgresql'
     
   end
 
-end
+end

data/spec/property_spec.rb

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
 describe DataMapper::Property do
   
   before(:all) do
@@ -5,22 +7,102 @@ describe DataMapper::Property do
   end
   
   it "should map a column" do
-    pending('until Property is implemented')
     @property.column.should eql(database.table(Zoo)[:notes])
   end
   
   it "should determine lazyness" do
-    pending('until Property is implemented')
     @property.should be_lazy
   end
   
-  it "should determine protection level"
+  it "should determine protection level" do
+    @property.reader_visibility.should == :public
+    @property.writer_visibility.should == :public
+  end
+  
+  it "should return instance variable name" do
+    @property.instance_variable_name.should == database.table(Zoo)[:notes].instance_variable_name
+  end
+  
+  it "should add a validates_presence_of for not-null properties" do
+    class NullableZoo #< DataMapper::Base # please do not remove this
+      include DataMapper::Persistence
+
+      property :name, :string, :nullable => false, :default => "Zoo"
+    end
+    zoo = NullableZoo.new
+    zoo.valid?.should == false
+    zoo.name = "Content"
+    zoo.valid?.should == true
+  end
   
-  it "should return instance variable name"
+  it "should add a validates_length_of for maximum size" do
+    class SizableZoo #< DataMapper::Base # please do not remove this
+      include DataMapper::Persistence
+      property :name, :string, :length => 50
+    end
+    zoo = SizableZoo.new(:name => "San Diego" * 100)
+    zoo.valid?.should == false
+    zoo.name = "San Diego"
+    zoo.valid?.should == true
+  end
   
-  it "should add a validates_presence_of for not-null properties"
+  it "should add a validates_length_of for a range" do
+    class RangableZoo #< DataMapper::Base # please do not remove this
+      include DataMapper::Persistence
+      property :name, :string, :length => 2..255
+    end
+    zoo = RangableZoo.new(:name => "A")
+    zoo.valid?.should == false
+    zoo.name = "Zoo"
+    zoo.valid?.should == true
+  end
   
-  it "should add a validates_format_of if you pass a format option"
+  it "should add a validates_format_of if you pass a format option" do
+    class FormatableUser
+      include DataMapper::Persistence
+      property :email, :string, :format => :email_address
+    end
+    user = FormatableUser.new(:email => "incomplete_email")
+    user.valid?.should == false
+    user.email = "complete_email@anonymous.com"
+    user.valid?.should == true
+  end
+  
+  it "should not add a validates_presence_of for not-null properties if auto valdations are disabled" do
+    class NullableZoo #< DataMapper::Base # please do not remove this
+      include DataMapper::Persistence
+      property :name, :string, :nullable => false, :default => "Zoo", :auto_validation => false
+    end
+    zoo = NullableZoo.new
+    zoo.errors.empty?.should == true
+  end
+  
+  it "should not add a validates_length_of if auto validations are disabled" do
+    class SizableZoo #< DataMapper::Base # please do not remove this
+      include DataMapper::Persistence
+      property :name, :string, :length => 50, :auto_validation => false
+    end
+    zoo = SizableZoo.new(:name => "San Diego" * 100)
+    zoo.errors.empty?.should == true
+  end
+  
+  it "should not add a validates_format_of if you pass a format option if auto validations are disabled" do
+    class FormatableUser
+      include DataMapper::Persistence
+      property :email, :string, :format => :email_address, :auto_validation => false
+    end
+    user = FormatableUser.new(:email => "incomplete_email")
+    user.errors.empty?.should == true
+  end
+  
+  it "should raise ArgumentError for unsupported types" do
+    lambda {
+      class PersistentFailure #< DataMapper::Base # please do not remove this
+        include DataMapper::Persistence
+        property :created_at, :timestamp
+      end
+    }.should raise_error(ArgumentError)
+  end
 end
 
 describe DataMapper::Adapters::Sql::Mappings do
@@ -44,8 +126,7 @@ describe DataMapper::Adapters::Sql::Mappings do
   end
   
   it "should have two different sets of mapped properties that point to subsets of the Table columns" do
-    pending('until Property is implemented')
-    
+    # pending("This one still needs some love to pass.")
     table = database.table(Person)
     
     # Every property's column should be represented in the Table's column mappings.
@@ -55,7 +136,7 @@ describe DataMapper::Adapters::Sql::Mappings do
     
     # For both models in the STI setup...
     SalesPerson.properties.each do |property|
-      table.columns.should include(property.column)
+      database.table(SalesPerson).columns.should include(property.column)
     end
     
     # Even though Person's properties are fewer than a SalesPerson's

data/spec/query_spec.rb

@@ -1,11 +1,77 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe('A query') do
+# * you have some crazy finder options... ie: Zoo, :name => 'bob', :include => :exhibits
+# 
+# * you want to turn this into SQL.
+# 
+# * you want to execute this SQL...
+# 
+# * you want to load objects from the results, which means you have to know what columns in the results map to what objects
+# 
+# * some values in the results will have no corresponding objects, theyll be indicators of other behaviour that should take place
+#   ie: the values for a m:n join table will tell you how to bind the associated objects together, or...
+#     the :type column will tell you what type to instantiate    
+#
+#
+# So... the Query class should basically take the options from step 1, give you the SQL in step 2,
+# allow you to handle step 3, and expose types/result-set mappings to load objects by for step 4.
+# step 5 should be handled in the DataObjectAdapter
+describe DataMapper::Query do
   
-  it 'should return a simple Array of primitives' do
-    database.query("SELECT name FROM zoos").all? do |entry|
-      entry.kind_of?(String)
-    end.should == true
+  it "should generate the correct queries for the given options" do
+    query = DataMapper::Query.new(database(:mock).adapter, Zoo, :name => 'bob')
+    query.to_sql.should == "SELECT `id`, `name`, `updated_at` FROM `zoos` WHERE (`name` = ?)"
+    query.parameters.should == ['bob']
+    
+    query = DataMapper::Query.new(database(:mock).adapter, Animal, :name => 'bob')
+    query.to_sql.should == "SELECT `id`, `name`, `nice` FROM `animals` WHERE (`name` = ?)"
+    query.parameters.should == ['bob']
+    
+    query = DataMapper::Query.new(database(:mock).adapter, Project)
+    query.to_sql.should == "SELECT `id`, `title`, `description`, `deleted_at` FROM `projects` WHERE (`deleted_at` IS NULL OR `deleted_at` > NOW())"
+    query.parameters.should be_empty
+  end
+  
+  it "should use the include option for lazily-loaded columns" do
+    query = DataMapper::Query.new(database(:mock).adapter, Zoo, :include => :notes)
+    query.to_sql.should == "SELECT `id`, `name`, `notes`, `updated_at` FROM `zoos`"
+    query.parameters.should be_empty
+  end
+  
+  it "should generate the correct join query" do
+    query = DataMapper::Query.new(database(:mock).adapter, Zoo, :include => [:exhibits])
+    query.to_sql.should == <<-EOS.compress_lines
+      SELECT `zoos`.`id`, `zoos`.`name`, `zoos`.`updated_at`, `exhibits`.`id`, `exhibits`.`name`, `exhibits`.`zoo_id`
+      FROM `zoos`
+      JOIN `exhibits` ON `exhibits`.`zoo_id` = `zoos`.`id`
+    EOS
+    
+    query = DataMapper::Query.new(database(:mock).adapter, Zoo, :include => [:exhibits], :name => ['bob', 'sam'])
+    query.to_sql.should == <<-EOS.compress_lines
+      SELECT `zoos`.`id`, `zoos`.`name`, `zoos`.`updated_at`, `exhibits`.`id`, `exhibits`.`name`, `exhibits`.`zoo_id`
+      FROM `zoos`
+      JOIN `exhibits` ON `exhibits`.`zoo_id` = `zoos`.`id`
+      WHERE (`zoos`.`name` IN ?)
+    EOS
+    query.parameters.should == [['bob', 'sam']]
+  end
+  
+  it "should be forgiving with options that require Arrays" do
+    
+    query = DataMapper::Query.new(database(:mock).adapter, Zoo, :conditions => ["`name` = ?", 'bob'])
+    query.to_sql.should == "SELECT `id`, `name`, `updated_at` FROM `zoos` WHERE (`name` = ?)"
+    query.parameters.should == ['bob']
+    
+    query = DataMapper::Query.new(database(:mock).adapter, Zoo, :conditions => "`name` = 'bob'")
+    query.to_sql.should == "SELECT `id`, `name`, `updated_at` FROM `zoos` WHERE (`name` = 'bob')"
+    query.parameters.should be_empty
+    
+    query = DataMapper::Query.new(database(:mock).adapter, Zoo, :include => :exhibits)
+    query.to_sql.should == <<-EOS.compress_lines
+      SELECT `zoos`.`id`, `zoos`.`name`, `zoos`.`updated_at`, `exhibits`.`id`, `exhibits`.`name`, `exhibits`.`zoo_id`
+      FROM `zoos`
+      JOIN `exhibits` ON `exhibits`.`zoo_id` = `zoos`.`id`
+    EOS
   end
   
 end

data/spec/save_command_spec.rb

@@ -36,6 +36,11 @@ describe "Save Commands" do
     end
   end
   
+  it "should return success of save call, not status of query execution" do
+    # pending "http://wm.lighthouseapp.com/projects/4819/tickets/54-save-should-return-success"
+    Exhibit.first.save.should be_true
+  end
+  
   it "should be invalid if invalid associations are loaded" do
     miami = Zoo.first(:name => 'Miami')
     fish_fancy = Exhibit.new
@@ -80,4 +85,10 @@ describe "Save Commands" do
     end
   end
   
+  it "save! should raise an error if validation failed" do
+    # pending "http://wm.lighthouseapp.com/projects/4819/tickets/29-dm-context-write"
+    empty = Zoo.new
+    lambda { empty.save! }.should raise_error(DataMapper::ValidationError)
+  end
+  
 end

data/spec/spec_helper.rb

@@ -11,11 +11,11 @@ def fixtures(name)
   rescue
     nil
   end
-  
-  unless klass.nil?  
+
+  unless klass.nil?
     database.logger.debug { "AUTOMIGRATE: #{klass}" }
     klass.auto_migrate!
-  
+
     (entry.kind_of?(Array) ? entry : [entry]).each do |hash|
       if hash['type']
         Object::const_get(hash['type'])::create(hash)
@@ -24,19 +24,22 @@ def fixtures(name)
       end
     end
   else
-    # TODO: Get rid of the stupid AnimalsExhibit model...
     table = database.table(name.to_s)
     table.create! true
-    
-    pp database.schema
-    
-    (entry.kind_of?(Array) ? entry : [entry]).each do |hash|  
+    table.activate_associations!
+
+    #pp database.schema
+
+    (entry.kind_of?(Array) ? entry : [entry]).each do |hash|
       table.insert(hash)
     end
   end
 end
 
-# Pre-fill the database so non-destructive tests don't need to reload fixtures.
-Dir[File.dirname(__FILE__) + "/fixtures/*.yaml"].each do |path|
-  fixtures(File::basename(path).sub(/\.yaml$/, ''))
+def load_database
+  Dir[File.dirname(__FILE__) + "/fixtures/*.yaml"].each do |path|
+    fixtures(File::basename(path).sub(/\.yaml$/, ''))
+  end
 end
+
+load_database

data/spec/support/blank_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe DataMapper::Support do
+  it "should mark empty objects as blank" do
+    [ nil, false, '', '   ', "  \n\t  \r ", [], {} ].each { |f| f.should be_blank }
+    [ Object.new, true, 0, 1, 'a', [nil], { nil => 0 } ].each { |t| t.should_not be_blank }
+  end
+end

data/spec/support/inflector_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Inflector do
+  it "should camelize strings" do
+    Inflector.camelize("data_mapper").should == "DataMapper"
+    Inflector.camelize("data_mapper/support").should == "DataMapper::Support"
+  end
+  
+  it "should pluralize strings" do
+    Inflector.pluralize("post").should == "posts"
+    Inflector.pluralize("octopus").should == "octopi"
+    Inflector.pluralize("sheep").should == "sheep"
+    Inflector.pluralize("word").should == "words"
+    Inflector.pluralize("the blue mailman").should == "the blue mailmen"
+    Inflector.pluralize("CamelOctopus").should == "CamelOctopi"
+  end
+  
+  it "should singularize strings" do
+    Inflector.singularize("posts").should == "post"
+    Inflector.singularize("octopi").should == "octopus"
+    Inflector.singularize("sheep").should == "sheep"
+    Inflector.singularize("word").should == "word"
+    Inflector.singularize("the blue mailmen").should == "the blue mailman"
+    Inflector.singularize("CamelOctopi").should == "CamelOctopus"
+  end
+  
+  it "should demodulize strings" do
+    Inflector.demodulize("DataMapper::Support").should == "Support"
+  end
+  
+  it "should create foreign keys from class names and key names" do
+    Inflector.foreign_key("Animal").should == "animal_id"
+    Inflector.foreign_key("Admin::Post").should == "post_id"
+    Inflector.foreign_key("Animal", "name").should == "animal_name"
+  end
+  
+  it "should constantize strings" do
+    Inflector.constantize("Class").should == Class
+    lambda { Inflector.constantize("asdf") }.should raise_error
+  end
+end

data/spec/support/object_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe DataMapper::Support::Object do
+  
+  it "should be able to get a recursive constant" do
+    Object.recursive_const_get('DataMapper::Support::String').should == DataMapper::Support::String
+  end
+  
+end

data/spec/{serialization_spec.rb → support/serialization_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + "/spec_helper"
+require File.dirname(__FILE__) + "/../spec_helper"
 
 describe DataMapper::Support::Serialization do
   

data/spec/support/silence_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe "Kernel#silence_warnings" do
+  
+  it "should not warn" do
+    $VERBOSE.should_not be_nil
+    
+    silence_warnings do
+      $VERBOSE.should be_nil
+    end
+    
+    $VERBOSE.should_not be_nil
+  end
+  
+end