ibm_db 5.6.1-arm64-darwin-24

data/test/cases/modules_test.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/company_in_module"
+require "models/shop"
+require "models/developer"
+require "models/computer"
+
+class ModulesTest < ActiveRecord::TestCase
+  fixtures :accounts, :companies, :projects, :developers, :collections, :products, :variants
+
+  def setup
+    # need to make sure Object::Firm and Object::Client are not defined,
+    # so that constantize will not be able to cheat when having to load namespaced classes
+    @undefined_consts = {}
+
+    [:Firm, :Client].each do |const|
+      @undefined_consts.merge! const => Object.send(:remove_const, const) if Object.const_defined?(const)
+    end
+
+    ActiveRecord::Base.store_full_sti_class = false
+  end
+
+  teardown do
+    # reinstate the constants that we undefined in the setup
+    @undefined_consts.each do |constant, value|
+      Object.const_set constant, value unless value.nil?
+    end
+
+    ActiveRecord::Base.store_full_sti_class = true
+  end
+
+  def test_module_spanning_associations
+    firm = MyApplication::Business::Firm.first
+    assert_not firm.clients.empty?, "Firm should have clients"
+    assert_nil firm.class.table_name.match("::"), "Firm shouldn't have the module appear in its table name"
+  end
+
+  def test_module_spanning_has_and_belongs_to_many_associations
+    project = MyApplication::Business::Project.first
+    project.developers << MyApplication::Business::Developer.create("name" => "John")
+    assert_equal "John", project.developers.last.name
+  end
+
+  def test_associations_spanning_cross_modules
+    account = MyApplication::Billing::Account.all.merge!(order: "id").first
+    assert_kind_of MyApplication::Business::Firm, account.firm
+    assert_kind_of MyApplication::Billing::Firm, account.qualified_billing_firm
+    assert_kind_of MyApplication::Billing::Firm, account.unqualified_billing_firm
+    assert_kind_of MyApplication::Billing::Nested::Firm, account.nested_qualified_billing_firm
+    assert_kind_of MyApplication::Billing::Nested::Firm, account.nested_unqualified_billing_firm
+  end
+
+  def test_find_account_and_include_company
+    account = MyApplication::Billing::Account.all.merge!(includes: :firm).find(1)
+    assert_kind_of MyApplication::Business::Firm, account.firm
+  end
+
+  def test_table_name
+    assert_equal "accounts", MyApplication::Billing::Account.table_name, "table_name for ActiveRecord model in module"
+    assert_equal "companies", MyApplication::Business::Client.table_name, "table_name for ActiveRecord model subclass"
+    assert_equal "company_contacts", MyApplication::Business::Client::Contact.table_name, "table_name for ActiveRecord model enclosed by another ActiveRecord model"
+  end
+
+  def test_assign_ids
+    firm = MyApplication::Business::Firm.first
+
+    assert_nothing_raised do
+      firm.client_ids = [MyApplication::Business::Client.first.id]
+    end
+  end
+
+  # An eager loading condition to force the eager loading model into the old join model.
+  def test_eager_loading_in_modules
+    clients = []
+
+    assert_nothing_raised do
+      clients << MyApplication::Business::Client.references(:accounts).merge!(includes: { firm: :account }, where: "accounts.id IS NOT NULL").find(3)
+      clients << MyApplication::Business::Client.includes(firm: :account).find(3)
+    end
+
+    clients.each do |client|
+      assert_no_queries do
+        assert_not_nil(client.firm.account)
+      end
+    end
+  end
+
+  def test_module_table_name_prefix
+    assert_equal "prefixed_companies", MyApplication::Business::Prefixed::Company.table_name, "inferred table_name for ActiveRecord model in module with table_name_prefix"
+    assert_equal "prefixed_companies", MyApplication::Business::Prefixed::Nested::Company.table_name, "table_name for ActiveRecord model in nested module with a parent table_name_prefix"
+    assert_equal "companies", MyApplication::Business::Prefixed::Firm.table_name, "explicit table_name for ActiveRecord model in module with table_name_prefix should not be prefixed"
+  end
+
+  def test_module_table_name_prefix_with_global_prefix
+    classes = [ MyApplication::Business::Company,
+                MyApplication::Business::Firm,
+                MyApplication::Business::Client,
+                MyApplication::Business::Client::Contact,
+                MyApplication::Business::Developer,
+                MyApplication::Business::Project,
+                MyApplication::Business::Prefixed::Company,
+                MyApplication::Business::Prefixed::Nested::Company,
+                MyApplication::Billing::Account ]
+
+    ActiveRecord::Base.table_name_prefix = "global_"
+    classes.each(&:reset_table_name)
+    assert_equal "global_companies", MyApplication::Business::Company.table_name, "inferred table_name for ActiveRecord model in module without table_name_prefix"
+    assert_equal "prefixed_companies", MyApplication::Business::Prefixed::Company.table_name, "inferred table_name for ActiveRecord model in module with table_name_prefix"
+    assert_equal "prefixed_companies", MyApplication::Business::Prefixed::Nested::Company.table_name, "table_name for ActiveRecord model in nested module with a parent table_name_prefix"
+    assert_equal "companies", MyApplication::Business::Prefixed::Firm.table_name, "explicit table_name for ActiveRecord model in module with table_name_prefix should not be prefixed"
+  ensure
+    ActiveRecord::Base.table_name_prefix = ""
+    classes.each(&:reset_table_name)
+  end
+
+  def test_module_table_name_suffix
+    assert_equal "companies_suffixed", MyApplication::Business::Suffixed::Company.table_name, "inferred table_name for ActiveRecord model in module with table_name_suffix"
+    assert_equal "companies_suffixed", MyApplication::Business::Suffixed::Nested::Company.table_name, "table_name for ActiveRecord model in nested module with a parent table_name_suffix"
+    assert_equal "companies", MyApplication::Business::Suffixed::Firm.table_name, "explicit table_name for ActiveRecord model in module with table_name_suffix should not be suffixed"
+  end
+
+  def test_module_table_name_suffix_with_global_suffix
+    classes = [ MyApplication::Business::Company,
+                MyApplication::Business::Firm,
+                MyApplication::Business::Client,
+                MyApplication::Business::Client::Contact,
+                MyApplication::Business::Developer,
+                MyApplication::Business::Project,
+                MyApplication::Business::Suffixed::Company,
+                MyApplication::Business::Suffixed::Nested::Company,
+                MyApplication::Billing::Account ]
+
+    ActiveRecord::Base.table_name_suffix = "_global"
+    classes.each(&:reset_table_name)
+    assert_equal "companies_global", MyApplication::Business::Company.table_name, "inferred table_name for ActiveRecord model in module without table_name_suffix"
+    assert_equal "companies_suffixed", MyApplication::Business::Suffixed::Company.table_name, "inferred table_name for ActiveRecord model in module with table_name_suffix"
+    assert_equal "companies_suffixed", MyApplication::Business::Suffixed::Nested::Company.table_name, "table_name for ActiveRecord model in nested module with a parent table_name_suffix"
+    assert_equal "companies", MyApplication::Business::Suffixed::Firm.table_name, "explicit table_name for ActiveRecord model in module with table_name_suffix should not be suffixed"
+  ensure
+    ActiveRecord::Base.table_name_suffix = ""
+    classes.each(&:reset_table_name)
+  end
+
+  def test_compute_type_can_infer_class_name_of_sibling_inside_module
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = true
+    assert_equal MyApplication::Business::Firm, MyApplication::Business::Client.send(:compute_type, "Firm")
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+
+  def test_nested_models_should_not_raise_exception_when_using_delete_all_dependency_on_association
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = true
+
+    collection = Shop::Collection.first
+    assert_not collection.products.empty?, "Collection should have products"
+    assert_nothing_raised { collection.destroy }
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+
+  def test_nested_models_should_not_raise_exception_when_using_nullify_dependency_on_association
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = true
+
+    product = Shop::Product.first
+    assert_not product.variants.empty?, "Product should have variants"
+    assert_nothing_raised { product.destroy }
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+end

data/test/cases/multi_db_migrator_test.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "cases/migration/helper"
+
+class MultiDbMigratorTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  # Use this class to sense if migrations have gone
+  # up or down.
+  class Sensor < ActiveRecord::Migration::Current
+    attr_reader :went_up, :went_down
+
+    def initialize(name = self.class.name, version = nil)
+      super
+      @went_up = false
+      @went_down = false
+    end
+
+    def up; @went_up = true; end
+    def down; @went_down = true; end
+  end
+
+  def setup
+    super
+    @connection_a = ActiveRecord::Base.connection
+    @connection_b = ARUnit2Model.connection
+
+    @connection_a.schema_migration.create_table
+    @connection_b.schema_migration.create_table
+
+    @connection_a.schema_migration.delete_all rescue nil
+    @connection_b.schema_migration.delete_all rescue nil
+
+    @path_a = MIGRATIONS_ROOT + "/valid"
+    @path_b = MIGRATIONS_ROOT + "/to_copy"
+
+    @schema_migration_a = @connection_a.schema_migration
+    @migrations_a = ActiveRecord::MigrationContext.new(@path_a, @schema_migration_a).migrations
+    @schema_migration_b = @connection_b.schema_migration
+    @migrations_b = ActiveRecord::MigrationContext.new(@path_b, @schema_migration_b).migrations
+
+    @migrations_a_list = [[1, "ValidPeopleHaveLastNames"], [2, "WeNeedReminders"], [3, "InnocentJointable"]]
+    @migrations_b_list = [[1, "PeopleHaveHobbies"], [2, "PeopleHaveDescriptions"]]
+
+    @verbose_was = ActiveRecord::Migration.verbose
+
+    ActiveRecord::Migration.message_count = 0
+    ActiveRecord::Migration.class_eval do
+      undef :puts
+      def puts(*)
+        ActiveRecord::Migration.message_count += 1
+      end
+    end
+  end
+
+  teardown do
+    @connection_a.schema_migration.delete_all rescue nil
+    @connection_b.schema_migration.delete_all rescue nil
+
+    ActiveRecord::Migration.verbose = @verbose_was
+    ActiveRecord::Migration.class_eval do
+      undef :puts
+      def puts(*)
+        super
+      end
+    end
+  end
+
+  def test_schema_migration_class_names
+    assert_equal "ActiveRecord::SchemaMigration", @schema_migration_a.name
+    assert_equal "ARUnit2Model::SchemaMigration", @schema_migration_b.name
+  end
+
+  def test_finds_migrations
+    @migrations_a_list.each_with_index do |pair, i|
+      assert_equal @migrations_a[i].version, pair.first
+      assert_equal @migrations_a[i].name, pair.last
+    end
+
+    @migrations_b_list.each_with_index do |pair, i|
+      assert_equal @migrations_b[i].version, pair.first
+      assert_equal @migrations_b[i].name, pair.last
+    end
+  end
+
+  def test_migrations_status
+    @schema_migration_a.create(version: 2)
+    @schema_migration_a.create(version: 10)
+
+    assert_equal [
+      ["down", "001", "Valid people have last names"],
+      ["up",   "002", "We need reminders"],
+      ["down", "003", "Innocent jointable"],
+      ["up",   "010", "********** NO FILE **********"],
+    ], ActiveRecord::MigrationContext.new(@path_a, @schema_migration_a).migrations_status
+
+    @schema_migration_b.create(version: 4)
+
+    assert_equal [
+      ["down", "001", "People have hobbies"],
+      ["down", "002", "People have descriptions"],
+      ["up", "004", "********** NO FILE **********"]
+    ], ActiveRecord::MigrationContext.new(@path_b, @schema_migration_b).migrations_status
+  end
+
+  def test_get_all_versions
+    _, migrator_a = migrator_class(3)
+    migrator_a = migrator_a.new(@path_a, @schema_migration_a)
+
+    migrator_a.migrate
+    assert_equal([1, 2, 3], migrator_a.get_all_versions)
+
+    migrator_a.rollback
+    assert_equal([1, 2], migrator_a.get_all_versions)
+
+    migrator_a.rollback
+    assert_equal([1], migrator_a.get_all_versions)
+
+    migrator_a.rollback
+    assert_equal([], migrator_a.get_all_versions)
+
+    _, migrator_b = migrator_class(2)
+    migrator_b = migrator_b.new(@path_b, @schema_migration_b)
+
+    migrator_b.migrate
+    assert_equal([1, 2], migrator_b.get_all_versions)
+
+    migrator_b.rollback
+    assert_equal([1], migrator_b.get_all_versions)
+
+    migrator_b.rollback
+    assert_equal([], migrator_b.get_all_versions)
+  end
+
+  def test_finds_pending_migrations
+    @schema_migration_a.create!(version: "1")
+    migration_list_a = [ActiveRecord::Migration.new("foo", 1), ActiveRecord::Migration.new("bar", 3)]
+    migrations_a = ActiveRecord::Migrator.new(:up, migration_list_a, @schema_migration_a).pending_migrations
+
+    assert_equal 1, migrations_a.size
+    assert_equal migration_list_a.last, migrations_a.first
+
+    @schema_migration_b.create!(version: "1")
+    migration_list_b = [ActiveRecord::Migration.new("foo", 1), ActiveRecord::Migration.new("bar", 3)]
+    migrations_b = ActiveRecord::Migrator.new(:up, migration_list_b, @schema_migration_b).pending_migrations
+
+    assert_equal 1, migrations_b.size
+    assert_equal migration_list_b.last, migrations_b.first
+  end
+
+  def test_migrator_db_has_no_schema_migrations_table
+    _, migrator = migrator_class(3)
+    migrator = migrator.new(@path_a, @schema_migration_a)
+
+    @schema_migration_a.drop_table
+    assert_not @connection_a.table_exists?("schema_migrations")
+    migrator.migrate(1)
+    assert @connection_a.table_exists?("schema_migrations")
+
+    _, migrator = migrator_class(3)
+    migrator = migrator.new(@path_b, @schema_migration_b)
+
+    @schema_migration_b.drop_table
+    assert_not @connection_b.table_exists?("schema_migrations")
+    migrator.migrate(1)
+    assert @connection_b.table_exists?("schema_migrations")
+  end
+
+  def test_migrator_forward
+    _, migrator = migrator_class(3)
+    migrator = migrator.new(@path_a, @schema_migration_a)
+    migrator.migrate(1)
+    assert_equal(1, migrator.current_version)
+
+    migrator.forward(2)
+    assert_equal(3, migrator.current_version)
+
+    migrator.forward
+    assert_equal(3, migrator.current_version)
+
+    _, migrator_b = migrator_class(3)
+    migrator_b = migrator_b.new(@path_b, @schema_migration_b)
+    migrator_b.migrate(1)
+    assert_equal(1, migrator_b.current_version)
+
+    migrator_b.forward(2)
+    assert_equal(3, migrator_b.current_version)
+
+    migrator_b.forward
+    assert_equal(3, migrator_b.current_version)
+  end
+
+  private
+    def m(name, version)
+      x = Sensor.new name, version
+      x.extend(Module.new {
+        define_method(:up) { yield(:up, x); super() }
+        define_method(:down) { yield(:down, x); super() }
+      }) if block_given?
+    end
+
+    def sensors(count)
+      calls = []
+      migrations = count.times.map { |i|
+        m(nil, i + 1) { |c, migration|
+          calls << [c, migration.version]
+        }
+      }
+      [calls, migrations]
+    end
+
+    def migrator_class(count)
+      calls, migrations = sensors(count)
+
+      migrator = Class.new(ActiveRecord::MigrationContext) {
+        define_method(:migrations) { |*|
+          migrations
+        }
+      }
+      [calls, migrator]
+    end
+end