activerecord 2.2.3 → 2.3.2

data/test/cases/inheritance_test.rb

@@ -68,7 +68,7 @@ class InheritanceTest < ActiveRecord::TestCase
     if current_adapter?(:SybaseAdapter)
       Company.connection.execute "SET IDENTITY_INSERT companies OFF"
     end
-    assert_raises(ActiveRecord::SubclassNotFound) { Company.find(100) }
+    assert_raise(ActiveRecord::SubclassNotFound) { Company.find(100) }
   end
 
   def test_inheritance_find
@@ -124,7 +124,7 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_finding_incorrect_type_data
-    assert_raises(ActiveRecord::RecordNotFound) { Firm.find(2) }
+    assert_raise(ActiveRecord::RecordNotFound) { Firm.find(2) }
     assert_nothing_raised   { Firm.find(1) }
   end
 

data/test/cases/json_serialization_test.rb

@@ -200,6 +200,6 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
       2 => @mary
     }
 
-    assert_equal %({1: {"name": "David"}}), authors_hash.to_json(:only => [1, :name])
+    assert_equal %({"1": {"name": "David"}}), authors_hash.to_json(:only => [1, :name])
   end
 end

data/test/cases/locking_test.rb

@@ -35,7 +35,25 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 0, p2.lock_version
 
     p2.first_name = 'sue'
-    assert_raises(ActiveRecord::StaleObjectError) { p2.save! }
+    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
+  end
+
+  def test_lock_destroy
+    p1 = Person.find(1)
+    p2 = Person.find(1)
+    assert_equal 0, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    p1.first_name = 'stu'
+    p1.save!
+    assert_equal 1, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    assert_raises(ActiveRecord::StaleObjectError) { p2.destroy }
+
+    assert p1.destroy
+    assert_equal true, p1.frozen?
+    assert_raises(ActiveRecord::RecordNotFound) { Person.find(1) }
   end
 
   def test_lock_repeating
@@ -50,9 +68,9 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 0, p2.lock_version
 
     p2.first_name = 'sue'
-    assert_raises(ActiveRecord::StaleObjectError) { p2.save! }
+    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
     p2.first_name = 'sue2'
-    assert_raises(ActiveRecord::StaleObjectError) { p2.save! }
+    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
   end
 
   def test_lock_new
@@ -71,7 +89,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 0, p2.lock_version
 
     p2.first_name = 'sue'
-    assert_raises(ActiveRecord::StaleObjectError) { p2.save! }
+    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
   end
 
   def test_lock_new_with_nil
@@ -95,7 +113,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 0, t2.version
 
     t2.tps_report_number = 800
-    assert_raises(ActiveRecord::StaleObjectError) { t2.save! }
+    assert_raise(ActiveRecord::StaleObjectError) { t2.save! }
   end
 
   def test_lock_column_is_mass_assignable

data/test/cases/method_scoping_test.rb

@@ -27,6 +27,24 @@ class MethodScopingTest < ActiveRecord::TestCase
     end
   end
 
+  def test_scoped_find_last
+    highest_salary = Developer.find(:first, :order => "salary DESC")
+
+    Developer.with_scope(:find => { :order => "salary" }) do
+      assert_equal highest_salary, Developer.last
+    end
+  end
+
+  def test_scoped_find_last_preserves_scope
+    lowest_salary = Developer.find(:first, :order => "salary ASC")
+    highest_salary = Developer.find(:first, :order => "salary DESC")
+
+    Developer.with_scope(:find => { :order => "salary" }) do
+      assert_equal highest_salary, Developer.last
+      assert_equal lowest_salary, Developer.first
+    end
+  end
+
   def test_scoped_find_combines_conditions
     Developer.with_scope(:find => { :conditions => "salary = 9000" }) do
       assert_equal developers(:poor_jamis), Developer.find(:first, :conditions => "name = 'Jamis'")
@@ -168,6 +186,16 @@ class MethodScopingTest < ActiveRecord::TestCase
     assert_equal authors(:david).attributes, scoped_authors.first.attributes
   end
 
+  def test_scoped_find_strips_spaces_from_string_joins_and_eliminates_duplicate_string_joins
+    scoped_authors = Author.with_scope(:find => { :joins => ' INNER JOIN posts ON posts.author_id = authors.id '}) do
+      Author.find(:all, :select => 'DISTINCT authors.*', :joins => ['INNER JOIN posts ON posts.author_id = authors.id'], :conditions => 'posts.id = 1')
+    end
+    assert scoped_authors.include?(authors(:david))
+    assert !scoped_authors.include?(authors(:mary))
+    assert_equal 1, scoped_authors.size
+    assert_equal authors(:david).attributes, scoped_authors.first.attributes
+  end
+
   def test_scoped_count_include
     # with the include, will retrieve only developers for the given project
     Developer.with_scope(:find => { :include => :projects }) do
@@ -234,6 +262,15 @@ class NestedScopingTest < ActiveRecord::TestCase
     end
   end
 
+  def test_merge_inner_scope_has_priority
+    Developer.with_scope(:find => { :limit => 5 }) do
+      Developer.with_scope(:find => { :limit => 10 }) do
+        merged_option = Developer.instance_eval('current_scoped_methods')[:find]
+        assert_equal({ :limit => 10 }, merged_option)
+      end
+    end
+  end
+
   def test_replace_options
     Developer.with_scope(:find => { :conditions => "name = 'David'" }) do
       Developer.with_exclusive_scope(:find => { :conditions => "name = 'Jamis'" }) do
@@ -374,6 +411,29 @@ class NestedScopingTest < ActiveRecord::TestCase
     end
   end
 
+  def test_nested_scoped_create
+    comment = nil
+    Comment.with_scope(:create => { :post_id => 1}) do
+      Comment.with_scope(:create => { :post_id => 2}) do
+        assert_equal({ :post_id => 2 }, Comment.send(:current_scoped_methods)[:create])
+        comment = Comment.create :body => "Hey guys, nested scopes are broken. Please fix!"
+      end
+    end
+    assert_equal 2, comment.post_id
+  end
+
+  def test_nested_exclusive_scope_for_create
+    comment = nil
+    Comment.with_scope(:create => { :body => "Hey guys, nested scopes are broken. Please fix!" }) do
+      Comment.with_exclusive_scope(:create => { :post_id => 1 }) do
+        assert_equal({ :post_id => 1 }, Comment.send(:current_scoped_methods)[:create])
+        comment = Comment.create :body => "Hey guys"
+      end
+    end
+    assert_equal 1, comment.post_id
+    assert_equal 'Hey guys', comment.body
+  end
+
   def test_merged_scoped_find_on_blank_conditions
     [nil, " ", [], {}].each do |blank|
       Developer.with_scope(:find => {:conditions => blank}) do
@@ -497,7 +557,6 @@ class HasManyScopingTest< ActiveRecord::TestCase
   end
 end
 
-
 class HasAndBelongsToManyScopingTest< ActiveRecord::TestCase
   fixtures :posts, :categories, :categories_posts
 
@@ -523,11 +582,76 @@ class HasAndBelongsToManyScopingTest< ActiveRecord::TestCase
   end
 end
 
+class DefaultScopingTest < ActiveRecord::TestCase
+  fixtures :developers
+
+  def test_default_scope
+    expected = Developer.find(:all, :order => 'salary DESC').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
+    assert_equal expected, received
+  end
+
+  def test_default_scoping_with_threads
+    scope = [{ :create => {}, :find => { :order => 'salary DESC' } }]
+
+    2.times do
+      Thread.new { assert_equal scope, DeveloperOrderedBySalary.send(:scoped_methods) }.join
+    end
+  end
+
+  def test_default_scoping_with_inheritance
+    scope = [{ :create => {}, :find => { :order => 'salary DESC' } }]
+
+    # Inherit a class having a default scope and define a new default scope
+    klass = Class.new(DeveloperOrderedBySalary)
+    klass.send :default_scope, {}
+
+    # Scopes added on children should append to parent scope
+    expected_klass_scope = [{ :create => {}, :find => { :order => 'salary DESC' }}, { :create => {}, :find => {} }]
+    assert_equal expected_klass_scope, klass.send(:scoped_methods)
+
+    # Parent should still have the original scope
+    assert_equal scope, DeveloperOrderedBySalary.send(:scoped_methods)
+  end
+
+  def test_method_scope
+    expected = Developer.find(:all, :order => 'name DESC').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.all_ordered_by_name.collect { |dev| dev.salary }
+    assert_equal expected, received
+  end
+
+  def test_nested_scope
+    expected = Developer.find(:all, :order => 'name DESC').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.with_scope(:find => { :order => 'name DESC'}) do
+      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
+    end
+    assert_equal expected, received
+  end
+
+  def test_named_scope
+    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.salary }
+    assert_equal expected, received
+  end
+
+  def test_nested_exclusive_scope
+    expected = Developer.find(:all, :limit => 100).collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.with_exclusive_scope(:find => { :limit => 100 }) do
+      DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
+    end
+    assert_equal expected, received
+  end
+
+  def test_overwriting_default_scope
+    expected = Developer.find(:all, :order => 'salary').collect { |dev| dev.salary }
+    received = DeveloperOrderedBySalary.find(:all, :order => 'salary').collect { |dev| dev.salary }
+    assert_equal expected, received
+  end
+end
 
 =begin
 # We disabled the scoping for has_one and belongs_to as we can't think of a proper use case
 
-
 class BelongsToScopingTest< ActiveRecord::TestCase
   fixtures :comments, :posts
 
@@ -547,7 +671,6 @@ class BelongsToScopingTest< ActiveRecord::TestCase
 
 end
 
-
 class HasOneScopingTest< ActiveRecord::TestCase
   fixtures :comments, :posts
 

data/test/cases/migration_test.rb

@@ -93,6 +93,30 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
+    def testing_table_with_only_foo_attribute
+      Person.connection.create_table :testings, :id => false do |t|
+        t.column :foo, :string
+      end
+
+      yield Person.connection
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+    protected :testing_table_with_only_foo_attribute
+
+    def test_create_table_without_id
+      testing_table_with_only_foo_attribute do |connection|
+        assert_equal connection.columns(:testings).size, 1
+      end
+    end
+
+    def test_add_column_with_primary_key_attribute
+      testing_table_with_only_foo_attribute do |connection|
+        assert_nothing_raised { connection.add_column :testings, :id, :primary_key }
+        assert_equal connection.columns(:testings).size, 2
+      end
+    end
+
     def test_create_table_adds_id
       Person.connection.create_table :testings do |t|
         t.column :foo, :string
@@ -111,7 +135,7 @@ if ActiveRecord::Base.connection.supports_migrations?
         end
       end
 
-      assert_raises(ActiveRecord::StatementInvalid) do
+      assert_raise(ActiveRecord::StatementInvalid) do
         Person.connection.execute "insert into testings (foo) values (NULL)"
       end
     ensure
@@ -219,22 +243,20 @@ if ActiveRecord::Base.connection.supports_migrations?
       ActiveRecord::Base.primary_key_prefix_type = nil
     end
 
-    uses_mocha('test_create_table_with_force_true_does_not_drop_nonexisting_table') do
-      def test_create_table_with_force_true_does_not_drop_nonexisting_table
-        if Person.connection.table_exists?(:testings2)
-          Person.connection.drop_table :testings2
-        end
+    def test_create_table_with_force_true_does_not_drop_nonexisting_table
+      if Person.connection.table_exists?(:testings2)
+        Person.connection.drop_table :testings2
+      end
 
-        # using a copy as we need the drop_table method to
-        # continue to work for the ensure block of the test
-        temp_conn = Person.connection.dup
-        temp_conn.expects(:drop_table).never
-        temp_conn.create_table :testings2, :force => true do |t|
-          t.column :foo, :string
-        end
-      ensure
-        Person.connection.drop_table :testings2 rescue nil
+      # using a copy as we need the drop_table method to
+      # continue to work for the ensure block of the test
+      temp_conn = Person.connection.dup
+      temp_conn.expects(:drop_table).never
+      temp_conn.create_table :testings2, :force => true do |t|
+        t.column :foo, :string
       end
+    ensure
+      Person.connection.drop_table :testings2 rescue nil
     end
 
     def test_create_table_with_timestamps_should_create_datetime_columns
@@ -280,7 +302,7 @@ if ActiveRecord::Base.connection.supports_migrations?
         end
         Person.connection.add_column :testings, :bar, :string, :null => false
 
-        assert_raises(ActiveRecord::StatementInvalid) do
+        assert_raise(ActiveRecord::StatementInvalid) do
           Person.connection.execute "insert into testings (foo, bar) values ('hello', NULL)"
         end
       ensure
@@ -299,7 +321,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.connection.enable_identity_insert("testings", false) if current_adapter?(:SybaseAdapter)
       assert_nothing_raised {Person.connection.add_column :testings, :bar, :string, :null => false, :default => "default" }
 
-      assert_raises(ActiveRecord::StatementInvalid) do
+      assert_raise(ActiveRecord::StatementInvalid) do
         unless current_adapter?(:OpenBaseAdapter)
           Person.connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) values (2, 'hello', NULL)"
         else
@@ -547,7 +569,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       else
         ActiveRecord::ActiveRecordError
       end
-      assert_raises(exception) do
+      assert_raise(exception) do
         Person.connection.rename_column "hats", "nonexistent", "should_fail"
       end
     ensure
@@ -797,7 +819,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal "hello world", Reminder.find(:first).content
 
       WeNeedReminders.down
-      assert_raises(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
+      assert_raise(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
     end
 
     def test_add_table_with_decimals
@@ -858,7 +880,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
 
       GiveMeBigNumbers.down
-      assert_raises(ActiveRecord::StatementInvalid) { BigNumber.find(:first) }
+      assert_raise(ActiveRecord::StatementInvalid) { BigNumber.find(:first) }
     end
 
     def test_migrator
@@ -878,7 +900,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal 0, ActiveRecord::Migrator.current_version
       Person.reset_column_information
       assert !Person.column_methods_hash.include?(:last_name)
-      assert_raises(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
+      assert_raise(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
     end
 
     def test_migrator_one_up
@@ -930,11 +952,11 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal(0, ActiveRecord::Migrator.current_version)
     end
 
-    if current_adapter?(:PostgreSQLAdapter)
+    if ActiveRecord::Base.connection.supports_ddl_transactions?
       def test_migrator_one_up_with_exception_and_rollback
         assert !Person.column_methods_hash.include?(:last_name)
 
-        e = assert_raises(StandardError) do
+        e = assert_raise(StandardError) do
           ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/broken", 100)
         end
 
@@ -947,20 +969,20 @@ if ActiveRecord::Base.connection.supports_migrations?
 
     def test_finds_migrations
       migrations = ActiveRecord::Migrator.new(:up, MIGRATIONS_ROOT + "/valid").migrations
-      [['1', 'people_have_last_names'],
-       ['2', 'we_need_reminders'],
-       ['3', 'innocent_jointable']].each_with_index do |pair, i|
-        migrations[i].version == pair.first
-        migrations[1].name    == pair.last
+
+      [[1, 'PeopleHaveLastNames'], [2, 'WeNeedReminders'], [3, 'InnocentJointable']].each_with_index do |pair, i|
+        assert_equal migrations[i].version, pair.first
+        assert_equal migrations[i].name, pair.last
       end
     end
 
     def test_finds_pending_migrations
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/interleaved/pass_2", 1)
       migrations = ActiveRecord::Migrator.new(:up, MIGRATIONS_ROOT + "/interleaved/pass_2").pending_migrations
+
       assert_equal 1, migrations.size
-      migrations[0].version == '3'
-      migrations[0].name    == 'innocent_jointable'
+      assert_equal migrations[0].version, 3
+      assert_equal migrations[0].name, 'InnocentJointable'
     end
 
     def test_only_loads_pending_migrations
@@ -1109,7 +1131,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal "hello world", Reminder.find(:first).content
 
       WeNeedReminders.down
-      assert_raises(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
+      assert_raise(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
     ensure
       ActiveRecord::Base.table_name_prefix = ''
       ActiveRecord::Base.table_name_suffix = ''
@@ -1139,13 +1161,13 @@ if ActiveRecord::Base.connection.supports_migrations?
     end
 
     def test_migrator_with_duplicates
-      assert_raises(ActiveRecord::DuplicateMigrationVersionError) do
+      assert_raise(ActiveRecord::DuplicateMigrationVersionError) do
         ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/duplicate", nil)
       end
     end
 
     def test_migrator_with_duplicate_names
-      assert_raises(ActiveRecord::DuplicateMigrationNameError, "Multiple migrations have the name Chunky") do
+      assert_raise(ActiveRecord::DuplicateMigrationNameError, "Multiple migrations have the name Chunky") do
         ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/duplicate_names", nil)
       end
     end
@@ -1161,7 +1183,7 @@ if ActiveRecord::Base.connection.supports_migrations?
 
       # table name is 29 chars, the standard sequence name will
       # be 33 chars and fail
-      assert_raises(ActiveRecord::StatementInvalid) do
+      assert_raise(ActiveRecord::StatementInvalid) do
         begin
           Person.connection.create_table :table_with_name_thats_just_ok do |t|
             t.column :foo, :string, :null => false
@@ -1188,7 +1210,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
 
       # confirm the custom sequence got dropped
-      assert_raises(ActiveRecord::StatementInvalid) do
+      assert_raise(ActiveRecord::StatementInvalid) do
         Person.connection.execute("select suitably_short_seq.nextval from dual")
       end
     end
@@ -1203,277 +1225,271 @@ if ActiveRecord::Base.connection.supports_migrations?
 
   end
   
-  uses_mocha 'Sexy migration tests' do
-    class SexyMigrationsTest < ActiveRecord::TestCase
-      def test_references_column_type_adds_id
-        with_new_table do |t|
-          t.expects(:column).with('customer_id', :integer, {})
-          t.references :customer
-        end
+  class SexyMigrationsTest < ActiveRecord::TestCase
+    def test_references_column_type_adds_id
+      with_new_table do |t|
+        t.expects(:column).with('customer_id', :integer, {})
+        t.references :customer
       end
+    end
 
-      def test_references_column_type_with_polymorphic_adds_type
-        with_new_table do |t|
-          t.expects(:column).with('taggable_type', :string, {})
-          t.expects(:column).with('taggable_id', :integer, {})
-          t.references :taggable, :polymorphic => true
-        end
+    def test_references_column_type_with_polymorphic_adds_type
+      with_new_table do |t|
+        t.expects(:column).with('taggable_type', :string, {})
+        t.expects(:column).with('taggable_id', :integer, {})
+        t.references :taggable, :polymorphic => true
       end
+    end
 
-      def test_references_column_type_with_polymorphic_and_options_null_is_false_adds_table_flag
-        with_new_table do |t|
-          t.expects(:column).with('taggable_type', :string, {:null => false})
-          t.expects(:column).with('taggable_id', :integer, {:null => false})
-          t.references :taggable, :polymorphic => true, :null => false
-        end
+    def test_references_column_type_with_polymorphic_and_options_null_is_false_adds_table_flag
+      with_new_table do |t|
+        t.expects(:column).with('taggable_type', :string, {:null => false})
+        t.expects(:column).with('taggable_id', :integer, {:null => false})
+        t.references :taggable, :polymorphic => true, :null => false
       end
+    end
 
-      def test_belongs_to_works_like_references
-        with_new_table do |t|
-          t.expects(:column).with('customer_id', :integer, {})
-          t.belongs_to :customer
-        end
+    def test_belongs_to_works_like_references
+      with_new_table do |t|
+        t.expects(:column).with('customer_id', :integer, {})
+        t.belongs_to :customer
       end
+    end
 
-      def test_timestamps_creates_updated_at_and_created_at
-        with_new_table do |t|
-          t.expects(:column).with(:created_at, :datetime, kind_of(Hash))
-          t.expects(:column).with(:updated_at, :datetime, kind_of(Hash))
-          t.timestamps
-        end
+    def test_timestamps_creates_updated_at_and_created_at
+      with_new_table do |t|
+        t.expects(:column).with(:created_at, :datetime, kind_of(Hash))
+        t.expects(:column).with(:updated_at, :datetime, kind_of(Hash))
+        t.timestamps
       end
+    end
 
-      def test_integer_creates_integer_column
-        with_new_table do |t|
-          t.expects(:column).with(:foo, 'integer', {})
-          t.expects(:column).with(:bar, 'integer', {})
-          t.integer :foo, :bar
-        end
+    def test_integer_creates_integer_column
+      with_new_table do |t|
+        t.expects(:column).with(:foo, 'integer', {})
+        t.expects(:column).with(:bar, 'integer', {})
+        t.integer :foo, :bar
       end
+    end
 
-      def test_string_creates_string_column
-        with_new_table do |t|
-          t.expects(:column).with(:foo, 'string', {})
-          t.expects(:column).with(:bar, 'string', {})
-          t.string :foo, :bar
-        end
+    def test_string_creates_string_column
+      with_new_table do |t|
+        t.expects(:column).with(:foo, 'string', {})
+        t.expects(:column).with(:bar, 'string', {})
+        t.string :foo, :bar
       end
+    end
 
-      protected
-      def with_new_table
-        Person.connection.create_table :delete_me, :force => true do |t|
-          yield t
-        end
-      ensure
-        Person.connection.drop_table :delete_me rescue nil
+    protected
+    def with_new_table
+      Person.connection.create_table :delete_me, :force => true do |t|
+        yield t
       end
+    ensure
+      Person.connection.drop_table :delete_me rescue nil
+    end
 
-    end # SexyMigrationsTest
-  end # uses_mocha
+  end # SexyMigrationsTest
 
-  uses_mocha 'ChangeTable migration tests' do
-    class ChangeTableMigrationsTest < ActiveRecord::TestCase
-      def setup
-        @connection = Person.connection
-        @connection.create_table :delete_me, :force => true do |t|
-        end
+  class ChangeTableMigrationsTest < ActiveRecord::TestCase
+    def setup
+      @connection = Person.connection
+      @connection.create_table :delete_me, :force => true do |t|
       end
+    end
 
-      def teardown
-        Person.connection.drop_table :delete_me rescue nil
-      end
+    def teardown
+      Person.connection.drop_table :delete_me rescue nil
+    end
 
-      def test_references_column_type_adds_id
-        with_change_table do |t|
-          @connection.expects(:add_column).with(:delete_me, 'customer_id', :integer, {})
-          t.references :customer
-        end
+    def test_references_column_type_adds_id
+      with_change_table do |t|
+        @connection.expects(:add_column).with(:delete_me, 'customer_id', :integer, {})
+        t.references :customer
       end
+    end
 
-      def test_remove_references_column_type_removes_id
-        with_change_table do |t|
-          @connection.expects(:remove_column).with(:delete_me, 'customer_id')
-          t.remove_references :customer
-        end
+    def test_remove_references_column_type_removes_id
+      with_change_table do |t|
+        @connection.expects(:remove_column).with(:delete_me, 'customer_id')
+        t.remove_references :customer
       end
+    end
 
-      def test_add_belongs_to_works_like_add_references
-        with_change_table do |t|
-          @connection.expects(:add_column).with(:delete_me, 'customer_id', :integer, {})
-          t.belongs_to :customer
-        end
+    def test_add_belongs_to_works_like_add_references
+      with_change_table do |t|
+        @connection.expects(:add_column).with(:delete_me, 'customer_id', :integer, {})
+        t.belongs_to :customer
       end
+    end
 
-      def test_remove_belongs_to_works_like_remove_references
-        with_change_table do |t|
-          @connection.expects(:remove_column).with(:delete_me, 'customer_id')
-          t.remove_belongs_to :customer
-        end
+    def test_remove_belongs_to_works_like_remove_references
+      with_change_table do |t|
+        @connection.expects(:remove_column).with(:delete_me, 'customer_id')
+        t.remove_belongs_to :customer
       end
+    end
 
-      def test_references_column_type_with_polymorphic_adds_type
-        with_change_table do |t|
-          @connection.expects(:add_column).with(:delete_me, 'taggable_type', :string, {})
-          @connection.expects(:add_column).with(:delete_me, 'taggable_id', :integer, {})
-          t.references :taggable, :polymorphic => true
-        end
+    def test_references_column_type_with_polymorphic_adds_type
+      with_change_table do |t|
+        @connection.expects(:add_column).with(:delete_me, 'taggable_type', :string, {})
+        @connection.expects(:add_column).with(:delete_me, 'taggable_id', :integer, {})
+        t.references :taggable, :polymorphic => true
       end
+    end
 
-      def test_remove_references_column_type_with_polymorphic_removes_type
-        with_change_table do |t|
-          @connection.expects(:remove_column).with(:delete_me, 'taggable_type')
-          @connection.expects(:remove_column).with(:delete_me, 'taggable_id')
-          t.remove_references :taggable, :polymorphic => true
-        end
+    def test_remove_references_column_type_with_polymorphic_removes_type
+      with_change_table do |t|
+        @connection.expects(:remove_column).with(:delete_me, 'taggable_type')
+        @connection.expects(:remove_column).with(:delete_me, 'taggable_id')
+        t.remove_references :taggable, :polymorphic => true
       end
+    end
 
-      def test_references_column_type_with_polymorphic_and_options_null_is_false_adds_table_flag
-        with_change_table do |t|
-          @connection.expects(:add_column).with(:delete_me, 'taggable_type', :string, {:null => false})
-          @connection.expects(:add_column).with(:delete_me, 'taggable_id', :integer, {:null => false})
-          t.references :taggable, :polymorphic => true, :null => false
-        end
+    def test_references_column_type_with_polymorphic_and_options_null_is_false_adds_table_flag
+      with_change_table do |t|
+        @connection.expects(:add_column).with(:delete_me, 'taggable_type', :string, {:null => false})
+        @connection.expects(:add_column).with(:delete_me, 'taggable_id', :integer, {:null => false})
+        t.references :taggable, :polymorphic => true, :null => false
       end
+    end
 
-      def test_remove_references_column_type_with_polymorphic_and_options_null_is_false_removes_table_flag
-        with_change_table do |t|
-          @connection.expects(:remove_column).with(:delete_me, 'taggable_type')
-          @connection.expects(:remove_column).with(:delete_me, 'taggable_id')
-          t.remove_references :taggable, :polymorphic => true, :null => false
-        end
+    def test_remove_references_column_type_with_polymorphic_and_options_null_is_false_removes_table_flag
+      with_change_table do |t|
+        @connection.expects(:remove_column).with(:delete_me, 'taggable_type')
+        @connection.expects(:remove_column).with(:delete_me, 'taggable_id')
+        t.remove_references :taggable, :polymorphic => true, :null => false
       end
+    end
 
-      def test_timestamps_creates_updated_at_and_created_at
-        with_change_table do |t|
-          @connection.expects(:add_timestamps).with(:delete_me)
-          t.timestamps
-        end
+    def test_timestamps_creates_updated_at_and_created_at
+      with_change_table do |t|
+        @connection.expects(:add_timestamps).with(:delete_me)
+        t.timestamps
       end
+    end
 
-      def test_remove_timestamps_creates_updated_at_and_created_at
-        with_change_table do |t|
-          @connection.expects(:remove_timestamps).with(:delete_me)
-          t.remove_timestamps
-        end
+    def test_remove_timestamps_creates_updated_at_and_created_at
+      with_change_table do |t|
+        @connection.expects(:remove_timestamps).with(:delete_me)
+        t.remove_timestamps
       end
+    end
 
-      def string_column
-        if current_adapter?(:PostgreSQLAdapter)
-          "character varying(255)"
-        else
-          'varchar(255)'
-        end
+    def string_column
+      if current_adapter?(:PostgreSQLAdapter)
+        "character varying(255)"
+      else
+        'varchar(255)'
       end
+    end
 
-      def integer_column
-        if current_adapter?(:MysqlAdapter)
-          'int(11)'
-        else
-          'integer'
-        end
+    def integer_column
+      if current_adapter?(:MysqlAdapter)
+        'int(11)'
+      else
+        'integer'
       end
+    end
 
-      def test_integer_creates_integer_column
-        with_change_table do |t|
-          @connection.expects(:add_column).with(:delete_me, :foo, integer_column, {})
-          @connection.expects(:add_column).with(:delete_me, :bar, integer_column, {})
-          t.integer :foo, :bar
-        end
+    def test_integer_creates_integer_column
+      with_change_table do |t|
+        @connection.expects(:add_column).with(:delete_me, :foo, integer_column, {})
+        @connection.expects(:add_column).with(:delete_me, :bar, integer_column, {})
+        t.integer :foo, :bar
       end
+    end
 
-      def test_string_creates_string_column
-        with_change_table do |t|
-          @connection.expects(:add_column).with(:delete_me, :foo, string_column, {})
-          @connection.expects(:add_column).with(:delete_me, :bar, string_column, {})
-          t.string :foo, :bar
-        end
+    def test_string_creates_string_column
+      with_change_table do |t|
+        @connection.expects(:add_column).with(:delete_me, :foo, string_column, {})
+        @connection.expects(:add_column).with(:delete_me, :bar, string_column, {})
+        t.string :foo, :bar
       end
+    end
 
-      def test_column_creates_column
-        with_change_table do |t|
-          @connection.expects(:add_column).with(:delete_me, :bar, :integer, {})
-          t.column :bar, :integer
-        end
+    def test_column_creates_column
+      with_change_table do |t|
+        @connection.expects(:add_column).with(:delete_me, :bar, :integer, {})
+        t.column :bar, :integer
       end
+    end
 
-      def test_column_creates_column_with_options
-        with_change_table do |t|
-          @connection.expects(:add_column).with(:delete_me, :bar, :integer, {:null => false})
-          t.column :bar, :integer, :null => false
-        end
+    def test_column_creates_column_with_options
+      with_change_table do |t|
+        @connection.expects(:add_column).with(:delete_me, :bar, :integer, {:null => false})
+        t.column :bar, :integer, :null => false
       end
+    end
 
-      def test_index_creates_index
-        with_change_table do |t|
-          @connection.expects(:add_index).with(:delete_me, :bar, {})
-          t.index :bar
-        end
+    def test_index_creates_index
+      with_change_table do |t|
+        @connection.expects(:add_index).with(:delete_me, :bar, {})
+        t.index :bar
       end
+    end
 
-      def test_index_creates_index_with_options
-        with_change_table do |t|
-          @connection.expects(:add_index).with(:delete_me, :bar, {:unique => true})
-          t.index :bar, :unique => true
-        end
+    def test_index_creates_index_with_options
+      with_change_table do |t|
+        @connection.expects(:add_index).with(:delete_me, :bar, {:unique => true})
+        t.index :bar, :unique => true
       end
+    end
 
-      def test_change_changes_column
-        with_change_table do |t|
-          @connection.expects(:change_column).with(:delete_me, :bar, :string, {})
-          t.change :bar, :string
-        end
+    def test_change_changes_column
+      with_change_table do |t|
+        @connection.expects(:change_column).with(:delete_me, :bar, :string, {})
+        t.change :bar, :string
       end
+    end
 
-      def test_change_changes_column_with_options
-        with_change_table do |t|
-          @connection.expects(:change_column).with(:delete_me, :bar, :string, {:null => true})
-          t.change :bar, :string, :null => true
-        end
+    def test_change_changes_column_with_options
+      with_change_table do |t|
+        @connection.expects(:change_column).with(:delete_me, :bar, :string, {:null => true})
+        t.change :bar, :string, :null => true
       end
+    end
 
-      def test_change_default_changes_column
-        with_change_table do |t|
-          @connection.expects(:change_column_default).with(:delete_me, :bar, :string)
-          t.change_default :bar, :string
-        end
+    def test_change_default_changes_column
+      with_change_table do |t|
+        @connection.expects(:change_column_default).with(:delete_me, :bar, :string)
+        t.change_default :bar, :string
       end
+    end
 
-      def test_remove_drops_single_column
-        with_change_table do |t|
-          @connection.expects(:remove_column).with(:delete_me, [:bar])
-          t.remove :bar
-        end
+    def test_remove_drops_single_column
+      with_change_table do |t|
+        @connection.expects(:remove_column).with(:delete_me, [:bar])
+        t.remove :bar
       end
+    end
 
-      def test_remove_drops_multiple_columns
-        with_change_table do |t|
-          @connection.expects(:remove_column).with(:delete_me, [:bar, :baz])
-          t.remove :bar, :baz
-        end
+    def test_remove_drops_multiple_columns
+      with_change_table do |t|
+        @connection.expects(:remove_column).with(:delete_me, [:bar, :baz])
+        t.remove :bar, :baz
       end
+    end
 
-      def test_remove_index_removes_index_with_options
-        with_change_table do |t|
-          @connection.expects(:remove_index).with(:delete_me, {:unique => true})
-          t.remove_index :unique => true
-        end
+    def test_remove_index_removes_index_with_options
+      with_change_table do |t|
+        @connection.expects(:remove_index).with(:delete_me, {:unique => true})
+        t.remove_index :unique => true
       end
+    end
 
-      def test_rename_renames_column
-        with_change_table do |t|
-          @connection.expects(:rename_column).with(:delete_me, :bar, :baz)
-          t.rename :bar, :baz
-        end
+    def test_rename_renames_column
+      with_change_table do |t|
+        @connection.expects(:rename_column).with(:delete_me, :bar, :baz)
+        t.rename :bar, :baz
       end
+    end
 
-      protected
-      def with_change_table
-        Person.connection.change_table :delete_me do |t|
-          yield t
-        end
+    protected
+    def with_change_table
+      Person.connection.change_table :delete_me do |t|
+        yield t
       end
-
-    end # ChangeTable test
-  end # uses_mocha
-
+    end
+  end
 end