Files
CenaForge/panel/src/lib/publishing-db.test.ts
T
MateuusandClaude Opus 5.5 f165659e4e Painel: ordenar fila de cortes, horário específico ao publicar e capas preservadas
Clipador (fila de cortes)
- Seletor "Ordenar": mais novos, mais antigos, maior/menor nota da IA, sinal
  mais forte e mais longos; a escolha fica lembrada no navegador.
- A fila abre filtrada pela sessão que está gravando.
- Gancho automático logo abaixo da câmera e legenda desviada enquanto o gancho
  a cobriria; posição do gancho editável no painel.

Publicação
- "Publicar este corte" ganha "Horário específico": um dia e hora para todas
  as redes ou um diferente por rede (timing "at" + scheduledAt por rede na rota
  POST /api/publishing/clips/[id]), com validação e testes.
- Capa do vídeo publicado copiada para output/publishing/covers/: apagar a
  sessão no Clipador não quebra mais a miniatura do dashboard; jobs antigos
  migram no ciclo de sincronização.
- Dashboard só usa capa que existe no disco; corrige a regex do número do
  episódio (link do episódio).
- Canais de publicação: seletor compacto de canais e detalhe reorganizado.
- Publicador: confirmação pela página pública quando o YouTube Studio fica com
  a caixa de envio aberta; estatísticas por rede.

Skill cenaforge 1.44.0 com as regras e a armadilha das capas.

Testes: painel 68/68, Clipador 279, Publicador 84.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 19:54:13 -03:00

440 lines
27 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Migração v5 e fluxos da fila num banco TEMPORÁRIO (CENAFORGE_ROOT aponta para uma pasta nova; o banco real
// data/cenaforge.db nunca é tocado). Monta um banco v4 com dados (perfil "mock", publicação simulada com
// métricas), abre pelo db() — que migra para v5 com backup — e exercita aprovação de episódio, publicar agora,
// cancelar, tentar de novo e o resultado do Publicador. Rodar: pnpm --filter cenaforge-panel test:panel
import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { DatabaseSync } from "node:sqlite";
import { after, before, describe, it } from "node:test";
const ROOT = fs.mkdtempSync(path.join(os.tmpdir(), "cenaforge-pub-"));
process.env.CENAFORGE_ROOT = ROOT;
type Db = typeof import("./db");
type Publishing = typeof import("./publishing");
type Accounts = typeof import("./accounts");
type Settings = typeof import("./settings");
let dbm: Db;
let pub: Publishing;
let accounts: Accounts;
let settings: Settings;
const MP4 = "output/runs/r1/ep01.mp4";
before(async () => {
dbm = await import("./db");
// Banco v4 com dados, como o do usuário antes desta versão.
fs.mkdirSync(path.join(ROOT, "data"), { recursive: true });
const raw = new DatabaseSync(path.join(ROOT, "data", "cenaforge.db"));
raw.exec("PRAGMA foreign_keys = OFF");
for (const sql of dbm.MIGRATIONS.slice(0, 4)) raw.exec(sql);
raw.exec("PRAGMA user_version = 4; PRAGMA foreign_keys = ON;");
const t = "2026-11-01T00:00:00.000Z";
raw.exec(`
INSERT INTO stories (id, title, kind, created_at, updated_at) VALUES ('litoral', 'Histórias do Litoral', 'linear', '${t}', '${t}');
INSERT INTO episodes (id, story_id, number, file_key, title, created_at) VALUES (1, 'litoral', 1, 'ep01', 'O farol', '${t}');
INSERT INTO accounts (id, name, created_at, updated_at) VALUES ('canal', 'Canal', '${t}', '${t}');
INSERT INTO account_networks (id, account_id, platform, handle, status, connected_at) VALUES (3, 'canal', 'youtube', '@canal', 'mock', '${t}');
INSERT INTO account_stories (account_id, story_id, status, linked_at) VALUES ('canal', 'litoral', 'active', '${t}');
INSERT INTO publications (id, episode_id, account_id, platform, url, published_at, simulated) VALUES (5, 1, 'canal', 'youtube', '', '${t}', 1);
INSERT INTO publication_metrics (publication_id, captured_at, views, simulated) VALUES (5, '${t}', 1234, 1);
INSERT INTO renders (id, episode_id, config_path, profile, status, mp4, started_at, finished_at)
VALUES (1, 1, 'config/litoral-ep01.json', 'final', 'success', '${MP4}', '${t}', '${t}'),
(2, 1, 'config/litoral-ep01.json', 'preview', 'success', 'output/runs/r0/ep01.mp4', '${t}', '${t}');
`);
raw.close();
fs.mkdirSync(path.join(ROOT, "output", "runs", "r1"), { recursive: true });
fs.writeFileSync(path.join(ROOT, MP4), "mp4 de teste");
pub = await import("./publishing");
accounts = await import("./accounts");
settings = await import("./settings");
});
after(() => {
dbm.db().close();
fs.rmSync(ROOT, { recursive: true, force: true });
});
describe("migração v5", () => {
it("migra com backup, preserva ids e não quebra chaves estrangeiras", () => {
const version = dbm.get<{ user_version: number }>("PRAGMA user_version")!.user_version;
assert.equal(version, dbm.MIGRATIONS.length);
assert.equal(version, 8);
assert.equal(fs.readdirSync(path.join(ROOT, "data", "backups")).filter((f) => f.startsWith("cenaforge-v4-")).length, 1);
assert.deepEqual(dbm.all("PRAGMA foreign_key_check"), []);
});
it("perfil mock vira disconnected, mantém o @ e ganha os padrões", () => {
const n = dbm.get<Record<string, unknown>>("SELECT * FROM account_networks WHERE id = 3")!;
assert.deepEqual(
[n.status, n.handle, n.mode, n.enabled, n.daily_limit, n.privacy, n.tiktok_mode, n.connected_at],
["disconnected", "@canal", null, 1, 3, "public", "direct", null]);
});
it("publicações: mesmo id, métricas ainda ligadas, episode_id aceita NULL com clip_id", () => {
const row = dbm.get<{ views: number; clip_id: number | null }>(
"SELECT m.views, p.clip_id FROM publications p JOIN publication_metrics m ON m.publication_id = p.id WHERE p.id = 5")!;
assert.deepEqual([row.views, row.clip_id], [1234, null]);
dbm.run("INSERT INTO publications (episode_id, clip_id, account_id, platform, published_at, simulated) VALUES (NULL, 99, 'canal', 'tiktok', ?, 0)", dbm.now());
assert.throws(() => dbm.run("INSERT INTO publications (episode_id, clip_id, account_id, platform, published_at) VALUES (NULL, NULL, 'canal', 'tiktok', ?)", dbm.now()));
dbm.run("DELETE FROM publications WHERE clip_id = 99");
});
it("canal com regras padrão e configurações iniciais", () => {
const a = dbm.get<Record<string, unknown>>("SELECT approval_mode, timing, ai_label FROM accounts WHERE id = 'canal'")!;
assert.deepEqual([a.approval_mode, a.timing, a.ai_label], ["manual", "best_slot", "auto"]);
const s = settings.getSettings();
assert.equal(s.publishingPaused, false);
assert.equal(s.timezone, "America/Sao_Paulo");
assert.deepEqual(s.slots.youtube, ["12:00", "15:00", "19:00"]);
});
});
describe("configurações", () => {
it("valida e grava horários bons e pausa", () => {
assert.throws(() => settings.updateSettings({ slots: { youtube: ["25:00"] } }), /HH:MM/);
assert.throws(() => settings.updateSettings({ timezone: "Lua/Base" }), /Fuso/);
const s = settings.updateSettings({ publishingPaused: true, slots: { tiktok: ["21:00", "08:00", "08:00"] } });
assert.equal(s.publishingPaused, true);
assert.deepEqual(s.slots.tiktok, ["08:00", "21:00"]);
settings.updateSettings({ publishingPaused: false });
});
});
describe("canal: regras e ajustes da rede", () => {
it("ligar o automático grava desde quando vale; desligar limpa", () => {
assert.ok(accounts.updateAccount("canal", { approvalMode: "auto" }).auto_since);
assert.equal(accounts.updateAccount("canal", { approvalMode: "manual" }).auto_since, null);
assert.throws(() => accounts.updateAccount("canal", { timing: "amanhã" }), /Quando publicar/);
});
it("ajustes por rede validados (privacidade por rede, limite 1–20)", () => {
const n = accounts.updateNetworkSettings("canal", "tiktok", { dailyLimit: 5, privacy: "private", tiktokMode: "draft" });
assert.deepEqual([n.status, n.daily_limit, n.privacy, n.tiktok_mode], ["disconnected", 5, "private", "draft"]);
assert.throws(() => accounts.updateNetworkSettings("canal", "instagram", { privacy: "unlisted" }), /Privacidade/);
assert.throws(() => accounts.updateNetworkSettings("canal", "youtube", { dailyLimit: 0 }), /1 a 20/);
});
});
describe("episódio aprovado → fila → resultado", () => {
it("exige render final (prévia não vale)", () => {
assert.throws(() => pub.approveEpisode(1, { renderId: 2, title: "O farol" }), /render final/);
assert.deepEqual(pub.episodeApproval(1).renders.map((r) => r.id), [1]);
});
it("rede nunca conectada não recebe; conectada recebe, agendada no próximo horário bom", () => {
assert.equal(pub.approveEpisode(1, { renderId: 1, title: "O farol", caption: "#litoral" }).jobs.length, 0);
dbm.run("UPDATE account_networks SET status = 'connected', mode = 'official' WHERE account_id = 'canal' AND platform = 'youtube'");
const approval = pub.approveEpisode(1, { renderId: 1, title: "O farol", caption: "#litoral" });
assert.ok(approval.approvedAt);
assert.equal(approval.jobs.length, 1);
const job = approval.jobs[0];
assert.deepEqual([job.platform, job.status, job.file, job.title, job.sourceLabel], ["youtube", "scheduled", MP4, "O farol", "Histórias do Litoral · ep01"]);
assert.ok(new Date(job.scheduledAt!).getTime() > Date.now());
assert.deepEqual(job.actions, ["publish-now", "reschedule", "edit", "cancel"]);
});
it("publicar agora, cancelar, tentar de novo (volta a aguardar) e aprovar", async () => {
const id = pub.listJobs({ sourceKind: "episode" })[0].id;
assert.equal((await pub.publishNow(id)).status, "queued");
assert.equal((await pub.cancelPublishJob(id)).status, "canceled");
assert.equal(pub.retryJob(id).status, "awaiting_approval");
assert.equal((await pub.approveJob(id)).status, "scheduled");
assert.equal(pub.publishingSummary().counts.scheduled, 1);
});
it("mudar horário à mão e título", () => {
const id = pub.listJobs({ sourceKind: "episode" })[0].id;
const at = new Date(Date.now() + 3 * 86_400_000).toISOString();
const job = pub.updateJob(id, { scheduledAt: at, title: "O farol — parte 1" });
assert.deepEqual([job.status, job.scheduledAt, job.title], ["scheduled", at, "O farol — parte 1"]);
assert.throws(() => pub.updateJob(id, { scheduledAt: "2020-01-01T00:00:00Z" }), /futuro/);
assert.throws(() => pub.updateJob(id, { title: "x".repeat(101) }), /100/);
});
it("Publicador terminou sem link: falha (não diz publicado)", () => {
const row = dbm.get<import("./publishing").JobRow>("SELECT * FROM publish_jobs WHERE source_kind = 'episode'")!;
dbm.run("UPDATE publish_jobs SET status = 'publishing', publisher_job_id = 'pj-1' WHERE id = ?", row.id);
pub.finishFromPublisher(row, { status: "done", step: "publicado; link não encontrado na tela", progress: 1, remoteId: null, url: null, draft: false, error: null });
const job = pub.getJobView(row.id)!;
assert.equal(job.status, "failed");
assert.match(job.error!, /não confirmou/);
assert.equal(dbm.get("SELECT 1 FROM publications WHERE job_id = ?", row.id), undefined);
});
it("com URL: published e publicação real substitui a simulada", () => {
const row = dbm.get<import("./publishing").JobRow>("SELECT * FROM publish_jobs WHERE source_kind = 'episode'")!;
pub.finishFromPublisher(row, { status: "done", step: "Publicado.", progress: 1, remoteId: "abc123", url: "https://youtu.be/abc123", draft: false, error: null });
const job = pub.getJobView(row.id)!;
assert.deepEqual([job.status, job.url, job.remoteId], ["published", "https://youtu.be/abc123", "abc123"]);
assert.ok(job.publishedAt);
const pubs = dbm.all<{ simulated: number; url: string; job_id: number }>("SELECT * FROM publications WHERE episode_id = 1 AND account_id = 'canal' AND platform = 'youtube'");
assert.deepEqual(pubs.map((p) => [p.simulated, p.url, p.job_id]), [[0, "https://youtu.be/abc123", row.id]]);
});
it("needs_login no envio marca o perfil", () => {
const ts = dbm.now();
const info = dbm.run(`INSERT INTO publish_jobs (account_id, platform, source_kind, source_id, file, title, status, publisher_job_id, created_at, updated_at)
VALUES ('canal', 'youtube', 'clip', '42', ?, 'Corte', 'publishing', 'pj-2', ?, ?)`, MP4, ts, ts);
const row = dbm.get<import("./publishing").JobRow>("SELECT * FROM publish_jobs WHERE id = ?", Number(info.lastInsertRowid))!;
pub.finishFromPublisher(row, { status: "needs_login", step: "", progress: 0.1, remoteId: null, url: null, draft: false, error: "Sessão expirou." });
assert.equal(pub.getJobView(row.id)!.status, "needs_login");
assert.equal(accounts.getNetwork("canal", "youtube")!.status, "needs_login");
});
it("desfazer a aprovação cancela o que não saiu e mantém o publicado", async () => {
dbm.run("INSERT INTO account_networks (account_id, platform, status, mode) VALUES ('canal', 'instagram', 'connected', 'session')");
const approval = pub.approveEpisode(1, { renderId: 1, title: "O farol", caption: "" });
const insta = approval.jobs.find((j) => j.platform === "instagram")!;
assert.equal(insta.status, "scheduled");
const after = await pub.unapproveEpisode(1);
assert.equal(after.approvedAt, null);
assert.equal(after.jobs.find((j) => j.platform === "instagram")!.status, "canceled");
assert.equal(after.jobs.find((j) => j.platform === "youtube")!.status, "published");
});
});
// ---------- despachante com um Publicador falso (fetch simulado; nenhuma porta aberta) ----------
type FakeCall = { method: string; path: string; body: Record<string, unknown> | null };
describe("despachante: corridas, clientRef e vínculos (ALTOS)", () => {
const calls: FakeCall[] = [];
let onCreate: (body: Record<string, unknown>) => Promise<Response> = async () => { throw new Error("sem roteiro"); };
let realFetch: typeof fetch;
const json = (body: unknown, status = 200) => new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
const remoteJob = (jobId: string, status = "queued") => ({
jobId, profileId: "canal--youtube", platform: "youtube", status, step: "Na fila do Publicador.", progress: 0,
remoteId: null, url: null, draft: false, error: null, createdAt: dbm.now(), updatedAt: dbm.now(),
});
const profile = (profileId: string) => ({
profileId, platform: profileId.split("--")[1], mode: "official", status: "connected", displayName: "Canal", handle: "@canal",
connectedAt: dbm.now(), expiresAt: null, lastCheckAt: dbm.now(), lastError: null,
});
let nextId = 100;
/** Job de corte na fila (fonte twitch-xis ligada ao canal), pronto para sair agora. */
const queuedClipJob = (over: Record<string, string | number | null> = {}): number => {
const ts = dbm.now();
const row = { status: "queued", scheduled_at: ts, schedule_source: "now", ...over };
return Number(dbm.run(`INSERT INTO publish_jobs (account_id, platform, source_kind, source_id, source_label, file, title, caption, status,
scheduled_at, schedule_source, created_at, updated_at)
VALUES ('canal', 'youtube', 'clip', ?, 'twitch-xis', ?, 'Corte', '#corte', ?, ?, ?, ?, ?)`,
String(nextId++), MP4, row.status, row.scheduled_at, row.schedule_source, ts, ts).lastInsertRowid);
};
const clearQueue = () => dbm.run(`UPDATE publish_jobs SET status = 'canceled', cancel_reason = 'user'
WHERE status IN ('queued', 'scheduled', 'awaiting_approval', 'publishing')`);
before(() => {
fs.mkdirSync(path.join(ROOT, "publisher"), { recursive: true });
fs.writeFileSync(path.join(ROOT, "publisher", ".env"), "PUBLISHER_SERVICE_KEY=chave-de-teste\nPUBLISHER_PORT=4530\n");
dbm.run("UPDATE account_networks SET status = 'connected', mode = 'official', enabled = 1 WHERE account_id = 'canal'");
accounts.linkChannel("canal", "twitch-xis");
realFetch = globalThis.fetch;
globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
const url = new URL(String(input instanceof Request ? input.url : input));
const method = (init?.method ?? "GET").toUpperCase();
const body = typeof init?.body === "string" ? (JSON.parse(init.body) as Record<string, unknown>) : null;
calls.push({ method, path: url.pathname, body });
if (url.pathname === "/v1/status") return json({ browser: { found: true, kind: "chrome", path: "x" }, worker: "idle", queue: 0 });
const prof = /^\/v1\/profiles\/([^/]+)$/.exec(url.pathname);
if (prof && method === "GET") return json(profile(decodeURIComponent(prof[1])));
if (url.pathname === "/v1/jobs" && method === "POST") return onCreate(body!);
const cancel = /^\/v1\/jobs\/([^/]+)\/cancel$/.exec(url.pathname);
if (cancel) return json(remoteJob(cancel[1], "canceled"));
const job = /^\/v1\/jobs\/([^/]+)$/.exec(url.pathname);
if (job) return json(remoteJob(job[1], "running"));
return json({ detail: "rota não simulada" }, 404);
}) as typeof fetch;
});
after(() => {
globalThis.fetch = realFetch;
});
it("cancelar enquanto o Publicador cria o envio: o job fica cancelado e o envio é cancelado lá", async () => {
clearQueue();
const id = queuedClipJob();
onCreate = async () => {
await pub.cancelPublishJob(id); // você clicou "Cancelar" bem no meio do envio
return json(remoteJob("pj-corrida"), 201);
};
await pub.dispatcherTick();
const job = pub.getJobView(id)!;
assert.deepEqual([job.status, job.cancelReason], ["canceled", "user"]);
assert.ok(calls.some((c) => c.method === "POST" && c.path === "/v1/jobs/pj-corrida/cancel"));
});
it("falha ambígua (conexão caiu): fica na fila e o reenvio usa o MESMO clientRef; tentar de novo troca", async () => {
clearQueue();
const id = queuedClipJob();
const refs: string[] = [];
let first = true;
onCreate = async (body) => {
refs.push(String(body.clientRef));
if (first) { first = false; throw new TypeError("fetch failed"); }
return json(remoteJob("pj-dedup"), 200); // o Publicador reconheceu o clientRef: devolve o existente
};
await pub.dispatcherTick();
assert.equal(pub.getJobView(id)!.status, "queued");
await pub.dispatcherTick();
const job = pub.getJobView(id)!;
assert.deepEqual([job.status, job.attempts], ["publishing", 0]);
assert.deepEqual(refs, [`${id}:0`, `${id}:0`]);
// O envio falhou no meio: pode já estar na rede ⇒ "Tentar de novo" exige confirmação e usa um clientRef novo.
const row = dbm.get<import("./publishing").JobRow>("SELECT * FROM publish_jobs WHERE id = ?", id)!;
pub.finishFromPublisher(row, { status: "failed", step: "", progress: 0.5, remoteId: null, url: null, draft: false, error: "caiu" });
assert.equal(pub.getJobView(id)!.mayBeLive, true);
assert.throws(() => pub.retryJob(id), /Confira na rede/);
assert.equal(pub.retryJob(id, { confirm: true }).attempts, 1);
onCreate = async (body) => { refs.push(String(body.clientRef)); return json(remoteJob("pj-nova"), 201); };
await pub.dispatcherTick();
assert.equal(refs.at(-1), `${id}:1`);
});
it("placeApproved não desfaz um cancelamento (UPDATE condicional)", () => {
clearQueue();
const id = queuedClipJob({ status: "canceled" });
assert.equal(pub.placeApproved(id, { from: ["awaiting_approval"] }), false);
assert.equal(pub.getJobView(id)!.status, "canceled");
});
it("agendado pela agenda automática que venceu com o painel fechado é reagendado, não disparado", async () => {
clearQueue();
settings.updateSettings({ publishingPaused: true });
const twoHoursAgo = new Date(Date.now() - 2 * 3_600_000).toISOString();
const auto = queuedClipJob({ status: "scheduled", scheduled_at: twoHoursAgo, schedule_source: "auto" });
const manual = queuedClipJob({ status: "scheduled", scheduled_at: twoHoursAgo, schedule_source: "manual" });
await pub.dispatcherTick();
const reflowed = pub.getJobView(auto)!;
assert.equal(reflowed.status, "scheduled");
assert.ok(new Date(reflowed.scheduledAt!).getTime() > Date.now());
assert.match(reflowed.step, /Reagendado/);
assert.equal(pub.getJobView(manual)!.status, "queued"); // horário escolhido à mão sai (aqui fica esperando a pausa)
settings.updateSettings({ publishingPaused: false });
});
it("desligar a fonte cancela os cortes não enviados; religar recomeça o linked_at", () => {
clearQueue();
const id = queuedClipJob({ status: "scheduled", scheduled_at: new Date(Date.now() + 3_600_000).toISOString(), schedule_source: "auto" });
const linkedBefore = dbm.get<{ linked_at: string }>("SELECT linked_at FROM account_channels WHERE account_id = 'canal' AND channel_id = 'twitch-xis'")!;
accounts.endChannel("canal", "twitch-xis");
assert.deepEqual([pub.getJobView(id)!.status, pub.getJobView(id)!.cancelReason], ["canceled", "unlinked"]);
const t0 = Date.now();
while (Date.now() === t0) { /* garante outro milissegundo no relógio */ }
accounts.linkChannel("canal", "twitch-xis");
const afterLink = dbm.get<{ linked_at: string; status: string }>("SELECT linked_at, status FROM account_channels WHERE account_id = 'canal' AND channel_id = 'twitch-xis'")!;
assert.equal(afterLink.status, "active");
assert.ok(afterLink.linked_at > linkedBefore.linked_at, "religar precisa atualizar linked_at");
});
it("job de fonte desligada na fila não sai (confere o vínculo antes de enviar)", async () => {
clearQueue();
const id = queuedClipJob();
dbm.run("UPDATE account_channels SET status = 'ended' WHERE account_id = 'canal' AND channel_id = 'twitch-xis'");
const sent = calls.length;
onCreate = async () => json(remoteJob("pj-nao"), 201);
await pub.dispatcherTick();
assert.equal(pub.getJobView(id)!.status, "canceled");
assert.equal(calls.slice(sent).some((c) => c.path === "/v1/jobs" && c.method === "POST"), false);
accounts.linkChannel("canal", "twitch-xis");
});
});
describe("\"Publicar\" no cartão do corte (origem manual)", () => {
let realFetch: typeof fetch;
const envFile = path.join(ROOT, "clipper", ".env");
const clip = (id: number, status: string) => ({
id, status, channelId: "twitch-xis", createdAt: "2026-11-01T00:00:00.000Z", title: "Corte bom", caption: "#corte",
file: MP4, thumb: null, edit: null,
});
before(() => {
fs.mkdirSync(path.dirname(envFile), { recursive: true });
fs.writeFileSync(envFile, "CLIPPER_SERVICE_KEY=chave-de-teste\nCLIPPER_PORT=4520\n");
dbm.run(`UPDATE publish_jobs SET status = 'canceled', cancel_reason = 'user' WHERE status IN ('queued', 'scheduled', 'awaiting_approval', 'publishing')`);
// YouTube conectado e TikTok desconectado neste canal (testes anteriores podem ter mexido nas redes).
dbm.run("UPDATE account_networks SET status = 'connected', enabled = 1 WHERE account_id = 'canal' AND platform = 'youtube'");
dbm.run("UPDATE account_networks SET status = 'disconnected' WHERE account_id = 'canal' AND platform = 'tiktok'");
realFetch = globalThis.fetch;
globalThis.fetch = (async (input: string | URL | Request) => {
const url = new URL(String(input instanceof Request ? input.url : input));
const m = /^\/v1\/clips\/(\d+)$/.exec(url.pathname);
const body = m && (m[1] === "500" ? clip(500, "approved") : m[1] === "501" ? clip(501, "ready") : null);
return body ? Response.json(body) : Response.json({ detail: "não achei" }, { status: 404 });
}) as typeof fetch;
});
after(() => {
globalThis.fetch = realFetch;
fs.rmSync(envFile, { force: true });
});
it("cria job aprovado e manual nas redes conectadas; a não conectada fica de fora com o motivo", async () => {
const r = await pub.publishClip(500, { accountId: "canal", platforms: ["youtube", "tiktok"], timing: "now" });
assert.equal(r.placed, 1);
assert.deepEqual(r.skipped, [{ platform: "tiktok", reason: "não está conectada neste canal" }]);
const row = dbm.get<import("./publishing").JobRow>("SELECT * FROM publish_jobs WHERE source_kind = 'clip' AND source_id = '500'")!;
assert.deepEqual([row.status, row.origin, row.schedule_source, row.title], ["queued", "manual", "now", "Corte bom"]);
// De novo, no próximo horário bom: a rede já está na fila ⇒ fica de fora.
const again = await pub.publishClip(500, { accountId: "canal", platforms: ["youtube"], timing: "best_slot" });
assert.deepEqual([again.placed, again.skipped[0]?.reason], [0, "já está na fila"]);
});
it("desligar a fonte do canal não cancela o que você publicou à mão", () => {
accounts.endChannel("canal", "twitch-xis");
assert.equal(dbm.get<{ status: string }>("SELECT status FROM publish_jobs WHERE source_kind = 'clip' AND source_id = '500'")!.status, "queued");
accounts.linkChannel("canal", "twitch-xis");
});
it("\"Já saiu: informar o link\": falhou ⇒ publicado com o link (e conta como publicação real)", () => {
const id = dbm.get<{ id: number }>("SELECT id FROM publish_jobs WHERE source_kind = 'clip' AND source_id = '500'")!.id;
dbm.run("UPDATE publish_jobs SET status = 'failed', publisher_job_id = 'pj-sem-link', error = 'sem link' WHERE id = ?", id);
assert.throws(() => pub.markPublished(id, { url: "https://www.tiktok.com/@canal/video/1" }), /link do vídeo no YouTube/);
const job = pub.markPublished(id, { url: "https://youtu.be/AbC123xyz" });
assert.deepEqual([job.status, job.url, job.remoteId, job.error], ["published", "https://www.youtube.com/shorts/AbC123xyz", "AbC123xyz", null]);
assert.ok(dbm.get("SELECT 1 FROM publications WHERE job_id = ? AND simulated = 0", id));
assert.throws(() => pub.markPublished(id, { url: "https://youtu.be/AbC123xyz" }), /ficou com problema/);
});
it("\"Apaguei na rede\": publicado ⇒ cancelado sem link nem registro; \"Publicar\" manda de novo (nova tentativa)", async () => {
const id = dbm.get<{ id: number }>("SELECT id FROM publish_jobs WHERE source_kind = 'clip' AND source_id = '500'")!.id;
assert.equal(pub.getJobView(id)!.status, "published");
const attempts = pub.getJobView(id)!.attempts;
const job = pub.markRemoved(id);
assert.deepEqual([job.status, job.url, job.remoteId, job.actions], ["canceled", null, null, ["retry"]]);
assert.equal(dbm.get("SELECT 1 FROM publications WHERE job_id = ?", id), undefined);
assert.throws(() => pub.markRemoved(id), /está publicado/);
const again = await pub.publishClip(500, { accountId: "canal", platforms: ["youtube"], timing: "now" });
assert.equal(again.placed, 1);
const after = pub.getJobView(id)!;
assert.deepEqual([after.status, after.attempts], ["queued", attempts + 1]);
});
it("horário específico: agenda no horário escolhido para a rede (manual), mesmo se já estava na fila", async () => {
const at = new Date(Date.now() + 3 * 86_400_000);
at.setUTCMinutes(17, 0, 0);
// O job do corte 500 está na fila (teste anterior): o horário escolhido o reagenda.
const r = await pub.publishClip(500, { accountId: "canal", platforms: ["youtube"], timing: "at", scheduledAt: { youtube: at.toISOString() } });
assert.equal(r.placed, 1);
const row = dbm.get<import("./publishing").JobRow>("SELECT * FROM publish_jobs WHERE source_kind = 'clip' AND source_id = '500'")!;
assert.deepEqual([row.status, row.schedule_source, row.scheduled_at], ["scheduled", "manual", at.toISOString()]);
});
it("horário específico: recusa rede sem horário, horário passado e além de um ano", async () => {
const base = { accountId: "canal", platforms: ["youtube"], timing: "at" };
await assert.rejects(pub.publishClip(500, { ...base, scheduledAt: {} }), /dia e a hora do YouTube/);
await assert.rejects(pub.publishClip(500, { ...base, scheduledAt: { youtube: "2020-01-01T10:00:00Z" } }), /já passou/);
await assert.rejects(pub.publishClip(500, { ...base, scheduledAt: { youtube: new Date(Date.now() + 400 * 86_400_000).toISOString() } }), /um ano/);
await assert.rejects(pub.publishClip(500, { ...base, timing: "ontem" }), /now, best_slot ou at/);
});
it("recusa corte que não está aprovado, canal inexistente e lista vazia de redes", async () => {
await assert.rejects(pub.publishClip(501, { accountId: "canal", platforms: ["youtube"] }), /aprovado/);
await assert.rejects(pub.publishClip(500, { accountId: "nao-existe", platforms: ["youtube"] }), /canal de publicação/);
await assert.rejects(pub.publishClip(500, { accountId: "canal", platforms: [] }), /pelo menos uma rede/);
});
});