class SchemaTest

Constants

CAPITALIZED_TABLE_NAME
COLUMNS
INDEX_A_COLUMN
INDEX_A_NAME
INDEX_B_COLUMN_S1
INDEX_B_COLUMN_S2
INDEX_B_NAME
INDEX_C_COLUMN
INDEX_C_NAME
INDEX_D_COLUMN
INDEX_D_NAME
INDEX_E_COLUMN
INDEX_E_NAME
PK_TABLE_NAME
SCHEMA2_NAME
SCHEMA_NAME
TABLE_NAME
UNMATCHED_PK_TABLE_NAME
UNMATCHED_SEQUENCE_NAME

Public Instance Methods

setup() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 79
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});"
  @connection.execute "CREATE INDEX #{INDEX_C_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING gin (#{INDEX_C_COLUMN});"
  @connection.execute "CREATE INDEX #{INDEX_C_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING gin (#{INDEX_C_COLUMN});"
  @connection.execute "CREATE INDEX #{INDEX_D_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_D_COLUMN} DESC);"
  @connection.execute "CREATE INDEX #{INDEX_D_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_D_COLUMN} DESC);"
  @connection.execute "CREATE INDEX #{INDEX_E_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING gin (#{INDEX_E_COLUMN});"
  @connection.execute "CREATE INDEX #{INDEX_E_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING gin (#{INDEX_E_COLUMN});"
  @connection.execute "CREATE TABLE #{SCHEMA_NAME}.#{PK_TABLE_NAME} (id serial primary key)"
  @connection.execute "CREATE TABLE #{SCHEMA2_NAME}.#{PK_TABLE_NAME} (id serial primary key)"
  @connection.execute "CREATE SEQUENCE #{SCHEMA_NAME}.#{UNMATCHED_SEQUENCE_NAME}"
  @connection.execute "CREATE TABLE #{SCHEMA_NAME}.#{UNMATCHED_PK_TABLE_NAME} (id integer NOT NULL DEFAULT nextval('#{SCHEMA_NAME}.#{UNMATCHED_SEQUENCE_NAME}'::regclass), CONSTRAINT unmatched_pkey PRIMARY KEY (id))"
end
test_classes_with_qualified_schema_name() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 260
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
test_create_schema() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 110
def test_create_schema
  begin
    @connection.create_schema "test_schema3"
    assert @connection.schema_names.include? "test_schema3"
  ensure
    @connection.drop_schema "test_schema3"
  end
end
test_current_schema() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 385
def test_current_schema
  {
    %('$user',public)                        => "public",
    SCHEMA_NAME                              => SCHEMA_NAME,
    %(#{SCHEMA2_NAME},#{SCHEMA_NAME},public) => SCHEMA2_NAME,
    %(public,#{SCHEMA2_NAME},#{SCHEMA_NAME}) => "public"
  }.each do |given, expect|
    with_schema_search_path(given) { assert_equal expect, @connection.current_schema }
  end
end
test_data_source_exists?() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 192
def test_data_source_exists?
  [Thing1, Thing2, Thing3, Thing4].each do |klass|
    name = klass.table_name
    assert @connection.data_source_exists?(name), "'#{name}' data_source should exist"
  end
end
test_data_source_exists_quoted_names() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 215
def test_data_source_exists_quoted_names
  [ %("#{SCHEMA_NAME}"."#{TABLE_NAME}"), %(#{SCHEMA_NAME}."#{TABLE_NAME}"), %(#{SCHEMA_NAME}."#{TABLE_NAME}")].each do |given|
    assert(@connection.data_source_exists?(given), "data_source should exist when specified as #{given}")
  end
  with_schema_search_path(SCHEMA_NAME) do
    given = %("#{TABLE_NAME}")
    assert(@connection.data_source_exists?(given), "data_source should exist when specified as #{given}")
  end
end
test_data_source_exists_quoted_table() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 225
def test_data_source_exists_quoted_table
  with_schema_search_path(SCHEMA_NAME) do
    assert(@connection.data_source_exists?('"things.table"'), "data_source should exist")
  end
end
test_data_source_exists_when_not_on_schema_search_path() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 205
def test_data_source_exists_when_not_on_schema_search_path
  with_schema_search_path("PUBLIC") do
    assert(!@connection.data_source_exists?(TABLE_NAME), "data_source exists but should not be found")
  end
end
test_data_source_exists_when_on_schema_search_path() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 199
def test_data_source_exists_when_on_schema_search_path
  with_schema_search_path(SCHEMA_NAME) do
    assert(@connection.data_source_exists?(TABLE_NAME), "data_source should exist and be found")
  end
end
test_data_source_exists_wrong_schema() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 211
def test_data_source_exists_wrong_schema
  assert(!@connection.data_source_exists?("foo.things"), "data_source should not exist")
end
test_drop_schema() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 130
def test_drop_schema
  begin
    @connection.create_schema "test_schema3"
  ensure
    @connection.drop_schema "test_schema3"
  end
  assert_not_includes @connection.schema_names, "test_schema3"
end
test_drop_schema_if_exists() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 139
def test_drop_schema_if_exists
  @connection.create_schema "some_schema"
  assert_includes @connection.schema_names, "some_schema"
  @connection.drop_schema "some_schema", if_exists: true
  assert_not_includes @connection.schema_names, "some_schema"
end
test_drop_schema_with_nonexisting_schema() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 162
def test_drop_schema_with_nonexisting_schema
  assert_raises(ActiveRecord::StatementInvalid) do
    @connection.drop_schema "idontexist"
  end

  assert_nothing_raised do
    @connection.drop_schema "idontexist", if_exists: true
  end
end
test_dump_indexes_for_schema_multiple_schemas_in_search_path() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 325
def test_dump_indexes_for_schema_multiple_schemas_in_search_path
  do_dump_index_tests_for_schema("public, #{SCHEMA_NAME}", INDEX_A_COLUMN, INDEX_B_COLUMN_S1, INDEX_D_COLUMN, INDEX_E_COLUMN)
end
test_dump_indexes_for_schema_one() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 317
def test_dump_indexes_for_schema_one
  do_dump_index_tests_for_schema(SCHEMA_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S1, INDEX_D_COLUMN, INDEX_E_COLUMN)
end
test_dump_indexes_for_schema_two() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 321
def test_dump_indexes_for_schema_two
  do_dump_index_tests_for_schema(SCHEMA2_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S2, INDEX_D_COLUMN, INDEX_E_COLUMN)
end
test_dump_indexes_for_table_with_scheme_specified_in_name() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 329
def test_dump_indexes_for_table_with_scheme_specified_in_name
  indexes = @connection.indexes("#{SCHEMA_NAME}.#{TABLE_NAME}")
  assert_equal 5, indexes.size
end
test_habtm_table_name_with_schema() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 146
  def test_habtm_table_name_with_schema
    ActiveRecord::Base.connection.drop_schema "music", if_exists: true
    ActiveRecord::Base.connection.create_schema "music"
    ActiveRecord::Base.connection.execute <<-SQL
      CREATE TABLE music.albums (id serial primary key);
      CREATE TABLE music.songs (id serial primary key);
      CREATE TABLE music.albums_songs (album_id integer, song_id integer);
    SQL

    song = Song.create
    Album.create
    assert_equal song, Song.includes(:albums).references(:albums).first
  ensure
    ActiveRecord::Base.connection.drop_schema "music", if_exists: true
  end
test_ignore_nil_schema_search_path() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 301
def test_ignore_nil_schema_search_path
  assert_nothing_raised { with_schema_search_path nil }
end
test_index_name_exists() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 305
def test_index_name_exists
  with_schema_search_path(SCHEMA_NAME) do
    assert @connection.index_name_exists?(TABLE_NAME, INDEX_A_NAME)
    assert @connection.index_name_exists?(TABLE_NAME, INDEX_B_NAME)
    assert @connection.index_name_exists?(TABLE_NAME, INDEX_C_NAME)
    assert @connection.index_name_exists?(TABLE_NAME, INDEX_D_NAME)
    assert @connection.index_name_exists?(TABLE_NAME, INDEX_E_NAME)
    assert @connection.index_name_exists?(TABLE_NAME, INDEX_E_NAME)
    assert_not @connection.index_name_exists?(TABLE_NAME, "missing_index")
  end
end
test_pk_and_sequence_for_with_schema_specified() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 372
def test_pk_and_sequence_for_with_schema_specified
  pg_name = ActiveRecord::ConnectionAdapters::PostgreSQL::Name
  [
    %("#{SCHEMA_NAME}"."#{PK_TABLE_NAME}"),
    %("#{SCHEMA_NAME}"."#{UNMATCHED_PK_TABLE_NAME}")
  ].each do |given|
    pk, seq = @connection.pk_and_sequence_for(given)
    assert_equal "id", pk, "primary key should be found when table referenced as #{given}"
    assert_equal pg_name.new(SCHEMA_NAME, "#{PK_TABLE_NAME}_id_seq"), seq, "sequence name should be found when table referenced as #{given}" if given == %("#{SCHEMA_NAME}"."#{PK_TABLE_NAME}")
    assert_equal pg_name.new(SCHEMA_NAME, UNMATCHED_SEQUENCE_NAME), seq, "sequence name should be found when table referenced as #{given}" if given == %("#{SCHEMA_NAME}"."#{UNMATCHED_PK_TABLE_NAME}")
  end
end
test_prepared_statements_with_multiple_schemas() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 396
def test_prepared_statements_with_multiple_schemas
  [SCHEMA_NAME, SCHEMA2_NAME].each do |schema_name|
    with_schema_search_path schema_name do
      Thing5.create(id: 1, name: "thing inside #{SCHEMA_NAME}", email: "thing1@localhost", moment: Time.now)
    end
  end

  [SCHEMA_NAME, SCHEMA2_NAME].each do |schema_name|
    with_schema_search_path schema_name do
      assert_equal 1, Thing5.count
    end
  end
end
test_primary_key_assuming_schema_search_path() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 366
def test_primary_key_assuming_schema_search_path
  with_schema_search_path("#{SCHEMA_NAME}, #{SCHEMA2_NAME}") do
    assert_equal "id", @connection.primary_key(PK_TABLE_NAME), "primary key should be found"
  end
end
test_primary_key_with_schema_specified() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 356
def test_primary_key_with_schema_specified
  [
    %("#{SCHEMA_NAME}"."#{PK_TABLE_NAME}"),
    %(#{SCHEMA_NAME}."#{PK_TABLE_NAME}"),
    %(#{SCHEMA_NAME}.#{PK_TABLE_NAME})
  ].each do |given|
    assert_equal "id", @connection.primary_key(given), "primary key should be found when table referenced as #{given}"
  end
end
test_proper_encoding_of_table_name() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 251
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
test_raise_create_schema_with_existing_schema() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 119
def test_raise_create_schema_with_existing_schema
  begin
    @connection.create_schema "test_schema3"
    assert_raises(ActiveRecord::StatementInvalid) do
      @connection.create_schema "test_schema3"
    end
  ensure
    @connection.drop_schema "test_schema3"
  end
end
test_raise_on_unquoted_schema_name() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 291
def test_raise_on_unquoted_schema_name
  assert_raises(ActiveRecord::StatementInvalid) do
    with_schema_search_path "$user,public"
  end
end
test_raise_wrapped_exception_on_bad_prepare() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 172
def test_raise_wrapped_exception_on_bad_prepare
  assert_raises(ActiveRecord::StatementInvalid) do
    @connection.exec_query "select * from developers where id = ?", "sql", [bind_param(1)]
  end
end
test_remove_index_when_schema_specified() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 342
def test_remove_index_when_schema_specified
  @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
  assert_nothing_raised { @connection.remove_index "things", name: "#{SCHEMA_NAME}.things_Index" }

  @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
  assert_nothing_raised { @connection.remove_index "#{SCHEMA_NAME}.things", name: "things_Index" }

  @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
  assert_nothing_raised { @connection.remove_index "#{SCHEMA_NAME}.things", name: "#{SCHEMA_NAME}.things_Index" }

  @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
  assert_raises(ArgumentError) { @connection.remove_index "#{SCHEMA2_NAME}.things", name: "#{SCHEMA_NAME}.things_Index" }
end
test_reset_pk_sequence() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 421
def test_reset_pk_sequence
  sequence_name = "#{SCHEMA_NAME}.#{UNMATCHED_SEQUENCE_NAME}"
  @connection.execute "SELECT setval('#{sequence_name}', 123)"
  assert_equal 124, @connection.select_value("SELECT nextval('#{sequence_name}')")
  @connection.reset_pk_sequence!("#{SCHEMA_NAME}.#{UNMATCHED_PK_TABLE_NAME}")
  assert_equal 1, @connection.select_value("SELECT nextval('#{sequence_name}')")
end
test_schema_change_with_prepared_stmt() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 179
def test_schema_change_with_prepared_stmt
  altered = false
  @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
  @connection.exec_query "alter table developers add column zomg int", "sql", []
  altered = true
  @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
ensure
  # We are not using DROP COLUMN IF EXISTS because that syntax is only
  # supported by pg 9.X
  @connection.exec_query("alter table developers drop column zomg", "sql", []) if altered
end
test_schema_exists?() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 410
def test_schema_exists?
  {
    "public"     => true,
    SCHEMA_NAME  => true,
    SCHEMA2_NAME => true,
    "darkside"   => false
  }.each do |given, expect|
    assert_equal expect, @connection.schema_exists?(given)
  end
end
test_schema_names() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 106
def test_schema_names
  assert_equal ["public", "test_schema", "test_schema2"], @connection.schema_names
end
test_set_pk_sequence() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 429
def test_set_pk_sequence
  table_name = "#{SCHEMA_NAME}.#{PK_TABLE_NAME}"
  _, sequence_name = @connection.pk_and_sequence_for table_name
  @connection.set_pk_sequence! table_name, 123
  assert_equal 124, @connection.select_value("SELECT nextval('#{sequence_name}')")
  @connection.reset_pk_sequence! table_name
end
test_with_schema_prefixed_capitalized_table_name() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 237
def test_with_schema_prefixed_capitalized_table_name
  assert_nothing_raised do
    assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{CAPITALIZED_TABLE_NAME}")
  end
end
test_with_schema_prefixed_table_name() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 231
def test_with_schema_prefixed_table_name
  assert_nothing_raised do
    assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{TABLE_NAME}")
  end
end
test_with_schema_search_path() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 243
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
test_with_uppercase_index_name() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 334
def test_with_uppercase_index_name
  @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"

  with_schema_search_path SCHEMA_NAME do
    assert_nothing_raised { @connection.remove_index "things", name: "things_Index" }
  end
end
test_without_schema_search_path() click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 297
def test_without_schema_search_path
  assert_raises(ActiveRecord::StatementInvalid) { columns(TABLE_NAME) }
end

Private Instance Methods

bind_param(value) click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 473
def bind_param(value)
  ActiveRecord::Relation::QueryAttribute.new(nil, value, ActiveRecord::Type::Value.new)
end
columns(table_name) click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 438
def columns(table_name)
  @connection.send(:column_definitions, table_name).map do |name, type, default|
    "#{name} #{type}" + (default ? " default #{default}" : "")
  end
end
do_dump_index_assertions_for_one_index(this_index, this_index_name, this_index_column) click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 466
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
do_dump_index_tests_for_schema(this_schema_name, first_index_column_name, second_index_column_name, third_index_column_name, fourth_index_column_name) click to toggle source
# File activerecord/test/cases/adapters/postgresql/schema_test.rb, line 444
def do_dump_index_tests_for_schema(this_schema_name, first_index_column_name, second_index_column_name, third_index_column_name, fourth_index_column_name)
  with_schema_search_path(this_schema_name) do
    indexes = @connection.indexes(TABLE_NAME).sort_by(&:name)
    assert_equal 5, indexes.size

    index_a, index_b, index_c, index_d, index_e = indexes

    do_dump_index_assertions_for_one_index(index_a, INDEX_A_NAME, first_index_column_name)
    do_dump_index_assertions_for_one_index(index_b, INDEX_B_NAME, second_index_column_name)
    do_dump_index_assertions_for_one_index(index_d, INDEX_D_NAME, third_index_column_name)
    do_dump_index_assertions_for_one_index(index_e, INDEX_E_NAME, fourth_index_column_name)

    assert_equal :btree, index_a.using
    assert_equal :btree, index_b.using
    assert_equal :gin,   index_c.using
    assert_equal :btree, index_d.using
    assert_equal :gin,   index_e.using

    assert_equal :desc,  index_d.orders[INDEX_D_COLUMN]
  end
end