mirror of
https://github.com/nomadkaraoke/karaoke-gen.git
synced 2026-11-20 13:07:57 +09:00
## Summary - Remove the deprecated beta enrollment system (endpoints, models, email templates, admin UI, rate limits) — ~20 files cleaned - Remove legacy count-based YouTube upload tracking from rate_limit_service and dead blocklist methods - Add GCP Cloud Monitoring integration to cross-reference YouTube API quota usage with Firestore tracking - Add drift detection (alerts when GCP reported vs Firestore tracked differs >10%) - Display GCP quota data in admin rate-limits dashboard ## Changes ### Backend (15 files) - **Removed:** 5 beta endpoints, `BetaTesterStatus` enum, beta User fields, beta email templates, `validate_email_for_beta()`, deprecated YouTube/beta rate limit methods, dead blocklist CRUD methods - **Added:** `get_gcp_quota_usage()` to `YouTubeQuotaService` with Cloud Monitoring API query, 5-min cache, and drift detection - **Updated:** Rate limits API response model with GCP quota fields (`gcp_quota_available`, `gcp_quota_units_consumed`, `quota_drift`, `quota_drift_alert`) ### Frontend (11 files) - **Deleted:** `frontend/app/admin/beta/page.tsx` (entire beta admin page) - **Removed:** Beta sidebar nav, layout breadcrumb, admin stats card, beta types/API methods, legacy YouTube stats cards - **Added:** GCP Cloud Monitoring section in rate-limits page showing reported usage, delay, and drift alerts ### Tests (4 files) - Removed 8 obsolete tests for deprecated methods - Created `test_gcp_quota_monitor.py` with 10 tests covering GCP quota querying, caching, fallbacks, and drift detection - Updated mock data and assertions across test files ### Docs (3 files) - Removed beta endpoint docs from API.md, added GCP quota fields - Updated ARCHITECTURE.md with Cloud Monitoring integration - Removed beta program section from PRODUCT-VISION.md ## Test plan - [x] All 2265 backend tests pass (1 pre-existing failure unrelated) - [x] All 516 frontend Jest tests pass - [x] New GCP quota monitor tests cover success, caching, fallbacks, drift alerts - [ ] Verify admin rate-limits page no longer shows beta/legacy cards - [ ] Verify GCP quota section shows "unavailable" gracefully when monitoring data not yet populated @coderabbitai ignore 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
526 lines
20 KiB
Python
526 lines
20 KiB
Python
"""
|
|
Unit tests for rate limits admin API endpoints.
|
|
|
|
Tests the rate limit statistics, blocklist management, and user override endpoints.
|
|
"""
|
|
import pytest
|
|
from unittest.mock import Mock, patch, MagicMock
|
|
from fastapi.testclient import TestClient
|
|
from fastapi import FastAPI
|
|
from datetime import datetime, timezone
|
|
|
|
from backend.api.routes.rate_limits import router
|
|
from backend.api.dependencies import require_admin
|
|
from backend.services.auth_service import AuthResult, UserType
|
|
|
|
|
|
# Create a test app with the rate_limits router
|
|
app = FastAPI()
|
|
app.include_router(router, prefix="/api")
|
|
|
|
|
|
def get_mock_admin():
|
|
"""Override for require_admin dependency."""
|
|
return AuthResult(
|
|
is_valid=True,
|
|
user_type=UserType.ADMIN,
|
|
remaining_uses=-1,
|
|
message="Admin access granted",
|
|
user_email="admin@example.com",
|
|
is_admin=True,
|
|
)
|
|
|
|
|
|
# Override the require_admin dependency
|
|
app.dependency_overrides[require_admin] = get_mock_admin
|
|
|
|
|
|
@pytest.fixture
|
|
def client():
|
|
"""Create a test client."""
|
|
return TestClient(app)
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_settings():
|
|
"""Create mock settings."""
|
|
settings = Mock()
|
|
settings.enable_rate_limiting = True
|
|
settings.rate_limit_jobs_per_day = 5
|
|
return settings
|
|
|
|
|
|
class TestGetRateLimitStats:
|
|
"""Tests for GET /api/admin/rate-limits/stats endpoint."""
|
|
|
|
def test_returns_stats(self, client, mock_settings):
|
|
"""Test successful stats retrieval."""
|
|
with patch('backend.api.routes.rate_limits.get_rate_limit_service') as mock_get_rls, \
|
|
patch('backend.api.routes.rate_limits.get_email_validation_service') as mock_get_evs, \
|
|
patch('backend.services.youtube_quota_service.get_youtube_quota_service') as mock_get_qs, \
|
|
patch('backend.services.youtube_upload_queue_service.get_youtube_upload_queue_service') as mock_get_uqs, \
|
|
patch('backend.api.routes.rate_limits.settings', mock_settings):
|
|
|
|
# Setup rate limit service mock
|
|
mock_rls = Mock()
|
|
mock_rls.get_all_overrides.return_value = {"user1@example.com": {}}
|
|
mock_get_rls.return_value = mock_rls
|
|
|
|
# Setup email validation service mock
|
|
mock_evs = Mock()
|
|
mock_evs.get_blocklist_stats.return_value = {
|
|
"disposable_domains_count": 100,
|
|
"blocked_emails_count": 5,
|
|
"blocked_ips_count": 2,
|
|
"default_disposable_domains_count": 130,
|
|
}
|
|
mock_get_evs.return_value = mock_evs
|
|
|
|
# Setup quota service mock
|
|
mock_quota = Mock()
|
|
mock_quota.get_quota_stats.return_value = {
|
|
"units_consumed": 900,
|
|
"units_remaining": 8600,
|
|
"units_limit": 10000,
|
|
"effective_limit": 9500,
|
|
"upload_cost": 300,
|
|
"upload_count": 3,
|
|
"estimated_uploads_remaining": 28,
|
|
"seconds_until_reset": 43200,
|
|
}
|
|
mock_quota.get_gcp_quota_usage.return_value = {"available": False}
|
|
mock_get_qs.return_value = mock_quota
|
|
|
|
# Setup queue service mock
|
|
mock_queue = Mock()
|
|
mock_queue.get_queue_stats.return_value = {
|
|
"queued": 0,
|
|
"processing": 0,
|
|
"failed": 0,
|
|
"completed": 0,
|
|
"total": 0,
|
|
}
|
|
mock_get_uqs.return_value = mock_queue
|
|
|
|
response = client.get(
|
|
"/api/admin/rate-limits/stats",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["jobs_per_day_limit"] == 5
|
|
assert data["rate_limiting_enabled"] is True
|
|
assert data["youtube_uploads_today"] == 3
|
|
assert data["disposable_domains_count"] == 100
|
|
assert data["total_overrides"] == 1
|
|
# Quota unit fields
|
|
assert data["youtube_quota_units_consumed"] == 900
|
|
assert data["youtube_quota_units_remaining"] == 8600
|
|
assert data["youtube_quota_daily_limit"] == 10000
|
|
assert data["youtube_quota_effective_limit"] == 9500
|
|
assert data["youtube_quota_upload_cost"] == 300
|
|
assert data["youtube_quota_estimated_uploads_remaining"] == 28
|
|
# Queue fields
|
|
assert data["youtube_uploads_queued"] == 0
|
|
assert data["youtube_uploads_failed"] == 0
|
|
# GCP quota (unavailable in this test)
|
|
assert data["gcp_quota_available"] is False
|
|
# Removed fields should not be present
|
|
assert "youtube_uploads_per_day_limit" not in data
|
|
assert "beta_ip_per_day_limit" not in data
|
|
assert "youtube_uploads_remaining" not in data
|
|
|
|
|
|
class TestGetUserRateLimitStatus:
|
|
"""Tests for GET /api/admin/rate-limits/users/{email} endpoint."""
|
|
|
|
def test_returns_user_status(self, client, mock_settings):
|
|
"""Test successful user status retrieval."""
|
|
with patch('backend.api.routes.rate_limits.get_rate_limit_service') as mock_get_rls, \
|
|
patch('backend.api.routes.rate_limits.settings', mock_settings):
|
|
|
|
mock_rls = Mock()
|
|
mock_rls.get_user_job_count_today.return_value = 2
|
|
mock_rls.get_user_override.return_value = None
|
|
mock_get_rls.return_value = mock_rls
|
|
|
|
response = client.get(
|
|
"/api/admin/rate-limits/users/user@example.com",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["email"] == "user@example.com"
|
|
assert data["jobs_today"] == 2
|
|
assert data["jobs_limit"] == 5
|
|
assert data["jobs_remaining"] == 3
|
|
assert data["has_bypass"] is False
|
|
|
|
def test_returns_user_with_bypass(self, client, mock_settings):
|
|
"""Test user with bypass override."""
|
|
with patch('backend.api.routes.rate_limits.get_rate_limit_service') as mock_get_rls, \
|
|
patch('backend.api.routes.rate_limits.settings', mock_settings):
|
|
|
|
mock_rls = Mock()
|
|
mock_rls.get_user_job_count_today.return_value = 10
|
|
mock_rls.get_user_override.return_value = {
|
|
"bypass_job_limit": True,
|
|
"reason": "VIP user"
|
|
}
|
|
mock_get_rls.return_value = mock_rls
|
|
|
|
response = client.get(
|
|
"/api/admin/rate-limits/users/vip@example.com",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["has_bypass"] is True
|
|
assert data["bypass_reason"] == "VIP user"
|
|
assert data["jobs_remaining"] == -1 # Unlimited
|
|
|
|
|
|
class TestBlocklistEndpoints:
|
|
"""Tests for blocklist management endpoints."""
|
|
|
|
def test_get_blocklists(self, client):
|
|
"""Test getting all blocklists."""
|
|
with patch('backend.api.routes.rate_limits.get_email_validation_service') as mock_get_evs, \
|
|
patch('backend.services.firestore_service.get_firestore_client') as mock_get_db:
|
|
|
|
mock_evs = Mock()
|
|
mock_evs.get_blocklist_config.return_value = {
|
|
"disposable_domains": {"tempmail.com", "mailinator.com"},
|
|
"blocked_emails": {"spammer@example.com"},
|
|
"blocked_ips": {"192.168.1.100"},
|
|
}
|
|
mock_get_evs.return_value = mock_evs
|
|
|
|
# Mock Firestore for metadata
|
|
mock_db = Mock()
|
|
mock_doc = Mock()
|
|
mock_doc.exists = True
|
|
mock_doc.to_dict.return_value = {
|
|
"updated_at": datetime.now(timezone.utc),
|
|
"updated_by": "admin@example.com"
|
|
}
|
|
mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
|
|
mock_get_db.return_value = mock_db
|
|
|
|
response = client.get(
|
|
"/api/admin/rate-limits/blocklists",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert "tempmail.com" in data["disposable_domains"]
|
|
assert "spammer@example.com" in data["blocked_emails"]
|
|
|
|
def test_add_disposable_domain(self, client):
|
|
"""Test adding a disposable domain."""
|
|
with patch('backend.api.routes.rate_limits.get_email_validation_service') as mock_get_evs:
|
|
|
|
mock_evs = Mock()
|
|
mock_evs.add_disposable_domain.return_value = True
|
|
mock_get_evs.return_value = mock_evs
|
|
|
|
response = client.post(
|
|
"/api/admin/rate-limits/blocklists/disposable-domains",
|
|
json={"domain": "newtemp.com"},
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["success"] is True
|
|
mock_evs.add_disposable_domain.assert_called_once_with("newtemp.com", "admin@example.com")
|
|
|
|
def test_add_disposable_domain_invalid(self, client):
|
|
"""Test adding invalid domain."""
|
|
response = client.post(
|
|
"/api/admin/rate-limits/blocklists/disposable-domains",
|
|
json={"domain": "invalid"}, # No dot
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 400
|
|
|
|
def test_remove_disposable_domain(self, client):
|
|
"""Test removing a disposable domain."""
|
|
with patch('backend.api.routes.rate_limits.get_email_validation_service') as mock_get_evs:
|
|
|
|
mock_evs = Mock()
|
|
mock_evs.remove_disposable_domain.return_value = True
|
|
mock_get_evs.return_value = mock_evs
|
|
|
|
response = client.delete(
|
|
"/api/admin/rate-limits/blocklists/disposable-domains/tempmail.com",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
mock_evs.remove_disposable_domain.assert_called_once()
|
|
|
|
def test_remove_disposable_domain_not_found(self, client):
|
|
"""Test removing non-existent domain."""
|
|
with patch('backend.api.routes.rate_limits.get_email_validation_service') as mock_get_evs:
|
|
|
|
mock_evs = Mock()
|
|
mock_evs.remove_disposable_domain.return_value = False
|
|
mock_get_evs.return_value = mock_evs
|
|
|
|
response = client.delete(
|
|
"/api/admin/rate-limits/blocklists/disposable-domains/notfound.com",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 404
|
|
|
|
def test_add_blocked_email(self, client):
|
|
"""Test adding a blocked email."""
|
|
with patch('backend.api.routes.rate_limits.get_email_validation_service') as mock_get_evs:
|
|
|
|
mock_evs = Mock()
|
|
mock_evs.add_blocked_email.return_value = True
|
|
mock_get_evs.return_value = mock_evs
|
|
|
|
response = client.post(
|
|
"/api/admin/rate-limits/blocklists/blocked-emails",
|
|
json={"email": "spammer@example.com"},
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
def test_add_blocked_ip(self, client):
|
|
"""Test adding a blocked IP."""
|
|
with patch('backend.api.routes.rate_limits.get_email_validation_service') as mock_get_evs:
|
|
|
|
mock_evs = Mock()
|
|
mock_evs.add_blocked_ip.return_value = True
|
|
mock_get_evs.return_value = mock_evs
|
|
|
|
response = client.post(
|
|
"/api/admin/rate-limits/blocklists/blocked-ips",
|
|
json={"ip_address": "192.168.1.100"},
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
|
|
class TestUserOverrideEndpoints:
|
|
"""Tests for user override management endpoints."""
|
|
|
|
def test_get_all_overrides(self, client):
|
|
"""Test getting all user overrides."""
|
|
with patch('backend.api.routes.rate_limits.get_rate_limit_service') as mock_get_rls:
|
|
|
|
mock_rls = Mock()
|
|
mock_rls.get_all_overrides.return_value = {
|
|
"vip@example.com": {
|
|
"bypass_job_limit": True,
|
|
"custom_daily_job_limit": None,
|
|
"reason": "VIP user",
|
|
"created_by": "admin@example.com",
|
|
"created_at": datetime.now(timezone.utc),
|
|
}
|
|
}
|
|
mock_get_rls.return_value = mock_rls
|
|
|
|
response = client.get(
|
|
"/api/admin/rate-limits/overrides",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["total"] == 1
|
|
assert len(data["overrides"]) == 1
|
|
assert data["overrides"][0]["email"] == "vip@example.com"
|
|
|
|
def test_set_user_override(self, client):
|
|
"""Test setting a user override."""
|
|
with patch('backend.api.routes.rate_limits.get_rate_limit_service') as mock_get_rls:
|
|
|
|
mock_rls = Mock()
|
|
mock_get_rls.return_value = mock_rls
|
|
|
|
response = client.put(
|
|
"/api/admin/rate-limits/overrides/user@example.com",
|
|
json={
|
|
"bypass_job_limit": True,
|
|
"reason": "Special access granted"
|
|
},
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
mock_rls.set_user_override.assert_called_once_with(
|
|
user_email="user@example.com",
|
|
bypass_job_limit=True,
|
|
custom_daily_job_limit=None,
|
|
reason="Special access granted",
|
|
admin_email="admin@example.com",
|
|
)
|
|
|
|
def test_set_user_override_with_custom_limit(self, client):
|
|
"""Test setting a user override with custom limit."""
|
|
with patch('backend.api.routes.rate_limits.get_rate_limit_service') as mock_get_rls:
|
|
|
|
mock_rls = Mock()
|
|
mock_get_rls.return_value = mock_rls
|
|
|
|
response = client.put(
|
|
"/api/admin/rate-limits/overrides/user@example.com",
|
|
json={
|
|
"bypass_job_limit": False,
|
|
"custom_daily_job_limit": 20,
|
|
"reason": "High volume user"
|
|
},
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
mock_rls.set_user_override.assert_called_once()
|
|
|
|
def test_set_user_override_missing_reason(self, client):
|
|
"""Test setting override without reason fails."""
|
|
response = client.put(
|
|
"/api/admin/rate-limits/overrides/user@example.com",
|
|
json={
|
|
"bypass_job_limit": True,
|
|
"reason": "ab" # Too short
|
|
},
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 400
|
|
|
|
def test_remove_user_override(self, client):
|
|
"""Test removing a user override."""
|
|
with patch('backend.api.routes.rate_limits.get_rate_limit_service') as mock_get_rls:
|
|
|
|
mock_rls = Mock()
|
|
mock_rls.remove_user_override.return_value = True
|
|
mock_get_rls.return_value = mock_rls
|
|
|
|
response = client.delete(
|
|
"/api/admin/rate-limits/overrides/user@example.com",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
|
|
def test_remove_user_override_not_found(self, client):
|
|
"""Test removing non-existent override."""
|
|
with patch('backend.api.routes.rate_limits.get_rate_limit_service') as mock_get_rls:
|
|
|
|
mock_rls = Mock()
|
|
mock_rls.remove_user_override.return_value = False
|
|
mock_get_rls.return_value = mock_rls
|
|
|
|
response = client.delete(
|
|
"/api/admin/rate-limits/overrides/notfound@example.com",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 404
|
|
|
|
|
|
class TestYouTubeQueueEndpoints:
|
|
"""Tests for YouTube upload queue management endpoints."""
|
|
|
|
def test_get_youtube_queue(self, client):
|
|
"""Test getting YouTube queue entries."""
|
|
with patch('backend.services.youtube_upload_queue_service.get_youtube_upload_queue_service') as mock_get_qs:
|
|
|
|
mock_qs = Mock()
|
|
mock_qs.get_all_queue_entries.return_value = [
|
|
{
|
|
"job_id": "job-123",
|
|
"status": "queued",
|
|
"reason": "quota_exceeded",
|
|
"user_email": "user@example.com",
|
|
"artist": "Test Artist",
|
|
"title": "Test Song",
|
|
"brand_code": "NOMAD-100",
|
|
"queued_at": "2026-03-03T10:00:00",
|
|
"attempts": 0,
|
|
"max_attempts": 5,
|
|
"last_error": None,
|
|
"youtube_url": None,
|
|
"notification_sent": False,
|
|
}
|
|
]
|
|
mock_qs.get_queue_stats.return_value = {
|
|
"queued": 1,
|
|
"processing": 0,
|
|
"failed": 0,
|
|
"completed": 5,
|
|
"total": 6,
|
|
}
|
|
mock_get_qs.return_value = mock_qs
|
|
|
|
response = client.get(
|
|
"/api/admin/rate-limits/youtube-queue",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert len(data["entries"]) == 1
|
|
assert data["entries"][0]["job_id"] == "job-123"
|
|
assert data["entries"][0]["status"] == "queued"
|
|
assert data["stats"]["queued"] == 1
|
|
assert data["stats"]["total"] == 6
|
|
|
|
def test_retry_youtube_upload_success(self, client):
|
|
"""Test retrying a failed YouTube upload."""
|
|
with patch('backend.services.youtube_upload_queue_service.get_youtube_upload_queue_service') as mock_get_qs:
|
|
|
|
mock_qs = Mock()
|
|
mock_qs.retry_upload.return_value = True
|
|
mock_get_qs.return_value = mock_qs
|
|
|
|
response = client.post(
|
|
"/api/admin/rate-limits/youtube-queue/job-123/retry",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["success"] is True
|
|
mock_qs.retry_upload.assert_called_once_with("job-123")
|
|
|
|
def test_retry_youtube_upload_not_found(self, client):
|
|
"""Test retrying a non-existent or non-retryable upload."""
|
|
with patch('backend.services.youtube_upload_queue_service.get_youtube_upload_queue_service') as mock_get_qs:
|
|
|
|
mock_qs = Mock()
|
|
mock_qs.retry_upload.return_value = False
|
|
mock_get_qs.return_value = mock_qs
|
|
|
|
response = client.post(
|
|
"/api/admin/rate-limits/youtube-queue/nonexistent/retry",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 404
|
|
|
|
def test_trigger_queue_processing(self, client):
|
|
"""Test manually triggering queue processing."""
|
|
response = client.post(
|
|
"/api/admin/rate-limits/youtube-queue/process",
|
|
headers={"Authorization": "Bearer admin-token"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["success"] is True
|
|
assert "background" in data["message"].lower()
|