fix(test): update template creator

It was using old and invalid SQL statements. I took that
opportunity to also change a bit its behaviour:
- Remove the related rake task and automatically cache
  the schema if non-existent.
- Cache every databases used in tests.
- Ensure that cache name is based on schema files.
- Rely on DefaultDB for db manipulations since the others
  might not exist.

Author: BuonOmo

CONTRIBUTING.md

@@ -61,23 +61,16 @@ Only do it if you know the schema was left in a correct state.
 
 ### Run Tests from a Backup
 
-Loading the full test schema every time a test runs can take a while, so for cases where loading the schema sequentially is unimportant, it is possible to use a backup to set up the database. This is significantly faster than the standard method and is provided to run individual tests faster, but should not be used to validate a build.
-
-First create the template database.
-
-```bash
-bundle exec rake db:create_test_template
-```
-
-This will create a template database for the current version (ex. `activerecord_test_template611` for version 6.1.1) and create a `BACKUP` in the `nodelocal://self/activerecord-crdb-adapter/#{activerecord_version}` directory.
-
-To load from the template, use the `COCKROACH_LOAD_FROM_TEMPLATE` flag.
-
-```bash
-COCKROACH_LOAD_FROM_TEMPLATE=1 TEST_FILES="test/cases/adapters/postgresql/ddl_test.rb" bundle exec rake test
-```
-
-And the `activerecord_unittest` database will use the `RESTORE` command to load the schema from the template database.
+Loading the full test schema every time a test runs can take
+a while, so for cases where loading the schema sequentially
+is unimportant, it is possible to use a backup to set up the
+database. This is significantly faster than the standard
+method and is provided to run individual tests faster, but
+should not be used to validate a build.
+
+To do so, just set the env variable `COCKROACH_LOAD_FROM_TEMPLATE`.
+First run will generate and cache a template, latter runs will use
+it.
 
 # Improvements
 

Rakefile

@@ -2,28 +2,9 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 require_relative 'test/support/paths_cockroachdb'
 require_relative 'test/support/rake_helpers'
-require_relative 'test/support/template_creator'
 
 task default: [:test]
 
-namespace :db do
-  task "create_test_template" do
-    ENV['DEBUG_COCKROACHDB_ADAPTER'] = "1"
-    ENV['COCKROACH_SKIP_LOAD_SCHEMA'] = "1"
-
-    TemplateCreator.connect
-    require_relative 'test/cases/helper'
-
-    # TODO: look into this more, but for some reason the blob alias
-    # is not defined while running this task.
-    ActiveRecord::ConnectionAdapters::CockroachDB::TableDefinition.class_eval do
-      alias :blob :binary
-    end
-
-    TemplateCreator.create_test_template
-  end
-end
-
 Rake::TestTask.new do |t|
   t.libs = ARTest::CockroachDB.test_load_paths
   t.test_files = RakeHelpers.test_files

test/cases/helper_cockroachdb.rb

@@ -22,52 +22,70 @@ module ExcludeMessage
 require "support/load_schema_helper"
 
 module LoadSchemaHelperExt
+  # Load the CockroachDB specific schema. It replaces ActiveRecord's PostgreSQL
+  # specific schema.
+  def load_cockroachdb_specific_schema
+    # silence verbose schema loading
+    shh do
+      load "schema/cockroachdb_specific_schema.rb"
+
+      ActiveRecord::FixtureSet.reset_cache
+    end
+  end
+
   def load_schema
-    return if ENV['COCKROACH_LOAD_FROM_TEMPLATE']
     return if ENV['COCKROACH_SKIP_LOAD_SCHEMA']
+    return load_from_template { super } if ENV['COCKROACH_LOAD_FROM_TEMPLATE']
 
+    print "Loading schema..."
+    t0 = Time.now
     super
+    load_cockroachdb_specific_schema
+    puts format(" %.2fs", Time.now - t0)
+    return
   end
-end
-LoadSchemaHelper.prepend(LoadSchemaHelperExt)
 
-require "activerecord-cockroachdb-adapter"
+  private def load_from_template(&)
+    require 'support/template_creator'
 
-# Load ActiveRecord test helper
-require "cases/helper"
+    if TemplateCreator.template_exists?
+      print "Loading schema from template..."
+    else
+      print "Generating and caching template schema..."
+    end
 
-require "support/exclude_from_transactional_tests"
+    t0 = Time.now
 
-# Allow exclusion of tests by name using #exclude_from_transactional_tests(test_name)
-ActiveRecord::TestCase.prepend(ExcludeFromTransactionalTests)
+    TemplateCreator.load_from_template do
+      yield
+      load_cockroachdb_specific_schema
+    end
 
-# Load the CockroachDB specific schema. It replaces ActiveRecord's PostgreSQL
-# specific schema.
-def load_cockroachdb_specific_schema
-  # silence verbose schema loading
-  original_stdout = $stdout
-  $stdout = StringIO.new
+    puts format(" %.2fs", Time.now - t0)
 
-  load "schema/cockroachdb_specific_schema.rb"
+    # reconnect to activerecord_unittest
+    shh { ARTest.connect }
+  end
 
-  ActiveRecord::FixtureSet.reset_cache
-ensure
-  $stdout = original_stdout
+  private def shh
+    original_stdout = $stdout
+    $stdout = StringIO.new
+    yield
+  ensure
+    $stdout = original_stdout
+  end
 end
+LoadSchemaHelper.prepend(LoadSchemaHelperExt)
 
-if ENV['COCKROACH_LOAD_FROM_TEMPLATE'].nil? && ENV['COCKROACH_SKIP_LOAD_SCHEMA'].nil?
-  load_cockroachdb_specific_schema
-elsif ENV['COCKROACH_LOAD_FROM_TEMPLATE']
-  require 'support/template_creator'
+require "activerecord-cockroachdb-adapter"
 
-  p "loading schema from template"
+# Load ActiveRecord test helper
+require "cases/helper"
 
-  # load from template
-  TemplateCreator.restore_from_template
+require "support/exclude_from_transactional_tests"
 
-  # reconnect to activerecord_unittest
-  ARTest.connect
-end
+# Allow exclusion of tests by name using #exclude_from_transactional_tests(test_name)
+ActiveRecord::TestCase.prepend(ExcludeFromTransactionalTests)
 
 require 'timeout'
 

test/support/template_creator.rb

@@ -1,88 +1,114 @@
 # frozen_string_literal: true
 
-require 'active_record'
+require "activerecord-cockroachdb-adapter"
 require_relative 'paths_cockroachdb'
+require 'support/config' # ARTest.config
+require 'support/connection' # ARTest.connect
 
 module TemplateCreator
-  # extend self
-
-  DEFAULT_CONNECTION_HASH = {
-    adapter: 'cockroachdb',
-    database: 'defaultdb',
-    port: 26257,
-    user: 'root',
-    host: 'localhost'
-  }.freeze
+  class DefaultDB < ActiveRecord::Base
+    establish_connection(
+      adapter: 'cockroachdb',
+      database: 'defaultdb',
+      port: 26257,
+      user: 'root',
+      host: 'localhost'
+    )
+  end
 
-  BACKUP_DIR = "nodelocal://self/activerecord-crdb-adapter"
+  # Database created once the backup is finished to make sure we have a
+  # clean backup to work with. See #template_exists?
+  EXISTS = "exists"
+  BACKUP_DIR = "userfile://defaultdb.public/activerecord-crdb-adapter"
 
   module_function
 
-  def ar_version
-    ActiveRecord.version.version.gsub('.','')
+  def template_version
+    ar_version = ActiveRecord.version.version.gsub('.','_')
+    main_schema_digest = Digest::MD5.file(SCHEMA_ROOT + "/schema.rb").hexdigest
+    crdb_schema_digest = Digest::MD5.file("#{__dir__}/../schema/cockroachdb_specific_schema.rb").hexdigest
+    "#{ar_version}_#{main_schema_digest}_#{crdb_schema_digest}"
   end
 
   def version_backup_path
-    BACKUP_DIR + "/#{ar_version}"
+    BACKUP_DIR + "/#{template_version}"
   end
 
-  def template_db_name
-    "activerecord_unittest_template#{ar_version}"
+  def template_db_name(db_name)
+    "#{db_name}__template__#{template_version}"
   end
 
-  def connect(connection_hash=nil)
-    connection_hash = DEFAULT_CONNECTION_HASH if connection_hash.nil?
-    ActiveRecord::Base.establish_connection(connection_hash)
+  def template_exists?
+    template_db_exists?(EXISTS)
   end
 
-  def template_db_exists?
-    ActiveRecord::Base.lease_connection.select_value("SELECT 1 FROM pg_database WHERE datname='#{template_db_name}'") == 1
+  def databases
+    @databases ||=ARTest.config.dig("connections", "cockroachdb").map { |_, value| value["database"] }.uniq
   end
 
-  def drop_template_db
-    ActiveRecord::Base.lease_connection.execute("DROP DATABASE #{template_db_name}")
+  def with_template_db_names
+    old_crdb = ARTest.config["connections"]["cockroachdb"]
+    new_crdb = old_crdb.transform_values { _1.merge("database" => template_db_name(_1["database"])) }
+    ARTest.config["connections"]["cockroachdb"] = new_crdb
+    yield
+  ensure
+    ARTest.config["connections"]["cockroachdb"] = old_crdb
   end
 
-  def create_template_db
-    ActiveRecord::Base.lease_connection.execute("CREATE DATABASE #{template_db_name}")
+  def template_db_exists?(db_name)
+    DefaultDB.lease_connection.select_value("SELECT 1 FROM pg_database WHERE datname='#{template_db_name(db_name)}'") == 1
   end
 
-  def load_schema
-    p 'loading schema'
-    load ARTest::CockroachDB.root_activerecord_test + '/schema/schema.rb'
-    load 'test/schema/cockroachdb_specific_schema.rb'
+  def drop_template_db(db_name)
+    DefaultDB.lease_connection.execute("DROP DATABASE #{template_db_name(db_name)} CASCADE")
   end
 
-  def create_test_template
-    connect
-    raise "#{template_db_name} already exists. If you do not have a backup created, please drop the database and run again." if template_db_exists?
-
-    create_template_db
+  def create_template_db(db_name)
+    DefaultDB.lease_connection.execute("CREATE DATABASE #{template_db_name(db_name)}")
+  end
 
-    # switch connection to template db
-    conn = DEFAULT_CONNECTION_HASH.dup
-    conn['database'] = template_db_name
-    connect(conn)
+  def create_test_template(&block)
+    databases.each do |db_name|
+      drop_template_db(db_name) if template_db_exists?(db_name)
+      create_template_db(db_name)
+    end
 
-    load_schema
+    with_template_db_names do
+      shh { ARTest.connect }
+      block.call
+    end
 
-    # create BACKUP to restore from
-    ActiveRecord::Base.lease_connection.execute("BACKUP DATABASE #{template_db_name} TO '#{version_backup_path}'")
+    DefaultDB.lease_connection.execute(<<~SQL)
+    BACKUP DATABASE #{databases.map { |db| template_db_name(db) }.join(', ')}
+    INTO '#{version_backup_path}'
+    SQL
+    create_template_db(EXISTS)
   end
 
-  def restore_from_template
-    connect
-    raise "The TemplateDB does not exist. Run 'rake db:create_test_template' first." unless template_db_exists?
-
-    begin
-      ActiveRecord::Base.lease_connection.execute("DROP DATABASE activerecord_unittest")
-    rescue ActiveRecord::StatementInvalid => e
-      unless e.cause.class == PG::InvalidCatalogName
-        raise e
+  def load_from_template(&block)
+    create_test_template(&block) unless template_exists?
+    databases.each do |db_name|
+      begin
+        DefaultDB.lease_connection.execute("DROP DATABASE #{db_name}")
+      rescue ActiveRecord::StatementInvalid => e
+        unless e.cause.class == PG::InvalidCatalogName
+          raise e
+        end
       end
+      DefaultDB.lease_connection.execute("CREATE DATABASE #{db_name}")
+      DefaultDB.lease_connection.execute(<<~SQL)
+      RESTORE #{template_db_name(db_name)}.*
+      FROM LATEST IN '#{version_backup_path}'
+      WITH into_db = '#{db_name}'
+      SQL
     end
-    ActiveRecord::Base.lease_connection.execute("CREATE DATABASE activerecord_unittest")
+  end
 
-    ActiveRecord::Base.lease_connection.execute("RESTORE #{template_db_name}.* FROM '#{version_backup_path}' WITH into_db = 'activerecord_unittest'")
+  private def shh
+    original_stdout = $stdout
+    $stdout = StringIO.new
+    yield
+  ensure
+    $stdout = original_stdout
   end
 end