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>
135 lines
5.4 KiB
Python
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"{}")
|