activerecord 1.1.0 → 1.2.0

data/test/fixtures/topic.rb

@@ -1,9 +1,9 @@
 class Topic < ActiveRecord::Base
-  has_many :replies, :foreign_key => "parent_id"
+  has_many :replies, :dependent => true, :foreign_key => "parent_id"
   serialize :content
   
   before_create  :default_written_on
-  before_destroy :destroy_children #'self.class.delete_all "parent_id = #{id}"'
+  before_destroy :destroy_children
 
   def parent
     self.class.find(parent_id)

data/test/fixtures/topics/first

@@ -3,6 +3,7 @@ title            => The First Topic
 author_name       => David
 author_email_address => david@loudthinking.com
 written_on        => 2003-07-16 15:28
+bonus_time       => 12:13:14
 last_read        => 2004-04-15
 content          => Have a nice day
 approved => 0

data/test/fixtures_test.rb

@@ -1,19 +1,16 @@
 require 'abstract_unit'
 require 'fixtures/topic'
 require 'fixtures/developer'
+require 'fixtures/company'
 
 class FixturesTest < Test::Unit::TestCase
-  fixtures :topics, :developers
-  
+  fixtures :topics, :developers, :accounts
+
   FIXTURES = %w( accounts companies customers
                  developers developers_projects entrants
                  movies projects subscribers topics )
   MATCH_ATTRIBUTE_NAME = /[a-zA-Z][-_\w]*/
 
-  def setup
-    # just to annoy
-  end
-
   def test_clean_fixtures
     FIXTURES.each do |name|
       fixtures = nil
@@ -52,28 +49,61 @@ class FixturesTest < Test::Unit::TestCase
   def test_bad_format
     path = File.join(File.dirname(__FILE__), 'fixtures', 'bad_fixtures')
     Dir.entries(path).each do |file|
-      next unless File.file?(file) and file !~ %r(^.|.yaml$)
+      next unless File.file?(file) and file !~ Fixtures::DEFAULT_FILTER_RE
       assert_raise(Fixture::FormatError) {
         Fixture.new(bad_fixtures_path, file)
       }
     end
   end
 
+  def test_deprecated_yaml_extension
+    assert_raise(Fixture::FormatError) {
+      Fixtures.new(nil, 'bad_extension', File.join(File.dirname(__FILE__), 'fixtures'))
+    }
+  end
+
   def test_logger_level_invariant
     level = ActiveRecord::Base.logger.level
     create_fixtures('topics')
     assert_equal level, ActiveRecord::Base.logger.level
   end
-  
+
   def test_instantiation
     topics = create_fixtures("topics")
     assert_kind_of Topic, topics["first"].find
   end
-  
+
   def test_complete_instantiation
-    # instantiate_fixtures "topics", "developers"
     assert_equal 2, @topics.size
-    assert_equal 2, @developers.size
     assert_equal "The First Topic", @first.title
   end
-end
+
+  def test_fixtures_from_root_yml_with_instantiation
+    # assert_equal 2, @accounts.size
+    assert_equal 50, @unknown.credit_limit
+  end
+
+  def test_erb_in_fixtures
+    assert_equal 10, @developers.size
+    assert_equal "fixture_5", @dev_5.name
+  end
+
+  def test_empty_yaml_fixture
+    assert_not_nil Fixtures.new( Account.connection, "accounts", File.dirname(__FILE__) + "/fixtures/naked/yml/accounts")
+  end
+
+  def test_empty_yaml_fixture_with_a_comment_in_it
+    assert_not_nil Fixtures.new( Account.connection, "companies", File.dirname(__FILE__) + "/fixtures/naked/yml/companies")
+  end
+
+  def test_dirty_dirty_yaml_file
+    assert_raises(Fixture::FormatError) do
+      Fixtures.new( Account.connection, "courses", File.dirname(__FILE__) + "/fixtures/naked/yml/courses")
+    end
+  end
+
+  def test_empty_csv_fixtures
+    assert_not_nil Fixtures.new( Account.connection, "accounts", File.dirname(__FILE__) + "/fixtures/naked/csv/accounts")
+  end
+  
+end

data/test/inflector_test.rb

@@ -15,6 +15,7 @@ class InflectorTest < Test::Unit::TestCase
     "query"       => "queries",
     "ability"     => "abilities",
     "agency"      => "agencies",
+    "movie"       => "movies",
 
     "wife"        => "wives",
     "safe"        => "saves",
@@ -46,7 +47,7 @@ class InflectorTest < Test::Unit::TestCase
   CamelToUnderscore = {
     "Product"                       => "product",
     "SpecialGuest"                  => "special_guest",
-    "AbstractApplicationController" => "abstract_application_controller"
+    "ApplicationController" => "application_controller"
   }
 
   ClassNameToForeignKeyWithUnderscore = {

data/test/inheritance_test.rb

@@ -1,20 +1,13 @@
 require 'abstract_unit'
 require 'fixtures/company'
-
+require 'fixtures/project'
 
 class InheritanceTest < Test::Unit::TestCase
-  def setup
-    @company_fixtures = create_fixtures "companies"
-  end
+  fixtures :companies, :projects
 
-  def switch_to_alt_inheritance_column
-    # we don't want misleading test results, so get rid of the values in the type column
-    Company.find_all(nil, "id").each do |c|
-	    c['type'] = nil
-      c.save
-    end
-    
-    def Company.inheritance_column() "ruby_type" end
+  def test_a_bad_type_column
+    Company.connection.insert "INSERT INTO companies (id, type, name) VALUES(100, 'bad_class!', 'Not happening')"
+    assert_raises(ActiveRecord::SubclassNotFound) { Company.find(100) }
   end
 
   def test_inheritance_find
@@ -122,4 +115,21 @@ class InheritanceTest < Test::Unit::TestCase
     switch_to_alt_inheritance_column
     test_complex_inheritance
   end
+
+  def test_inheritance_without_mapping
+    assert_kind_of SpecialProject, SpecialProject.find(1)
+    assert_nothing_raised { SpecialProject.create("name" => "And breaaaaathe!") }
+    
+  end
+
+  private
+    def switch_to_alt_inheritance_column
+      # we don't want misleading test results, so get rid of the values in the type column
+      Company.find_all(nil, "id").each do |c|
+        c['type'] = nil
+        c.save
+      end
+    
+      def Company.inheritance_column() "ruby_type" end
+    end
 end

data/test/mixin_test.rb

@@ -0,0 +1,138 @@
+require 'abstract_unit'
+require 'active_record/acts/tree'
+require 'active_record/acts/list'
+require 'fixtures/mixin'
+
+
+class ListTest < Test::Unit::TestCase
+  fixtures :mixins
+  
+  def test_injection
+    l = ListMixin.new("parent_id"=>1)
+    assert_equal "parent_id = 1", l.scope_condition
+    assert_equal "pos", l.position_column
+
+  end
+  
+  def test_reordering
+    
+    assert_equal [ListMixin.find(2), ListMixin.find(3)], ListMixin.find_all("parent_id=1", "pos")
+    
+    ListMixin.find(2).move_lower
+    
+    assert_equal [ListMixin.find(3), ListMixin.find(2)], ListMixin.find_all("parent_id=1", "pos")
+    
+    ListMixin.find(2).move_higher
+
+    assert_equal [ListMixin.find(2), ListMixin.find(3)], ListMixin.find_all("parent_id=1", "pos")
+    
+  end
+
+  def test_insert
+    new = ListMixin.create("parent_id"=>5)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+
+    new = ListMixin.create("parent_id"=>5)
+    assert_equal 2, new.pos
+    assert !new.first?
+    assert new.last?
+    
+    new = ListMixin.create("parent_id"=>5)
+    assert_equal 3, new.pos    
+    assert !new.first?
+    assert new.last?
+    
+    new = ListMixin.create("parent_id"=>10)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+  end    
+  
+  def test_delete_middle
+    first = ListMixin.create("parent_id"=>5)
+    assert_equal 1, first.pos
+
+    second = ListMixin.create("parent_id"=>5)
+    assert_equal 2, second.pos
+    
+    third = ListMixin.create("parent_id"=>5)
+    assert_equal 3, third.pos    
+    
+    second.destroy
+    
+    assert_equal 1, @mixins["first"].find.pos
+    assert_equal 2, @mixins["third"].find.pos
+    
+  end  
+
+  def test_with_string_based_scope
+    new = ListWithStringScopeMixin.create("parent_id"=>5)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+  end 
+end
+
+class TreeTest < Test::Unit::TestCase
+  fixtures :mixins
+  
+  def test_has_child
+    assert_equal true, @first.has_children?
+    assert_equal false, @second.has_children?
+    assert_equal false, @third.has_children?
+  end
+
+  def test_children
+    assert_equal @first.children, [@second, @third]
+    assert_equal @second.children, []
+  end
+
+  def test_parent
+    assert_equal @second.parent, @first
+    assert_equal @second.parent, @third.parent
+    assert_nil @first.parent
+  end
+  
+  def test_insert
+    @extra = @first.children.create
+    
+    assert @extra
+    
+    assert_equal @extra.parent, @first
+    assert_equal [@second, @third, @extra], @first.children
+  end
+  
+  def test_delete
+    assert_equal 3, Mixin.count
+    @first.destroy
+    assert_equal 0, Mixin.count
+  end
+end
+
+class TouchTest < Test::Unit::TestCase
+  fixtures :mixins
+  
+  def test_update
+    assert_nil @first.updated_at
+    @first.save
+    assert_not_nil @first.updated_at
+  end  
+
+  def test_create
+    @obj = Mixin.create({"parent" => @third})
+    assert_not_nil @obj.updated_at
+    assert_not_nil @obj.created_at
+  end  
+  
+  def test_create_turned_off
+    Mixin.record_timestamps = false
+
+    assert_nil @first.updated_at
+    @first.save
+    assert_nil @first.updated_at
+
+    Mixin.record_timestamps = true
+  end
+end

data/test/pk_test.rb

@@ -18,7 +18,8 @@ class PrimaryKeysTest < Test::Unit::TestCase
 
     topic = Topic.new
     topic.title = "New Topic"
-    topic.save
+    assert_equal(nil, topic.id)
+    assert_nothing_raised{ topic.save }
     id = topic.id
 
     topicReloaded = Topic.find(id)
@@ -33,8 +34,9 @@ class PrimaryKeysTest < Test::Unit::TestCase
 
     subscriber = Subscriber.new
     subscriber.id = "jdoe"
+    assert_equal("jdoe", subscriber.id)
     subscriber.name = "John Doe"
-    subscriber.save
+    assert_nothing_raised{ subscriber.save }
 
     subscriberReloaded = Subscriber.find("jdoe")
     assert_equal("John Doe", subscriberReloaded.name)

data/test/reflection_test.rb

@@ -15,17 +15,17 @@ class ReflectionTest < Test::Unit::TestCase
 
   def test_read_attribute_names
     assert_equal(
-      %w( id title author_name author_email_address written_on last_read content approved replies_count parent_id type ).sort,
+      %w( id title author_name author_email_address bonus_time written_on last_read content approved replies_count parent_id type ).sort,
       @first.attribute_names
     )
   end
   
   def test_columns
-    assert_equal 11, Topic.columns.length
+    assert_equal 12, Topic.columns.length
   end
 
   def test_content_columns
-    assert_equal 7, Topic.content_columns.length
+    assert_equal 8, Topic.content_columns.length
   end
   
   def test_column_string_type_and_limit

data/test/transactions_test.rb

@@ -84,6 +84,21 @@ class TransactionTest < Test::Unit::TestCase
     end
   end
 
+  def xtest_nested_explicit_transactions
+    Topic.transaction do
+      Topic.transaction do
+        @first.approved  = 1
+        @second.approved = 0
+        @first.save
+        @second.save
+      end
+    end
+
+    assert Topic.find(1).approved?, "First should have been approved"
+    assert !Topic.find(2).approved?, "Second should have been unapproved"
+  end
+    
+
   private
     def add_exception_raising_after_save_callback_to_topic
       Topic.class_eval { def after_save() raise "Make the transaction rollback" end }

data/test/validations_test.rb

@@ -3,11 +3,12 @@ require 'fixtures/topic'
 require 'fixtures/reply'
 require 'fixtures/developer'
 
-
 class ValidationsTest < Test::Unit::TestCase
-  def setup
-    @topic_fixtures = create_fixtures("topics")
-    @developers = create_fixtures("developers")
+  fixtures :topics, :developers
+
+  def teardown
+    Topic.write_inheritable_attribute("validate", [])
+    Topic.write_inheritable_attribute("validate_on_create", [])
   end
 
   def test_single_field_validation
@@ -123,4 +124,228 @@ class ValidationsTest < Test::Unit::TestCase
     developer.name = "Just right"
     assert developer.save
   end
+
+  def test_title_confirmation
+    Topic.validates_confirmation_of(:title)
+
+    t = Topic.create("title" => "We should be confirmed")
+    assert !t.save
+
+    t.title_confirmation = "We should be confirmed"
+    assert t.save
+  end
+
+  def test_terms_of_service_agreement
+    Topic.validates_acceptance_of(:terms_of_service, :on => :create)
+
+    t = Topic.create("title" => "We should be confirmed")
+    assert !t.save
+    assert_equal "must be accepted", t.errors.on(:terms_of_service)
+
+    t.terms_of_service = "1"
+    assert t.save
+  end
+
+
+  def test_eula
+    Topic.validates_acceptance_of(:eula, :message => "must be abided", :on => :create)
+
+    t = Topic.create("title" => "We should be confirmed")
+    assert !t.save
+    assert_equal "must be abided", t.errors.on(:eula)
+
+    t.eula = "1"
+    assert t.save
+  end
+  
+  def test_validate_presences
+    Topic.validates_presence_of(:title, :content)
+
+    t = Topic.create
+    assert !t.save
+    assert_equal "can't be empty", t.errors.on(:title)
+    assert_equal "can't be empty", t.errors.on(:content)
+    
+    t.title = "something"
+    t.content  = "another"
+    
+    assert t.save
+  end
+  
+  def test_validate_uniqueness
+    Topic.validates_uniqueness_of(:title)
+    
+    t = Topic.new("title" => "I'm unique!")
+    assert t.save, "Should save t as unique"
+
+    t.content = "Remaining unique"
+    assert t.save, "Should still save t as unique"
+
+    t2 = Topic.new("title" => "I'm unique!")
+    assert !t2.valid?, "Shouldn't be valid"
+    assert !t2.save, "Shouldn't save t2 as unique"
+    assert_equal "has already been taken", t2.errors.on(:title)
+    
+    t2.title = "Now Im really also unique"
+    assert t2.save, "Should now save t2 as unique"
+  end
+
+  def test_validate_format
+    Topic.validates_format_of(:title, :content, :with => /^Validation macros rule!$/, :message => "is bad data")
+
+    t = Topic.create("title" => "i'm incorrect", "content" => "Validation macros rule!")
+    assert !t.valid?, "Shouldn't be valid"
+    assert !t.save, "Shouldn't save because it's invalid"
+    assert_equal "is bad data", t.errors.on(:title)
+    assert_nil t.errors.on(:content)
+
+    t.title = "Validation macros rule!"
+
+    assert t.save
+    assert_nil t.errors.on(:title)
+
+    assert_raise(ArgumentError) { Topic.validates_format_of(:title, :content) }
+  end
+
+  def test_validates_inclusion_of
+    Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ) )
+
+    assert !Topic.create("title" => "a!", "content" => "abc").valid?
+    assert !Topic.create("title" => "a b", "content" => "abc").valid?
+    assert !Topic.create("title" => nil, "content" => "def").valid?
+    assert !Topic.create("title" => %w(a b c), "content" => "def").valid?
+    
+    t = Topic.create("title" => "a", "content" => "I know you are but what am I?")
+    assert t.valid?
+    t.title = "uhoh"
+    assert !t.valid?
+    assert t.errors.on(:title)
+    assert_equal "is not included in the list", t.errors["title"]
+
+    assert_raise(ArgumentError) { Topic.validates_inclusion_of( :title, :in => nil ) }
+    assert_raise(ArgumentError) { Topic.validates_inclusion_of( :title, :in => 0) }
+
+    assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => "hi!" ) }
+    assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => {} ) }
+    assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => [] ) }
+  end
+
+  def test_validates_length_of_using_minimum
+    Topic.validates_length_of( :title, :minimum=>5 )
+    t = Topic.create("title" => "valid", "content" => "whatever")
+    assert t.valid?
+    t.title = "not"
+    assert !t.valid?
+    assert t.errors.on(:title)
+    assert_equal "is too short (min is 5 characters)", t.errors["title"]
+    t.title = ""
+    assert !t.valid?
+    assert t.errors.on(:title)
+    t.title = nil
+    assert !t.valid?
+    assert_equal "is too short (min is 5 characters)", t.errors["title"]
+    assert t.errors.on(:title)
+  end
+  
+  def test_validates_length_of_using_maximum
+    Topic.validates_length_of( :title, :maximum=>5 )
+    t = Topic.create("title" => "valid", "content" => "whatever")
+    assert t.valid?
+    t.title = "notvalid"
+    assert !t.valid?
+    assert t.errors.on(:title)
+    assert_equal "is too long (max is 5 characters)", t.errors["title"]
+    t.title = ""
+    assert t.valid?
+    t.title = nil
+    assert t.valid?
+  end
+
+  def test_validates_length_of_using_within
+    Topic.validates_length_of(:title, :content, :within => 3..5)
+
+    t = Topic.create("title" => "a!", "content" => "I'm ooooooooh so very long")
+    assert !t.save
+    assert_equal "is too short (min is 3 characters)", t.errors.on(:title)
+    assert_equal "is too long (max is 5 characters)", t.errors.on(:content)
+
+    t.title = "abe"
+    t.content  = "mad"
+
+    assert t.save
+  end
+
+  def test_validates_length_of_using_is
+    Topic.validates_length_of( :title, :is=>5 )
+    t = Topic.create("title" => "valid", "content" => "whatever")
+    assert t.valid?
+    t.title = "notvalid"
+    assert !t.valid?
+    assert t.errors.on(:title)
+    assert_equal "is the wrong length (should be 5 characters)", t.errors["title"]
+    t.title = ""
+    assert !t.valid?
+    t.title = nil
+    assert !t.valid?
+  end
+
+  def test_validates_length_of_nasty_params
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :minimum=>6, :maximum=>9) }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>6, :maximum=>9) }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>6, :minimum=>9) }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>6, :is=>9) }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :minimum=>"a") }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :maximum=>"a") }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>"a") }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :is=>"a") }
+  end
+
+  def test_validates_length_of_custom_errors_for_minimum_with_message
+    Topic.validates_length_of( :title, :minimum=>5, :message=>"boo %d" )
+    t = Topic.create("title" => "uhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors.on(:title)
+    assert_equal "boo 5", t.errors["title"]
+  end
+
+  def test_validates_length_of_custom_errors_for_minimum_with_too_short
+    Topic.validates_length_of( :title, :minimum=>5, :too_short=>"hoo %d" )
+    t = Topic.create("title" => "uhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors.on(:title)
+    assert_equal "hoo 5", t.errors["title"]
+  end
+
+  def test_validates_length_of_custom_errors_for_maximum_with_message
+    Topic.validates_length_of( :title, :maximum=>5, :message=>"boo %d" )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors.on(:title)
+    assert_equal "boo 5", t.errors["title"]
+  end
+
+  def test_validates_length_of_custom_errors_for_maximum_with_too_long
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %d" )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors.on(:title)
+    assert_equal "hoo 5", t.errors["title"]
+  end
+  
+  def test_validates_length_of_custom_errors_for_is_with_message
+    Topic.validates_length_of( :title, :is=>5, :message=>"boo %d" )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors.on(:title)
+    assert_equal "boo 5", t.errors["title"]
+  end
+
+  def test_validates_length_of_custom_errors_for_is_with_wrong_length
+    Topic.validates_length_of( :title, :is=>5, :wrong_length=>"hoo %d" )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors.on(:title)
+    assert_equal "hoo 5", t.errors["title"]
+  end
+
 end