activerecord 2.0.5 → 2.1.0

data/test/{reserved_word_test_mysql.rb → cases/reserved_word_test_mysql.rb}

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/abstract_unit"
+require "cases/helper"
 
 class Group < ActiveRecord::Base
   Group.table_name = 'group'
@@ -23,7 +23,7 @@ end
 
 # a suite of tests to ensure the ConnectionAdapters#MysqlAdapter can handle tables with
 # reserved word names (ie: group, order, values, etc...)
-class MysqlReservedWordTest < Test::Unit::TestCase
+class MysqlReservedWordTest < ActiveRecord::TestCase
   def setup
     @connection = ActiveRecord::Base.connection
 
@@ -141,7 +141,7 @@ class MysqlReservedWordTest < Test::Unit::TestCase
     assert_nothing_raised { Group.table_exists? }
     assert_nothing_raised { Group.columns }
   end
-  
+
   # Calculations
   def test_calculations_work_with_reserved_words
     assert_nothing_raised { Group.count }
@@ -156,8 +156,7 @@ class MysqlReservedWordTest < Test::Unit::TestCase
   private
   # custom fixture loader, uses Fixtures#create_fixtures and appends base_path to the current file's path
   def create_test_fixtures(*fixture_names)
-    fixture_path = "./test/fixtures/reserved_words"
-    Fixtures.create_fixtures(fixture_path, fixture_names)
+    Fixtures.create_fixtures(FIXTURES_ROOT + "/reserved_words", fixture_names)
   end
 
   # custom drop table, uses execute on connection to drop a table if it exists. note: escapes table_name

data/test/{schema_authorization_test_postgresql.rb → cases/schema_authorization_test_postgresql.rb}

@@ -1,9 +1,9 @@
-require 'abstract_unit'
+require "cases/helper"
 
 class SchemaThing < ActiveRecord::Base
 end
 
-class SchemaAuthorizationTest < Test::Unit::TestCase
+class SchemaAuthorizationTest < ActiveRecord::TestCase
   self.use_transactional_fixtures = false
 
   TABLE_NAME = 'schema_things'
@@ -18,7 +18,7 @@ class SchemaAuthorizationTest < Test::Unit::TestCase
     @connection.execute "SET search_path TO '$user',public"
     set_session_auth
     USERS.each do |u|
-      @connection.execute "CREATE ROLE #{u}"
+      @connection.execute "CREATE USER #{u}"
       @connection.execute "CREATE SCHEMA AUTHORIZATION #{u}"
       set_session_auth u
       @connection.execute "CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
@@ -28,11 +28,11 @@ class SchemaAuthorizationTest < Test::Unit::TestCase
   end
 
   def teardown
-    set_session_auth 
+    set_session_auth
     @connection.execute "RESET search_path"
     USERS.each do |u|
       @connection.execute "DROP SCHEMA #{u} CASCADE"
-      @connection.execute "DROP ROLE #{u}"
+      @connection.execute "DROP USER #{u}"
     end
   end
 

data/test/cases/schema_dumper_test.rb

@@ -0,0 +1,138 @@
+require "cases/helper"
+require 'active_record/schema_dumper'
+require 'stringio'
+
+
+class SchemaDumperTest < ActiveRecord::TestCase
+  def standard_dump
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = []
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    stream.string
+  end
+
+  def test_schema_dump
+    output = standard_dump
+    assert_match %r{create_table "accounts"}, output
+    assert_match %r{create_table "authors"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+  end
+
+  def test_schema_dump_excludes_sqlite_sequence
+    output = standard_dump
+    assert_no_match %r{create_table "sqlite_sequence"}, output
+  end
+
+  def assert_line_up(lines, pattern, required = false)
+    return assert(true) if lines.empty?
+    matches = lines.map { |line| line.match(pattern) }
+    assert matches.all? if required
+    matches.compact!
+    return assert(true) if matches.empty?
+    assert_equal 1, matches.map{ |match| match.offset(0).first }.uniq.length
+  end
+
+  def column_definition_lines(output = standard_dump)
+    output.scan(/^( *)create_table.*?\n(.*?)^\1end/m).map{ |m| m.last.split(/\n/) }
+  end
+
+  def test_types_line_up
+    column_definition_lines.each do |column_set|
+      next if column_set.empty?
+
+      lengths = column_set.map do |column|
+        if match = column.match(/t\.(?:integer|decimal|float|datetime|timestamp|time|date|text|binary|string|boolean)\s+"/)
+          match[0].length
+        end
+      end
+
+      assert_equal 1, lengths.uniq.length
+    end
+  end
+
+  def test_arguments_line_up
+    column_definition_lines.each do |column_set|
+      assert_line_up(column_set, /:default => /)
+      assert_line_up(column_set, /:limit => /)
+      assert_line_up(column_set, /:null => /)
+    end
+  end
+
+  def test_no_dump_errors
+    output = standard_dump
+    assert_no_match %r{\# Could not dump table}, output
+  end
+
+  def test_schema_dump_includes_not_null_columns
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.ignore_tables = [/^[^r]/]
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    output = stream.string
+    assert_match %r{:null => false}, output
+  end
+
+  def test_schema_dump_with_string_ignored_table
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.ignore_tables = ['accounts']
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    output = stream.string
+    assert_no_match %r{create_table "accounts"}, output
+    assert_match %r{create_table "authors"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+  end
+
+  def test_schema_dump_with_regexp_ignored_table
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.ignore_tables = [/^account/]
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    output = stream.string
+    assert_no_match %r{create_table "accounts"}, output
+    assert_match %r{create_table "authors"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+  end
+
+  def test_schema_dump_illegal_ignored_table_value
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = [5]
+    assert_raise(StandardError) do
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    end
+  end
+
+  if current_adapter?(:MysqlAdapter)
+    def test_schema_dump_should_not_add_default_value_for_mysql_text_field
+      output = standard_dump
+      assert_match %r{t.text\s+"body",\s+:null => false$}, output
+    end
+
+    def test_mysql_schema_dump_should_honor_nonstandard_primary_keys
+      output = standard_dump
+      match = output.match(%r{create_table "movies"(.*)do})
+      assert_not_nil(match, "nonstandardpk table not found")
+      assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
+    end
+
+    def test_schema_dump_includes_length_for_mysql_blob_and_text_fields
+      output = standard_dump
+      assert_match %r{t.binary\s+"tiny_blob",\s+:limit => 255$}, output
+      assert_match %r{t.binary\s+"normal_blob"$}, output
+      assert_match %r{t.binary\s+"medium_blob",\s+:limit => 16777215$}, output
+      assert_match %r{t.binary\s+"long_blob",\s+:limit => 2147483647$}, output
+      assert_match %r{t.text\s+"tiny_text",\s+:limit => 255$}, output
+      assert_match %r{t.text\s+"normal_text"$}, output
+      assert_match %r{t.text\s+"medium_text",\s+:limit => 16777215$}, output
+      assert_match %r{t.text\s+"long_text",\s+:limit => 2147483647$}, output
+    end
+  end
+
+  def test_schema_dump_includes_decimal_options
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = [/^[^n]/]
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    output = stream.string
+    assert_match %r{:precision => 3,[[:space:]]+:scale => 2,[[:space:]]+:default => 2.78}, output
+  end
+end

data/test/cases/schema_test_postgresql.rb

@@ -0,0 +1,102 @@
+require "cases/helper"
+
+class SchemaTest < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  SCHEMA_NAME = 'test_schema'
+  SCHEMA2_NAME = 'test_schema2'
+  TABLE_NAME = 'things'
+  INDEX_A_NAME = 'a_index_things_on_name'
+  INDEX_B_NAME = 'b_index_things_on_different_columns_in_each_schema'
+  INDEX_A_COLUMN = 'name'
+  INDEX_B_COLUMN_S1 = 'email'
+  INDEX_B_COLUMN_S2 = 'moment'
+  COLUMNS = [
+    'id integer',
+    'name character varying(50)',
+    'email character varying(50)',
+    'moment timestamp without time zone default now()'
+  ]
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
+    @connection.execute "CREATE SCHEMA #{SCHEMA2_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
+    @connection.execute "CREATE INDEX #{INDEX_A_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_A_COLUMN});"
+    @connection.execute "CREATE INDEX #{INDEX_A_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_A_COLUMN});"
+    @connection.execute "CREATE INDEX #{INDEX_B_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_B_COLUMN_S1});"
+    @connection.execute "CREATE INDEX #{INDEX_B_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_B_COLUMN_S2});"
+  end
+
+  def teardown
+    @connection.execute "DROP SCHEMA #{SCHEMA2_NAME} CASCADE"
+    @connection.execute "DROP SCHEMA #{SCHEMA_NAME} CASCADE"
+  end
+
+  def test_with_schema_prefixed_table_name
+    assert_nothing_raised do
+      assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{TABLE_NAME}")
+    end
+  end
+
+  def test_with_schema_search_path
+    assert_nothing_raised do
+      with_schema_search_path(SCHEMA_NAME) do
+        assert_equal COLUMNS, columns(TABLE_NAME)
+      end
+    end
+  end
+
+  def test_raise_on_unquoted_schema_name
+    assert_raise(ActiveRecord::StatementInvalid) do
+      with_schema_search_path '$user,public'
+    end
+  end
+
+  def test_without_schema_search_path
+    assert_raise(ActiveRecord::StatementInvalid) { columns(TABLE_NAME) }
+  end
+
+  def test_ignore_nil_schema_search_path
+    assert_nothing_raised { with_schema_search_path nil }
+  end
+
+  def test_dump_indexes_for_schema_one
+    do_dump_index_tests_for_schema(SCHEMA_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S1)
+  end
+
+  def test_dump_indexes_for_schema_two
+    do_dump_index_tests_for_schema(SCHEMA2_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S2)
+  end
+
+  private
+    def columns(table_name)
+      @connection.send(:column_definitions, table_name).map do |name, type, default|
+        "#{name} #{type}" + (default ? " default #{default}" : '')
+      end
+    end
+
+    def with_schema_search_path(schema_search_path)
+      @connection.schema_search_path = schema_search_path
+      yield if block_given?
+    ensure
+      @connection.schema_search_path = "'$user', public"
+    end
+
+    def do_dump_index_tests_for_schema(this_schema_name, first_index_column_name, second_index_column_name)
+      with_schema_search_path(this_schema_name) do
+        indexes = @connection.indexes(TABLE_NAME).sort_by {|i| i.name}
+        assert_equal 2,indexes.size
+
+        do_dump_index_assertions_for_one_index(indexes[0], INDEX_A_NAME, first_index_column_name)
+        do_dump_index_assertions_for_one_index(indexes[1], INDEX_B_NAME, second_index_column_name)
+      end
+    end
+
+    def do_dump_index_assertions_for_one_index(this_index, this_index_name, this_index_column)
+      assert_equal TABLE_NAME, this_index.table
+      assert_equal 1, this_index.columns.size
+      assert_equal this_index_column, this_index.columns[0]
+      assert_equal this_index_name, this_index.name
+    end
+end

data/test/{serialization_test.rb → cases/serialization_test.rb}

@@ -1,9 +1,9 @@
-require 'abstract_unit'
-require 'fixtures/contact'
+require "cases/helper"
+require 'models/contact'
 
-class SerializationTest < Test::Unit::TestCase
+class SerializationTest < ActiveRecord::TestCase
   FORMATS = [ :xml, :json ]
-  
+
   def setup
     @contact_attributes = {
       :name        => 'aaron stack',
@@ -16,12 +16,12 @@ class SerializationTest < Test::Unit::TestCase
 
     @contact = Contact.new(@contact_attributes)
   end
-  
+
   def test_serialize_should_be_reversible
     for format in FORMATS
       @serialized = Contact.new.send("to_#{format}")
       contact = Contact.new.send("from_#{format}", @serialized)
-      
+
       assert_equal @contact_attributes.keys.collect(&:to_s).sort, contact.attributes.keys.collect(&:to_s).sort, "For #{format}"
     end
   end
@@ -44,4 +44,4 @@ class SerializationTest < Test::Unit::TestCase
       assert_equal @contact_attributes[:awesome], contact.awesome, "For #{format}"
     end
   end
-end
+end

data/test/{synonym_test_oracle.rb → cases/synonym_test_oracle.rb}

@@ -1,17 +1,17 @@
-require 'abstract_unit'
-require 'fixtures/topic'
-require 'fixtures/subject'
+require "cases/helper"
+require 'models/topic'
+require 'models/subject'
 
 # confirm that synonyms work just like tables; in this case
 # the "subjects" table in Oracle (defined in oci.sql) is just
 # a synonym to the "topics" table
 
-class TestOracleSynonym < Test::Unit::TestCase
+class TestOracleSynonym < ActiveRecord::TestCase
 
   def test_oracle_synonym
     topic = Topic.new
     subject = Subject.new
     assert_equal(topic.attributes, subject.attributes)
   end
-  
+
 end

data/test/{table_name_test_sqlserver.rb → cases/table_name_test_sqlserver.rb}

@@ -1,12 +1,12 @@
-require 'abstract_unit'
-require "#{File.dirname(__FILE__)}/../lib/active_record/schema"
+require "cases/helper"
+require 'active_record/schema'
 
 if ActiveRecord::Base.connection.supports_migrations?
   class Order < ActiveRecord::Base
     self.table_name = '[order]'
   end
 
-  class TableNameTest < Test::Unit::TestCase
+  class TableNameTest < ActiveRecord::TestCase
     self.use_transactional_fixtures = false
 
     # Ensures Model.columns works when using SQLServer escape characters.

data/test/{threaded_connections_test.rb → cases/threaded_connections_test.rb}

@@ -1,9 +1,9 @@
-require 'abstract_unit'
-require 'fixtures/topic'
-require 'fixtures/reply'
+require "cases/helper"
+require 'models/topic'
+require 'models/reply'
 
 unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name
-  class ThreadedConnectionsTest < Test::Unit::TestCase
+  class ThreadedConnectionsTest < ActiveRecord::TestCase
     self.use_transactional_fixtures = false
 
     fixtures :topics
@@ -13,7 +13,7 @@ unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name
     @connections = []
     @allow_concurrency = ActiveRecord::Base.allow_concurrency
   end
-  
+
   def teardown
     # clear the connection cache
     ActiveRecord::Base.send(:clear_all_cached_connections!)
@@ -22,11 +22,11 @@ unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name
     # reestablish old connection
     ActiveRecord::Base.establish_connection(@connection)
   end
-  
+
   def gather_connections(use_threaded_connections)
     ActiveRecord::Base.allow_concurrency = use_threaded_connections
     ActiveRecord::Base.establish_connection(@connection)
-    
+
       5.times do
         Thread.new do
           Topic.find :first

data/test/{transactions_test.rb → cases/transactions_test.rb}

@@ -1,9 +1,9 @@
-require 'abstract_unit'
-require 'fixtures/topic'
-require 'fixtures/reply'
-require 'fixtures/developer'
+require "cases/helper"
+require 'models/topic'
+require 'models/reply'
+require 'models/developer'
 
-class TransactionTest < Test::Unit::TestCase
+class TransactionTest < ActiveRecord::TestCase
   self.use_transactional_fixtures = false
   fixtures :topics, :developers
 
@@ -179,6 +179,32 @@ class TransactionTest < Test::Unit::TestCase
     end
   end
 
+  def test_sqlite_add_column_in_transaction_raises_statement_invalid
+    return true unless current_adapter?(:SQLite3Adapter, :SQLiteAdapter)
+
+    # Test first if column creation/deletion works correctly when no
+    # transaction is in place.
+    #
+    # We go back to the connection for the column queries because
+    # Topic.columns is cached and won't report changes to the DB
+    
+    assert_nothing_raised do
+      Topic.reset_column_information
+      Topic.connection.add_column('topics', 'stuff', :string)
+      assert Topic.column_names.include?('stuff')
+      
+      Topic.reset_column_information
+      Topic.connection.remove_column('topics', 'stuff')
+      assert !Topic.column_names.include?('stuff')
+    end
+
+    # Test now inside a transaction: add_column should raise a StatementInvalid
+    Topic.transaction do
+      assert_raises(ActiveRecord::StatementInvalid) { Topic.connection.add_column('topics', 'stuff', :string) }
+      raise ActiveRecord::Rollback
+    end
+  end
+
   private
     def add_exception_raising_after_save_callback_to_topic
       Topic.class_eval { def after_save() raise "Make the transaction rollback" end }