Sucukdeluxe
2ea494cd5c
Restore and persist the package-based link collector with progressive metadata, bounded high-volume updates, safe hydration, visible selection, and complete localization. Harden download controls, snapshot ordering, history pagination, statistics recovery, settings saves, backup imports, notification persistence, and Windows storage races with regression coverage.
2385 lines
88 KiB
TypeScript
2385 lines
88 KiB
TypeScript
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { parseDebridLinkApiKeys } from "../src/shared/debrid-link-keys";
|
|
import { getMegaDebridAccountId } from "../src/shared/mega-debrid-accounts";
|
|
import { getProviderUsageDayKey } from "../src/shared/provider-daily-limits";
|
|
import { parseRealDebridApiAccounts, serializeRealDebridApiAccounts } from "../src/shared/real-debrid-accounts";
|
|
import { AppSettings } from "../src/shared/types";
|
|
import { defaultSettings } from "../src/main/constants";
|
|
import { configureCredentialProtector } from "../src/main/credential-protection";
|
|
import { acquirePersistenceBarrier, addHistoryEntryForRetention, clearHistory, createStoragePaths, emptySession, loadHistory, loadHistoryForRetention, loadSession, loadSessionWithStatus, loadSettings, normalizeHistoryEntry, normalizeLoadedSession, normalizeSettings, removeHistoryEntries, replaceHistory, resetHistoryForRetention, saveHistory, saveSession, saveSessionAsync, saveSettings, saveSettingsAsync } from "../src/main/storage";
|
|
|
|
const tempDirs: string[] = [];
|
|
type SettingsSaveMode = "sync" | "async";
|
|
|
|
async function saveSettingsInMode(mode: SettingsSaveMode, paths: ReturnType<typeof createStoragePaths>, settings: AppSettings): Promise<void> {
|
|
if (mode === "sync") {
|
|
saveSettings(paths, settings);
|
|
} else {
|
|
await saveSettingsAsync(paths, settings);
|
|
}
|
|
}
|
|
|
|
function loadSettingsFrom(raw: Record<string, unknown>): AppSettings {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
fs.writeFileSync(paths.configFile, JSON.stringify(raw), "utf8");
|
|
return loadSettings(paths);
|
|
}
|
|
|
|
beforeEach(() => {
|
|
configureCredentialProtector({
|
|
isEncryptionAvailable: () => true,
|
|
encryptString: (value) => Buffer.from(value, "utf8").reverse(),
|
|
decryptString: (value) => Buffer.from(value).reverse().toString("utf8")
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
for (const dir of tempDirs.splice(0)) {
|
|
fs.rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
describe("settings storage", () => {
|
|
it("defaults and round-trips Deepbrid credentials and provider settings", () => {
|
|
const key = "fixture-deepbrid-storage-key-2aB4";
|
|
const defaults = defaultSettings();
|
|
expect(defaults.deepbridApiKey).toBe("");
|
|
|
|
const normalized = normalizeSettings({
|
|
...defaults,
|
|
deepbridApiKey: ` ${key} `,
|
|
providerOrder: ["deepbrid", "realdebrid", "deepbrid"],
|
|
providerPrimary: "deepbrid",
|
|
providerSecondary: "realdebrid",
|
|
providerTertiary: "none",
|
|
disabledProviders: ["deepbrid"],
|
|
hosterRouting: { rapidgator: "deepbrid" },
|
|
providerDailyLimitBytes: { deepbrid: 1_024 },
|
|
providerDailyUsageBytes: { deepbrid: 2_048 },
|
|
providerTotalUsageBytes: { deepbrid: 4_096 },
|
|
debridAccountStatuses: {
|
|
"svc-deepbrid": {
|
|
accountId: "svc-deepbrid",
|
|
provider: "deepbrid",
|
|
label: "Deepbrid",
|
|
maskedLogin: "••••",
|
|
valid: true,
|
|
isPremium: true,
|
|
premiumUntilMs: null,
|
|
message: "OK",
|
|
checkedAt: 1
|
|
}
|
|
}
|
|
} as AppSettings);
|
|
|
|
expect(normalized).toMatchObject({
|
|
deepbridApiKey: key,
|
|
providerOrder: ["deepbrid", "realdebrid"],
|
|
providerPrimary: "deepbrid",
|
|
providerSecondary: "realdebrid",
|
|
providerTertiary: "none",
|
|
disabledProviders: ["deepbrid"],
|
|
hosterRouting: { rapidgator: "deepbrid" },
|
|
providerDailyLimitBytes: { deepbrid: 1_024 },
|
|
providerDailyUsageBytes: { deepbrid: 2_048 },
|
|
providerTotalUsageBytes: { deepbrid: 4_096 }
|
|
});
|
|
expect(normalized.debridAccountStatuses["svc-deepbrid"]?.provider).toBe("deepbrid");
|
|
expect(normalizeSettings({
|
|
...defaults,
|
|
providerPrimary: "realdebrid",
|
|
providerSecondary: "deepbrid",
|
|
providerTertiary: "bestdebrid"
|
|
}).providerSecondary).toBe("deepbrid");
|
|
expect(normalizeSettings({
|
|
...defaults,
|
|
providerPrimary: "realdebrid",
|
|
providerSecondary: "bestdebrid",
|
|
providerTertiary: "deepbrid"
|
|
}).providerTertiary).toBe("deepbrid");
|
|
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
saveSettings(paths, normalized);
|
|
expect(loadSettings(paths).deepbridApiKey).toBe(key);
|
|
});
|
|
|
|
it("preserves Deepbrid in normalized session items, packages and history", () => {
|
|
const outputDir = path.resolve("C:\\Downloads\\Deepbrid");
|
|
const session = normalizeLoadedSession({
|
|
...emptySession(),
|
|
packageOrder: ["pkg-deepbrid"],
|
|
packages: {
|
|
"pkg-deepbrid": {
|
|
id: "pkg-deepbrid",
|
|
name: "Deepbrid package",
|
|
outputDir,
|
|
extractDir: outputDir,
|
|
status: "completed",
|
|
itemIds: ["item-deepbrid"],
|
|
cleanedProviders: ["deepbrid"],
|
|
createdAt: 1,
|
|
updatedAt: 2
|
|
}
|
|
},
|
|
items: {
|
|
"item-deepbrid": {
|
|
id: "item-deepbrid",
|
|
packageId: "pkg-deepbrid",
|
|
url: "https://example.test/deepbrid.bin",
|
|
provider: "deepbrid",
|
|
status: "completed",
|
|
fileName: "deepbrid.bin",
|
|
targetPath: path.join(outputDir, "deepbrid.bin"),
|
|
createdAt: 1,
|
|
updatedAt: 2
|
|
}
|
|
}
|
|
});
|
|
const history = normalizeHistoryEntry({
|
|
id: "hist-deepbrid",
|
|
name: "Deepbrid history",
|
|
provider: "deepbrid",
|
|
status: "completed"
|
|
}, 0);
|
|
|
|
expect(session.items["item-deepbrid"]?.provider).toBe("deepbrid");
|
|
expect(session.packages["pkg-deepbrid"]?.cleanedProviders).toEqual(["deepbrid"]);
|
|
expect(history?.provider).toBe("deepbrid");
|
|
});
|
|
|
|
it.each([undefined, "megadebrid", "realdebrid", "invalid-provider"])("normalizes svc-deepbrid status with provider %s deterministically to Deepbrid", (provider) => {
|
|
const key = "fixture-deepbrid-status-key-4pQ5";
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
deepbridApiKey: key,
|
|
debridAccountStatuses: {
|
|
"svc-deepbrid": {
|
|
accountId: "svc-deepbrid",
|
|
...(provider === undefined ? {} : { provider }),
|
|
label: "Deepbrid",
|
|
maskedLogin: "••••",
|
|
valid: true,
|
|
isPremium: true,
|
|
premiumUntilMs: null,
|
|
message: "OK",
|
|
checkedAt: 1
|
|
}
|
|
}
|
|
} as AppSettings);
|
|
|
|
expect(normalized.debridAccountStatuses["svc-deepbrid"]?.provider).toBe("deepbrid");
|
|
});
|
|
|
|
it("defaults and normalizes persistent daily start calendar fields", () => {
|
|
const defaults = defaultSettings();
|
|
|
|
expect(defaults.dailyStartEnabled).toBe(false);
|
|
expect(defaults.dailyStartMinuteOfDay).toBe(0);
|
|
expect(defaults.dailyStartFirstLocalDate).toBe("");
|
|
expect(defaults.dailyStartLastHandledLocalDate).toBe("");
|
|
expect(defaults.dailyStartPendingLocalDate).toBe("");
|
|
expect(defaults.dailyStartLastOutcome).toBe("");
|
|
|
|
expect(normalizeSettings({
|
|
...defaults,
|
|
dailyStartEnabled: true,
|
|
dailyStartMinuteOfDay: 1_500,
|
|
dailyStartFirstLocalDate: "2026-02-29",
|
|
dailyStartLastHandledLocalDate: "2026-08-21",
|
|
dailyStartPendingLocalDate: "not-a-day",
|
|
dailyStartLastOutcome: "unsupported"
|
|
} as unknown as AppSettings)).toMatchObject({
|
|
dailyStartEnabled: true,
|
|
dailyStartMinuteOfDay: 1_439,
|
|
dailyStartFirstLocalDate: "",
|
|
dailyStartLastHandledLocalDate: "2026-08-21",
|
|
dailyStartPendingLocalDate: "",
|
|
dailyStartLastOutcome: ""
|
|
});
|
|
});
|
|
|
|
it("reports whether a loaded session was active before transient normalization", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const session = emptySession();
|
|
session.running = true;
|
|
saveSession(paths, session);
|
|
|
|
const loaded = loadSessionWithStatus(paths);
|
|
|
|
expect(loaded.wasRunning).toBe(true);
|
|
expect(loaded.session.running).toBe(false);
|
|
});
|
|
|
|
it("migrates legacy package success notifications without changing their delivery frequency", () => {
|
|
expect(loadSettingsFrom({ notifyOnPackageCompleted: true }).notifyPackageSuccessMode).toBe("individual");
|
|
expect(loadSettingsFrom({}).notifyPackageSuccessMode).toBe("digest");
|
|
expect(loadSettingsFrom({ notifyOnPackageCompleted: true, notifyPackageSuccessMode: "digest" }).notifyPackageSuccessMode).toBe("digest");
|
|
});
|
|
|
|
it("preserves an explicit individual success mode when legacy package notifications are disabled", () => {
|
|
expect(loadSettingsFrom({ notifyOnPackageCompleted: false, notifyPackageSuccessMode: "individual" }).notifyPackageSuccessMode).toBe("individual");
|
|
});
|
|
|
|
it("falls back from an invalid persisted success mode according to the legacy package toggle", () => {
|
|
expect(loadSettingsFrom({ notifyOnPackageCompleted: true, notifyPackageSuccessMode: "invalid" }).notifyPackageSuccessMode).toBe("individual");
|
|
expect(loadSettingsFrom({ notifyOnPackageCompleted: false, notifyPackageSuccessMode: "invalid" }).notifyPackageSuccessMode).toBe("digest");
|
|
});
|
|
|
|
it("loads notification defaults for new settings", () => {
|
|
const defaults = loadSettingsFrom({});
|
|
|
|
expect(defaults).toEqual(expect.objectContaining({
|
|
notifyPackageSuccessMode: "digest",
|
|
notifyOnRemainingBelow: false,
|
|
notifyRemainingThresholdGb: 50,
|
|
notifyOnDownloadStall: false,
|
|
notifyStallAfterSeconds: 90,
|
|
notifyStallCooldownMinutes: 10,
|
|
notifyOnDownloadRecovery: true
|
|
}));
|
|
});
|
|
|
|
it.each([
|
|
["notifyRemainingThresholdGb", 0, 1],
|
|
["notifyRemainingThresholdGb", 100_001, 100_000],
|
|
["notifyRemainingThresholdGb", "invalid", 50],
|
|
["notifyStallAfterSeconds", 59, 60],
|
|
["notifyStallAfterSeconds", 3_601, 3_600],
|
|
["notifyStallAfterSeconds", "invalid", 90],
|
|
["notifyStallCooldownMinutes", 4, 5],
|
|
["notifyStallCooldownMinutes", 1_441, 1_440],
|
|
["notifyStallCooldownMinutes", "invalid", 10]
|
|
] as const)("normalizes %s from %s to %s", (key, input, expected) => {
|
|
const normalized = normalizeSettings({ ...defaultSettings(), [key]: input } as AppSettings);
|
|
|
|
expect(normalized[key]).toBe(expected);
|
|
});
|
|
|
|
it("enables package disclosure motion by default and preserves an explicit opt-out", () => {
|
|
const legacy = { ...defaultSettings() } as Partial<AppSettings>;
|
|
delete legacy.animatePackageDisclosure;
|
|
|
|
expect(normalizeSettings(legacy as AppSettings).animatePackageDisclosure).toBe(true);
|
|
expect(normalizeSettings({ ...defaultSettings(), animatePackageDisclosure: false }).animatePackageDisclosure).toBe(false);
|
|
});
|
|
|
|
it("repairs a persisted version-2 column order that lost availability during default merging", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
fs.writeFileSync(paths.configFile, JSON.stringify({
|
|
...defaultSettings(),
|
|
columnOrder: ["name", "size", "progress", "hoster", "account", "prio", "status", "speed"],
|
|
columnOrderVersion: 2
|
|
}), "utf8");
|
|
|
|
const loaded = loadSettings(paths);
|
|
|
|
expect(loaded.columnOrder).toEqual(["name", "size", "progress", "hoster", "account", "prio", "status", "speed", "availability"]);
|
|
expect(loaded.columnOrderVersion).toBe(3);
|
|
});
|
|
|
|
it("adds availability beside speed once for legacy column settings", () => {
|
|
const legacy = { ...defaultSettings(), columnOrder: ["name", "status", "speed"] } as Partial<AppSettings>;
|
|
delete legacy.columnOrderVersion;
|
|
|
|
const normalized = normalizeSettings(legacy as AppSettings);
|
|
|
|
expect(normalized.columnOrder).toEqual(["name", "status", "speed", "availability"]);
|
|
expect(normalized.columnOrderVersion).toBe(3);
|
|
expect(normalizeSettings({ ...normalized, columnOrder: ["name", "speed"] }).columnOrder).toEqual(["name", "speed"]);
|
|
});
|
|
|
|
it("uses English for new installations and preserves only supported languages", () => {
|
|
expect(defaultSettings().language).toBe("en");
|
|
expect(normalizeSettings({ ...defaultSettings(), language: "de" }).language).toBe("de");
|
|
expect(normalizeSettings({ ...defaultSettings(), language: "fr" as "en" }).language).toBe("en");
|
|
});
|
|
|
|
it("migrates a legacy shared Mega-Debrid pool into only the preferred mode", () => {
|
|
const legacy = { ...defaultSettings() } as Partial<AppSettings>;
|
|
legacy.megaCredentials = "legacy@example.test:legacy-pass";
|
|
legacy.megaLogin = "legacy@example.test";
|
|
legacy.megaPassword = "legacy-pass";
|
|
legacy.megaDebridApiEnabled = true;
|
|
legacy.megaDebridWebEnabled = true;
|
|
legacy.megaDebridPreferApi = true;
|
|
delete legacy.megaDebridApiCredentials;
|
|
delete legacy.megaDebridWebCredentials;
|
|
delete legacy.megaDebridApiDisabledAccountIds;
|
|
delete legacy.megaDebridWebDisabledAccountIds;
|
|
|
|
const normalized = normalizeSettings(legacy as AppSettings);
|
|
|
|
expect(normalized.megaDebridApiCredentials).toBe("legacy@example.test:legacy-pass");
|
|
expect(normalized.megaDebridWebCredentials).toBe("");
|
|
expect(normalized.megaDebridApiEnabled).toBe(true);
|
|
expect(normalized.megaDebridWebEnabled).toBe(false);
|
|
});
|
|
|
|
it("keeps German for existing settings files created before language selection existed", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const legacy = { ...defaultSettings() } as Partial<AppSettings>;
|
|
delete legacy.language;
|
|
fs.mkdirSync(path.dirname(paths.configFile), { recursive: true });
|
|
fs.writeFileSync(paths.configFile, JSON.stringify(legacy), "utf8");
|
|
|
|
expect(loadSettings(paths).language).toBe("de");
|
|
});
|
|
|
|
it("defaults download directories to the desktop project folder", () => {
|
|
const baseDir = path.join(os.homedir(), "Desktop", "Multi-Debrid-Downloader");
|
|
const defaults = defaultSettings();
|
|
|
|
expect(defaults.outputDir).toBe(baseDir);
|
|
expect(defaults.extractDir).toBe(path.join(baseDir, "_entpackt"));
|
|
expect(defaults.mkvLibraryDir).toBe(path.join(baseDir, "_mkv"));
|
|
});
|
|
|
|
it("migrates an untouched legacy directory configuration", () => {
|
|
const legacyBaseDir = path.join(os.homedir(), "Downloads", "RealDebrid");
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
outputDir: legacyBaseDir,
|
|
extractDir: path.join(legacyBaseDir, "_entpackt"),
|
|
mkvLibraryDir: path.join(legacyBaseDir, "_mkv")
|
|
});
|
|
const defaults = defaultSettings();
|
|
|
|
expect(normalized.outputDir).toBe(defaults.outputDir);
|
|
expect(normalized.extractDir).toBe(defaults.extractDir);
|
|
expect(normalized.mkvLibraryDir).toBe(defaults.mkvLibraryDir);
|
|
});
|
|
|
|
it("keeps custom directory choices during legacy migration", () => {
|
|
const legacyBaseDir = path.join(os.homedir(), "Downloads", "RealDebrid");
|
|
const customOutputDir = path.join(os.homedir(), "Videos", "Custom-Downloads");
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
outputDir: customOutputDir,
|
|
extractDir: path.join(legacyBaseDir, "_entpackt"),
|
|
mkvLibraryDir: path.join(legacyBaseDir, "_mkv")
|
|
});
|
|
|
|
expect(normalized.outputDir).toBe(customOutputDir);
|
|
expect(normalized.extractDir).toBe(path.join(legacyBaseDir, "_entpackt"));
|
|
expect(normalized.mkvLibraryDir).toBe(path.join(legacyBaseDir, "_mkv"));
|
|
});
|
|
|
|
it("does not persist provider credentials when rememberToken is disabled", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
saveSettings(paths, {
|
|
...defaultSettings(),
|
|
rememberToken: false,
|
|
token: "rd-token",
|
|
megaLogin: "mega-user",
|
|
megaPassword: "mega-pass",
|
|
megaCredentials: "mega-user:mega-pass",
|
|
megaDebridApiCredentials: "mega-user:mega-pass",
|
|
megaDebridWebCredentials: "web-user:web-pass",
|
|
bestToken: "best-token",
|
|
allDebridToken: "all-token"
|
|
});
|
|
|
|
const raw = JSON.parse(fs.readFileSync(paths.configFile, "utf8")) as Record<string, unknown>;
|
|
expect(raw.token).toBe("");
|
|
expect(raw.megaLogin).toBe("");
|
|
expect(raw.megaPassword).toBe("");
|
|
expect(raw.megaCredentials).toBe("");
|
|
expect(raw.megaDebridApiCredentials).toBe("");
|
|
expect(raw.megaDebridWebCredentials).toBe("");
|
|
expect(raw.bestToken).toBe("");
|
|
expect(raw.allDebridToken).toBe("");
|
|
|
|
const loaded = loadSettings(paths);
|
|
expect(loaded.rememberToken).toBe(false);
|
|
expect(loaded.token).toBe("");
|
|
expect(loaded.megaLogin).toBe("");
|
|
expect(loaded.megaPassword).toBe("");
|
|
expect(loaded.megaCredentials).toBe("");
|
|
expect(loaded.megaDebridApiCredentials).toBe("");
|
|
expect(loaded.megaDebridWebCredentials).toBe("");
|
|
expect(loaded.bestToken).toBe("");
|
|
expect(loaded.allDebridToken).toBe("");
|
|
});
|
|
|
|
it("persists provider credentials when rememberToken is enabled", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
saveSettings(paths, {
|
|
...defaultSettings(),
|
|
rememberToken: true,
|
|
token: "rd-token",
|
|
megaLogin: "mega-user",
|
|
megaPassword: "mega-pass",
|
|
bestToken: "best-token",
|
|
allDebridToken: "all-token"
|
|
});
|
|
|
|
const loaded = loadSettings(paths);
|
|
expect(loaded.token).toBe("rd-token");
|
|
expect(loaded.megaLogin).toBe("mega-user");
|
|
expect(loaded.megaPassword).toBe("mega-pass");
|
|
expect(loaded.bestToken).toBe("best-token");
|
|
expect(loaded.allDebridToken).toBe("all-token");
|
|
});
|
|
|
|
it.each(["sync", "async"] as const)("preserves the previous recoverable settings state during a %s save", async (mode) => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const previousToken = "previous-value-for-recovery";
|
|
const previous = {
|
|
...defaultSettings(),
|
|
packageName: "previous-package-name",
|
|
token: previousToken
|
|
};
|
|
saveSettings(paths, previous);
|
|
|
|
await saveSettingsInMode(mode, paths, {
|
|
...previous,
|
|
packageName: "current-package-name",
|
|
token: "current-value"
|
|
});
|
|
|
|
const backupText = fs.readFileSync(`${paths.configFile}.bak`, "utf8");
|
|
expect(backupText).not.toContain(previousToken);
|
|
fs.writeFileSync(paths.configFile, "{broken-current-config", "utf8");
|
|
const recovered = loadSettings(paths);
|
|
expect(recovered.packageName).toBe("previous-package-name");
|
|
expect(recovered.token).toBe(previousToken);
|
|
});
|
|
|
|
it.each(["sync", "async"] as const)("clears previously stored credentials from the backup when remembering is disabled during a %s save", async (mode) => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const remembered = {
|
|
...defaultSettings(),
|
|
rememberToken: true,
|
|
token: "stored-value-before-clear",
|
|
packageName: "previous-package-name"
|
|
};
|
|
saveSettings(paths, remembered);
|
|
|
|
const cleared = { ...remembered, rememberToken: false, packageName: "current-package-name" };
|
|
await saveSettingsInMode(mode, paths, cleared);
|
|
|
|
const primary = JSON.parse(fs.readFileSync(paths.configFile, "utf8")) as Record<string, unknown>;
|
|
const backup = JSON.parse(fs.readFileSync(`${paths.configFile}.bak`, "utf8")) as Record<string, unknown>;
|
|
expect(primary.token).toBe("");
|
|
expect(backup.token).toBe("");
|
|
expect(primary.packageName).toBe("current-package-name");
|
|
expect(backup.packageName).toBe("previous-package-name");
|
|
expect(backup.rememberToken).toBe(false);
|
|
});
|
|
|
|
it.each(["sync", "async"] as const)("clears previously stored credentials from the backup when encryption is unavailable during a %s save", async (mode) => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const remembered = {
|
|
...defaultSettings(),
|
|
rememberToken: true,
|
|
token: "stored-value-before-unavailable"
|
|
};
|
|
saveSettings(paths, remembered);
|
|
configureCredentialProtector({
|
|
isEncryptionAvailable: () => false,
|
|
encryptString: () => Buffer.alloc(0),
|
|
decryptString: () => ""
|
|
});
|
|
|
|
await saveSettingsInMode(mode, paths, remembered);
|
|
|
|
const primary = JSON.parse(fs.readFileSync(paths.configFile, "utf8")) as Record<string, unknown>;
|
|
const backup = JSON.parse(fs.readFileSync(`${paths.configFile}.bak`, "utf8")) as Record<string, unknown>;
|
|
expect(primary.token).toBe("");
|
|
expect(backup.token).toBe("");
|
|
});
|
|
|
|
it.each([
|
|
["sync", "absent"],
|
|
["async", "absent"],
|
|
["sync", "corrupt"],
|
|
["async", "corrupt"]
|
|
] as const)("uses a credential-free current fallback for a %s save with a %s prior primary", async (mode, priorState) => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
if (priorState === "corrupt") {
|
|
fs.writeFileSync(paths.configFile, "{broken-prior-config", "utf8");
|
|
}
|
|
const currentToken = "current-value-for-safe-fallback";
|
|
|
|
await saveSettingsInMode(mode, paths, {
|
|
...defaultSettings(),
|
|
rememberToken: true,
|
|
packageName: "current-package-name",
|
|
token: currentToken
|
|
});
|
|
|
|
expect(fs.existsSync(`${paths.configFile}.bak`)).toBe(true);
|
|
const backupText = fs.readFileSync(`${paths.configFile}.bak`, "utf8");
|
|
const backup = JSON.parse(backupText) as Record<string, unknown>;
|
|
expect(backup.packageName).toBe("current-package-name");
|
|
expect(backup.rememberToken).toBe(false);
|
|
expect(backup.token).toBe("");
|
|
expect(backupText).not.toContain(currentToken);
|
|
expect(loadSettings(paths).token).toBe(currentToken);
|
|
});
|
|
|
|
it("migrates remembered plaintext provider values without retaining plaintext in config backups", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const value = "legacy-value-to-migrate";
|
|
fs.writeFileSync(paths.configFile, JSON.stringify({
|
|
...defaultSettings(),
|
|
rememberToken: true,
|
|
token: value
|
|
}), "utf8");
|
|
|
|
const loaded = loadSettings(paths);
|
|
const config = fs.readFileSync(paths.configFile, "utf8");
|
|
const backup = fs.existsSync(`${paths.configFile}.bak`)
|
|
? fs.readFileSync(`${paths.configFile}.bak`, "utf8")
|
|
: "";
|
|
|
|
expect(loaded.token).toBe(value);
|
|
expect(config).not.toContain(value);
|
|
expect(backup).not.toContain(value);
|
|
});
|
|
|
|
it("normalizes invalid enum and numeric values", () => {
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
providerPrimary: "invalid-provider" as unknown as AppSettings["providerPrimary"],
|
|
providerSecondary: "invalid-provider" as unknown as AppSettings["providerSecondary"],
|
|
providerTertiary: "invalid-provider" as unknown as AppSettings["providerTertiary"],
|
|
cleanupMode: "broken" as unknown as AppSettings["cleanupMode"],
|
|
extractConflictMode: "broken" as unknown as AppSettings["extractConflictMode"],
|
|
completedCleanupPolicy: "broken" as unknown as AppSettings["completedCleanupPolicy"],
|
|
speedLimitMode: "broken" as unknown as AppSettings["speedLimitMode"],
|
|
maxParallel: 0,
|
|
retryLimit: 999,
|
|
reconnectWaitSeconds: 9999,
|
|
speedLimitKbps: -1,
|
|
outputDir: " ",
|
|
extractDir: " ",
|
|
mkvLibraryDir: " ",
|
|
updateRepo: " "
|
|
});
|
|
|
|
expect(normalized.providerPrimary).toBe("realdebrid");
|
|
expect(normalized.providerSecondary).toBe("none");
|
|
expect(normalized.providerTertiary).toBe("none");
|
|
expect(normalized.cleanupMode).toBe("none");
|
|
expect(normalized.extractConflictMode).toBe("overwrite");
|
|
expect(normalized.completedCleanupPolicy).toBe("never");
|
|
expect(normalized.speedLimitMode).toBe("global");
|
|
expect(normalized.maxParallel).toBe(1);
|
|
expect(normalized.retryLimit).toBe(99);
|
|
expect(normalized.reconnectWaitSeconds).toBe(600);
|
|
expect(normalized.speedLimitKbps).toBe(0);
|
|
expect(normalized.outputDir).toBe(defaultSettings().outputDir);
|
|
expect(normalized.extractDir).toBe(defaultSettings().extractDir);
|
|
expect(normalized.mkvLibraryDir).toBe(defaultSettings().mkvLibraryDir);
|
|
expect(normalized.updateRepo).toBe(defaultSettings().updateRepo);
|
|
});
|
|
|
|
it("migrates the previous private update repository to the public release repository", () => {
|
|
for (const updateRepo of [
|
|
"legacy-owner/real-debrid-downloader",
|
|
"legacy-owner/multi-debrid-downloader",
|
|
"legacy-owner/real-debrid-downloader.git",
|
|
"Sucukdeluxe/multi-debrid-downloader"
|
|
]) {
|
|
const normalized = normalizeSettings({ ...defaultSettings(), updateRepo });
|
|
expect(normalized.updateRepo).toBe(defaultSettings().updateRepo);
|
|
}
|
|
});
|
|
|
|
it("normalizes malformed persisted config on load", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
fs.writeFileSync(
|
|
paths.configFile,
|
|
JSON.stringify({
|
|
providerPrimary: "not-valid",
|
|
completedCleanupPolicy: "not-valid",
|
|
maxParallel: "999",
|
|
retryLimit: "-3",
|
|
reconnectWaitSeconds: "1",
|
|
speedLimitMode: "not-valid",
|
|
updateRepo: "",
|
|
autoSortPackagesByProgress: false
|
|
}),
|
|
"utf8"
|
|
);
|
|
|
|
const loaded = loadSettings(paths);
|
|
expect(loaded.providerPrimary).toBe("realdebrid");
|
|
expect(loaded.completedCleanupPolicy).toBe("never");
|
|
expect(loaded.maxParallel).toBe(50);
|
|
expect(loaded.retryLimit).toBe(0);
|
|
expect(loaded.reconnectWaitSeconds).toBe(10);
|
|
expect(loaded.speedLimitMode).toBe("global");
|
|
expect(loaded.updateRepo).toBe(defaultSettings().updateRepo);
|
|
expect(loaded.autoSortPackagesByProgress).toBe(false);
|
|
});
|
|
|
|
it("keeps explicit none as fallback provider choice", () => {
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
providerSecondary: "none",
|
|
providerTertiary: "none"
|
|
});
|
|
|
|
expect(normalized.providerSecondary).toBe("none");
|
|
expect(normalized.providerTertiary).toBe("none");
|
|
});
|
|
|
|
it("migrates legacy MegaDebrid provider selections to explicit API/Web providers", () => {
|
|
const apiNormalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
megaLogin: "mega-user",
|
|
megaPassword: "mega-pass",
|
|
megaDebridPreferApi: true,
|
|
providerPrimary: "megadebrid" as unknown as AppSettings["providerPrimary"],
|
|
providerSecondary: "megadebrid" as unknown as AppSettings["providerSecondary"],
|
|
disabledProviders: ["megadebrid" as unknown as AppSettings["providerPrimary"]]
|
|
});
|
|
|
|
expect(apiNormalized.providerPrimary).toBe("megadebrid-api");
|
|
expect(apiNormalized.providerSecondary).toBe("none");
|
|
expect(apiNormalized.disabledProviders).toEqual(["megadebrid-api", "megadebrid-web"]);
|
|
|
|
const webNormalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
megaLogin: "mega-user",
|
|
megaPassword: "mega-pass",
|
|
megaDebridPreferApi: false,
|
|
megaDebridApiEnabled: false,
|
|
megaDebridWebEnabled: true,
|
|
providerPrimary: "megadebrid" as unknown as AppSettings["providerPrimary"],
|
|
hosterRouting: { rapidgator: "megadebrid" as unknown as AppSettings["providerPrimary"] }
|
|
});
|
|
|
|
expect(webNormalized.providerPrimary).toBe("megadebrid-web");
|
|
expect(webNormalized.hosterRouting.rapidgator).toBe("megadebrid-web");
|
|
});
|
|
|
|
it("migriert eine pre-v1.6.90-Config (Mega-Creds, beide Enable-Flags fehlen) zu aktiviertem Mega-Debrid statt es still auf false zu setzen", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const legacyApi = {
|
|
megaLogin: "mega-user",
|
|
megaPassword: "mega-pass",
|
|
megaDebridPreferApi: true,
|
|
providerPrimary: "realdebrid",
|
|
providerSecondary: "megadebrid"
|
|
};
|
|
fs.writeFileSync(paths.configFile, JSON.stringify(legacyApi), "utf8");
|
|
const loadedApi = loadSettings(paths);
|
|
expect(loadedApi.megaDebridApiEnabled).toBe(true);
|
|
expect(loadedApi.megaDebridWebEnabled).toBe(false);
|
|
|
|
const dir2 = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir2);
|
|
const paths2 = createStoragePaths(dir2);
|
|
const legacyWeb = {
|
|
megaLogin: "mega-user",
|
|
megaPassword: "mega-pass",
|
|
megaDebridPreferApi: false,
|
|
providerPrimary: "realdebrid",
|
|
providerSecondary: "megadebrid"
|
|
};
|
|
fs.writeFileSync(paths2.configFile, JSON.stringify(legacyWeb), "utf8");
|
|
const loadedWeb = loadSettings(paths2);
|
|
expect(loadedWeb.megaDebridApiEnabled).toBe(false);
|
|
expect(loadedWeb.megaDebridWebEnabled).toBe(true);
|
|
});
|
|
|
|
it("migrates an explicitly Web-only legacy account even when API remains preferred", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
fs.writeFileSync(paths.configFile, JSON.stringify({
|
|
rememberToken: true,
|
|
megaCredentials: "web-user:web-pass",
|
|
megaDebridPreferApi: true,
|
|
megaDebridApiEnabled: false,
|
|
megaDebridWebEnabled: true
|
|
}), "utf8");
|
|
|
|
const loaded = loadSettings(paths);
|
|
|
|
expect(loaded.megaDebridApiCredentials).toBe("");
|
|
expect(loaded.megaDebridWebCredentials).toBe("web-user:web-pass");
|
|
expect(loaded.megaDebridApiEnabled).toBe(false);
|
|
expect(loaded.megaDebridWebEnabled).toBe(true);
|
|
});
|
|
|
|
it("migrates legacy disabled Mega-Debrid accounts into the selected mode", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const accountId = getMegaDebridAccountId("disabled-user");
|
|
fs.writeFileSync(paths.configFile, JSON.stringify({
|
|
rememberToken: true,
|
|
megaCredentials: "disabled-user:disabled-pass",
|
|
megaDebridPreferApi: true,
|
|
megaDebridApiEnabled: true,
|
|
megaDebridWebEnabled: false,
|
|
megaDebridDisabledAccountIds: [accountId]
|
|
}), "utf8");
|
|
|
|
const loaded = loadSettings(paths);
|
|
|
|
expect(loaded.megaDebridApiDisabledAccountIds).toEqual([accountId]);
|
|
expect(loaded.megaDebridWebDisabledAccountIds).toEqual([]);
|
|
});
|
|
|
|
it("preserves explicit mode-specific disabled Mega-Debrid accounts", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const accountId = getMegaDebridAccountId("shared-user");
|
|
fs.writeFileSync(paths.configFile, JSON.stringify({
|
|
rememberToken: true,
|
|
megaDebridApiCredentials: "shared-user:api-pass",
|
|
megaDebridWebCredentials: "shared-user:web-pass",
|
|
megaDebridApiEnabled: true,
|
|
megaDebridWebEnabled: true,
|
|
megaDebridDisabledAccountIds: [accountId],
|
|
megaDebridApiDisabledAccountIds: [],
|
|
megaDebridWebDisabledAccountIds: [accountId]
|
|
}), "utf8");
|
|
|
|
const loaded = loadSettings(paths);
|
|
|
|
expect(loaded.megaDebridApiDisabledAccountIds).toEqual([]);
|
|
expect(loaded.megaDebridWebDisabledAccountIds).toEqual([accountId]);
|
|
});
|
|
|
|
it("re-aktiviert KEINE bewusst deaktivierten Mega-Flags und migriert nicht ohne Mega-Creds", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const deliberatelyDisabled = {
|
|
megaLogin: "mega-user",
|
|
megaPassword: "mega-pass",
|
|
megaDebridPreferApi: true,
|
|
megaDebridApiEnabled: false,
|
|
megaDebridWebEnabled: false
|
|
};
|
|
fs.writeFileSync(paths.configFile, JSON.stringify(deliberatelyDisabled), "utf8");
|
|
const loaded = loadSettings(paths);
|
|
expect(loaded.megaDebridApiEnabled).toBe(false);
|
|
expect(loaded.megaDebridWebEnabled).toBe(false);
|
|
|
|
const dir2 = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir2);
|
|
const paths2 = createStoragePaths(dir2);
|
|
const noCreds = {
|
|
megaDebridPreferApi: true,
|
|
providerPrimary: "realdebrid"
|
|
};
|
|
fs.writeFileSync(paths2.configFile, JSON.stringify(noCreds), "utf8");
|
|
const loadedNoCreds = loadSettings(paths2);
|
|
expect(loadedNoCreds.megaDebridApiEnabled).toBe(false);
|
|
expect(loadedNoCreds.megaDebridWebEnabled).toBe(false);
|
|
});
|
|
|
|
it("normalizes provider daily limits and resets stale daily usage", () => {
|
|
const [debridLinkKey] = parseDebridLinkApiKeys("dl-key-one");
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
megaLogin: "mega-user",
|
|
megaPassword: "mega-pass",
|
|
megaDebridApiEnabled: true,
|
|
debridLinkApiKeys: "dl-key-one",
|
|
providerDailyLimitBytes: {
|
|
realdebrid: 1024,
|
|
megadebrid: 2048
|
|
} as AppSettings["providerDailyLimitBytes"],
|
|
providerTotalUsageBytes: {
|
|
realdebrid: 16384,
|
|
megadebrid: 32768
|
|
} as AppSettings["providerTotalUsageBytes"],
|
|
debridLinkApiKeyDailyLimitBytes: {
|
|
[debridLinkKey.id]: 3072,
|
|
stale: 1234
|
|
},
|
|
providerDailyUsageDay: "2001-01-01",
|
|
providerDailyUsageBytes: {
|
|
realdebrid: 4096,
|
|
megadebrid: 8192
|
|
} as AppSettings["providerDailyUsageBytes"],
|
|
debridLinkApiKeyDailyUsageBytes: {
|
|
[debridLinkKey.id]: 8192,
|
|
stale: 9999
|
|
},
|
|
debridLinkApiKeyTotalUsageBytes: {
|
|
[debridLinkKey.id]: 12288,
|
|
stale: 9999
|
|
}
|
|
});
|
|
|
|
expect(normalized.providerDailyLimitBytes.realdebrid).toBe(1024);
|
|
expect(normalized.providerDailyLimitBytes["megadebrid-api"]).toBe(2048);
|
|
expect(normalized.debridLinkApiKeyDailyLimitBytes).toEqual({
|
|
[debridLinkKey.id]: 3072
|
|
});
|
|
expect(normalized.providerTotalUsageBytes).toEqual({
|
|
realdebrid: 16384,
|
|
"megadebrid-api": 32768
|
|
});
|
|
expect(normalized.providerDailyUsageDay).toBe(getProviderUsageDayKey());
|
|
expect(normalized.providerDailyUsageBytes).toEqual({});
|
|
expect(normalized.debridLinkApiKeyDailyUsageBytes).toEqual({});
|
|
expect(normalized.debridLinkApiKeyTotalUsageBytes).toEqual({
|
|
[debridLinkKey.id]: 12288
|
|
});
|
|
});
|
|
|
|
it("normalizes archive password list line endings", () => {
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
archivePasswordList: "one\r\ntwo\r\nthree"
|
|
});
|
|
|
|
expect(normalized.archivePasswordList).toBe("one\ntwo\nthree");
|
|
});
|
|
|
|
it("defaults Real-Debrid web login to disabled and normalizes the flag", () => {
|
|
expect(defaultSettings().realDebridUseWebLogin).toBe(false);
|
|
|
|
const normalizedEnabled = normalizeSettings({
|
|
...defaultSettings(),
|
|
realDebridUseWebLogin: 1 as unknown as boolean
|
|
});
|
|
expect(normalizedEnabled.realDebridUseWebLogin).toBe(true);
|
|
|
|
const normalizedDisabled = normalizeSettings({
|
|
...defaultSettings(),
|
|
realDebridUseWebLogin: 0 as unknown as boolean
|
|
});
|
|
expect(normalizedDisabled.realDebridUseWebLogin).toBe(false);
|
|
});
|
|
|
|
it("migrates legacy Real-Debrid API and Web accounts with their existing status", () => {
|
|
const checkedAt = Date.now();
|
|
const apiToken = "legacy-real-debrid-token";
|
|
const legacyApi = {
|
|
...defaultSettings(),
|
|
token: apiToken,
|
|
debridAccountStatuses: {
|
|
"svc-realdebrid": {
|
|
accountId: "svc-realdebrid",
|
|
provider: "realdebrid",
|
|
label: "Real-Debrid",
|
|
maskedLogin: "API-Token",
|
|
valid: true,
|
|
isPremium: true,
|
|
premiumUntilMs: checkedAt + 1000,
|
|
username: "api-user",
|
|
message: "Premium aktiv",
|
|
checkedAt
|
|
}
|
|
}
|
|
} as Partial<AppSettings>;
|
|
delete legacyApi.realDebridApiTokens;
|
|
delete legacyApi.realDebridWebAccountIds;
|
|
const normalizedApi = normalizeSettings(legacyApi as AppSettings);
|
|
const [migratedApiAccount] = parseRealDebridApiAccounts(normalizedApi.realDebridApiTokens);
|
|
const apiId = migratedApiAccount.id;
|
|
|
|
expect(migratedApiAccount.token).toBe(apiToken);
|
|
expect(apiId).toMatch(/^rda_[A-Za-z0-9_-]+$/);
|
|
expect(normalizedApi.realDebridWebAccountIds).toEqual([]);
|
|
expect(normalizedApi.debridAccountStatuses[apiId]).toMatchObject({
|
|
accountId: apiId,
|
|
provider: "realdebrid",
|
|
username: "api-user"
|
|
});
|
|
expect(normalizedApi.debridAccountStatuses["svc-realdebrid"]).toBeUndefined();
|
|
|
|
const legacyWeb = {
|
|
...defaultSettings(),
|
|
realDebridUseWebLogin: true,
|
|
debridAccountStatuses: {
|
|
"svc-realdebrid": {
|
|
accountId: "svc-realdebrid",
|
|
provider: "realdebrid",
|
|
label: "Real-Debrid",
|
|
maskedLogin: "Browser-Login",
|
|
valid: true,
|
|
isPremium: true,
|
|
premiumUntilMs: checkedAt + 1000,
|
|
username: "web-user",
|
|
message: "Premium aktiv",
|
|
checkedAt
|
|
}
|
|
}
|
|
} as Partial<AppSettings>;
|
|
delete legacyWeb.realDebridApiTokens;
|
|
delete legacyWeb.realDebridWebAccountIds;
|
|
const normalizedWeb = normalizeSettings(legacyWeb as AppSettings);
|
|
|
|
expect(normalizedWeb.realDebridApiTokens).toBe("");
|
|
expect(normalizedWeb.realDebridWebAccountIds).toEqual(["rdw_legacy"]);
|
|
expect(normalizedWeb.debridAccountStatuses.rdw_legacy).toMatchObject({
|
|
accountId: "rdw_legacy",
|
|
provider: "realdebrid",
|
|
username: "web-user"
|
|
});
|
|
});
|
|
|
|
it("keeps authoritative empty Real-Debrid pools empty instead of restoring legacy accounts", () => {
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
token: "deleted-legacy-api-token",
|
|
realDebridUseWebLogin: true,
|
|
realDebridApiTokens: "",
|
|
realDebridWebAccountIds: []
|
|
});
|
|
|
|
expect(normalized.realDebridApiTokens).toBe("");
|
|
expect(normalized.realDebridWebAccountIds).toEqual([]);
|
|
});
|
|
|
|
it("keeps two opaque Real-Debrid API IDs across normalize, save and load", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-opaque-rd-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const expected = [
|
|
{ id: "rda_persistedFirst", token: "persisted-first-token" },
|
|
{ id: "rda_persistedSecond", token: "persisted-second-token" }
|
|
];
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
realDebridApiTokens: serializeRealDebridApiAccounts(expected)
|
|
});
|
|
|
|
saveSettings(paths, normalized);
|
|
const loaded = loadSettings(paths);
|
|
|
|
expect(parseRealDebridApiAccounts(normalized.realDebridApiTokens).map(({ id, token }) => ({ id, token }))).toEqual(expected);
|
|
expect(parseRealDebridApiAccounts(loaded.realDebridApiTokens).map(({ id, token }) => ({ id, token }))).toEqual(expected);
|
|
expect(normalizeSettings(loaded)).toEqual(loaded);
|
|
});
|
|
|
|
it("prefers a concrete Real-Debrid status over the legacy status regardless of object order", () => {
|
|
const token = "status-order-token";
|
|
const accountId = "rda_statusOrder";
|
|
const checkedAt = Date.now();
|
|
const legacyStatus = {
|
|
accountId: "svc-realdebrid",
|
|
provider: "realdebrid" as const,
|
|
label: "Legacy",
|
|
maskedLogin: "Legacy",
|
|
valid: false,
|
|
isPremium: false,
|
|
premiumUntilMs: null,
|
|
username: "legacy-user",
|
|
message: "Legacy status",
|
|
checkedAt: checkedAt - 1000
|
|
};
|
|
const concreteStatus = {
|
|
...legacyStatus,
|
|
accountId,
|
|
label: "Concrete",
|
|
valid: true,
|
|
isPremium: true,
|
|
username: "concrete-user",
|
|
message: "Concrete status",
|
|
checkedAt
|
|
};
|
|
const normalizeWithOrder = (entries: [string, typeof legacyStatus][]) => normalizeSettings({
|
|
...defaultSettings(),
|
|
realDebridApiTokens: serializeRealDebridApiAccounts([{ id: accountId, token }]),
|
|
debridAccountStatuses: Object.fromEntries(entries)
|
|
}).debridAccountStatuses[accountId];
|
|
|
|
expect(normalizeWithOrder([["svc-realdebrid", legacyStatus], [accountId, concreteStatus]])).toMatchObject({
|
|
valid: true,
|
|
username: "concrete-user"
|
|
});
|
|
expect(normalizeWithOrder([[accountId, concreteStatus], ["svc-realdebrid", legacyStatus]])).toMatchObject({
|
|
valid: true,
|
|
username: "concrete-user"
|
|
});
|
|
});
|
|
|
|
it("normalizes the Real-Debrid pool idempotently and prunes stale account maps", () => {
|
|
const apiId = "rda_apiPrimary";
|
|
const secondApiId = "rda_apiSecond";
|
|
const today = getProviderUsageDayKey();
|
|
const once = normalizeSettings({
|
|
...defaultSettings(),
|
|
realDebridApiTokens: serializeRealDebridApiAccounts([
|
|
{ id: apiId, token: "api-token" },
|
|
{ id: "rda_duplicate", token: "api-token" },
|
|
{ id: secondApiId, token: "second-token" }
|
|
]),
|
|
realDebridWebAccountIds: ["rdw_legacy", "rdw_second", "broken", "rdw_second"],
|
|
realDebridDisabledAccountIds: [apiId, "rdw_second", "stale"],
|
|
realDebridAccountDailyLimitBytes: { [apiId]: 1000, rdw_second: 2000, stale: 3000 },
|
|
realDebridAccountDailyUsageBytes: { [apiId]: 4000, stale: 5000 },
|
|
realDebridAccountTotalUsageBytes: { rdw_second: 6000, stale: 7000 },
|
|
providerDailyUsageDay: today
|
|
});
|
|
const twice = normalizeSettings(once);
|
|
|
|
expect(parseRealDebridApiAccounts(once.realDebridApiTokens).map((account) => ({ id: account.id, token: account.token }))).toEqual([
|
|
{ id: apiId, token: "api-token" },
|
|
{ id: secondApiId, token: "second-token" }
|
|
]);
|
|
expect(once.realDebridWebAccountIds).toEqual(["rdw_legacy", "rdw_second"]);
|
|
expect(once.realDebridDisabledAccountIds).toEqual([apiId, "rdw_second"]);
|
|
expect(once.realDebridAccountDailyLimitBytes).toEqual({ [apiId]: 1000, rdw_second: 2000 });
|
|
expect(once.realDebridAccountDailyUsageBytes).toEqual({ [apiId]: 4000 });
|
|
expect(once.realDebridAccountTotalUsageBytes).toEqual({ rdw_second: 6000 });
|
|
expect(twice).toEqual(once);
|
|
});
|
|
|
|
it("resets stale per-account Real-Debrid daily usage", () => {
|
|
const apiId = "rda_staleUsage";
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
realDebridApiTokens: serializeRealDebridApiAccounts([{ id: apiId, token: "api-token" }]),
|
|
providerDailyUsageDay: "2001-01-01",
|
|
realDebridAccountDailyUsageBytes: { [apiId]: 4000 },
|
|
realDebridAccountTotalUsageBytes: { [apiId]: 9000 }
|
|
});
|
|
|
|
expect(normalized.realDebridAccountDailyUsageBytes).toEqual({});
|
|
expect(normalized.realDebridAccountTotalUsageBytes).toEqual({ [apiId]: 9000 });
|
|
});
|
|
|
|
it("moves the Real-Debrid service status to the migrated Web account", () => {
|
|
const checkedAt = Date.now();
|
|
const legacy = {
|
|
...defaultSettings(),
|
|
realDebridUseWebLogin: true,
|
|
debridAccountStatuses: {
|
|
"svc-realdebrid": {
|
|
accountId: "svc-realdebrid",
|
|
provider: "realdebrid",
|
|
label: "Real-Debrid",
|
|
maskedLogin: "Browser-Login",
|
|
valid: true,
|
|
isPremium: true,
|
|
premiumUntilMs: checkedAt + 1000,
|
|
username: "web-user",
|
|
email: "w***r@example.test",
|
|
message: "Premium aktiv",
|
|
checkedAt
|
|
}
|
|
}
|
|
} as Partial<AppSettings>;
|
|
delete legacy.realDebridApiTokens;
|
|
delete legacy.realDebridWebAccountIds;
|
|
const normalized = normalizeSettings(legacy as AppSettings);
|
|
|
|
expect(normalized.debridAccountStatuses.rdw_legacy).toMatchObject({
|
|
accountId: "rdw_legacy",
|
|
provider: "realdebrid",
|
|
valid: true,
|
|
username: "web-user",
|
|
email: "w***r@example.test",
|
|
checkedAt
|
|
});
|
|
});
|
|
|
|
it("migrates a legacy Debrid-Link username out of the email field", () => {
|
|
const [key] = parseDebridLinkApiKeys("dl-key-one");
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
debridLinkApiKeys: "dl-key-one",
|
|
debridAccountStatuses: {
|
|
[key.id]: {
|
|
accountId: key.id,
|
|
provider: "debridlink",
|
|
label: "Key 1",
|
|
maskedLogin: key.masked,
|
|
valid: true,
|
|
isPremium: false,
|
|
premiumUntilMs: 0,
|
|
email: "xsucukde5",
|
|
message: "Kein Premium (Free)",
|
|
checkedAt: Date.now()
|
|
}
|
|
}
|
|
});
|
|
|
|
expect(normalized.debridAccountStatuses[key.id].username).toBe("xsucukde5");
|
|
expect(normalized.debridAccountStatuses[key.id].email).toBeUndefined();
|
|
});
|
|
|
|
it("defaults AllDebrid web login to disabled and normalizes the flag", () => {
|
|
expect(defaultSettings().allDebridUseWebLogin).toBe(false);
|
|
|
|
const normalizedEnabled = normalizeSettings({
|
|
...defaultSettings(),
|
|
allDebridUseWebLogin: 1 as unknown as boolean
|
|
});
|
|
expect(normalizedEnabled.allDebridUseWebLogin).toBe(true);
|
|
|
|
const normalizedDisabled = normalizeSettings({
|
|
...defaultSettings(),
|
|
allDebridUseWebLogin: 0 as unknown as boolean
|
|
});
|
|
expect(normalizedDisabled.allDebridUseWebLogin).toBe(false);
|
|
});
|
|
|
|
it("defaults history retention to permanent and normalizes invalid values", () => {
|
|
expect(defaultSettings().historyRetentionMode).toBe("permanent");
|
|
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
historyRetentionMode: "broken" as unknown as AppSettings["historyRetentionMode"]
|
|
});
|
|
|
|
expect(normalized.historyRetentionMode).toBe("permanent");
|
|
});
|
|
|
|
it("loads legacy history without inventing structured durations", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
fs.writeFileSync(paths.historyFile, JSON.stringify([{
|
|
id: "legacy",
|
|
name: "Altbestand",
|
|
totalBytes: 1_000,
|
|
downloadedBytes: 1_000,
|
|
fileCount: 1,
|
|
provider: "realdebrid",
|
|
completedAt: 10_000,
|
|
durationSeconds: 9,
|
|
status: "completed",
|
|
outputDir: "C:\\Downloads\\Altbestand"
|
|
}]), "utf8");
|
|
|
|
const [loaded] = loadHistory(paths);
|
|
|
|
expect(loaded).toEqual(expect.objectContaining({
|
|
durationSeconds: 9,
|
|
status: "completed"
|
|
}));
|
|
expect(loaded.downloadDurationSeconds).toBeUndefined();
|
|
expect(loaded.totalDurationSeconds).toBeUndefined();
|
|
});
|
|
|
|
it.each(["completed", "partial", "failed", "cancelled", "deleted"] as const)("preserves the %s history status", (status) => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
fs.writeFileSync(paths.historyFile, JSON.stringify([{
|
|
id: `history-${status}`,
|
|
name: "Paket",
|
|
completedAt: 10_000,
|
|
durationSeconds: 1,
|
|
status,
|
|
outputDir: "C:\\Downloads\\Paket"
|
|
}]), "utf8");
|
|
|
|
expect(loadHistory(paths)[0]?.status).toBe(status);
|
|
});
|
|
|
|
it("clamps expanded history metrics and preserves normalized operations", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
fs.writeFileSync(paths.historyFile, JSON.stringify([{
|
|
id: "structured",
|
|
name: "Paket",
|
|
completedAt: 50_000,
|
|
durationSeconds: 1,
|
|
status: "failed",
|
|
outputDir: "C:\\Downloads\\Paket",
|
|
startedAt: -10,
|
|
downloadEndedAt: 20_000,
|
|
postProcessStartedAt: 25_000,
|
|
downloadDurationSeconds: -120,
|
|
extractionDurationSeconds: 30,
|
|
remuxDurationSeconds: 5,
|
|
postProcessDurationSeconds: 35,
|
|
totalDurationSeconds: 50,
|
|
successfulFiles: -1,
|
|
failedFiles: 1,
|
|
cancelledFiles: 0,
|
|
archiveCount: 1,
|
|
partCount: 16,
|
|
outputCount: 15,
|
|
failurePhase: "extract",
|
|
errorCategory: "checksum",
|
|
downloadFailures: 2,
|
|
offlineFailures: 1,
|
|
extractionFailures: 3,
|
|
remuxFailures: 4,
|
|
cleanupFailures: 5,
|
|
postProcessFailures: 6,
|
|
archiveOperations: [{
|
|
id: "archive-1",
|
|
name: "Paket.part01.rar",
|
|
itemIds: ["item-1", "", "item-2"],
|
|
partCount: -16,
|
|
startedAt: 25_000,
|
|
completedAt: 50_000,
|
|
durationMs: -30_000,
|
|
status: "failed",
|
|
errorCategory: "checksum"
|
|
}],
|
|
remuxOperations: [{
|
|
id: "remux-1",
|
|
fileName: "episode.mkv",
|
|
startedAt: 30_000,
|
|
completedAt: 35_000,
|
|
durationMs: 5_000,
|
|
status: "cancelled",
|
|
errorCategory: "cancelled"
|
|
}]
|
|
}]), "utf8");
|
|
|
|
expect(loadHistory(paths)[0]).toEqual(expect.objectContaining({
|
|
status: "failed",
|
|
startedAt: 0,
|
|
downloadEndedAt: 20_000,
|
|
postProcessStartedAt: 25_000,
|
|
downloadDurationSeconds: 0,
|
|
extractionDurationSeconds: 30,
|
|
remuxDurationSeconds: 5,
|
|
postProcessDurationSeconds: 35,
|
|
totalDurationSeconds: 50,
|
|
successfulFiles: 0,
|
|
failedFiles: 1,
|
|
cancelledFiles: 0,
|
|
archiveCount: 1,
|
|
partCount: 16,
|
|
outputCount: 15,
|
|
failurePhase: "extract",
|
|
errorCategory: "Entpacken",
|
|
downloadFailures: 2,
|
|
offlineFailures: 1,
|
|
extractionFailures: 3,
|
|
remuxFailures: 4,
|
|
cleanupFailures: 5,
|
|
postProcessFailures: 6,
|
|
archiveOperations: [{
|
|
id: "archive-1",
|
|
name: "Paket.part01.rar",
|
|
itemIds: ["item-1", "item-2"],
|
|
partCount: 0,
|
|
startedAt: 25_000,
|
|
completedAt: 50_000,
|
|
durationMs: 0,
|
|
status: "failed",
|
|
errorCategory: "Entpacken"
|
|
}],
|
|
remuxOperations: [{
|
|
id: "remux-1",
|
|
fileName: "episode.mkv",
|
|
startedAt: 30_000,
|
|
completedAt: 35_000,
|
|
durationMs: 5_000,
|
|
status: "cancelled",
|
|
errorCategory: "Remux"
|
|
}]
|
|
}));
|
|
});
|
|
|
|
it("preserves package lifecycle timestamps and operation metrics when loading a session", () => {
|
|
const normalized = normalizeLoadedSession({
|
|
version: 2,
|
|
packageOrder: ["pkg-1"],
|
|
packages: {
|
|
"pkg-1": {
|
|
id: "pkg-1",
|
|
name: "Paket",
|
|
outputDir: "C:\\Downloads\\Paket",
|
|
extractDir: "C:\\Downloads\\Paket",
|
|
status: "completed",
|
|
itemIds: [],
|
|
cancelled: false,
|
|
enabled: true,
|
|
resultGeneration: 7,
|
|
downloadStartedAt: 1_000,
|
|
downloadCompletedAt: 10_000,
|
|
downloadEndedAt: 12_000,
|
|
postProcessQueuedAt: 13_000,
|
|
postProcessStartedAt: 14_000,
|
|
postProcessCompletedAt: 20_000,
|
|
terminalAt: 21_000,
|
|
archiveOperations: [{
|
|
id: "archive-1",
|
|
name: "Paket.rar",
|
|
itemIds: [],
|
|
partCount: 1,
|
|
startedAt: 14_000,
|
|
completedAt: 18_000,
|
|
durationMs: 4_000,
|
|
status: "completed",
|
|
errorCategory: ""
|
|
}],
|
|
remuxOperations: [],
|
|
outputCount: 1,
|
|
outputBaselineSignatures: [
|
|
"a".repeat(64),
|
|
"invalid",
|
|
"b".repeat(64)
|
|
],
|
|
cleanupErrorCategory: "",
|
|
postProcessErrorCategory: "rename failed",
|
|
createdAt: 1_000,
|
|
updatedAt: 21_000
|
|
}
|
|
},
|
|
items: {},
|
|
runStartedAt: 1_000,
|
|
totalDownloadedBytes: 0,
|
|
summaryText: "",
|
|
reconnectUntil: 0,
|
|
reconnectReason: "",
|
|
paused: false,
|
|
running: false,
|
|
updatedAt: 21_000
|
|
});
|
|
|
|
expect(normalized.packages["pkg-1"]).toEqual(expect.objectContaining({
|
|
resultGeneration: 7,
|
|
downloadEndedAt: 12_000,
|
|
postProcessQueuedAt: 13_000,
|
|
postProcessStartedAt: 14_000,
|
|
postProcessCompletedAt: 20_000,
|
|
terminalAt: 21_000,
|
|
archiveOperations: [expect.objectContaining({ id: "archive-1", durationMs: 4_000 })],
|
|
remuxOperations: [],
|
|
outputCount: 1,
|
|
outputBaselineSignatures: ["a".repeat(64), "b".repeat(64)],
|
|
cleanupErrorCategory: "",
|
|
postProcessErrorCategory: "Nachbearbeitung"
|
|
}));
|
|
});
|
|
|
|
it("migrates persisted package failure details to safe categories", () => {
|
|
const normalized = normalizeLoadedSession({
|
|
version: 2,
|
|
packageOrder: ["pkg-private"],
|
|
packages: {
|
|
"pkg-private": {
|
|
id: "pkg-private",
|
|
name: "Private telemetry",
|
|
outputDir: "C:\\Downloads\\Private",
|
|
extractDir: "C:\\Downloads\\Private",
|
|
status: "failed",
|
|
itemIds: [],
|
|
cancelled: false,
|
|
enabled: true,
|
|
archiveOperations: [{
|
|
id: "archive-private",
|
|
name: "private.rar",
|
|
itemIds: [],
|
|
partCount: 1,
|
|
startedAt: 1_000,
|
|
completedAt: 2_000,
|
|
durationMs: 1_000,
|
|
status: "failed",
|
|
errorCategory: "CRC_ERROR in C:\\Users\\Alice\\private.rar"
|
|
}],
|
|
remuxOperations: [{
|
|
id: "remux-private",
|
|
fileName: "private.mkv",
|
|
startedAt: 2_000,
|
|
completedAt: 3_000,
|
|
durationMs: 1_000,
|
|
status: "failed",
|
|
errorCategory: "ffmpeg failed for https://private.example.test/private.mkv"
|
|
}, {
|
|
id: "remux-disk-full",
|
|
fileName: "disk-full.mkv",
|
|
startedAt: 3_000,
|
|
completedAt: 4_000,
|
|
durationMs: 1_000,
|
|
status: "failed",
|
|
errorCategory: "disk_full at C:\\Users\\Alice\\disk-full.mkv"
|
|
}],
|
|
cleanupErrorCategory: "unlink failed for C:\\Users\\Alice\\private.rar",
|
|
createdAt: 1_000,
|
|
updatedAt: 4_000
|
|
}
|
|
},
|
|
items: {},
|
|
runStartedAt: 1_000,
|
|
totalDownloadedBytes: 0,
|
|
summaryText: "",
|
|
reconnectUntil: 0,
|
|
reconnectReason: "",
|
|
paused: false,
|
|
running: false,
|
|
updatedAt: 4_000
|
|
});
|
|
const pkg = normalized.packages["pkg-private"];
|
|
|
|
expect(pkg.archiveOperations?.[0]?.errorCategory).toBe("Entpacken");
|
|
expect(pkg.remuxOperations?.map((operation) => operation.errorCategory)).toEqual(["Remux", "Speicherplatz"]);
|
|
expect(pkg.cleanupErrorCategory).toBe("Cleanup");
|
|
});
|
|
|
|
it("skips adding persisted history entries when history retention is never", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
const result = addHistoryEntryForRetention(paths, "never", {
|
|
id: "hist-1",
|
|
name: "ignored",
|
|
totalBytes: 1024,
|
|
downloadedBytes: 1024,
|
|
fileCount: 1,
|
|
provider: "realdebrid",
|
|
completedAt: Date.now(),
|
|
durationSeconds: 12,
|
|
status: "completed",
|
|
outputDir: path.join(dir, "out"),
|
|
urls: ["https://example.com/file.rar"]
|
|
});
|
|
|
|
expect(result).toEqual([]);
|
|
expect(loadHistory(paths)).toEqual([]);
|
|
expect(loadHistoryForRetention(paths, "never")).toEqual([]);
|
|
});
|
|
|
|
it("clears persisted history for session retention mode", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
saveHistory(paths, [{
|
|
id: "hist-2",
|
|
name: "kept",
|
|
totalBytes: 2048,
|
|
downloadedBytes: 2048,
|
|
fileCount: 1,
|
|
provider: "realdebrid",
|
|
completedAt: Date.now(),
|
|
durationSeconds: 20,
|
|
status: "completed",
|
|
outputDir: path.join(dir, "out"),
|
|
urls: ["https://example.com/file2.rar"]
|
|
}]);
|
|
saveHistory(paths, [{
|
|
id: "hist-3",
|
|
name: "newer",
|
|
totalBytes: 4096,
|
|
downloadedBytes: 4096,
|
|
fileCount: 1,
|
|
provider: "realdebrid",
|
|
completedAt: Date.now(),
|
|
durationSeconds: 25,
|
|
status: "completed",
|
|
outputDir: path.join(dir, "out"),
|
|
urls: ["https://example.com/file3.rar"]
|
|
}]);
|
|
|
|
resetHistoryForRetention(paths, "session");
|
|
|
|
expect(loadHistory(paths)).toEqual([]);
|
|
expect(fs.existsSync(`${paths.historyFile}.bak`)).toBe(false);
|
|
});
|
|
|
|
it("recovers history from the last valid backup when the primary file is corrupted", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const entry = {
|
|
id: "history-backup",
|
|
name: "Backup",
|
|
totalBytes: 1,
|
|
downloadedBytes: 1,
|
|
fileCount: 1,
|
|
provider: "realdebrid" as const,
|
|
completedAt: Date.now(),
|
|
durationSeconds: 1,
|
|
status: "completed" as const,
|
|
outputDir: path.join(dir, "out"),
|
|
urls: []
|
|
};
|
|
saveHistory(paths, [entry]);
|
|
saveHistory(paths, [{ ...entry, id: "newer", name: "Neuer" }]);
|
|
fs.writeFileSync(paths.historyFile, "{broken", "utf8");
|
|
|
|
expect(loadHistory(paths).map((item) => item.id)).toEqual(["history-backup"]);
|
|
expect(loadHistory(paths).map((item) => item.id)).toEqual(["history-backup"]);
|
|
});
|
|
|
|
it("reports an unreadable history instead of silently replacing it with an empty list", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
fs.mkdirSync(paths.baseDir, { recursive: true });
|
|
fs.writeFileSync(paths.historyFile, "{broken", "utf8");
|
|
fs.writeFileSync(`${paths.historyFile}.bak`, "{also-broken", "utf8");
|
|
|
|
expect(() => loadHistory(paths)).toThrow("Verlaufsspeicher ist beschädigt");
|
|
});
|
|
|
|
it("returns a valid history backup even when repairing the primary file fails", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const entry = {
|
|
id: "readable-backup",
|
|
name: "Backup",
|
|
totalBytes: 1,
|
|
downloadedBytes: 1,
|
|
fileCount: 1,
|
|
provider: "realdebrid" as const,
|
|
completedAt: Date.now(),
|
|
durationSeconds: 1,
|
|
status: "completed" as const,
|
|
outputDir: path.join(dir, "out"),
|
|
urls: []
|
|
};
|
|
saveHistory(paths, [entry]);
|
|
saveHistory(paths, [{ ...entry, id: "newer" }]);
|
|
fs.writeFileSync(paths.historyFile, "{broken", "utf8");
|
|
const rename = vi.spyOn(fs, "renameSync").mockImplementation(() => {
|
|
throw Object.assign(new Error("locked"), { code: "EPERM" });
|
|
});
|
|
try {
|
|
expect(loadHistory(paths).map((item) => item.id)).toEqual(["readable-backup"]);
|
|
} finally {
|
|
rename.mockRestore();
|
|
}
|
|
});
|
|
|
|
it("authoritatively replaces both history copies without retaining previous entries", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
saveHistory(paths, [{ id: "old", name: "Alt" } as never]);
|
|
|
|
replaceHistory(paths, [{ id: "new", name: "Neu" } as never]);
|
|
|
|
expect(loadHistory(paths).map((entry) => entry.id)).toEqual(["new"]);
|
|
expect((JSON.parse(fs.readFileSync(`${paths.historyFile}.bak`, "utf8")) as Array<{ id: string }>).map((entry) => entry.id)).toEqual(["new"]);
|
|
});
|
|
|
|
it("rolls back the backup copy when authoritative primary replacement fails", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
saveHistory(paths, [{ id: "older", name: "Älter" } as never]);
|
|
saveHistory(paths, [{ id: "old", name: "Alt" } as never]);
|
|
const previousBackup = fs.readFileSync(`${paths.historyFile}.bak`, "utf8");
|
|
const renameFile = fs.renameSync.bind(fs);
|
|
let failed = false;
|
|
const rename = vi.spyOn(fs, "renameSync").mockImplementation((source, destination) => {
|
|
if (!failed && String(destination) === paths.historyFile) {
|
|
failed = true;
|
|
throw Object.assign(new Error("primary locked"), { code: "EPERM" });
|
|
}
|
|
return renameFile(source, destination);
|
|
});
|
|
|
|
try {
|
|
expect(() => replaceHistory(paths, [{ id: "new", name: "Neu" } as never])).toThrow("primary locked");
|
|
} finally {
|
|
rename.mockRestore();
|
|
}
|
|
|
|
expect(loadHistory(paths).map((entry) => entry.id)).toEqual(["old"]);
|
|
expect(fs.readFileSync(`${paths.historyFile}.bak`, "utf8")).toBe(previousBackup);
|
|
});
|
|
|
|
it("keeps the primary history intact when clearing its backup fails", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const entry = {
|
|
id: "clear-protected",
|
|
name: "Geschützt",
|
|
totalBytes: 1,
|
|
downloadedBytes: 1,
|
|
fileCount: 1,
|
|
provider: "realdebrid" as const,
|
|
completedAt: Date.now(),
|
|
durationSeconds: 1,
|
|
status: "completed" as const,
|
|
outputDir: path.join(dir, "out"),
|
|
urls: []
|
|
};
|
|
saveHistory(paths, [entry]);
|
|
saveHistory(paths, [{ ...entry, id: "clear-current" }]);
|
|
const removeFile = fs.rmSync.bind(fs);
|
|
const remove = vi.spyOn(fs, "rmSync").mockImplementation((filePath, options) => {
|
|
if (String(filePath) === `${paths.historyFile}.bak`) throw Object.assign(new Error("busy"), { code: "EBUSY" });
|
|
return removeFile(filePath, options);
|
|
});
|
|
try {
|
|
expect(() => clearHistory(paths)).toThrow();
|
|
expect(fs.existsSync(paths.historyFile)).toBe(true);
|
|
} finally {
|
|
remove.mockRestore();
|
|
}
|
|
});
|
|
|
|
it("caps persisted history to the configured maxEntries", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const now = Date.now();
|
|
const entries = Array.from({ length: 10 }, (_unused, i) => ({
|
|
id: `h-${i}`,
|
|
name: `e${i}`,
|
|
totalBytes: 1,
|
|
downloadedBytes: 1,
|
|
fileCount: 1,
|
|
provider: "realdebrid" as const,
|
|
completedAt: now - i * 1000,
|
|
durationSeconds: 1,
|
|
status: "completed" as const,
|
|
outputDir: path.join(dir, "out"),
|
|
urls: []
|
|
}));
|
|
|
|
saveHistory(paths, entries, { maxEntries: 3, maxAgeDays: 0 });
|
|
|
|
const loaded = loadHistory(paths, { maxEntries: 3, maxAgeDays: 0 });
|
|
expect(loaded).toHaveLength(3);
|
|
expect(loaded.map((e) => e.id)).toEqual(["h-0", "h-1", "h-2"]);
|
|
});
|
|
|
|
it("drops history entries older than maxAgeDays", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const now = Date.now();
|
|
const day = 24 * 60 * 60 * 1000;
|
|
const fresh = {
|
|
id: "fresh",
|
|
name: "fresh",
|
|
totalBytes: 1,
|
|
downloadedBytes: 1,
|
|
fileCount: 1,
|
|
provider: "realdebrid" as const,
|
|
completedAt: now - 2 * day,
|
|
durationSeconds: 1,
|
|
status: "completed" as const,
|
|
outputDir: path.join(dir, "out"),
|
|
urls: []
|
|
};
|
|
const old = { ...fresh, id: "old", name: "old", completedAt: now - 40 * day };
|
|
|
|
saveHistory(paths, [fresh, old], { maxEntries: 500, maxAgeDays: 30 });
|
|
|
|
const loaded = loadHistory(paths, { maxEntries: 500, maxAgeDays: 30 });
|
|
expect(loaded.map((e) => e.id)).toEqual(["fresh"]);
|
|
});
|
|
|
|
it("assigns and preserves bandwidth schedule ids", () => {
|
|
const normalized = normalizeSettings({
|
|
...defaultSettings(),
|
|
bandwidthSchedules: [{ id: "", startHour: 1, endHour: 6, speedLimitKbps: 1024, enabled: true }]
|
|
});
|
|
|
|
const generatedId = normalized.bandwidthSchedules[0]?.id;
|
|
expect(typeof generatedId).toBe("string");
|
|
expect(generatedId?.length).toBeGreaterThan(0);
|
|
|
|
const normalizedAgain = normalizeSettings({
|
|
...defaultSettings(),
|
|
bandwidthSchedules: normalized.bandwidthSchedules
|
|
});
|
|
expect(normalizedAgain.bandwidthSchedules[0]?.id).toBe(generatedId);
|
|
});
|
|
|
|
it("resets stale active statuses to queued on session load", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
const session = emptySession();
|
|
session.packages["pkg1"] = {
|
|
id: "pkg1",
|
|
name: "Test Package",
|
|
outputDir: "/tmp/out",
|
|
extractDir: "/tmp/extract",
|
|
status: "downloading",
|
|
itemIds: ["item1", "item2", "item3", "item4"],
|
|
cancelled: false,
|
|
enabled: true,
|
|
downloadStartedAt: 0,
|
|
downloadCompletedAt: 0,
|
|
createdAt: Date.now(),
|
|
updatedAt: Date.now()
|
|
};
|
|
session.items["item1"] = {
|
|
id: "item1",
|
|
packageId: "pkg1",
|
|
url: "https://example.com/file1.rar",
|
|
provider: null,
|
|
status: "downloading",
|
|
retries: 0,
|
|
speedBps: 1024,
|
|
downloadedBytes: 5000,
|
|
totalBytes: 10000,
|
|
progressPercent: 50,
|
|
fileName: "file1.rar",
|
|
targetPath: "/tmp/out/file1.rar",
|
|
resumable: true,
|
|
attempts: 1,
|
|
lastError: "some error",
|
|
fullStatus: "",
|
|
createdAt: Date.now(),
|
|
updatedAt: Date.now()
|
|
};
|
|
session.items["item2"] = {
|
|
id: "item2",
|
|
packageId: "pkg1",
|
|
url: "https://example.com/file2.rar",
|
|
provider: null,
|
|
status: "paused",
|
|
retries: 0,
|
|
speedBps: 0,
|
|
downloadedBytes: 0,
|
|
totalBytes: null,
|
|
progressPercent: 0,
|
|
fileName: "file2.rar",
|
|
targetPath: "/tmp/out/file2.rar",
|
|
resumable: false,
|
|
attempts: 0,
|
|
lastError: "",
|
|
fullStatus: "",
|
|
createdAt: Date.now(),
|
|
updatedAt: Date.now()
|
|
};
|
|
session.items["item3"] = {
|
|
id: "item3",
|
|
packageId: "pkg1",
|
|
url: "https://example.com/file3.rar",
|
|
provider: null,
|
|
status: "completed",
|
|
retries: 0,
|
|
speedBps: 0,
|
|
downloadedBytes: 10000,
|
|
totalBytes: 10000,
|
|
progressPercent: 100,
|
|
fileName: "file3.rar",
|
|
targetPath: "/tmp/out/file3.rar",
|
|
resumable: false,
|
|
attempts: 1,
|
|
lastError: "",
|
|
fullStatus: "",
|
|
createdAt: Date.now(),
|
|
updatedAt: Date.now()
|
|
};
|
|
session.items["item4"] = {
|
|
id: "item4",
|
|
packageId: "pkg1",
|
|
url: "https://example.com/file4.rar",
|
|
provider: null,
|
|
status: "queued",
|
|
retries: 0,
|
|
speedBps: 0,
|
|
downloadedBytes: 0,
|
|
totalBytes: null,
|
|
progressPercent: 0,
|
|
fileName: "file4.rar",
|
|
targetPath: "/tmp/out/file4.rar",
|
|
resumable: false,
|
|
attempts: 0,
|
|
lastError: "",
|
|
fullStatus: "",
|
|
createdAt: Date.now(),
|
|
updatedAt: Date.now()
|
|
};
|
|
|
|
saveSession(paths, session);
|
|
const loaded = loadSession(paths);
|
|
|
|
expect(loaded.items["item1"].status).toBe("queued");
|
|
expect(loaded.items["item2"].status).toBe("queued");
|
|
expect(loaded.items["item1"].speedBps).toBe(0);
|
|
expect(loaded.items["item1"].lastError).toBe("");
|
|
expect(loaded.items["item3"].status).toBe("completed");
|
|
expect(loaded.items["item4"].status).toBe("queued");
|
|
expect(loaded.items["item1"].downloadedBytes).toBe(5000);
|
|
expect(loaded.packages["pkg1"].name).toBe("Test Package");
|
|
});
|
|
|
|
it("preserves cleaned package progress aggregates while normalizing a session", () => {
|
|
const session = emptySession();
|
|
session.packageOrder = ["pkg-progress"];
|
|
session.packages["pkg-progress"] = {
|
|
id: "pkg-progress",
|
|
name: "Progress",
|
|
outputDir: "C:\\Downloads\\Progress",
|
|
extractDir: "C:\\Downloads\\Progress\\Extracted",
|
|
status: "downloading",
|
|
itemIds: [],
|
|
cancelled: false,
|
|
enabled: true,
|
|
cleanedCompletedItemCount: 3,
|
|
cleanedExtractedItemCount: 2,
|
|
cleanedDownloadedBytes: 3_000,
|
|
cleanedTotalBytes: 4_000,
|
|
createdAt: Date.now(),
|
|
updatedAt: Date.now()
|
|
};
|
|
|
|
const normalized = normalizeLoadedSession(session);
|
|
|
|
expect(normalized.packages["pkg-progress"]).toEqual(expect.objectContaining({
|
|
cleanedCompletedItemCount: 3,
|
|
cleanedExtractedItemCount: 2,
|
|
cleanedDownloadedBytes: 3_000,
|
|
cleanedTotalBytes: 4_000
|
|
}));
|
|
});
|
|
|
|
it("removes a history selection in one pass without applying the default 500-entry limit", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const limits = { maxEntries: 1_000, maxAgeDays: 0 };
|
|
const entries = Array.from({ length: 600 }, (_, index) => ({
|
|
id: `hist-${index}`,
|
|
name: `Paket ${index}`,
|
|
totalBytes: 1024,
|
|
downloadedBytes: 1024,
|
|
fileCount: 1,
|
|
provider: "realdebrid" as const,
|
|
completedAt: Date.now() - index,
|
|
durationSeconds: 12,
|
|
status: "completed" as const,
|
|
outputDir: path.join(dir, `out-${index}`),
|
|
urls: [`https://example.com/file-${index}.rar`]
|
|
}));
|
|
saveHistory(paths, entries, limits);
|
|
const renameSpy = vi.spyOn(fs, "renameSync");
|
|
renameSpy.mockClear();
|
|
|
|
const updated = removeHistoryEntries(paths, ["hist-0", "hist-599"], limits);
|
|
|
|
expect(renameSpy).toHaveBeenCalledTimes(2);
|
|
expect(renameSpy.mock.calls.map((call) => call[1])).toEqual([`${paths.historyFile}.bak`, paths.historyFile]);
|
|
renameSpy.mockRestore();
|
|
expect(updated).toHaveLength(598);
|
|
expect(updated.some((entry) => entry.id === "hist-0" || entry.id === "hist-599")).toBe(false);
|
|
expect(loadHistory(paths, limits)).toHaveLength(598);
|
|
});
|
|
|
|
it("returns empty session when session file contains invalid JSON", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
fs.writeFileSync(paths.sessionFile, "{{{corrupted json!!!", "utf8");
|
|
|
|
const loaded = loadSession(paths);
|
|
const empty = emptySession();
|
|
expect(loaded.packages).toEqual(empty.packages);
|
|
expect(loaded.items).toEqual(empty.items);
|
|
expect(loaded.packageOrder).toEqual(empty.packageOrder);
|
|
});
|
|
|
|
it("loads backup session when primary session is corrupted", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
const backupSession = emptySession();
|
|
backupSession.packageOrder = ["pkg-backup"];
|
|
backupSession.packages["pkg-backup"] = {
|
|
id: "pkg-backup",
|
|
name: "Backup Package",
|
|
outputDir: path.join(dir, "out"),
|
|
extractDir: path.join(dir, "extract"),
|
|
status: "queued",
|
|
itemIds: ["item-backup"],
|
|
cancelled: false,
|
|
enabled: true,
|
|
downloadStartedAt: 0,
|
|
downloadCompletedAt: 0,
|
|
createdAt: Date.now(),
|
|
updatedAt: Date.now()
|
|
};
|
|
backupSession.items["item-backup"] = {
|
|
id: "item-backup",
|
|
packageId: "pkg-backup",
|
|
url: "https://example.com/backup-file",
|
|
provider: null,
|
|
status: "queued",
|
|
retries: 0,
|
|
speedBps: 0,
|
|
downloadedBytes: 0,
|
|
totalBytes: null,
|
|
progressPercent: 0,
|
|
fileName: "backup-file.rar",
|
|
targetPath: path.join(dir, "out", "backup-file.rar"),
|
|
resumable: true,
|
|
attempts: 0,
|
|
lastError: "",
|
|
fullStatus: "Wartet",
|
|
createdAt: Date.now(),
|
|
updatedAt: Date.now()
|
|
};
|
|
|
|
fs.writeFileSync(`${paths.sessionFile}.bak`, JSON.stringify(backupSession), "utf8");
|
|
fs.writeFileSync(paths.sessionFile, "{broken-session-json", "utf8");
|
|
|
|
const loaded = loadSession(paths);
|
|
expect(loaded.packageOrder).toEqual(["pkg-backup"]);
|
|
expect(loaded.packages["pkg-backup"]?.name).toBe("Backup Package");
|
|
expect(loaded.items["item-backup"]?.fileName).toBe("backup-file.rar");
|
|
|
|
const restoredPrimary = JSON.parse(fs.readFileSync(paths.sessionFile, "utf8")) as { packages?: Record<string, unknown> };
|
|
expect(restoredPrimary.packages && "pkg-backup" in restoredPrimary.packages).toBe(true);
|
|
});
|
|
|
|
it("returns defaults when config file contains invalid JSON", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
fs.writeFileSync(paths.configFile, "{{{{not valid json!!!}", "utf8");
|
|
|
|
const loaded = loadSettings(paths);
|
|
const defaults = defaultSettings();
|
|
expect(loaded.providerPrimary).toBe(defaults.providerPrimary);
|
|
expect(loaded.maxParallel).toBe(defaults.maxParallel);
|
|
expect(loaded.retryLimit).toBe(defaults.retryLimit);
|
|
expect(loaded.outputDir).toBe(defaults.outputDir);
|
|
expect(loaded.cleanupMode).toBe(defaults.cleanupMode);
|
|
});
|
|
|
|
it("loads backup config when primary config is corrupted", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
const backupSettings = {
|
|
...defaultSettings(),
|
|
outputDir: path.join(dir, "backup-output"),
|
|
packageName: "from-backup"
|
|
};
|
|
fs.writeFileSync(`${paths.configFile}.bak`, JSON.stringify(backupSettings, null, 2), "utf8");
|
|
fs.writeFileSync(paths.configFile, "{broken-json", "utf8");
|
|
|
|
const loaded = loadSettings(paths);
|
|
expect(loaded.outputDir).toBe(backupSettings.outputDir);
|
|
expect(loaded.packageName).toBe("from-backup");
|
|
});
|
|
|
|
it("sanitizes malformed persisted session structures", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
fs.writeFileSync(paths.sessionFile, JSON.stringify({
|
|
version: "invalid",
|
|
packageOrder: [123, "pkg-valid"],
|
|
packages: {
|
|
"1": "bad-entry",
|
|
"pkg-valid": {
|
|
id: "pkg-valid",
|
|
name: "Valid Package",
|
|
outputDir: "C:/tmp/out",
|
|
extractDir: "C:/tmp/extract",
|
|
status: "downloading",
|
|
itemIds: ["item-valid", 123],
|
|
cancelled: false,
|
|
enabled: true
|
|
}
|
|
},
|
|
items: {
|
|
"item-valid": {
|
|
id: "item-valid",
|
|
packageId: "pkg-valid",
|
|
url: "https://example.com/file",
|
|
status: "queued",
|
|
fileName: "file.bin",
|
|
targetPath: "C:/tmp/out/file.bin"
|
|
},
|
|
"item-bad": "broken"
|
|
}
|
|
}), "utf8");
|
|
|
|
const loaded = loadSession(paths);
|
|
expect(Object.keys(loaded.packages)).toEqual(["pkg-valid"]);
|
|
expect(Object.keys(loaded.items)).toEqual(["item-valid"]);
|
|
expect(loaded.packageOrder).toEqual(["pkg-valid"]);
|
|
});
|
|
|
|
it("drops unsafe session ids and target paths outside the package output directory", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const outputDir = path.join(dir, "downloads", "safe");
|
|
const safeTargetPath = path.join(outputDir, "safe.bin");
|
|
const outsideTargetPath = path.join(dir, "outside.bin");
|
|
|
|
fs.writeFileSync(paths.sessionFile, JSON.stringify({
|
|
version: 2,
|
|
packageOrder: ["pkg-safe", "../pkg-evil"],
|
|
packages: {
|
|
"pkg-safe": {
|
|
id: "pkg-safe",
|
|
name: "Safe Package",
|
|
outputDir,
|
|
extractDir: path.join(dir, "extract", "safe"),
|
|
status: "queued",
|
|
itemIds: ["item-safe", "item-outside", "../item-evil"],
|
|
cancelled: false,
|
|
enabled: true
|
|
},
|
|
"../pkg-evil": {
|
|
id: "../pkg-evil",
|
|
name: "Unsafe Package",
|
|
outputDir,
|
|
extractDir: path.join(dir, "extract", "unsafe"),
|
|
status: "queued",
|
|
itemIds: ["item-evil"],
|
|
cancelled: false,
|
|
enabled: true
|
|
}
|
|
},
|
|
items: {
|
|
"item-safe": {
|
|
id: "item-safe",
|
|
packageId: "pkg-safe",
|
|
url: "https://example.com/safe",
|
|
status: "queued",
|
|
fileName: "safe.bin",
|
|
targetPath: safeTargetPath
|
|
},
|
|
"item-outside": {
|
|
id: "item-outside",
|
|
packageId: "pkg-safe",
|
|
url: "https://example.com/outside",
|
|
status: "queued",
|
|
fileName: "outside.bin",
|
|
targetPath: outsideTargetPath
|
|
},
|
|
"../item-evil": {
|
|
id: "../item-evil",
|
|
packageId: "pkg-safe",
|
|
url: "https://example.com/evil",
|
|
status: "queued",
|
|
fileName: "evil.bin",
|
|
targetPath: safeTargetPath
|
|
}
|
|
}
|
|
}), "utf8");
|
|
|
|
const loaded = loadSession(paths);
|
|
expect(Object.keys(loaded.packages)).toEqual(["pkg-safe"]);
|
|
expect(Object.keys(loaded.items).sort()).toEqual(["item-outside", "item-safe"]);
|
|
expect(loaded.packageOrder).toEqual(["pkg-safe"]);
|
|
expect(path.resolve(loaded.items["item-safe"]?.targetPath || "")).toBe(path.resolve(safeTargetPath));
|
|
expect(loaded.items["item-outside"]?.targetPath).toBe("");
|
|
});
|
|
|
|
it("captures async session save payload before later mutations", async () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
const session = emptySession();
|
|
session.summaryText = "before-mutation";
|
|
|
|
const pending = saveSessionAsync(paths, session);
|
|
session.summaryText = "after-mutation";
|
|
await pending;
|
|
|
|
const persisted = JSON.parse(fs.readFileSync(paths.sessionFile, "utf8")) as { summaryText: string };
|
|
expect(persisted.summaryText).toBe("before-mutation");
|
|
});
|
|
|
|
it("keeps newer synchronous settings and session saves when older async commits resume", async () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-sync-wins-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const oldSettings = { ...defaultSettings(), packageName: "old-async" };
|
|
const newSettings = { ...defaultSettings(), packageName: "new-sync" };
|
|
const oldSession = { ...emptySession(), summaryText: "old-async" };
|
|
const newSession = { ...emptySession(), summaryText: "new-sync" };
|
|
saveSettings(paths, defaultSettings());
|
|
saveSession(paths, emptySession());
|
|
|
|
let releaseSettingsCommit = () => {};
|
|
let releaseSessionCommit = () => {};
|
|
let markSettingsCommitStarted = () => {};
|
|
let markSessionCommitStarted = () => {};
|
|
const settingsCommitStarted = new Promise<void>((resolve) => { markSettingsCommitStarted = resolve; });
|
|
const sessionCommitStarted = new Promise<void>((resolve) => { markSessionCommitStarted = resolve; });
|
|
const settingsCommitRelease = new Promise<void>((resolve) => { releaseSettingsCommit = resolve; });
|
|
const sessionCommitRelease = new Promise<void>((resolve) => { releaseSessionCommit = resolve; });
|
|
const renameFile = fs.promises.rename.bind(fs.promises);
|
|
const rename = vi.spyOn(fs.promises, "rename").mockImplementation(async (source, destination) => {
|
|
const sourcePath = String(source);
|
|
if (sourcePath === `${paths.configFile}.settings.tmp`) {
|
|
markSettingsCommitStarted();
|
|
await settingsCommitRelease;
|
|
}
|
|
if (sourcePath === `${paths.sessionFile}.async.tmp`) {
|
|
markSessionCommitStarted();
|
|
await sessionCommitRelease;
|
|
}
|
|
await renameFile(source, destination);
|
|
});
|
|
|
|
try {
|
|
const oldSettingsSave = saveSettingsAsync(paths, oldSettings);
|
|
const oldSessionSave = saveSessionAsync(paths, oldSession);
|
|
const oldSaves = Promise.all([oldSettingsSave, oldSessionSave]);
|
|
const asyncCommitPaused = await Promise.race([
|
|
Promise.all([settingsCommitStarted, sessionCommitStarted]).then(() => true),
|
|
oldSaves.then(() => false)
|
|
]);
|
|
|
|
saveSettings(paths, newSettings);
|
|
saveSession(paths, newSession);
|
|
if (asyncCommitPaused) {
|
|
releaseSettingsCommit();
|
|
releaseSessionCommit();
|
|
}
|
|
await oldSaves;
|
|
|
|
expect(loadSettings(paths).packageName).toBe("new-sync");
|
|
expect(loadSession(paths).summaryText).toBe("new-sync");
|
|
} finally {
|
|
releaseSettingsCommit();
|
|
releaseSessionCommit();
|
|
rename.mockRestore();
|
|
}
|
|
});
|
|
|
|
it("persists the async session primary when replacing its backup is temporarily blocked", async () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-session-backup-blocked-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
saveSession(paths, { ...emptySession(), summaryText: "previous" });
|
|
const renameFile = fs.renameSync.bind(fs);
|
|
const rename = vi.spyOn(fs, "renameSync").mockImplementation((source, destination) => {
|
|
if (String(destination) === `${paths.sessionFile}.bak`) {
|
|
throw Object.assign(new Error("backup busy"), { code: "EBUSY" });
|
|
}
|
|
return renameFile(source, destination);
|
|
});
|
|
|
|
try {
|
|
await saveSessionAsync(paths, { ...emptySession(), summaryText: "latest" });
|
|
} finally {
|
|
rename.mockRestore();
|
|
}
|
|
|
|
expect(loadSession(paths).summaryText).toBe("latest");
|
|
});
|
|
|
|
it("waits for in-flight settings and session writes and discards saves blocked by an import barrier", async () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-barrier-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const oldSettings = { ...defaultSettings(), packageName: "old-settings" };
|
|
const importedSettings = { ...defaultSettings(), packageName: "imported-settings" };
|
|
const oldSession = { ...emptySession(), summaryText: "old-session" };
|
|
const importedSession = { ...emptySession(), summaryText: "imported-session" };
|
|
saveSettings(paths, defaultSettings());
|
|
saveSession(paths, emptySession());
|
|
|
|
let releaseSettingsWrite = () => {};
|
|
let releaseSessionWrite = () => {};
|
|
let markSettingsWriteStarted = () => {};
|
|
let markSessionWriteStarted = () => {};
|
|
const settingsWriteStarted = new Promise<void>((resolve) => { markSettingsWriteStarted = resolve; });
|
|
const sessionWriteStarted = new Promise<void>((resolve) => { markSessionWriteStarted = resolve; });
|
|
const settingsWriteRelease = new Promise<void>((resolve) => { releaseSettingsWrite = resolve; });
|
|
const sessionWriteRelease = new Promise<void>((resolve) => { releaseSessionWrite = resolve; });
|
|
const writeFile = fs.promises.writeFile.bind(fs.promises);
|
|
const openFile = fs.promises.open.bind(fs.promises);
|
|
const write = vi.spyOn(fs.promises, "writeFile").mockImplementation(async (filePath, data, options) => {
|
|
await writeFile(filePath, data, options);
|
|
if (String(filePath) === `${paths.configFile}.settings.tmp`) {
|
|
markSettingsWriteStarted();
|
|
await settingsWriteRelease;
|
|
}
|
|
});
|
|
const open = vi.spyOn(fs.promises, "open").mockImplementation(async (filePath, flags, mode) => {
|
|
const handle = await openFile(filePath, flags, mode);
|
|
if (String(filePath) === `${paths.sessionFile}.async.tmp`) {
|
|
const originalWrite = handle.writeFile.bind(handle);
|
|
handle.writeFile = async (...args: Parameters<typeof handle.writeFile>) => {
|
|
const result = await originalWrite(...args);
|
|
markSessionWriteStarted();
|
|
await sessionWriteRelease;
|
|
return result;
|
|
};
|
|
}
|
|
return handle;
|
|
});
|
|
|
|
try {
|
|
const oldSettingsSave = saveSettingsAsync(paths, oldSettings);
|
|
const oldSessionSave = saveSessionAsync(paths, oldSession);
|
|
await Promise.all([settingsWriteStarted, sessionWriteStarted]);
|
|
|
|
let barrierAcquired = false;
|
|
const barrierPromise = acquirePersistenceBarrier().then((barrier) => {
|
|
barrierAcquired = true;
|
|
return barrier;
|
|
});
|
|
await Promise.resolve();
|
|
expect(barrierAcquired).toBe(false);
|
|
|
|
releaseSettingsWrite();
|
|
releaseSessionWrite();
|
|
const barrier = await barrierPromise;
|
|
await Promise.all([oldSettingsSave, oldSessionSave]);
|
|
|
|
const blockedSettingsSave = saveSettingsAsync(paths, oldSettings);
|
|
const blockedSessionSave = saveSessionAsync(paths, oldSession);
|
|
saveSettings(paths, importedSettings);
|
|
saveSession(paths, importedSession);
|
|
await barrier.release({ replayBlocked: false });
|
|
await Promise.all([blockedSettingsSave, blockedSessionSave]);
|
|
|
|
expect(loadSettings(paths).packageName).toBe("imported-settings");
|
|
expect(loadSession(paths).summaryText).toBe("imported-session");
|
|
} finally {
|
|
releaseSettingsWrite();
|
|
releaseSessionWrite();
|
|
write.mockRestore();
|
|
open.mockRestore();
|
|
}
|
|
});
|
|
|
|
it("replays the latest saves blocked by a failed import and releases the barrier", async () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-barrier-replay-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
const barrier = await acquirePersistenceBarrier();
|
|
const settingsSave = saveSettingsAsync(paths, { ...defaultSettings(), packageName: "replayed-settings" });
|
|
const sessionSave = saveSessionAsync(paths, { ...emptySession(), summaryText: "replayed-session" });
|
|
|
|
await barrier.release({ replayBlocked: true });
|
|
await Promise.all([settingsSave, sessionSave]);
|
|
|
|
expect(loadSettings(paths).packageName).toBe("replayed-settings");
|
|
expect(loadSession(paths).summaryText).toBe("replayed-session");
|
|
const nextBarrier = await acquirePersistenceBarrier();
|
|
await nextBarrier.release({ replayBlocked: false });
|
|
});
|
|
|
|
it("creates session backup before sync and async session overwrites", async () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
const first = emptySession();
|
|
first.summaryText = "first";
|
|
saveSession(paths, first);
|
|
|
|
const second = emptySession();
|
|
second.summaryText = "second";
|
|
saveSession(paths, second);
|
|
|
|
const backupAfterSync = JSON.parse(fs.readFileSync(`${paths.sessionFile}.bak`, "utf8")) as { summaryText?: string };
|
|
expect(backupAfterSync.summaryText).toBe("first");
|
|
|
|
const third = emptySession();
|
|
third.summaryText = "third";
|
|
await saveSessionAsync(paths, third);
|
|
|
|
const backupAfterAsync = JSON.parse(fs.readFileSync(`${paths.sessionFile}.bak`, "utf8")) as { summaryText?: string };
|
|
const primaryAfterAsync = JSON.parse(fs.readFileSync(paths.sessionFile, "utf8")) as { summaryText?: string };
|
|
expect(backupAfterAsync.summaryText).toBe("second");
|
|
expect(primaryAfterAsync.summaryText).toBe("third");
|
|
});
|
|
|
|
it("applies defaults for missing fields when loading old config", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
fs.writeFileSync(
|
|
paths.configFile,
|
|
JSON.stringify({
|
|
token: "my-token",
|
|
rememberToken: true,
|
|
outputDir: "/custom/output"
|
|
}),
|
|
"utf8"
|
|
);
|
|
|
|
const loaded = loadSettings(paths);
|
|
const defaults = defaultSettings();
|
|
|
|
expect(loaded.token).toBe("my-token");
|
|
expect(loaded.outputDir).toBe(path.resolve("/custom/output"));
|
|
|
|
expect(loaded.autoProviderFallback).toBe(defaults.autoProviderFallback);
|
|
expect(loaded.hybridExtract).toBe(defaults.hybridExtract);
|
|
expect(loaded.completedCleanupPolicy).toBe(defaults.completedCleanupPolicy);
|
|
expect(loaded.speedLimitMode).toBe(defaults.speedLimitMode);
|
|
expect(loaded.clipboardWatch).toBe(defaults.clipboardWatch);
|
|
expect(loaded.minimizeToTray).toBe(defaults.minimizeToTray);
|
|
expect(loaded.retryLimit).toBe(defaults.retryLimit);
|
|
expect(loaded.collectMkvToLibrary).toBe(defaults.collectMkvToLibrary);
|
|
expect(loaded.mkvLibraryDir).toBe(defaults.mkvLibraryDir);
|
|
expect(loaded.theme).toBe(defaults.theme);
|
|
expect(loaded.themePreference).toBe(defaults.themePreference);
|
|
expect(loaded.bandwidthSchedules).toEqual(defaults.bandwidthSchedules);
|
|
expect(loaded.updateRepo).toBe(defaults.updateRepo);
|
|
});
|
|
|
|
it("persists the semantic theme preference and migrates legacy fixed themes", () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rd-store-"));
|
|
tempDirs.push(dir);
|
|
const paths = createStoragePaths(dir);
|
|
|
|
const legacy = { ...defaultSettings(), theme: "light" as const } as Partial<AppSettings>;
|
|
delete legacy.themePreference;
|
|
fs.mkdirSync(path.dirname(paths.configFile), { recursive: true });
|
|
fs.writeFileSync(paths.configFile, JSON.stringify(legacy), "utf8");
|
|
|
|
expect(loadSettings(paths).themePreference).toBe("light");
|
|
|
|
saveSettings(paths, { ...defaultSettings(), theme: "dark", themePreference: "system" });
|
|
|
|
expect(loadSettings(paths)).toEqual(expect.objectContaining({
|
|
theme: "dark",
|
|
themePreference: "system"
|
|
}));
|
|
expect(normalizeSettings({
|
|
...defaultSettings(),
|
|
theme: "light",
|
|
themePreference: "invalid" as AppSettings["themePreference"]
|
|
}).themePreference).toBe("light");
|
|
});
|
|
});
|