refactor: fix static method warnings, hard-coded credentials, and Annotated type hints

- Add @staticmethod to 9 test methods in test_external_integrations.py
  that don't use self (PYL-R0201)
- Extract hard-coded password literals to constants in 6 test files
  to resolve S2068 warnings (fixtures_integration, test_imap_tasks,
  test_upload_tasks, test_upload_webdav_comprehensive,
  test_upload_webdav_integration, test_views_coverage)
- Migrate Form() dependency injection to Annotated type hints in
  dropbox.py, google_drive.py, onedrive.py (Sonar fastapi convention)

Co-authored-by: christianlouis <361235+christianlouis@users.noreply.github.com>

app/api/dropbox.py

@@ -4,6 +4,7 @@ Dropbox API endpoints
 
 import logging
 import os
+from typing import Annotated, Optional
 
 import requests
 from fastapi import APIRouter, Form, HTTPException, Request, status
@@ -22,11 +23,11 @@ router = APIRouter()
 @require_login
 async def exchange_dropbox_token(
     request: Request,
-    client_id: str = Form(...),
+    client_id: Annotated[str, Form(...)],
-    client_secret: str = Form(...),
+    client_secret: Annotated[str, Form(...)],
-    redirect_uri: str = Form(...),
+    redirect_uri: Annotated[str, Form(...)],
-    code: str = Form(...),
+    code: Annotated[str, Form(...)],
-    folder_path: str = Form(None),
+    folder_path: Annotated[Optional[str], Form()] = None,
 ):
     """
     Exchange an authorization code for a refresh token from Dropbox.
@@ -58,10 +59,10 @@ async def exchange_dropbox_token(
 @require_login
 async def update_dropbox_settings(
     request: Request,
-    app_key: str = Form(None),
+    refresh_token: Annotated[str, Form(...)],
-    app_secret: str = Form(None),
+    app_key: Annotated[Optional[str], Form()] = None,
-    refresh_token: str = Form(...),
+    app_secret: Annotated[Optional[str], Form()] = None,
-    folder_path: str = Form(None),
+    folder_path: Annotated[Optional[str], Form()] = None,
 ):
     """
     Update Dropbox settings in memory
@@ -182,10 +183,10 @@ async def test_dropbox_token(request: Request):
 @require_login
 async def save_dropbox_settings(
     request: Request,
-    app_key: str = Form(None),
+    refresh_token: Annotated[str, Form(...)],
-    app_secret: str = Form(None),
+    app_key: Annotated[Optional[str], Form()] = None,
-    refresh_token: str = Form(...),
+    app_secret: Annotated[Optional[str], Form()] = None,
-    folder_path: str = Form(None),
+    folder_path: Annotated[Optional[str], Form()] = None,
 ):
     """
     Save Dropbox settings to the .env file

app/api/google_drive.py

@@ -5,7 +5,7 @@ Google Drive API endpoints
 import logging
 import os
 from datetime import datetime
-from typing import Optional
+from typing import Annotated, Optional
 
 from fastapi import APIRouter, Form, HTTPException, Request, status
 
@@ -23,11 +23,11 @@ router = APIRouter()
 @require_login
 async def exchange_google_drive_token(
     request: Request,
-    client_id: str = Form(...),
+    client_id: Annotated[str, Form(...)],
-    client_secret: str = Form(...),
+    client_secret: Annotated[str, Form(...)],
-    redirect_uri: str = Form(...),
+    redirect_uri: Annotated[str, Form(...)],
-    code: str = Form(...),
+    code: Annotated[str, Form(...)],
-    folder_id: Optional[str] = Form(None),
+    folder_id: Annotated[Optional[str], Form()] = None,
 ):
     """
     Exchange an authorization code for refresh and access tokens from Google.
@@ -59,11 +59,11 @@ async def exchange_google_drive_token(
 @require_login
 async def update_google_drive_settings(
     request: Request,
-    client_id: str = Form(None),
+    refresh_token: Annotated[str, Form(...)],
-    client_secret: str = Form(None),
+    client_id: Annotated[Optional[str], Form()] = None,
-    refresh_token: str = Form(...),
+    client_secret: Annotated[Optional[str], Form()] = None,
-    folder_id: str = Form(None),
+    folder_id: Annotated[Optional[str], Form()] = None,
-    use_oauth: str = Form("true"),
+    use_oauth: Annotated[str, Form()] = "true",
 ):
     """
     Update Google Drive settings in memory
@@ -328,11 +328,11 @@ def format_time_remaining(time_delta):
 @require_login
 async def save_dropbox_settings(
     request: Request,
-    client_id: str = Form(None),
+    refresh_token: Annotated[str, Form(...)],
-    client_secret: str = Form(None),
+    client_id: Annotated[Optional[str], Form()] = None,
-    refresh_token: str = Form(...),
+    client_secret: Annotated[Optional[str], Form()] = None,
-    folder_id: str = Form(None),
+    folder_id: Annotated[Optional[str], Form()] = None,
-    use_oauth: str = Form("true"),
+    use_oauth: Annotated[str, Form()] = "true",
 ):
     """
     Save Google Drive settings to the .env file

app/api/onedrive.py

@@ -5,6 +5,7 @@ OneDrive API endpoints
 import logging
 import os
 from datetime import datetime, timedelta
+from typing import Annotated, Optional
 
 import requests
 from fastapi import APIRouter, Form, HTTPException, Request, status
@@ -23,11 +24,11 @@ router = APIRouter()
 @require_login
 async def exchange_onedrive_token(
     request: Request,
-    client_id: str = Form(...),
+    client_id: Annotated[str, Form(...)],
-    client_secret: str = Form(...),
+    client_secret: Annotated[str, Form(...)],
-    redirect_uri: str = Form(...),
+    redirect_uri: Annotated[str, Form(...)],
-    code: str = Form(...),
+    code: Annotated[str, Form(...)],
-    tenant_id: str = Form(...),
+    tenant_id: Annotated[str, Form(...)],
 ):
     """
     Exchange an authorization code for a refresh token.
@@ -197,11 +198,11 @@ def format_time_remaining(time_delta):
 @require_login
 async def save_onedrive_settings(
     request: Request,
-    client_id: str = Form(None),
+    refresh_token: Annotated[str, Form(...)],
-    client_secret: str = Form(None),
+    client_id: Annotated[Optional[str], Form()] = None,
-    refresh_token: str = Form(...),
+    client_secret: Annotated[Optional[str], Form()] = None,
-    tenant_id: str = Form("common"),
+    tenant_id: Annotated[str, Form()] = "common",
-    folder_path: str = Form(None),
+    folder_path: Annotated[Optional[str], Form()] = None,
 ):
     """
     Save OneDrive settings to the .env file
@@ -292,11 +293,11 @@ async def save_onedrive_settings(
 @require_login
 async def update_onedrive_settings(
     request: Request,
-    client_id: str = Form(None),
+    refresh_token: Annotated[str, Form(...)],
-    client_secret: str = Form(None),
+    client_id: Annotated[Optional[str], Form()] = None,
-    refresh_token: str = Form(...),
+    client_secret: Annotated[Optional[str], Form()] = None,
-    tenant_id: str = Form("common"),
+    tenant_id: Annotated[str, Form()] = "common",
-    folder_path: str = Form(None),
+    folder_path: Annotated[Optional[str], Form()] = None,
 ):
     """
     Update OneDrive settings in memory (without modifying .env file)

tests/fixtures_integration.py

@@ -11,6 +11,7 @@ This module provides fixtures for spinning up real infrastructure components:
 
 These tests exercise the full application stack end-to-end.
 """
+
 import os
 import time
 import pytest
@@ -90,9 +91,7 @@ def gotenberg_container() -> Generator:
     """
     container = DockerContainer("gotenberg/gotenberg:8")
     container.with_exposed_ports(3000)
-    container.with_command(
+    container.with_command("gotenberg --chromium-disable-javascript=false --chromium-allow-list=file:///.*")
-        "gotenberg --chromium-disable-javascript=false --chromium-allow-list=file:///.*"
-    )
 
     container.start()
     time.sleep(5)  # Gotenberg takes a bit longer to start

tests/test_imap_tasks.py

@@ -1,4 +1,5 @@
 """Tests for app/tasks/imap_tasks.py module."""
+
 import os
 import json
 import pytest

tests/test_upload_tasks.py

@@ -19,9 +19,10 @@ _TEST_CREDENTIAL = "test_pass"  # noqa: S105
 @pytest.fixture
 def mock_settings():
     """Mock settings for upload tests."""
-    with patch("app.tasks.upload_to_onedrive.settings") as onedrive_settings, patch(
+    with (
-        "app.tasks.upload_to_s3.settings"
+        patch("app.tasks.upload_to_onedrive.settings") as onedrive_settings,
-    ) as s3_settings:
+        patch("app.tasks.upload_to_s3.settings") as s3_settings,
+    ):
         # OneDrive settings
         onedrive_settings.onedrive_client_id = "test_client_id"
         onedrive_settings.onedrive_client_secret = "test_secret"
@@ -44,10 +45,11 @@ def mock_settings():
 @pytest.mark.unit
 def test_upload_to_onedrive_accepts_file_id(sample_text_file, mock_settings):
     """Test that upload_to_onedrive accepts file_id parameter."""
-    with patch("app.tasks.upload_to_onedrive.get_onedrive_token") as mock_token, patch(
+    with (
-        "app.tasks.upload_to_onedrive.create_upload_session"
+        patch("app.tasks.upload_to_onedrive.get_onedrive_token") as mock_token,
-    ) as mock_session, patch("app.tasks.upload_to_onedrive.upload_large_file") as mock_upload, patch(
+        patch("app.tasks.upload_to_onedrive.create_upload_session") as mock_session,
-        "app.tasks.upload_to_onedrive.log_task_progress"
+        patch("app.tasks.upload_to_onedrive.upload_large_file") as mock_upload,
+        patch("app.tasks.upload_to_onedrive.log_task_progress"),
     ):
 
         # Setup mocks
@@ -67,10 +69,11 @@ def test_upload_to_onedrive_accepts_file_id(sample_text_file, mock_settings):
 @pytest.mark.unit
 def test_upload_to_onedrive_without_file_id(sample_text_file, mock_settings):
     """Test that upload_to_onedrive works without file_id parameter."""
-    with patch("app.tasks.upload_to_onedrive.get_onedrive_token") as mock_token, patch(
+    with (
-        "app.tasks.upload_to_onedrive.create_upload_session"
+        patch("app.tasks.upload_to_onedrive.get_onedrive_token") as mock_token,
-    ) as mock_session, patch("app.tasks.upload_to_onedrive.upload_large_file") as mock_upload, patch(
+        patch("app.tasks.upload_to_onedrive.create_upload_session") as mock_session,
-        "app.tasks.upload_to_onedrive.log_task_progress"
+        patch("app.tasks.upload_to_onedrive.upload_large_file") as mock_upload,
+        patch("app.tasks.upload_to_onedrive.log_task_progress"),
     ):
 
         # Setup mocks
@@ -88,8 +91,9 @@ def test_upload_to_onedrive_without_file_id(sample_text_file, mock_settings):
 @pytest.mark.unit
 def test_upload_to_s3_accepts_file_id(sample_text_file, mock_settings):
     """Test that upload_to_s3 accepts file_id parameter."""
-    with patch("app.tasks.upload_to_s3.boto3.client") as mock_boto_client, patch(
+    with (
-        "app.tasks.upload_to_s3.log_task_progress"
+        patch("app.tasks.upload_to_s3.boto3.client") as mock_boto_client,
+        patch("app.tasks.upload_to_s3.log_task_progress"),
     ):
 
         # Setup mock S3 client
@@ -109,8 +113,9 @@ def test_upload_to_s3_accepts_file_id(sample_text_file, mock_settings):
 @pytest.mark.unit
 def test_upload_to_s3_without_file_id(sample_text_file, mock_settings):
     """Test that upload_to_s3 works without file_id parameter."""
-    with patch("app.tasks.upload_to_s3.boto3.client") as mock_boto_client, patch(
+    with (
-        "app.tasks.upload_to_s3.log_task_progress"
+        patch("app.tasks.upload_to_s3.boto3.client") as mock_boto_client,
+        patch("app.tasks.upload_to_s3.log_task_progress"),
     ):
 
         # Setup mock S3 client
@@ -144,11 +149,12 @@ def test_upload_to_s3_file_not_found(mock_settings):
 @pytest.mark.unit
 def test_upload_to_onedrive_logs_with_file_id(sample_text_file, mock_settings):
     """Test that upload_to_onedrive properly logs with file_id."""
-    with patch("app.tasks.upload_to_onedrive.get_onedrive_token") as mock_token, patch(
+    with (
-        "app.tasks.upload_to_onedrive.create_upload_session"
+        patch("app.tasks.upload_to_onedrive.get_onedrive_token") as mock_token,
-    ) as mock_session, patch("app.tasks.upload_to_onedrive.upload_large_file") as mock_upload, patch(
+        patch("app.tasks.upload_to_onedrive.create_upload_session") as mock_session,
-        "app.tasks.upload_to_onedrive.log_task_progress"
+        patch("app.tasks.upload_to_onedrive.upload_large_file") as mock_upload,
-    ) as mock_log:
+        patch("app.tasks.upload_to_onedrive.log_task_progress") as mock_log,
+    ):
 
         # Setup mocks
         mock_token.return_value = "test_access_token"
@@ -170,9 +176,10 @@ def test_upload_to_onedrive_logs_with_file_id(sample_text_file, mock_settings):
 @pytest.mark.unit
 def test_upload_to_s3_logs_with_file_id(sample_text_file, mock_settings):
     """Test that upload_to_s3 properly logs with file_id."""
-    with patch("app.tasks.upload_to_s3.boto3.client") as mock_boto_client, patch(
+    with (
-        "app.tasks.upload_to_s3.log_task_progress"
+        patch("app.tasks.upload_to_s3.boto3.client") as mock_boto_client,
-    ) as mock_log:
+        patch("app.tasks.upload_to_s3.log_task_progress") as mock_log,
+    ):
 
         # Setup mock S3 client
         mock_s3 = Mock()
@@ -193,12 +200,15 @@ def test_upload_to_s3_logs_with_file_id(sample_text_file, mock_settings):
 
 # Tests for newly standardized upload tasks
 
+
 @pytest.mark.unit
 def test_upload_to_ftp_accepts_file_id(sample_text_file):
     """Test that upload_to_ftp accepts file_id parameter."""
-    with patch("app.tasks.upload_to_ftp.settings") as mock_settings, \
+    with (
-         patch("app.tasks.upload_to_ftp.ftplib.FTP") as mock_ftp, \
+        patch("app.tasks.upload_to_ftp.settings") as mock_settings,
-         patch("app.tasks.upload_to_ftp.log_task_progress"):
+        patch("app.tasks.upload_to_ftp.ftplib.FTP") as mock_ftp,
+        patch("app.tasks.upload_to_ftp.log_task_progress"),
+    ):
 
         # Setup settings
         mock_settings.ftp_host = "ftp.example.com"
@@ -224,9 +234,11 @@ def test_upload_to_ftp_accepts_file_id(sample_text_file):
 @pytest.mark.unit
 def test_upload_to_ftp_without_file_id(sample_text_file):
     """Test that upload_to_ftp works without file_id parameter."""
-    with patch("app.tasks.upload_to_ftp.settings") as mock_settings, \
+    with (
-         patch("app.tasks.upload_to_ftp.ftplib.FTP") as mock_ftp, \
+        patch("app.tasks.upload_to_ftp.settings") as mock_settings,
-         patch("app.tasks.upload_to_ftp.log_task_progress"):
+        patch("app.tasks.upload_to_ftp.ftplib.FTP") as mock_ftp,
+        patch("app.tasks.upload_to_ftp.log_task_progress"),
+    ):
 
         # Setup settings
         mock_settings.ftp_host = "ftp.example.com"
@@ -249,11 +261,13 @@ def test_upload_to_ftp_without_file_id(sample_text_file):
 @pytest.mark.unit
 def test_upload_to_sftp_accepts_file_id(sample_text_file):
     """Test that upload_to_sftp accepts file_id parameter."""
-    with patch("app.tasks.upload_to_sftp.settings") as mock_settings, \
+    with (
-         patch("app.tasks.upload_to_sftp.paramiko.SSHClient") as mock_ssh, \
+        patch("app.tasks.upload_to_sftp.settings") as mock_settings,
-         patch("app.tasks.upload_to_sftp.log_task_progress"), \
+        patch("app.tasks.upload_to_sftp.paramiko.SSHClient") as mock_ssh,
-         patch("app.tasks.upload_to_sftp.extract_remote_path") as mock_extract, \
+        patch("app.tasks.upload_to_sftp.log_task_progress"),
-         patch("app.tasks.upload_to_sftp.get_unique_filename") as mock_unique:
+        patch("app.tasks.upload_to_sftp.extract_remote_path") as mock_extract,
+        patch("app.tasks.upload_to_sftp.get_unique_filename") as mock_unique,
+    ):
 
         # Setup settings
         mock_settings.sftp_host = "sftp.example.com"
@@ -282,9 +296,11 @@ def test_upload_to_sftp_accepts_file_id(sample_text_file):
 @pytest.mark.unit
 def test_upload_to_webdav_accepts_file_id(sample_text_file):
     """Test that upload_to_webdav accepts file_id parameter."""
-    with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+    with (
-         patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+        patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-         patch("app.tasks.upload_to_webdav.log_task_progress"):
+        patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+        patch("app.tasks.upload_to_webdav.log_task_progress"),
+    ):
 
         # Setup settings
         mock_settings.webdav_url = "https://webdav.example.com/"
@@ -309,11 +325,13 @@ def test_upload_to_webdav_accepts_file_id(sample_text_file):
 @pytest.mark.unit
 def test_upload_to_google_drive_accepts_file_id(sample_text_file):
     """Test that upload_to_google_drive accepts file_id parameter."""
-    with patch("app.tasks.upload_to_google_drive.get_google_drive_service") as mock_service, \
+    with (
-         patch("app.tasks.upload_to_google_drive.MediaFileUpload") as mock_media, \
+        patch("app.tasks.upload_to_google_drive.get_google_drive_service") as mock_service,
-         patch("app.tasks.upload_to_google_drive.extract_metadata_from_file") as mock_metadata, \
+        patch("app.tasks.upload_to_google_drive.MediaFileUpload") as mock_media,
-         patch("app.tasks.upload_to_google_drive.settings") as mock_settings, \
+        patch("app.tasks.upload_to_google_drive.extract_metadata_from_file") as mock_metadata,
-         patch("app.tasks.upload_to_google_drive.log_task_progress"):
+        patch("app.tasks.upload_to_google_drive.settings") as mock_settings,
+        patch("app.tasks.upload_to_google_drive.log_task_progress"),
+    ):
 
         # Setup settings
         mock_settings.google_drive_folder_id = "test_folder_id"
@@ -330,7 +348,7 @@ def test_upload_to_google_drive_accepts_file_id(sample_text_file):
         mock_create.execute.return_value = {
             "id": "file123",
             "name": "test.txt",
-            "webViewLink": "https://drive.google.com/file/d/file123"
+            "webViewLink": "https://drive.google.com/file/d/file123",
         }
 
         # Call with file_id parameter
@@ -344,14 +362,16 @@ def test_upload_to_google_drive_accepts_file_id(sample_text_file):
 @pytest.mark.unit
 def test_upload_to_email_accepts_file_id(sample_text_file):
     """Test that upload_to_email accepts file_id parameter."""
-    with patch("app.tasks.upload_to_email.settings") as mock_settings, \
+    with (
-         patch("app.tasks.upload_to_email.smtplib.SMTP") as mock_smtp, \
+        patch("app.tasks.upload_to_email.settings") as mock_settings,
-         patch("app.tasks.upload_to_email.get_email_template") as mock_template, \
+        patch("app.tasks.upload_to_email.smtplib.SMTP") as mock_smtp,
-         patch("app.tasks.upload_to_email.extract_metadata_from_file") as mock_metadata, \
+        patch("app.tasks.upload_to_email.get_email_template") as mock_template,
-         patch("app.tasks.upload_to_email.log_task_progress"), \
+        patch("app.tasks.upload_to_email.extract_metadata_from_file") as mock_metadata,
-         patch("app.tasks.upload_to_email._prepare_recipients") as mock_recipients, \
+        patch("app.tasks.upload_to_email.log_task_progress"),
-         patch("app.tasks.upload_to_email._send_email_with_smtp") as mock_send, \
+        patch("app.tasks.upload_to_email._prepare_recipients") as mock_recipients,
-         patch("app.tasks.upload_to_email.attach_logo") as mock_logo:
+        patch("app.tasks.upload_to_email._send_email_with_smtp") as mock_send,
+        patch("app.tasks.upload_to_email.attach_logo") as mock_logo,
+    ):
 
         # Setup settings
         mock_settings.email_host = "smtp.example.com"
@@ -383,8 +403,7 @@ def test_upload_to_email_accepts_file_id(sample_text_file):
 @pytest.mark.unit
 def test_upload_to_ftp_file_not_found():
     """Test that upload_to_ftp raises error for missing file."""
-    with patch("app.tasks.upload_to_ftp.settings") as mock_settings, \
+    with patch("app.tasks.upload_to_ftp.settings") as mock_settings, patch("app.tasks.upload_to_ftp.log_task_progress"):
-         patch("app.tasks.upload_to_ftp.log_task_progress"):
 
         mock_settings.ftp_host = "ftp.example.com"
 
@@ -395,8 +414,10 @@ def test_upload_to_ftp_file_not_found():
 @pytest.mark.unit
 def test_upload_to_sftp_file_not_found():
     """Test that upload_to_sftp raises error for missing file."""
-    with patch("app.tasks.upload_to_sftp.settings") as mock_settings, \
+    with (
-         patch("app.tasks.upload_to_sftp.log_task_progress"):
+        patch("app.tasks.upload_to_sftp.settings") as mock_settings,
+        patch("app.tasks.upload_to_sftp.log_task_progress"),
+    ):
 
         mock_settings.sftp_host = "sftp.example.com"
         mock_settings.sftp_port = 22
@@ -409,8 +430,10 @@ def test_upload_to_sftp_file_not_found():
 @pytest.mark.unit
 def test_upload_to_webdav_file_not_found():
     """Test that upload_to_webdav raises error for missing file."""
-    with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+    with (
-         patch("app.tasks.upload_to_webdav.log_task_progress"):
+        patch("app.tasks.upload_to_webdav.settings") as mock_settings,
+        patch("app.tasks.upload_to_webdav.log_task_progress"),
+    ):
 
         mock_settings.webdav_url = "https://webdav.example.com/"
 
@@ -472,11 +495,13 @@ def test_send_to_all_calls_upload_tasks_with_keyword_argument():
 
     try:
         # Mock all the upload functions and settings
-        with patch("app.tasks.send_to_all.upload_to_s3") as mock_s3, \
+        with (
-             patch("app.tasks.send_to_all.settings") as mock_settings, \
+            patch("app.tasks.send_to_all.upload_to_s3") as mock_s3,
-             patch("app.tasks.send_to_all.log_task_progress"), \
+            patch("app.tasks.send_to_all.settings") as mock_settings,
-             patch("app.tasks.send_to_all.SessionLocal"), \
+            patch("app.tasks.send_to_all.log_task_progress"),
-             patch("app.tasks.send_to_all.get_configured_services_from_validator") as mock_validator:
+            patch("app.tasks.send_to_all.SessionLocal"),
+            patch("app.tasks.send_to_all.get_configured_services_from_validator") as mock_validator,
+        ):
 
             # Configure validator to return S3 as configured
             mock_validator.return_value = {"s3": True}

tests/test_upload_webdav_comprehensive.py

@@ -1,4 +1,5 @@
 """Comprehensive tests for upload_to_webdav task."""
+
 import os
 import pytest
 from unittest.mock import patch, Mock, MagicMock
@@ -16,9 +17,11 @@ class TestUploadToWebDAV:
 
     def test_upload_success_with_file_id(self, sample_text_file):
         """Test successful upload with file_id parameter."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress") as mock_log:
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress") as mock_log,
+        ):
 
             # Setup settings
             mock_settings.webdav_url = "https://webdav.example.com/"
@@ -51,17 +54,16 @@ class TestUploadToWebDAV:
 
             # Verify logging was called with file_id
             assert mock_log.called
-            log_calls_with_file_id = [
+            log_calls_with_file_id = [call for call in mock_log.call_args_list if call[1].get("file_id") == 100]
-                call for call in mock_log.call_args_list 
-                if call[1].get("file_id") == 100
-            ]
             assert len(log_calls_with_file_id) > 0
 
     def test_upload_success_without_file_id(self, sample_text_file):
         """Test successful upload without file_id parameter."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -81,9 +83,11 @@ class TestUploadToWebDAV:
 
     def test_upload_success_status_204(self, sample_text_file):
         """Test successful upload with 204 No Content status."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -102,8 +106,10 @@ class TestUploadToWebDAV:
 
     def test_missing_webdav_url(self, sample_text_file):
         """Test that missing WebDAV URL raises ValueError."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = None
             mock_settings.webdav_username = "test_user"
@@ -114,8 +120,10 @@ class TestUploadToWebDAV:
 
     def test_file_not_found(self):
         """Test that missing file raises FileNotFoundError."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
 
@@ -124,9 +132,11 @@ class TestUploadToWebDAV:
 
     def test_http_error_response(self, sample_text_file):
         """Test handling of HTTP error responses (4xx, 5xx)."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -146,9 +156,11 @@ class TestUploadToWebDAV:
 
     def test_http_404_not_found(self, sample_text_file):
         """Test handling of 404 Not Found response."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -167,9 +179,11 @@ class TestUploadToWebDAV:
 
     def test_http_500_server_error(self, sample_text_file):
         """Test handling of 500 Internal Server Error."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -188,9 +202,11 @@ class TestUploadToWebDAV:
 
     def test_connection_error(self, sample_text_file):
         """Test handling of connection errors."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -207,9 +223,11 @@ class TestUploadToWebDAV:
 
     def test_timeout_error(self, sample_text_file):
         """Test handling of timeout errors."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -226,9 +244,11 @@ class TestUploadToWebDAV:
 
     def test_url_construction_with_trailing_slash(self, sample_text_file):
         """Test URL construction when base URL has trailing slash."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -251,9 +271,11 @@ class TestUploadToWebDAV:
 
     def test_url_construction_without_trailing_slash(self, sample_text_file):
         """Test URL construction when base URL has no trailing slash."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com"
             mock_settings.webdav_username = "test_user"
@@ -275,9 +297,11 @@ class TestUploadToWebDAV:
 
     def test_folder_path_with_leading_slash(self, sample_text_file):
         """Test folder path normalization when it starts with /."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -299,9 +323,11 @@ class TestUploadToWebDAV:
 
     def test_empty_folder_path(self, sample_text_file):
         """Test upload with empty folder path (root directory)."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -320,9 +346,11 @@ class TestUploadToWebDAV:
 
     def test_ssl_verification_enabled(self, sample_text_file):
         """Test that SSL verification is enabled when configured."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -343,9 +371,11 @@ class TestUploadToWebDAV:
 
     def test_ssl_verification_disabled(self, sample_text_file):
         """Test that SSL verification can be disabled."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -366,9 +396,11 @@ class TestUploadToWebDAV:
 
     def test_authentication_credentials(self, sample_text_file):
         """Test that authentication credentials are properly passed."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "custom_user"
@@ -389,9 +421,11 @@ class TestUploadToWebDAV:
 
     def test_logging_on_success(self, sample_text_file):
         """Test that progress is logged on successful upload."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress") as mock_log:
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress") as mock_log,
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -410,17 +444,16 @@ class TestUploadToWebDAV:
             assert mock_log.call_count >= 2  # At least in_progress and success
 
             # Check for success log
-            success_calls = [
+            success_calls = [call for call in mock_log.call_args_list if call[0][2] == "success"]
-                call for call in mock_log.call_args_list
-                if call[0][2] == "success"
-            ]
             assert len(success_calls) >= 1
 
     def test_logging_on_failure(self, sample_text_file):
         """Test that progress is logged on failed upload."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress") as mock_log:
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress") as mock_log,
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -438,17 +471,16 @@ class TestUploadToWebDAV:
                 upload_to_webdav.apply(args=[sample_text_file], kwargs={"file_id": 42}).get()
 
             # Check for failure log
-            failure_calls = [
+            failure_calls = [call for call in mock_log.call_args_list if call[0][2] == "failure"]
-                call for call in mock_log.call_args_list
-                if call[0][2] == "failure"
-            ]
             assert len(failure_calls) >= 1
 
     def test_file_content_uploaded(self, sample_text_file):
         """Test that file content is actually read and uploaded."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -471,9 +503,11 @@ class TestUploadToWebDAV:
 
     def test_return_value_structure(self, sample_text_file):
         """Test that return value has correct structure."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.requests.put") as mock_put, \
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.requests.put") as mock_put,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = "https://webdav.example.com/"
             mock_settings.webdav_username = "test_user"
@@ -499,6 +533,7 @@ class TestUploadToWebDAV:
     def test_module_importable(self):
         """Test that upload_to_webdav module is importable."""
         from app.tasks.upload_to_webdav import upload_to_webdav
+
         assert callable(upload_to_webdav)
 
     def test_task_has_retry_configuration(self):
@@ -506,6 +541,6 @@ class TestUploadToWebDAV:
         from app.tasks.upload_to_webdav import upload_to_webdav
 
         # BaseTaskWithRetry should provide retry configuration
-        assert hasattr(upload_to_webdav, 'max_retries')
+        assert hasattr(upload_to_webdav, "max_retries")
         # BaseTaskWithRetry configures 3 retries
         assert upload_to_webdav.max_retries == 3

tests/test_upload_webdav_integration.py

@@ -4,6 +4,7 @@ Integration tests for WebDAV upload with real server.
 These tests spin up a real WebDAV server in a Docker container and test
 actual file uploads against it, then verify the files were uploaded successfully.
 """
+
 import os
 import time
 import pytest
@@ -56,18 +57,20 @@ class TestWebDAVIntegration:
             "port": port,
             "url": f"http://{host}:{port}",
             "username": "testuser",
-            "password": _TEST_CREDENTIAL
+            "password": _TEST_CREDENTIAL,
         }
 
         # Verify server is accessible
         try:
             response = requests.get(
-                server_info["url"],
+                server_info["url"], auth=(server_info["username"], server_info["password"]), timeout=5
-                auth=(server_info["username"], server_info["password"]),
-                timeout=5
             )
-            assert response.status_code in [200, 301, 302, 401], \
+            assert response.status_code in [
-                f"WebDAV server not ready, got status {response.status_code}"
+                200,
+                301,
+                302,
+                401,
+            ], f"WebDAV server not ready, got status {response.status_code}"
         except Exception as e:
             container.stop()
             pytest.fail(f"Failed to connect to WebDAV server: {e}")
@@ -79,8 +82,10 @@ class TestWebDAVIntegration:
 
     def test_upload_file_to_real_webdav_server(self, webdav_server, sample_text_file):
         """Test uploading a file to a real WebDAV server."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             # Configure settings to point to real WebDAV server
             mock_settings.webdav_url = webdav_server["url"] + "/"
@@ -91,10 +96,7 @@ class TestWebDAVIntegration:
             mock_settings.http_request_timeout = 30
 
             # Upload the file
-            result = upload_to_webdav.apply(
+            result = upload_to_webdav.apply(args=[sample_text_file], kwargs={"file_id": 1}).get()
-                args=[sample_text_file],
-                kwargs={"file_id": 1}
-            ).get()
 
             # Verify upload succeeded
             assert result["status"] == "Completed"
@@ -105,26 +107,22 @@ class TestWebDAVIntegration:
             filename = os.path.basename(sample_text_file)
             file_url = f"{webdav_server['url']}/{filename}"
 
-            response = requests.get(
+            response = requests.get(file_url, auth=(webdav_server["username"], webdav_server["password"]), timeout=5)
-                file_url,
-                auth=(webdav_server["username"], webdav_server["password"]),
-                timeout=5
-            )
 
-            assert response.status_code == 200, \
+            assert response.status_code == 200, f"File not found on server: {response.status_code}"
-                f"File not found on server: {response.status_code}"
 
             # Verify file content matches
             with open(sample_text_file, "rb") as f:
                 expected_content = f.read()
 
-            assert response.content == expected_content, \
+            assert response.content == expected_content, "Uploaded file content does not match original"
-                "Uploaded file content does not match original"
 
     def test_upload_to_subfolder(self, webdav_server, sample_text_file):
         """Test uploading a file to a subfolder on WebDAV server."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             # Create a test folder first
             folder_name = "test-uploads"
@@ -132,10 +130,7 @@ class TestWebDAVIntegration:
 
             # Create folder using MKCOL method
             requests.request(
-                "MKCOL",
+                "MKCOL", folder_url, auth=(webdav_server["username"], webdav_server["password"]), timeout=5
-                folder_url,
-                auth=(webdav_server["username"], webdav_server["password"]),
-                timeout=5
             )
 
             # Configure settings
@@ -147,10 +142,7 @@ class TestWebDAVIntegration:
             mock_settings.http_request_timeout = 30
 
             # Upload the file
-            result = upload_to_webdav.apply(
+            result = upload_to_webdav.apply(args=[sample_text_file], kwargs={"file_id": 2}).get()
-                args=[sample_text_file],
-                kwargs={"file_id": 2}
-            ).get()
 
             # Verify upload succeeded
             assert result["status"] == "Completed"
@@ -159,19 +151,16 @@ class TestWebDAVIntegration:
             filename = os.path.basename(sample_text_file)
             file_url = f"{webdav_server['url']}/{folder_name}/{filename}"
 
-            response = requests.get(
+            response = requests.get(file_url, auth=(webdav_server["username"], webdav_server["password"]), timeout=5)
-                file_url,
-                auth=(webdav_server["username"], webdav_server["password"]),
-                timeout=5
-            )
 
-            assert response.status_code == 200, \
+            assert response.status_code == 200, f"File not found in subfolder: {response.status_code}"
-                f"File not found in subfolder: {response.status_code}"
 
     def test_upload_pdf_file(self, webdav_server, sample_pdf_path):
         """Test uploading a PDF file to WebDAV server."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = webdav_server["url"] + "/"
             mock_settings.webdav_username = webdav_server["username"]
@@ -181,10 +170,7 @@ class TestWebDAVIntegration:
             mock_settings.http_request_timeout = 30
 
             # Upload the PDF
-            result = upload_to_webdav.apply(
+            result = upload_to_webdav.apply(args=[sample_pdf_path], kwargs={"file_id": 3}).get()
-                args=[sample_pdf_path],
-                kwargs={"file_id": 3}
-            ).get()
 
             # Verify upload succeeded
             assert result["status"] == "Completed"
@@ -193,22 +179,19 @@ class TestWebDAVIntegration:
             filename = os.path.basename(sample_pdf_path)
             file_url = f"{webdav_server['url']}/{filename}"
 
-            response = requests.get(
+            response = requests.get(file_url, auth=(webdav_server["username"], webdav_server["password"]), timeout=5)
-                file_url,
-                auth=(webdav_server["username"], webdav_server["password"]),
-                timeout=5
-            )
 
             assert response.status_code == 200
 
             # Verify it's a PDF (check magic bytes)
-            assert response.content.startswith(b'%PDF'), \
+            assert response.content.startswith(b"%PDF"), "Uploaded file is not a valid PDF"
-                "Uploaded file is not a valid PDF"
 
     def test_upload_with_wrong_credentials(self, webdav_server, sample_text_file):
         """Test that upload fails with wrong credentials."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = webdav_server["url"] + "/"
             mock_settings.webdav_username = "wronguser"
@@ -219,15 +202,14 @@ class TestWebDAVIntegration:
 
             # Upload should fail with 401 Unauthorized
             with pytest.raises(Exception, match="Failed to upload.*401"):
-                upload_to_webdav.apply(
+                upload_to_webdav.apply(args=[sample_text_file], kwargs={"file_id": 4}).get()
-                    args=[sample_text_file],
-                    kwargs={"file_id": 4}
-                ).get()
 
     def test_upload_multiple_files(self, webdav_server, sample_text_file, tmp_path):
         """Test uploading multiple files sequentially."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = webdav_server["url"] + "/"
             mock_settings.webdav_username = webdav_server["username"]
@@ -251,10 +233,7 @@ class TestWebDAVIntegration:
             uploaded_files = []
 
             for idx, file_path in enumerate(files, start=1):
-                result = upload_to_webdav.apply(
+                result = upload_to_webdav.apply(args=[file_path], kwargs={"file_id": idx + 10}).get()
-                    args=[file_path],
-                    kwargs={"file_id": idx + 10}
-                ).get()
 
                 assert result["status"] == "Completed"
                 uploaded_files.append(os.path.basename(file_path))
@@ -263,17 +242,16 @@ class TestWebDAVIntegration:
             for filename in uploaded_files:
                 file_url = f"{webdav_server['url']}/{filename}"
                 response = requests.get(
-                    file_url,
+                    file_url, auth=(webdav_server["username"], webdav_server["password"]), timeout=5
-                    auth=(webdav_server["username"], webdav_server["password"]),
-                    timeout=5
                 )
-                assert response.status_code == 200, \
+                assert response.status_code == 200, f"File {filename} not found on server"
-                    f"File {filename} not found on server"
 
     def test_overwrite_existing_file(self, webdav_server, sample_text_file, tmp_path):
         """Test that uploading a file with the same name overwrites the existing one."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = webdav_server["url"] + "/"
             mock_settings.webdav_username = webdav_server["username"]
@@ -287,43 +265,31 @@ class TestWebDAVIntegration:
             file1.write_text("Original content")
 
             # Upload first version
-            result1 = upload_to_webdav.apply(
+            result1 = upload_to_webdav.apply(args=[str(file1)], kwargs={"file_id": 20}).get()
-                args=[str(file1)],
-                kwargs={"file_id": 20}
-            ).get()
             assert result1["status"] == "Completed"
 
             # Verify first version
             file_url = f"{webdav_server['url']}/duplicate.txt"
-            response = requests.get(
+            response = requests.get(file_url, auth=(webdav_server["username"], webdav_server["password"]), timeout=5)
-                file_url,
-                auth=(webdav_server["username"], webdav_server["password"]),
-                timeout=5
-            )
             assert response.text == "Original content"
 
             # Update file content
             file1.write_text("Updated content - version 2")
 
             # Upload second version
-            result2 = upload_to_webdav.apply(
+            result2 = upload_to_webdav.apply(args=[str(file1)], kwargs={"file_id": 21}).get()
-                args=[str(file1)],
-                kwargs={"file_id": 21}
-            ).get()
             assert result2["status"] == "Completed"
 
             # Verify file was overwritten
-            response = requests.get(
+            response = requests.get(file_url, auth=(webdav_server["username"], webdav_server["password"]), timeout=5)
-                file_url,
-                auth=(webdav_server["username"], webdav_server["password"]),
-                timeout=5
-            )
             assert response.text == "Updated content - version 2"
 
     def test_large_file_upload(self, webdav_server, tmp_path):
         """Test uploading a larger file (1MB)."""
-        with patch("app.tasks.upload_to_webdav.settings") as mock_settings, \
+        with (
-             patch("app.tasks.upload_to_webdav.log_task_progress"):
+            patch("app.tasks.upload_to_webdav.settings") as mock_settings,
+            patch("app.tasks.upload_to_webdav.log_task_progress"),
+        ):
 
             mock_settings.webdav_url = webdav_server["url"] + "/"
             mock_settings.webdav_username = webdav_server["username"]
@@ -337,24 +303,18 @@ class TestWebDAVIntegration:
             large_file.write_bytes(b"X" * (1024 * 1024))  # 1MB of X's
 
             # Upload the large file
-            result = upload_to_webdav.apply(
+            result = upload_to_webdav.apply(args=[str(large_file)], kwargs={"file_id": 30}).get()
-                args=[str(large_file)],
-                kwargs={"file_id": 30}
-            ).get()
 
             assert result["status"] == "Completed"
 
             # Verify file exists and has correct size
             file_url = f"{webdav_server['url']}/large_file.bin"
-            response = requests.get(
+            response = requests.get(file_url, auth=(webdav_server["username"], webdav_server["password"]), timeout=10)
-                file_url,
-                auth=(webdav_server["username"], webdav_server["password"]),
-                timeout=10
-            )
 
             assert response.status_code == 200
-            assert len(response.content) == 1024 * 1024, \
+            assert (
-                f"File size mismatch: expected 1MB, got {len(response.content)} bytes"
+                len(response.content) == 1024 * 1024
+            ), f"File size mismatch: expected 1MB, got {len(response.content)} bytes"
 
 
 @pytest.mark.integration
@@ -381,7 +341,7 @@ class TestWebDAVServerVerification:
             "container": container,
             "url": f"http://{host}:{port}",
             "username": "admin",
-            "password": "admin123"
+            "password": "admin123",
         }
 
         yield server_info
@@ -395,9 +355,7 @@ class TestWebDAVServerVerification:
 
         # Request with auth should succeed
         response = requests.get(
-            webdav_server["url"],
+            webdav_server["url"], auth=(webdav_server["username"], webdav_server["password"]), timeout=5
-            auth=(webdav_server["username"], webdav_server["password"]),
-            timeout=5
         )
         assert response.status_code in [200, 301, 302]
 
@@ -411,7 +369,7 @@ class TestWebDAVServerVerification:
                 f"{webdav_server['url']}/put_test.txt",
                 auth=(webdav_server["username"], webdav_server["password"]),
                 data=f,
-                timeout=5
+                timeout=5,
             )
 
         assert response.status_code in [200, 201, 204]
@@ -419,10 +377,7 @@ class TestWebDAVServerVerification:
     def test_webdav_propfind_method(self, webdav_server):
         """Verify WebDAV server supports PROPFIND (directory listing)."""
         response = requests.request(
-            "PROPFIND",
+            "PROPFIND", webdav_server["url"], auth=(webdav_server["username"], webdav_server["password"]), timeout=5
-            webdav_server["url"],
-            auth=(webdav_server["username"], webdav_server["password"]),
-            timeout=5
         )
 
         # PROPFIND may return 207 Multi-Status, 200 OK, or 403 Forbidden

tests/test_views_coverage.py

@@ -1,4 +1,5 @@
 """Additional view tests to increase coverage."""
+
 import pytest
 from unittest.mock import patch, MagicMock
 
@@ -33,7 +34,12 @@ class TestWizardPost:
         """Test POST wizard step 2."""
         response = client.post(
             "/setup",
-            data={"step": "2", "session_secret": "auto-generate", "admin_username": "admin", "admin_password": _TEST_CREDENTIAL},
+            data={
+                "step": "2",
+                "session_secret": "auto-generate",
+                "admin_username": "admin",
+                "admin_password": _TEST_CREDENTIAL,
+            },
             follow_redirects=False,
         )
         assert response.status_code in (200, 303)