activerecord-jdbc-adapter-onsite 1.2.2

data/test/oracle_reset_column_information_test.rb

@@ -0,0 +1,8 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/oracle'
+
+class OracleResetColumnInformationTest < Test::Unit::TestCase
+  include ResetColumnInformationTestMethods
+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.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,93 @@
+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"
+    columns = [
+               "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"
+              ]
+    columns << "uuid_should_be_string uuid" if PG_VERSION >= 80300
+    table_sql = %Q{
+      CREATE TABLE customers (
+        #{columns.join(",\n")}
+      )}
+    execute table_sql
+  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") if PG_VERSION >= 80300
+  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
+  self.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

data/test/postgres_reserved_test.rb

@@ -0,0 +1,22 @@
+require 'jdbc_common'
+require 'db/postgres'
+require 'models/reserved_word'
+
+class PostgresReservedWordsTest < Test::Unit::TestCase
+  def setup
+    CreateReservedWords.up
+  end
+  def teardown
+    CreateReservedWords.down
+  end
+
+  def test_quote_reserved_word_column
+    columns = ReservedWord.column_names - ["id"]
+    ReservedWord.connection.add_index :reserved_words, columns
+    indexes = ReservedWord.connection.indexes("reserved_words")
+    assert_equal 1, indexes.size
+    columns.each do |c|
+      assert indexes[0].columns.include?(c), "#{indexes[0].columns.inspect} does not include #{c.inspect}"
+    end
+  end
+end

data/test/postgres_reset_column_information_test.rb

@@ -0,0 +1,8 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/postgres'
+
+class PostgresResetColumnInformationTest < Test::Unit::TestCase
+  include ResetColumnInformationTestMethods
+end

data/test/postgres_schema_search_path_test.rb

@@ -0,0 +1,48 @@
+require 'jdbc_common'
+require 'db/postgres'
+
+class CreateSchema < ActiveRecord::Migration
+  def self.up
+    execute "CREATE SCHEMA test"
+    execute "CREATE TABLE test.people (id serial, name text)"
+    execute "INSERT INTO test.people (name) VALUES ('Alex')"
+    execute "CREATE TABLE public.people (id serial, wrongname text)"
+  end
+
+  def self.down
+    execute "DROP SCHEMA test CASCADE"
+    execute "DROP TABLE people"
+  end
+end
+
+class Person < ActiveRecord::Base
+  establish_connection POSTGRES_CONFIG.merge(:schema_search_path => 'test,public')
+end
+
+class PostgresSchemaSearchPathTest < Test::Unit::TestCase
+  def setup
+    CreateSchema.up
+  end
+
+  def teardown
+    CreateSchema.down
+  end
+
+  def test_columns
+    assert_equal(%w{id name}, Person.column_names)
+  end
+
+  def test_find_right
+    assert_not_nil Person.find_by_name("Alex")
+  end
+
+  def test_find_wrong
+    assert_raise NoMethodError do
+      Person.find_by_wrongname("Alex")
+    end
+  end
+  def test_column_information
+    assert Person.columns.map{|col| col.name}.include?("name")
+    assert !Person.columns.map{|col| col.name}.include?("wrongname")
+  end
+end

data/test/postgres_simple_test.rb

@@ -0,0 +1,168 @@
+# To run this script, set up the following postgres user and database:
+#
+#   sudo -u postgres createuser -D -A -P blog
+#   sudo -u postgres createdb -O blog weblog_development
+#
+
+require 'jdbc_common'
+require 'db/postgres'
+
+class PostgresSimpleTest < Test::Unit::TestCase
+  include SimpleTestMethods
+  include ActiveRecord3TestMethods
+  include ColumnNameQuotingTests
+
+  def test_adapter_class_name_equals_native_adapter_class_name
+    classname = @connection.class.name[/[^:]*$/]
+    assert_equal 'PostgreSQLAdapter', classname
+  end
+
+  def test_encoding
+    assert_not_nil @connection.encoding
+  end
+
+  def test_multi_statement_support
+    results = @connection.execute "SELECT title from entries; SELECT login from users"
+    assert_equal 2, results.length
+    assert_equal ["title"], results[0].first.keys
+    assert_equal ["login"], results[1].first.keys
+  end
+
+  def test_create_xml_column
+    return unless PG_VERSION >= 80300
+    assert_nothing_raised do
+      @connection.create_table :xml_testings do |t|
+        t.column :xml_test, :xml
+      end
+    end
+
+    xml_test = @connection.columns(:xml_testings).detect do
+      |c| c.name == "xml_test"
+    end
+
+    assert_equal "xml", xml_test.sql_type
+  ensure
+    @connection.drop_table :xml_testings rescue nil
+  end
+
+  def test_create_table_with_limits
+    assert_nothing_raised do
+      @connection.create_table :testings do |t|
+        t.column :eleven_int, :integer, :limit => 11
+      end
+    end
+
+    columns = @connection.columns(:testings)
+    eleven = columns.detect { |c| c.name == "eleven_int" }
+    assert_equal "integer", eleven.sql_type
+  ensure
+    @connection.drop_table :testings rescue nil
+  end
+end
+
+class PostgresTimestampTest < Test::Unit::TestCase
+  def setup
+    DbTypeMigration.up
+  end
+
+  def teardown
+    DbTypeMigration.down
+  end
+
+  def test_string_is_character_varying
+    sample_string = DbType.connection.columns(:db_types).detect do |c|
+      c.name == "sample_string"
+    end
+
+    assert_match(/^character varying/, sample_string.sql_type)
+  end
+
+  # infinite timestamp tests based on rails tests for postgresql_adapter.rb
+  def test_load_infinity_and_beyond
+    d = DbType.find_by_sql("select 'infinity'::timestamp as sample_timestamp")
+    assert d.first.sample_timestamp.infinite?, 'timestamp should be infinite'
+
+    d = DbType.find_by_sql "select '-infinity'::timestamp as sample_timestamp"
+    time = d.first.sample_timestamp
+    assert time.infinite?, "timestamp should be infinte"
+    assert_operator time, :<, 0
+  end
+
+  def test_save_infinity_and_beyond
+    d = DbType.create!(:sample_timestamp => 1.0 / 0.0)
+    assert_equal(1.0 / 0.0, d.sample_timestamp)
+
+    e = DbType.create!(:sample_timestamp => -1.0 / 0.0)
+    assert_equal(-1.0 / 0.0, e.sample_timestamp)
+  end
+end
+
+class PostgresDeserializationTest < Test::Unit::TestCase
+  def setup
+    DbTypeMigration.up
+  end
+
+  def teardown
+    DbTypeMigration.down
+  end
+
+  def test_should_keep_float_precision
+    expected = DbType.create(:sample_float => 7.3)
+    actual = DbType.find(expected.id)
+
+    assert_equal expected.sample_float, actual.sample_float
+  end
+end
+
+class PostgresSchemaDumperTest < Test::Unit::TestCase
+  def setup
+    DbTypeMigration.up
+    @connection = ActiveRecord::Base.connection
+    strio = StringIO.new
+    ActiveRecord::SchemaDumper::dump(ActiveRecord::Base.connection, strio)
+    @dump = strio.string
+  end
+
+  def teardown
+    DbTypeMigration.down
+  end
+
+  # http://kenai.com/jira/browse/ACTIVERECORD_JDBC-135
+  def test_schema_dump_should_not_have_limits_on_boolean
+    lines = @dump.lines.grep(/boolean/)
+    assert !lines.empty?
+    lines.each {|line| assert line !~ /limit/ }
+  end
+
+
+  def test_schema_dump_should_not_have_limits_on_binaries
+    lines = @dump.lines.grep(/binary/)
+    assert !lines.empty?, 'no binary type definitions found'
+    lines.each {|line| assert line !~ /limit/, 'binary definition contains limit' }
+  end
+
+  # http://kenai.com/jira/browse/ACTIVERECORD_JDBC-139
+  def test_schema_dump_should_not_have_limits_on_text_or_date
+    lines = @dump.lines.grep(/date|text/)
+    assert !lines.empty?
+    lines.each {|line| assert line !~ /limit/ }
+  end
+
+  def test_schema_dump_integer_with_no_limit_should_have_no_limit
+    lines = @dump.lines.grep(/sample_integer_no_limit/)
+    assert !lines.empty?
+    lines.each {|line| assert line !~ /:limit/ }
+  end
+
+  def test_schema_dump_integer_with_limit_2_should_have_limit_2
+    lines = @dump.lines.grep(/sample_integer_with_limit_2/)
+    assert !lines.empty?
+    lines.each {|line| assert line =~ /limit => 2/ }
+  end
+
+  def test_schema_dump_integer_with_limit_8_should_have_limit_8
+    lines = @dump.lines.grep(/sample_integer_with_limit_8/)
+    assert !lines.empty?
+    lines.each {|line| assert line =~ /limit => 8/ }
+  end
+end