Refactor test cases for improved readability and consistency

- Updated test functions in various test files to enhance code clarity by formatting long lines and improving indentation.
- Adjusted assertions to use multi-line formatting for better readability.
- Added new test cases for theme settings API to ensure proper functionality.
- Ensured consistent use of line breaks and spacing across test files for uniformity.

tests/unit/test_setup_database.py

@@ -31,10 +31,13 @@ def setup_instance(mock_config: DatabaseConfig) -> DatabaseSetup:
     return DatabaseSetup(mock_config, dry_run=True)
 
 
-def test_seed_baseline_data_dry_run_skips_verification(setup_instance: DatabaseSetup) -> None:
-    with mock.patch("scripts.seed_data.run_with_namespace") as seed_run, mock.patch.object(
-        setup_instance, "_verify_seeded_data"
-    ) as verify_mock:
+def test_seed_baseline_data_dry_run_skips_verification(
+    setup_instance: DatabaseSetup,
+) -> None:
+    with (
+        mock.patch("scripts.seed_data.run_with_namespace") as seed_run,
+        mock.patch.object(setup_instance, "_verify_seeded_data") as verify_mock,
+    ):
         setup_instance.seed_baseline_data(dry_run=True)
 
     seed_run.assert_called_once()
@@ -47,13 +50,16 @@ def test_seed_baseline_data_dry_run_skips_verification(setup_instance: DatabaseS
     verify_mock.assert_not_called()
 
 
-def test_seed_baseline_data_invokes_verification(setup_instance: DatabaseSetup) -> None:
+def test_seed_baseline_data_invokes_verification(
+    setup_instance: DatabaseSetup,
+) -> None:
     expected_currencies = {code for code, *_ in seed_data.CURRENCY_SEEDS}
     expected_units = {code for code, *_ in seed_data.MEASUREMENT_UNIT_SEEDS}
 
-    with mock.patch("scripts.seed_data.run_with_namespace") as seed_run, mock.patch.object(
-        setup_instance, "_verify_seeded_data"
-    ) as verify_mock:
+    with (
+        mock.patch("scripts.seed_data.run_with_namespace") as seed_run,
+        mock.patch.object(setup_instance, "_verify_seeded_data") as verify_mock,
+    ):
         setup_instance.seed_baseline_data(dry_run=False)
 
     seed_run.assert_called_once()
@@ -67,7 +73,9 @@ def test_seed_baseline_data_invokes_verification(setup_instance: DatabaseSetup)
     )
 
 
-def test_run_migrations_applies_baseline_when_missing(mock_config: DatabaseConfig, tmp_path) -> None:
+def test_run_migrations_applies_baseline_when_missing(
+    mock_config: DatabaseConfig, tmp_path
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=False)
 
     baseline = tmp_path / "000_base.sql"
@@ -88,15 +96,24 @@ def test_run_migrations_applies_baseline_when_missing(mock_config: DatabaseConfi
     cursor_context.__enter__.return_value = cursor_mock
     connection_mock.cursor.return_value = cursor_context
 
-    with mock.patch.object(
-        setup_instance, "_application_connection", return_value=connection_mock
-    ), mock.patch.object(
-        setup_instance, "_migrations_table_exists", return_value=True
-    ), mock.patch.object(
-        setup_instance, "_fetch_applied_migrations", return_value=set()
-    ), mock.patch.object(
-        setup_instance, "_apply_migration_file", side_effect=capture_migration
-    ) as apply_mock:
+    with (
+        mock.patch.object(
+            setup_instance,
+            "_application_connection",
+            return_value=connection_mock,
+        ),
+        mock.patch.object(
+            setup_instance, "_migrations_table_exists", return_value=True
+        ),
+        mock.patch.object(
+            setup_instance, "_fetch_applied_migrations", return_value=set()
+        ),
+        mock.patch.object(
+            setup_instance,
+            "_apply_migration_file",
+            side_effect=capture_migration,
+        ) as apply_mock,
+    ):
         setup_instance.run_migrations(tmp_path)
 
     assert apply_mock.call_count == 1
@@ -121,17 +138,24 @@ def test_run_migrations_noop_when_all_files_already_applied(
 
     connection_mock, cursor_mock = _connection_with_cursor()
 
-    with mock.patch.object(
-        setup_instance, "_application_connection", return_value=connection_mock
-    ), mock.patch.object(
-        setup_instance, "_migrations_table_exists", return_value=True
-    ), mock.patch.object(
-        setup_instance,
-        "_fetch_applied_migrations",
-        return_value={"000_base.sql", "20251022_add_other.sql"},
-    ), mock.patch.object(
-        setup_instance, "_apply_migration_file"
-    ) as apply_mock:
+    with (
+        mock.patch.object(
+            setup_instance,
+            "_application_connection",
+            return_value=connection_mock,
+        ),
+        mock.patch.object(
+            setup_instance, "_migrations_table_exists", return_value=True
+        ),
+        mock.patch.object(
+            setup_instance,
+            "_fetch_applied_migrations",
+            return_value={"000_base.sql", "20251022_add_other.sql"},
+        ),
+        mock.patch.object(
+            setup_instance, "_apply_migration_file"
+        ) as apply_mock,
+    ):
         setup_instance.run_migrations(tmp_path)
 
     apply_mock.assert_not_called()
@@ -148,12 +172,16 @@ def _connection_with_cursor() -> tuple[mock.MagicMock, mock.MagicMock]:
     return connection_mock, cursor_mock
 
 
-def test_verify_seeded_data_raises_when_currency_missing(mock_config: DatabaseConfig) -> None:
+def test_verify_seeded_data_raises_when_currency_missing(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=False)
     connection_mock, cursor_mock = _connection_with_cursor()
     cursor_mock.fetchall.return_value = [("USD", True)]
 
-    with mock.patch.object(setup_instance, "_application_connection", return_value=connection_mock):
+    with mock.patch.object(
+        setup_instance, "_application_connection", return_value=connection_mock
+    ):
         with pytest.raises(RuntimeError) as exc:
             setup_instance._verify_seeded_data(
                 expected_currency_codes={"USD", "EUR"},
@@ -163,12 +191,16 @@ def test_verify_seeded_data_raises_when_currency_missing(mock_config: DatabaseCo
     assert "EUR" in str(exc.value)
 
 
-def test_verify_seeded_data_raises_when_default_currency_inactive(mock_config: DatabaseConfig) -> None:
+def test_verify_seeded_data_raises_when_default_currency_inactive(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=False)
     connection_mock, cursor_mock = _connection_with_cursor()
     cursor_mock.fetchall.return_value = [("USD", False)]
 
-    with mock.patch.object(setup_instance, "_application_connection", return_value=connection_mock):
+    with mock.patch.object(
+        setup_instance, "_application_connection", return_value=connection_mock
+    ):
         with pytest.raises(RuntimeError) as exc:
             setup_instance._verify_seeded_data(
                 expected_currency_codes={"USD"},
@@ -178,12 +210,16 @@ def test_verify_seeded_data_raises_when_default_currency_inactive(mock_config: D
     assert "inactive" in str(exc.value)
 
 
-def test_verify_seeded_data_raises_when_units_missing(mock_config: DatabaseConfig) -> None:
+def test_verify_seeded_data_raises_when_units_missing(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=False)
     connection_mock, cursor_mock = _connection_with_cursor()
     cursor_mock.fetchall.return_value = [("tonnes", True)]
 
-    with mock.patch.object(setup_instance, "_application_connection", return_value=connection_mock):
+    with mock.patch.object(
+        setup_instance, "_application_connection", return_value=connection_mock
+    ):
         with pytest.raises(RuntimeError) as exc:
             setup_instance._verify_seeded_data(
                 expected_currency_codes=set(),
@@ -193,12 +229,18 @@ def test_verify_seeded_data_raises_when_units_missing(mock_config: DatabaseConfi
     assert "liters" in str(exc.value)
 
 
-def test_verify_seeded_data_raises_when_measurement_table_missing(mock_config: DatabaseConfig) -> None:
+def test_verify_seeded_data_raises_when_measurement_table_missing(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=False)
     connection_mock, cursor_mock = _connection_with_cursor()
-    cursor_mock.execute.side_effect = psycopg_errors.UndefinedTable("relation does not exist")
+    cursor_mock.execute.side_effect = psycopg_errors.UndefinedTable(
+        "relation does not exist"
+    )
 
-    with mock.patch.object(setup_instance, "_application_connection", return_value=connection_mock):
+    with mock.patch.object(
+        setup_instance, "_application_connection", return_value=connection_mock
+    ):
         with pytest.raises(RuntimeError) as exc:
             setup_instance._verify_seeded_data(
                 expected_currency_codes=set(),
@@ -226,9 +268,14 @@ def test_seed_baseline_data_rerun_uses_existing_records(
         unit_rows,
     ]
 
-    with mock.patch.object(
-        setup_instance, "_application_connection", return_value=connection_mock
-    ), mock.patch("scripts.seed_data.run_with_namespace") as seed_run:
+    with (
+        mock.patch.object(
+            setup_instance,
+            "_application_connection",
+            return_value=connection_mock,
+        ),
+        mock.patch("scripts.seed_data.run_with_namespace") as seed_run,
+    ):
         setup_instance.seed_baseline_data(dry_run=False)
         setup_instance.seed_baseline_data(dry_run=False)
 
@@ -240,7 +287,9 @@ def test_seed_baseline_data_rerun_uses_existing_records(
     assert cursor_mock.execute.call_count == 4
 
 
-def test_ensure_database_raises_with_context(mock_config: DatabaseConfig) -> None:
+def test_ensure_database_raises_with_context(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=False)
     connection_mock = mock.MagicMock()
     cursor_mock = mock.MagicMock()
@@ -248,14 +297,18 @@ def test_ensure_database_raises_with_context(mock_config: DatabaseConfig) -> Non
     cursor_mock.execute.side_effect = [None, psycopg2.Error("create_fail")]
     connection_mock.cursor.return_value = cursor_mock
 
-    with mock.patch.object(setup_instance, "_admin_connection", return_value=connection_mock):
+    with mock.patch.object(
+        setup_instance, "_admin_connection", return_value=connection_mock
+    ):
         with pytest.raises(RuntimeError) as exc:
             setup_instance.ensure_database()
 
     assert "Failed to create database" in str(exc.value)
 
 
-def test_ensure_role_raises_with_context_during_creation(mock_config: DatabaseConfig) -> None:
+def test_ensure_role_raises_with_context_during_creation(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=False)
 
     admin_conn, admin_cursor = _connection_with_cursor()
@@ -295,7 +348,9 @@ def test_ensure_role_raises_with_context_during_privilege_grants(
     assert "Failed to grant privileges" in str(exc.value)
 
 
-def test_ensure_database_dry_run_skips_creation(mock_config: DatabaseConfig) -> None:
+def test_ensure_database_dry_run_skips_creation(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=True)
 
     connection_mock = mock.MagicMock()
@@ -303,45 +358,59 @@ def test_ensure_database_dry_run_skips_creation(mock_config: DatabaseConfig) ->
     cursor_mock.fetchone.return_value = None
     connection_mock.cursor.return_value = cursor_mock
 
-    with mock.patch.object(setup_instance, "_admin_connection", return_value=connection_mock), mock.patch(
-        "scripts.setup_database.logger"
-    ) as logger_mock:
+    with (
+        mock.patch.object(
+            setup_instance, "_admin_connection", return_value=connection_mock
+        ),
+        mock.patch("scripts.setup_database.logger") as logger_mock,
+    ):
         setup_instance.ensure_database()
 
     # expect only existence check, no create attempt
     cursor_mock.execute.assert_called_once()
     logger_mock.info.assert_any_call(
-        "Dry run: would create database '%s'. Run without --dry-run to proceed.", mock_config.database
+        "Dry run: would create database '%s'. Run without --dry-run to proceed.",
+        mock_config.database,
     )
 
 
-def test_ensure_role_dry_run_skips_creation_and_grants(mock_config: DatabaseConfig) -> None:
+def test_ensure_role_dry_run_skips_creation_and_grants(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=True)
 
     admin_conn, admin_cursor = _connection_with_cursor()
     admin_cursor.fetchone.return_value = None
 
-    with mock.patch.object(
-        setup_instance,
-        "_admin_connection",
-        side_effect=[admin_conn],
-    ) as conn_mock, mock.patch("scripts.setup_database.logger") as logger_mock:
+    with (
+        mock.patch.object(
+            setup_instance,
+            "_admin_connection",
+            side_effect=[admin_conn],
+        ) as conn_mock,
+        mock.patch("scripts.setup_database.logger") as logger_mock,
+    ):
         setup_instance.ensure_role()
 
     assert conn_mock.call_count == 1
     admin_cursor.execute.assert_called_once()
     logger_mock.info.assert_any_call(
-        "Dry run: would create role '%s'. Run without --dry-run to apply.", mock_config.user
+        "Dry run: would create role '%s'. Run without --dry-run to apply.",
+        mock_config.user,
     )
 
 
-def test_register_rollback_skipped_when_dry_run(mock_config: DatabaseConfig) -> None:
+def test_register_rollback_skipped_when_dry_run(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=True)
     setup_instance._register_rollback("noop", lambda: None)
     assert setup_instance._rollback_actions == []
 
 
-def test_execute_rollbacks_runs_in_reverse_order(mock_config: DatabaseConfig) -> None:
+def test_execute_rollbacks_runs_in_reverse_order(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=False)
 
     calls: list[str] = []
@@ -362,16 +431,24 @@ def test_execute_rollbacks_runs_in_reverse_order(mock_config: DatabaseConfig) ->
     assert setup_instance._rollback_actions == []
 
 
-def test_ensure_database_registers_rollback_action(mock_config: DatabaseConfig) -> None:
+def test_ensure_database_registers_rollback_action(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=False)
     connection_mock = mock.MagicMock()
     cursor_mock = mock.MagicMock()
     cursor_mock.fetchone.return_value = None
     connection_mock.cursor.return_value = cursor_mock
 
-    with mock.patch.object(setup_instance, "_admin_connection", return_value=connection_mock), mock.patch.object(
-        setup_instance, "_register_rollback"
-    ) as register_mock, mock.patch.object(setup_instance, "_drop_database") as drop_mock:
+    with (
+        mock.patch.object(
+            setup_instance, "_admin_connection", return_value=connection_mock
+        ),
+        mock.patch.object(
+            setup_instance, "_register_rollback"
+        ) as register_mock,
+        mock.patch.object(setup_instance, "_drop_database") as drop_mock,
+    ):
         setup_instance.ensure_database()
         register_mock.assert_called_once()
         label, action = register_mock.call_args[0]
@@ -380,24 +457,29 @@ def test_ensure_database_registers_rollback_action(mock_config: DatabaseConfig)
         drop_mock.assert_called_once_with(mock_config.database)
 
 
-def test_ensure_role_registers_rollback_actions(mock_config: DatabaseConfig) -> None:
+def test_ensure_role_registers_rollback_actions(
+    mock_config: DatabaseConfig,
+) -> None:
     setup_instance = DatabaseSetup(mock_config, dry_run=False)
 
     admin_conn, admin_cursor = _connection_with_cursor()
     admin_cursor.fetchone.return_value = None
     privilege_conn, privilege_cursor = _connection_with_cursor()
 
-    with mock.patch.object(
-        setup_instance,
-        "_admin_connection",
-        side_effect=[admin_conn, privilege_conn],
-    ), mock.patch.object(
-        setup_instance, "_register_rollback"
-    ) as register_mock, mock.patch.object(
-        setup_instance, "_drop_role"
-    ) as drop_mock, mock.patch.object(
-        setup_instance, "_revoke_role_privileges"
-    ) as revoke_mock:
+    with (
+        mock.patch.object(
+            setup_instance,
+            "_admin_connection",
+            side_effect=[admin_conn, privilege_conn],
+        ),
+        mock.patch.object(
+            setup_instance, "_register_rollback"
+        ) as register_mock,
+        mock.patch.object(setup_instance, "_drop_role") as drop_mock,
+        mock.patch.object(
+            setup_instance, "_revoke_role_privileges"
+        ) as revoke_mock,
+    ):
         setup_instance.ensure_role()
         assert register_mock.call_count == 2
         drop_label, drop_action = register_mock.call_args_list[0][0]
@@ -413,7 +495,9 @@ def test_ensure_role_registers_rollback_actions(mock_config: DatabaseConfig) ->
         revoke_mock.assert_called_once()
 
 
-def test_main_triggers_rollbacks_on_failure(mock_config: DatabaseConfig) -> None:
+def test_main_triggers_rollbacks_on_failure(
+    mock_config: DatabaseConfig,
+) -> None:
     args = argparse.Namespace(
         ensure_database=True,
         ensure_role=True,
@@ -437,11 +521,13 @@ def test_main_triggers_rollbacks_on_failure(mock_config: DatabaseConfig) -> None
         verbose=0,
     )
 
-    with mock.patch.object(setup_db_module, "parse_args", return_value=args), mock.patch.object(
-        setup_db_module.DatabaseConfig, "from_env", return_value=mock_config
-    ), mock.patch.object(
-        setup_db_module, "DatabaseSetup"
-    ) as setup_cls:
+    with (
+        mock.patch.object(setup_db_module, "parse_args", return_value=args),
+        mock.patch.object(
+            setup_db_module.DatabaseConfig, "from_env", return_value=mock_config
+        ),
+        mock.patch.object(setup_db_module, "DatabaseSetup") as setup_cls,
+    ):
         setup_instance = mock.MagicMock()
         setup_instance.dry_run = False
         setup_instance._rollback_actions = [