"""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"{}")