datamapper 0.3.2 → 0.9.3

data/spec/attributes_spec.rb

@@ -1,52 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe "DataMapper::Attributes" do
-    
-  it 'should allow mass-assignment of attributes' do
-    zoo = Zoo.new(:name => 'MassAssignment', :notes => 'This is a test.')
-    
-    zoo.name.should eql('MassAssignment')
-    zoo.notes.should eql('This is a test.')
-    
-    zoo.attributes = { :name => 'ThroughAttributesEqual', :notes => 'This is another test.' }
-    
-    zoo.name.should eql('ThroughAttributesEqual')
-    zoo.notes.should eql('This is another test.')
-  end
-  
-  it "should allow custom setters" do
-    zoo = Zoo.new
-    
-    zoo.name = 'Colorado Springs'
-    zoo.name.should eql("Cheyenne Mountain")
-  end
-  
-  it "should call custom setters on mass-assignment" do
-    zoo = Zoo.new(:name => 'Colorado Springs')
-    
-    zoo.name.should eql("Cheyenne Mountain")
-  end
-  
-  it "should provide an ATTRIBUTES constant" do
-    Tomato::ATTRIBUTES.should == Set.new([:id, :name, :bruised])
-  end
-  
-  it "should get attributes declared in ATTRIBUTES constant" do
-    Tomato.new.attributes.should == { :id => nil, :name => 'Ugly', :bruised => true }
-  end
-  
-  it "should get proper values for mass-created attributes with array" do
-    person = Person.new(:name => 'Steve Jobs', :occupation => 'Apple CEO')
-    
-    person.name.should eql('Steve Jobs')
-    person.occupation.should eql('Apple CEO')
-  end
-  
-  it "should get proper values for mass-created attributes without array" do
-    job = Job.new(:name => 'Banker')
-    job.save! and job.reload
-    
-    job.hours.should eql(0)
-    job.days.should eql(0)
-  end
-end

data/spec/auto_migrations_spec.rb

@@ -1,101 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe DataMapper::AutoMigrations do
-  before(:all) do
-    DataMapper::Persistence.drop_all_tables!
-    DataMapper::Persistence.subclasses.clear
-  end
-
-#  before(:each) do
-#    DataMapper::Persistence.drop_all_tables!
-#  end
-#  
-#  after(:all) do
-#    DataMapper::Persistence.drop_all_tables!
-#    DataMapper::Persistence.auto_migrate!
-#  end
-
-#  describe DataMapper::Base do
-#    it "should auto migrate all" do
-#      DataMapper::Base.auto_migrate!
-#
-#      database.adapter.schema.database_tables.size.should == Dir[File.dirname(__FILE__) + '/fixtures/*'].size
-#    end
-#
-#    describe "when migrating a descendant" do
-#      before do
-#	class Descendant < DataMapper::Base
-#	  property :one, :string
-#	  property :two, :string
-#	  property :three, :string
-#	end
-#      end
-#
-#      it "should work" do
-#	Descendant.auto_migrate!
-#
-#	database.table_exists?(Descendant).should be_true
-#	database.column_exists_for_table?(Descendant, :one).should be_true
-#	database.column_exists_for_table?(Descendant, :two).should be_true
-#	database.column_exists_for_table?(Descendant, :three).should be_true
-#	database.adapter.schema.database_tables.size.should == 1
-#      end
-#
-#      after do
-#	database.schema[Descendant].drop!
-#      end
-#    end
-#  end
-  
-  it "should find all new models" do
-    Zoo.auto_migrate!
-
-    database.table_exists?(Zoo).should be_true
-    database.column_exists_for_table?(Zoo, :id).should be_true
-    database.column_exists_for_table?(Zoo, :name).should be_true
-    database.column_exists_for_table?(Zoo, :notes).should be_true
-    database.column_exists_for_table?(Zoo, :updated_at).should be_true    
-    database.adapter.schema.database_tables.size.should == 1
-  end
-  
-  it "should find all changed models"
-  it "should find all unmapped tables"
-
-  describe Zoo, "with auto-migrations" do
-    it "should allow auto migration" do
-      Zoo.should respond_to("auto_migrate!")
-    end
-  end
-
-  describe "when migrating a new model" do
-    it "should allow creation of new tables for new models"
-    it "should allow renaming of unmapped tables for new models"
-    it "should create columns for the model's properties"
-  end
-
-  describe "when migrating a changed model" do
-    it "should find all new properties"
-    it "should allow creation of new columns for new properties"
-    it "should allow an unmapped column to be renamed for a new property"
-    it "should find all unmapped columns"
-    it "should allow removal of any or all unmapped columns"
-  end
-
-  describe "when migrating an unmapped table" do
-    it "should allow the table to be dropped"
-  end
-
-  describe "after migrating" do
-    it "should store migration decisions to allow the migration to be replicated"
-  end
-
-  after(:all) do
-    DataMapper::Persistence.subclasses.clear
-    DataMapper::Persistence.subclasses.concat INITIAL_CLASSES
-    
-    # Use DataMapper::Base to boost spec coverage since it delegates to Persistence anyways.
-    DataMapper::Base.auto_migrate!
-
-    load_database
-  end
-end

data/spec/callbacks_spec.rb

@@ -1,186 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe DataMapper::Callbacks do
-  
-  it "should allow for a callback to be set, then called" do
-    
-    example = Class.new do
-      include DataMapper::CallbacksHelper
-      
-      attr_accessor :name
-      
-      def initialize(name)
-        @name = name
-      end
-      
-      before_save 'name = "bob"'
-      before_validation { |instance| instance.name = 'Barry White Returns!' }
-
-    end.new('Barry White')
-    
-    example.class::callbacks.execute(:before_save, example)
-    example.name.should == 'Barry White'
-    
-    example.class::callbacks.execute(:before_validation, example)
-    example.name.should == 'Barry White Returns!'
-  end
-  
-  it "should allow method delegation by passing symbols to the callback definitions" do
-    
-    example = Class.new do
-      include DataMapper::CallbacksHelper
-      
-      attr_accessor :name
-      
-      before_save :test
-      
-      def test
-        @name = 'Walter'
-      end
-    end.new
-    
-    example.class::callbacks.execute(:before_save, example)
-    example.name.should == 'Walter'
-    
-  end
-  
-  it "should execute before_save regardless of dirty state" do
-    
-    Post.before_save do |post|
-      post.instance_variable_set("@one", 'moo')
-    end
-    
-    Post.before_save do |post|
-      post.instance_variable_set("@two", 'cow')
-    end
-    
-    Post.before_save :red_cow
-    
-    class Post
-      def red_cow
-        @three = "blue_cow"
-      end
-    end
-    
-    post = Post.new(:title => 'bob')
-    post.save
-    
-    post = Post.first(:title => 'bob')
-    post.instance_variable_get("@one").should be_nil
-    post.instance_variable_get("@two").should be_nil
-    post.instance_variable_get("@three").should be_nil
-
-    post.save
-    post.instance_variable_get("@one").should eql('moo')
-    post.instance_variable_get("@two").should eql('cow')
-    post.instance_variable_get("@three").should eql('blue_cow')
-  end
-  
-  it "should execute materialization callbacks" do
-    
-    $before_materialize = 0
-    $after_materialize = 0
-    
-    Zoo.before_materialize do
-      $before_materialize += 1
-    end
-    
-    Zoo.after_materialize do
-      $after_materialize += 1
-    end
-    
-    class Zoo
-      
-      # This syntax doesn't work in DM.
-      # Which I don't think is necessarily a bad thing...
-      # Just FYI -Sam
-      def before_materialize
-        $before_materialize += 1
-      end
-      
-      def call_before_materialize
-        $before_materialize += 1
-      end
-      
-      # Example of invalid syntax
-      def after_materialize
-        $after_materialize += 1
-      end
-      
-      def call_after_materialize
-        $after_materialize += 1
-      end
-      
-    end
-    
-    Zoo.before_materialize :call_before_materialize
-    Zoo.after_materialize :call_after_materialize
-    
-    Zoo.before_materialize "$before_materialize += 1"
-    Zoo.after_materialize "$after_materialize += 1"
-    
-    Zoo.first
-    
-    $before_materialize.should == 3
-    $after_materialize.should == 3
-    
-    Zoo[1]
-    
-    $before_materialize.should == 6
-    $after_materialize.should == 6
-    
-  end
-  
-  it "should execute creation callbacks" do
-    
-    $before_create = 0
-    $after_create = 0
-    
-    Zoo.before_create do
-      $before_create += 1
-    end
-    
-    Zoo.after_create do
-      $after_create += 1
-    end
-    
-    class Zoo
-      
-      # Example of invalid syntax
-      def before_create
-        $before_create += 1
-      end
-      
-      def call_before_create
-        $before_create += 1
-      end
-      
-      # Example of invalid syntax
-      def after_create
-        $after_create += 1
-      end
-      
-      def call_after_create
-        $after_create += 1
-      end
-      
-    end
-    
-    Zoo.before_create :call_before_create
-    Zoo.after_create :call_after_create
-    
-    Zoo.before_create "$before_create += 1"
-    Zoo.after_create "$after_create += 1"
-    
-    Zoo.create(:name => 'bob')
-    
-    $before_create.should == 3
-    $after_create.should == 3  
-    
-    Zoo.new(:name => 'bob2').save
-    
-    $before_create.should == 6
-    $after_create.should == 6
-  end
-  
-end

data/spec/can_has_sphinx.rb

@@ -1,5 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe DataMapper::Plugins::CanHasSphinx do
-  
-end

data/spec/coersion_spec.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe DataMapper::Adapters::Sql::Coersion do
-  
-  before(:all) do
-    @coersive = Class.new do
-      include DataMapper::Adapters::Sql::Coersion
-    end.new
-  end
-  
-  it 'should cast to a BigDecimal' do
-    target = BigDecimal.new('7.2')
-    @coersive.type_cast_decimal('7.2').should == target
-    @coersive.type_cast_decimal(7.2).should == target
-  end
-  
-  it 'should store and load a date' do
-    dob = Date::today
-    bob = Person.create(:name => 'DateCoersionTest', :date_of_birth => dob)
-    
-    bob2 = Person.first(:name => 'DateCoersionTest')
-    
-    bob.date_of_birth.should eql(dob)
-    bob2.date_of_birth.should eql(dob)
-  end
-  
-  it 'should cast to a Date' do
-    target = Date.civil(2001, 1, 1)
-    
-    @coersive.type_cast_date('2001-1-1').should eql(target)
-    @coersive.type_cast_date(target.dup).should eql(target)
-    @coersive.type_cast_date(DateTime::parse('2001-1-1')).should eql(target)
-    @coersive.type_cast_date(Time::parse('2001-1-1')).should eql(target)
-  end
-
-  it 'should cast to a String' do
-    target = "\n\ttest\n\n\ntest\n\n"
-
-    @coersive.type_cast_text(target).should == target
-  end
-end

data/spec/column_spec.rb

@@ -1,114 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe DataMapper::Adapters::Sql::Mappings::Column do
-  
-  before(:all) do
-    @mappings = DataMapper::Adapters::Sql::Mappings
-    fixtures(:zoos)
-  end
-  
-  def table
-  	@table ||= @mappings::Table.new(database(:mock).adapter, "Cow")
-  end
-
-  it "should only lazy loading text columns by default" do
-    table = database.table(Zoo)
-    table.columns.each do  |column|
-      if column.type == :text
-        column.should be_lazy
-      else
-        column.should_not be_lazy
-      end
-    end
-  end
-  
-  it "should be unique within a set" do
-    columns = SortedSet.new
-    
-    columns << @mappings::Column.new(database(:mock).adapter, table, :one, :string, 1)
-    columns << @mappings::Column.new(database(:mock).adapter, table, :two, :string, 2)
-    columns << @mappings::Column.new(database(:mock).adapter, table, :three, :string, 3)
-    columns.should have(3).entries
-    
-    columns << @mappings::Column.new(database(:mock).adapter, table, :two, :integer, 3)
-    columns.should have(3).entries
-    
-    columns << @mappings::Column.new(database(:mock).adapter, table, :id, :integer, -1)
-    columns.should have(4).entries
-  end
-  
-  it "should get its meta data from the database"
-  
-  it "should be able to rename" do
-    table = database.table(Zoo)
-    name_column = table[:name]
-    
-    lambda { database.query("SELECT name FROM zoos") }.should_not raise_error
-    lambda { database.query("SELECT moo FROM zoos") }.should raise_error
-    
-    name_column = name_column.rename!(:moo)
-    name_column.name.should eql(:moo)
-    
-    lambda { database.query("SELECT name FROM zoos") }.should raise_error
-    lambda { database.query("SELECT moo FROM zoos") }.should_not raise_error
-    
-    name_column = name_column.rename!(:name)
-    name_column.name.should eql(:name)
-    
-    lambda { database.query("SELECT name FROM zoos") }.should_not raise_error
-    lambda { database.query("SELECT moo FROM zoos") }.should raise_error
-  end
-  
-  it "should create, alter and drop a column" do
-    lambda { database.query("SELECT moo FROM zoos") }.should raise_error
-    
-    database.logger.debug { 'MOO' * 10 }
-    
-    table = database.table(Zoo)
-    Zoo.property(:moo, :string)
-    moo = table[:moo]
-    moo.create!
-    
-    lambda { database.query("SELECT moo FROM zoos") }.should_not raise_error
-    
-    zoo = Zoo.create(:name => 'columns', :moo => 'AAA')
-    zoo.moo.should eql('AAA')
-    
-    zoo.moo = 4
-    zoo.save
-    zoo.reload!
-    zoo.moo.should eql('4')
-    
-    moo.type = :integer
-    moo.alter!
-    zoo.reload!
-    zoo.moo.should eql(4)
-    
-    moo.drop!
-    
-    Zoo.send(:undef_method, :moo)
-    Zoo.send(:undef_method, :moo=)
-    Zoo.properties.delete_if { |x| x.name == :moo }
-    
-    lambda { database.query("SELECT moo FROM zoos") }.should raise_error
-  end
-  
-  it "should default the size of an integer column to 11" do
-    integer  = @mappings::Column.new(database(:mock).adapter, table, :age, :integer, 1)
-    integer.size.should == 11    
-  end
-  
-  it "should be able to create a column with unique index" do
-    column = table.add_column("name", :string, :index => :unique)
-    column.unique?.should be_true
-    column.index?.should be_nil
-    table.to_create_index_sql.should == []
-    table.to_create_sql.should match(/UNIQUE/)
-  end
-  
-  it "should be able to create an indexed column" do
-    column = table.add_column("age", :integer, :index => true)
-    column.index?.should be_true
-    table.to_create_index_sql[0].should match(/CREATE INDEX cow_age_index/)
-  end
-end