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>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+421
View File
@@ -0,0 +1,421 @@
// 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("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/);
});
});