A community-supported supercharged document management system: scan, index and archive all your documents
Python aiangulararchivingdjangodmsdocument-managementdocument-management-systemllmmachine-learningocroptical-character-recognitionpdf
Chore: pytest style paperless tests (#12254)
Trenton H9d5e618de80f
diff --git a/src/paperless/tests/test_adapter.py b/src/paperless/tests/test_adapter.pyindex fcbd21b12..680abdd77 100644--- a/src/paperless/tests/test_adapter.py+++ b/src/paperless/tests/test_adapter.py@@ -1,107 +1,100 @@-from unittest import mock+import logging+import pytestfrom allauth.account.adapter import get_adapterfrom allauth.core import contextfrom allauth.socialaccount.adapter import get_adapter as get_social_adapter-from django.conf import settingsfrom django.contrib.auth.models import AnonymousUserfrom django.contrib.auth.models import Groupfrom django.contrib.auth.models import Userfrom django.forms import ValidationErrorfrom django.http import HttpRequest-from django.test import TestCase-from django.test import override_settingsfrom django.urls import reverse+from pytest_django.fixtures import SettingsWrapper+from pytest_mock import MockerFixturefrom rest_framework.authtoken.models import Tokenfrom paperless.adapter import DrfTokenStrategy-class TestCustomAccountAdapter(TestCase):- def test_is_open_for_signup(self) -> None:+class TestCustomAccountAdapter:+ def test_is_open_for_signup(self, settings: SettingsWrapper) -> None:adapter = get_adapter()# With no accounts, signups should be allowed- self.assertTrue(adapter.is_open_for_signup(None))+ assert adapter.is_open_for_signup(None)User.objects.create_user("testuser")- # Test when ACCOUNT_ALLOW_SIGNUPS is Truesettings.ACCOUNT_ALLOW_SIGNUPS = True- self.assertTrue(adapter.is_open_for_signup(None))+ assert adapter.is_open_for_signup(None)- # Test when ACCOUNT_ALLOW_SIGNUPS is Falsesettings.ACCOUNT_ALLOW_SIGNUPS = False- self.assertFalse(adapter.is_open_for_signup(None))+ assert not adapter.is_open_for_signup(None)- def test_is_safe_url(self) -> None:+ def test_is_safe_url(self, settings: SettingsWrapper) -> None:request = HttpRequest()- request.get_host = mock.Mock(return_value="example.com")+ request.get_host = lambda: "example.com"with context.request_context(request):adapter = get_adapter()- with override_settings(ALLOWED_HOSTS=["*"]):- # True because request host is same- url = "https://example.com"- self.assertTrue(adapter.is_safe_url(url))- url = "https://evil.com"+ settings.ALLOWED_HOSTS = ["*"]+ # True because request host is same+ assert adapter.is_safe_url("https://example.com")# False despite wildcard because request host is different- self.assertFalse(adapter.is_safe_url(url))+ assert not adapter.is_safe_url("https://evil.com")settings.ALLOWED_HOSTS = ["example.com"]- url = "https://example.com"# True because request host is same- self.assertTrue(adapter.is_safe_url(url))+ assert adapter.is_safe_url("https://example.com")settings.ALLOWED_HOSTS = ["*", "example.com"]- url = "//evil.com"# False because request host is not in allowed hosts- self.assertFalse(adapter.is_safe_url(url))-- @mock.patch("allauth.core.internal.ratelimit.consume", return_value=True)- def test_pre_authenticate(self, mock_consume) -> None:+ assert not adapter.is_safe_url("//evil.com")++ def test_pre_authenticate(+ self,+ settings: SettingsWrapper,+ mocker: MockerFixture,+ ) -> None:+ mocker.patch("allauth.core.internal.ratelimit.consume", return_value=True)adapter = get_adapter()request = HttpRequest()- request.get_host = mock.Mock(return_value="example.com")+ request.get_host = lambda: "example.com"settings.DISABLE_REGULAR_LOGIN = Falseadapter.pre_authenticate(request)settings.DISABLE_REGULAR_LOGIN = True- with self.assertRaises(ValidationError):+ with pytest.raises(ValidationError):adapter.pre_authenticate(request)- def test_get_reset_password_from_key_url(self) -> None:+ def test_get_reset_password_from_key_url(self, settings: SettingsWrapper) -> None:request = HttpRequest()- request.get_host = mock.Mock(return_value="foo.org")+ request.get_host = lambda: "foo.org"with context.request_context(request):adapter = get_adapter()- # Test when PAPERLESS_URL is None- with override_settings(- PAPERLESS_URL=None,- ACCOUNT_DEFAULT_HTTP_PROTOCOL="https",- ):- expected_url = f"https://foo.org{reverse('account_reset_password_from_key', kwargs={'uidb36': 'UID', 'key': 'KEY'})}"- self.assertEqual(- adapter.get_reset_password_from_key_url("UID-KEY"),- expected_url,- )-- # Test when PAPERLESS_URL is not None- with override_settings(PAPERLESS_URL="https://bar.com"):- expected_url = f"https://bar.com{reverse('account_reset_password_from_key', kwargs={'uidb36': 'UID', 'key': 'KEY'})}"- self.assertEqual(- adapter.get_reset_password_from_key_url("UID-KEY"),- expected_url,- )-- @override_settings(ACCOUNT_DEFAULT_GROUPS=["group1", "group2"])- def test_save_user_adds_groups(self) -> None:+ settings.PAPERLESS_URL = None+ settings.ACCOUNT_DEFAULT_HTTP_PROTOCOL = "https"+ expected_url = f"https://foo.org{reverse('account_reset_password_from_key', kwargs={'uidb36': 'UID', 'key': 'KEY'})}"+ assert adapter.get_reset_password_from_key_url("UID-KEY") == expected_url++ settings.PAPERLESS_URL = "https://bar.com"+ expected_url = f"https://bar.com{reverse('account_reset_password_from_key', kwargs={'uidb36': 'UID', 'key': 'KEY'})}"+ assert adapter.get_reset_password_from_key_url("UID-KEY") == expected_url++ def test_save_user_adds_groups(+ self,+ settings: SettingsWrapper,+ mocker: MockerFixture,+ ) -> None:+ settings.ACCOUNT_DEFAULT_GROUPS = ["group1", "group2"]Group.objects.create(name="group1")user = User.objects.create_user("testuser")adapter = get_adapter()- form = mock.Mock(+ form = mocker.MagicMock(cleaned_data={"username": "testuser","email": "[email protected]",@@ -110,88 +103,81 @@ class TestCustomAccountAdapter(TestCase):user = adapter.save_user(HttpRequest(), user, form, commit=True)- self.assertEqual(user.groups.count(), 1)- self.assertTrue(user.groups.filter(name="group1").exists())- self.assertFalse(user.groups.filter(name="group2").exists())+ assert user.groups.count() == 1+ assert user.groups.filter(name="group1").exists()+ assert not user.groups.filter(name="group2").exists()- def test_fresh_install_save_creates_superuser(self) -> None:+ def test_fresh_install_save_creates_superuser(self, mocker: MockerFixture) -> None:adapter = get_adapter()- form = mock.Mock(+ form = mocker.MagicMock(cleaned_data={"username": "testuser","email": "[email protected]",},)user = adapter.save_user(HttpRequest(), User(), form, commit=True)- self.assertTrue(user.is_superuser)+ assert user.is_superuser- # Next time, it should not create a superuser- form = mock.Mock(+ form = mocker.MagicMock(cleaned_data={"username": "testuser2","email": "[email protected]",},)user2 = adapter.save_user(HttpRequest(), User(), form, commit=True)- self.assertFalse(user2.is_superuser)+ assert not user2.is_superuser-class TestCustomSocialAccountAdapter(TestCase):- def test_is_open_for_signup(self) -> None:+class TestCustomSocialAccountAdapter:+ @pytest.mark.django_db+ def test_is_open_for_signup(self, settings: SettingsWrapper) -> None:adapter = get_social_adapter()- # Test when SOCIALACCOUNT_ALLOW_SIGNUPS is Truesettings.SOCIALACCOUNT_ALLOW_SIGNUPS = True- self.assertTrue(adapter.is_open_for_signup(None, None))+ assert adapter.is_open_for_signup(None, None)- # Test when SOCIALACCOUNT_ALLOW_SIGNUPS is Falsesettings.SOCIALACCOUNT_ALLOW_SIGNUPS = False- self.assertFalse(adapter.is_open_for_signup(None, None))+ assert not adapter.is_open_for_signup(None, None)def test_get_connect_redirect_url(self) -> None:adapter = get_social_adapter()- request = None- socialaccount = None-- # Test the default URL- expected_url = reverse("base")- self.assertEqual(- adapter.get_connect_redirect_url(request, socialaccount),- expected_url,- )-- @override_settings(SOCIAL_ACCOUNT_DEFAULT_GROUPS=["group1", "group2"])- def test_save_user_adds_groups(self) -> None:+ assert adapter.get_connect_redirect_url(None, None) == reverse("base")++ @pytest.mark.django_db+ def test_save_user_adds_groups(+ self,+ settings: SettingsWrapper,+ mocker: MockerFixture,+ ) -> None:+ settings.SOCIAL_ACCOUNT_DEFAULT_GROUPS = ["group1", "group2"]Group.objects.create(name="group1")adapter = get_social_adapter()- request = HttpRequest()user = User.objects.create_user("testuser")- sociallogin = mock.Mock(- user=user,- )+ sociallogin = mocker.MagicMock(user=user)- user = adapter.save_user(request, sociallogin, None)+ user = adapter.save_user(HttpRequest(), sociallogin, None)- self.assertEqual(user.groups.count(), 1)- self.assertTrue(user.groups.filter(name="group1").exists())- self.assertFalse(user.groups.filter(name="group2").exists())+ assert user.groups.count() == 1+ assert user.groups.filter(name="group1").exists()+ assert not user.groups.filter(name="group2").exists()- def test_error_logged_on_authentication_error(self) -> None:+ def test_error_logged_on_authentication_error(+ self,+ caplog: pytest.LogCaptureFixture,+ ) -> None:adapter = get_social_adapter()- request = HttpRequest()- with self.assertLogs("paperless.auth", level="INFO") as log_cm:+ with caplog.at_level(logging.INFO, logger="paperless.auth"):adapter.on_authentication_error(- request,+ HttpRequest(),provider="test-provider",error="Error",exception="Test authentication error",)- self.assertTrue(- any("Test authentication error" in message for message in log_cm.output),- )+ assert any("Test authentication error" in msg for msg in caplog.messages)-class TestDrfTokenStrategy(TestCase):+class TestDrfTokenStrategy:def test_create_access_token_creates_new_token(self) -> None:"""GIVEN:@@ -201,7 +187,6 @@ class TestDrfTokenStrategy(TestCase):THEN:- A new token is created and its key is returned"""-user = User.objects.create_user("testuser")request = HttpRequest()request.user = user@@ -209,13 +194,9 @@ class TestDrfTokenStrategy(TestCase):strategy = DrfTokenStrategy()token_key = strategy.create_access_token(request)- # Verify a token was created- self.assertIsNotNone(token_key)- self.assertTrue(Token.objects.filter(user=user).exists())-- # Verify the returned key matches the created token- token = Token.objects.get(user=user)- self.assertEqual(token_key, token.key)+ assert token_key is not None+ assert Token.objects.filter(user=user).exists()+ assert token_key == Token.objects.get(user=user).keydef test_create_access_token_returns_existing_token(self) -> None:"""@@ -226,7 +207,6 @@ class TestDrfTokenStrategy(TestCase):THEN:- The same token key is returned (no new token created)"""-user = User.objects.create_user("testuser")existing_token = Token.objects.create(user=user)@@ -236,11 +216,8 @@ class TestDrfTokenStrategy(TestCase):strategy = DrfTokenStrategy()token_key = strategy.create_access_token(request)- # Verify the existing token key is returned- self.assertEqual(token_key, existing_token.key)-- # Verify only one token exists (no duplicate created)- self.assertEqual(Token.objects.filter(user=user).count(), 1)+ assert token_key == existing_token.key+ assert Token.objects.filter(user=user).count() == 1def test_create_access_token_returns_none_for_unauthenticated_user(self) -> None:"""@@ -251,12 +228,11 @@ class TestDrfTokenStrategy(TestCase):THEN:- None is returned and no token is created"""-request = HttpRequest()request.user = AnonymousUser()strategy = DrfTokenStrategy()token_key = strategy.create_access_token(request)- self.assertIsNone(token_key)- self.assertEqual(Token.objects.count(), 0)+ assert token_key is None+ assert Token.objects.count() == 0diff --git a/src/paperless/tests/test_checks.py b/src/paperless/tests/test_checks.pyindex c8596a396..14950e2ca 100644--- a/src/paperless/tests/test_checks.py+++ b/src/paperless/tests/test_checks.py@@ -1,16 +1,15 @@import os+from collections.abc import Callable+from dataclasses import dataclassfrom pathlib import Pathfrom unittest import mockimport pytestfrom django.core.checks import Errorfrom django.core.checks import Warning-from django.test import TestCase-from django.test import override_settings+from pytest_django.fixtures import SettingsWrapperfrom pytest_mock import MockerFixture-from documents.tests.utils import DirectoriesMixin-from documents.tests.utils import FileSystemAssertsMixinfrom paperless.checks import audit_log_checkfrom paperless.checks import binaries_checkfrom paperless.checks import check_deprecated_db_settings@@ -20,162 +19,159 @@ from paperless.checks import paths_checkfrom paperless.checks import settings_values_check-class TestChecks(DirectoriesMixin, TestCase):- def test_binaries(self) -> None:- self.assertEqual(binaries_check(None), [])-- @override_settings(CONVERT_BINARY="uuuhh")- def test_binaries_fail(self) -> None:- self.assertEqual(len(binaries_check(None)), 1)+@dataclass(frozen=True, slots=True)+class PaperlessTestDirs:+ data_dir: Path+ media_dir: Path+ consumption_dir: Path- def test_paths_check(self) -> None:- self.assertEqual(paths_check(None), [])- @override_settings(- MEDIA_ROOT=Path("uuh"),- DATA_DIR=Path("whatever"),- CONSUMPTION_DIR=Path("idontcare"),- )- def test_paths_check_dont_exist(self) -> None:- msgs = paths_check(None)- self.assertEqual(len(msgs), 3, str(msgs))+# TODO: consolidate with documents/tests/conftest.py PaperlessDirs/paperless_dirs+# once the paperless and documents test suites are ready to share fixtures.+def directories(tmp_path: Path, settings: SettingsWrapper) -> PaperlessTestDirs:+ data_dir = tmp_path / "data"+ media_dir = tmp_path / "media"+ consumption_dir = tmp_path / "consumption"- for msg in msgs:- self.assertTrue(msg.msg.endswith("is set but doesn't exist."))+ for d in (data_dir, media_dir, consumption_dir):+ d.mkdir()- def test_paths_check_no_access(self) -> None:- Path(self.dirs.data_dir).chmod(0o000)- Path(self.dirs.media_dir).chmod(0o000)- Path(self.dirs.consumption_dir).chmod(0o000)+ settings.DATA_DIR = data_dir+ settings.MEDIA_ROOT = media_dir+ settings.CONSUMPTION_DIR = consumption_dir- self.addCleanup(os.chmod, self.dirs.data_dir, 0o777)- self.addCleanup(os.chmod, self.dirs.media_dir, 0o777)- self.addCleanup(os.chmod, self.dirs.consumption_dir, 0o777)+ return PaperlessTestDirs(+ data_dir=data_dir,+ media_dir=media_dir,+ consumption_dir=consumption_dir,+ )- msgs = paths_check(None)- self.assertEqual(len(msgs), 3)- for msg in msgs:- self.assertTrue(msg.msg.endswith("is not writeable"))+class TestChecks:+ def test_binaries(self) -> None:+ assert binaries_check(None) == []- @override_settings(DEBUG=False)- def test_debug_disabled(self) -> None:- self.assertEqual(debug_mode_check(None), [])+ def test_binaries_fail(self, settings: SettingsWrapper) -> None:+ settings.CONVERT_BINARY = "uuuhh"+ assert len(binaries_check(None)) == 1- @override_settings(DEBUG=True)- def test_debug_enabled(self) -> None:- self.assertEqual(len(debug_mode_check(None)), 1)+ @pytest.mark.usefixtures("directories")+ def test_paths_check(self) -> None:+ assert paths_check(None) == []+ def test_paths_check_dont_exist(self, settings: SettingsWrapper) -> None:+ settings.MEDIA_ROOT = Path("uuh")+ settings.DATA_DIR = Path("whatever")+ settings.CONSUMPTION_DIR = Path("idontcare")-class TestSettingsChecksAgainstDefaults(DirectoriesMixin, TestCase):- def test_all_valid(self) -> None:- """- GIVEN:- - Default settings- WHEN:- - Settings are validated- THEN:- - No system check errors reported- """- msgs = settings_values_check(None)- self.assertEqual(len(msgs), 0)+ msgs = paths_check(None)+ assert len(msgs) == 3, str(msgs)+ for msg in msgs:+ assert msg.msg.endswith("is set but doesn't exist.")-class TestOcrSettingsChecks(DirectoriesMixin, TestCase):- @override_settings(OCR_OUTPUT_TYPE="notapdf")- def test_invalid_output_type(self) -> None:- """- GIVEN:- - Default settings- - OCR output type is invalid- WHEN:- - Settings are validated- THEN:- - system check error reported for OCR output type- """- msgs = settings_values_check(None)- self.assertEqual(len(msgs), 1)+ def test_paths_check_no_access(self, directories: PaperlessTestDirs) -> None:+ directories.data_dir.chmod(0o000)+ directories.media_dir.chmod(0o000)+ directories.consumption_dir.chmod(0o000)- msg = msgs[0]+ try:+ msgs = paths_check(None)+ finally:+ directories.data_dir.chmod(0o777)+ directories.media_dir.chmod(0o777)+ directories.consumption_dir.chmod(0o777)- self.assertIn('OCR output type "notapdf"', msg.msg)+ assert len(msgs) == 3+ for msg in msgs:+ assert msg.msg.endswith("is not writeable")- @override_settings(OCR_MODE="makeitso")- def test_invalid_ocr_type(self) -> None:- """- GIVEN:- - Default settings- - OCR type is invalid- WHEN:- - Settings are validated- THEN:- - system check error reported for OCR type- """- msgs = settings_values_check(None)- self.assertEqual(len(msgs), 1)+ def test_debug_disabled(self, settings: SettingsWrapper) -> None:+ settings.DEBUG = False+ assert debug_mode_check(None) == []- msg = msgs[0]+ def test_debug_enabled(self, settings: SettingsWrapper) -> None:+ settings.DEBUG = True+ assert len(debug_mode_check(None)) == 1- self.assertIn('OCR output mode "makeitso"', msg.msg)- @override_settings(OCR_MODE="skip_noarchive")- def test_deprecated_ocr_type(self) -> None:+class TestSettingsChecksAgainstDefaults:+ def test_all_valid(self) -> None:"""GIVEN:- Default settings- - OCR type is deprecatedWHEN:- Settings are validatedTHEN:- - deprecation warning reported for OCR type+ - No system check errors reported"""msgs = settings_values_check(None)- self.assertEqual(len(msgs), 1)+ assert len(msgs) == 0- msg = msgs[0]- self.assertIn("deprecated", msg.msg)-- @override_settings(OCR_SKIP_ARCHIVE_FILE="invalid")- def test_invalid_ocr_skip_archive_file(self) -> None:+class TestOcrSettingsChecks:+ @pytest.mark.parametrize(+ ("setting", "value", "expected_msg"),+ [+ pytest.param(+ "OCR_OUTPUT_TYPE",+ "notapdf",+ 'OCR output type "notapdf"',+ id="invalid-output-type",+ ),+ pytest.param(+ "OCR_MODE",+ "makeitso",+ 'OCR output mode "makeitso"',+ id="invalid-mode",+ ),+ pytest.param(+ "OCR_MODE",+ "skip_noarchive",+ "deprecated",+ id="deprecated-mode",+ ),+ pytest.param(+ "OCR_SKIP_ARCHIVE_FILE",+ "invalid",+ 'OCR_SKIP_ARCHIVE_FILE setting "invalid"',+ id="invalid-skip-archive-file",+ ),+ pytest.param(+ "OCR_CLEAN",+ "cleanme",+ 'OCR clean mode "cleanme"',+ id="invalid-clean",+ ),+ ],+ )+ def test_invalid_setting_produces_one_error(+ self,+ settings: SettingsWrapper,+ setting: str,+ value: str,+ expected_msg: str,+ ) -> None:"""GIVEN:- Default settings- - OCR_SKIP_ARCHIVE_FILE is invalid+ - One OCR setting is set to an invalid valueWHEN:- Settings are validatedTHEN:- - system check error reported for OCR_SKIP_ARCHIVE_FILE+ - Exactly one system check error is reported containing the expected message"""- msgs = settings_values_check(None)- self.assertEqual(len(msgs), 1)-- msg = msgs[0]-- self.assertIn('OCR_SKIP_ARCHIVE_FILE setting "invalid"', msg.msg)+ setattr(settings, setting, value)- @override_settings(OCR_CLEAN="cleanme")- def test_invalid_ocr_clean(self) -> None:- """- GIVEN:- - Default settings- - OCR cleaning type is invalid- WHEN:- - Settings are validated- THEN:- - system check error reported for OCR cleaning type- """msgs = settings_values_check(None)- self.assertEqual(len(msgs), 1)- msg = msgs[0]+ assert len(msgs) == 1+ assert expected_msg in msgs[0].msg- self.assertIn('OCR clean mode "cleanme"', msg.msg)--class TestTimezoneSettingsChecks(DirectoriesMixin, TestCase):- @override_settings(TIME_ZONE="TheMoon\\MyCrater")- def test_invalid_timezone(self) -> None:+class TestTimezoneSettingsChecks:+ def test_invalid_timezone(self, settings: SettingsWrapper) -> None:"""GIVEN:- Default settings@@ -185,17 +181,16 @@ class TestTimezoneSettingsChecks(DirectoriesMixin, TestCase):THEN:- system check error reported for timezone"""- msgs = settings_values_check(None)- self.assertEqual(len(msgs), 1)+ settings.TIME_ZONE = "TheMoon\\MyCrater"- msg = msgs[0]+ msgs = settings_values_check(None)- self.assertIn('Timezone "TheMoon\\MyCrater"', msg.msg)+ assert len(msgs) == 1+ assert 'Timezone "TheMoon\\MyCrater"' in msgs[0].msg-class TestEmailCertSettingsChecks(DirectoriesMixin, FileSystemAssertsMixin, TestCase):- @override_settings(EMAIL_CERTIFICATE_FILE=Path("/tmp/not_actually_here.pem"))- def test_not_valid_file(self) -> None:+class TestEmailCertSettingsChecks:+ def test_not_valid_file(self, settings: SettingsWrapper) -> None:"""GIVEN:- Default settings@@ -205,19 +200,22 @@ class TestEmailCertSettingsChecks(DirectoriesMixin, FileSystemAssertsMixin, TestTHEN:- system check error reported for email certificate"""- self.assertIsNotFile("/tmp/not_actually_here.pem")+ cert_path = Path("/tmp/not_actually_here.pem")+ assert not cert_path.is_file()+ settings.EMAIL_CERTIFICATE_FILE = cert_pathmsgs = settings_values_check(None)- self.assertEqual(len(msgs), 1)-- msg = msgs[0]+ assert len(msgs) == 1+ assert "Email cert /tmp/not_actually_here.pem is not a file" in msgs[0].msg- self.assertIn("Email cert /tmp/not_actually_here.pem is not a file", msg.msg)--class TestAuditLogChecks(TestCase):- def test_was_enabled_once(self) -> None:+class TestAuditLogChecks:+ def test_was_enabled_once(+ self,+ settings: SettingsWrapper,+ mocker: MockerFixture,+ ) -> None:"""GIVEN:- Audit log is not enabled@@ -226,23 +224,18 @@ class TestAuditLogChecks(TestCase):THEN:- system check error reported for disabling audit log"""- introspect_mock = mock.MagicMock()+ settings.AUDIT_LOG_ENABLED = False+ introspect_mock = mocker.MagicMock()introspect_mock.introspection.table_names.return_value = ["auditlog_logentry"]- with override_settings(AUDIT_LOG_ENABLED=False):- with mock.patch.dict(- "paperless.checks.connections",- {"default": introspect_mock},- ):- msgs = audit_log_check(None)-- self.assertEqual(len(msgs), 1)+ mocker.patch.dict(+ "paperless.checks.connections",+ {"default": introspect_mock},+ )- msg = msgs[0]+ msgs = audit_log_check(None)- self.assertIn(- ("auditlog table was found but audit log is disabled."),- msg.msg,- )+ assert len(msgs) == 1+ assert "auditlog table was found but audit log is disabled." in msgs[0].msgDEPRECATED_VARS: dict[str, str] = {@@ -271,20 +264,16 @@ class TestDeprecatedDbSettings:@pytest.mark.parametrize(("env_var", "db_option_key"),[- ("PAPERLESS_DB_TIMEOUT", "timeout"),- ("PAPERLESS_DB_POOLSIZE", "pool.min_size / pool.max_size"),- ("PAPERLESS_DBSSLMODE", "sslmode"),- ("PAPERLESS_DBSSLROOTCERT", "sslrootcert"),- ("PAPERLESS_DBSSLCERT", "sslcert"),- ("PAPERLESS_DBSSLKEY", "sslkey"),- ],- ids=[- "db-timeout",- "db-poolsize",- "ssl-mode",- "ssl-rootcert",- "ssl-cert",- "ssl-key",+ pytest.param("PAPERLESS_DB_TIMEOUT", "timeout", id="db-timeout"),+ pytest.param(+ "PAPERLESS_DB_POOLSIZE",+ "pool.min_size / pool.max_size",+ id="db-poolsize",+ ),+ pytest.param("PAPERLESS_DBSSLMODE", "sslmode", id="ssl-mode"),+ pytest.param("PAPERLESS_DBSSLROOTCERT", "sslrootcert", id="ssl-rootcert"),+ pytest.param("PAPERLESS_DBSSLCERT", "sslcert", id="ssl-cert"),+ pytest.param("PAPERLESS_DBSSLKEY", "sslkey", id="ssl-key"),],)def test_single_deprecated_var_produces_one_warning(@@ -403,7 +392,10 @@ class TestV3MinimumUpgradeVersionCheck:"""Test suite for check_v3_minimum_upgrade_version system check."""@pytest.fixture- def build_conn_mock(self, mocker: MockerFixture):+ def build_conn_mock(+ self,+ mocker: MockerFixture,+ ) -> Callable[[list[str], list[str]], mock.MagicMock]:"""Factory fixture that builds a connections['default'] mock.Usage::@@ -423,7 +415,7 @@ class TestV3MinimumUpgradeVersionCheck:def test_no_migrations_table_fresh_install(self,mocker: MockerFixture,- build_conn_mock,+ build_conn_mock: Callable[[list[str], list[str]], mock.MagicMock],) -> None:"""GIVEN:@@ -442,7 +434,7 @@ class TestV3MinimumUpgradeVersionCheck:def test_no_documents_migrations_fresh_install(self,mocker: MockerFixture,- build_conn_mock,+ build_conn_mock: Callable[[list[str], list[str]], mock.MagicMock],) -> None:"""GIVEN:@@ -461,7 +453,7 @@ class TestV3MinimumUpgradeVersionCheck:def test_v3_state_with_0001_squashed(self,mocker: MockerFixture,- build_conn_mock,+ build_conn_mock: Callable[[list[str], list[str]], mock.MagicMock],) -> None:"""GIVEN:@@ -485,7 +477,7 @@ class TestV3MinimumUpgradeVersionCheck:def test_v3_state_with_0002_squashed_only(self,mocker: MockerFixture,- build_conn_mock,+ build_conn_mock: Callable[[list[str], list[str]], mock.MagicMock],) -> None:"""GIVEN:@@ -504,7 +496,7 @@ class TestV3MinimumUpgradeVersionCheck:def test_v2_20_9_state_ready_to_upgrade(self,mocker: MockerFixture,- build_conn_mock,+ build_conn_mock: Callable[[list[str], list[str]], mock.MagicMock],) -> None:"""GIVEN:@@ -531,7 +523,7 @@ class TestV3MinimumUpgradeVersionCheck:def test_v2_20_8_raises_error(self,mocker: MockerFixture,- build_conn_mock,+ build_conn_mock: Callable[[list[str], list[str]], mock.MagicMock],) -> None:"""GIVEN:@@ -558,7 +550,7 @@ class TestV3MinimumUpgradeVersionCheck:def test_very_old_version_raises_error(self,mocker: MockerFixture,- build_conn_mock,+ build_conn_mock: Callable[[list[str], list[str]], mock.MagicMock],) -> None:"""GIVEN:@@ -585,7 +577,7 @@ class TestV3MinimumUpgradeVersionCheck:def test_error_hint_mentions_v2_20_9(self,mocker: MockerFixture,- build_conn_mock,+ build_conn_mock: Callable[[list[str], list[str]], mock.MagicMock],) -> None:"""GIVEN:diff --git a/src/paperless/tests/test_utils.py b/src/paperless/tests/test_utils.pyindex 215498c29..152913867 100644--- a/src/paperless/tests/test_utils.py+++ b/src/paperless/tests/test_utils.py@@ -9,35 +9,50 @@ from paperless.utils import ocr_to_dateparser_languages@pytest.mark.parametrize(("ocr_language", "expected"),[- # One language- ("eng", ["en"]),- # Multiple languages- ("fra+ita+lao", ["fr", "it", "lo"]),- # Languages that don't have a two-letter equivalent- ("fil", ["fil"]),- # Languages with a script part supported by dateparser- ("aze_cyrl+srp_latn", ["az-Cyrl", "sr-Latn"]),- # Languages with a script part not supported by dateparser- # In this case, default to the language without script- ("deu_frak", ["de"]),- # Traditional and simplified chinese don't have the same name in dateparser,- # so they're converted to the general chinese language- ("chi_tra+chi_sim", ["zh"]),- # If a language is not supported by dateparser, fallback to the supported ones- ("eng+unsupported_language+por", ["en", "pt"]),- # If no language is supported, fallback to default- ("unsupported1+unsupported2", []),- # Duplicate languages, should not duplicate in result- ("eng+eng", ["en"]),- # Language with script, but script is not mapped- ("ita_unknownscript", ["it"]),+ pytest.param("eng", ["en"], id="single-language"),+ pytest.param("fra+ita+lao", ["fr", "it", "lo"], id="multiple-languages"),+ pytest.param("fil", ["fil"], id="no-two-letter-equivalent"),+ pytest.param(+ "aze_cyrl+srp_latn",+ ["az-Cyrl", "sr-Latn"],+ id="script-supported-by-dateparser",+ ),+ pytest.param(+ "deu_frak",+ ["de"],+ id="script-not-supported-falls-back-to-language",+ ),+ pytest.param(+ "chi_tra+chi_sim",+ ["zh"],+ id="chinese-variants-collapse-to-general",+ ),+ pytest.param(+ "eng+unsupported_language+por",+ ["en", "pt"],+ id="unsupported-language-skipped",+ ),+ pytest.param(+ "unsupported1+unsupported2",+ [],+ id="all-unsupported-returns-empty",+ ),+ pytest.param("eng+eng", ["en"], id="duplicates-deduplicated"),+ pytest.param(+ "ita_unknownscript",+ ["it"],+ id="unknown-script-falls-back-to-language",+ ),],)-def test_ocr_to_dateparser_languages(ocr_language, expected):+def test_ocr_to_dateparser_languages(ocr_language: str, expected: list[str]) -> None:assert sorted(ocr_to_dateparser_languages(ocr_language)) == sorted(expected)-def test_ocr_to_dateparser_languages_exception(monkeypatch, caplog):+def test_ocr_to_dateparser_languages_exception(+ monkeypatch: pytest.MonkeyPatch,+ caplog: pytest.LogCaptureFixture,+) -> None:# Patch LocaleDataLoader.get_locale_map to raise an exceptionclass DummyLoader:def get_locale_map(self, locales=None):diff --git a/src/paperless/tests/test_views.py b/src/paperless/tests/test_views.pyindex ab8941538..35e0fd910 100644--- a/src/paperless/tests/test_views.py+++ b/src/paperless/tests/test_views.py@@ -1,24 +1,31 @@-import tempfilefrom pathlib import Path-from django.test import override_settings+from django.test import Client+from pytest_django.fixtures import SettingsWrapper-def test_favicon_view(client):- with tempfile.TemporaryDirectory() as tmpdir:- static_dir = Path(tmpdir)- favicon_path = static_dir / "paperless" / "img" / "favicon.ico"- favicon_path.parent.mkdir(parents=True, exist_ok=True)- favicon_path.write_bytes(b"FAKE ICON DATA")+def test_favicon_view(+ client: Client,+ tmp_path: Path,+ settings: SettingsWrapper,+) -> None:+ favicon_path = tmp_path / "paperless" / "img" / "favicon.ico"+ favicon_path.parent.mkdir(parents=True)+ favicon_path.write_bytes(b"FAKE ICON DATA")- with override_settings(STATIC_ROOT=static_dir):- response = client.get("/favicon.ico")- assert response.status_code == 200- assert response["Content-Type"] == "image/x-icon"- assert b"".join(response.streaming_content) == b"FAKE ICON DATA"+ settings.STATIC_ROOT = tmp_path+ response = client.get("/favicon.ico")+ assert response.status_code == 200+ assert response["Content-Type"] == "image/x-icon"+ assert b"".join(response.streaming_content) == b"FAKE ICON DATA"-def test_favicon_view_missing_file(client):- with override_settings(STATIC_ROOT=Path(tempfile.mkdtemp())):- response = client.get("/favicon.ico")- assert response.status_code == 404++def test_favicon_view_missing_file(+ client: Client,+ tmp_path: Path,+ settings: SettingsWrapper,+) -> None:+ settings.STATIC_ROOT = tmp_path+ response = client.get("/favicon.ico")+ assert response.status_code == 404