Test: start a test suite for migration utils functions

specifyweb/specify/management/commands/run_key_migration_functions.py

@@ -21,7 +21,7 @@
 from specifyweb.specify.migration_utils.migration_helpers.helper_0003_cotype_picklist import create_cotype_splocalecontaineritem, create_cotype_picklist
 from specifyweb.specify.migration_utils.migration_helpers.helper_0004_stratigraphy_age import create_agetype_picklist, create_strat_table_schema_config_with_defaults
 from specifyweb.specify.migration_utils.migration_helpers.helper_0007_schema_config_update import create_cogtype_picklist
-from specifyweb.specify.migration_utils.migration_helpers.helper_0008_schema_config_update import update_relative_age_fields
+from specifyweb.specify.migration_utils.migration_helpers.helper_0008_ageCitations_fix import update_relative_age_fields
 from specifyweb.specify.migration_utils.migration_helpers.helper_0012_add_cojo_to_schema_config import add_cojo_to_schema_config
 from specifyweb.specify.migration_utils.migration_helpers.helper_0013_collectionobjectgroup_parentcog import update_cog_schema_config
 from specifyweb.specify.migration_utils.migration_helpers.helper_0015_add_version_to_ages import update_age_schema_config
@@ -31,7 +31,7 @@
 from specifyweb.specify.migration_utils.migration_helpers.helper_0040_components import create_table_schema_config_with_defaults, remove_componentparent_item
 from specifyweb.specify.migration_utils.migration_helpers.helper_0042_discipline_type_picklist import create_discipline_type_picklist
 from specifyweb.specify.migration_utils.router import use_migration_connection
-from specifyweb.specify.migration_utils.misc_migrations import make_selectseries_false
+from specifyweb.specify.migration_utils.migration_helpers.helper_0031_add_default_for_selectseries import make_selectseries_false
 from specifyweb.specify.migration_utils.tectonic_ranks import create_default_tectonic_ranks, create_root_tectonic_node, fix_tectonic_unit_treedef_discipline_links
 from specifyweb.backend.patches.migration_utils import apply_migrations as apply_patches
 
@@ -268,4 +268,4 @@ def handle(self, *args, **options):
                         self.stdout.write(self.style.SUCCESS(f"Applied {func_name}"))
         except Exception:
             logger.exception("An error occurred while running key migrations")
-            raise
+            raise

specifyweb/specify/management/commands/tests/app_resource_tests.py

@@ -0,0 +1,76 @@
+from unittest.mock import Mock, patch, sentinel, call
+from specifyweb.specify.management.commands import run_key_migration_functions as rkm
+from specifyweb.specify.management.commands.tests.test_migration_base import MigrationCommandTestCase
+
+
+class AppResourceTests(MigrationCommandTestCase):
+    def test_create_missing_app_resource_dirs_writes_summary(self):
+        stdout = Mock()
+
+        ensure_dirs_path = (
+            "specifyweb.backend.setup_tool.app_resource_defaults."
+            "ensure_all_discipline_resource_dirs"
+        )
+        with patch(
+            ensure_dirs_path,
+            return_value={"total_disciplines": 4, "created": 2, "updated": 1},
+        ) as ensure_dirs:
+            rkm.create_missing_app_resource_dirs(stdout, sentinel.apps)
+
+        ensure_dirs.assert_called_once_with()
+        stdout.assert_called_once_with(
+            "Ensured discipline app resource directories: total=4, created=2, updated=1"
+        )
+
+    def test_create_missing_app_resource_dirs_without_stdout_writes_nothing(self):
+        ensure_dirs_path = (
+            "specifyweb.backend.setup_tool.app_resource_defaults."
+            "ensure_all_discipline_resource_dirs"
+        )
+        with patch(
+            ensure_dirs_path,
+            return_value={"total_disciplines": 4, "created": 2, "updated": 1},
+        ) as ensure_dirs:
+            rkm.create_missing_app_resource_dirs(None, sentinel.apps)
+
+        ensure_dirs.assert_called_once_with()
+
+    def test_fix_app_resource_dirs_runs_creation_then_deduplication(self):
+        calls = []
+        stdout = Mock()
+
+        def create_missing_app_resource_dirs(stdout_arg, apps):
+            calls.append(("create_missing_app_resource_dirs", stdout_arg, apps))
+
+        def deduplicate_discipline_resource_dirs(apps):
+            calls.append(("deduplicate_discipline_resource_dirs", apps))
+
+        with (
+            patch.object(rkm, "apps", sentinel.apps),
+            patch.object(
+                rkm,
+                "create_missing_app_resource_dirs",
+                create_missing_app_resource_dirs,
+            ),
+            patch.object(
+                rkm,
+                "deduplicate_discipline_resource_dirs",
+                deduplicate_discipline_resource_dirs,
+            ),
+        ):
+            rkm.fix_app_resource_dirs(stdout)
+
+        self.assertEqual(
+            calls,
+            [
+                ("create_missing_app_resource_dirs", stdout, sentinel.apps),
+                ("deduplicate_discipline_resource_dirs", sentinel.apps),
+            ],
+        )
+        self.assertEqual(
+            stdout.call_args_list,
+            [
+                call("Running <lambda>..."),
+                call("Running deduplicate_discipline_resource_dirs..."),
+            ],
+        )

specifyweb/specify/management/commands/tests/business_rules_tests.py

@@ -0,0 +1,105 @@
+from unittest.mock import patch
+from types import SimpleNamespace
+
+from django.apps import apps as django_apps
+from django.test import TestCase
+
+from specifyweb.backend.businessrules.models import UniquenessRule, UniquenessRuleField
+from specifyweb.specify.models import Discipline
+from specifyweb.specify.management.commands import run_key_migration_functions as rkm
+from specifyweb.specify.management.commands.tests.test_migration_base import MigrationCommandTestCase
+
+
+class BusinessRulesMigrationTests(MigrationCommandTestCase):
+    def test_fix_business_rules_runs_migrations_in_order(self):
+        names = [
+            "apply_default_uniqueness_rules_to_disciplines",
+            "catnum_rule_editable", 
+            "fix_global_default_rules",
+        ]
+        self._assert_section_calls(
+            rkm.fix_business_rules,
+            [(rkm, name) for name in names],
+            names,
+        )
+
+    def test_apply_default_uniqueness_rules_skips_existing_db_constraints(self):
+        discipline_without_constraint = SimpleNamespace(id=1)
+        discipline_with_constraint = SimpleNamespace(id=2)
+
+        class FakeDiscipline:
+            objects = SimpleNamespace(
+                all=lambda: [discipline_without_constraint, discipline_with_constraint]
+            )
+
+        class FakeUniquenessRuleManager:
+            def filter(self, discipline, isDatabaseConstraint):
+                self.last_is_database_constraint = isDatabaseConstraint
+                return SimpleNamespace(
+                    exists=lambda: discipline is discipline_with_constraint
+                )
+
+        fake_uniqueness_rule_manager = FakeUniquenessRuleManager()
+
+        class FakeUniquenessRule:
+            objects = fake_uniqueness_rule_manager
+
+        class FakeApps:
+            def get_model(self, app_label, model_name):
+                return {
+                    ("specify", "Discipline"): FakeDiscipline,
+                    ("businessrules", "UniquenessRule"): FakeUniquenessRule,
+                }[(app_label, model_name)]
+
+        fake_apps = FakeApps()
+
+        with patch.object(rkm, "apply_default_uniqueness_rules") as apply_rules:
+            rkm.apply_default_uniqueness_rules_to_disciplines(fake_apps)
+
+        apply_rules.assert_called_once_with(
+            discipline_without_constraint,
+            registry=fake_apps,
+        )
+        self.assertIs(fake_uniqueness_rule_manager.last_is_database_constraint, True)
+
+
+class BusinessRulesDatabaseTests(TestCase):
+    def test_catnum_rule_editable_only_updates_matching_catalog_number_rule(self):
+        discipline = Discipline.objects.create(name="Test Discipline")
+        matching_rule = UniquenessRule.objects.create(
+            modelName="Collectionobject",
+            discipline=discipline,
+            isDatabaseConstraint=True,
+        )
+        UniquenessRuleField.objects.create(
+            uniquenessrule=matching_rule,
+            fieldPath="catalogNumber",
+            isScope=False,
+        )
+        UniquenessRuleField.objects.create(
+            uniquenessrule=matching_rule,
+            fieldPath="collection",
+            isScope=True,
+        )
+        nonmatching_rule = UniquenessRule.objects.create(
+            modelName="Collectionobject",
+            discipline=discipline,
+            isDatabaseConstraint=True,
+        )
+        UniquenessRuleField.objects.create(
+            uniquenessrule=nonmatching_rule,
+            fieldPath="catalogNumber",
+            isScope=False,
+        )
+        UniquenessRuleField.objects.create(
+            uniquenessrule=nonmatching_rule,
+            fieldPath="discipline",
+            isScope=True,
+        )
+
+        rkm.catnum_rule_editable(django_apps)
+
+        matching_rule.refresh_from_db()
+        nonmatching_rule.refresh_from_db()
+        self.assertFalse(matching_rule.isDatabaseConstraint)
+        self.assertTrue(nonmatching_rule.isDatabaseConstraint)

specifyweb/specify/management/commands/tests/command_tests.py

@@ -0,0 +1,66 @@
+from io import StringIO
+from unittest.mock import Mock, patch, sentinel
+
+from specifyweb.specify.management.commands import run_key_migration_functions as rkm
+from specifyweb.specify.management.commands.tests.test_migration_base import MigrationCommandTestCase
+
+
+class KeyMigrationCommandTests(MigrationCommandTestCase):
+    def test_full_pipeline_dispatches_sections_in_order_with_verbose_stdout(self):
+        calls = []
+
+        def section(name):
+            def wrapped(stdout):
+                calls.append((name, stdout is not None))
+            return wrapped
+
+        command = self._command()
+        command.funcs = {name: section(name) for name in self.section_names}
+
+        command.handle(functions=[], verbose=True)
+
+        self.assertEqual(calls, [(name, True) for name in self.section_names])
+
+    def test_selected_sections_run_in_requested_order_without_verbose_stdout(self):
+        calls = []
+
+        def section(name):
+            def wrapped(stdout):
+                calls.append((name, stdout))
+            return wrapped
+
+        command = self._command()
+        command.funcs = {name: section(name) for name in self.section_names}
+
+        command.handle(
+            functions=["fix_misc", "fix_cots", "fix_permissions"],
+            verbose=False,
+        )
+
+        self.assertEqual(
+            calls,
+            [
+                ("fix_misc", None),
+                ("fix_cots", None),
+                ("fix_permissions", None),
+            ],
+        )
+
+    def test_apply_patches_dispatch_passes_apps_registry_not_stdout(self):
+        command = self._command()
+
+        with patch.object(rkm, "apps", sentinel.apps), patch.object(rkm, "apply_patches") as apply_patches:
+            command.handle(functions=["apply_patches"], verbose=True)
+
+        apply_patches.assert_called_once_with(sentinel.apps)
+
+    def test_unknown_function_writes_error_and_dispatches_nothing(self):
+        stdout = StringIO()
+        stderr = StringIO()
+        command = rkm.Command(stdout=stdout, stderr=stderr)
+        command.funcs = {"known": Mock()}
+
+        command.handle(functions=["unknown"], verbose=True)
+
+        command.funcs["known"].assert_not_called()
+        self.assertIn("Unknown function: unknown", stderr.getvalue())

specifyweb/specify/management/commands/tests/cots_tests.py

@@ -0,0 +1,94 @@
+from django.apps import apps as django_apps
+from specifyweb.specify import models
+from specifyweb.specify.management.commands import run_key_migration_functions as rkm
+from specifyweb.specify.management.commands.tests.test_migration_base import (
+    MigrationCommandTestCase,
+    MigrationDatabaseTestCase,
+)
+
+class CotsMigrationTests(MigrationCommandTestCase):
+    def test_fix_cots_runs_migrations_in_order(self):
+        names = [
+            "create_default_collection_types",
+            "create_default_discipline_for_tree_defs",
+            "create_cogtype_type_picklist",
+            "set_discipline_for_taxon_treedefs",
+            "fix_taxon_treedef_discipline_links",
+            "create_cotype_picklist"
+        ]
+
+        self._assert_section_calls(
+            rkm.fix_cots,
+            [(rkm, name) for name in names],
+            names,
+        )
+
+
+class CotsDatabaseTests(MigrationDatabaseTestCase):    
+    def test_set_discipline_for_taxon_treedefs_uses_collection_discipline(self):
+        taxon_tree_def = models.Taxontreedef.objects.create(
+            name=f"Unlinked Taxon Tree {self.collection.id}",
+        )
+        self.collectionobjecttype.taxontreedef = taxon_tree_def
+        self.collectionobjecttype.save()
+
+        rkm.set_discipline_for_taxon_treedefs(django_apps)
+
+        taxon_tree_def.refresh_from_db()
+        self.assertEqual(taxon_tree_def.discipline_id, self.discipline.id)
+
+    def test_create_cotype_picklist_creates_readonly_system_picklist_idempotently(self):
+        new_collection = models.Collection.objects.create(
+            catalognumformatname="test",
+            collectionname=f"TestCollection{self.collection.id}",
+            isembeddedcollectingevent=False,
+            discipline=self.discipline,
+        )
+        models.Picklist.objects.filter(
+            collection__in=[self.collection, new_collection],
+            name="CollectionObjectType",
+        ).delete()
+
+        rkm.create_cotype_picklist(django_apps)
+        rkm.create_cotype_picklist(django_apps)
+
+        for collection in [self.collection, new_collection]:
+            picklists = models.Picklist.objects.filter(
+                collection=collection,
+                name="CollectionObjectType",
+            )
+            self.assertEqual(picklists.count(), 1)
+            picklist = picklists.get()
+            self.assertTrue(picklist.issystem)
+            self.assertTrue(picklist.readonly)
+            self.assertEqual(picklist.type, 1)
+            self.assertEqual(picklist.tablename, "collectionobjecttype")
+            self.assertEqual(picklist.sizelimit, -1)
+            self.assertEqual(picklist.sorttype, 1)
+            self.assertEqual(picklist.formatter, "CollectionObjectType")
+
+    def test_create_cogtype_type_picklist_creates_default_items_idempotently(self):
+        models.Picklist.objects.filter(
+            collection=self.collection,
+            name="SystemCOGTypes",
+        ).delete()
+
+        rkm.create_cogtype_type_picklist(django_apps)
+        rkm.create_cogtype_type_picklist(django_apps)
+
+        picklist = models.Picklist.objects.get(
+            collection=self.collection,
+            name="SystemCOGTypes",
+        )
+        self.assertFalse(picklist.issystem)
+        self.assertFalse(picklist.readonly)
+        self.assertEqual(picklist.type, 0)
+        self.assertEqual(
+            set(picklist.picklistitems.values_list("title", "value")),
+            {
+                ("Discrete", "Discrete"),
+                ("Consolidated", "Consolidated"),
+                ("Drill Core", "Drill Core"),
+            },
+        )
+        self.assertEqual(picklist.picklistitems.count(), 3)