activerecord_authorails 1.0.0

data/test/class_inheritable_attributes_test.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require 'abstract_unit'
+require 'active_support/core_ext/class/inheritable_attributes'
+
+class A
+  include ClassInheritableAttributes
+end
+
+class B < A
+  write_inheritable_array "first", [ :one, :two ]
+end
+
+class C < A
+  write_inheritable_array "first", [ :three ]
+end
+
+class D < B
+  write_inheritable_array "first", [ :four ]
+end
+
+
+class ClassInheritableAttributesTest < Test::Unit::TestCase
+  def test_first_level
+    assert_equal [ :one, :two ], B.read_inheritable_attribute("first")
+    assert_equal [ :three ], C.read_inheritable_attribute("first")
+  end
+  
+  def test_second_level
+    assert_equal [ :one, :two, :four ], D.read_inheritable_attribute("first")
+    assert_equal [ :one, :two ], B.read_inheritable_attribute("first")
+  end
+end

data/test/column_alias_test.rb

@@ -0,0 +1,17 @@
+require 'abstract_unit'
+require 'fixtures/topic'
+
+class TestColumnAlias < Test::Unit::TestCase
+  fixtures :topics
+
+  QUERY = if 'Oracle' == ActiveRecord::Base.connection.adapter_name
+            'SELECT id AS pk FROM topics WHERE ROWNUM < 2'
+          else
+            'SELECT id AS pk FROM topics'
+          end
+
+  def test_column_alias
+    records = Topic.connection.select_all(QUERY)
+    assert_equal 'pk', records[0].keys[0]
+  end
+end

data/test/connection_test_firebird.rb

@@ -0,0 +1,8 @@
+require 'abstract_unit'
+
+class ConnectionTest < Test::Unit::TestCase
+  def test_charset_properly_set
+    fb_conn = ActiveRecord::Base.connection.instance_variable_get(:@connection)
+    assert_equal 'UTF8', fb_conn.database.character_set
+  end
+end

data/test/connections/native_db2/connection.rb

@@ -0,0 +1,25 @@
+print "Using native DB2\n"
+require_dependency 'fixtures/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

@@ -0,0 +1,26 @@
+print "Using native Firebird\n"
+require_dependency 'fixtures/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

@@ -0,0 +1,27 @@
+puts 'Using native Frontbase'
+require_dependency 'fixtures/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

@@ -0,0 +1,24 @@
+print "Using native MySQL\n"
+require_dependency 'fixtures/course'
+require 'logger'
+
+RAILS_DEFAULT_LOGGER = Logger.new('debug.log')
+RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+ActiveRecord::Base.logger = RAILS_DEFAULT_LOGGER
+
+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

@@ -0,0 +1,21 @@
+print "Using native OpenBase\n"
+require_dependency 'fixtures/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

@@ -0,0 +1,27 @@
+print "Using Oracle\n"
+require_dependency 'fixtures/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

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

data/test/connections/native_sqlite/connection.rb

@@ -0,0 +1,34 @@
+print "Using native SQlite\n"
+require_dependency 'fixtures/course'
+require 'logger'
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+class SqliteError < StandardError
+end
+
+BASE_DIR = File.expand_path(File.dirname(__FILE__) + '/../../fixtures')
+sqlite_test_db  = "#{BASE_DIR}/fixture_database.sqlite"
+sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite"
+
+def make_connection(clazz, db_file, db_definitions_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)
+    clazz.establish_connection(clazz.name)
+    script = File.read("#{BASE_DIR}/db_definitions/#{db_definitions_file}")
+    # SQLite-Ruby has problems with semi-colon separated commands, so split and execute one at a time
+    script.split(';').each do
+      |command|
+      clazz.connection.execute(command) unless command.strip.empty?
+    end
+  else
+    clazz.establish_connection(clazz.name)
+  end
+end
+
+make_connection(ActiveRecord::Base, sqlite_test_db, 'sqlite.sql')
+make_connection(Course, sqlite_test_db2, 'sqlite2.sql')
+load(File.join(BASE_DIR, 'db_definitions', 'schema.rb'))

data/test/connections/native_sqlite3/connection.rb

@@ -0,0 +1,34 @@
+print "Using native SQLite3\n"
+require_dependency 'fixtures/course'
+require 'logger'
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+class SqliteError < StandardError
+end
+
+BASE_DIR = File.expand_path(File.dirname(__FILE__) + '/../../fixtures')
+sqlite_test_db  = "#{BASE_DIR}/fixture_database.sqlite3"
+sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite3"
+
+def make_connection(clazz, db_file, db_definitions_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)
+    clazz.establish_connection(clazz.name)
+    script = File.read("#{BASE_DIR}/db_definitions/#{db_definitions_file}")
+    # SQLite-Ruby has problems with semi-colon separated commands, so split and execute one at a time
+    script.split(';').each do
+      |command|
+      clazz.connection.execute(command) unless command.strip.empty?
+    end
+  else
+    clazz.establish_connection(clazz.name)
+  end
+end
+
+make_connection(ActiveRecord::Base, sqlite_test_db, 'sqlite.sql')
+make_connection(Course, sqlite_test_db2, 'sqlite2.sql')
+load(File.join(BASE_DIR, 'db_definitions', 'schema.rb'))

data/test/connections/native_sqlite3/in_memory_connection.rb

@@ -0,0 +1,18 @@
+print "Using native SQLite3\n"
+require_dependency 'fixtures/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("#{File.dirname(__FILE__)}/../../fixtures/db_definitions/#{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("#{File.dirname(__FILE__)}/../../fixtures/db_definitions/schema.rb"))

data/test/connections/native_sqlserver/connection.rb

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

data/test/connections/native_sqlserver_odbc/connection.rb

@@ -0,0 +1,25 @@
+print "Using native SQLServer via ODBC\n"
+require_dependency 'fixtures/course'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter  => 'sqlserver',
+    :mode     => 'ODBC',
+    :host     => 'localhost',
+    :username => 'sa',
+    :dsn => 'activerecord_unittest'
+  },
+  'arunit2' => {
+    :adapter  => 'sqlserver',
+    :mode     => 'ODBC',
+    :host     => 'localhost',
+    :username => 'sa',
+    :dsn => 'activerecord_unittest2'
+  }
+}
+
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

data/test/connections/native_sybase/connection.rb

@@ -0,0 +1,23 @@
+print "Using native Sybase Open Client\n"
+require_dependency 'fixtures/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'

data/test/copy_table_sqlite.rb

@@ -0,0 +1,64 @@
+require 'abstract_unit'
+
+class CopyTableTest < Test::Unit::TestCase
+  fixtures :companies, :comments
+  
+  def setup
+    @connection = ActiveRecord::Base.connection
+    class << @connection
+      public :copy_table, :table_structure, :indexes
+    end
+  end
+  
+  def test_copy_table(from = 'companies', to = 'companies2', options = {})
+    assert_nothing_raised {copy_table(from, to, options)}
+    assert_equal row_count(from), row_count(to)
+      
+    if block_given?
+      yield from, to, options
+    else
+      assert_equal column_names(from), column_names(to)
+    end
+    
+    @connection.drop_table(to) rescue nil
+  end
+  
+  def test_copy_table_renaming_column
+    test_copy_table('companies', 'companies2', 
+        :rename => {'client_of' => 'fan_of'}) do |from, to, options|
+      assert_equal column_values(from, 'client_of').compact.sort, 
+                   column_values(to, 'fan_of').compact.sort
+    end
+  end
+  
+  def test_copy_table_with_index
+    test_copy_table('comments', 'comments_with_index') do
+      @connection.add_index('comments_with_index', ['post_id', 'type'])
+      test_copy_table('comments_with_index', 'comments_with_index2') do
+        assert_equal table_indexes_without_name('comments_with_index'),
+                     table_indexes_without_name('comments_with_index2')
+      end
+    end
+  end
+  
+protected
+  def copy_table(from, to, options = {})
+    @connection.copy_table(from, to, {:temporary => true}.merge(options))
+  end
+
+  def column_names(table)
+    @connection.table_structure(table).map {|column| column['name']}
+  end
+  
+  def column_values(table, column)
+    @connection.select_all("SELECT #{column} FROM #{table}").map {|row| row[column]}
+  end
+
+  def table_indexes_without_name(table)
+    @connection.indexes('comments_with_index').delete(:name)
+  end
+  
+  def row_count(table)
+    @connection.select_one("SELECT COUNT(*) AS count FROM #{table}")['count']
+  end
+end