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

data/test/db/derby/serialize_test.rb

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

data/test/db/derby/simple_test.rb

@@ -1,173 +0,0 @@
-# encoding: ASCII-8BIT
-require File.expand_path('test_helper', File.dirname(__FILE__))
-require 'simple'
-require 'has_many_through'
-
-class DerbySimpleTest < Test::Unit::TestCase
-  include SimpleTestMethods
-  include ActiveRecord3TestMethods
-  include CustomSelectTestMethods
-  
-  # @override
-  def test_empty_insert_statement
-    # "INSERT INTO table VALUES ( DEFAULT ) " not supported by Derby DB
-    pend if ar_version('4.0')
-    super
-  end
-  
-  # Check that a table-less VALUES(xxx) query (like SELECT  works.
-  def test_values
-    value = nil
-    assert_nothing_raised do
-      value = ActiveRecord::Base.connection.send(:select_rows, "VALUES('ur', 'doin', 'it', 'right')")
-    end
-    assert_equal [['ur', 'doin', 'it', 'right']], value
-  end
-
-  def test_find_with_include_and_order
-    Entry.create! :title => 'First Post!', 
-      :content => "Hello from 'JRuby on Rails'!", 
-      :user => (user = User.create!(:login => "someone"))
-    
-    users = User.find(:all, :include=>[:entries], :order=>"entries.rating DESC", :limit => 2)
-
-    assert users.include?(user)
-  end
-
-  def test_text_and_string_conversions
-    e = DbType.create!(:sample_string => '', :sample_text => '').reload
-
-    # Derby will normally reject any non text value.
-    # The adapter has been patched to convert non text values to strings
-    ['string', 45, 4.3, 18488425889503641645].each do |value|
-      assert_nothing_raised do
-        e.sample_string = value
-        e.sample_text = value
-        e.save!
-        e.reload
-        assert_equal [value.to_s]*2, [e.sample_string, e.sample_text]
-      end
-    end
-    [true, false].each do |value|
-      assert_nothing_raised do
-        e.sample_string = value
-        e.sample_text = value
-        e.save!
-        e.reload
-        assert_equal [value ? "1" : "0"]*2, [e.sample_string, e.sample_text]
-      end
-    end
-    assert_nothing_raised do
-      value = Time.now
-      if ActiveRecord::VERSION::MAJOR >= 3
-        str = value.utc.to_s(:db)
-      else                      # AR 2 #quoted_date did not do TZ conversions
-        str = value.to_s(:db)
-      end
-      e.sample_string = value
-      e.sample_text = value
-      e.save!
-      e.reload
-      assert_equal [str]*2, [e.sample_string, e.sample_text]
-    end
-    assert_nothing_raised do
-      value = Date.today
-      e.sample_string = value
-      e.sample_text = value
-      e.save!
-      e.reload
-      assert_equal [value.to_s(:db)]*2, [e.sample_string, e.sample_text]
-    end
-    value = {'a' => 7}
-    assert_nothing_raised do
-      e.sample_string = value
-      e.sample_text = value
-      e.save!
-      e.reload
-      assert_equal [value.to_yaml]*2, [e.sample_string, e.sample_text]
-    end
-    value = BigDecimal.new("0")
-    assert_nothing_raised do
-      e.sample_string = value
-      e.sample_text = value
-      e.save!
-      e.reload
-      assert_equal ['0.0']*2, [e.sample_string, e.sample_text]
-    end
-    # An empty string is treated as a null value in Oracle: http://www.techonthenet.com/oracle/questions/empty_null.php
-    unless ActiveRecord::Base.connection.adapter_name =~ /oracle/i
-      assert_nothing_raised do
-        e.sample_string = nil
-        e.sample_text = nil
-        e.save!
-        e.reload
-        assert_equal [nil]*2, [e.sample_string, e.sample_text]
-      end
-    end
-  end
-
-  def test_data_types
-    # from test/models/data_types.rb, with the modifications as noted in the comments.
-    expected_types = [
-      ["id",                          :integer,   { }],
-      ["sample_timestamp",            :datetime,  { }], # :timestamp is just an alias for :datetime in Derby
-      ["sample_datetime",             :datetime,  { }],
-      ["sample_date",                 :date,      { }],
-      ["sample_time",                 :time,      { }],
-      # NOTE: it's an :integer because the :scale is 0 (...right?) :
-      ["sample_decimal",              :integer,   { :precision => 9, :scale => 0 }],
-      ["sample_small_decimal",        :decimal,   { :precision => 3, :scale => 2, :default => 3.14 }],
-      ["sample_default_decimal",      :integer,   { }], # decimal by default assumes :scale => 0
-      ["sample_float",                :float,     { }],
-      ["sample_binary",               :binary,    { }],
-      ["sample_boolean",              :boolean,   { }],
-      ["sample_string",               :string,    { :default => '' }],
-      ["sample_integer",              :integer,   { }], # don't care about the limit
-      ["sample_integer_with_limit_2", :integer,   { }], # don't care about the limit
-      ["sample_integer_with_limit_8", :integer,   { }], # don't care about the limit
-      ["sample_integer_no_limit",     :integer,   { }],
-      ["sample_integer_neg_default",  :integer,   { :default => -1 }],
-      ["sample_text",                 :text,      { }],
-      ["big_decimal",                 :integer,   { :precision => 31, :scale => 0 }],
-      ["decimal_with_scale",          :decimal,   { :precision => 15, :scale => 3 }],
-    ].sort{ |a,b| a[0] <=> b[0] }
-
-    column_names = (expected_types.map{|et| et[0]} + DbType.column_names).sort.uniq
-    result = []
-    column_names.each do |column_name|
-      et = expected_types.detect{|t| t[0] == column_name }
-      col = DbType.columns_hash[column_name]
-      if col
-        attrs = et && Hash[et[2].keys.map{|k| [k, col.send(k)]}]
-        result << [col.name, col.type, attrs]
-      else
-        result << [column_name, nil, nil]
-      end
-    end
-    result.sort!{|a,b| a[0] <=> b[0]}
-
-    assert_equal expected_types, result
-  end
-  
-  # @override Derby is made in IBM thus it needs to get complicated with 1.42
-  def test_custom_select_float
-    model = DbType.create! :sample_float => 1.42
-    if ActiveRecord::VERSION::MAJOR >= 3
-      model = DbType.where("id = #{model.id}").select('sample_float AS custom_sample_float').first
-    else
-      model = DbType.find(:first, :conditions => "id = #{model.id}", :select => 'sample_float AS custom_sample_float')
-    end
-    assert_instance_of Float, model.custom_sample_float
-    custom_sample_float = (model.custom_sample_float * 100).round.to_f / 100 # .round(2) 1.8.7 compatible
-    assert_equal 1.42, custom_sample_float # Derby otherwise returns us smt like: 1.4199999570846558
-  end
-  
-end
-
-class DerbyMultibyteTest < Test::Unit::TestCase
-  include MultibyteTestMethods
-end
-
-class DerbyHasManyThroughTest < Test::Unit::TestCase
-  include HasManyThroughMethods
-end

data/test/db/derby/test_helper.rb

@@ -1,6 +0,0 @@
-require 'db/derby'
-require 'simple'
-require 'row_locking'
-require 'schema_dump'
-
-DbTypeMigration.big_decimal_precision = 31 # DECIMAL precision between 1 and 31

data/test/db/derby/unit_test.rb

@@ -1,32 +0,0 @@
-# encoding: ASCII-8BIT
-require 'test_helper'
-
-class DerbyUnitTest < Test::Unit::TestCase
-
-  class DerbyImpl
-    include ArJdbc::Derby
-    def initialize; end
-  end
-  derby = DerbyImpl.new
-  
-  test "quote (string) without column passed" do
-    s = "'"; q = "''"
-    assert_equal q, derby.quote_string(s)
-    assert_equal "'string #{q}'", derby.quote(v = "string #{s}"), "while quoting #{v.inspect}"
-    assert_equal "' #{q}'", derby.quote(v = " #{s}", nil), "while quoting #{v.inspect}"
-    assert_equal "'#{q}str'", derby.quote(v = "#{s}str", nil), "while quoting #{v.inspect}"
-  end
-
-  test "quote (string) keeps original" do
-    s = "kôň ůň löw9876qűáéőú.éáű-mehehehehehehe0 \x01 \x02"
-    q = "'kôň ůň löw9876qűáéőú.éáű-mehehehehehehe0 \x01 \x02'"
-    assert_equal q, derby.quote(s.dup)
-    
-    if s.respond_to?(:force_encoding)
-      s.force_encoding('UTF-8')
-      q.force_encoding('UTF-8')
-      assert_equal q, derby.quote(s.dup)
-    end
-  end
-  
-end

data/test/db/derby/xml_column_test.rb

@@ -1,17 +0,0 @@
-require File.expand_path('test_helper', File.dirname(__FILE__))
-require 'simple'
-
-class DerbyXmlColumnTest < Test::Unit::TestCase
-  include FixtureSetup
-  include XmlColumnTests
-  
-  def xml_sql_type; 'xml'; end
-  
-  # @override
-  def test_use_xml_column
-    omit("[derby] XML values are not allowed in top-level result sets;")
-    # we'll need to somehow magically add XMLSERIALIZE for all XML columns !
-    super
-  end
-  
-end

data/test/db/h2.rb

@@ -1,11 +0,0 @@
-require 'test_helper'
-
-config = { :adapter => 'h2', :database => 'test' } # adds .h2.db suffix
-
-ActiveRecord::Base.establish_connection(config)
-
-at_exit do 
-  Dir['*test.h2.db'].each { |f| FileUtils.rm(f) }
-  Dir['*test.lock.db'].each { |f| FileUtils.rm(f) }
-  Dir['*test.trace.db'].each { |f| FileUtils.rm(f) }
-end

data/test/db/h2/binary_test.rb

@@ -1,6 +0,0 @@
-require 'db/h2'
-require 'binary'
-
-class H2BinaryTest < Test::Unit::TestCase
-  include BinaryTestMethods
-end

data/test/db/h2/change_column_test.rb

@@ -1,68 +0,0 @@
-require 'db/h2'
-require 'jdbc_common'
-
-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_raise(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/db/h2/identity_column_test.rb

@@ -1,35 +0,0 @@
-require 'test_helper'
-require 'db/h2'
-
-class H2IdentityColumnTest < Test::Unit::TestCase
-
-  class Persona < ActiveRecord::Base
-  end
-
-  class CreatePersonasTable < ActiveRecord::Migration
-    def self.up
-      create_table :personas do |t|
-        t.string :firstname
-        t.string :lastname
-      end
-    end
-
-    def self.down
-      drop_table :personas
-    end
-  end
-
-  def setup
-    CreatePersonasTable.up
-    Persona.create(:firstname => "John",     :lastname => "Smith")
-  end
-
-  def teardown
-    CreatePersonasTable.down
-  end
-
-  def test_auto_increment
-    assert_equal 1, Persona.all[0].id, "H2 auto increment initially should start at ID 1, not 0"
-  end
-end
-

data/test/db/h2/offset_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-require 'db/h2'
-
-class H2OffsetTest < Test::Unit::TestCase
-
-  class Persona < ActiveRecord::Base
-  end
-
-  class CreatePersonasTable < ActiveRecord::Migration
-    def self.up
-      create_table :personas do |t|
-        t.string :firstname
-        t.string :lastname
-      end
-    end
-
-    def self.down
-      drop_table :personas
-    end
-  end
-
-  def setup
-    CreatePersonasTable.up
-    Persona.create(:firstname => "John",     :lastname => "Smith")
-    Persona.create(:firstname => "Jill",     :lastname => "Smith")
-    Persona.create(:firstname => "Joan",     :lastname => "Smith")
-    Persona.create(:firstname => "Jason",    :lastname => "Smith")
-    Persona.create(:firstname => "Jack",     :lastname => "Smith")
-    Persona.create(:firstname => "Jenssen",  :lastname => "Smith")
-    Persona.create(:firstname => "Joe",      :lastname => "Smith")
-    Persona.create(:firstname => "Johanna",  :lastname => "Smith")
-    Persona.create(:firstname => "James",    :lastname => "Smith")
-    Persona.create(:firstname => "Jim",      :lastname => "Smith")
-    Persona.create(:firstname => "Jody",     :lastname => "Smith")
-  end
-
-  def teardown
-    CreatePersonasTable.down
-  end
-
-  def test_offset
-    query = Arel::Table.new(:persons).skip(3)
-    assert_nothing_raised do
-      sql = query.to_sql
-      assert_equal "SELECT LIMIT 3", sql[0..13], "SQL statement was not generated, properly"
-    end
-  end if ar_version('3.0')
-  
-end

data/test/db/h2/rake_test.rb

@@ -1,98 +0,0 @@
-require 'rake_test_support'
-require 'db/h2'
-
-class H2RakeTest < Test::Unit::TestCase
-  include RakeTestSupport
-
-  def db_name; 'mem:rake-test'; end
-
-  def do_teardown
-    drop_rake_test_database(:silence)
-  end
-  
-  test 'rake db:create (and db:drop)' do
-    @db_name = 'rake-create-test'
-    Rake::Task["db:create"].invoke
-    assert_true File.exists?("#{@db_name}.h2.db"), "db file: #{@db_name}.h2.db is missing"
-    
-    Rake::Task["db:drop"].invoke
-    assert_false File.exists?("#{@db_name}.h2.db"), "db file: #{@db_name}.h2.db not deleted"
-  end
-
-  test 'rake db:create (and db:drop) in memory db' do
-    Rake::Task["db:create"].invoke
-    # assert_true File.exists?("#{db_name}.lck")
-    
-    Rake::Task["db:drop"].invoke
-    # assert_false File.exists?("#{db_name}.lck")
-  end
-  
-  test 'rake db:test:purge' do
-    # Rake::Task["db:create"].invoke
-    create_rake_test_database do |connection|
-      connection.create_table('loosers') { |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?('loosers')
-    ActiveRecord::Base.connection.disconnect!
-  end
-  
-  test 'rake db:structure:dump (and db:structure:load)' do
-    db_name = @db_name = 'test-dump-rake'
-    create_rake_test_database(db_name) do |connection|
-      create_schema_migrations_table(connection)
-      connection.create_table('loosers') { |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)
-      # CREATE CACHED TABLE PUBLIC.LOOSERS
-      assert_match /CREATE .*? TABLE PUBLIC.LOOSERS/i, File.read(structure_sql)
-      
-      # db:structure:load
-      drop_rake_test_database(:silence)
-      Rake::Task["db:structure:load"].invoke
-      
-      ActiveRecord::Base.establish_connection db_config.merge :database => db_name
-      assert ActiveRecord::Base.connection.table_exists?('loosers')
-      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
-  
-  def create_rake_test_database(db_name = self.db_name)
-    ActiveRecord::Base.establish_connection db_config.merge :database => db_name
-    if block_given?
-      yield ActiveRecord::Base.connection
-    end
-    ActiveRecord::Base.connection.disconnect!
-  end
-  
-  def drop_rake_test_database(silence = nil)
-    # ActiveRecord::Base.establish_connection db_config.merge :database => @db_name
-    # ActiveRecord::Base.connection.disconnect!
-    
-    File.delete("#{@db_name}.lock.db") if File.exist? "#{@db_name}.lock.db"
-    File.delete("#{@db_name}.trace.db") if File.exist? "#{@db_name}.trace.db"
-    if silence
-      File.delete("#{@db_name}.h2.db") if File.exist? "#{@db_name}.h2.db"
-    else
-      File.delete("#{@db_name}.h2.db")
-    end
-  end
-  
-end