datamapper 0.3.2 → 0.9.3

data/spec/postgres_spec.rb

@@ -1,96 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-# Only run these specs when the ADAPTER env-variable is set to 'postgresql'
-# You will probably need to set the DATABASE and USERNAME vars as well.
-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
-      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 # please do not remove this
-        include DataMapper::Base
-
-        set_table_name "cages"
-        property :name, :string
-      end
-  
-      class CageInSchema #< DataMapper::Base # please do not remove this
-        include DataMapper::Base
-
-        set_table_name "my_schema.cages"
-        property :name, :string
-      end
-    end
-    
-    it "should return a quoted table name for a simple table" do
-      table_sql = database.adapter.table(Cage).to_sql
-      table_sql.should == "\"cages\""
-    end
-  
-    it "should return a quoted schema and table name for a table which specifies a schema" do
-      table_sql = database.adapter.table(CageInSchema).to_sql
-      table_sql.should == "\"my_schema\".\"cages\""
-    end
-
-    it "should search only the specified schema if qualified" do
-      database.save(Cage)
-      database.adapter.table(CageInSchema).exists?.should == false
-      database.save(CageInSchema)
-      database.adapter.table(CageInSchema).exists?.should == true
-    end
-    
-    after do
-      database.adapter.execute("DROP SCHEMA my_schema CASCADE") rescue nil
-    end
-    
-  end
-
-end

data/spec/property_spec.rb

@@ -1,151 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe DataMapper::Property do
-  
-  before(:all) do
-    @property = Zoo.properties.find { |property| property.name == :notes }
-  end
-  
-  it "should map a column" do
-    @property.column.should eql(database.table(Zoo)[:notes])
-  end
-  
-  it "should determine lazyness" do
-    @property.should be_lazy
-  end
-  
-  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 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_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" 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
-  
-  it "should return the same Table instance for two objects mapped to the same database table" do
-    # Refers to the same Table instance
-    database.table(Person) == database.table(SalesPerson)
-  end
-  
-  it "should have one super-set of total mapped columns" do
-    # Refers to the mapped columns
-    database.table(Person).columns == database.table(SalesPerson).columns
-  end
-  
-  it "should have one set of columns that represents the actual database" do
-    # Refers to the actual columns in the database, which may/are-likely-to-be different
-    # than the mapped columns, sometimes just because your models are dealing with
-    # a legacy database where not every column is mapped to the new model, so this
-    # is expected.
-    database.table(Person).send(:database_columns) == database.table(SalesPerson).send(:database_columns)
-  end
-  
-  it "should have two different sets of mapped properties that point to subsets of the Table columns" do
-    # 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.
-    Person.properties.each do |property|
-      table.columns.should include(property.column)
-    end
-    
-    # For both models in the STI setup...
-    SalesPerson.properties.each do |property|
-      database.table(SalesPerson).columns.should include(property.column)
-    end
-    
-    # Even though Person's properties are fewer than a SalesPerson's
-    Person.properties.size.should_not eql(SalesPerson.properties.size)
-    
-    # And Person's properties should be a subset of a SalesPerson's
-    Person.properties.each do |property|
-      SalesPerson.properties.map(&:column).should include(property.column)
-    end
-  end
-  
-end

data/spec/query_spec.rb

@@ -1,77 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-# * 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 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

@@ -1,94 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe "Save Commands" do
-  
-  before(:all) do
-    fixtures(:zoos)
-  end
-  
-  it "should create a new row" do
-    total = Zoo.all.length
-    Zoo.create({ :name => 'bob' })
-    zoo = Zoo.first(:name => 'bob')
-    zoo.name.should == 'bob'
-    Zoo.all.length.should == total+1
-  end
-  
-  it "should update an existing row" do
-    dallas = Zoo.first(:name => 'Dallas')
-    dallas.name = 'bob'
-    dallas.save
-    dallas.name = 'Dallas'
-    dallas.save
-  end
-  
-  it "should be able to read other attributes after a record is created" do
-    zoo = Zoo.create({ :name => 'bob' })
-    zoo.notes.should == nil
-  end
-  
-  it "should stamp association on save" do
-    database do
-      dallas = Zoo.first(:name => 'Dallas')
-      dallas.exhibits << Exhibit.new(:name => 'Flying Monkeys')
-      dallas.save
-      Exhibit.first(:name => 'Flying Monkeys').zoo.should == dallas
-    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
-    miami.exhibits << fish_fancy
-    miami.should_not be_valid
-    fish_fancy.name = 'Fish Fancy'
-    fish_fancy.should be_valid
-    miami.should be_valid
-  end
-  
-  it "should retrieve it's id on creation if the key is auto-incrementing so it can be successively updated" do
-    database do # Use the same Session so the reference-equality checks will pass.
-      mary = Animal::create(:name => 'Mary')
-      mary.name = 'Jane'
-      # Without retrieving the id during creation, the following #save call would fail,
-      # because we wouldn't know what id to update.
-      mary.save.should == true
-      jane = Animal.first(:name => 'Jane')
-      mary.should == jane
-    end
-  end
-  
-  it "should not be dirty if there are no attributes to update" do
-    bob = Animal.new
-    bob.should_not be_dirty
-    bob.name = 'bob'
-    bob.dirty_attributes.should == { :name => 'bob' }
-    bob.should be_dirty
-  end
-  
-  it "should not persist invalid objects" do
-    zoo = Zoo.create(:notes => "I'm invalid!")
-    zoo.should_not be_valid
-    zoo.should be_new_record
-  end
-  
-  it "should create a Project with a \"Main\" Section" do
-    database do
-      project = Project::create(:title => 'Test')
-      project.sections.first.should == Section.first
-      project.sections.first.should be_a_kind_of(Section)
-    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/schema_spec.rb

@@ -1,8 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe DataMapper::Adapters::Sql::Mappings::Schema do
-  it "should return all tables from the database schema" do
-    database.adapter.schema.database_tables.size.should == Dir[File.dirname(__FILE__) + '/fixtures/*'].size
-    database.adapter.schema.database_tables.each { |table| table.should be_a_kind_of( DataMapper::Adapters::Sql::Mappings::Table ) }
-  end
-end

data/spec/serialize_spec.rb

@@ -1,19 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe('An AR serialize implementation') do
-  
-  it 'should instatiate, save, (clear and load) the original objects' do
-    test_data = { :first => 1, :second => "dos", :third => 3.0 }
-
-    srlzr1 = Serializer.new(:content => test_data)
-    srlzr1.content.should == test_data
-    
-    srlzr1.save
-    srlzr1.content.should == test_data
-    
-    srlzr1 = nil
-    srlzr2 = Serializer.first
-    srlzr2.content.should == test_data
-  end
-
-end