327 lines
12 KiB
Python
327 lines
12 KiB
Python
"""
|
|
Frontend unit tests for delete-modal.js.
|
|
|
|
Tests the DeleteModal JavaScript module in isolation using a mock DOM.
|
|
"""
|
|
# pyright: reportUndefinedVariable=false
|
|
from unittest.mock import AsyncMock, MagicMock
|
|
|
|
import pytest
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_window(monkeypatch):
|
|
"""Mock window.AniWorld namespace."""
|
|
class MockUI:
|
|
showToast_called_with = []
|
|
|
|
@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
|
|
|
|
|
|
class TestDeleteModalHTML:
|
|
"""Tests for the delete modal HTML structure and validation."""
|
|
|
|
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)
|
|
|
|
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
|
|
|
|
def test_confirm_input_disables_button_until_delete_typed(self, mock_window):
|
|
"""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'
|
|
confirm_input["value"] = "del"
|
|
is_match = confirm_input["value"] == "delete"
|
|
confirm_btn["disabled"] = not is_match
|
|
assert confirm_btn["disabled"] is True
|
|
|
|
# User types 'delete'
|
|
confirm_input["value"] = "delete"
|
|
is_match = confirm_input["value"] == "delete"
|
|
confirm_btn["disabled"] = not is_match
|
|
assert confirm_btn["disabled"] is False
|
|
|
|
def test_confirm_input_matched_class_toggles(self, mock_window):
|
|
"""Input gets 'matched' CSS class when value is 'delete'."""
|
|
matched_states = []
|
|
|
|
for value in ["", "del", "delete", "Delete", "delete "]:
|
|
is_match = value == "delete"
|
|
matched_states.append(is_match)
|
|
|
|
assert matched_states == [False, False, True, False, False]
|
|
|
|
def test_folder_checkbox_shows_warning_when_checked(self, mock_window):
|
|
"""Folder warning appears when delete-folder checkbox is checked."""
|
|
warning_shown = []
|
|
for is_checked in [False, True, False]:
|
|
warning_shown.append(is_checked)
|
|
|
|
assert warning_shown[0] is False
|
|
assert warning_shown[1] is True
|
|
assert warning_shown[2] is False
|
|
|
|
def test_at_least_one_option_required_validation(self, mock_window):
|
|
"""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'."""
|
|
test_cases = [
|
|
("delete", True),
|
|
(" delete", False),
|
|
("delete ", False),
|
|
(" delete ", False),
|
|
("deletex", False),
|
|
("", False),
|
|
]
|
|
|
|
for text, expected in test_cases:
|
|
result = text == "delete"
|
|
assert result is expected, f"'{text}' should be {expected}"
|
|
|
|
|
|
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):
|
|
"""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"
|
|
})
|
|
}
|
|
|
|
response = await mock_window.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(
|
|
"/api/anime/not-found-key",
|
|
{"method": "DELETE", "body": "{}"}
|
|
)
|
|
|
|
assert response.status == 404
|
|
data = await response.json()
|
|
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(
|
|
"/api/anime/bad-confirm-key",
|
|
{"method": "DELETE"}
|
|
)
|
|
|
|
assert response.status == 400
|
|
data = await response.json()
|
|
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(
|
|
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()
|
|
|
|
|
|
class TestDeleteModalSeriesManagerIntegration:
|
|
"""Tests for SeriesManager.removeSeries integration."""
|
|
|
|
def test_remove_series_called_after_success(self, mock_window):
|
|
"""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:
|
|
@staticmethod
|
|
def removeSeries(k):
|
|
remove_called_with.append(k)
|
|
|
|
mock_window.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"])
|
|
|
|
assert remove_called_with == [key]
|
|
|
|
def test_remove_series_not_called_on_failure(self, mock_window):
|
|
"""removeSeries is NOT called when API returns error."""
|
|
remove_called_with = []
|
|
|
|
class MockSeriesManager:
|
|
@staticmethod
|
|
def removeSeries(k):
|
|
remove_called_with.append(k)
|
|
|
|
mock_window.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"])
|
|
|
|
assert remove_called_with == []
|
|
|
|
|
|
class TestDeleteModalConstants:
|
|
"""Tests for SERIES_DELETED WebSocket event constant."""
|
|
|
|
def test_series_deleted_constant_referenced_in_constants_js(self):
|
|
"""WS_EVENTS.SERIES_DELETED constant exists in constants.js."""
|
|
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:
|
|
content = f.read()
|
|
|
|
assert 'SERIES_DELETED' in content
|
|
assert "SERIES_DELETED: 'series_deleted'" in content
|
|
|
|
def test_series_deleted_constant_referenced_in_socket_handler(self):
|
|
"""WS_EVENTS.SERIES_DELETED is handled in socket-handler.js."""
|
|
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
|