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

data/test/schema_dump.rb

@@ -1,182 +0,0 @@
-require 'stringio'
-require 'test_helper'
-require 'simple' # due MigrationSetup
-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 => )|(default: )/)
-      assert_line_up(column_set, /(:limit => )|(limit: )/)
-      assert_line_up(column_set, /(:null => )|(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)|(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")|(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
-    if ar_version('4.0')
-      assert_match %r{precision: 3,[[:space:]]+scale: 2,[[:space:]]+default: 3.14}, output
-    else
-      assert_match %r{:precision => 3,[[:space:]]+:scale => 2,[[:space:]]+:default => 3.14}, output
-    end
-  end
-
-  def test_schema_dump_keeps_large_precision_integer_columns_as_decimal
-    output = standard_dump
-    precision = DbTypeMigration.big_decimal_precision
-    if ar_version('4.0')
-      assert_match %r{t.decimal\s+"big_decimal",\s+precision: #{precision},\s+scale: 0}, output
-    else
-      assert_match %r{t.decimal\s+"big_decimal",\s+:precision => #{precision},\s+:scale => 0}, output
-    end
-  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)|(id: false)), match[1], "no table id not preserved"
-    if ar_version('4.0')
-      assert_match %r{t.string[[:space:]]+"id",[[:space:]]+null: false$}, match[2], "non-primary key id column not preserved"
-    else
-      assert_match %r{t.string[[:space:]]+"id",[[:space:]]+:null => false$}, match[2], "non-primary key id column not preserved"
-    end
-  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)|(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

@@ -1,275 +0,0 @@
-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)
-
-    assert_equal myobj, Topic.select(:content).find(topic.id).content
-    assert_raise(ActiveModel::MissingAttributeError) { Topic.select(:id).find(topic.id).content }
-  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
-