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

data/test/models/string_id.rb

@@ -1,17 +0,0 @@
-class CreateStringIds < ActiveRecord::Migration
-  def self.up
-    create_table "string_ids", :force => true, :id => false do |t|
-      t.string :id, :null => false
-    end
-  end
-
-  def self.down
-    drop_table "string_ids"
-  end
-end
-
-class StringId < ActiveRecord::Base
-  def self.table_name; "string_ids"; end
-  # Fake out a table without a primary key
-  self.primary_key = "id"
-end

data/test/models/thing.rb

@@ -1,17 +0,0 @@
-class CreateThings < ActiveRecord::Migration
-  def self.up
-    create_table :things, :id => false do |t|
-      t.string :name
-      t.timestamps
-    end
-    add_index :things, :name, :unique => true
-    add_index :things, :created_at, :where => 'name IS NOT NULL', :name => "thing_partial_index"
-  end
-
-  def self.down
-    drop_table :things
-  end
-end
-
-class Thing < ActiveRecord::Base
-end

data/test/models/topic.rb

@@ -1,32 +0,0 @@
-class Topic < ActiveRecord::Base
-  serialize :content
-end
-
-class ImportantTopic < Topic
-  serialize :important, Hash
-end
-
-class TopicMigration < ActiveRecord::Migration
-
-  def self.up
-    create_table :topics, :force => true do |t|
-      t.string :title
-      # use VARCHAR2(4000) instead of CLOB datatype as CLOB data type has many limitations in
-      # Oracle SELECT WHERE clause which causes many unit test failures
-      #if current_adapter?(:OracleAdapter)
-        #t.string :content, :limit => 4000
-        #t.string :important, :limit => 4000
-      #else
-        t.text :content
-        t.text :important
-      #end
-      t.string :type
-      t.timestamps
-    end
-  end
-
-  def self.down
-    drop_table :topics
-  end
-
-end

data/test/models/validates_uniqueness_of_string.rb

@@ -1,19 +0,0 @@
-class CreateValidatesUniquenessOf < ActiveRecord::Migration
-  def self.up
-    create_table "validates_uniqueness_of", :force => true do |t|
-      t.column :cs_string, :string
-      t.column :ci_string, :string
-      t.column :content, :text
-    end
-  end
-
-  def self.down
-    drop_table "validates_uniqueness_of"
-  end
-end
-
-class ValidatesUniquenessOfString < ActiveRecord::Base
-  self.table_name = "validates_uniqueness_of"
-  validates_uniqueness_of :cs_string, :case_sensitive => true
-  validates_uniqueness_of :ci_string, :case_sensitive => false
-end

data/test/rails/mysql.rb

@@ -1,13 +0,0 @@
-module Mysql # :nodoc:
-  # remove_const(:Error) if const_defined?(:Error)
-  class Error < StandardError; end
-
-  def self.client_version
-    50400 # faked out for AR tests
-  end
-  
-  #module GemVersion
-  #  VERSION = '2.8.2'
-  #end
-  
-end

data/test/rails/sqlite3/version.rb

@@ -1,6 +0,0 @@
-# activerecord/test/cases/query_cache_test.rb requires this file
-module SQLite3 # gem 'sqlite3' (native)
-  module Version
-    VERSION = '1.3.7' # SQLite3::Version::VERSION > '1.2.5'
-  end
-end

data/test/rails_stub.rb

@@ -1,31 +0,0 @@
-require 'pathname'
-
-module Rails
-  class Configuration; end unless const_defined?(:Configuration)
-  Configuration.class_eval do
-    def root
-      defined?(RAILS_ROOT) ? Pathname.new(RAILS_ROOT).realpath : raise("Rails.root not set")
-    end
-  end
-  class Application
-    def self.config
-      @config ||= Configuration.new
-    end
-    def self.paths
-      @paths ||= Hash.new { [] }
-    end
-  end
-  def self.application
-    Rails::Application
-  end
-  def self.configuration
-    application.config
-  end
-  def self.root
-    application && application.config.root
-  end
-  def self.env
-    env = defined?(RAILS_ENV) ? RAILS_ENV : ( ENV["RAILS_ENV"] || "development" )
-    ActiveSupport::StringInquirer.new(env)
-  end
-end

data/test/rake_test_support.rb

@@ -1,298 +0,0 @@
-require 'test_helper'
-require 'pathname'
-require 'stringio'
-
-module RakeTestSupport
-  
-  def self.included(base)
-    require 'rake'
-    base.module_eval { include Rake::DSL } # if defined?(Rake::DSL)
-    base.extend ClassMethods
-  end
-
-  module ClassMethods
-    
-    def startup
-      super
-      load 'rails_stub.rb'
-    end
-    
-    def shutdown
-      Object.send(:remove_const, :Rails)
-      super
-    end
-    
-  end
-  
-  def setup
-    @_prev_application = Rake.application
-    @_prev_configurations = ActiveRecord::Base.configurations
-    @_prev_connection_config = current_connection_config
-    db_config # if not re-defined initialize from current connection's config
-
-    @db_name = db_name unless @db_name ||= nil
-    @rails_env = rails_env unless @rails_env ||= nil
-    
-    setup_rails
-    set_rails_env(@rails_env)
-    set_rails_root(".")
-    
-    Rake.application = new_application
-    ActiveRecord::Base.connection.disconnect!
-    
-    verbose(true)
-    
-    load_tasks
-    
-    do_setup
-  end
-
-  def do_setup
-  end
-
-  RAILS_4x = ActiveRecord::VERSION::MAJOR >= 4
-  
-  def load_tasks
-    if ActiveRecord::VERSION::MAJOR >= 3
-      load "active_record/railties/databases.rake"
-    else # we still support AR-2.3
-      load "tasks/databases.rake" # from rails/railties
-    end
-    load 'arjdbc/tasks.rb' if defined?(JRUBY_VERSION)
-
-    namespace :db do
-      task :load_config do
-        # 4.0 :
-        # ActiveRecord::Base.configurations = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
-        # ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
-        # 3.2 :
-        # ActiveRecord::Base.configurations = Rails.application.config.database_configuration
-        # ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
-        # 2.3 :
-        # ActiveRecord::Base.configurations = Rails::Configuration.new.database_configuration
-        ActiveRecord::Base.configurations = configurations
-      end
-    end
-
-    task :environment do
-      ActiveRecord::Base.configurations = configurations
-      ActiveRecord::Base.establish_connection @rails_env
-      @full_env_loaded = true
-    end
-    
-    if RAILS_4x
-      ActiveRecord::Tasks::DatabaseTasks.env = @rails_env
-      ActiveRecord::Tasks::DatabaseTasks.db_dir = 'db'
-    else
-      task(:rails_env) { @rails_env_set = true }
-    end
-  end
-  
-  def teardown
-    verify_and_restore_stdout
-    error = nil
-    begin
-      do_teardown
-    rescue => e
-      error = e
-    end
-    Rake.application = @_prev_application
-    restore_rails
-    ActiveRecord::Base.configurations = @_prev_configurations
-    ActiveRecord::Base.establish_connection @_prev_connection_config
-    @rails_env_set = nil
-    @full_env_loaded = nil
-    raise error if error
-  end
-
-  def do_teardown
-  end
-  
-  def new_application
-    Rake::Application.new
-  end
-  
-  # (Test) Helpers :
-  
-  def create_schema_migrations_table(connection = ActiveRecord::Base.connection)
-    schema_migration = ActiveRecord::Migrator.schema_migrations_table_name
-    return if connection.table_exists?(schema_migration)
-    connection.create_table(schema_migration, :id => false) do |t|
-      t.column :version, :string, :null => false
-    end
-  end
-  
-  def create_rake_test_database
-    ActiveRecord::Base.establish_connection db_config
-    connection = ActiveRecord::Base.connection
-    connection.create_database(db_name, db_config) if connection.respond_to?(:create_database)
-    if block_given?
-      if db_name
-        config = db_config.merge :database => db_name
-        ActiveRecord::Base.establish_connection config
-      end
-      yield ActiveRecord::Base.connection
-    end
-    ActiveRecord::Base.connection.disconnect!
-  end
-  
-  def drop_rake_test_database(silence = false)
-    ActiveRecord::Base.establish_connection db_config
-    begin
-      ActiveRecord::Base.connection.drop_database(db_name)
-    rescue => e
-      raise e unless silence
-    end
-    ActiveRecord::Base.connection.disconnect!
-  end
-  
-  def structure_sql_filename
-    ar_version('3.2') ? 'structure.sql' : "#{@rails_env}_structure.sql"
-  end
-  
-  def expect_rake_output(matcher)
-    @_stdout, @_stdout_matcher = $stdout, matcher
-    $stdout = StringIO.new
-  end
-  
-  def verify_and_restore_stdout
-    if @_stdout ||= nil
-      _stdout = $stdout
-      $stdout = @_stdout
-      
-      output = _stdout.string
-      if @_stdout_matcher.is_a?(String)
-        unless @_stdout_matcher.index("\n")
-          output = output.rstrip
-        end
-        assert_equal @_stdout_matcher, output
-      else
-        assert_match @_stdout_matcher, output
-      end
-    end
-  end
-  private :verify_and_restore_stdout
-  
-  def rails_env
-    'unittest'
-  end
-  
-  def db_name
-    'test_rake_db'
-  end
-  
-  @@db_config = nil
-  
-  def db_config
-    @@db_config ||= current_connection_config.reject { |key, val| val && key.to_s == 'url' }
-  end
-  
-  def current_connection_config
-    if ActiveRecord::Base.respond_to?(:connection_config)
-      ActiveRecord::Base.connection_config
-    else
-      ActiveRecord::Base.connection_pool.spec.config
-    end
-  end
-  
-  def configurations
-    @configurations ||= begin
-      db_config = self.db_config.dup
-      db_config.merge!(:database => @db_name) if @db_name ||= nil
-      db_config.stringify_keys!
-      raise "Rails.env not set" unless @rails_env ||= nil
-      configurations = { @rails_env => db_config }
-      configurations['test'] = db_config.dup
-      configurations
-    end
-  end
-  
-  private
-
-  RAILS_2x = ActiveRecord::VERSION::MAJOR < 3
-  
-  def setup_rails
-    RAILS_2x ? setup_rails2 : setup_rails3
-  end
-
-  def setup_rails2
-    test = self
-    Rails::Configuration.module_eval do
-      define_method(:database_configuration) { test.configurations }
-    end
-  end
-
-  def setup_rails3
-    test = self
-    (class << Rails::Application.config; self ; end).instance_eval do
-      define_method(:database_configuration) { test.configurations }
-    end
-  end
-
-  def set_rails_env(env); set_rails_constant("env", env); end
-
-  def set_rails_root(root = '.'); set_rails_constant("root", root); end
-
-  NO_VALUE = Java::JavaLang::Void rescue NilClass
-  
-  def set_rails_constant(name, value)
-    name = name.to_s
-    
-    @rails_constants ||= {}
-    begin
-      @rails_constants[name] = Object.const_get(rails_constant_name(name))
-    rescue NameError
-      @rails_constants[name] = NO_VALUE
-    end
-    silence_warnings { Object.const_set(rails_constant_name(name), value) } if RAILS_2x
-    
-    case name
-    when 'env'
-      unless value.is_a?(ActiveSupport::StringInquirer)
-        value = ActiveSupport::StringInquirer.new(value)
-      end
-    when 'root'
-      unless value.is_a?(Pathname)
-        value = Pathname.new(value).realpath
-      end
-    end
-    
-    Rails.instance_eval do
-      if methods(false).map(&:to_s).include?(name)
-        singleton_class = (class << self; self; end)
-        singleton_class.send(:alias_method, "orig_#{name}", name)
-        singleton_class.send(:define_method, name) { value }
-      end
-    end
-  end
-
-  def restore_rails
-    ( @rails_constants ||= {} ).each do |name, value|
-      
-      if value == NO_VALUE
-        Object.send(:remove_const, rails_constant_name(name)) if RAILS_2x
-      else
-        silence_warnings { Object.const_set(rails_constant_name(name), value) }
-      end
-      
-      Rails.instance_eval do
-        if methods(false).map(&:to_s).include?(name)
-          singleton_class = (class << self; self; end)
-          singleton_class.send :remove_method, name
-          singleton_class.send :alias_method, name, "orig_#{name}"
-        end
-      end
-      
-    end
-  end
-
-  def rails_constant_name(name); "RAILS_#{name.upcase}"; end
-  
-  def silence_warnings
-    prev, $VERBOSE = $VERBOSE, nil
-    yield
-  ensure
-    $VERBOSE = prev
-  end
-  
-end

data/test/row_locking.rb

@@ -1,102 +0,0 @@
-require 'thread'
-
-require 'test_helper'
-require 'models/entry'
-
-module RowLockingTestMethods
-
-  # Simple SELECT ... FOR UPDATE test
-  def test_select_all_for_update
-    @row1_id = Entry.create!(:title => "row1").id
-    all_locked = Entry.lock(true)
-    all_locked_ids = all_locked.all.map { |row| row.id }
-    assert all_locked_ids.include?(@row1_id)
-  end if Test::Unit::TestCase.ar_version('3.0')
-
-  def test_row_locking
-    row_locking_test_template
-  end
-
-  def test_row_locking_with_limit
-    row_locking_test_template(:limit => 1)
-  end
-
-  protected
-  
-  def row_locking_test_template(options={})
-    # Create two rows that we will work with
-    @row1_id = Entry.create!(:title => "row1").id
-    @row2_id = Entry.create!(:title => "row2").id
-
-    @result_queue = Queue.new
-    signal_queue = Queue.new
-    t1 = Thread.new { thread_helper { thread1_main(signal_queue, options) } }
-    t2 = Thread.new { thread_helper { thread2_main(signal_queue, options) } }
-    t1.join
-    t2.join
-
-    result = []
-    result << @result_queue.shift until @result_queue.empty?    # Convert the queue into an array
-
-    expected = [
-      :t1_locking_row2,
-      :t1_locked_row2,
-
-      :t2_locking_row1,
-      :t2_locked_row1,
-
-      :t2_locking_row2,     # thread 2 tries to lock row2 ...
-      :t1_committed,
-      :t2_locked_row2,      # ... but it doesn't succeed until after thread 1 commits its transaction
-
-      :t2_committed,
-    ]
-
-    assert_equal expected, result, "thread2 should lock row1 immediately but wait for thread1 to commit before getting the lock on row2"
-  end
-  
-  private
-
-  def thread1_main(signal_queue, options={})
-    Entry.transaction do
-      @result_queue << :t1_locking_row2
-      Entry.find(@row2_id, {:lock=>true}.merge(options))   # acquire a row lock on r2
-      @result_queue << :t1_locked_row2
-      signal_queue << :go               # signal thread2 to start
-      sleep 1.5                         # Wait for a few seconds, to allow the other thread to race with this thread.
-      @result_queue << :t1_committed
-    end
-  end
-
-  def thread2_main(signal_queue, options={})
-    Entry.transaction do
-      signal_queue.shift   # wait until we get the signal from thread1
-      @result_queue << :t2_locking_row1
-      Entry.find(@row1_id, {:lock=>true}.merge(options))   # should return immediately
-      @result_queue << :t2_locked_row1
-      @result_queue << :t2_locking_row2
-      Entry.find(@row2_id, {:lock=>true}.merge(options))   # should block until thread1 commits its transaction
-      @result_queue << :t2_locked_row2
-      @result_queue << :t2_committed
-    end
-  end
-
-  def thread_helper
-    yield
-  rescue Exception => exc
-    # Output backtrace, since otherwise we won't see anything until the main thread joins this thread.
-    display_exception(exc)
-    raise
-  ensure
-    # This is needed.  Otherwise, the database connections aren't returned to the pool and things break.
-    ActiveRecord::Base.connection_handler.clear_active_connections!
-  end
-
-  def display_exception(exception)
-    lines = []
-    lines << "#{exception.class.name}: #{exception.message}\n"
-    lines += exception.backtrace.map{|line| "\tfrom #{line}"}
-    $stderr.puts lines.join("\n")
-  end
-  
-end