activerecord 2.3.18 → 3.2.22

data/test/cases/xml_serialization_test.rb

@@ -1,240 +0,0 @@
-require "cases/helper"
-require 'models/contact'
-require 'models/post'
-require 'models/author'
-require 'models/tagging'
-require 'models/comment'
-require 'models/company_in_module'
-
-class XmlSerializationTest < ActiveRecord::TestCase
-  def test_should_serialize_default_root
-    @xml = Contact.new.to_xml
-    assert_match %r{^<contact>},  @xml
-    assert_match %r{</contact>$}, @xml
-  end
-
-  def test_should_serialize_default_root_with_namespace
-    @xml = Contact.new.to_xml :namespace=>"http://xml.rubyonrails.org/contact"
-    assert_match %r{^<contact xmlns="http://xml.rubyonrails.org/contact">},  @xml
-    assert_match %r{</contact>$}, @xml
-  end
-
-  def test_should_serialize_custom_root
-    @xml = Contact.new.to_xml :root => 'xml_contact'
-    assert_match %r{^<xml-contact>},  @xml
-    assert_match %r{</xml-contact>$}, @xml
-  end
-
-  def test_should_allow_undasherized_tags
-    @xml = Contact.new.to_xml :root => 'xml_contact', :dasherize => false
-    assert_match %r{^<xml_contact>},  @xml
-    assert_match %r{</xml_contact>$}, @xml
-    assert_match %r{<created_at},     @xml
-  end
-
-  def test_should_allow_camelized_tags
-    @xml = Contact.new.to_xml :root => 'xml_contact', :camelize => true
-    assert_match %r{^<XmlContact>},  @xml
-    assert_match %r{</XmlContact>$}, @xml
-    assert_match %r{<CreatedAt},    @xml
-  end
-
-  def test_should_allow_skipped_types
-    @xml = Contact.new(:age => 25).to_xml :skip_types => true
-    assert %r{<age>25</age>}.match(@xml)
-  end
-
-  def test_should_include_yielded_additions
-    @xml = Contact.new.to_xml do |xml|
-      xml.creator "David"
-    end
-    assert_match %r{<creator>David</creator>}, @xml
-  end
-end
-
-class DefaultXmlSerializationTest < ActiveRecord::TestCase
-  def setup
-    @xml = Contact.new(:name => 'aaron stack', :age => 25, :avatar => 'binarydata', :created_at => Time.utc(2006, 8, 1), :awesome => false, :preferences => { :gem => 'ruby' }).to_xml
-  end
-
-  def test_should_serialize_string
-    assert_match %r{<name>aaron stack</name>},     @xml
-  end
-
-  def test_should_serialize_integer
-    assert_match %r{<age type="integer">25</age>}, @xml
-  end
-
-  def test_should_serialize_binary
-    assert_match %r{YmluYXJ5ZGF0YQ==\n</avatar>},    @xml
-    assert_match %r{<avatar(.*)(type="binary")},     @xml
-    assert_match %r{<avatar(.*)(encoding="base64")}, @xml
-  end
-
-  def test_should_serialize_datetime
-    assert_match %r{<created-at type=\"datetime\">2006-08-01T00:00:00Z</created-at>}, @xml
-  end
-
-  def test_should_serialize_boolean
-    assert_match %r{<awesome type=\"boolean\">false</awesome>}, @xml
-  end
-
-  def test_should_serialize_yaml
-    assert_match %r{<preferences type=\"yaml\">--- \n:gem: ruby\n</preferences>}, @xml
-  end
-end
-
-class NilXmlSerializationTest < ActiveRecord::TestCase
-  def setup
-    @xml = Contact.new.to_xml(:root => 'xml_contact')
-  end
-
-  def test_should_serialize_string
-    assert_match %r{<name nil="true"></name>},     @xml
-  end
-
-  def test_should_serialize_integer
-    assert %r{<age (.*)></age>}.match(@xml)
-    attributes = $1
-    assert_match %r{nil="true"}, attributes
-    assert_match %r{type="integer"}, attributes
-  end
-
-  def test_should_serialize_binary
-    assert %r{<avatar (.*)></avatar>}.match(@xml)
-    attributes = $1
-    assert_match %r{type="binary"}, attributes
-    assert_match %r{encoding="base64"}, attributes
-    assert_match %r{nil="true"}, attributes
-  end
-
-  def test_should_serialize_datetime
-    assert %r{<created-at (.*)></created-at>}.match(@xml)
-    attributes = $1
-    assert_match %r{nil="true"}, attributes
-    assert_match %r{type="datetime"}, attributes
-  end
-
-  def test_should_serialize_boolean
-    assert %r{<awesome (.*)></awesome>}.match(@xml)
-    attributes = $1
-    assert_match %r{type="boolean"}, attributes
-    assert_match %r{nil="true"}, attributes
-  end
-
-  def test_should_serialize_yaml
-    assert %r{<preferences(.*)></preferences>}.match(@xml)
-    attributes = $1
-    assert_match %r{type="yaml"}, attributes
-    assert_match %r{nil="true"}, attributes
-  end
-end
-
-class DatabaseConnectedXmlModuleSerializationTest < ActiveRecord::TestCase
-
-  fixtures :projects, :developers, :developers_projects
-
-  def test_module
-    project = MyApplication::Business::Project.find :first
-    xml = project.to_xml
-    assert_match %r{<my-application-business-project>}, xml
-    assert_match %r{</my-application-business-project>}, xml
-  end
-
-  def test_module_with_include
-    project = MyApplication::Business::Project.find :first
-    xml = project.to_xml :include => :developers
-    assert_match %r{<developer type="MyApplication::Business::Developer">}, xml
-    assert_match %r{</developer>}, xml
-  end
-end
-
-class DatabaseConnectedXmlSerializationTest < ActiveRecord::TestCase
-  fixtures :authors, :posts
-  # to_xml used to mess with the hash the user provided which
-  # caused the builder to be reused.  This meant the document kept
-  # getting appended to.
-  def test_passing_hash_shouldnt_reuse_builder
-    options = {:include=>:posts}
-    david = authors(:david)
-    first_xml_size = david.to_xml(options).size
-    second_xml_size = david.to_xml(options).size
-    assert_equal first_xml_size, second_xml_size
-  end
-
-  def test_include_uses_association_name
-    xml = authors(:david).to_xml :include=>:hello_posts, :indent => 0
-    assert_match %r{<hello-posts type="array">}, xml
-    assert_match %r{<hello-post type="Post">}, xml
-    assert_match %r{<hello-post type="StiPost">}, xml
-  end
-
-  def test_included_associations_should_skip_types
-    xml = authors(:david).to_xml :include=>:hello_posts, :indent => 0, :skip_types => true
-    assert_match %r{<hello-posts>}, xml
-    assert_match %r{<hello-post>}, xml
-    assert_match %r{<hello-post>}, xml
-  end
-
-  def test_methods_are_called_on_object
-    xml = authors(:david).to_xml :methods => :label, :indent => 0
-    assert_match %r{<label>.*</label>}, xml
-  end
-
-  def test_should_not_call_methods_on_associations_that_dont_respond
-    xml = authors(:david).to_xml :include=>:hello_posts, :methods => :label, :indent => 2
-    assert !authors(:david).hello_posts.first.respond_to?(:label)
-    assert_match %r{^  <label>.*</label>}, xml
-    assert_no_match %r{^      <label>}, xml
-  end
-
-  def test_procs_are_called_on_object
-    proc = Proc.new { |options| options[:builder].tag!('nationality', 'Danish') }
-    xml = authors(:david).to_xml(:procs => [ proc ])
-    assert_match %r{<nationality>Danish</nationality>}, xml
-  end
-
-  def test_top_level_procs_arent_applied_to_associations
-    author_proc = Proc.new { |options| options[:builder].tag!('nationality', 'Danish') }
-    xml = authors(:david).to_xml(:procs => [ author_proc ], :include => :posts, :indent => 2)
-
-    assert_match %r{^  <nationality>Danish</nationality>}, xml
-    assert_no_match %r{^ {6}<nationality>Danish</nationality>}, xml
-  end
-
-  def test_procs_on_included_associations_are_called
-    posts_proc = Proc.new { |options| options[:builder].tag!('copyright', 'DHH') }
-    xml = authors(:david).to_xml(
-      :indent => 2,
-      :include => {
-        :posts => { :procs => [ posts_proc ] }
-      }
-    )
-
-    assert_no_match %r{^  <copyright>DHH</copyright>}, xml
-    assert_match %r{^ {6}<copyright>DHH</copyright>}, xml
-  end
-
-  def test_should_include_empty_has_many_as_empty_array
-    authors(:david).posts.delete_all
-    xml = authors(:david).to_xml :include=>:posts, :indent => 2
-
-    assert_equal [], Hash.from_xml(xml)['author']['posts']
-    assert_match %r{^  <posts type="array"/>}, xml
-  end
-
-  def test_should_has_many_array_elements_should_include_type_when_different_from_guessed_value
-    xml = authors(:david).to_xml :include=>:posts_with_comments, :indent => 2
-
-    assert Hash.from_xml(xml)
-    assert_match %r{^  <posts-with-comments type="array">}, xml
-    assert_match %r{^    <posts-with-comment type="Post">}, xml
-    assert_match %r{^    <posts-with-comment type="StiPost">}, xml
-
-    types = Hash.from_xml(xml)['author']['posts_with_comments'].collect {|t| t['type'] }
-    assert types.include?('SpecialPost')
-    assert types.include?('Post')
-    assert types.include?('StiPost')
-  end
-
-end

data/test/cases/yaml_serialization_test.rb

@@ -1,11 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-
-class YamlSerializationTest < ActiveRecord::TestCase
-  def test_to_yaml_with_time_with_zone_should_not_raise_exception
-    Time.zone = ActiveSupport::TimeZone["Pacific Time (US & Canada)"]
-    ActiveRecord::Base.time_zone_aware_attributes = true
-    topic = Topic.new(:written_on => DateTime.now)
-    assert_nothing_raised { topic.to_yaml }
-  end
-end

data/test/config.rb

@@ -1,5 +0,0 @@
-TEST_ROOT       = File.expand_path(File.dirname(__FILE__))
-ASSETS_ROOT     = TEST_ROOT + "/assets"
-FIXTURES_ROOT   = TEST_ROOT + "/fixtures"
-MIGRATIONS_ROOT = TEST_ROOT + "/migrations"
-SCHEMA_ROOT     = TEST_ROOT + "/schema"

data/test/connections/jdbc_jdbcderby/connection.rb

@@ -1,18 +0,0 @@
-print "Using Derby via JRuby, activerecord-jdbc-adapter and activerecord-jdbcderby-adapter\n"
-require_dependency 'models/course'
-require 'logger'
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter  => 'jdbcderby',
-    :database => 'activerecord_unittest'
-  },
-  'arunit2' => {
-    :adapter  => 'jdbcderby',
-    :database => 'activerecord_unittest2'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'

data/test/connections/jdbc_jdbch2/connection.rb

@@ -1,18 +0,0 @@
-print "Using H2 via JRuby, activerecord-jdbc-adapter and activerecord-jdbch2-adapter\n"
-require_dependency 'models/course'
-require 'logger'
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter  => 'jdbch2',
-    :database => 'activerecord_unittest'
-  },
-  'arunit2' => {
-    :adapter  => 'jdbch2',
-    :database => 'activerecord_unittest2'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'

data/test/connections/jdbc_jdbchsqldb/connection.rb

@@ -1,18 +0,0 @@
-print "Using HSQLDB via JRuby, activerecord-jdbc-adapter and activerecord-jdbchsqldb-adapter\n"
-require_dependency 'models/course'
-require 'logger'
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter  => 'jdbchsqldb',
-    :database => 'activerecord_unittest'
-  },
-  'arunit2' => {
-    :adapter  => 'jdbchsqldb',
-    :database => 'activerecord_unittest2'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'

data/test/connections/jdbc_jdbcmysql/connection.rb

@@ -1,26 +0,0 @@
-print "Using MySQL via JRuby, activerecord-jdbc-adapter and activerecord-jdbcmysql-adapter\n"
-require_dependency 'models/course'
-require 'logger'
-
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-# GRANT ALL PRIVILEGES ON activerecord_unittest.* to 'rails'@'localhost';
-# GRANT ALL PRIVILEGES ON activerecord_unittest2.* to 'rails'@'localhost';
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter  => 'jdbcmysql',
-    :username => 'rails',
-    :encoding => 'utf8',
-    :database => 'activerecord_unittest',
-  },
-  'arunit2' => {
-    :adapter  => 'jdbcmysql',
-    :username => 'rails',
-    :database => 'activerecord_unittest2'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'
-

data/test/connections/jdbc_jdbcpostgresql/connection.rb

@@ -1,26 +0,0 @@
-print "Using Postgrsql via JRuby, activerecord-jdbc-adapter and activerecord-postgresql-adapter\n"
-require_dependency 'models/course'
-require 'logger'
-
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-# createuser rails --createdb --no-superuser --no-createrole
-# createdb -O rails activerecord_unittest
-# createdb -O rails activerecord_unittest2
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter  => 'jdbcpostgresql',
-    :username => ENV['USER'] || 'rails',
-    :database => 'activerecord_unittest'
-  },
-  'arunit2' => {
-    :adapter  => 'jdbcpostgresql',
-    :username => ENV['USER'] || 'rails',
-    :database => 'activerecord_unittest2'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'
-

data/test/connections/jdbc_jdbcsqlite3/connection.rb

@@ -1,25 +0,0 @@
-print "Using SQLite3 via JRuby, activerecord-jdbc-adapter and activerecord-jdbcsqlite3-adapter\n"
-require_dependency 'models/course'
-require 'logger'
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-class SqliteError < StandardError
-end
-
-BASE_DIR = FIXTURES_ROOT
-sqlite_test_db  = "#{BASE_DIR}/fixture_database.sqlite3"
-sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite3"
-
-def make_connection(clazz, db_file)
-  ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'jdbcsqlite3', :database => db_file, :timeout => 5000 } }
-  unless File.exist?(db_file)
-    puts "SQLite3 database not found at #{db_file}. Rebuilding it."
-    sqlite_command = %Q{sqlite3 "#{db_file}" "create table a (a integer); drop table a;"}
-    puts "Executing '#{sqlite_command}'"
-    raise SqliteError.new("Seems that there is no sqlite3 executable available") unless system(sqlite_command)
-  end
-  clazz.establish_connection(clazz.name)
-end
-
-make_connection(ActiveRecord::Base, sqlite_test_db)
-make_connection(Course, sqlite_test_db2)

data/test/connections/native_db2/connection.rb

@@ -1,25 +0,0 @@
-print "Using native DB2\n"
-require_dependency 'models/course'
-require 'logger'
-
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter => 'db2',
-    :host => 'localhost',
-    :username => 'arunit',
-    :password => 'arunit',
-    :database => 'arunit'
-  },
-  'arunit2' => {
-    :adapter => 'db2',
-    :host => 'localhost',
-    :username => 'arunit',
-    :password => 'arunit',
-    :database => 'arunit2'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'

data/test/connections/native_firebird/connection.rb

@@ -1,26 +0,0 @@
-print "Using native Firebird\n"
-require_dependency 'models/course'
-require 'logger'
-
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter => 'firebird',
-    :host => 'localhost',
-    :username => 'rails',
-    :password => 'rails',
-    :database => 'activerecord_unittest',
-    :charset => 'UTF8'
-  },
-  'arunit2' => {
-    :adapter => 'firebird',
-    :host => 'localhost',
-    :username => 'rails',
-    :password => 'rails',
-    :database => 'activerecord_unittest2'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'

data/test/connections/native_frontbase/connection.rb

@@ -1,27 +0,0 @@
-puts 'Using native Frontbase'
-require_dependency 'models/course'
-require 'logger'
-
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter => 'frontbase',
-    :host => 'localhost',
-    :username => 'rails',
-    :password => '',
-    :database => 'activerecord_unittest',
-    :session_name => "unittest-#{$$}"
-  },
-  'arunit2' => {
-    :adapter => 'frontbase',
-    :host => 'localhost',
-    :username => 'rails',
-    :password => '',
-    :database => 'activerecord_unittest2',
-    :session_name => "unittest-#{$$}"
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'

data/test/connections/native_mysql/connection.rb

@@ -1,25 +0,0 @@
-print "Using native MySQL\n"
-require_dependency 'models/course'
-require 'logger'
-
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-# GRANT ALL PRIVILEGES ON activerecord_unittest.* to 'rails'@'localhost';
-# GRANT ALL PRIVILEGES ON activerecord_unittest2.* to 'rails'@'localhost';
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter  => 'mysql',
-    :username => 'rails',
-    :encoding => 'utf8',
-    :database => 'activerecord_unittest',
-  },
-  'arunit2' => {
-    :adapter  => 'mysql',
-    :username => 'rails',
-    :database => 'activerecord_unittest2'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'

data/test/connections/native_openbase/connection.rb

@@ -1,21 +0,0 @@
-print "Using native OpenBase\n"
-require_dependency 'models/course'
-require 'logger'
-
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter  => 'openbase',
-    :username => 'admin',
-    :database => 'activerecord_unittest',
-  },
-  'arunit2' => {
-    :adapter  => 'openbase',
-    :username => 'admin',
-    :database => 'activerecord_unittest2'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'

data/test/connections/native_oracle/connection.rb

@@ -1,27 +0,0 @@
-print "Using Oracle\n"
-require_dependency 'models/course'
-require 'logger'
-
-ActiveRecord::Base.logger = Logger.new STDOUT
-ActiveRecord::Base.logger.level = Logger::WARN
-
-# Set these to your database connection strings
-db = ENV['ARUNIT_DB'] || 'activerecord_unittest'
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter  => 'oracle',
-    :username => 'arunit',
-    :password => 'arunit',
-    :database => db,
-  },
-  'arunit2' => {
-    :adapter  => 'oracle',
-    :username => 'arunit2',
-    :password => 'arunit2',
-    :database => db
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'

data/test/connections/native_postgresql/connection.rb

@@ -1,21 +0,0 @@
-print "Using native PostgreSQL\n"
-require_dependency 'models/course'
-require 'logger'
-
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter  => 'postgresql',
-    :database => 'activerecord_unittest',
-    :min_messages => 'warning'
-  },
-  'arunit2' => {
-    :adapter  => 'postgresql',
-    :database => 'activerecord_unittest2',
-    :min_messages => 'warning'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'

data/test/connections/native_sqlite/connection.rb

@@ -1,25 +0,0 @@
-print "Using native SQlite\n"
-require_dependency 'models/course'
-require 'logger'
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-class SqliteError < StandardError
-end
-
-BASE_DIR = FIXTURES_ROOT
-sqlite_test_db  = "#{BASE_DIR}/fixture_database.sqlite"
-sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite"
-
-def make_connection(clazz, db_file)
-  ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'sqlite', :database => db_file } }
-  unless File.exist?(db_file)
-    puts "SQLite database not found at #{db_file}. Rebuilding it."
-    sqlite_command = %Q{sqlite "#{db_file}" "create table a (a integer); drop table a;"}
-    puts "Executing '#{sqlite_command}'"
-    raise SqliteError.new("Seems that there is no sqlite executable available") unless system(sqlite_command)
-  end
-  clazz.establish_connection(clazz.name)
-end
-
-make_connection(ActiveRecord::Base, sqlite_test_db)
-make_connection(Course, sqlite_test_db2)

data/test/connections/native_sqlite3/connection.rb

@@ -1,25 +0,0 @@
-print "Using native SQLite3\n"
-require_dependency 'models/course'
-require 'logger'
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-class SqliteError < StandardError
-end
-
-BASE_DIR = FIXTURES_ROOT
-sqlite_test_db  = "#{BASE_DIR}/fixture_database.sqlite3"
-sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite3"
-
-def make_connection(clazz, db_file)
-  ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'sqlite3', :database => db_file, :timeout => 5000 } }
-  unless File.exist?(db_file)
-    puts "SQLite3 database not found at #{db_file}. Rebuilding it."
-    sqlite_command = %Q{sqlite3 "#{db_file}" "create table a (a integer); drop table a;"}
-    puts "Executing '#{sqlite_command}'"
-    raise SqliteError.new("Seems that there is no sqlite3 executable available") unless system(sqlite_command)
-  end
-  clazz.establish_connection(clazz.name)
-end
-
-make_connection(ActiveRecord::Base, sqlite_test_db)
-make_connection(Course, sqlite_test_db2)

data/test/connections/native_sqlite3/in_memory_connection.rb

@@ -1,18 +0,0 @@
-print "Using native SQLite3\n"
-require_dependency 'models/course'
-require 'logger'
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-class SqliteError < StandardError
-end
-
-def make_connection(clazz, db_definitions_file)
-  clazz.establish_connection(:adapter => 'sqlite3', :database  => ':memory:')
-  File.read(SCHEMA_ROOT + "/#{db_definitions_file}").split(';').each do |command|
-    clazz.connection.execute(command) unless command.strip.empty?
-  end
-end
-
-make_connection(ActiveRecord::Base, 'sqlite.sql')
-make_connection(Course, 'sqlite2.sql')
-load(SCHEMA_ROOT + "/schema.rb")

data/test/connections/native_sybase/connection.rb

@@ -1,23 +0,0 @@
-print "Using native Sybase Open Client\n"
-require_dependency 'models/course'
-require 'logger'
-
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-ActiveRecord::Base.configurations = {
-  'arunit' => {
-    :adapter  => 'sybase',
-    :host     => 'database_ASE',
-    :username => 'sa',
-    :database => 'activerecord_unittest'
-  },
-  'arunit2' => {
-    :adapter  => 'sybase',
-    :host     => 'database_ASE',
-    :username => 'sa',
-    :database => 'activerecord_unittest2'
-  }
-}
-
-ActiveRecord::Base.establish_connection 'arunit'
-Course.establish_connection 'arunit2'