cmoran92-activerecord-jdbc-adapter 1.2.1

data/test/generic_jdbc_connection_test.rb

@@ -0,0 +1,29 @@
+require 'jdbc_common'
+require 'db/jdbc'
+
+class GenericJdbcConnectionTest < Test::Unit::TestCase
+  def test_connection_available_through_jdbc_adapter
+    ActiveRecord::Base.connection.execute("show databases");
+    assert ActiveRecord::Base.connected?
+  end
+
+  def test_configure_connection_url
+    connection = Object.new
+    connection.extend ActiveRecord::ConnectionAdapters::JdbcConnection::ConfigHelper
+    connection.config = { :url => "jdbc://somehost", :options => { :hoge => "true", :fuya => "false"} }
+    assert_equal "jdbc://somehost?hoge=true&fuya=false", connection.configure_url
+
+    connection.config = { :url => "jdbc://somehost?param=0", :options => { :hoge => "true", :fuya => "false"} }
+    assert_equal "jdbc://somehost?param=0&hoge=true&fuya=false", connection.configure_url
+  end
+
+  def test_connection_fails_without_driver_and_url
+    conn = ActiveRecord::Base.remove_connection
+    assert_raises(ActiveRecord::ConnectionNotEstablished) do
+      ActiveRecord::Base.establish_connection :adapter => 'jdbc'
+      ActiveRecord::Base.connection
+    end
+  ensure
+    ActiveRecord::Base.establish_connection conn
+  end
+end

data/test/h2_change_column_test.rb

@@ -0,0 +1,68 @@
+require 'jdbc_common'
+require 'db/h2'
+
+class H2ChangeColumnTest < Test::Unit::TestCase
+
+  class Person < ActiveRecord::Base; end
+
+  class CreatePeopleTable < ActiveRecord::Migration
+    def self.up
+      create_table :people do |t|
+        t.integer :phone
+      end
+    end
+
+    def self.down
+      drop_table :people
+    end
+  end
+
+  def setup
+    CreatePeopleTable.up
+  end
+
+  def teardown
+    CreatePeopleTable.down
+  end
+
+  def test_should_change_column_type
+    ActiveRecord::Migration.change_column :people, :phone, :string
+    Person.reset_column_information
+
+    p = Person.create!(:phone => 'ABC')
+    assert_equal 'ABC', p.phone
+  end
+
+  def test_sets_defaults_on_column
+    ActiveRecord::Migration.change_column :people, :phone, :string, :default => '123456'
+    Person.reset_column_information
+
+    p = Person.create!
+    assert_equal '123456', p.phone
+  end
+
+  def test_should_change_column_default_value
+    ActiveRecord::Migration.add_column    :people, :email, :string, :default => 'foo@example.com'
+    ActiveRecord::Migration.change_column :people, :email, :string, :default => 'bar@example.com'
+    Person.reset_column_information
+
+    p = Person.create!
+    assert_equal 'bar@example.com', p.email
+  end
+
+  def test_should_set_non_null_restriction
+    ActiveRecord::Migration.change_column :people, :phone, :string, :null => false
+    Person.reset_column_information
+    assert_raises(ActiveRecord::StatementInvalid) { Person.create! }
+  end
+
+  def test_should_set_null_restriction_with_default
+    p = Person.create!
+    ActiveRecord::Migration.change_column :people, :phone, :string, :null => true, :default => '123456'
+    Person.reset_column_information
+
+    assert_nil p.reload.phone
+    assert_equal '123456', Person.create!.phone
+  end
+end
+

data/test/h2_simple_test.rb

@@ -0,0 +1,41 @@
+require 'jdbc_common'
+require 'db/h2'
+
+class H2SimpleTest < Test::Unit::TestCase
+  include SimpleTestMethods
+end
+
+class H2SchemaTest < Test::Unit::TestCase
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.execute("create schema s1");
+    @connection.execute("set schema s1");
+    CreateEntries.up
+    @connection.execute("create schema s2");
+    @connection.execute("set schema s2");
+    CreateUsers.up
+    @connection.execute("set schema public");
+    Entry.set_table_name 's1.entries'
+    User.set_table_name 's2.users'
+    user = User.create! :login => "something"
+    Entry.create! :title => "title", :content => "content", :rating => 123.45, :user => user
+  end
+
+  def teardown
+    @connection.execute("set schema s1");
+    CreateEntries.down
+    @connection.execute("set schema s2");
+    CreateUsers.down
+    @connection.execute("drop schema s1");
+    @connection.execute("drop schema s2");
+    @connection.execute("set schema public");
+    Entry.reset_table_name
+    Entry.reset_column_information
+    User.reset_table_name
+    User.reset_column_information
+  end
+
+  def test_find_in_other_schema
+    assert !Entry.all(:include => :user).empty?
+  end
+end

data/test/has_many_through.rb

@@ -0,0 +1,79 @@
+class CreateRbac < ActiveRecord::Migration
+  def self.up
+    create_table :role_assignments do |t| 
+      t.column :role_id, :integer
+      t.column :user_id, :integer
+    end
+
+    create_table :roles do |t| 
+      t.column :name, :string
+      t.column :description, :string
+    end 
+
+    create_table :permission_groups do |t|
+      t.column :right_id, :integer
+      t.column :role_id, :integer
+    end 
+
+    create_table :rights do |t| 
+      t.column :name, :string
+      t.column :controller_name, :string
+      t.column :actions, :string
+      t.column :hours, :float, :null => false
+    end
+  end
+
+  def self.down
+    drop_table :role_assignments
+    drop_table :roles
+    drop_table :permission_groups
+    drop_table :rights
+  end
+end
+
+class Right < ActiveRecord::Base
+  has_many :permission_groups, :dependent => :destroy
+  has_many :roles, :through => :permission_groups
+end
+
+class Role < ActiveRecord::Base
+  has_many :permission_groups, :dependent => :destroy
+  has_many :rights, :through => :permission_groups
+  has_many :role_assignments, :dependent => :destroy
+end
+
+class PermissionGroup < ActiveRecord::Base
+  belongs_to :right
+  belongs_to :role
+end
+
+class RoleAssignment < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :role
+end
+
+module HasManyThroughMethods
+  def setup
+    CreateRbac.up
+  end
+
+  def teardown
+    CreateRbac.down
+  end
+
+  def test_has_many_through
+    admin_role    = Role.create( {:name => "Administrator", :description => "System defined super user - access to right and role management."} )
+    admin_role.save
+
+    assert_equal(0, admin_role.rights.sum(:hours))
+
+    role_rights   = Right.create( {:name => "Administrator - Full Access To Roles", :actions => "*", :controller_name => "Admin::RolesController", :hours => 0} )
+    right_rights  = Right.create( {:name => "Administrator - Full Access To Rights", :actions => "*", :controller_name => "Admin::RightsController", :hours => 1.5} )
+
+    admin_role.rights << role_rights
+    admin_role.rights << right_rights
+    admin_role.save
+
+    assert_equal(1.5, admin_role.rights.sum(:hours))
+  end
+end

data/test/helper.rb

@@ -0,0 +1,85 @@
+module Kernel
+  def find_executable?(name)
+    ENV['PATH'].split(File::PATH_SEPARATOR).detect {|p| File.executable?(File.join(p, name))}
+  end
+
+  def have_postgres?
+    if find_executable?("psql")
+      if `psql -c '\\l' -U postgres 2>&1` && $?.exitstatus == 0
+        true
+      else
+        warn "No \"postgres\" role? You might need to execute `createuser postgres -drs' first."
+        false
+      end
+    end
+  end
+end
+
+# assert_queries and SQLCounter taken from rails active_record tests
+require 'test/unit'
+class Test::Unit::TestCase
+  def assert_queries(num = 1)
+    ActiveRecord::SQLCounter.log = []
+    yield
+  ensure
+    assert_equal num, ActiveRecord::SQLCounter.log.size, "#{ActiveRecord::SQLCounter.log.size} instead of #{num} queries were executed.#{ActiveRecord::SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{ActiveRecord::SQLCounter.log.join("\n")}"}"
+  end
+end
+
+require 'active_support/notifications'
+module ActiveRecord
+  class SQLCounter
+    def self.ignored_sql
+      @@ignored_sql
+    end
+
+    def self.ignored_sql=(value)
+      @@ignored_sql = value
+    end
+
+    self.ignored_sql = [
+      /^PRAGMA (?!(table_info))/,
+      /^SELECT currval/,
+      /^SELECT CAST/,
+      /^SELECT @@IDENTITY/,
+      /^SELECT @@ROWCOUNT/,
+      /^SAVEPOINT/,
+      /^ROLLBACK TO SAVEPOINT/,
+      /^RELEASE SAVEPOINT/,
+      /^SHOW max_identifier_length/,
+      /^BEGIN/,
+      /^COMMIT/
+    ]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL.  This ignored SQL is for Oracle.
+    ignored_sql.concat [/^select .*nextval/i,
+      /^SAVEPOINT/,
+      /^ROLLBACK TO/,
+      /^\s*select .* from all_triggers/im
+    ]
+
+    def self.log=(v)
+      @@log = v
+    end
+
+    def self.log
+      @@log
+    end
+
+    self.log = []
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      unless 'CACHE' == values[:name]
+        self.class.log << sql unless self.class.ignored_sql.
+          any? { |r| sql =~ r }
+      end
+    end
+  end
+
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+end

data/test/hsqldb_simple_test.rb

@@ -0,0 +1,6 @@
+require 'jdbc_common'
+require 'db/hsqldb'
+
+class HsqldbSimpleTest < Test::Unit::TestCase
+  include SimpleTestMethods
+end

data/test/informix_simple_test.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+#
+# To run this script, run the following:
+#
+#   CREATE DATABASE weblog_development;
+#
+# TODO: Finish the explanation.
+
+require 'jdbc_common'
+require 'db/informix'
+
+class InformixSimpleTest < Test::Unit::TestCase
+  include SimpleTestMethods
+
+  # Informix does not like "= NULL".
+  def test_equals_null
+    Entry.create!(:title => "Foo")
+    entry = Entry.find(:first, :conditions => ["content = NULL"])
+    assert_equal "Foo", entry.title
+  end
+
+  # Informix does not like "!= NULL" or "<> NULL".
+  def test_not_equals_null
+    Entry.create!(:title => "Foo", :content => "Bar")
+    entry = Entry.find_by_title("Foo", :conditions => ["content != NULL"])
+    assert_equal "Foo", entry.title
+    entry = Entry.find_by_title("Foo", :conditions => ["content <> NULL"])
+    assert_equal "Foo", entry.title
+  end
+end
+
+class InformixMultibyteTest < Test::Unit::TestCase
+  include MultibyteTestMethods
+
+  # Overriding the included test since we can't create text fields via a
+  # simple insert in Informix.
+  def test_select_multibyte_string
+    Entry.create!(:title => 'テスト', :content => '本文')
+    entry = Entry.find(:first)
+    assert_equal "テスト", entry.title
+    assert_equal "本文", entry.content
+    assert_equal entry, Entry.find_by_title("テスト")
+  end
+end
+
+class InformixHasManyThroughTest < Test::Unit::TestCase
+  include HasManyThroughMethods
+end

data/test/jdbc_common.rb

@@ -0,0 +1,27 @@
+# Simple method to reduce the boilerplate
+def jruby?
+  defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+end
+
+require 'arjdbc' if jruby?
+puts "Using activerecord version #{ActiveRecord::VERSION::STRING}"
+puts "Specify version with AR_VERSION={version} or RUBYLIB={path}"
+require 'models/auto_id'
+require 'models/entry'
+require 'models/data_types'
+require 'models/add_not_null_column_to_table'
+require 'models/validates_uniqueness_of_string'
+require 'models/string_id'
+require 'models/thing'
+require 'simple'
+require 'has_many_through'
+require 'helper'
+require 'test/unit'
+
+# Comment/uncomment to enable logging to be loaded for any of the database adapters
+if $DEBUG || ENV['DEBUG']
+  require 'db/logger'
+  require 'ruby-debug'
+end
+
+

data/test/jndi_callbacks_test.rb

@@ -0,0 +1,40 @@
+require 'jdbc_common'
+require 'db/jndi_config'
+
+begin
+  require 'mocha'
+
+class JndiConnectionPoolCallbacksTest < Test::Unit::TestCase
+  def setup
+    @connection = mock "JdbcConnection"
+    @connection.stubs(:jndi_connection?).returns(true)
+    @connection.stubs(:adapter=)
+    @logger = mock "logger"
+    @config = JNDI_CONFIG
+    Entry.connection_pool.disconnect!
+    assert !Entry.connection_pool.connected?
+    class << Entry.connection_pool; public :instance_variable_set; end
+  end
+
+  def teardown
+    @connection.stubs(:disconnect!)
+    Entry.connection_pool.disconnect!
+  end
+
+  def test_should_call_hooks_on_checkout_and_checkin
+    @connection.stubs(:active?).returns(true)
+    @connection.expects(:disconnect!)
+    @adapter = ActiveRecord::ConnectionAdapters::JdbcAdapter.new @connection, @logger, @config
+    Entry.connection_pool.instance_variable_set "@connections", [@adapter]
+
+    @connection.expects(:reconnect!)
+    Entry.connection_pool.checkout
+
+    @connection.expects(:disconnect!)
+    Entry.connection_pool.checkin @adapter
+  end
+end
+
+rescue LoadError
+  warn "mocha not found, disabling mocha-based tests"
+end if ActiveRecord::Base.respond_to?(:connection_pool)

data/test/jndi_test.rb

@@ -0,0 +1,25 @@
+# In order to run these tests, you need to have a few things on your
+# classpath. First, you're going to need the Sun File system
+# context. You can get that here: 
+#
+# http://java.sun.com/products/jndi/serviceproviders.html.  
+#
+# Make sure that you put both the fscontext.jar and the
+# providerutil.jar on your classpath.  
+#
+# To support the connection pooling in the test, you'll need
+# commons-dbcp, commons-pool, and commons-collections.
+#
+# Finally, you'll need the jdbc driver, which is derby, for this test.
+
+require 'jdbc_common'
+require 'db/jndi_config'
+
+class DerbyJndiTest < Test::Unit::TestCase
+  include SimpleTestMethods
+end
+
+at_exit {
+  require 'fileutils'
+  FileUtils.rm_rf 'derby-testdb'
+}