activerecord-jdbc-adapter 1.3.0.beta1 → 1.3.0.beta2

data/lib/pg.rb

@@ -1,26 +0,0 @@
-# Stub library for postgresql -- allows Rails to load
-# postgresql_adapter without error. Other than postgres-pr, there's no
-# other way to use PostgreSQL on JRuby anyway, right? If you've
-# installed ar-jdbc you probably want to use that to connect to pg.
-#
-# If by chance this library is installed in another Ruby and this file
-# got required then we'll just continue to try to load the next pg.rb
-# in the $LOAD_PATH.
-
-unless defined?(JRUBY_VERSION)
-  gem 'pg' if respond_to?(:gem)   # make sure pg gem is activated
-  after_current_file = false
-  $LOAD_PATH.each do |p|
-    require_file = File.join(p, 'pg.rb')
-
-    if File.expand_path(require_file) == File.expand_path(__FILE__)
-      after_current_file = true
-      next
-    end
-
-    if after_current_file && File.exist?(require_file)
-      load require_file
-      break
-    end
-  end
-end

data/test/abstract_db_create.rb

@@ -1,139 +0,0 @@
-require 'test_helper'
-require 'rake'
-
-module Rails
-  class Configuration; end unless const_defined?(:Configuration)
-  class Application
-    def self.config
-      @config ||= Object.new
-    end
-    def self.paths
-      @paths ||= Hash.new { [] }
-    end
-  end
-  def self.application
-    Rails::Application
-  end
-end
-
-module AbstractDbCreate
-  def self.included(base)
-    base.module_eval { include Rake::DSL } if defined?(Rake::DSL)
-  end
-
-  def setup
-    @prev_app = Rake.application
-    Rake.application = Rake::Application.new
-    verbose(true)
-    do_setup
-  end
-
-  def do_setup(env = 'unittest', db = 'test_rake_db_create')
-    @env = env
-    @prev_configs = ActiveRecord::Base.configurations
-    ActiveRecord::Base.connection.disconnect!
-    @db_name = db
-    setup_rails
-    set_rails_constant("env", @env)
-    set_rails_constant("root", ".")
-    load File.dirname(__FILE__) + '/../lib/arjdbc/jdbc/jdbc.rake' if defined?(JRUBY_VERSION)
-    task :environment do
-      ActiveRecord::Base.configurations = configurations
-      @full_env_loaded = true
-    end
-    task :rails_env do
-      @rails_env_set = true
-    end
-  end
-
-  def teardown
-    Rake::Task["db:drop"].invoke
-    Rake.application = @prev_app
-    restore_rails
-    ActiveRecord::Base.configurations = @prev_configs
-    ActiveRecord::Base.establish_connection(db_config)
-    @rails_env_set = nil
-    @full_env_loaded = nil
-  end
-
-  def setup_rails
-    if ActiveRecord::VERSION::MAJOR <= 2
-      setup_rails2
-    else
-      setup_rails3
-    end
-  end
-
-  def configurations
-    db_name = @db_name
-    db_config = self.db_config
-    db_config = db_config.merge({:database => db_name}) if db_name
-    db_config.stringify_keys!
-    @configs = { @env => db_config }
-    @configs["test"] = @configs[@env].dup
-    @configs
-  end
-
-  def setup_rails2
-    configs = configurations
-    Rails::Configuration.module_eval do
-      define_method(:database_configuration) { configs }
-    end
-    ar_version = $LOADED_FEATURES.grep(%r{active_record/version}).first
-    ar_lib_path = $LOAD_PATH.detect {|p| p if File.exist?File.join(p, ar_version)}
-    # if the old style finder didn't work, assume we have the absolute path already
-    if ar_lib_path.nil? && File.exist?(ar_version)
-      ar_lib_path = ar_version.sub(%r{/active_record/version.*}, '')
-    end
-    ar_lib_path = ar_lib_path.sub(%r{activerecord/lib}, 'railties/lib') # edge rails
-    rails_lib_path = ar_lib_path.sub(/activerecord-([\d\.]+)/, 'rails-\1') # gem rails
-    load "#{rails_lib_path}/tasks/databases.rake"
-  end
-
-  def setup_rails3
-    configs = configurations
-    (class << Rails::Application.config; self ; end).instance_eval do
-      define_method(:database_configuration) { configs }
-    end
-    require 'pathname'
-    ar_version = $LOADED_FEATURES.grep(%r{active_record/version}).first
-    ar_lib_path = $LOAD_PATH.detect do |p|
-      Pathname.new(p).absolute? && ar_version.start_with?(p) ||
-        File.exist?(File.join(p, ar_version))
-    end
-    load "#{ar_lib_path}/active_record/railties/databases.rake"
-  end
-
-  def set_rails_constant(name, value)
-    cname ="RAILS_#{name.upcase}"
-    @constants ||= {}
-    @constants[name] = Object.const_get(cname) rescue nil
-    silence_warnings { Object.const_set(cname, value) }
-    Rails.instance_eval do
-      if instance_methods(false).include?(name)
-        alias_method "orig_#{name}", name
-        define_method(name) { value }
-      end
-    end
-  end
-
-  def restore_rails
-    @constants.each do |key,value|
-      silence_warnings { Object.const_set("RAILS_#{key.upcase}", value) }
-      Rails.instance_eval do
-        if instance_methods(false).include?(name)
-          remove_method name
-          alias_method name, "orig_#{name}"
-        end
-      end
-    end
-  end
-
-  def silence_warnings
-    prev, $VERBOSE = $VERBOSE, nil
-    yield
-  ensure
-    $VERBOSE = prev
-  end
-  
-end

data/test/activerecord/connection_adapters/type_conversion_test.rb

@@ -1,36 +0,0 @@
-require 'java'
-require 'models/data_types'
-require 'arjdbc'
-require 'test/unit'
-
-class TypeConversionTest < Test::Unit::TestCase
-  
-  TEST_INT = 987654321
-  
-  TEST_TIME = Time.at(1169964202).gmtime
-  
-  def self.startup
-    DbTypeMigration.up
-  end
-
-  def self.shutdown
-    DbTypeMigration.down
-  end
-  
-  def setup
-    DbType.create(
-      :sample_timestamp => TEST_TIME,
-      :sample_decimal => TEST_INT) # DECIMAL(9,0)
-  end
-  
-  def test_timestamp
-    type = DbType.first
-    assert_equal TEST_TIME, type.sample_timestamp.getutc
-  end
-  
-  def test_decimal
-    type = DbType.first
-    assert_equal TEST_INT, type.sample_decimal
-  end
-  
-end

data/test/db/mssql/db_create_test.rb

@@ -1,29 +0,0 @@
-require 'abstract_db_create'
-require 'db/mssql'
-
-class MSSQLDbCreateTest < Test::Unit::TestCase
-  include AbstractDbCreate
-
-  def db_config
-    MSSQL_CONFIG
-  end
-  
-  def test_rake_db_create
-    begin
-      Rake::Task["db:create"].invoke
-    rescue => e
-      if e.message =~ /CREATE DATABASE permission denied/
-        puts "\nwarning: db:create test skipped; add 'dbcreator' role to user '#{db_config[:username]}' to run"
-        return
-      end
-    end
-    ActiveRecord::Base.establish_connection(db_config.merge(:database => "master"))
-    if ActiveRecord::Base.connection.send(:sqlserver_2000?)
-      select = "SELECT name FROM master..sysdatabases ORDER BY name"
-    else
-      select = "SELECT name FROM sys.sysdatabases"
-    end
-    databases = ActiveRecord::Base.connection.select_rows(select).flatten
-    assert databases.include?(@db_name)
-  end
-end

data/test/db/mysql/db_create_test.rb

@@ -1,33 +0,0 @@
-require 'abstract_db_create'
-require 'db/mysql'
-
-class MysqlDbCreateTest < Test::Unit::TestCase
-  include AbstractDbCreate
-
-  def db_config
-    MYSQL_CONFIG
-  end
-
-  def test_rake_db_create
-    omit_unless find_executable?("mysql")
-    Rake::Task["db:create"].invoke
-    with_mysql do |mysql|
-      mysql << "show databases where `Database` = '#{@db_name}';"
-      mysql.close_write
-      assert mysql.read =~ /#{@db_name}/m      
-    end
-  end
-
-  def test_rake_db_test_purge
-    Rake::Task["db:create"].invoke
-    Rake::Task["db:test:purge"].invoke
-  end
-  
-  private
-  
-  def with_mysql(args = nil)
-    exec = "mysql -u #{db_config[:username]} --password=#{db_config[:password]} #{args}"
-    IO.popen(exec, "r+") { |mysql| yield(mysql) }
-  end
-  
-end

data/test/db/postgres/db_create_test.rb

@@ -1,44 +0,0 @@
-require 'db/postgres'
-require 'abstract_db_create'
-
-class PostgresDbCreateTest < Test::Unit::TestCase
-  include AbstractDbCreate
-
-  def db_config
-    POSTGRES_CONFIG
-  end
-
-  PSQL_EXECUTABLE = find_executable?("psql")
-  
-  def test_rake_db_create
-    omit_unless PSQL_EXECUTABLE
-    Rake::Task["db:create"].invoke
-    assert_match /#{@db_name}/m, psql("-d template1 -c '\\\l'")
-  end
-
-  def test_rake_db_test_purge
-    # omit_unless PSQL_EXECUTABLE
-    Rake::Task["db:create"].invoke
-    Rake::Task["db:test:purge"].invoke
-  end
-
-  def test_rake_db_create_does_not_load_full_environment
-    Rake::Task["db:create"].invoke
-    assert @rails_env_set
-    assert !defined?(@full_environment_loaded) || !@full_environment_loaded
-  end
-  
-  private
-  
-  def psql(args)
-    args = args.join(' ') unless args.is_a?(String)
-    if db_config[:host] != 'localhost'
-      args = "--host=#{db_config[:host]} #{args}"
-    end
-    if username = ENV['PSQL_USERNAME']
-      args = "--username=#{username} #{args}"
-    end
-    `psql #{args}`
-  end
-  
-end

data/test/db/postgres/db_drop_test.rb

@@ -1,17 +0,0 @@
-require 'db/postgres'
-require 'abstract_db_create'
-
-class PostgresDbDropTest < Test::Unit::TestCase
-  include AbstractDbCreate
-
-  def db_config
-    POSTGRES_CONFIG
-  end
-
-  def test_dropping_nonexistent_database_does_not_raise_exception
-    assert_nothing_raised do
-      Rake::Task["db:drop"].invoke
-    end
-  end
-  
-end