activerecord-cockroachdb-adapter 8.0.3 → 8.1.0

data/test/cases/helper_cockroachdb.rb

@@ -0,0 +1,232 @@
+require 'bundler'
+Bundler.setup
+
+module ExcludeMessage
+  VALIDATE_BUG = "CockcroachDB bug, see https://github.com/cockroachdb/cockroach/blob/dd1e0e0164cb3d5859ea4bb23498863d1eebc0af/pkg/sql/alter_table.go#L458-L467"
+  NO_HSTORE = "Extension \"hstore\" is not yet supported by CRDB. See https://github.com/cockroachdb/cockroach/issues/41284"
+end
+
+require "minitest/excludes"
+
+# This gives great visibility on schema dump related tests, but
+# some rails specific messages are then ignored.
+Minitest::Test.make_my_diffs_pretty! if ENV['VERBOSE']
+
+# Override the load_schema_helper for the
+# two ENV variables COCKROACH_LOAD_FROM_TEMPLATE
+# and COCKROACH_SKIP_LOAD_SCHEMA that can
+# skip this step
+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_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
+
+  private def load_from_template(&)
+    require 'support/template_creator'
+
+    if TemplateCreator.template_exists?
+      print "Loading schema from template..."
+    else
+      print "Generating and caching template schema..."
+    end
+
+    t0 = Time.now
+
+    TemplateCreator.load_from_template do
+      yield
+      load_cockroachdb_specific_schema
+    end
+
+    puts format(" %.2fs", Time.now - t0)
+
+    # reconnect to activerecord_unittest
+    shh { ARTest.connect }
+  end
+
+  private def shh
+    original_stdout = $stdout
+    $stdout = StringIO.new
+    yield
+  ensure
+    $stdout = original_stdout
+  end
+end
+LoadSchemaHelper.prepend(LoadSchemaHelperExt)
+
+require "activerecord-cockroachdb-adapter"
+
+# Load ActiveRecord test helper
+require "cases/helper"
+
+require "support/exclude_from_transactional_tests"
+
+# Allow exclusion of tests by name using #exclude_from_transactional_tests(test_name)
+ActiveRecord::TestCase.prepend(ExcludeFromTransactionalTests)
+
+require 'timeout'
+
+module TestTimeoutHelper
+  def time_it
+    t0 = Minitest.clock_time
+
+    timeout_mins = ENV.fetch("TEST_TIMEOUT", 5).to_i
+    Timeout.timeout(timeout_mins * 60, Timeout::Error, "Test took over #{timeout_mins} minutes to finish") do
+      yield
+    end
+  ensure
+    self.time = Minitest.clock_time - t0
+  end
+end
+
+module ActiveSupport
+  class TestCase
+    include TestTimeoutHelper
+
+    def postgis_version
+      @postgis_version ||= ActiveRecord::Base.lease_connection.select_value('SELECT postgis_lib_version()')
+    end
+
+    def factory
+      RGeo::Cartesian.preferred_factory(srid: 3857)
+    end
+
+    def geographic_factory
+      RGeo::Geographic.spherical_factory(srid: 4326)
+    end
+
+    def spatial_factory_store
+      RGeo::ActiveRecord::SpatialFactoryStore.instance
+    end
+  end
+end
+
+module SetDatetimeInCockroachDBAdapter
+  def with_postgresql_datetime_type(type)
+    adapter = ActiveRecord::ConnectionAdapters::CockroachDBAdapter
+    adapter.remove_instance_variable(:@native_database_types) if adapter.instance_variable_defined?(:@native_database_types)
+    datetime_type_was = adapter.datetime_type
+    adapter.datetime_type = type
+    yield
+  ensure
+    adapter = ActiveRecord::ConnectionAdapters::CockroachDBAdapter
+    adapter.datetime_type = datetime_type_was
+    adapter.remove_instance_variable(:@native_database_types) if adapter.instance_variable_defined?(:@native_database_types)
+  end
+  alias :with_cockroachdb_datetime_type :with_postgresql_datetime_type
+end
+
+ActiveRecord::TestCase.prepend(SetDatetimeInCockroachDBAdapter)
+
+if ENV["JSON_REPORTER"]
+  puts "Generating JSON report: #{ENV["JSON_REPORTER"]}"
+  module Minitest
+    class JSONReporter < StatisticsReporter
+      def report
+        super
+        io.write(
+          {
+            seed: Minitest.seed,
+            assertions: assertions,
+            count: count,
+            failed_tests: results.reject(&:skipped?),
+            total_time: total_time,
+            failures: failures,
+            errors: errors,
+            warnings: warnings,
+            skips: skips,
+          }.to_json
+        )
+      end
+    end
+
+    def self.plugin_json_reporter_init(*)
+      reporter << JSONReporter.new(File.open(ENV["JSON_REPORTER"], "w"))
+    end
+
+    self.extensions << "json_reporter"
+  end
+end
+
+# Using '--fail-fast' may cause the rails plugin to raise Interrupt when recording
+# a test. This would prevent other plugins from recording it. Hence we make sure
+# that rails plugin is loaded last.
+Minitest.load_plugins
+if Minitest.extensions.include?("rails")
+  Minitest.extensions.delete("rails")
+  Minitest.extensions << "rails"
+end
+
+if ENV['TRACE_LIB']
+  module TraceLibPlugin
+    def after_setup
+      super
+      @tl_plugin__already_showed = {}
+      @tl_plugin__trace = TracePoint.new(:call) do |tp|
+          next unless tp.path.include?("activerecord-cockroachdb-adapter/lib")
+          full_path = "#{tp.path}:#{tp.lineno}"
+          next if @tl_plugin__already_showed[full_path]
+          @tl_plugin__already_showed[full_path] = true
+          puts "==> #{tp.defined_class}##{tp.method_id} at #{full_path}"
+      end
+      @tl_plugin__trace.enable
+    end
+
+    def before_teardown
+      @tl_plugin__trace.disable
+      super
+    end
+  end
+  Minitest::Test.include(TraceLibPlugin)
+end
+
+# Log all SQL queries and print total time spent in SQL.
+if ENV["AR_LOG"]
+  require "support/sql_logger"
+  case ENV["AR_LOG"].strip
+  when "stdout" then SQLLogger.stdout_log
+  when "summary" then SQLLogger.summary_log
+  else
+    SQLLogger.stdout_log
+    SQLLogger.summary_log
+  end
+
+end
+
+# Remove the header from the schema dump to clarify tests outputs.
+module NoHeaderExt
+  def header(stream)
+    with_comments = StringIO.new
+    super(with_comments)
+    stream.print with_comments.string.gsub(/^(:?#.*)?\n/, '')
+  end
+end
+
+ActiveRecord::SchemaDumper.prepend(NoHeaderExt)
+
+# CRDB does not support ALTER COLUMN TYPE inside a transaction
+# NOTE: This would be better in an exclude test, however this base
+#   class is used by a lot of inherited tests. We repeat less here.
+class BaseCompatibilityTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+end

data/test/cases/inheritance_test.rb

@@ -0,0 +1,42 @@
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "models/company"
+
+module CockroachDB
+  class InheritanceComputeTypeTest < ActiveRecord::TestCase
+
+    # This replaces the same test that's been excluded from
+    # InheritanceComputeTypeTest. New, unsaved records won't have
+    # string default values if the default has been changed in the database.
+    # This happens because once a column default is changed in CockroachDB, the
+    # type information on the value is missing.
+    # We can still verify the desired behavior by persisting the test records.
+    # When ActiveRecord fetches the records from the database, they'll have
+    # their default values.
+    # See test/excludes/InheritanceComputeTypeTest.rb
+    def test_inheritance_new_with_subclass_as_default
+      original_type = Company.columns_hash["type"].default
+      ActiveRecord::Base.lease_connection.change_column_default :companies, :type, "Firm"
+      Company.reset_column_information
+
+      # Instead of using an unsaved Company record, persist one and fetch it
+      # from the database to get the new default value for type.
+      Company.create!(name: "Acme Co.", firm_name: "Shri Hans Plastic") # with arguments
+      firm = Company.last
+      assert_equal "Firm", firm.type
+      assert_instance_of Firm, firm
+
+      client = Client.new
+      assert_equal "Client", client.type
+      assert_instance_of Client, client
+
+      firm = Company.new(type: "Client") # overwrite the default type
+      assert_equal "Client", firm.type
+      assert_instance_of Client, firm
+    ensure
+      ActiveRecord::Base.lease_connection.change_column_default :companies, :type, original_type
+      Company.reset_column_information
+    end
+  end
+end

data/test/cases/invertible_migration_test.rb

@@ -0,0 +1,73 @@
+require "cases/helper_cockroachdb"
+
+module CockroachDB
+  class Horse < ActiveRecord::Base
+  end
+
+  class InvertibleMigrationTest < ActiveRecord::TestCase
+    class SilentMigration < ActiveRecord::Migration::Current
+      def write(text = "")
+        # sssshhhhh!!
+      end
+    end
+
+    class ChangeColumnDefault1 < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :name, :string, default: "Sekitoba"
+        end
+      end
+    end
+
+    class ChangeColumnDefault2 < SilentMigration
+      def change
+        change_column_default :horses, :name, from: "Sekitoba", to: "Diomed"
+      end
+    end
+
+    self.use_transactional_tests = false
+
+    setup do
+      @verbose_was, ActiveRecord::Migration.verbose = ActiveRecord::Migration.verbose, false
+    end
+
+    teardown do
+      %w[horses new_horses].each do |table|
+        if ActiveRecord::Base.lease_connection.table_exists?(table)
+          ActiveRecord::Base.lease_connection.drop_table(table)
+        end
+      end
+      ActiveRecord::Migration.verbose = @verbose_was
+    end
+
+    # This replaces the same test that's been excluded from
+    # ActiveRecord::InvertibleMigrationTest. New, unsaved records won't have
+    # string default values if the default has been changed in the database.
+    # This happens because once a column default is changed in CockroachDB, the
+    # type information on the value is missing.
+    # We can still verify the desired behavior by persisting the test records.
+    # When ActiveRecord fetches the records from the database, they'll have
+    # their default values.
+    # See test/excludes/ActiveRecord/InvertibleMigrationTest.rb
+    def test_migrate_revert_change_column_default
+      migration1 = ChangeColumnDefault1.new
+      migration1.migrate(:up)
+      assert_equal "Sekitoba", Horse.new.name
+
+      # Instead of using an unsaved Horse record, persist one and fetch it from
+      # the database to get the new default value for name.
+      migration2 = ChangeColumnDefault2.new
+      migration2.migrate(:up)
+      Horse.reset_column_information
+      Horse.create!
+      assert_equal "Diomed", Horse.last.name
+
+      # Instead of using an unsaved Horse record, persist one and fetch it from
+      # the database to get the new default value for name.
+      migration2.migrate(:down)
+      Horse.reset_column_information
+      Horse.create!
+      assert_equal "Sekitoba", Horse.last.name
+    end
+  end
+end

data/test/cases/marshal_serialization_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+require "support/paths_cockroachdb"
+
+module CockroachDB
+  class MarshalSerializationTest < ActiveRecord::TestCase
+    # This test file is identical to the one in Rails, except that
+    # the marshal_fixture_path method specifies to use the PostgreSQL
+    # directory instead of using the adapter name.
+    fixtures :topics
+
+    def test_deserializing_rails_6_1_marshal_basic
+      topic = Marshal.load(marshal_fixture("rails_6_1_topic"))
+
+      assert_not_predicate topic, :new_record?
+      assert_equal 1, topic.id
+      assert_equal "The First Topic", topic.title
+      assert_equal "Have a nice day", topic.content
+    end
+
+    def test_deserializing_rails_6_1_marshal_with_loaded_association_cache
+      topic = Marshal.load(marshal_fixture("rails_6_1_topic_associations"))
+
+      assert_not_predicate topic, :new_record?
+      assert_equal 1, topic.id
+      assert_equal "The First Topic", topic.title
+      assert_equal "Have a nice day", topic.content
+    end
+
+    private
+      def marshal_fixture(file_name)
+        File.binread(marshal_fixture_path(file_name))
+      end
+
+      def marshal_fixture_path(file_name)
+        File.expand_path(
+          "support/marshal_compatibility_fixtures/PostgreSQL/#{file_name}.dump",
+          ARTest::CockroachDB.root_activerecord_test
+        )
+      end
+  end
+end

data/test/cases/migration/change_schema_test.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+
+module ActiveRecord
+  module CockroachDB
+    class Migration
+      class ChangeSchemaTest < ActiveRecord::TestCase
+        attr_reader :connection, :table_name
+
+        self.use_transactional_tests = false
+
+        def setup
+          super
+          @connection = ActiveRecord::Base.lease_connection
+          @table_name = :testings
+        end
+
+        teardown do
+          connection.drop_table :testings, if_exists: true
+          ActiveRecord::Base.primary_key_prefix_type = nil
+          ActiveRecord::Base.clear_cache!
+        end
+
+        # This test is identical to the one in Rails, except here we are running
+        # it with transactions turned off so that we can properly assert on
+        # database changes. See https://www.cockroachlabs.com/docs/v19.2/transactions.html
+        def test_drop_table_if_exists
+          connection.create_table(:testings)
+          assert connection.table_exists?(:testings)
+          connection.drop_table(:testings, if_exists: true)
+          assert_not connection.table_exists?(:testings)
+        end
+
+        # This test is identical to the one in Rails, except here we are running
+        # it with transactions turned off so that we can properly assert on
+        # database changes. See https://www.cockroachlabs.com/docs/v19.2/transactions.html
+        def test_keeping_default_and_notnull_constraints_on_change
+          connection.create_table :testings do |t|
+            t.column :title, :string
+          end
+          person_klass = Class.new(ActiveRecord::Base)
+          person_klass.table_name = "testings"
+
+          person_klass.lease_connection.add_column "testings", "wealth", :integer, null: false, default: 99
+          person_klass.reset_column_information
+          assert_equal 99, person_klass.column_defaults["wealth"]
+          assert_equal false, person_klass.columns_hash["wealth"].null
+          assert_nothing_raised { person_klass.lease_connection.execute("insert into testings (title) values ('tester')") }
+
+          # change column default to see that column doesn't lose its not null definition
+          person_klass.lease_connection.change_column_default "testings", "wealth", 100
+          person_klass.reset_column_information
+          assert_equal 100, person_klass.column_defaults["wealth"]
+          assert_equal false, person_klass.columns_hash["wealth"].null
+
+          # rename column to see that column doesn't lose its not null and/or default definition
+          person_klass.lease_connection.rename_column "testings", "wealth", "money"
+          person_klass.reset_column_information
+          assert_nil person_klass.columns_hash["wealth"]
+          assert_equal 100, person_klass.column_defaults["money"]
+          assert_equal false, person_klass.columns_hash["money"].null
+
+          # change column
+          person_klass.lease_connection.change_column "testings", "money", :integer, null: false, default: 1000
+          person_klass.reset_column_information
+          assert_equal 1000, person_klass.column_defaults["money"]
+          assert_equal false, person_klass.columns_hash["money"].null
+
+          # change column, make it nullable and clear default
+          person_klass.lease_connection.change_column "testings", "money", :integer, null: true, default: nil
+          person_klass.reset_column_information
+          assert_nil person_klass.columns_hash["money"].default
+          assert_equal true, person_klass.columns_hash["money"].null
+
+          # change_column_null, make it not nullable and set null values to a default value
+          person_klass.lease_connection.execute("UPDATE testings SET money = NULL")
+          person_klass.lease_connection.change_column_null "testings", "money", false, 2000
+          person_klass.reset_column_information
+          assert_nil person_klass.columns_hash["money"].default
+          assert_equal false, person_klass.columns_hash["money"].null
+          assert_equal 2000, connection.select_values("SELECT money FROM testings").first.to_i
+        end
+
+        # This test is identical to the one in Rails, except here we are running
+        # it with transactions turned off so that we can properly assert on
+        # database changes. See https://www.cockroachlabs.com/docs/v19.2/transactions.html
+        def test_change_column_null
+          testing_table_with_only_foo_attribute do
+            notnull_migration = Class.new(ActiveRecord::Migration::Current) do
+              def change
+                change_column_null :testings, :foo, false
+              end
+            end
+            notnull_migration.new.suppress_messages do
+              notnull_migration.migrate(:up)
+              assert_equal false, connection.columns(:testings).find { |c| c.name == "foo" }.null
+              notnull_migration.migrate(:down)
+              assert connection.columns(:testings).find { |c| c.name == "foo" }.null
+            end
+          end
+        end
+
+        def test_create_table_with_limits
+          connection.create_table :testings do |t|
+            t.column :foo, :string, limit: 255
+
+            t.column :default_int, :integer
+
+            t.column :one_int,    :integer, limit: 1
+            t.column :four_int,   :integer, limit: 4
+            t.column :eight_int,  :integer, limit: 8
+          end
+
+          columns = connection.columns(:testings)
+          foo = columns.detect { |c| c.name == "foo" }
+          assert_equal 255, foo.limit
+
+          default = columns.detect { |c| c.name == "default_int" }
+          one     = columns.detect { |c| c.name == "one_int"     }
+          four    = columns.detect { |c| c.name == "four_int"    }
+          eight   = columns.detect { |c| c.name == "eight_int"   }
+
+          assert_equal "bigint", default.sql_type #This differs from PG, whose default type is integer
+          assert_equal "smallint", one.sql_type
+          assert_equal "integer", four.sql_type
+          assert_equal "bigint", eight.sql_type
+        end
+
+        private
+          def testing_table_with_only_foo_attribute
+            connection.create_table :testings, id: false do |t|
+              t.column :foo, :string
+            end
+            yield
+          end
+      end
+    end
+  end
+end

data/test/cases/migration/check_constraint_test.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_check_constraints?
+  module ActiveRecord
+    module CockroachDB
+      class Migration
+        class CheckConstraintTest < ActiveRecord::TestCase
+          include SchemaDumpingHelper
+          self.use_transactional_tests = false
+
+          class Trade < ActiveRecord::Base
+          end
+
+          setup do
+            @connection = ActiveRecord::Base.lease_connection
+            @connection.create_table "trades", force: true do |t|
+              t.integer :price
+              t.integer :quantity
+            end
+          end
+
+          teardown do
+            @connection.drop_table "trades", if_exists: true
+          end
+
+          if ActiveRecord::Base.lease_connection.supports_validate_constraints?
+            # keep
+            def test_validate_check_constraint_by_name
+              @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: false
+              assert_not_predicate @connection.check_constraints("trades").first, :validated?
+
+              @connection.validate_check_constraint :trades, name: "quantity_check"
+              assert_predicate @connection.check_constraints("trades").first, :validated?
+            end
+          end
+
+          # ExcludeMessage::VALIDATE_BUG
+          # def test_schema_dumping_with_validate_false
+          #   @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: false
+
+          #   output = dump_table_schema "trades"
+
+          #   assert_match %r{\s+t.check_constraint "(quantity > 0)", name: "quantity_check", validate: false$}, output
+          # end
+
+          def test_schema_dumping_with_validate_true
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check", validate: true
+
+            output = dump_table_schema "trades"
+
+            assert_match %r{\s+t.check_constraint "\(quantity > 0\)", name: "quantity_check"$}, output
+          end
+
+          # keep
+          def test_remove_check_constraint
+            @connection.add_check_constraint :trades, "price > 0", name: "price_check"
+            @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check"
+
+            assert_equal 2, @connection.check_constraints("trades").size
+            @connection.remove_check_constraint :trades, name: "quantity_check"
+            assert_equal 1, @connection.check_constraints("trades").size
+
+            constraint = @connection.check_constraints("trades").first
+            assert_equal "trades", constraint.table_name
+            assert_equal "price_check", constraint.name
+
+            if current_adapter?(:Mysql2Adapter)
+              assert_equal "`price` > 0", constraint.expression
+            else
+              assert_equal "(price > 0)", constraint.expression
+            end
+          end
+
+          def test_check_constraints
+            check_constraints = @connection.check_constraints("products")
+            assert_equal 1, check_constraints.size
+
+            constraint = check_constraints.first
+            assert_equal "products", constraint.table_name
+            assert_equal "products_price_check", constraint.name
+
+            if current_adapter?(:Mysql2Adapter)
+              assert_equal "`price` > `discounted_price`", constraint.expression
+            else
+              assert_equal "(price > discounted_price)", constraint.expression
+            end
+
+            if current_adapter?(:PostgreSQLAdapter)
+              begin
+                # Test that complex expression is correctly parsed from the database
+                @connection.add_check_constraint(:trades,
+                  "CASE WHEN price IS NOT NULL THEN true ELSE false END", name: "price_is_required")
+
+                constraint = @connection.check_constraints("trades").find { |c| c.name == "price_is_required" }
+                assert_includes constraint.expression, "WHEN price IS NOT NULL"
+              ensure
+                @connection.remove_check_constraint(:trades, name: "price_is_required")
+              end
+            end
+          end
+
+          def test_add_check_constraint
+            @connection.add_check_constraint :trades, "quantity > 0"
+
+            check_constraints = @connection.check_constraints("trades")
+            assert_equal 1, check_constraints.size
+
+            constraint = check_constraints.first
+            assert_equal "trades", constraint.table_name
+            assert_equal "chk_rails_2189e9f96c", constraint.name
+
+            if current_adapter?(:Mysql2Adapter)
+              assert_equal "`quantity` > 0", constraint.expression
+            else
+              assert_equal "(quantity > 0)", constraint.expression
+            end
+          end
+        end
+      end
+    end
+  end
+end