activerecord_csi 2.3.5.p6

data/test/cases/reserved_word_test_mysql.rb

@@ -0,0 +1,176 @@
+require "cases/helper"
+
+class Group < ActiveRecord::Base
+  Group.table_name = 'group'
+  belongs_to :select, :class_name => 'Select'
+  has_one :values
+end
+
+class Select < ActiveRecord::Base
+  Select.table_name = 'select'
+  has_many :groups
+end
+
+class Values < ActiveRecord::Base
+  Values.table_name = 'values'
+end
+
+class Distinct < ActiveRecord::Base
+  Distinct.table_name = 'distinct'
+  has_and_belongs_to_many :selects
+  has_many :values, :through => :groups
+end
+
+# a suite of tests to ensure the ConnectionAdapters#MysqlAdapter can handle tables with
+# reserved word names (ie: group, order, values, etc...)
+class MysqlReservedWordTest < ActiveRecord::TestCase
+  def setup
+    @connection = ActiveRecord::Base.connection
+
+    # we call execute directly here (and do similar below) because ActiveRecord::Base#create_table()
+    # will fail with these table names if these test cases fail
+
+    create_tables_directly 'group'=>'id int auto_increment primary key, `order` varchar(255), select_id int',
+      'select'=>'id int auto_increment primary key',
+      'values'=>'id int auto_increment primary key, group_id int',
+      'distinct'=>'id int auto_increment primary key',
+      'distincts_selects'=>'distinct_id int, select_id int'
+  end
+
+  def teardown
+    drop_tables_directly ['group', 'select', 'values', 'distinct', 'distincts_selects', 'order']
+  end
+
+  # create tables with reserved-word names and columns
+  def test_create_tables
+    assert_nothing_raised {
+      @connection.create_table :order do |t|
+        t.column :group, :string
+      end
+    }
+  end
+
+  # rename tables with reserved-word names
+  def test_rename_tables
+    assert_nothing_raised { @connection.rename_table(:group, :order) }
+  end
+
+  # alter column with a reserved-word name in a table with a reserved-word name
+  def test_change_columns
+    assert_nothing_raised { @connection.change_column_default(:group, :order, 'whatever') }
+    #the quoting here will reveal any double quoting issues in change_column's interaction with the column method in the adapter
+    assert_nothing_raised { @connection.change_column('group', 'order', :Int, :default => 0) }
+    assert_nothing_raised { @connection.rename_column(:group, :order, :values) }
+  end
+
+  # dump structure of table with reserved word name
+  def test_structure_dump
+    assert_nothing_raised { @connection.structure_dump  }
+  end
+
+  # introspect table with reserved word name
+  def test_introspect
+    assert_nothing_raised { @connection.columns(:group) }
+    assert_nothing_raised { @connection.indexes(:group) }
+  end
+
+  #fixtures
+  self.use_instantiated_fixtures = true
+  self.use_transactional_fixtures = false
+
+  #fixtures :group
+
+  def test_fixtures
+    f = create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
+
+    assert_nothing_raised {
+      f.each do |x|
+        x.delete_existing_fixtures
+      end
+    }
+
+    assert_nothing_raised {
+      f.each do |x|
+        x.insert_fixtures
+      end
+    }
+  end
+
+  #activerecord model class with reserved-word table name
+  def test_activerecord_model
+    create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
+    x = nil
+    assert_nothing_raised { x = Group.new }
+    x.order = 'x'
+    assert_nothing_raised { x.save }
+    x.order = 'y'
+    assert_nothing_raised { x.save }
+    assert_nothing_raised { y = Group.find_by_order('y') }
+    assert_nothing_raised { y = Group.find(1) }
+    x = Group.find(1)
+  end
+
+  # has_one association with reserved-word table name
+  def test_has_one_associations
+    create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
+    v = nil
+    assert_nothing_raised { v = Group.find(1).values }
+    assert_equal v.id, 2
+  end
+
+  # belongs_to association with reserved-word table name
+  def test_belongs_to_associations
+    create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
+    gs = nil
+    assert_nothing_raised { gs = Select.find(2).groups }
+    assert_equal gs.length, 2
+    assert(gs.collect{|x| x.id}.sort == [2, 3])
+  end
+
+  # has_and_belongs_to_many with reserved-word table name
+  def test_has_and_belongs_to_many
+    create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
+    s = nil
+    assert_nothing_raised { s = Distinct.find(1).selects }
+    assert_equal s.length, 2
+    assert(s.collect{|x|x.id}.sort == [1, 2])
+  end
+
+  # activerecord model introspection with reserved-word table and column names
+  def test_activerecord_introspection
+    assert_nothing_raised { Group.table_exists? }
+    assert_nothing_raised { Group.columns }
+  end
+
+  # Calculations
+  def test_calculations_work_with_reserved_words
+    assert_nothing_raised { Group.count }
+  end
+
+  def test_associations_work_with_reserved_words
+    assert_nothing_raised { Select.find(:all, :include => [:groups]) }
+  end
+
+  #the following functions were added to DRY test cases
+
+  private
+  # custom fixture loader, uses Fixtures#create_fixtures and appends base_path to the current file's path
+  def create_test_fixtures(*fixture_names)
+    Fixtures.create_fixtures(FIXTURES_ROOT + "/reserved_words", fixture_names)
+  end
+
+  # custom drop table, uses execute on connection to drop a table if it exists. note: escapes table_name
+  def drop_tables_directly(table_names, connection = @connection)
+    table_names.each do |name|
+      connection.execute("DROP TABLE IF EXISTS `#{name}`")
+    end
+  end
+
+  # custom create table, uses execute on connection to create a table, note: escapes table_name, does NOT escape columns
+  def create_tables_directly (tables, connection = @connection)
+    tables.each do |table_name, column_properties|
+      connection.execute("CREATE TABLE `#{table_name}` ( #{column_properties} )")
+    end
+  end
+
+end

data/test/cases/sanitize_test.rb

@@ -0,0 +1,25 @@
+require "cases/helper"
+require 'models/binary'
+
+class SanitizeTest < ActiveRecord::TestCase
+  def setup
+  end
+
+  def test_sanitize_sql_array_handles_string_interpolation
+    quoted_bambi = ActiveRecord::Base.connection.quote_string("Bambi")
+    assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=%s", "Bambi"])
+    assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=%s", "Bambi".mb_chars])
+    quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote_string("Bambi\nand\nThumper")
+    assert_equal "name=#{quoted_bambi_and_thumper}",Binary.send(:sanitize_sql_array, ["name=%s", "Bambi\nand\nThumper"])
+    assert_equal "name=#{quoted_bambi_and_thumper}",Binary.send(:sanitize_sql_array, ["name=%s", "Bambi\nand\nThumper".mb_chars])
+  end
+
+  def test_sanitize_sql_array_handles_bind_variables
+    quoted_bambi = ActiveRecord::Base.connection.quote("Bambi")
+    assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=?", "Bambi"])
+    assert_equal "name=#{quoted_bambi}", Binary.send(:sanitize_sql_array, ["name=?", "Bambi".mb_chars])
+    quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote("Bambi\nand\nThumper")
+    assert_equal "name=#{quoted_bambi_and_thumper}", Binary.send(:sanitize_sql_array, ["name=?", "Bambi\nand\nThumper"])
+    assert_equal "name=#{quoted_bambi_and_thumper}", Binary.send(:sanitize_sql_array, ["name=?", "Bambi\nand\nThumper".mb_chars])
+  end
+end

data/test/cases/schema_authorization_test_postgresql.rb

@@ -0,0 +1,75 @@
+require "cases/helper"
+
+class SchemaThing < ActiveRecord::Base
+end
+
+class SchemaAuthorizationTest < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  TABLE_NAME = 'schema_things'
+  COLUMNS = [
+    'id serial primary key',
+    'name character varying(50)'
+  ]
+  USERS = ['rails_pg_schema_user1', 'rails_pg_schema_user2']
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.execute "SET search_path TO '$user',public"
+    set_session_auth
+    USERS.each do |u|
+      @connection.execute "CREATE USER #{u}" rescue nil
+      @connection.execute "CREATE SCHEMA AUTHORIZATION #{u}" rescue nil
+      set_session_auth u
+      @connection.execute "CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
+      @connection.execute "INSERT INTO #{TABLE_NAME} (name) VALUES ('#{u}')"
+      set_session_auth
+    end
+  end
+
+  def teardown
+    set_session_auth
+    @connection.execute "RESET search_path"
+    USERS.each do |u|
+      @connection.execute "DROP SCHEMA #{u} CASCADE"
+      @connection.execute "DROP USER #{u}"
+    end
+  end
+
+  def test_schema_invisible
+    assert_raise(ActiveRecord::StatementInvalid) do
+      set_session_auth
+      @connection.execute "SELECT * FROM #{TABLE_NAME}"
+    end
+  end
+
+  def test_schema_uniqueness
+    assert_nothing_raised do
+      set_session_auth
+      USERS.each do |u|
+        set_session_auth u
+        assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = 1")
+        set_session_auth
+      end
+    end
+  end
+
+  def test_sequence_schema_caching
+    assert_nothing_raised do
+      USERS.each do |u|
+        set_session_auth u
+        st = SchemaThing.new :name => 'TEST1'
+        st.save!
+        st = SchemaThing.new :id => 5, :name => 'TEST2'
+        st.save!
+        set_session_auth
+      end
+    end
+  end
+
+  private
+    def set_session_auth auth = nil
+       @connection.execute "SET SESSION AUTHORIZATION #{auth || 'default'}"
+    end
+
+end

data/test/cases/schema_dumper_test.rb

@@ -0,0 +1,211 @@
+require "cases/helper"
+require 'stringio'
+
+
+class SchemaDumperTest < ActiveRecord::TestCase
+  def standard_dump
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = []
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    stream.string
+  end
+
+  def test_schema_dump
+    output = standard_dump
+    assert_match %r{create_table "accounts"}, output
+    assert_match %r{create_table "authors"}, 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 test_schema_dump_includes_camelcase_table_name
+    output = standard_dump
+    assert_match %r{create_table "CamelCase"}, 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
+
+  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
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.ignore_tables = [/^[^r]/]
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    output = stream.string
+    assert_match %r{:null => false}, output
+  end
+
+  def test_schema_dump_includes_limit_constraint_for_integer_columns
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.ignore_tables = [/^(?!integer_limits)/]
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    output = stream.string
+
+    if current_adapter?(:PostgreSQLAdapter)
+      assert_match %r{c_int_1.*:limit => 2}, output
+      assert_match %r{c_int_2.*:limit => 2}, output
+
+      # int 3 is 4 bytes in postgresql
+      assert_match %r{c_int_3.*}, output
+      assert_no_match %r{c_int_3.*:limit}, output
+
+      assert_match %r{c_int_4.*}, output
+      assert_no_match %r{c_int_4.*:limit}, output
+    elsif current_adapter?(:MysqlAdapter)
+      assert_match %r{c_int_1.*:limit => 1}, output
+      assert_match %r{c_int_2.*:limit => 2}, output
+      assert_match %r{c_int_3.*:limit => 3}, output
+
+      assert_match %r{c_int_4.*}, output
+      assert_no_match %r{c_int_4.*:limit}, output
+    elsif current_adapter?(:SQLiteAdapter)
+      assert_match %r{c_int_1.*:limit => 1}, output
+      assert_match %r{c_int_2.*:limit => 2}, output
+      assert_match %r{c_int_3.*:limit => 3}, output
+      assert_match %r{c_int_4.*:limit => 4}, output
+    end
+    assert_match %r{c_int_without_limit.*}, output
+    assert_no_match %r{c_int_without_limit.*:limit}, output
+
+    if current_adapter?(:SQLiteAdapter)
+      assert_match %r{c_int_5.*:limit => 5}, output
+      assert_match %r{c_int_6.*:limit => 6}, output
+      assert_match %r{c_int_7.*:limit => 7}, output
+      assert_match %r{c_int_8.*:limit => 8}, output
+    else
+      assert_match %r{c_int_5.*:limit => 8}, output
+      assert_match %r{c_int_6.*:limit => 8}, output
+      assert_match %r{c_int_7.*:limit => 8}, output
+      assert_match %r{c_int_8.*:limit => 8}, output
+    end
+  end
+
+  def test_schema_dump_with_string_ignored_table
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.ignore_tables = ['accounts']
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    output = stream.string
+    assert_no_match %r{create_table "accounts"}, output
+    assert_match %r{create_table "authors"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+  end
+
+  def test_schema_dump_with_regexp_ignored_table
+    stream = StringIO.new
+
+    ActiveRecord::SchemaDumper.ignore_tables = [/^account/]
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    output = stream.string
+    assert_no_match %r{create_table "accounts"}, output
+    assert_match %r{create_table "authors"}, output
+    assert_no_match %r{create_table "schema_migrations"}, output
+  end
+
+  def test_schema_dump_illegal_ignored_table_value
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = [5]
+    assert_raise(StandardError) do
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    end
+  end
+
+  def test_schema_dumps_index_columns_in_right_order
+    index_definition = standard_dump.split(/\n/).grep(/add_index.*companies/).first.strip
+    assert_equal 'add_index "companies", ["firm_id", "type", "rating", "ruby_type"], :name => "company_index"', index_definition
+  end
+
+  def test_schema_dump_should_honor_nonstandard_primary_keys
+    output = standard_dump
+    match = output.match(%r{create_table "movies"(.*)do})
+    assert_not_nil(match, "nonstandardpk table not found")
+    assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
+  end
+
+  if current_adapter?(:MysqlAdapter)
+    def test_schema_dump_should_not_add_default_value_for_mysql_text_field
+      output = standard_dump
+      assert_match %r{t.text\s+"body",\s+:null => false$}, output
+    end
+
+    def test_schema_dump_includes_length_for_mysql_blob_and_text_fields
+      output = standard_dump
+      assert_match %r{t.binary\s+"tiny_blob",\s+:limit => 255$}, output
+      assert_match %r{t.binary\s+"normal_blob"$}, output
+      assert_match %r{t.binary\s+"medium_blob",\s+:limit => 16777215$}, output
+      assert_match %r{t.binary\s+"long_blob",\s+:limit => 2147483647$}, output
+      assert_match %r{t.text\s+"tiny_text",\s+:limit => 255$}, output
+      assert_match %r{t.text\s+"normal_text"$}, output
+      assert_match %r{t.text\s+"medium_text",\s+:limit => 16777215$}, output
+      assert_match %r{t.text\s+"long_text",\s+:limit => 2147483647$}, output
+    end
+  end
+
+  def test_schema_dump_includes_decimal_options
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = [/^[^n]/]
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    output = stream.string
+    assert_match %r{:precision => 3,[[:space:]]+:scale => 2,[[:space:]]+:default => 2.78}, output
+  end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    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
+  end
+
+  def test_schema_dump_keeps_id_column_when_id_is_false_and_id_column_added
+    output = standard_dump
+    match = output.match(%r{create_table "goofy_string_id"(.*)do.*\n(.*)\n})
+    assert_not_nil(match, "goofy_string_id 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
+end
+

data/test/cases/schema_test_postgresql.rb

@@ -0,0 +1,178 @@
+require "cases/helper"
+
+class SchemaTest < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  SCHEMA_NAME = 'test_schema'
+  SCHEMA2_NAME = 'test_schema2'
+  TABLE_NAME = 'things'
+  CAPITALIZED_TABLE_NAME = 'Things'
+  INDEX_A_NAME = 'a_index_things_on_name'
+  INDEX_B_NAME = 'b_index_things_on_different_columns_in_each_schema'
+  INDEX_A_COLUMN = 'name'
+  INDEX_B_COLUMN_S1 = 'email'
+  INDEX_B_COLUMN_S2 = 'moment'
+  COLUMNS = [
+    'id integer',
+    'name character varying(50)',
+    'email character varying(50)',
+    'moment timestamp without time zone default now()'
+  ]
+
+  class Thing1 < ActiveRecord::Base
+    set_table_name "test_schema.things"
+  end
+
+  class Thing2 < ActiveRecord::Base
+    set_table_name "test_schema2.things"
+  end
+
+  class Thing3 < ActiveRecord::Base
+    set_table_name 'test_schema."things.table"'
+  end
+
+  class Thing4 < ActiveRecord::Base
+    set_table_name 'test_schema."Things"'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
+    @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{TABLE_NAME}.table\" (#{COLUMNS.join(',')})"
+    @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{CAPITALIZED_TABLE_NAME}\" (#{COLUMNS.join(',')})"
+    @connection.execute "CREATE SCHEMA #{SCHEMA2_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
+    @connection.execute "CREATE INDEX #{INDEX_A_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_A_COLUMN});"
+    @connection.execute "CREATE INDEX #{INDEX_A_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_A_COLUMN});"
+    @connection.execute "CREATE INDEX #{INDEX_B_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_B_COLUMN_S1});"
+    @connection.execute "CREATE INDEX #{INDEX_B_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_B_COLUMN_S2});"
+  end
+
+  def teardown
+    @connection.execute "DROP SCHEMA #{SCHEMA2_NAME} CASCADE"
+    @connection.execute "DROP SCHEMA #{SCHEMA_NAME} CASCADE"
+  end
+
+  def test_with_schema_prefixed_table_name
+    assert_nothing_raised do
+      assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{TABLE_NAME}")
+    end
+  end
+
+  def test_with_schema_prefixed_capitalized_table_name
+    assert_nothing_raised do
+      assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{CAPITALIZED_TABLE_NAME}")
+    end
+  end
+
+  def test_with_schema_search_path
+    assert_nothing_raised do
+      with_schema_search_path(SCHEMA_NAME) do
+        assert_equal COLUMNS, columns(TABLE_NAME)
+      end
+    end
+  end
+
+
+  def test_proper_encoding_of_table_name
+    assert_equal '"table_name"', @connection.quote_table_name('table_name')
+    assert_equal '"table.name"', @connection.quote_table_name('"table.name"')
+    assert_equal '"schema_name"."table_name"', @connection.quote_table_name('schema_name.table_name')
+    assert_equal '"schema_name"."table.name"', @connection.quote_table_name('schema_name."table.name"')
+    assert_equal '"schema.name"."table_name"', @connection.quote_table_name('"schema.name".table_name')
+    assert_equal '"schema.name"."table.name"', @connection.quote_table_name('"schema.name"."table.name"')
+  end
+
+  def test_classes_with_qualified_schema_name
+    assert_equal 0, Thing1.count
+    assert_equal 0, Thing2.count
+    assert_equal 0, Thing3.count
+    assert_equal 0, Thing4.count
+
+    Thing1.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
+    assert_equal 1, Thing1.count
+    assert_equal 0, Thing2.count
+    assert_equal 0, Thing3.count
+    assert_equal 0, Thing4.count
+
+    Thing2.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
+    assert_equal 1, Thing1.count
+    assert_equal 1, Thing2.count
+    assert_equal 0, Thing3.count
+    assert_equal 0, Thing4.count
+
+    Thing3.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
+    assert_equal 1, Thing1.count
+    assert_equal 1, Thing2.count
+    assert_equal 1, Thing3.count
+    assert_equal 0, Thing4.count
+
+    Thing4.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
+    assert_equal 1, Thing1.count
+    assert_equal 1, Thing2.count
+    assert_equal 1, Thing3.count
+    assert_equal 1, Thing4.count
+  end
+
+  def test_raise_on_unquoted_schema_name
+    assert_raise(ActiveRecord::StatementInvalid) do
+      with_schema_search_path '$user,public'
+    end
+  end
+
+  def test_without_schema_search_path
+    assert_raise(ActiveRecord::StatementInvalid) { columns(TABLE_NAME) }
+  end
+
+  def test_ignore_nil_schema_search_path
+    assert_nothing_raised { with_schema_search_path nil }
+  end
+
+  def test_dump_indexes_for_schema_one
+    do_dump_index_tests_for_schema(SCHEMA_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S1)
+  end
+
+  def test_dump_indexes_for_schema_two
+    do_dump_index_tests_for_schema(SCHEMA2_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S2)
+  end
+
+  def test_with_uppercase_index_name
+    ActiveRecord::Base.connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
+    assert_nothing_raised { ActiveRecord::Base.connection.remove_index :things, :name => "#{SCHEMA_NAME}.things_Index"}
+
+    ActiveRecord::Base.connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
+    ActiveRecord::Base.connection.schema_search_path = SCHEMA_NAME
+    assert_nothing_raised { ActiveRecord::Base.connection.remove_index :things, :name => "things_Index"}
+    ActiveRecord::Base.connection.schema_search_path = "public"
+  end
+
+  private
+    def columns(table_name)
+      @connection.send(:column_definitions, table_name).map do |name, type, default|
+        "#{name} #{type}" + (default ? " default #{default}" : '')
+      end
+    end
+
+    def with_schema_search_path(schema_search_path)
+      @connection.schema_search_path = schema_search_path
+      yield if block_given?
+    ensure
+      @connection.schema_search_path = "'$user', public"
+    end
+
+    def do_dump_index_tests_for_schema(this_schema_name, first_index_column_name, second_index_column_name)
+      with_schema_search_path(this_schema_name) do
+        indexes = @connection.indexes(TABLE_NAME).sort_by {|i| i.name}
+        assert_equal 2,indexes.size
+
+        do_dump_index_assertions_for_one_index(indexes[0], INDEX_A_NAME, first_index_column_name)
+        do_dump_index_assertions_for_one_index(indexes[1], INDEX_B_NAME, second_index_column_name)
+      end
+    end
+
+    def do_dump_index_assertions_for_one_index(this_index, this_index_name, this_index_column)
+      assert_equal TABLE_NAME, this_index.table
+      assert_equal 1, this_index.columns.size
+      assert_equal this_index_column, this_index.columns[0]
+      assert_equal this_index_name, this_index.name
+    end
+end