cmoran92-activerecord-jdbc-adapter 1.2.1

data/test/mysql_simple_test.rb

@@ -0,0 +1,125 @@
+# To run this script, run the following in a mysql instance:
+#
+#   drop database if exists weblog_development;
+#   create database weblog_development;
+#   grant all on weblog_development.* to blog@localhost;
+#   flush privileges;
+
+require 'jdbc_common'
+require 'db/mysql'
+
+class MysqlSimpleTest < Test::Unit::TestCase
+  include SimpleTestMethods
+  include ActiveRecord3TestMethods
+  include ColumnNameQuotingTests
+
+  column_quote_char "`"
+
+  def test_column_class_instantiation
+    text_column = nil
+    assert_nothing_raised do
+      text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.
+        new("title", nil, "text")
+    end
+    assert_not_nil text_column
+  end
+
+  def test_string_quoting_oddity
+    s = "0123456789a'a"
+    assert_equal "'0123456789a\\'a'", ActiveRecord::Base.connection.quote(s)
+
+    s2 = s[10,3]
+    assert_equal "a'a", s2
+    assert_equal "'a\\'a'", ActiveRecord::Base.connection.quote(s2)
+  end
+
+  def test_table_name_quoting_with_dot
+    s = "#{MYSQL_CONFIG[:database]}.posts"
+    assert_equal "`#{MYSQL_CONFIG[:database]}`.`posts`", ActiveRecord::Base.connection.quote_table_name(s)
+  end
+
+  def test_update_all_with_limit
+    assert_nothing_raised { Entry.update_all({:title => "test"}, {}, {:limit => 1}) }
+  end
+
+  # from rails active record tests
+  def test_update_all_with_joins_and_offset_and_order
+    user_1 = User.create :login => 'user_1'
+    user_2 = User.create :login => 'user_2'
+
+    entry_1 = Entry.create :title => 'title_1', :content => 'content_1', :rating => 0,
+    :user_id => user_1.id
+    entry_2 = Entry.create :title => 'title_2', :content => 'content_2', :rating => 1,
+    :user_id => user_2.id
+
+    all_entries = Entry.joins(:user).where('users.id' => user_1.id).
+      order('users.id', 'entries.id')
+    count   = all_entries.count
+    entries = all_entries.offset(1)
+
+    assert_equal count - 1, entries.update_all(:user_id => user_2.id)
+    assert_equal user_2, Entry.find_by_title('title_2').user
+  end
+
+  # from rails active record tests
+  def test_caching_of_columns
+    user = User.create :login => 'test'
+    # clear cache possibly created by other tests
+    user.entries.reset_column_information
+
+    # One query for columns, one for primary key
+    assert_queries(2) { user.entries.columns; user.entries.columns }
+
+    ## and again to verify that reset_column_information clears the cache correctly
+    user.entries.reset_column_information
+    assert_queries(2) { user.entries.columns; user.entries.columns }
+  end
+
+  # from rails active record tests
+  def test_drop_index_from_table_named_values
+    connection = Entry.connection
+    connection.create_table :values, :force => true do |t|
+      t.integer :value
+    end
+
+    assert_nothing_raised do
+      connection.add_index :values, :value
+      connection.remove_index :values, :column => :value
+    end
+
+    connection.drop_table :values rescue nil
+  end
+
+  def test_find_in_other_schema_with_include
+    old_entries_table_name = Entry.table_name
+    old_users_table_name   = User.table_name
+    begin
+      User.set_table_name "#{MYSQL_CONFIG[:database]}.users"
+      Entry.set_table_name "#{MYSQL_CONFIG[:database]}.entries"
+      assert !Entry.all(:include => :user).empty?
+    ensure
+      Entry.set_table_name old_entries_table_name
+      User.set_table_name old_users_table_name
+    end
+  end
+
+  def test_create_xml_column
+    assert_nothing_raised do
+      @connection.create_table :xml_testings do |t|
+        t.xml :xml_test
+      end
+    end
+
+    xml_test = @connection.columns(:xml_testings).detect do |c|
+      c.name == "xml_test"
+    end
+
+    assert_equal "text", xml_test.sql_type
+  ensure
+    @connection.drop_table :xml_testings rescue nil
+  end
+end
+
+class MysqlHasManyThroughTest < Test::Unit::TestCase
+  include HasManyThroughMethods
+end

data/test/oracle_simple_test.rb

@@ -0,0 +1,18 @@
+require 'jdbc_common'
+require 'db/oracle'
+
+class OracleSimpleTest < Test::Unit::TestCase
+  include SimpleTestMethods
+
+  def test_default_id_type_is_integer
+    assert Integer === Entry.first.id
+  end
+
+  def test_sequences_are_not_cached
+    ActiveRecord::Base.transaction do
+      e1 = Entry.create :title => "hello1"
+      e2 = Entry.create :title => "hello2"
+      assert e1.id != e2.id
+    end
+  end
+end

data/test/oracle_specific_test.rb

@@ -0,0 +1,83 @@
+require 'jdbc_common'
+require 'db/oracle'
+
+class DefaultNumber < ActiveRecord::Base
+end
+
+class OracleSpecificTest < Test::Unit::TestCase
+  include MultibyteTestMethods  # so we can get @java_con
+
+  def setup
+    super
+    @java_con.createStatement.execute "
+      CREATE TABLE DEFAULT_NUMBERS (
+       ID INTEGER NOT NULL PRIMARY KEY, VALUE NUMBER, DATUM DATE, FPOINT NUMBER(10,2), VALUE2 NUMBER(15)
+      )"
+    @java_con.createStatement.execute "
+      INSERT INTO DEFAULT_NUMBERS (ID, VALUE, DATUM, FPOINT, VALUE2)
+                          VALUES (1, 0.076, TIMESTAMP'2009-11-05 00:00:00', 1000.01, 1234)"
+    @java_con.createStatement.execute "CREATE SYNONYM POSTS FOR ENTRIES"
+  end
+
+  def teardown
+    @java_con.createStatement.execute "DROP TABLE DEFAULT_NUMBERS"
+    @java_con.createStatement.execute "DROP SYNONYM POSTS"
+    super
+  end
+
+  def test_default_number_precision
+    assert_equal 0.076, DefaultNumber.find(:first).value
+  end
+
+  def test_number_with_precision_and_scale
+    assert_equal 1000.01, DefaultNumber.find(:first).fpoint
+  end
+
+  def test_number_with_precision
+    assert_equal 1234, DefaultNumber.find(:first).value2
+  end
+
+  def test_number_type_with_precision_and_scale_is_reported_correctly
+    assert_equal 'NUMBER', DefaultNumber.columns_hash['value'].sql_type
+    assert_equal 'NUMBER(10,2)', DefaultNumber.columns_hash['fpoint'].sql_type
+    assert_equal 'NUMBER(15)', DefaultNumber.columns_hash['value2'].sql_type
+  end
+
+  # JRUBY-3675, ACTIVERECORD_JDBC-22
+  def test_load_date
+    obj = DefaultNumber.find(:first)
+    assert_not_nil obj.datum, "no date"
+  end
+
+  # ACTIVERECORD_JDBC-127
+  def test_save_date
+    obj = DefaultNumber.find(:first)
+    obj.datum = '01Jan2010'
+    obj.save!
+  end
+
+  def test_save_timestamp
+    obj = DefaultNumber.find(:first)
+    obj.datum = Time.now
+    obj.save!
+  end
+
+  def test_load_null_date
+    @java_con.createStatement.execute "UPDATE DEFAULT_NUMBERS SET DATUM = NULL"
+    obj = DefaultNumber.find(:first)
+    assert obj.datum.nil?
+  end
+
+  def test_model_access_by_synonym
+    @klass = Class.new(ActiveRecord::Base)
+    @klass.set_table_name "POSTS"
+    entry_columns = Entry.columns_hash
+    @klass.columns.each do |c|
+      ec = entry_columns[c.name]
+      assert ec
+      assert_equal ec.sql_type, c.sql_type
+      assert_equal ec.type, c.type
+    end
+  end
+
+end if defined?(JRUBY_VERSION)

data/test/postgres_db_create_test.rb

@@ -0,0 +1,32 @@
+require 'abstract_db_create'
+require 'db/postgres'
+
+class PostgresDbCreateTest < Test::Unit::TestCase
+  include AbstractDbCreate
+
+  def db_config
+    POSTGRES_CONFIG
+  end
+
+  if find_executable?("psql")
+    def test_rake_db_create
+      Rake::Task["db:create"].invoke
+      output = `psql -d template1 -c '\\l'`
+      assert output =~ /#{@db_name}/m
+    end
+
+    def test_rake_db_test_purge
+      Rake::Task["db:create"].invoke
+      Rake::Task["db:test:purge"].invoke
+    end
+  else
+    def test_skipped
+    end
+  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
+end

data/test/postgres_drop_db_test.rb

@@ -0,0 +1,16 @@
+require 'abstract_db_create'
+require 'db/postgres'
+
+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

data/test/postgres_information_schema_leak_test.rb

@@ -0,0 +1,29 @@
+require 'jdbc_common'
+require 'db/postgres'
+
+class CreateISLSchema < ActiveRecord::Migration
+  def self.up
+    execute "CREATE TABLE domains (id int, name varchar(16))"
+  end
+
+  def self.down
+    execute "DROP TABLE domains"
+  end
+end
+
+class Domain < ActiveRecord::Base
+end
+
+class PostgresInformationSchemaLeakTest < Test::Unit::TestCase
+  def setup
+    CreateISLSchema.up
+  end
+
+  def teardown
+    CreateISLSchema.down
+  end
+
+  def test_columns
+    assert_equal(%w{id name}, Domain.column_names)
+  end
+end  

data/test/postgres_mixed_case_test.rb

@@ -0,0 +1,29 @@
+require 'jdbc_common'
+require 'models/entry'
+require 'models/mixed_case'
+
+class MixedCaseTest < Test::Unit::TestCase
+  def setup
+    Migration::MixedCase.up
+    @table_name = User.table_name
+    User.table_name = 'tblUsers'
+    User.reset_column_information
+  end
+
+  def teardown
+    User.table_name = @table_name
+    User.reset_column_information
+    Migration::MixedCase.down
+  end
+
+  def test_create
+    mixed_case = MixedCase.create :SOME_value => 'some value'
+    assert_equal 'some value', mixed_case.SOME_value
+  end
+
+  def test_find_mixed_table_name
+    User.create :firstName => "Nick", :lastName => "Sieger"
+    u = User.find :first
+    assert_equal "Nick Sieger", "#{u.firstName} #{u.lastName}"
+  end
+end

data/test/postgres_native_type_mapping_test.rb

@@ -0,0 +1,89 @@
+require 'jdbc_common'
+require 'db/postgres'
+
+class CreateNativeTypeMappingTestSchema < ActiveRecord::Migration
+  def self.up
+    execute "DROP SEQUENCE IF EXISTS seq_pk_customers"
+    execute "CREATE SEQUENCE seq_pk_customers"
+    execute %q{
+      CREATE TABLE customers (
+          bigint_serial_should_be_integer bigint default nextval('seq_pk_customers'),
+          integer_serial_should_be_integer integer default nextval('seq_pk_customers'),
+          varchar_should_be_string varchar(2),
+          timestamp_should_be_datetime timestamp,
+          bytea_should_be_binary bytea,
+          double_precision_should_be_float double precision,
+          real_should_be_float real,
+          bool_should_be_boolean bool,
+          interval_should_be_string interval,
+          bigint_should_be_integer bigint,
+          uuid_should_be_string uuid
+      )}
+  end
+
+  def self.down
+    execute "DROP TABLE customers"
+    execute "DROP SEQUENCE IF EXISTS seq_pk_customers"
+  end
+end
+
+class Customer < ActiveRecord::Base
+end
+
+class PostgresNativeTypeMappingTest < Test::Unit::TestCase
+  def setup
+    CreateNativeTypeMappingTestSchema.up
+  end
+
+  def teardown
+    CreateNativeTypeMappingTestSchema.down
+  end
+
+  def column_type(column_name)
+    Customer.columns.detect { |c| c.name == column_name }.type
+  end
+
+  def test_uuid_column_should_map_to_string
+    assert_equal :string, column_type("uuid_should_be_string")
+  end
+  
+  def test_bigint_serial_should_be_mapped_to_integer
+    assert_equal :integer, column_type("bigint_serial_should_be_integer")
+  end
+
+  def test_integer_serial_should_be_mapped_to_integer
+    assert_equal :integer, column_type("integer_serial_should_be_integer")
+  end
+
+  def test_varchar_should_be_mapped_to_string
+    assert_equal :string, column_type("varchar_should_be_string")
+  end
+
+  def test_timestamp_should_be_mapped_to_datetime
+    assert_equal :datetime, column_type("timestamp_should_be_datetime")
+  end
+
+  def test_bytea_should_be_mapped_to_binary
+    assert_equal :binary, column_type("bytea_should_be_binary")
+  end
+
+  def test_double_precision_should_be_mapped_to_float
+    assert_equal :float, column_type("double_precision_should_be_float")
+  end
+
+  def test_real_should_be_mapped_to_float
+    assert_equal :float, column_type("real_should_be_float")
+  end
+
+  def test_bool_should_be_mapped_to_boolean
+    assert_equal :boolean, column_type("bool_should_be_boolean")
+  end
+
+  def test_interval_should_be_mapped_to_string
+    assert_equal :string, column_type("interval_should_be_string")
+  end
+
+  def test_bigint_should_be_mapped_to_integer
+    assert_equal :integer, column_type("bigint_should_be_integer")
+  end
+end

data/test/postgres_nonseq_pkey_test.rb

@@ -0,0 +1,38 @@
+require 'jdbc_common'
+require 'db/postgres'
+
+class CreateUrls < ActiveRecord::Migration
+  def self.up
+    create_table 'urls', :id => false do |t|
+      t.text :uhash, :null => false
+      t.text :url,  :null => false
+    end
+    execute "ALTER TABLE urls ADD PRIMARY KEY (uhash)"
+  end
+  def self.down
+    drop_table 'urls'
+  end
+end
+
+class Url < ActiveRecord::Base
+  set_primary_key :uhash
+  #Shouldn't be needed: set_sequence_name nil
+end
+
+class PostgresNonSeqPKey < Test::Unit::TestCase
+  def setup
+    CreateUrls.up
+  end
+
+  def teardown
+    CreateUrls.down
+  end
+
+  def test_create
+    url = Url.create! do |u|
+      u.uhash = 'uhash'
+      u.url = 'http://url'
+    end
+    assert_equal( 'uhash', url.uhash )
+  end
+end