activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/test/postgres_table_alias_length_test.rb

@@ -1,4 +1,5 @@
 require 'jdbc_common'
+require 'db/postgres'
 
 class PostgresTableAliasLengthTest < Test::Unit::TestCase
   def test_table_alias_length

data/test/postgres_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class PostgresTest < Test::Unit::TestCase
+
+  test 'create_database (with options)' do
+    connection = connection_stub
+    connection.expects(:execute).with '' + 
+      "CREATE DATABASE \"mega_development\" ENCODING='utf8' TABLESPACE = \"TS1\" OWNER = \"kimcom\""
+    connection.create_database 'mega_development', 
+      :tablespace => :'TS1', 'owner' => 'kimcom', :invalid => 'ignored'
+  end
+  
+  test 'create_database (no options)' do
+    connection = connection_stub
+    connection.expects(:execute).with "CREATE DATABASE \"mega_development\" ENCODING='utf8'"
+    connection.create_database 'mega_development'
+  end
+  
+  private
+  
+  def connection_stub
+    connection = mock('connection')
+    (class << connection; self; end).class_eval do
+      def self.alias_chained_method(*args); args; end
+    end
+    def connection.configure_connection; nil; end
+    connection.extend ArJdbc::PostgreSQL
+    connection
+  end
+  
+end

data/test/postgres_type_conversion_test.rb

@@ -1,26 +1,27 @@
 require 'jdbc_common'
+require 'db/postgres'
 
-class BooleanSchema < ActiveRecord::Migration
-  def self.up
-    create_table :booleans do |t|
-      t.boolean :value, :default => false, :null => false
+class PostgresTypeConversionTest < Test::Unit::TestCase
+  
+  class BooleanSchema < ActiveRecord::Migration
+    def self.up
+      create_table :booleans do |t|
+        t.boolean :value, :default => false, :null => false
+      end
     end
-  end
 
-  def self.down
-    drop_table :booleans
+    def self.down
+      drop_table :booleans
+    end
   end
-end
 
-class Boolean < ActiveRecord::Base
-end
-
-class PostgresTypeConversionTest < Test::Unit::TestCase
-  def setup
+  class Boolean < ActiveRecord::Base; end
+  
+  def self.startup
     BooleanSchema.up
   end
 
-  def teardown
+  def self.shutdown
     BooleanSchema.down
   end
 
@@ -29,5 +30,4 @@ class PostgresTypeConversionTest < Test::Unit::TestCase
       ActiveRecord::Base.connection.raw_connection.set_native_database_types
     end
   end
-end
-
+end

data/test/row_locking.rb

@@ -5,8 +5,10 @@ module RowLockingTestMethods
   # Simple SELECT ... FOR UPDATE test
   def test_select_all_for_update
     @row1_id = Entry.create!(:title => "row1").id
-    assert Entry.lock(true).all.map{|row| row.id}.include?(@row1_id)
-  end
+    all_locked = Entry.lock(true)
+    all_locked_ids = all_locked.all.map { |row| row.id }
+    assert all_locked_ids.include?(@row1_id)
+  end if Test::Unit::TestCase.ar_version('3.0')
 
   def test_row_locking
     row_locking_test_template
@@ -16,79 +18,82 @@ module RowLockingTestMethods
     row_locking_test_template(:limit => 1)
   end
 
-  private
-
-    def row_locking_test_template(options={})
-      # Create two rows that we will work with
-      @row1_id = Entry.create!(:title => "row1").id
-      @row2_id = Entry.create!(:title => "row2").id
+  protected
+  
+  def row_locking_test_template(options={})
+    # Create two rows that we will work with
+    @row1_id = Entry.create!(:title => "row1").id
+    @row2_id = Entry.create!(:title => "row2").id
 
-      @result_queue = Queue.new
-      signal_queue = Queue.new
-      t1 = Thread.new { thread_helper { thread1_main(signal_queue, options) } }
-      t2 = Thread.new { thread_helper { thread2_main(signal_queue, options) } }
-      t1.join
-      t2.join
+    @result_queue = Queue.new
+    signal_queue = Queue.new
+    t1 = Thread.new { thread_helper { thread1_main(signal_queue, options) } }
+    t2 = Thread.new { thread_helper { thread2_main(signal_queue, options) } }
+    t1.join
+    t2.join
 
-      result = []
-      result << @result_queue.shift until @result_queue.empty?    # Convert the queue into an array
+    result = []
+    result << @result_queue.shift until @result_queue.empty?    # Convert the queue into an array
 
-      expected = [
-        :t1_locking_row2,
-        :t1_locked_row2,
+    expected = [
+      :t1_locking_row2,
+      :t1_locked_row2,
 
-        :t2_locking_row1,
-        :t2_locked_row1,
+      :t2_locking_row1,
+      :t2_locked_row1,
 
-        :t2_locking_row2,     # thread 2 tries to lock row2 ...
-        :t1_committed,
-        :t2_locked_row2,      # ... but it doesn't succeed until after thread 1 commits its transaction
+      :t2_locking_row2,     # thread 2 tries to lock row2 ...
+      :t1_committed,
+      :t2_locked_row2,      # ... but it doesn't succeed until after thread 1 commits its transaction
 
-        :t2_committed,
-      ]
+      :t2_committed,
+    ]
 
-      assert_equal expected, result, "thread2 should lock row1 immediately but wait for thread1 to commit before getting the lock on row2"
-    end
+    assert_equal expected, result, "thread2 should lock row1 immediately but wait for thread1 to commit before getting the lock on row2"
+  end
+  
+  private
 
-    def thread1_main(signal_queue, options={})
-      Entry.transaction do
-        @result_queue << :t1_locking_row2
-        Entry.find(@row2_id, {:lock=>true}.merge(options))   # acquire a row lock on r2
-        @result_queue << :t1_locked_row2
-        signal_queue << :go               # signal thread2 to start
-        sleep 2.0                         # Wait for a few seconds, to allow the other thread to race with this thread.
-        @result_queue << :t1_committed
-      end
+  def thread1_main(signal_queue, options={})
+    Entry.transaction do
+      @result_queue << :t1_locking_row2
+      Entry.find(@row2_id, {:lock=>true}.merge(options))   # acquire a row lock on r2
+      @result_queue << :t1_locked_row2
+      signal_queue << :go               # signal thread2 to start
+      sleep 1.5                         # Wait for a few seconds, to allow the other thread to race with this thread.
+      @result_queue << :t1_committed
     end
+  end
 
-    def thread2_main(signal_queue, options={})
-      Entry.transaction do
-        signal_queue.shift   # wait until we get the signal from thread1
-        @result_queue << :t2_locking_row1
-        Entry.find(@row1_id, {:lock=>true}.merge(options))   # should return immediately
-        @result_queue << :t2_locked_row1
-        @result_queue << :t2_locking_row2
-        Entry.find(@row2_id, {:lock=>true}.merge(options))   # should block until thread1 commits its transaction
-        @result_queue << :t2_locked_row2
-        @result_queue << :t2_committed
-      end
+  def thread2_main(signal_queue, options={})
+    Entry.transaction do
+      signal_queue.shift   # wait until we get the signal from thread1
+      @result_queue << :t2_locking_row1
+      Entry.find(@row1_id, {:lock=>true}.merge(options))   # should return immediately
+      @result_queue << :t2_locked_row1
+      @result_queue << :t2_locking_row2
+      Entry.find(@row2_id, {:lock=>true}.merge(options))   # should block until thread1 commits its transaction
+      @result_queue << :t2_locked_row2
+      @result_queue << :t2_committed
     end
+  end
 
-    def thread_helper
-      yield
-    rescue Exception => exc
-      # Output backtrace, since otherwise we won't see anything until the main thread joins this thread.
-      display_exception(exc)
-      raise
-    ensure
-      # This is needed.  Otherwise, the database connections aren't returned to the pool and things break.
-      ActiveRecord::Base.connection_handler.clear_active_connections!
-    end
+  def thread_helper
+    yield
+  rescue Exception => exc
+    # Output backtrace, since otherwise we won't see anything until the main thread joins this thread.
+    display_exception(exc)
+    raise
+  ensure
+    # This is needed.  Otherwise, the database connections aren't returned to the pool and things break.
+    ActiveRecord::Base.connection_handler.clear_active_connections!
+  end
 
-    def display_exception(exception)
-      lines = []
-      lines << "#{exception.class.name}: #{exception.message}\n"
-      lines += exception.backtrace.map{|line| "\tfrom #{line}"}
-      $stderr.puts lines.join("\n")
-    end
+  def display_exception(exception)
+    lines = []
+    lines << "#{exception.class.name}: #{exception.message}\n"
+    lines += exception.backtrace.map{|line| "\tfrom #{line}"}
+    $stderr.puts lines.join("\n")
+  end
+  
 end

data/test/schema_dump.rb

@@ -0,0 +1,168 @@
+require 'stringio'
+require 'active_record/schema_dumper'
+
+module SchemaDumpTestMethods
+  include MigrationSetup
+  
+  def test_dumping_schema_with_index
+    connection = ActiveRecord::Base.connection
+    connection.add_index :entries, :title
+    StringIO.open do |io|
+      ActiveRecord::SchemaDumper.dump(connection, io)
+      assert_match(/add_index "entries",/, io.string)
+    end
+  ensure
+    connection.remove_index :entries, :title
+  end
+  
+  def standard_dump(io = StringIO.new, ignore_tables = [])
+    io = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = ignore_tables
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, io)
+    io.string
+  end
+  private :standard_dump
+
+  def test_magic_comment
+    standard_dump(strio = StringIO.new)
+    assert_match "# encoding: #{strio.external_encoding.name}", standard_dump
+  end if ( "string".encoding_aware? rescue nil )
+
+  def test_schema_dump
+    output = standard_dump
+    assert_match %r{create_table "users"}, output
+    assert_match %r{create_table "entries"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+  end
+
+  def test_schema_dump_excludes_sqlite_sequence
+    output = standard_dump
+    assert_no_match %r{create_table "sqlite_sequence"}, output
+  end
+
+  def assert_line_up(lines, pattern, required = false)
+    return assert(true) if lines.empty?
+    matches = lines.map { |line| line.match(pattern) }
+    assert matches.all? if required
+    matches.compact!
+    return assert(true) if matches.empty?
+    assert_equal 1, matches.map{ |match| match.offset(0).first }.uniq.length
+  end
+
+  def column_definition_lines(output = standard_dump)
+    output.scan(/^( *)create_table.*?\n(.*?)^\1end/m).map{ |m| m.last.split(/\n/) }
+  end
+  private :column_definition_lines
+
+  def test_types_line_up
+    column_definition_lines.each do |column_set|
+      next if column_set.empty?
+
+      lengths = column_set.map do |column|
+        if match = column.match(/t\.(?:integer|decimal|float|datetime|timestamp|time|date|text|binary|string|boolean)\s+"/)
+          match[0].length
+        end
+      end
+
+      assert_equal 1, lengths.uniq.length
+    end
+  end
+
+  def test_arguments_line_up
+    column_definition_lines.each do |column_set|
+      assert_line_up(column_set, /:default => /)
+      assert_line_up(column_set, /:limit => /)
+      assert_line_up(column_set, /:null => /)
+    end
+  end
+
+  def test_no_dump_errors
+    output = standard_dump
+    assert_no_match %r{\# Could not dump table}, output
+  end
+
+  def test_schema_dump_includes_not_null_columns
+    output = standard_dump(StringIO.new, [/^[^u]/]) # keep users
+    assert_match %r{:null => false}, output
+  end
+
+  def test_schema_dump_with_string_ignored_table
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.ignore_tables = ['users']
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    output = stream.string
+    assert_no_match %r{create_table "users"}, output
+    assert_match %r{create_table "entries"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+  end
+
+  def test_schema_dump_with_regexp_ignored_table
+    output = standard_dump(StringIO.new, [/^user/]) # ignore users
+    assert_no_match %r{create_table "users"}, output
+    assert_match %r{create_table "entries"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+  end
+
+  def test_schema_dump_should_honor_nonstandard_primary_keys
+    output = standard_dump
+    match = output.match(%r{create_table "custom_pk_names"(.*)do})
+    assert_not_nil(match, "nonstandardpk table not found")
+    assert_match %r(:primary_key => "custom_id"), match[1], "non-standard primary key not preserved"
+  end
+
+  def test_schema_dump_includes_decimal_options
+    output = standard_dump(StringIO.new, [/^[^d]/]) # keep db_types
+    # t.column :sample_small_decimal, :decimal, :precision => 3, :scale => 2, :default => 3.14
+    assert_match %r{:precision => 3,[[:space:]]+:scale => 2,[[:space:]]+:default => 3.14}, output
+  end
+
+  def test_schema_dump_keeps_large_precision_integer_columns_as_decimal
+    output = standard_dump
+    precision = DbTypeMigration.big_decimal_precision
+    assert_match %r{t.decimal\s+"big_decimal",\s+:precision => #{precision},\s+:scale => 0}, output
+  end if Test::Unit::TestCase.ar_version('3.0') # does not work in 2.3 :
+  # t.integer  "big_decimal", :limit => 38, :precision => 38, :scale => 0
+
+  def test_schema_dump_keeps_id_column_when_id_is_false_and_id_column_added
+    output = standard_dump
+    match = output.match(%r{create_table "string_ids"(.*)do.*\n(.*)\n})
+    assert_not_nil(match, "string_ids table not found")
+    assert_match %r(:id => false), match[1], "no table id not preserved"
+    assert_match %r{t.string[[:space:]]+"id",[[:space:]]+:null => false$}, match[2], "non-primary key id column not preserved"
+  end
+
+  def test_schema_dump_keeps_id_false_when_id_is_false_and_unique_not_null_column_added
+    output = standard_dump
+    assert_match %r{create_table "things", :id => false}, output
+  end
+  
+  class CreateDogMigration < ActiveRecord::Migration
+    def up
+      create_table :dogs do |t|
+        t.column :name, :string
+      end
+    end
+    def down
+      drop_table :dogs
+    end
+  end
+
+  def test_schema_dump_with_table_name_prefix_and_suffix
+    ActiveRecord::Base.table_name_prefix = 'foo_'
+    ActiveRecord::Base.table_name_suffix = '_bar'
+
+    migration = CreateDogMigration.new
+    migration.migrate(:up)
+
+    output = standard_dump
+    assert_no_match %r{create_table "foo_.+_bar"}, output
+    assert_no_match %r{create_index "foo_.+_bar"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+  ensure
+    migration.migrate(:down)
+
+    ActiveRecord::Base.table_name_suffix = ActiveRecord::Base.table_name_prefix = ''
+  end if Test::Unit::TestCase.ar_version('3.2')
+
+end

data/test/serialize.rb

@@ -0,0 +1,277 @@
+require 'models/topic'
+require 'ostruct'
+
+# borrosed from AR/test/cases/serialized_attribute_test.rb
+
+module SerializeTestMethods
+
+  def self.included(base)
+    base.extend UpAndDown
+  end
+
+  module UpAndDown
+
+    def startup
+      super
+      TopicMigration.up
+    end
+
+    def shutdown
+      super
+      TopicMigration.down
+    end
+
+  end
+  
+  def setup
+    super
+  end
+
+  def teardown
+    super
+    Topic.serialize("content")
+  end
+  
+  MyObject = Struct.new :attribute1, :attribute2
+
+  def test_list_of_serialized_attributes
+    assert_equal %w(content), Topic.serialized_attributes.keys
+  end
+  
+  def test_serialized_attribute
+    Topic.serialize("content", MyObject)
+
+    myobj = MyObject.new('value1', 'value2')
+    topic = Topic.create("content" => myobj)
+    assert_equal(myobj, topic.content)
+
+    topic.reload
+    assert_equal(myobj, topic.content)
+  end
+
+  def test_serialized_attribute_init_with
+    topic = Topic.allocate
+    topic.init_with('attributes' => { 'content' => '--- foo' })
+    assert_equal 'foo', topic.content
+  end if Test::Unit::TestCase.ar_version('3.0')
+
+  def test_serialized_attribute_in_base_class
+    Topic.serialize("content", Hash)
+
+    hash = { 'content1' => 'value1', 'content2' => 'value2' }
+    important_topic = ImportantTopic.create("content" => hash)
+    assert_equal(hash, important_topic.content)
+
+    important_topic.reload
+    assert_equal(hash, important_topic.content)
+  end
+
+  # This test was added to fix GH #4004. Obviously the value returned
+  # is not really the value 'before type cast' so we should maybe think
+  # about changing that in the future.
+#  def test_serialized_attribute_before_type_cast_returns_unserialized_value
+#    Topic.serialize :content, Hash
+#
+#    t = Topic.new :content => { :foo => :bar }
+#    assert_equal({ :foo => :bar }, t.content_before_type_cast)
+#    t.save!
+#    t.reload
+#    assert_equal({ :foo => :bar }, t.content_before_type_cast)
+#  end
+
+#  def test_serialized_attributes_before_type_cast_returns_unserialized_value
+#    Topic.serialize :content, Hash
+#
+#    t = Topic.new :content => { :foo => :bar }
+#    assert_equal({ :foo => :bar }, t.attributes_before_type_cast["content"])
+#    t.save!
+#    t.reload
+#    assert_equal({ :foo => :bar }, t.attributes_before_type_cast["content"])
+#  end
+  
+  def test_serialized_ostruct
+    Topic.serialize :content, OpenStruct
+
+    t = Topic.new
+    t.content.foo = 'bar'
+    t.save!
+    assert_equal 'bar', t.reload.content.foo
+  end if Test::Unit::TestCase.ar_version('3.1')
+  
+  def test_serialized_attribute_declared_in_subclass
+    hash = { 'important1' => 'value1', 'important2' => 'value2' }
+    important_topic = ImportantTopic.create("important" => hash)
+    assert_equal(hash, important_topic.important)
+
+    important_topic.reload
+    assert_equal(hash, important_topic.important)
+    assert_equal(hash, important_topic.read_attribute(:important))
+  end
+
+  def test_serialized_time_attribute
+    myobj = Time.local(2008,1,1,1,0)
+    topic = Topic.create("content" => myobj).reload
+    assert_equal(myobj, topic.content)
+  end
+
+  def test_serialized_string_attribute
+    myobj = "Yes"
+    topic = Topic.create("content" => myobj).reload
+    assert_equal(myobj, topic.content)
+  end
+
+  def test_nil_serialized_attribute_with_class_constraint
+    topic = ImportantTopic.new
+    assert_nil topic.content
+  end
+
+  def test_nil_serialized_attribute_without_class_constraint
+    topic = Topic.new
+    assert_nil topic.content
+  end
+    
+  def test_nil_not_serialized_without_class_constraint
+    #ActiveRecord::Base.logger.level = Logger::DEBUG
+    topic = Topic.new(:content => nil); topic.save!
+    # NOTE: seems smt broken on AR 3.2's side inserts '--- \n' !
+    #assert_equal 1, Topic.where(:content => nil).count
+    assert_nil topic.reload.content
+  ensure
+    #ActiveRecord::Base.logger.level = Logger::WARN
+  end
+
+  def test_nil_not_serialized_with_class_constraint
+    #ActiveRecord::Base.logger.level = Logger::DEBUG
+    topic = ImportantTopic.new(:content => nil); topic.save!
+    # NOTE: seems smt broken on AR 3.2's side inserts '--- \n' !
+    #assert_equal 1, ImportantTopic.where(:content => nil).count
+    assert_nil topic.reload.content
+  ensure
+    #ActiveRecord::Base.logger.level = Logger::WARN
+  end
+
+  def test_serialized_attribute_should_raise_exception_on_save_with_wrong_type
+    Topic.serialize(:content, Hash)
+    topic = Topic.new(:content => "string")
+    assert_raise(ActiveRecord::SerializationTypeMismatch) { topic.save }
+  end if Test::Unit::TestCase.ar_version('3.2')
+
+  def test_should_raise_exception_on_serialized_attribute_with_type_mismatch
+    myobj = MyObject.new('value1', 'value2')
+    topic = Topic.new(:content => myobj)
+    assert topic.save
+    Topic.serialize(:content, Hash)
+    assert_raise(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).content }
+  end if Test::Unit::TestCase.ar_version('3.2')
+
+  def test_serialized_attribute_with_class_constraint
+    settings = { "color" => "blue" }
+    Topic.serialize(:content, Hash)
+    topic = Topic.new(:content => settings)
+    assert topic.save
+    assert_equal(settings, Topic.find(topic.id).content)
+  end
+
+  def test_serialized_default_class
+    Topic.serialize(:content, Hash)
+    topic = Topic.new
+    assert_equal Hash, topic.content.class
+    assert_equal Hash, topic.read_attribute(:content).class
+    topic.content["beer"] = "MadridRb"
+    assert topic.save
+    topic.reload
+    assert_equal Hash, topic.content.class
+    assert_equal "MadridRb", topic.content["beer"]
+  end if Test::Unit::TestCase.ar_version('3.1')
+
+  def test_serialized_no_default_class_for_object
+    topic = Topic.new
+    assert_nil topic.content
+  end
+
+  def test_serialized_boolean_value_true
+    Topic.serialize(:content)
+    topic = Topic.new(:content => true)
+    assert topic.save
+    topic = topic.reload
+    assert_equal topic.content, true
+  end if Test::Unit::TestCase.ar_version('3.0')
+
+  def test_serialized_boolean_value_false
+    Topic.serialize(:content)
+    topic = Topic.new(:content => false)
+    assert topic.save
+    topic = topic.reload
+    assert_equal topic.content, false
+  end if Test::Unit::TestCase.ar_version('3.0')
+
+  def test_serialize_with_coder
+    coder = Class.new {
+      # Identity
+      def load(thing)
+        thing
+      end
+
+      # base 64
+      def dump(thing)
+        [thing].pack('m')
+      end
+    }.new
+
+    Topic.serialize(:content, coder)
+    s = 'hello world'
+    topic = Topic.new(:content => s)
+    assert topic.save
+    topic = topic.reload
+    assert_equal [s].pack('m'), topic.content
+  ensure
+    Topic.serialize(:content)
+  end if Test::Unit::TestCase.ar_version('3.1')
+  
+  def test_serialize_with_bcrypt_coder
+    require 'bcrypt'
+    crypt_coder = Class.new {
+      def load(thing)
+        return unless thing
+        BCrypt::Password.new thing
+      end
+
+      def dump(thing)
+        BCrypt::Password.create(thing).to_s
+      end
+    }.new
+
+    Topic.serialize(:content, crypt_coder)
+    password = 'password'
+    topic = Topic.new(:content => password)
+    assert topic.save
+    topic = topic.reload
+    assert_kind_of BCrypt::Password, topic.content
+    assert_equal(true, topic.content == password, 'password should equal')
+  end if Test::Unit::TestCase.ar_version('3.1')
+  
+  def test_serialize_attribute_via_select_method_when_time_zone_available
+    ActiveRecord::Base.time_zone_aware_attributes = true
+    Topic.serialize(:content, MyObject)
+
+    myobj = MyObject.new('value1', 'value2')
+    topic = Topic.create(:content => myobj)
+
+    ActiveRecord::IdentityMap.without do
+      assert_equal(myobj, Topic.select(:content).find(topic.id).content)
+      assert_raise(ActiveModel::MissingAttributeError) { Topic.select(:id).find(topic.id).content }
+    end
+  ensure
+    ActiveRecord::Base.time_zone_aware_attributes = false
+  end if Test::Unit::TestCase.ar_version('3.2')
+
+#  def test_serialize_attribute_can_be_serialized_in_an_integer_column
+#    insures = ['life']
+#    person = SerializedPerson.new(:first_name => 'David', :insures => insures)
+#    assert person.save
+#    person = person.reload
+#    assert_equal(insures, person.insures)
+#  end
+
+end
+