 NewsletterSubscriber:
+ return NewsletterSubscriber.objects.create(
+ email='leitor@example.com',
+ is_active=True,
+ )
+
+
+def test_send_welcome_returns_true_on_success(subscriber):
+ """Caminho feliz: SMTP entrega → retorna True."""
+ with patch(
+ 'apps.newsletter.services.EmailMultiAlternatives.send',
+ return_value=1,
+ ) as mock_send:
+ assert send_welcome(subscriber) is True
+ # Confirma que fail_silently=False (queremos que erros propaguem)
+ mock_send.assert_called_once_with(fail_silently=False)
+
+
+def test_send_welcome_propagates_smtp_error_to_caller(subscriber):
+ """Fix BUG-2: falha SMTP deve propagar para o Celery autoretry pegar.
+
+ Antes: try/except Exception engolia tudo e retornava False, matando
+ o autoretry_for=(Exception,) do wrapper task `send_welcome_email`.
+ Agora: exceção escapa, Celery faz retry conforme política.
+ """
+ from smtplib import SMTPServerDisconnected
+
+ with patch(
+ 'apps.newsletter.services.EmailMultiAlternatives.send',
+ side_effect=SMTPServerDisconnected('Connection unexpectedly closed'),
+ ):
+ with pytest.raises(SMTPServerDisconnected):
+ send_welcome(subscriber)
+
+
+def test_send_welcome_propagates_generic_exception(subscriber):
+ """Defesa em profundidade: qualquer Exception propaga (não só SMTP)."""
+ with patch(
+ 'apps.newsletter.services.render_to_string',
+ side_effect=RuntimeError('template malformado'),
+ ):
+ with pytest.raises(RuntimeError, match='template malformado'):
+ send_welcome(subscriber)
+
+
+# ── BUG-1: cover URL absoluta em article notification (CONCERNS / F-40) ──────
+
+
+@pytest.fixture
+def category(db):
+ """Pega a primeira Category disponível (seeded em migration 0003).
+
+ Migration 0003 cria 5 categorias com slugify(name, allow_unicode=True).
+ Música vira slug 'música' (não 'musica'), por isso buscamos por nome.
+ """
+ from apps.articles.models import Category
+ return Category.objects.get(name='Música')
+
+
+@pytest.fixture
+def author(db):
+ from django.contrib.auth import get_user_model
+ User = get_user_model()
+ return User.objects.create_user(
+ username='autora',
+ email='autora@interpop.com',
+ password='S3nh@Forte!2026',
+ )
+
+
+@pytest.fixture
+def article_with_cover(db, category, author):
+ """Article com cover_image simulada (sem subir arquivo real)."""
+ from apps.articles.models import Article
+ from django.utils import timezone
+ from django.core.files.uploadedfile import SimpleUploadedFile
+
+ article = Article.objects.create(
+ title='K-pop como Soft Power',
+ slug='kpop-como-soft-power',
+ excerpt='Análise editorial sobre Soft Power asiático.',
+ body='Corpo do artigo.',
+ author=author,
+ category=category,
+ status='published',
+ published_at=timezone.now(),
+ )
+ article.cover_image = SimpleUploadedFile(
+ 'cover.jpg',
+ b'\xff\xd8\xff\xe0fake-jpeg',
+ content_type='image/jpeg',
+ )
+ article.save()
+ return article
+
+
+def test_article_notification_uses_absolute_cover_url(
+ subscriber, article_with_cover, settings
+):
+ """Fix BUG-1: cover_image em email deve ser URL ABSOLUTA com SITE_URL.
+
+ Antes do fix: template usava `{{ article.cover_image.url }}` direto, que
+ retorna `/media/articles/cover.jpg` (caminho relativo, MEDIA_URL Django).
+ Clientes de email NÃO resolvem caminhos relativos contra base — todos os
+ subscribers viam placeholder broken-image em TODA notificação.
+
+ Após fix: ctx do service tem `cover_image_absolute_url` = SITE_URL +
+ .url. Template usa essa var.
+ """
+ settings.SITE_URL = 'https://interpop.com'
+
+ from apps.newsletter.services import _dispatch_article_notification_sync
+
+ with patch(
+ 'apps.newsletter.services.EmailMultiAlternatives'
+ ) as mock_msg_cls:
+ mock_msg = mock_msg_cls.return_value
+ sent, failed = _dispatch_article_notification_sync(
+ article_with_cover, subscribers=[subscriber],
+ )
+
+ assert sent == 1 and failed == 0
+
+ # Captura o HTML attached para verificar a URL absoluta
+ attach_calls = mock_msg.attach_alternative.call_args_list
+ assert attach_calls, 'esperado attach_alternative chamado'
+ html_body = attach_calls[0][0][0]
+
+ assert 'https://interpop.com/media/' in html_body or (
+ f'https://interpop.com{article_with_cover.cover_image.url}' in html_body
+ ), (
+ f'cover_image deve aparecer com URL absoluta no email. '
+ f'HTML render: {html_body[:500]}'
+ )
+ # E NÃO deve aparecer URL relativa começando com /media/ sem host
+ relative_marker = f'src="{article_with_cover.cover_image.url}"'
+ assert relative_marker not in html_body, (
+ f'cover_image NÃO deve estar como URL relativa. Found: {relative_marker}'
+ )
diff --git a/backend/apps/search/tests/test_settings_production.py b/backend/apps/search/tests/test_settings_production.py
index 9ae5f097..85e64be4 100644
--- a/backend/apps/search/tests/test_settings_production.py
+++ b/backend/apps/search/tests/test_settings_production.py
@@ -55,7 +55,11 @@ def _run_settings_load(env: dict[str, str]) -> subprocess.CompletedProcess:
def _base_env() -> dict[str, str]:
- """Env mínima para `production.py` carregar sem outros erros."""
+ """Env mínima para `production.py` carregar sem outros erros.
+
+ Inclui `JWT_SIGNING_KEY` distinta de `SECRET_KEY` para não disparar o
+ guard S-02 acidentalmente (cada arquivo testa SEU próprio guard).
+ """
return {
**os.environ,
'DJANGO_SETTINGS_MODULE': 'config.settings.production',
@@ -69,6 +73,7 @@ def _base_env() -> dict[str, str]:
'EMAIL_HOST': 'smtp.example.com',
'EMAIL_HOST_USER': 'u',
'EMAIL_HOST_PASSWORD': 'p',
+ 'JWT_SIGNING_KEY': 'distinct-jwt-signing-key-not-secret-key-cafefeed',
}
diff --git a/backend/apps/users/tests/test_settings_production.py b/backend/apps/users/tests/test_settings_production.py
new file mode 100644
index 00000000..0d7c8b02
--- /dev/null
+++ b/backend/apps/users/tests/test_settings_production.py
@@ -0,0 +1,123 @@
+"""Production settings guards para `users-auth` (fix S-02 do CONCERNS).
+
+Por que existe: `base.py:150` deixa `SIGNING_KEY` cair em `SECRET_KEY`
+como fallback (conveniente em dev). `production.py` precisa recusar essa
+configuração — leak de `SECRET_KEY` (via dump, traceback ou dependência
+comprometida) compromete sessão **e** JWT simultaneamente, permitindo
+forja de access token e impersonação total.
+
+Réplica do padrão F2-B-03 (`apps.search.tests.test_settings_production`)
+que já endureceu `SEARCH_CURSOR_HMAC_SECRET`. Mesmo vetor, mesma
+mitigação.
+
+Estratégia de teste: importação dinâmica de `config.settings.production`
+em subprocess isolado, capturando `ImproperlyConfigured`. Necessário
+porque settings já está carregado pela sessão pytest atual e
+`importlib.reload` quebra apps.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+
+# Backend root = …/interpop/backend (contém manage.py + config/).
+_BACKEND_ROOT = Path(__file__).resolve().parents[3]
+
+
+def _run_settings_load(env: dict[str, str]) -> subprocess.CompletedProcess:
+ """Carrega `config.settings.production` num Python isolado."""
+ script = textwrap.dedent(
+ """
+ import os, django
+ from django.core.exceptions import ImproperlyConfigured
+ os.environ['DJANGO_SETTINGS_MODULE'] = 'config.settings.production'
+ try:
+ django.setup()
+ except ImproperlyConfigured as exc:
+ print('IMPROPER:' + str(exc))
+ raise SystemExit(2)
+ except Exception as exc: # noqa: BLE001
+ print('OTHER:' + repr(exc))
+ raise SystemExit(3)
+ print('OK')
+ """
+ )
+ return subprocess.run(
+ [sys.executable, '-c', script],
+ capture_output=True,
+ text=True,
+ env=env,
+ cwd=str(_BACKEND_ROOT),
+ timeout=30,
+ )
+
+
+def _base_env() -> dict[str, str]:
+ """Env mínima para `production.py` carregar — inclui HMAC secret válida
+ (testes do JWT não devem disparar o guard do F2-B-03 acidentalmente)."""
+ return {
+ **os.environ,
+ 'DJANGO_SETTINGS_MODULE': 'config.settings.production',
+ 'SECRET_KEY': 'test-secret-key-not-real-prod',
+ 'ALLOWED_HOSTS': 'interpop.com',
+ 'CORS_ALLOWED_ORIGINS': 'https://interpop.com',
+ 'CSRF_TRUSTED_ORIGINS': 'https://interpop.com',
+ 'DB_NAME': 'interpop',
+ 'DB_USER': 'interpop',
+ 'DB_PASSWORD': 'x',
+ 'EMAIL_HOST': 'smtp.example.com',
+ 'EMAIL_HOST_USER': 'u',
+ 'EMAIL_HOST_PASSWORD': 'p',
+ 'SEARCH_CURSOR_HMAC_SECRET': 'distinct-hmac-secret-not-secret-key-deadbeef',
+ }
+
+
+def test_production_settings_reject_jwt_signing_key_equal_to_secret_key():
+ """JWT_SIGNING_KEY == SECRET_KEY → ImproperlyConfigured (S-02)."""
+ env = _base_env()
+ # NÃO setamos JWT_SIGNING_KEY → fallback p/ SECRET_KEY (default em base.py:150).
+ env.pop('JWT_SIGNING_KEY', None)
+
+ result = _run_settings_load(env)
+ assert result.returncode == 2, (
+ f"Esperado SystemExit(2) (ImproperlyConfigured). "
+ f"Got rc={result.returncode}\nstdout={result.stdout}\nstderr={result.stderr}"
+ )
+ assert 'JWT_SIGNING_KEY' in result.stdout, (
+ f'Mensagem de erro deve citar JWT_SIGNING_KEY. stdout={result.stdout!r}'
+ )
+ assert 'S-02' in result.stdout, (
+ f'Mensagem de erro deve referenciar o achado S-02 para rastreabilidade. '
+ f'stdout={result.stdout!r}'
+ )
+
+
+def test_production_settings_reject_empty_jwt_signing_key():
+ """JWT_SIGNING_KEY vazio → ImproperlyConfigured (cai no default=SECRET_KEY)."""
+ env = _base_env()
+ env['JWT_SIGNING_KEY'] = ''
+
+ result = _run_settings_load(env)
+ assert result.returncode == 2, (
+ f"Esperado ImproperlyConfigured para JWT_SIGNING_KEY vazia. "
+ f"rc={result.returncode}\nstdout={result.stdout}\nstderr={result.stderr}"
+ )
+
+
+def test_production_settings_accept_distinct_jwt_signing_key():
+ """JWT_SIGNING_KEY distinta de SECRET_KEY → load sucesso."""
+ env = _base_env()
+ env['JWT_SIGNING_KEY'] = (
+ 'distinct-prod-jwt-signing-key-not-same-as-secret-key-cafefeed'
+ )
+
+ result = _run_settings_load(env)
+ assert result.returncode == 0, (
+ f'Esperado rc=0 com JWT_SIGNING_KEY válida distinta de SECRET_KEY. '
+ f'rc={result.returncode}\nstdout={result.stdout}\nstderr={result.stderr}'
+ )
+ assert 'OK' in result.stdout
diff --git a/backend/config/settings/base.py b/backend/config/settings/base.py
index 9359f09b..4512488e 100644
--- a/backend/config/settings/base.py
+++ b/backend/config/settings/base.py
@@ -194,6 +194,12 @@
'anon': '100/hour',
'user': '1000/hour',
'auth': '10/minute',
+ # S-07 (CONCERNS / F-20): anti-flood em POST /comments/.
+ # 'user'=1000/hour é alto demais para anti-flood imediato em artigo
+ # viral. Scope dedicado via ScopedRateThrottle aplicado SÓ em POST
+ # (GET list permanece ilimitado). Limite generoso para legítimo
+ # (1 a cada 6s), agressivo contra abuso (bot ultrapassa em segundos).
+ 'comments_create': '10/minute',
},
}
diff --git a/backend/config/settings/development.py b/backend/config/settings/development.py
index 02e15878..8bb7f10a 100644
--- a/backend/config/settings/development.py
+++ b/backend/config/settings/development.py
@@ -70,5 +70,9 @@
'search_anon': '10000/hour',
'search_user': '10000/hour',
'search_global': '20000/hour',
+ # S-07 (CONCERNS / F-20): scope dedicado anti-flood em POST /comments/.
+ # Em prod: 10/min (base.py). Em dev: relaxa para smoke manual sem 429
+ # — TESTES de throttle sobrescrevem com settings fixture.
+ 'comments_create': '10000/hour',
},
}
diff --git a/backend/config/settings/production.py b/backend/config/settings/production.py
index 4553dbe3..b55ed2bc 100644
--- a/backend/config/settings/production.py
+++ b/backend/config/settings/production.py
@@ -3,7 +3,7 @@
from decouple import Csv, config
from .base import * # noqa: F401, F403
-from .base import SECRET_KEY, SEARCH_CURSOR_HMAC_SECRET
+from .base import SECRET_KEY, SEARCH_CURSOR_HMAC_SECRET, SIMPLE_JWT
from apps.audit.sentry import init_sentry
DEBUG = False
@@ -22,6 +22,24 @@
'Gere com `python -c "import secrets; print(secrets.token_urlsafe(48))"`.'
)
+# ── Fix S-02 (CONCERNS / RF-005) — JWT signing key hard-fail em prod ─────────
+# Mesma família que F2-B-03 acima: `base.py:150` deixa `SIGNING_KEY` cair em
+# `SECRET_KEY` como fallback (conveniente em dev). Em produção isso é vetor
+# crítico — leak de `SECRET_KEY` compromete sessão **e** JWT simultaneamente,
+# permitindo forja de access token e impersonação total (incluindo de roles
+# `dev`, que é imune a ban por design). Defesa em profundidade exige duas
+# chaves distintas: comprometer uma não compromete a outra. Hard-fail força
+# o operador a setar `JWT_SIGNING_KEY` distinta antes de subir produção.
+_JWT_SIGNING_KEY = SIMPLE_JWT.get('SIGNING_KEY')
+if not _JWT_SIGNING_KEY or _JWT_SIGNING_KEY == SECRET_KEY:
+ raise ImproperlyConfigured(
+ 'JWT_SIGNING_KEY deve estar setada em produção e ser distinta de '
+ 'SECRET_KEY (vetor S-02 do CONCERNS). Comprometer uma chave não '
+ 'pode comprometer a outra — defesa em profundidade. Gere com '
+ '`python -c "import secrets; print(secrets.token_urlsafe(50))"`.'
+ )
+del _JWT_SIGNING_KEY
+
# Sentry — no-op silencioso se SENTRY_DSN não estiver no env.
# Em prod real: DSN setado, traces 10%, releases taggadas via GIT_SHA.
init_sentry(environment='production')
|