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

data/test/db/sqlite3/has_many_though_test.rb

@@ -1,6 +0,0 @@
-require 'db/sqlite3'
-require 'has_many_through'
-
-class SQLite3HasManyThroughTest < Test::Unit::TestCase
-  include HasManyThroughMethods
-end

data/test/db/sqlite3/rake_test.rb

@@ -1,71 +0,0 @@
-require 'rake_test_support'
-require 'db/sqlite3'
-
-class SQLite3RakeTest < Test::Unit::TestCase
-  include RakeTestSupport
-  
-  def db_name; 'rake_test.sqlite3'; end
-  
-  def do_setup
-    File.delete('rake_test.sqlite3') if File.exists?('rake_test.sqlite3')
-  end
-  
-  def do_teardown
-    File.delete('rake_test.sqlite3') if File.exists?('rake_test.sqlite3')
-  end
-
-  test 'rake db:create (and db:drop)' do
-    Rake::Task["db:create"].invoke
-    assert_true File.exists?('rake_test.sqlite3')
-    
-    Rake::Task["db:drop"].invoke
-    assert_false File.exists?('rake_test.sqlite3')
-  end
-  
-  test 'rake db:test:purge' do
-    # Rake::Task["db:create"].invoke
-    ActiveRecord::Base.establish_connection db_config.merge :database => db_name
-    ActiveRecord::Base.connection.create_table('users') { |t| t.string :name }
-    ActiveRecord::Base.connection.disconnect!
-    
-    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:structure:dump (and db:structure:load)' do
-    omit('sqlite3 not available') unless self.class.find_executable?('sqlite3')
-    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
-      File.delete('rake_test.sqlite3')
-      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
-  
-  test 'rake db:charset' do
-    expect_rake_output('UTF-8')
-    Rake::Task["db:charset"].invoke
-  end
-  
-end

data/test/db/sqlite3/reset_column_information_test.rb

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

data/test/db/sqlite3/schema_dump_test.rb

@@ -1,6 +0,0 @@
-require 'db/sqlite3'
-require 'schema_dump'
-
-class SQLite3SchemaDumpTest < Test::Unit::TestCase
-  include SchemaDumpTestMethods
-end

data/test/db/sqlite3/serialize_test.rb

@@ -1,6 +0,0 @@
-require 'db/sqlite3'
-require 'serialize'
-
-class SQLite3SerializeTest < Test::Unit::TestCase
-  include SerializeTestMethods
-end

data/test/db/sqlite3/simple_test.rb

@@ -1,268 +0,0 @@
-require 'db/sqlite3'
-require 'models/data_types'
-require 'models/validates_uniqueness_of_string'
-require 'simple'
-require 'jdbc_common'
-
-class SQLite3SimpleTest < Test::Unit::TestCase
-  include SimpleTestMethods
-  include ActiveRecord3TestMethods
-  include ColumnNameQuotingTests
-  include DirtyAttributeTests
-  include XmlColumnTests
-  include ExplainSupportTestMethods if ar_version("3.1")
-  include CustomSelectTestMethods
-  
-  def test_recreate_database
-    assert connection.tables.include?(Entry.table_name)
-    db = connection.database_name
-    connection.recreate_database(db)
-    assert ! connection.tables.include?(Entry.table_name)
-    self.setup # avoid teardown complaining
-  end
-
-  def test_execute_insert
-    user = User.create! :login => 'user1'
-    Entry.create! :title => 'E1', :user_id => user.id
-    
-    assert_equal 1, Entry.count
-    id = connection.execute "INSERT INTO entries (title, content) VALUES ('Execute Insert', 'This now works with SQLite3')"
-    assert_equal Entry.last.id, id
-    assert_equal 2, Entry.count
-  end
-
-  def test_execute_update
-    user = User.create! :login => 'user1'
-    Entry.create! :title => 'E1', :user_id => user.id
-    
-    affected_rows = connection.execute "UPDATE entries SET title = 'Execute Update' WHERE id = #{Entry.first.id}"
-    assert_equal 1, affected_rows
-    assert_equal 'Execute Update', Entry.first.title
-  end
-
-  def test_columns
-    cols = ActiveRecord::Base.connection.columns("entries")
-    assert cols.find {|col| col.name == "title"}
-  end
-
-  def test_remove_column
-    assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        add_column "entries", "test_remove_column", :string
-      end
-    end
-
-    cols = ActiveRecord::Base.connection.columns("entries")
-    assert cols.find {|col| col.name == "test_remove_column"}
-
-    #assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        remove_column "entries", "test_remove_column"
-      end
-    #end
-
-    cols = ActiveRecord::Base.connection.columns("entries")
-    assert_nil cols.find {|col| col.name == "test_remove_column"}
-  end
-
-  def test_rename_column
-    #assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        rename_column "entries", "title", "name"
-      end
-    #end
-
-    cols = ActiveRecord::Base.connection.columns("entries")
-    assert_not_nil cols.find {|col| col.name == "name"}
-    assert_nil cols.find {|col| col.name == "title"}
-
-    assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        rename_column "entries", "name", "title"
-      end
-    end
-
-    cols = ActiveRecord::Base.connection.columns("entries")
-    assert_not_nil cols.find {|col| col.name == "title"}
-    assert_nil cols.find {|col| col.name == "name"}
-  end
-
-  def test_rename_column_preserves_content
-    title = "First post!"
-    content = "Hello from JRuby on Rails!"
-    rating = 205.76
-    user = User.create! :login => "something"
-    entry = Entry.create! :title => title, :content => content, :rating => rating, :user => user
-    
-    entry.reload
-    #assert_equal title, entry.title
-    #assert_equal content, entry.content
-    #assert_equal rating, entry.rating
-
-    ActiveRecord::Schema.define do
-      rename_column "entries", "title", "name"
-      rename_column "entries", "rating", "popularity"
-    end
-    
-    entry = Entry.find(entry.id)
-    assert_equal title, entry.name
-    assert_equal content, entry.content
-    assert_equal rating, entry.popularity
-  end
-
-  def test_rename_column_preserves_index
-    assert_equal(0, connection.indexes(:entries).size)
-
-    index_name = "entries_index"
-
-    ActiveRecord::Schema.define do
-      add_index "entries", "title", :name => index_name
-    end
-
-    indexes = connection.indexes(:entries)
-    assert_equal(1, indexes.size)
-    assert_equal "entries", indexes.first.table.to_s
-    assert_equal index_name, indexes.first.name
-    assert ! indexes.first.unique
-    assert_equal ["title"], indexes.first.columns
-
-    ActiveRecord::Schema.define do
-      rename_column "entries", "title", "name"
-    end
-
-    indexes = connection.indexes(:entries)
-    assert_equal(1, indexes.size)
-    assert_equal "entries", indexes.first.table.to_s
-    assert_equal index_name, indexes.first.name
-    assert ! indexes.first.unique
-    assert_equal ["name"], indexes.first.columns
-  end
-
-  def test_column_default
-    assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        add_column "entries", "test_column_default", :string
-      end
-    end
-
-    columns = ActiveRecord::Base.connection.columns("entries")
-    assert column = columns.find{ |c| c.name == "test_column_default" }
-    assert_equal column.default, nil
-  end
-
-  def test_change_column_default
-    assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        add_column "entries", "test_change_column_default", :string, :default => "unchanged"
-      end
-    end
-
-    columns = ActiveRecord::Base.connection.columns("entries")
-    assert column = columns.find{ |c| c.name == "test_change_column_default" }
-    assert_equal column.default, 'unchanged'
-
-    assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        change_column_default "entries", "test_change_column_default", "changed"
-      end
-    end
-
-    columns = ActiveRecord::Base.connection.columns("entries")
-    assert column = columns.find{ |c| c.name == "test_change_column_default" }
-    assert_equal column.default, 'changed'
-  end
-
-  def test_change_column
-    assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        add_column "entries", "test_change_column", :string
-      end
-    end
-
-    columns = ActiveRecord::Base.connection.columns("entries")
-    assert column = columns.find{ |c| c.name == "test_change_column" }
-    assert_equal column.type, :string
-
-    assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        change_column "entries", "test_change_column", :integer
-      end
-    end
-
-    columns = ActiveRecord::Base.connection.columns("entries")
-    assert column = columns.find{ |c| c.name == "test_change_column" }
-    assert_equal column.type, :integer
-  end
-
-  def test_change_column_with_new_precision_and_scale
-    Entry.delete_all
-    Entry.
-      connection.
-      change_column "entries", "rating", :decimal, :precision => 9, :scale => 7
-    Entry.reset_column_information
-    change_column = Entry.columns_hash["rating"]
-    assert_equal 9, change_column.precision
-    assert_equal 7, change_column.scale
-  end
-
-  def test_change_column_preserve_other_column_precision_and_scale
-    Entry.delete_all
-    Entry.
-      connection.
-      change_column "entries", "rating", :decimal, :precision => 9, :scale => 7
-    Entry.reset_column_information
-
-    rating_column = Entry.columns_hash["rating"]
-    assert_equal 9, rating_column.precision
-    assert_equal 7, rating_column.scale
-
-    Entry.
-      connection.
-      change_column "entries", "title", :string, :null => false
-    Entry.reset_column_information
-
-    rating_column = Entry.columns_hash["rating"]
-    assert_equal 9, rating_column.precision
-    assert_equal 7, rating_column.scale
-  end
-
-  def test_delete_sql
-    ActiveRecord::Base.connection.send :delete_sql, "DELETE FROM entries"
-    assert Entry.all.empty?
-  end
-  
-  # @override
-  def test_big_decimal
-    test_value = 1234567890.0 # FINE just like native adapter
-    db_type = DbType.create!(:big_decimal => test_value)
-    db_type = DbType.find(db_type.id)
-    assert_equal test_value, db_type.big_decimal
-
-    test_value = 1234567890_123456 # FINE just like native adapter
-    db_type = DbType.create!(:big_decimal => test_value)
-    db_type = DbType.find(db_type.id)
-    assert_equal test_value, db_type.big_decimal
-    
-    # NOTE: this is getting f*cked up in the native adapter as well although 
-    # differently and only when inserted manually - works with PSs (3.1+) :
-    test_value = 1234567890_1234567890.0
-    db_type = DbType.create!(:big_decimal => test_value)
-    db_type = DbType.find(db_type.id)
-    # TODO native gets us 12345678901234567000.0 JDBC gets us 1
-    #assert_equal test_value, db_type.big_decimal
-    #super
-  end
-  
-  # @override SQLite3 returns FLOAT (JDBC type) for DECIMAL columns
-  def test_custom_select_decimal
-    model = DbType.create! :sample_small_decimal => ( decimal = BigDecimal.new('5.45') )
-    if ActiveRecord::VERSION::MAJOR >= 3
-      model = DbType.where("id = #{model.id}").select('sample_small_decimal AS custom_decimal').first
-    else
-      model = DbType.find(:first, :conditions => "id = #{model.id}", :select => 'sample_small_decimal AS custom_decimal')
-    end
-    assert_equal decimal, model.custom_decimal
-    #assert_instance_of BigDecimal, model.custom_decimal
-  end
-  
-end

data/test/db/sqlite3/transaction_test.rb

@@ -1,32 +0,0 @@
-require 'db/sqlite3'
-require 'transaction'
-
-class SQLite3TransactionTest < Test::Unit::TestCase
-  include TransactionTestMethods
-  
-  def test_supports_transaction_isolation
-    assert ActiveRecord::Base.connection.supports_transaction_isolation?
-    # NOTE: adapter tell us it supports but JDBC meta-data API returns false ?!
-    #assert ActiveRecord::Base.connection.supports_transaction_isolation?(:read_uncommitted)
-    assert ActiveRecord::Base.connection.supports_transaction_isolation?(:serializable)
-  end
-  
-  # supports only TRANSACTION_SERIALIZABLE and TRANSACTION_READ_UNCOMMITTED
-  
-  def test_transaction_isolation_read_committed
-    assert ! ActiveRecord::Base.connection.supports_transaction_isolation?(:read_committed)
-    
-    assert_raise ActiveRecord::TransactionIsolationError do
-      super
-    end
-  end if Test::Unit::TestCase.ar_version('4.0')
-  
-  def test_transaction_isolation_repeatable_read
-    assert ! ActiveRecord::Base.connection.supports_transaction_isolation?(:repeatable_read)
-    
-    assert_raise ActiveRecord::TransactionIsolationError do
-      super
-    end
-  end if Test::Unit::TestCase.ar_version('4.0')
-  
-end

data/test/db/sqlite3/type_conversion_test.rb

@@ -1,104 +0,0 @@
-# encoding: utf-8
-require 'jdbc_common'
-require 'db/sqlite3'
-
-class SQLite3TypeConversionTest < Test::Unit::TestCase
-  
-  if defined?(JRUBY_VERSION)
-    JInteger = java.lang.Integer
-  else
-    JInteger = Fixnum
-    class Fixnum
-      MAX_VALUE = 1024 * 1024 # arbitrary value ... we could pick
-    end
-  end
-  
-  def self.startup; DbTypeMigration.up; end
-  def self.shutdown; DbTypeMigration.down; end
-  
-  TEST_BINARY = "Some random binary data % \0 and then some"
-  
-  @@time_zone = Time.zone
-  
-  setup do
-    Time.zone = ActiveSupport::TimeZone['UTC']
-    DbType.delete_all
-    some_time = Time.now
-    DbType.create!(
-      :sample_timestamp => some_time,
-      :sample_datetime => some_time.to_datetime,
-      :sample_time => some_time.to_time,
-      :sample_date => some_time.to_date,
-      :sample_decimal => JInteger::MAX_VALUE + 1,
-      :sample_small_decimal => 3.14,
-      :sample_binary => TEST_BINARY)
-    DbType.create!(
-      :sample_timestamp => some_time,
-      :sample_datetime => some_time.to_datetime,
-      :sample_time => some_time.to_time,
-      :sample_date => some_time.to_date,
-      :sample_decimal => JInteger::MAX_VALUE + 1,
-      :sample_small_decimal => 1.0,
-      :sample_binary => TEST_BINARY)
-  end
-
-  teardown { Time.zone = @@time_zone; DbType.delete_all }
-  
-  def test_decimal
-    types = DbType.first
-    assert_equal((JInteger::MAX_VALUE + 1), types.sample_decimal)
-  end
-
-  def test_decimal_scale
-    assert_equal(2, DbType.columns_hash["sample_small_decimal"].scale)
-  end
-
-  def test_decimal_precision
-    assert_equal(3, DbType.columns_hash["sample_small_decimal"].precision)
-  end
-
-  def test_small_decimal
-    types = DbType.all :order => "sample_small_decimal DESC"
-    assert_equal(3.14, types[0].sample_small_decimal)
-    assert_equal(1.0, types[1].sample_small_decimal)
-  end
-
-  def test_small_decimal_with_ordering
-    types = DbType.all :order => "sample_small_decimal ASC"
-    types[1].sample_small_decimal
-    assert_equal(1.0, types[0].sample_small_decimal)
-    assert_equal(3.14, types[1].sample_small_decimal)
-  end
-  
-  def test_binary
-    types = DbType.first
-    assert_equal(TEST_BINARY, types.sample_binary)
-  end
-  
-  class DualEncoding < ActiveRecord::Base
-  end
-  
-  def test_quote_binary_column_escapes_it
-    DualEncoding.connection.execute(<<-eosql)
-      CREATE TABLE dual_encodings (
-        id integer PRIMARY KEY AUTOINCREMENT,
-        name string,
-        data binary
-      )
-    eosql
-    str = "01 \x80"
-    str.force_encoding('ASCII-8BIT') if str.respond_to?(:force_encoding)
-    binary = DualEncoding.new :name => '12ščťžýáííéúäô', :data => str
-    binary.save!
-    assert_equal str, binary.data
-    binary.reload
-    if str.respond_to?(:force_encoding)
-      assert_equal '12ščťžýáííéúäô'.force_encoding('UTF-8'), binary.name
-      assert_equal "01 \x80".force_encoding('ASCII-8BIT'), binary.data
-    else
-      assert_equal '12ščťžýáííéúäô', binary.name
-      assert_equal "01 \x80", binary.data
-    end
-  end
-  
-end