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

data/test/db/postgres/rake_test.rb

@@ -1,117 +0,0 @@
-require 'rake_test_support'
-require 'db/postgres'
-
-class PostgresRakeTest < Test::Unit::TestCase
-  include RakeTestSupport
-
-  def db_config
-    POSTGRES_CONFIG
-  end
-
-  def do_teardown
-    drop_rake_test_database(:silence)
-  end
-  
-  PSQL_EXECUTABLE = find_executable?("psql")
-  
-  test 'rake db:create (and db:drop)' do
-    Rake::Task["db:create"].invoke
-    if PSQL_EXECUTABLE
-      output = psql("-d template1 -c '\\\l'")
-      assert_match /#{db_name}/m, output
-    end
-    
-    Rake::Task["db:drop"].invoke
-    if PSQL_EXECUTABLE
-      output = psql("-d template1 -c '\\\l'")
-      assert_no_match /#{db_name}/m, output
-    end
-  end
-
-  test 'rake db:drop (non-existing database)' do
-    drop_rake_test_database(:silence)
-    Rake::Task["db:drop"].invoke
-  end
-  
-  test 'rake db:test:purge' do
-    # Rake::Task["db:create"].invoke
-    create_rake_test_database do |connection|
-      connection.create_table('users') { |t| t.string :name }
-    end
-    
-    Rake::Task["db:test:purge"].invoke
-
-    ActiveRecord::Base.establish_connection db_config.merge :database => db_name
-    assert_false ActiveRecord::Base.connection.table_exists?('users')
-    ActiveRecord::Base.connection.disconnect!
-  end
-
-  test 'rake db:charset' do
-    create_rake_test_database
-    expect_rake_output 'UTF8'
-    Rake::Task["db:charset"].invoke
-  end
-
-  test 'rake db:collation' do
-    create_rake_test_database
-    expect_rake_output /\w*?\.UTF-8/ # en_US.UTF-8
-    Rake::Task["db:collation"].invoke
-  end
-  
-  test 'rake db:structure:dump (and db:structure:load)' do
-    omit('pg_dump not available') unless self.class.find_executable?('pg_dump')
-    # Rake::Task["db:create"].invoke
-    create_rake_test_database do |connection|
-      create_schema_migrations_table(connection)
-      connection.create_table('users') { |t| t.string :name; t.timestamps }
-    end
-    
-    structure_sql = File.join('db', structure_sql_filename)
-    begin
-      Dir.mkdir 'db' # db/structure.sql
-      Rake::Task["db:structure:dump"].invoke
-      
-      assert File.exists?(structure_sql)
-      assert_match /CREATE TABLE users/, File.read(structure_sql)
-      
-      # db:structure:load
-      drop_rake_test_database(:silence)
-      create_rake_test_database
-      Rake::Task["db:structure:load"].invoke
-      
-      ActiveRecord::Base.establish_connection db_config.merge :database => db_name
-      assert ActiveRecord::Base.connection.table_exists?('users')
-      ActiveRecord::Base.connection.disconnect!
-    ensure
-      File.delete(structure_sql) if File.exists?(structure_sql)
-      Dir.rmdir 'db'
-    end
-  end
-  
-  setup { rm_r 'db' if File.exist?('db') }
-  
-  test 'rake db:create does not load full environment' do
-    begin
-      Rake::Task["db:create"].invoke
-      assert @rails_env_set
-      assert ! ( @full_environment_loaded ||= nil )
-    ensure
-      # Rake::Task["db:drop"].invoke rescue nil
-      drop_rake_test_database(:silence)
-    end
-  end if ActiveRecord::VERSION::MAJOR < 4
-  
-  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/reserved_test.rb

@@ -1,22 +0,0 @@
-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/db/postgres/reset_column_information_test.rb

@@ -1,6 +0,0 @@
-require 'jdbc_common'
-require 'db/postgres'
-
-class PostgresResetColumnInformationTest < Test::Unit::TestCase
-  include ResetColumnInformationTestMethods
-end

data/test/db/postgres/row_locking_test.rb

@@ -1,21 +0,0 @@
-require 'jdbc_common'
-require 'db/postgres'
-require 'row_locking'
-
-class PostgresRowLockingTest < Test::Unit::TestCase
-  include MigrationSetup
-  include RowLockingTestMethods
-  
-  def self.startup
-    MigrationSetup.setup!
-  end
-  
-  def setup!; nil; end
-
-  def self.shutdown
-    MigrationSetup.teardown!
-  end
-  
-  def teardown!; nil; end
-  
-end

data/test/db/postgres/schema_dump_test.rb

@@ -1,95 +0,0 @@
-# encoding: utf-8
-require 'db/postgres'
-require 'schema_dump'
-
-class PostgresSchemaDumpTest < Test::Unit::TestCase
-  include SchemaDumpTestMethods
-  
-  def self.startup
-    super
-    MigrationSetup.setup!
-  end
-  
-  def self.shutdown
-    MigrationSetup.teardown!
-    super
-  end
-
-  def setup!; end # MigrationSetup#setup!
-  def teardown!; end # MigrationSetup#teardown!
-  
-  def test_schema_dump_includes_xml_shorthand_definition
-    output = standard_dump
-    if %r{create_table "postgresql_xml_data_type"} =~ output
-      assert_match %r{t.xml "data"}, output
-    end
-  end
-
-  def test_schema_dump_includes_tsvector_shorthand_definition
-    output = standard_dump
-    if %r{create_table "postgresql_tsvectors"} =~ output
-      assert_match %r{t.tsvector "text_vector"}, output
-    end
-  end
-  
-  #
-
-  # http://kenai.com/jira/browse/ACTIVERECORD_JDBC-135
-  def test_schema_dump_should_not_have_limits_on_boolean
-    dump = dump_with_data_types
-    lines = dump.lines.grep(/boolean/)
-    assert ! lines.empty?, "no boolean type definition found in: #{dump}"
-    lines.each {|line| assert line !~ /limit/ }
-  end
-
-  def test_schema_dump_should_not_have_limits_on_binaries
-    dump = dump_with_data_types
-    lines = dump.lines.grep(/binary/)
-    assert ! lines.empty?, "no binary type definitions found in: #{dump}"
-    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
-    dump = dump_with_data_types
-    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
-    dump = dump_with_data_types
-    lines = dump.lines.grep(/sample_integer_no_limit/)
-    assert ! lines.empty?
-    lines.each { |line| assert line !~ /:limit|limit:/ }
-  end
-
-  def test_schema_dump_integer_with_limit_2_should_have_limit_2
-    dump = dump_with_data_types
-    lines = dump.lines.grep(/sample_integer_with_limit_2/)
-    assert ! lines.empty?
-    lines.each {|line| assert line =~ /(limit => 2)|(limit: 2)/ }
-  end
-
-  def test_schema_dump_integer_with_limit_8_should_have_limit_8
-    dump = dump_with_data_types
-    lines = dump.lines.grep(/sample_integer_with_limit_8/)
-    assert ! lines.empty?
-    lines.each {|line| assert line =~ /(limit => 8)|(limit: 8)/ }
-  end
-
-  def test_schema_dumps_partial_indices
-    index_definition = standard_dump.split(/\n/).grep(/add_index.*thing_partial_index/).first.strip
-
-    assert_equal 'add_index "things", ["created_at"], name: "thing_partial_index", where: "(name IS NOT NULL)", using: :btree', index_definition
-  end if ar_version('4.0')
-
-  private
-
-  def dump_with_data_types(io = StringIO.new)
-    ActiveRecord::SchemaDumper.ignore_tables = [/^[^d]/] # keep data_types
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, io)
-    io.string
-  end
-  
-end

data/test/db/postgres/schema_test.rb

@@ -1,115 +0,0 @@
-require 'test_helper'
-require 'db/postgres'
-
-class PostgresSchemaTest < Test::Unit::TestCase
-  
-  def test_create_schema
-    begin
-      connection.create_schema "test_schema3"
-      assert connection.schema_names.include? "test_schema3"
-    ensure
-      connection.drop_schema "test_schema3"
-    end
-  end
-
-  def test_raise_create_schema_with_existing_schema
-    begin
-      connection.create_schema "test_schema3"
-      disable_logger(connection) do
-        assert_raise(ActiveRecord::StatementInvalid) do
-          connection.create_schema "test_schema3"
-        end
-      end
-    ensure
-      connection.drop_schema "test_schema3"
-    end
-  end
-
-  def test_drop_schema
-    begin
-      connection.create_schema "test_schema3" 
-    ensure
-      connection.drop_schema "test_schema3"
-    end
-    assert ! connection.schema_names.include?("test_schema3")
-  end 
-  
-  def test_collation
-    assert_equal 'en_US.UTF-8', connection.collation
-  end
-
-  def test_encoding
-    assert_equal 'UTF8', connection.encoding
-  end
-
-  def test_ctype
-    assert connection.ctype
-  end
-  
-  def test_current_database
-    db = ActiveRecord::Base.connection.config[:database]
-    assert_equal db, connection.current_database
-  end
-  
-  def test_current_schema
-    assert_equal 'public', connection.current_schema
-  end
-  
-  def test_schema_exists?
-    assert connection.schema_exists?('public')
-    assert ! connection.schema_exists?('missing')
-  end
-  
-  def test_schema_names
-    assert_equal [ "public" ], connection.schema_names
-  end
-  
-  context "search path" do
-
-    def test_schema_names
-      assert_equal [ "public", "test" ], connection.schema_names
-    end
-    
-    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 
-    
-    setup { CreateSchema.up }
-    teardown { CreateSchema.down }
-
-    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_include Person.columns.map{ |col| col.name }, "name"
-      assert ! Person.columns.map{ |col| col.name }.include?("wrongname")
-    end
-    
-  end
-  
-end

data/test/db/postgres/simple_test.rb

@@ -1,260 +0,0 @@
-# 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
-  include DirtyAttributeTests
-  include XmlColumnTests
-  include CustomSelectTestMethods
-  
-  def test_adapter_class_name_equals_native_adapter_class_name
-    classname = connection.class.name[/[^:]*$/]
-    assert_equal 'PostgreSQLAdapter', classname
-  end
-
-  def test_schema_search_path
-    assert_equal connection.schema_search_path, "\"$user\",public"
-  end
-
-  def test_current_schema
-    assert_equal connection.current_schema, "public"
-  end
-
-  def test_encoding
-    assert_not_nil connection.encoding
-  end
-
-  def test_multi_statement_support
-    user = User.create! :login => 'jozko'
-    Entry.create! :title => 'eee', :user_id => user.id
-    
-    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_find_by_sql_WITH_statement
-    user = User.create! :login => 'ferko'
-    Entry.create! :title => 'aaa', :user_id => user.id
-    entries = Entry.find_by_sql '' + 
-      '( ' + 
-      'WITH EntryAndUser (title, login, updated_on) AS ' +
-      ' ( ' +
-      ' SELECT e.title, u.login, e.updated_on ' + 
-      ' FROM entries e INNER JOIN users u ON e.user_id = u.id ' +
-      ' ) ' +
-      'SELECT * FROM EntryAndUser ORDER BY title ASC ' +
-      ') '
-    assert entries.first
-    assert entries.first.title
-    assert entries.first.login
-  end
-  
-  def test_create_xml_column
-    return unless PG_VERSION >= 80300
-    super
-  end if ar_version('3.1')
-  def xml_sql_type; 'xml'; end
-  
-  def test_create_table_with_limits
-    if ar_version('4.0')
-      # No integer type has byte size 11. Use a numeric with precision 0 instead.
-      connection.create_table :testings do |t|
-        t.column :an_int, :integer, :limit => 8
-      end
-      
-      columns = connection.columns(:testings)
-      an_int = columns.detect { |c| c.name == "an_int" }
-      assert_equal "bigint", an_int.sql_type
-    else
-      assert_nothing_raised do
-        connection.create_table :testings do |t|
-          t.column :an_int, :integer, :limit => 11
-        end
-      end
-      
-      columns = connection.columns(:testings)
-      an_int = columns.detect { |c| c.name == "an_int" }
-      assert_equal "integer", an_int.sql_type
-    end
-  ensure
-    connection.drop_table :testings rescue nil
-  end
-
-  def test_resolves_correct_columns_default
-    assert column = DbType.columns.find { |col| col.name == 'sample_small_decimal' }
-    assert_equal 3.14, column.default
-    assert column = DbType.columns.find { |col| col.name == 'sample_integer_no_limit' }
-    assert_equal 42, column.default
-    assert column = DbType.columns.find { |col| col.name == 'sample_integer_neg_default' }
-    assert_equal -1, column.default
-  end
-  
-  def test_supports_standard_conforming_string
-    assert([true, false].include?(connection.supports_standard_conforming_strings?))
-  end
-
-  def test_standard_conforming_string_default_set_on_new_connections
-    c = ActiveRecord::Base.postgresql_connection(POSTGRES_CONFIG)
-    assert_equal true, c.instance_variable_get("@standard_conforming_strings")
-  end
-
-  def test_default_standard_conforming_string
-    if connection.supports_standard_conforming_strings?
-      assert_equal true, connection.standard_conforming_strings?
-    else
-      assert_equal false, connection.standard_conforming_strings?
-    end
-  end
-
-  def test_string_quoting_with_standard_conforming_strings
-    if connection.supports_standard_conforming_strings?
-      s = "\\m it's \\M"
-      assert_equal "'\\m it''s \\M'", connection.quote(s)
-    end
-  end
-
-  def test_string_quoting_without_standard_conforming_strings
-    connection.standard_conforming_strings = false
-    s = "\\m it's \\M"
-    assert_equal "'\\\\m it''s \\\\M'", connection.quote(s)
-    connection.standard_conforming_strings = true
-  end
-  
-  include ExplainSupportTestMethods if ar_version("3.1")
-  
-  def test_primary_key
-    assert_equal 'id', connection.primary_key('entries')
-    assert_equal 'custom_id', connection.primary_key('custom_pk_names')
-    # assert_equal 'id', connection.primary_key('auto_ids')
-  end
-
-  def test_primary_key_without_sequence
-    connection.execute "CREATE TABLE uid_table (uid UUID PRIMARY KEY, name TEXT)"
-    assert_equal 'uid', connection.primary_key('uid_table')
-  ensure
-    connection.execute "DROP TABLE uid_table"
-  end
-  
-  def test_extensions
-    if connection.supports_extensions?
-      assert_include connection.extensions, 'plpgsql'
-      assert connection.extension_enabled?('plpgsql')
-      assert ! connection.extension_enabled?('invalid')
-    else
-      assert_empty connection.extensions
-    end
-  end
-  
-end
-
-class PostgresTimestampTest < Test::Unit::TestCase
-  
-  def self.startup
-    DbTypeMigration.up
-  end
-
-  def self.shutdown
-    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
-  
-  def test_select_infinity
-    d = DbType.find_by_sql("select 'infinity'::timestamp as sample_timestamp").first
-    assert d.sample_timestamp.infinite?, "timestamp: #{d.sample_timestamp.inspect} should be infinite"
-
-    d = DbType.find_by_sql("select '-infinity'::timestamp as sample_timestamp").first
-    
-    time = d.sample_timestamp
-    assert time.infinite?, "timestamp: #{time.inspect} should be infinte"
-    assert_operator time, :<, 0
-  end
-
-  def test_save_infinity
-    if ar_version('4.0')
-      # NOTE: likely an AR issue - it only works when time_zone_aware_attributes
-      # are disabled otherwise TimeZoneConversion's define_method_attribute=(attr_name)
-      # does the following code ("infinite" time instance ending as nil): 
-      # time_with_zone = time.respond_to?(:in_time_zone) ? time.in_time_zone : nil
-      tz_aware_attributes = ActiveRecord::Base.time_zone_aware_attributes
-      begin
-        ActiveRecord::Base.time_zone_aware_attributes = false
-        do_test_save_infinity
-      ensure
-        ActiveRecord::Base.time_zone_aware_attributes = tz_aware_attributes
-      end
-    else
-      do_test_save_infinity
-    end
-  end
-  
-  def do_test_save_infinity
-    d = DbType.new
-    d.sample_datetime = 1.0 / 0.0
-    d.save!
-    
-    if ar_version('3.0')
-      assert_equal 1.0 / 0.0, d.reload.sample_datetime # sample_timestamp
-    else # 2.3
-      assert_equal nil, d.reload.sample_datetime # d.sample_timestamp
-    end
-    
-    d = DbType.create!(:sample_timestamp => -1.0 / 0.0)
-    if ar_version('3.0')
-      assert_equal -1.0 / 0.0, d.sample_timestamp
-    else # 2.3
-      assert_equal nil, d.sample_timestamp
-    end
-  end
-  private :do_test_save_infinity
-  
-  def test_bc_timestamp
-    if RUBY_VERSION == '1.9.3' && defined?(JRUBY_VERSION) && JRUBY_VERSION =~ /1\.7\.3|4/
-      omit "Date.new(0) issue on JRuby 1.7.3/4" 
-    end
-    # JRuby 1.7.3 (--1.9) bug: `Date.new(0) + 1.seconds` "1753-08-29 22:43:42 +0057"
-    date = Date.new(0) - 1.second
-    db_type = DbType.create!(:sample_timestamp => date)
-    assert_equal date, db_type.reload.sample_timestamp
-  end if ar_version('3.0')
-  
-end
-
-class PostgresDeserializationTest < Test::Unit::TestCase
-
-  def self.startup
-    DbTypeMigration.up
-  end
-
-  def self.shutdown
-    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 PostgresHasManyThroughTest < Test::Unit::TestCase
-  include HasManyThroughMethods
-end