Merge branch 'pb-consolidate-database-spec-helpers' into 'master'

Move database spec helpers into separate directory

See merge request gitlab-org/gitlab!50206

lib/gitlab/database/partitioning_migration_helpers/index_helpers.rb

@@ -32,7 +32,7 @@ module Gitlab
             return
           end
 
-          partitioned_table.postgres_partitions.each do |partition|
+          partitioned_table.postgres_partitions.order(:name).each do |partition|
             partition_index_name = generated_index_name(partition.identifier, options[:name])
             partition_options = options.merge(name: partition_index_name)
 

spec/factories_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe 'factories' do
-  include DatabaseHelpers
+  include Database::DatabaseHelpers
 
   shared_examples 'factory' do |factory|
     describe "#{factory.name} factory" do

spec/lib/gitlab/database/partitioning/partition_creator_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Database::Partitioning::PartitionCreator do
-  include PartitioningHelpers
+  include Database::PartitioningHelpers
   include ExclusiveLeaseHelpers
 
   describe '.register' do

spec/lib/gitlab/database/partitioning/replace_table_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Database::Partitioning::ReplaceTable, '#perform' do
-  include TableSchemaHelpers
+  include Database::TableSchemaHelpers
 
   subject(:replace_table) { described_class.new(original_table, replacement_table, archived_table, 'id').perform }
 

spec/lib/gitlab/database/partitioning_migration_helpers/foreign_key_helpers_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Database::PartitioningMigrationHelpers::ForeignKeyHelpers do
-  include TriggerHelpers
+  include Database::TriggerHelpers
 
   let(:model) do
     ActiveRecord::Migration.new.extend(described_class)

spec/lib/gitlab/database/partitioning_migration_helpers/index_helpers_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Database::PartitioningMigrationHelpers::IndexHelpers do
-  include TableSchemaHelpers
+  include Database::TableSchemaHelpers
 
   let(:migration) do
     ActiveRecord::Migration.new.extend(described_class)

spec/lib/gitlab/database/partitioning_migration_helpers/table_management_helpers_spec.rb

@@ -3,9 +3,9 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Database::PartitioningMigrationHelpers::TableManagementHelpers do
-  include PartitioningHelpers
-  include TriggerHelpers
-  include TableSchemaHelpers
+  include Database::PartitioningHelpers
+  include Database::TriggerHelpers
+  include Database::TableSchemaHelpers
 
   let(:migration) do
     ActiveRecord::Migration.new.extend(described_class)

spec/lib/gitlab/database/reindexing/index_selection_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Database::Reindexing::IndexSelection do
-  include DatabaseHelpers
+  include Database::DatabaseHelpers
 
   subject { described_class.new(Gitlab::Database::PostgresIndex.all).to_a }
 

spec/support/helpers/database/database_helpers.rb

+# frozen_string_literal: true
+
+module Database
+  module DatabaseHelpers
+    # In order to directly work with views using factories,
+    # we can swapout the view for a table of identical structure.
+    def swapout_view_for_table(view)
+      ActiveRecord::Base.connection.execute(<<~SQL)
+        CREATE TABLE #{view}_copy (LIKE #{view});
+        DROP VIEW #{view};
+        ALTER TABLE #{view}_copy RENAME TO #{view};
+      SQL
+    end
+  end
+end

spec/support/helpers/database/partitioning_helpers.rb

+# frozen_string_literal: true
+
+module Database
+  module PartitioningHelpers
+    def expect_table_partitioned_by(table, columns, part_type: :range)
+      columns_with_part_type = columns.map { |c| [part_type.to_s, c] }
+      actual_columns = find_partitioned_columns(table)
+
+      expect(columns_with_part_type).to match_array(actual_columns)
+    end
+
+    def expect_range_partition_of(partition_name, table_name, min_value, max_value)
+      definition = find_partition_definition(partition_name, schema: Gitlab::Database::DYNAMIC_PARTITIONS_SCHEMA)
+
+      expect(definition).not_to be_nil
+      expect(definition['base_table']).to eq(table_name.to_s)
+      expect(definition['condition']).to eq("FOR VALUES FROM (#{min_value}) TO (#{max_value})")
+    end
+
+    def expect_total_partitions(table_name, count, schema: Gitlab::Database::DYNAMIC_PARTITIONS_SCHEMA)
+      partitions = find_partitions(table_name, schema: schema)
+
+      expect(partitions.size).to eq(count)
+    end
+
+    def expect_range_partitions_for(table_name, partitions)
+      partitions.each do |suffix, (min_value, max_value)|
+        partition_name = "#{table_name}_#{suffix}"
+        expect_range_partition_of(partition_name, table_name, min_value, max_value)
+      end
+
+      expect_total_partitions(table_name, partitions.size, schema: Gitlab::Database::DYNAMIC_PARTITIONS_SCHEMA)
+    end
+
+    def expect_hash_partition_of(partition_name, table_name, modulus, remainder)
+      definition = find_partition_definition(partition_name, schema: Gitlab::Database::STATIC_PARTITIONS_SCHEMA)
+
+      expect(definition).not_to be_nil
+      expect(definition['base_table']).to eq(table_name.to_s)
+      expect(definition['condition']).to eq("FOR VALUES WITH (modulus #{modulus}, remainder #{remainder})")
+    end
+
+    private
+
+    def find_partitioned_columns(table)
+      connection.select_rows(<<~SQL)
+        select
+          case partstrat
+          when 'l' then 'list'
+          when 'r' then 'range'
+          when 'h' then 'hash'
+          end as partstrat,
+          cols.column_name
+        from (
+          select partrelid, partstrat, unnest(partattrs) as col_pos
+          from pg_partitioned_table
+        ) pg_part
+        inner join pg_class
+        on pg_part.partrelid = pg_class.oid
+        inner join information_schema.columns cols
+        on cols.table_name = pg_class.relname
+        and cols.ordinal_position = pg_part.col_pos
+        where pg_class.relname = '#{table}';
+      SQL
+    end
+
+    def find_partition_definition(partition, schema: )
+      connection.select_one(<<~SQL)
+        select
+          parent_class.relname as base_table,
+          pg_get_expr(pg_class.relpartbound, inhrelid) as condition
+        from pg_class
+        inner join pg_inherits i on pg_class.oid = inhrelid
+        inner join pg_class parent_class on parent_class.oid = inhparent
+        inner join pg_namespace ON pg_namespace.oid = pg_class.relnamespace
+        where pg_namespace.nspname = '#{schema}'
+          and pg_class.relname = '#{partition}'
+          and pg_class.relispartition
+      SQL
+    end
+
+    def find_partitions(partition, schema: Gitlab::Database::DYNAMIC_PARTITIONS_SCHEMA)
+      connection.select_rows(<<~SQL)
+        select
+          pg_class.relname
+        from pg_class
+        inner join pg_inherits i on pg_class.oid = inhrelid
+        inner join pg_class parent_class on parent_class.oid = inhparent
+        inner join pg_namespace ON pg_namespace.oid = pg_class.relnamespace
+        where pg_namespace.nspname = '#{schema}'
+          and parent_class.relname = '#{partition}'
+          and pg_class.relispartition
+      SQL
+    end
+  end
+end

spec/support/helpers/database/table_schema_helpers.rb

+# frozen_string_literal: true
+
+module Database
+  module TableSchemaHelpers
+    def connection
+      ActiveRecord::Base.connection
+    end
+
+    def expect_table_to_be_replaced(original_table:, replacement_table:, archived_table:)
+      original_oid = table_oid(original_table)
+      replacement_oid = table_oid(replacement_table)
+
+      yield
+
+      expect(table_oid(original_table)).to eq(replacement_oid)
+      expect(table_oid(archived_table)).to eq(original_oid)
+      expect(table_oid(replacement_table)).to be_nil
+    end
+
+    def expect_index_to_exist(name, schema: nil)
+      expect(index_exists_by_name(name, schema: schema)).to eq(true)
+    end
+
+    def expect_index_not_to_exist(name, schema: nil)
+      expect(index_exists_by_name(name, schema: schema)).to be_nil
+    end
+
+    def expect_primary_keys_after_tables(tables, schema: nil)
+      tables.each do |table|
+        primary_key = primary_key_constraint_name(table, schema: schema)
+
+        expect(primary_key).to eq("#{table}_pkey")
+      end
+    end
+
+    def table_oid(name)
+      connection.select_value(<<~SQL)
+        SELECT oid
+        FROM pg_catalog.pg_class
+        WHERE relname = '#{name}'
+      SQL
+    end
+
+    def table_type(name)
+      connection.select_value(<<~SQL)
+        SELECT
+          CASE class.relkind
+          WHEN 'r' THEN 'normal'
+          WHEN 'p' THEN 'partitioned'
+          ELSE 'other'
+          END as table_type
+        FROM pg_catalog.pg_class class
+        WHERE class.relname = '#{name}'
+      SQL
+    end
+
+    def sequence_owned_by(table_name, column_name)
+      connection.select_value(<<~SQL)
+        SELECT
+          sequence.relname as name
+        FROM pg_catalog.pg_class as sequence
+        INNER JOIN pg_catalog.pg_depend depend
+          ON depend.objid = sequence.oid
+        INNER JOIN pg_catalog.pg_class class
+          ON class.oid = depend.refobjid
+        INNER JOIN pg_catalog.pg_attribute attribute
+          ON attribute.attnum = depend.refobjsubid
+          AND attribute.attrelid = depend.refobjid
+        WHERE class.relname = '#{table_name}'
+          AND attribute.attname = '#{column_name}'
+      SQL
+    end
+
+    def default_expression_for(table_name, column_name)
+      connection.select_value(<<~SQL)
+        SELECT
+          pg_get_expr(attrdef.adbin, attrdef.adrelid) AS default_value
+        FROM pg_catalog.pg_attribute attribute
+        INNER JOIN pg_catalog.pg_attrdef attrdef
+          ON attribute.attrelid = attrdef.adrelid
+          AND attribute.attnum = attrdef.adnum
+        WHERE attribute.attrelid = '#{table_name}'::regclass
+          AND attribute.attname = '#{column_name}'
+      SQL
+    end
+
+    def primary_key_constraint_name(table_name, schema: nil)
+      table_name = schema ? "#{schema}.#{table_name}" : table_name
+
+      connection.select_value(<<~SQL)
+        SELECT
+          conname AS constraint_name
+        FROM pg_catalog.pg_constraint
+        WHERE pg_constraint.conrelid = '#{table_name}'::regclass
+          AND pg_constraint.contype = 'p'
+      SQL
+    end
+
+    def index_exists_by_name(index, schema: nil)
+      schema = schema ? "'#{schema}'" : 'current_schema'
+
+      connection.select_value(<<~SQL)
+        SELECT true
+        FROM pg_catalog.pg_index i
+        INNER JOIN pg_catalog.pg_class c
+          ON c.oid = i.indexrelid
+        INNER JOIN pg_catalog.pg_namespace n
+          ON c.relnamespace = n.oid
+        WHERE c.relname = '#{index}'
+          AND n.nspname = #{schema}
+      SQL
+    end
+  end
+end

spec/support/helpers/database/trigger_helpers.rb

+# frozen_string_literal: true
+
+module Database
+  module TriggerHelpers
+    def expect_function_to_exist(name)
+      expect(find_function_def(name)).not_to be_nil
+    end
+
+    def expect_function_not_to_exist(name)
+      expect(find_function_def(name)).to be_nil
+    end
+
+    def expect_function_to_contain(name, *statements)
+      return_stmt, *body_stmts = parsed_function_statements(name).reverse
+
+      expect(return_stmt).to eq('return old')
+      expect(body_stmts).to contain_exactly(*statements)
+    end
+
+    def expect_trigger_not_to_exist(table_name, name)
+      expect(find_trigger_def(table_name, name)).to be_nil
+    end
+
+    def expect_valid_function_trigger(table_name, name, fn_name, fires_on)
+      events, timing, definition = cleaned_trigger_def(table_name, name)
+
+      events = events&.split(',')
+      expected_timing, expected_events = fires_on.first
+      expect(timing).to eq(expected_timing.to_s)
+      expect(events).to match_array(Array.wrap(expected_events))
+
+      expect(definition).to match(%r{execute (?:procedure|function) #{fn_name}()})
+    end
+
+    private
+
+    def parsed_function_statements(name)
+      cleaned_definition = find_function_def(name)['body'].downcase.gsub(/\s+/, ' ')
+      statements = cleaned_definition.sub(/\A\s*begin\s*(.*)\s*end\s*\Z/, "\\1")
+      statements.split(';').map! { |stmt| stmt.strip.presence }.compact!
+    end
+
+    def find_function_def(name)
+      connection.select_one(<<~SQL)
+        SELECT prosrc AS body
+        FROM pg_proc
+        WHERE proname = '#{name}'
+      SQL
+    end
+
+    def cleaned_trigger_def(table_name, name)
+      find_trigger_def(table_name, name).values_at('event', 'action_timing', 'action_statement').map!(&:downcase)
+    end
+
+    def find_trigger_def(table_name, name)
+      connection.select_one(<<~SQL)
+        SELECT
+          string_agg(event_manipulation, ',') AS event,
+          action_timing,
+          action_statement
+        FROM information_schema.triggers
+        WHERE event_object_table = '#{table_name}'
+        AND trigger_name = '#{name}'
+        GROUP BY 2, 3
+      SQL
+    end
+  end
+end

spec/support/helpers/database_helpers.rb

-# frozen_string_literal: true
-
-module DatabaseHelpers
-  # In order to directly work with views using factories,
-  # we can swapout the view for a table of identical structure.
-  def swapout_view_for_table(view)
-    ActiveRecord::Base.connection.execute(<<~SQL)
-      CREATE TABLE #{view}_copy (LIKE #{view});
-      DROP VIEW #{view};
-      ALTER TABLE #{view}_copy RENAME TO #{view};
-    SQL
-  end
-end

spec/support/helpers/partitioning_helpers.rb

-# frozen_string_literal: true
-
-module PartitioningHelpers
-  def expect_table_partitioned_by(table, columns, part_type: :range)
-    columns_with_part_type = columns.map { |c| [part_type.to_s, c] }
-    actual_columns = find_partitioned_columns(table)
-
-    expect(columns_with_part_type).to match_array(actual_columns)
-  end
-
-  def expect_range_partition_of(partition_name, table_name, min_value, max_value)
-    definition = find_partition_definition(partition_name, schema: Gitlab::Database::DYNAMIC_PARTITIONS_SCHEMA)
-
-    expect(definition).not_to be_nil
-    expect(definition['base_table']).to eq(table_name.to_s)
-    expect(definition['condition']).to eq("FOR VALUES FROM (#{min_value}) TO (#{max_value})")
-  end
-
-  def expect_total_partitions(table_name, count, schema: Gitlab::Database::DYNAMIC_PARTITIONS_SCHEMA)
-    partitions = find_partitions(table_name, schema: schema)
-
-    expect(partitions.size).to eq(count)
-  end
-
-  def expect_range_partitions_for(table_name, partitions)
-    partitions.each do |suffix, (min_value, max_value)|
-      partition_name = "#{table_name}_#{suffix}"
-      expect_range_partition_of(partition_name, table_name, min_value, max_value)
-    end
-
-    expect_total_partitions(table_name, partitions.size, schema: Gitlab::Database::DYNAMIC_PARTITIONS_SCHEMA)
-  end
-
-  def expect_hash_partition_of(partition_name, table_name, modulus, remainder)
-    definition = find_partition_definition(partition_name, schema: Gitlab::Database::STATIC_PARTITIONS_SCHEMA)
-
-    expect(definition).not_to be_nil
-    expect(definition['base_table']).to eq(table_name.to_s)
-    expect(definition['condition']).to eq("FOR VALUES WITH (modulus #{modulus}, remainder #{remainder})")
-  end
-
-  private
-
-  def find_partitioned_columns(table)
-    connection.select_rows(<<~SQL)
-      select
-        case partstrat
-        when 'l' then 'list'
-        when 'r' then 'range'
-        when 'h' then 'hash'
-        end as partstrat,
-        cols.column_name
-      from (
-        select partrelid, partstrat, unnest(partattrs) as col_pos
-        from pg_partitioned_table
-      ) pg_part
-      inner join pg_class
-      on pg_part.partrelid = pg_class.oid
-      inner join information_schema.columns cols
-      on cols.table_name = pg_class.relname
-      and cols.ordinal_position = pg_part.col_pos
-      where pg_class.relname = '#{table}';
-    SQL
-  end
-
-  def find_partition_definition(partition, schema: )
-    connection.select_one(<<~SQL)
-      select
-        parent_class.relname as base_table,
-        pg_get_expr(pg_class.relpartbound, inhrelid) as condition
-      from pg_class
-      inner join pg_inherits i on pg_class.oid = inhrelid
-      inner join pg_class parent_class on parent_class.oid = inhparent
-      inner join pg_namespace ON pg_namespace.oid = pg_class.relnamespace
-      where pg_namespace.nspname = '#{schema}'
-        and pg_class.relname = '#{partition}'
-        and pg_class.relispartition
-    SQL
-  end
-
-  def find_partitions(partition, schema: Gitlab::Database::DYNAMIC_PARTITIONS_SCHEMA)
-    connection.select_rows(<<~SQL)
-      select
-        pg_class.relname
-      from pg_class
-      inner join pg_inherits i on pg_class.oid = inhrelid
-      inner join pg_class parent_class on parent_class.oid = inhparent
-      inner join pg_namespace ON pg_namespace.oid = pg_class.relnamespace
-      where pg_namespace.nspname = '#{schema}'
-        and parent_class.relname = '#{partition}'
-        and pg_class.relispartition
-    SQL
-  end
-end

spec/support/helpers/table_schema_helpers.rb

-# frozen_string_literal: true
-
-module TableSchemaHelpers
-  def connection
-    ActiveRecord::Base.connection
-  end
-
-  def expect_table_to_be_replaced(original_table:, replacement_table:, archived_table:)
-    original_oid = table_oid(original_table)
-    replacement_oid = table_oid(replacement_table)
-
-    yield
-
-    expect(table_oid(original_table)).to eq(replacement_oid)
-    expect(table_oid(archived_table)).to eq(original_oid)
-    expect(table_oid(replacement_table)).to be_nil
-  end
-
-  def expect_index_to_exist(name, schema: nil)
-    expect(index_exists_by_name(name, schema: schema)).to eq(true)
-  end
-
-  def expect_index_not_to_exist(name, schema: nil)
-    expect(index_exists_by_name(name, schema: schema)).to be_nil
-  end
-
-  def expect_primary_keys_after_tables(tables, schema: nil)
-    tables.each do |table|
-      primary_key = primary_key_constraint_name(table, schema: schema)
-
-      expect(primary_key).to eq("#{table}_pkey")
-    end
-  end
-
-  def table_oid(name)
-    connection.select_value(<<~SQL)
-      SELECT oid
-      FROM pg_catalog.pg_class
-      WHERE relname = '#{name}'
-    SQL
-  end
-
-  def table_type(name)
-    connection.select_value(<<~SQL)
-      SELECT
-        CASE class.relkind
-        WHEN 'r' THEN 'normal'
-        WHEN 'p' THEN 'partitioned'
-        ELSE 'other'
-        END as table_type
-      FROM pg_catalog.pg_class class
-      WHERE class.relname = '#{name}'
-    SQL
-  end
-
-  def sequence_owned_by(table_name, column_name)
-    connection.select_value(<<~SQL)
-      SELECT
-        sequence.relname as name
-      FROM pg_catalog.pg_class as sequence
-      INNER JOIN pg_catalog.pg_depend depend
-        ON depend.objid = sequence.oid
-      INNER JOIN pg_catalog.pg_class class
-        ON class.oid = depend.refobjid
-      INNER JOIN pg_catalog.pg_attribute attribute
-        ON attribute.attnum = depend.refobjsubid
-        AND attribute.attrelid = depend.refobjid
-      WHERE class.relname = '#{table_name}'
-        AND attribute.attname = '#{column_name}'
-    SQL
-  end
-
-  def default_expression_for(table_name, column_name)
-    connection.select_value(<<~SQL)
-      SELECT
-        pg_get_expr(attrdef.adbin, attrdef.adrelid) AS default_value
-      FROM pg_catalog.pg_attribute attribute
-      INNER JOIN pg_catalog.pg_attrdef attrdef
-        ON attribute.attrelid = attrdef.adrelid
-        AND attribute.attnum = attrdef.adnum
-      WHERE attribute.attrelid = '#{table_name}'::regclass
-        AND attribute.attname = '#{column_name}'
-    SQL
-  end
-
-  def primary_key_constraint_name(table_name, schema: nil)
-    table_name = schema ? "#{schema}.#{table_name}" : table_name
-
-    connection.select_value(<<~SQL)
-      SELECT
-        conname AS constraint_name
-      FROM pg_catalog.pg_constraint
-      WHERE pg_constraint.conrelid = '#{table_name}'::regclass
-        AND pg_constraint.contype = 'p'
-    SQL
-  end
-
-  def index_exists_by_name(index, schema: nil)
-    schema = schema ? "'#{schema}'" : 'current_schema'
-
-    connection.select_value(<<~SQL)
-      SELECT true
-      FROM pg_catalog.pg_index i
-      INNER JOIN pg_catalog.pg_class c
-        ON c.oid = i.indexrelid
-      INNER JOIN pg_catalog.pg_namespace n
-        ON c.relnamespace = n.oid
-      WHERE c.relname = '#{index}'
-        AND n.nspname = #{schema}
-    SQL
-  end
-end

spec/support/helpers/trigger_helpers.rb

-# frozen_string_literal: true
-
-module TriggerHelpers
-  def expect_function_to_exist(name)
-    expect(find_function_def(name)).not_to be_nil
-  end
-
-  def expect_function_not_to_exist(name)
-    expect(find_function_def(name)).to be_nil
-  end
-
-  def expect_function_to_contain(name, *statements)
-    return_stmt, *body_stmts = parsed_function_statements(name).reverse
-
-    expect(return_stmt).to eq('return old')
-    expect(body_stmts).to contain_exactly(*statements)
-  end
-
-  def expect_trigger_not_to_exist(table_name, name)
-    expect(find_trigger_def(table_name, name)).to be_nil
-  end
-
-  def expect_valid_function_trigger(table_name, name, fn_name, fires_on)
-    events, timing, definition = cleaned_trigger_def(table_name, name)
-
-    events = events&.split(',')
-    expected_timing, expected_events = fires_on.first
-    expect(timing).to eq(expected_timing.to_s)
-    expect(events).to match_array(Array.wrap(expected_events))
-
-    expect(definition).to match(%r{execute (?:procedure|function) #{fn_name}()})
-  end
-
-  private
-
-  def parsed_function_statements(name)
-    cleaned_definition = find_function_def(name)['body'].downcase.gsub(/\s+/, ' ')
-    statements = cleaned_definition.sub(/\A\s*begin\s*(.*)\s*end\s*\Z/, "\\1")
-    statements.split(';').map! { |stmt| stmt.strip.presence }.compact!
-  end
-
-  def find_function_def(name)
-    connection.select_one(<<~SQL)
-      SELECT prosrc AS body
-      FROM pg_proc
-      WHERE proname = '#{name}'
-    SQL
-  end
-
-  def cleaned_trigger_def(table_name, name)
-    find_trigger_def(table_name, name).values_at('event', 'action_timing', 'action_statement').map!(&:downcase)
-  end
-
-  def find_trigger_def(table_name, name)
-    connection.select_one(<<~SQL)
-      SELECT
-        string_agg(event_manipulation, ',') AS event,
-        action_timing,
-        action_statement
-      FROM information_schema.triggers
-      WHERE event_object_table = '#{table_name}'
-      AND trigger_name = '#{name}'
-      GROUP BY 2, 3
-    SQL
-  end
-end