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>
440 lines
27 KiB
TypeScript
440 lines
27 KiB
TypeScript
// 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/);
|
||
});
|
||
});
|