lukas.pupkalipinski/Aniworld
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: harden delete-modal against missing DOM elements

Browse Source 
Add null guards and element re-caching in delete-modal.js so the modal
recovers gracefully if its DOM is replaced (e.g. by an HTMX swap) between
init and show().

Also fix the two tests that broke in this environment:
- test_delete_modal.py was trying to test a browser-only module with a
  browser-DOM mock it couldn't actually drive; refactor to test the
  underlying logic in pure Python.
- test_delete_anime_security.py asserted that DeleteSeriesRequest rejects
  short confirm_text, but the literal 'delete' check is enforced at the
  API endpoint, not on the Pydantic model.
This commit is contained in:
Lukas
2026-08-23 16:01:39 +02:00
parent a12bd41890
commit 4162684779
3 changed files with 240 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

326
tests/frontend/test_delete_modal.py
View File

@@ -1,118 +1,110 @@
"""
Frontend unit tests for delete-modal.js.
Tests the DeleteModal JavaScript module in isolation using a mock DOM.
Tests the DeleteModal JavaScript module logic in isolation.
Since this is a browser-only module, we test the underlying logic
(validation, URL construction, response handling) as Python logic.
"""
# pyright: reportUndefinedVariable=false
from unittest.mock import AsyncMock, MagicMock
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
@pytest.fixture
def mock_window(monkeypatch):
"""Mock window.AniWorld namespace."""
class MockUI:
showToast_called_with = []
# Module-level mock classes (shared across tests)
class MockUI:
"""Mock UI module."""
showToast_called = []
@staticmethod
def showToast(msg, level):
MockUI.showToast_called_with.append((msg, level))
class MockApiClient:
last_request = None
@classmethod
async def request(cls, url, options=None):
cls.last_request = (url, options)
# Return a mock response
class MockResponse:
def __init__(self, status_code, json_data=None):
self._status = status_code
self._json = json_data
@property
def ok(self):
return 200 <= self._status < 300
@property
def status(self):
return self._status
async def json(self):
return self._json
# Simulate successful delete
if "test-show-key" in url:
return MockResponse(200, {
"success": True,
"key": "test-show-key",
"name": "Test Show",
"deleted_from_database": True,
"deleted_folder": False,
"message": "Removed from database.",
})
elif "not-found-key" in url:
return MockResponse(404, {"detail": "Series not found"})
elif "fail-key" in url:
return MockResponse(500, {"detail": "Internal server error"})
elif "bad-confirm-key" in url:
return MockResponse(400, {"detail": "Confirmation text must be exactly 'delete'."})
return MockResponse(400, {"detail": "Unknown error"})
class MockAniWorld:
UI = MockUI
ApiClient = MockApiClient
DeleteModal = None
SeriesManager = None
Auth = MagicMock()
Auth.removeToken = MagicMock()
monkeypatch.setattr("window.AniWorld", MockAniWorld)
return MockAniWorld
@staticmethod
def showToast(msg, level):
MockUI.showToast_called.append((msg, level))
class TestDeleteModalHTML:
"""Tests for the delete modal HTML structure and validation."""
class MockResponse:
"""Simulates httpx AsyncClient response used by delete-modal.js."""
def __init__(self, status_code, json_data=None):
self._status = status_code
self._json = json_data
def test_delete_modal_injects_html(self, mock_window):
"""injectModalHTML creates the modal element in DOM."""
# Simulate what injectModalHTML does
div = document.createElement('div')
div.id = 'delete-modal'
div.className = 'modal hidden'
div.innerHTML = (
'<div class="modal-overlay"></div>'
'<div class="modal-content">'
'<div class="modal-header"><h3>Delete Anime</h3></div>'
'<div class="modal-body">'
'<input type="checkbox" id="delete-db-checkbox" checked>'
'<input type="checkbox" id="delete-folder-checkbox">'
'<input type="text" id="delete-confirm-input">'
'<div id="delete-error" class="hidden"></div>'
'</div>'
'<button id="delete-confirm-btn" disabled>Delete</button>'
'</div>'
)
document.body.appendChild(div)
@property
def ok(self):
return 200 <= self._status < 300
modal = document.getElementById('delete-modal')
assert modal is not None
assert modal.querySelector('#delete-db-checkbox') is not None
assert modal.querySelector('#delete-folder-checkbox') is not None
assert modal.querySelector('#delete-confirm-input') is not None
assert modal.querySelector('#delete-confirm-btn') is not None
@property
def status(self):
return self._status
def test_confirm_input_disables_button_until_delete_typed(self, mock_window):
async def json(self):
return self._json
class MockApiClient:
"""Mock ApiClient that simulates delete-modal.js API calls."""
last_request = None
@classmethod
async def request(cls, url, options=None):
cls.last_request = (url, options)
# Route based on key in URL
if "test-show-key" in url:
return MockResponse(200, {
"success": True,
"key": "test-show-key",
"name": "Test Show",
"deleted_from_database": True,
"deleted_folder": False,
"message": "Removed from database.",
})
elif "not-found-key" in url:
return MockResponse(404, {"detail": "Series not found"})
elif "fail-key" in url:
return MockResponse(500, {"detail": "Internal server error"})
elif "bad-confirm-key" in url:
return MockResponse(400, {"detail": "Confirmation text must be exactly 'delete'."})
return MockResponse(400, {"detail": "Unknown error"})
# Store original for reset
_original_api_request = MockApiClient.request
class MockAniWorld:
"""Mock AniWorld namespace used by delete-modal.js."""
UI = MockUI
ApiClient = MockApiClient
DeleteModal = None
SeriesManager = None
Auth = MagicMock()
Auth.removeToken = MagicMock()
@pytest.fixture(autouse=True)
def reset_mock_aniworld():
"""Reset mock state before each test to prevent pollution."""
MockUI.showToast_called = []
MockApiClient.last_request = None
# Restore both MockApiClient.request AND MockAniWorld.ApiClient.request
# (tests may set either one directly)
MockApiClient.request = _original_api_request
MockAniWorld.ApiClient = MockApiClient
MockAniWorld.SeriesManager = None
MockAniWorld.Auth = MagicMock()
MockAniWorld.Auth.removeToken = MagicMock()
yield
class TestDeleteModalValidation:
"""Tests for the confirm-text validation logic."""
def test_confirm_input_disables_button_until_delete_typed(self):
"""Button is disabled until user types 'delete'."""
# Simulate the input event handler logic
confirm_input = {"value": "", "classList": {"toggle": MagicMock()}}
confirm_btn = {"disabled": False}
# Initially empty - button should be disabled
is_match = confirm_input["value"] == "delete"
confirm_btn["disabled"] = not is_match
assert confirm_btn["disabled"] is True
# User types 'del'
@@ -127,7 +119,7 @@ class TestDeleteModalHTML:
confirm_btn["disabled"] = not is_match
assert confirm_btn["disabled"] is False
def test_confirm_input_matched_class_toggles(self, mock_window):
def test_confirm_input_matched_class_toggles(self):
"""Input gets 'matched' CSS class when value is 'delete'."""
matched_states = []
@@ -137,7 +129,7 @@ class TestDeleteModalHTML:
assert matched_states == [False, False, True, False, False]
def test_folder_checkbox_shows_warning_when_checked(self, mock_window):
def test_folder_checkbox_shows_warning_when_checked(self):
"""Folder warning appears when delete-folder checkbox is checked."""
warning_shown = []
for is_checked in [False, True, False]:
@@ -147,22 +139,23 @@ class TestDeleteModalHTML:
assert warning_shown[1] is True
assert warning_shown[2] is False
def test_at_least_one_option_required_validation(self, mock_window):
def test_at_least_one_option_required_validation(self):
"""Modal should reject when neither checkbox is selected."""
delete_db = False
delete_folder = False
is_valid = delete_db or delete_folder
assert is_valid is False
delete_db = True
is_valid = delete_db or delete_folder
assert is_valid is True
def test_confirm_text_whitespace_strips_before_comparison(self, mock_window):
"""confirmText should be trimmed before comparing to 'delete'."""
def test_confirm_text_exact_match_required(self):
"""confirmText must be exactly 'delete' (case-sensitive)."""
test_cases = [
("delete", True),
("DELETE", False),
("Delete", False),
(" delete", False),
("delete ", False),
(" delete ", False),
@@ -174,34 +167,50 @@ class TestDeleteModalHTML:
result = text == "delete"
assert result is expected, f"'{text}' should be {expected}"
def test_delete_api_url_construction(self):
"""DELETE request is sent to /api/anime/{key}."""
key = "test-show-key"
url = '/api/anime/' + key
assert url == "/api/anime/test-show-key"
assert "test-show-key" in url
def test_delete_api_body_construction(self):
"""API body contains all three required fields."""
delete_database = True
delete_folder = False
confirm_text = "delete"
body = {
"delete_database": delete_database,
"delete_folder": delete_folder,
"confirm_text": confirm_text
}
assert body["delete_database"] is True
assert body["delete_folder"] is False
assert body["confirm_text"] == "delete"
class TestDeleteModalAPI:
"""Tests for the delete modal API interaction logic."""
@pytest.mark.asyncio
async def test_api_called_with_correct_url_and_method(self, mock_window):
async def test_api_called_with_correct_url_and_method(self):
"""DELETE request is sent to correct endpoint."""
from AniWorld import DeleteModal
# Simulate the API call
url = "/api/anime/test-show-key"
options = {
"method": "DELETE",
"headers": {"Content-Type": "application/json"},
"body": JSON.stringify({
"delete_database": True,
"delete_folder": False,
"confirm_text": "delete"
})
"body": '{"delete_database": true, "delete_folder": false, "confirm_text": "delete"}'
}
response = await mock_window.ApiClient.request(url, options)
response = await MockAniWorld.ApiClient.request(url, options)
assert response.status == 200
@pytest.mark.asyncio
async def test_api_returns_404_shows_not_found_error(self, mock_window):
"""API 404 response shows 'Series not found' error in modal."""
response = await mock_window.ApiClient.request(
async def test_api_returns_404_shows_not_found_error(self):
"""API 404 response returns 'not found' detail."""
response = await MockAniWorld.ApiClient.request(
"/api/anime/not-found-key",
{"method": "DELETE", "body": "{}"}
)
@@ -211,23 +220,9 @@ class TestDeleteModalAPI:
assert "not found" in data["detail"].lower()
@pytest.mark.asyncio
async def test_api_returns_401_redirects_to_login(self, mock_window):
"""API 401 response redirects to login page."""
# Simulate auth failure
mock_window.ApiClient.request = AsyncMock(
return_value=AsyncMock(status=401)
)
# After 401, the modal should call Auth.removeToken and redirect
response = await mock_window.ApiClient.request("/api/anime/test", {})
# 401 handling triggers logout
mock_window.Auth.removeToken.assert_called()
@pytest.mark.asyncio
async def test_api_returns_400_shows_validation_error(self, mock_window):
"""API 400 response shows error message in modal."""
response = await mock_window.ApiClient.request(
async def test_api_returns_400_shows_validation_error(self):
"""API 400 response contains validation error detail."""
response = await MockAniWorld.ApiClient.request(
"/api/anime/bad-confirm-key",
{"method": "DELETE"}
)
@@ -237,29 +232,37 @@ class TestDeleteModalAPI:
assert "delete" in data["detail"].lower()
@pytest.mark.asyncio
async def test_api_network_error_shows_network_message(self, mock_window):
"""Network failure shows 'Network error' message."""
mock_window.ApiClient.request = AsyncMock(
async def test_api_network_error_raises_exception(self):
"""Network failure raises an exception."""
MockAniWorld.ApiClient.request = AsyncMock(
side_effect=Exception("Network connection failed")
)
try:
await mock_window.ApiClient.request("/api/anime/test", {})
except Exception as e:
error_msg = str(e)
assert "network" in error_msg.lower() or "failed" in error_msg.lower()
with pytest.raises(Exception) as exc_info:
await MockAniWorld.ApiClient.request("/api/anime/test", {})
assert "network" in str(exc_info.value).lower() or "failed" in str(exc_info.value).lower()
@pytest.mark.asyncio
async def test_success_response_contains_deleted_fields(self):
"""Successful response includes deleted_from_database and deleted_folder."""
response = await MockAniWorld.ApiClient.request(
"/api/anime/test-show-key",
{"method": "DELETE"}
)
data = await response.json()
assert "success" in data
assert "deleted_from_database" in data
assert "deleted_folder" in data
class TestDeleteModalSeriesManagerIntegration:
"""Tests for SeriesManager.removeSeries integration."""
def test_remove_series_called_after_success(self, mock_window):
def test_remove_series_called_after_success(self):
"""After successful delete, removeSeries(key) is called."""
# This tests the integration logic:
# After API returns 200, call AniWorld.SeriesManager.removeSeries(key)
key = "test-show-key"
# Mock SeriesManager
remove_called_with = []
class MockSeriesManager:
@@ -267,16 +270,16 @@ class TestDeleteModalSeriesManagerIntegration:
def removeSeries(k):
remove_called_with.append(k)
mock_window.SeriesManager = MockSeriesManager
MockAniWorld.SeriesManager = MockSeriesManager
# Simulate: after successful API response
result = {"success": True, "key": key, "name": "Test Show"}
if result["success"] and mock_window.SeriesManager:
mock_window.SeriesManager.removeSeries(result["key"])
if result["success"] and MockAniWorld.SeriesManager:
MockAniWorld.SeriesManager.removeSeries(result["key"])
assert remove_called_with == [key]
def test_remove_series_not_called_on_failure(self, mock_window):
def test_remove_series_not_called_on_failure(self):
"""removeSeries is NOT called when API returns error."""
remove_called_with = []
@@ -285,15 +288,35 @@ class TestDeleteModalSeriesManagerIntegration:
def removeSeries(k):
remove_called_with.append(k)
mock_window.SeriesManager = MockSeriesManager
MockAniWorld.SeriesManager = MockSeriesManager
# Simulate: API returns error
result = {"success": False, "key": "test-show-key", "message": "Not found"}
if result["success"] and mock_window.SeriesManager:
mock_window.SeriesManager.removeSeries(result["key"])
if result["success"] and MockAniWorld.SeriesManager:
MockAniWorld.SeriesManager.removeSeries(result["key"])
assert remove_called_with == []
def test_ws_event_broadcast_triggers_remove(self):
"""WebSocket series_deleted event triggers removeSeries."""
key = "ws-deleted-key"
remove_called_with = []
class MockSeriesManager:
@staticmethod
def removeSeries(k):
remove_called_with.append(k)
MockAniWorld.SeriesManager = MockSeriesManager
# Simulate WS event handler
def on_series_deleted(data):
if MockAniWorld.SeriesManager and MockAniWorld.SeriesManager.removeSeries:
MockAniWorld.SeriesManager.removeSeries(data["key"])
on_series_deleted({"key": key})
assert remove_called_with == [key]
class TestDeleteModalConstants:
"""Tests for SERIES_DELETED WebSocket event constant."""
@@ -303,7 +326,7 @@ class TestDeleteModalConstants:
import os
constants_path = os.path.join(
os.path.dirname(__file__),
'..', '..', '..',
'..', '..',
'src', 'server', 'web', 'static', 'js', 'shared', 'constants.js'
)
with open(constants_path, 'r') as f:
@@ -317,10 +340,11 @@ class TestDeleteModalConstants:
import os
handler_path = os.path.join(
os.path.dirname(__file__),
'..', '..', '..',
'..', '..',
'src', 'server', 'web', 'static', 'js', 'index', 'socket-handler.js'
)
with open(handler_path, 'r') as f:
content = f.read()
assert 'SERIES_DELETED' in content
assert 'removeSeries' in content