fix(backups): проверять ответы и прогресс резервного копирования

shared/api/backups.test.ts

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict"
+import { test } from "node:test"
+import { listBackups, createBackupsAsync, getBackupJob, deleteBackup, restoreBackup, getBackupScheduleSettings, putBackupScheduleSettings, getBackupStorageSettings, putBackupStorageSettings, testBackupStorage, syncBackupsFromStorage } from "./backups"
+
+const base = "https://api.example.test"
+const item = { id: "backup-1", serverId: 1, serverName: "router", filename: "config.rsc", sizeBytes: 0, createdAt: "2026-10-01T00:00:00Z", kind: "manual", storage: "local" }
+const schedule = { enabled: false, frequency: "daily", hour: 0, minute: 0, weekDay: 0, monthDay: 1, keepCount: 7, format: "rsc", serverIds: [] }
+const storage = { provider: "local", s3Endpoint: "", s3Region: "", s3Bucket: "", s3Prefix: "", s3AccessKeyId: "", secretConfigured: false, s3ForcePathStyle: false, keepLocalCopy: false }
+const job = { id: "job-1", status: "done", total: 2, completed: 2, requestedAt: "2026-10-01T00:00:00Z", finishedAt: "2026-10-01T00:01:00Z", created: [item], failures: [{ serverId: "2", error: "RouterOS unavailable" }] }
+function json(payload: unknown, status = 200) { return new Response(JSON.stringify(payload), { status }) }
+
+test("known empty and zero are preserved; malformed catalogue and duplicates rejected", async () => {
+  const original = globalThis.fetch
+  try {
+    globalThis.fetch = async () => json([]); assert.deepEqual(await listBackups(base), [])
+    globalThis.fetch = async () => json([item]); assert.equal((await listBackups(base))[0].sizeBytes, 0)
+    for (const payload of [{}, [item, item], [{ ...item, sizeBytes: -1 }], [{ ...item, serverId: "1" }], [{ ...item, createdAt: "bad" }], [{ ...item, storage: undefined }]]) {
+      globalThis.fetch = async () => json(payload); await assert.rejects(() => listBackups(base))
+    }
+  } finally { globalThis.fetch = original }
+})
+test("settings require a confirmed response and preserve false rather than defaults", async () => {
+  const original = globalThis.fetch
+  try {
+    for (const read of [getBackupScheduleSettings, getBackupStorageSettings]) {
+      globalThis.fetch = async () => json({}); await assert.rejects(() => read(base))
+      globalThis.fetch = async () => new Response(null, { status: 204 }); await assert.rejects(() => read(base))
+    }
+    globalThis.fetch = async url => json(String(url).endsWith("schedule") ? schedule : storage)
+    assert.equal((await getBackupScheduleSettings(base)).enabled, false)
+    assert.equal((await getBackupStorageSettings(base)).secretConfigured, false)
+    assert.equal((await putBackupScheduleSettings(base, { enabled: false })).enabled, false)
+    assert.equal((await putBackupStorageSettings(base, { keepLocalCopy: false })).keepLocalCopy, false)
+  } finally { globalThis.fetch = original }
+})
+test("invalid mutations fail before HTTP; create receives job acknowledgment", async () => {
+  const original = globalThis.fetch; let calls = 0, body: unknown
+  globalThis.fetch = async (_url, init) => { calls++; body = JSON.parse(String(init?.body)); return json({ jobId: "job-1", status: "queued", total: 1, completed: 0 }, 202) }
+  try {
+    await assert.rejects(() => createBackupsAsync(base, { serverIds: [] }))
+    await assert.rejects(() => createBackupsAsync(base, { serverIds: ["1", "1"] }))
+    await assert.rejects(() => createBackupsAsync(base, { serverIds: ["0"] }))
+    await assert.rejects(() => putBackupScheduleSettings(base, { hour: 24 }))
+    assert.equal(calls, 0)
+    assert.equal((await createBackupsAsync(base, { serverIds: ["1"], notes: "manual" })).jobId, "job-1")
+    assert.deepEqual(body, { serverIds: ["1"], notes: "manual" })
+    globalThis.fetch = async () => json({ created: [item], failures: [] }); await assert.rejects(() => createBackupsAsync(base, { serverIds: ["1"] }))
+  } finally { globalThis.fetch = original }
+})
+test("partial completion is valid, foreign and inconsistent job observations rejected", async () => {
+  const original = globalThis.fetch
+  try {
+    globalThis.fetch = async () => json(job)
+    assert.equal((await getBackupJob(base, "job-1")).failures[0].error, "RouterOS unavailable")
+    await assert.rejects(() => getBackupJob(base, "job-other"), /другой задаче/)
+    for (const patch of [{ completed: 3 }, { completed: 1 }, { finishedAt: undefined }, { created: [item, item] }, { failures: [] }]) {
+      globalThis.fetch = async () => json({ ...job, ...patch }); await assert.rejects(() => getBackupJob(base, "job-1"))
+    }
+    globalThis.fetch = async () => json({ ...job, status: "failed", completed: 1, failures: [{ serverId: "job", error: "interrupted" }] })
+    assert.equal((await getBackupJob(base, "job-1")).status, "failed")
+  } finally { globalThis.fetch = original }
+})
+test("delete requires 204, encodes ID and carries caller cancellation", async () => {
+  const original = globalThis.fetch; let url = "", signal: AbortSignal | null | undefined
+  try {
+    globalThis.fetch = async (input, init) => { url = String(input); signal = init?.signal; return json({ ok: true }) }
+    await assert.rejects(() => deleteBackup(base, "a/b"), /204/); assert.ok(url.endsWith("a%2Fb"))
+    globalThis.fetch = async (_input, init) => { signal = init?.signal; return new Response(null, { status: 204 }) }
+    const abort = new AbortController(); await deleteBackup(base, "backup-1", { signal: abort.signal }); abort.abort(); assert.equal(signal?.aborted, true)
+    globalThis.fetch = async () => json({ error: "Нет доступа" }, 403); await assert.rejects(() => deleteBackup(base, "backup-1"), /Нет доступа/)
+  } finally { globalThis.fetch = original }
+})
+test("restore, S3 test and sync do not accept empty or malformed success", async () => {
+  const original = globalThis.fetch
+  try {
+    globalThis.fetch = async () => json({}); await assert.rejects(() => restoreBackup(base, "backup-1")); await assert.rejects(() => testBackupStorage(base)); await assert.rejects(() => syncBackupsFromStorage(base))
+    globalThis.fetch = async () => json({ filename: "config.rsc", serverName: "router" }); assert.equal((await restoreBackup(base, "backup-1")).filename, "config.rsc")
+    globalThis.fetch = async () => json(storage); assert.equal((await testBackupStorage(base)).secretConfigured, false)
+    globalThis.fetch = async () => json({ imported: 0, skipped: 0 }); assert.equal((await syncBackupsFromStorage(base)).imported, 0)
+    globalThis.fetch = async () => json({ imported: -1, skipped: 0 }); await assert.rejects(() => syncBackupsFromStorage(base))
+  } finally { globalThis.fetch = original }
+})