Files
CenaForge/publisher/tests/conftest.py
T
MateuusandClaude Opus 5.5 84f30bbc2d CenaForge: primeira versão pública
Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 16:35:09 -03:00

135 lines
5.4 KiB
Python

"""Fixtures dos testes do Publicador: tudo em tmp_path, cofre com cifrador falso, rede simulada (httpx.MockTransport)
e navegador falso. Nenhum teste abre navegador nem fala com a internet."""
from __future__ import annotations
import json
from pathlib import Path
from typing import Callable
import httpx
import pytest
from fastapi.testclient import TestClient
from app.config import Settings
from app.db import Database
from app.main import create_app
from app.platforms.base import PublishResult
from app.platforms.session.browser import BrowserInfo, BrowserManager
from app.service import Publisher
from app.vault import Vault
from app.worker import Worker
KEY = "k" * 40
class FakeCipher:
"""Inverte e marca os bytes: suficiente para provar que o arquivo não fica em texto puro."""
def protect(self, data: bytes) -> bytes:
return b"FAKE" + data[::-1]
def unprotect(self, data: bytes) -> bytes:
assert data.startswith(b"FAKE")
return data[4:][::-1]
class Router:
"""Rede simulada: registra handlers por (método, prefixo da URL) e guarda todas as requisições."""
def __init__(self) -> None:
self.routes: list[tuple[str, str, Callable[[httpx.Request], httpx.Response]]] = []
self.requests: list[httpx.Request] = []
def add(self, method: str, prefix: str, handler: Callable[[httpx.Request], httpx.Response] | dict | list) -> None:
if not callable(handler):
payload = handler
handler = lambda _req, payload=payload: httpx.Response(200, json=payload) # noqa: E731
self.routes.insert(0, (method, prefix, handler))
def __call__(self, request: httpx.Request) -> httpx.Response:
request.read()
self.requests.append(request)
url = str(request.url)
for method, prefix, handler in self.routes:
if request.method == method and url.startswith(prefix):
return handler(request)
return httpx.Response(599, json={"error": f"rota não simulada: {request.method} {url}"})
def find(self, method: str, prefix: str) -> list[httpx.Request]:
return [r for r in self.requests if r.method == method and str(r.url).startswith(prefix)]
class FakeRunner:
"""Substitui o SessionRunner (Playwright) nos testes."""
def __init__(self) -> None:
self.opened: list[tuple[str, str]] = []
self.check_reason: str | None = None
self.result = PublishResult(None, None, False, "Publicado (sessão); link não encontrado na tela")
self.error: Exception | None = None
def open_for_login(self, profile_id: str, platform: str) -> None:
self.opened.append((profile_id, platform))
def check(self, profile_id: str, platform: str) -> str | None:
return self.check_reason
def publish(self, spec, progress):
progress("Enviando pelo navegador…", 0.5)
if self.error:
raise self.error
return self.result
class Env:
def __init__(self, tmp_path: Path):
self.root = tmp_path / "repo"
self.root.mkdir()
self.settings = Settings.load(env_file=tmp_path / "none.env", service_key=KEY,
data_dir=self.root / "data" / "publisher", repo_root=self.root)
self.router = Router()
self.http = httpx.Client(transport=httpx.MockTransport(self.router))
self.db = Database(self.settings.db_path)
self.vault = Vault(self.settings.vault_path, cipher=FakeCipher())
self.runner = FakeRunner()
self.sleeps: list[float] = []
browsers = BrowserManager(self.settings.browser_dir, BrowserInfo("chrome", "C:/fake/chrome.exe"))
self.publisher = Publisher(self.settings, self.db, self.vault, http=self.http, browsers=browsers,
runner=self.runner, sleep=self.sleeps.append, # type: ignore[arg-type]
detect=lambda: BrowserInfo("chrome", "C:/fake/chrome.exe"))
self.worker = Worker(self.db, self.publisher.execute)
self.app = create_app(self.settings, self.publisher, start_worker=False, worker=self.worker)
self.client = TestClient(self.app, headers={"X-Service-Key": KEY})
def video(self, name: str = "clip.mp4", size: int = 1000) -> Path:
path = self.root / "output" / name
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(bytes(range(256)) * (size // 256) + b"x" * (size % 256))
return path
def connect_profile(self, profile_id: str, mode: str = "official", secret: dict | None = None, **fields) -> None:
platform = profile_id.rsplit("--", 1)[1]
self.publisher._update(profile_id, mode=mode, status="connected", connected_at="2026-11-17T00:00:00Z", **fields)
if secret is not None:
self.vault.set(f"token:{profile_id}", secret)
assert platform
def job_body(self, profile_id: str, file: Path, **extra) -> dict:
body = {"profileId": profile_id, "platform": profile_id.rsplit("--", 1)[1], "file": str(file), "cover": None,
"title": "Meu vídeo", "caption": "Legenda #cortes", "tags": ["cortes", "live"], "privacy": "public",
"publishAt": None, "aiGenerated": False, "madeForKids": False, "tiktokMode": "direct"}
body.update(extra)
return body
@pytest.fixture
def env(tmp_path):
e = Env(tmp_path)
yield e
e.db.close()
def json_body(request: httpx.Request) -> dict:
return json.loads(request.content or b"{}")