wehub-resource-sync
471 lines
16 KiB
TypeScript
471 lines
16 KiB
TypeScript
import { describe, it, beforeEach, afterEach, after } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import path from "node:path";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import Database from "better-sqlite3";
|
|
|
|
const fileTmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "omni-dbvm-test-"));
|
|
const moduleDataDir = fs.mkdtempSync(path.join(os.tmpdir(), "omni-dbvm-module-"));
|
|
process.env.DATA_DIR = moduleDataDir;
|
|
|
|
const coreDb = await import("../../src/lib/db/core.ts");
|
|
const versionManagerDb = await import("../../src/lib/db/versionManager.ts");
|
|
|
|
const SCHEMA = `
|
|
CREATE TABLE IF NOT EXISTS version_manager (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
tool TEXT NOT NULL UNIQUE,
|
|
current_version TEXT,
|
|
installed_version TEXT,
|
|
pinned_version TEXT,
|
|
binary_path TEXT,
|
|
status TEXT NOT NULL DEFAULT 'not_installed',
|
|
pid INTEGER,
|
|
port INTEGER DEFAULT 8317,
|
|
api_key TEXT,
|
|
management_key TEXT,
|
|
auto_update INTEGER NOT NULL DEFAULT 1,
|
|
auto_start INTEGER NOT NULL DEFAULT 0,
|
|
last_health_check TEXT,
|
|
last_update_check TEXT,
|
|
health_status TEXT DEFAULT 'unknown',
|
|
config_overrides TEXT,
|
|
error_message TEXT,
|
|
created_at TEXT NOT NULL DEFAULT (datetime('now')),
|
|
updated_at TEXT NOT NULL DEFAULT (datetime('now'))
|
|
);
|
|
`;
|
|
|
|
let testDb;
|
|
let testDbPath;
|
|
|
|
beforeEach(() => {
|
|
testDbPath = path.join(fileTmpDir, `test-${Date.now()}.db`);
|
|
testDb = new Database(testDbPath);
|
|
testDb.exec(SCHEMA);
|
|
});
|
|
|
|
afterEach(() => {
|
|
testDb.close();
|
|
try {
|
|
fs.unlinkSync(testDbPath);
|
|
} catch {}
|
|
});
|
|
|
|
after(() => {
|
|
if (fs.existsSync(fileTmpDir)) fs.rmSync(fileTmpDir, { recursive: true, force: true });
|
|
});
|
|
|
|
async function resetModuleStorage() {
|
|
coreDb.resetDbInstance();
|
|
fs.rmSync(moduleDataDir, { recursive: true, force: true });
|
|
fs.mkdirSync(moduleDataDir, { recursive: true });
|
|
}
|
|
|
|
function upsertTool(db, data) {
|
|
db.prepare(
|
|
`
|
|
INSERT INTO version_manager (
|
|
tool, current_version, installed_version, pinned_version, binary_path,
|
|
status, pid, port, api_key, management_key, auto_update, auto_start,
|
|
health_status, config_overrides, error_message, created_at, updated_at
|
|
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
|
|
ON CONFLICT(tool) DO UPDATE SET
|
|
current_version = excluded.current_version,
|
|
installed_version = excluded.installed_version,
|
|
pinned_version = excluded.pinned_version,
|
|
binary_path = excluded.binary_path,
|
|
status = excluded.status,
|
|
pid = excluded.pid,
|
|
port = excluded.port,
|
|
api_key = excluded.api_key,
|
|
management_key = excluded.management_key,
|
|
auto_update = excluded.auto_update,
|
|
auto_start = excluded.auto_start,
|
|
health_status = excluded.health_status,
|
|
config_overrides = excluded.config_overrides,
|
|
error_message = excluded.error_message,
|
|
updated_at = datetime('now')
|
|
`
|
|
).run(
|
|
data.tool,
|
|
data.currentVersion ?? null,
|
|
data.installedVersion ?? null,
|
|
data.pinnedVersion ?? null,
|
|
data.binaryPath ?? null,
|
|
data.status ?? "not_installed",
|
|
data.pid ?? null,
|
|
data.port ?? 8317,
|
|
data.apiKey ?? null,
|
|
data.managementKey ?? null,
|
|
data.autoUpdate !== undefined ? (data.autoUpdate ? 1 : 0) : 1,
|
|
data.autoStart !== undefined ? (data.autoStart ? 1 : 0) : 0,
|
|
data.healthStatus ?? "unknown",
|
|
data.configOverrides !== undefined
|
|
? data.configOverrides
|
|
? JSON.stringify(data.configOverrides)
|
|
: null
|
|
: null,
|
|
data.errorMessage ?? null
|
|
);
|
|
return db.prepare("SELECT * FROM version_manager WHERE tool = ?").get(data.tool);
|
|
}
|
|
|
|
function parseConfigOverrides(value) {
|
|
if (!value || typeof value !== "string" || value.trim() === "") return null;
|
|
try {
|
|
const parsed = JSON.parse(value);
|
|
return typeof parsed === "object" && parsed !== null ? parsed : null;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function toTool(row) {
|
|
if (!row) return null;
|
|
return {
|
|
id: row.id,
|
|
tool: row.tool,
|
|
currentVersion: row.current_version,
|
|
installedVersion: row.installed_version,
|
|
pinnedVersion: row.pinned_version,
|
|
binaryPath: row.binary_path,
|
|
status: row.status,
|
|
pid: row.pid,
|
|
port: row.port,
|
|
apiKey: row.api_key,
|
|
managementKey: row.management_key,
|
|
autoUpdate: row.auto_update === 1,
|
|
autoStart: row.auto_start === 1,
|
|
lastHealthCheck: row.last_health_check,
|
|
lastUpdateCheck: row.last_update_check,
|
|
healthStatus: row.health_status,
|
|
configOverrides: parseConfigOverrides(row.config_overrides),
|
|
errorMessage: row.error_message,
|
|
createdAt: row.created_at,
|
|
updatedAt: row.updated_at,
|
|
};
|
|
}
|
|
|
|
describe("db/versionManager (logic)", () => {
|
|
describe("upsertVersionManagerTool", () => {
|
|
it("should insert a new tool and read it back", () => {
|
|
const tool = toTool(
|
|
upsertTool(testDb, {
|
|
tool: "cliproxyapi",
|
|
installedVersion: "6.9.7",
|
|
binaryPath: "/tmp/bin/cliproxyapi",
|
|
status: "installed",
|
|
})
|
|
);
|
|
assert.equal(tool.tool, "cliproxyapi");
|
|
assert.equal(tool.installedVersion, "6.9.7");
|
|
assert.equal(tool.binaryPath, "/tmp/bin/cliproxyapi");
|
|
assert.equal(tool.status, "installed");
|
|
assert.equal(tool.port, 8317);
|
|
assert.equal(tool.autoUpdate, true);
|
|
assert.equal(tool.autoStart, false);
|
|
assert.equal(tool.healthStatus, "unknown");
|
|
assert.ok(tool.id > 0);
|
|
});
|
|
|
|
it("should update on conflict (upsert)", () => {
|
|
upsertTool(testDb, { tool: "test-tool", status: "installed" });
|
|
const tool = toTool(
|
|
upsertTool(testDb, { tool: "test-tool", installedVersion: "7.0.0", status: "running" })
|
|
);
|
|
assert.equal(tool.installedVersion, "7.0.0");
|
|
assert.equal(tool.status, "running");
|
|
});
|
|
|
|
it("should store boolean fields as 0/1", () => {
|
|
const tool = toTool(
|
|
upsertTool(testDb, { tool: "bool-test", autoUpdate: false, autoStart: true })
|
|
);
|
|
assert.equal(tool.autoUpdate, false);
|
|
assert.equal(tool.autoStart, true);
|
|
});
|
|
|
|
it("should store config overrides as JSON", () => {
|
|
const tool = toTool(upsertTool(testDb, { tool: "cfg", configOverrides: { port: 9999 } }));
|
|
assert.deepEqual(tool.configOverrides, { port: 9999 });
|
|
});
|
|
|
|
it("should handle null config overrides", () => {
|
|
const tool = toTool(upsertTool(testDb, { tool: "null-cfg" }));
|
|
assert.equal(tool.configOverrides, null);
|
|
});
|
|
|
|
it("should handle pid and error message", () => {
|
|
const tool = toTool(
|
|
upsertTool(testDb, { tool: "pid-test", pid: 12345, errorMessage: "err" })
|
|
);
|
|
assert.equal(tool.pid, 12345);
|
|
assert.equal(tool.errorMessage, "err");
|
|
});
|
|
});
|
|
|
|
describe("getVersionManagerTool", () => {
|
|
it("should return null for non-existent tool", () => {
|
|
assert.equal(
|
|
toTool(testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("ghost")),
|
|
null
|
|
);
|
|
});
|
|
|
|
it("should return tool by name", () => {
|
|
upsertTool(testDb, { tool: "findme", installedVersion: "1.0.0" });
|
|
const tool = toTool(
|
|
testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("findme")
|
|
);
|
|
assert.equal(tool.installedVersion, "1.0.0");
|
|
});
|
|
});
|
|
|
|
describe("getVersionManagerStatus", () => {
|
|
it("should return all tools", () => {
|
|
upsertTool(testDb, { tool: "a" });
|
|
upsertTool(testDb, { tool: "b" });
|
|
assert.equal(testDb.prepare("SELECT * FROM version_manager").all().length, 2);
|
|
});
|
|
|
|
it("should return empty when no tools", () => {
|
|
assert.equal(testDb.prepare("SELECT * FROM version_manager").all().length, 0);
|
|
});
|
|
});
|
|
|
|
describe("updateVersionManagerTool (partial)", () => {
|
|
it("should update pinnedVersion and autoUpdate", () => {
|
|
upsertTool(testDb, { tool: "upd", status: "installed" });
|
|
testDb
|
|
.prepare(
|
|
"UPDATE version_manager SET pinned_version = ?, auto_update = ?, updated_at = datetime('now') WHERE tool = ?"
|
|
)
|
|
.run("6.8.0", 0, "upd");
|
|
const tool = toTool(
|
|
testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("upd")
|
|
);
|
|
assert.equal(tool.pinnedVersion, "6.8.0");
|
|
assert.equal(tool.autoUpdate, false);
|
|
assert.equal(tool.status, "installed");
|
|
});
|
|
|
|
it("should set fields to null", () => {
|
|
upsertTool(testDb, { tool: "nulls", installedVersion: "1.0.0", pid: 42 });
|
|
testDb
|
|
.prepare("UPDATE version_manager SET installed_version = NULL, pid = NULL WHERE tool = ?")
|
|
.run("nulls");
|
|
const tool = toTool(
|
|
testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("nulls")
|
|
);
|
|
assert.equal(tool.installedVersion, null);
|
|
assert.equal(tool.pid, null);
|
|
});
|
|
});
|
|
|
|
describe("deleteVersionManagerTool", () => {
|
|
it("should delete existing tool", () => {
|
|
upsertTool(testDb, { tool: "del" });
|
|
assert.equal(
|
|
testDb.prepare("DELETE FROM version_manager WHERE tool = ?").run("del").changes,
|
|
1
|
|
);
|
|
assert.equal(
|
|
testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("del"),
|
|
undefined
|
|
);
|
|
});
|
|
|
|
it("should return 0 changes for non-existent", () => {
|
|
assert.equal(
|
|
testDb.prepare("DELETE FROM version_manager WHERE tool = ?").run("ghost").changes,
|
|
0
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("updateToolHealth", () => {
|
|
it("should update health_status and last_health_check", () => {
|
|
upsertTool(testDb, { tool: "h" });
|
|
const r = testDb
|
|
.prepare(
|
|
"UPDATE version_manager SET health_status = ?, last_health_check = datetime('now') WHERE tool = ?"
|
|
)
|
|
.run("healthy", "h");
|
|
assert.equal(r.changes, 1);
|
|
const tool = toTool(testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("h"));
|
|
assert.equal(tool.healthStatus, "healthy");
|
|
assert.ok(tool.lastHealthCheck);
|
|
});
|
|
|
|
it("should return 0 changes for non-existent", () => {
|
|
assert.equal(
|
|
testDb
|
|
.prepare("UPDATE version_manager SET health_status = ? WHERE tool = ?")
|
|
.run("healthy", "ghost").changes,
|
|
0
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("updateToolVersion", () => {
|
|
it("should update current_version", () => {
|
|
upsertTool(testDb, { tool: "v1" });
|
|
testDb
|
|
.prepare("UPDATE version_manager SET current_version = ? WHERE tool = ?")
|
|
.run("7.0.0", "v1");
|
|
assert.equal(
|
|
testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("v1").current_version,
|
|
"7.0.0"
|
|
);
|
|
});
|
|
|
|
it("should update installed_version", () => {
|
|
upsertTool(testDb, { tool: "v2" });
|
|
testDb
|
|
.prepare("UPDATE version_manager SET installed_version = ? WHERE tool = ?")
|
|
.run("7.0.0", "v2");
|
|
assert.equal(
|
|
testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("v2").installed_version,
|
|
"7.0.0"
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("setToolStatus", () => {
|
|
it("should update status with pid", () => {
|
|
upsertTool(testDb, { tool: "s1" });
|
|
testDb
|
|
.prepare("UPDATE version_manager SET status = ?, pid = ?, error_message = ? WHERE tool = ?")
|
|
.run("running", 9999, "ok", "s1");
|
|
const row = testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("s1");
|
|
assert.equal(row.status, "running");
|
|
assert.equal(row.pid, 9999);
|
|
assert.equal(row.error_message, "ok");
|
|
});
|
|
|
|
it("should update status without pid", () => {
|
|
upsertTool(testDb, { tool: "s2" });
|
|
testDb
|
|
.prepare("UPDATE version_manager SET status = ?, error_message = ? WHERE tool = ?")
|
|
.run("error", "crashed", "s2");
|
|
const row = testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("s2");
|
|
assert.equal(row.status, "error");
|
|
});
|
|
|
|
it("should return 0 for non-existent", () => {
|
|
assert.equal(
|
|
testDb
|
|
.prepare("UPDATE version_manager SET status = ? WHERE tool = ?")
|
|
.run("running", "ghost").changes,
|
|
0
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("parseConfigOverrides", () => {
|
|
it("should parse valid JSON", () => {
|
|
assert.deepEqual(parseConfigOverrides('{"key":"val"}'), { key: "val" });
|
|
});
|
|
|
|
it("should return null for invalid JSON", () => {
|
|
assert.equal(parseConfigOverrides("not-json"), null);
|
|
assert.equal(parseConfigOverrides(""), null);
|
|
assert.equal(parseConfigOverrides(null), null);
|
|
assert.equal(parseConfigOverrides("123"), null);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("db/versionManager (module coverage)", () => {
|
|
beforeEach(async () => {
|
|
await resetModuleStorage();
|
|
});
|
|
|
|
after(async () => {
|
|
coreDb.resetDbInstance();
|
|
fs.rmSync(moduleDataDir, { recursive: true, force: true });
|
|
});
|
|
|
|
it("round-trips inserts, updates and status listings through the production module", async () => {
|
|
const inserted = await versionManagerDb.upsertVersionManagerTool({
|
|
tool: "cliproxyapi",
|
|
installedVersion: "6.9.7",
|
|
binaryPath: "/tmp/cliproxyapi",
|
|
status: "installed",
|
|
autoUpdate: false,
|
|
autoStart: true,
|
|
configOverrides: { port: 9999 },
|
|
});
|
|
|
|
assert.equal(inserted.tool, "cliproxyapi");
|
|
assert.equal(inserted.autoUpdate, false);
|
|
assert.equal(inserted.autoStart, true);
|
|
assert.deepEqual(inserted.configOverrides, { port: 9999 });
|
|
|
|
const updated = await versionManagerDb.updateVersionManagerTool("cliproxyapi", {
|
|
installedVersion: "7.0.0",
|
|
configOverrides: { port: 8317, host: "127.0.0.1" },
|
|
apiKey: null,
|
|
ignoredField: "noop",
|
|
});
|
|
|
|
assert.equal(updated.installedVersion, "7.0.0");
|
|
assert.deepEqual(updated.configOverrides, { port: 8317, host: "127.0.0.1" });
|
|
|
|
const status = await versionManagerDb.getVersionManagerStatus();
|
|
const cliproxy = status.find((row) => row.tool === "cliproxyapi");
|
|
assert.ok(cliproxy, "expected cliproxyapi entry in status listing");
|
|
assert.equal(cliproxy.tool, "cliproxyapi");
|
|
});
|
|
|
|
it("parses invalid config overrides defensively and returns null for missing updates", async () => {
|
|
const db = coreDb.getDbInstance();
|
|
db.prepare(
|
|
`
|
|
INSERT INTO version_manager
|
|
(tool, status, config_overrides, created_at, updated_at)
|
|
VALUES (?, ?, ?, datetime('now'), datetime('now'))
|
|
`
|
|
).run("broken-tool", "installed", "{not-json");
|
|
|
|
const loaded = await versionManagerDb.getVersionManagerTool("broken-tool");
|
|
|
|
assert.equal(loaded.configOverrides, null);
|
|
assert.equal(
|
|
await versionManagerDb.updateVersionManagerTool("ghost", { status: "running" }),
|
|
null
|
|
);
|
|
});
|
|
|
|
it("updates health/version/status fields and deletes tools", async () => {
|
|
await versionManagerDb.upsertVersionManagerTool({
|
|
tool: "managed-tool",
|
|
status: "installed",
|
|
});
|
|
|
|
assert.equal(await versionManagerDb.updateToolHealth("managed-tool", "healthy"), true);
|
|
assert.equal(
|
|
await versionManagerDb.updateToolVersion("managed-tool", "current_version", "1.2.3"),
|
|
true
|
|
);
|
|
assert.equal(
|
|
await versionManagerDb.updateToolVersion("managed-tool", "installed_version", "1.2.0"),
|
|
true
|
|
);
|
|
assert.equal(await versionManagerDb.setToolStatus("managed-tool", "running", 4321, "ok"), true);
|
|
assert.equal(await versionManagerDb.setToolStatus("managed-tool", "error"), true);
|
|
|
|
const stored = await versionManagerDb.getVersionManagerTool("managed-tool");
|
|
assert.equal(stored.currentVersion, "1.2.3");
|
|
assert.equal(stored.installedVersion, "1.2.0");
|
|
assert.equal(stored.status, "error");
|
|
|
|
assert.equal(await versionManagerDb.updateToolHealth("ghost", "healthy"), false);
|
|
assert.equal(await versionManagerDb.setToolStatus("ghost", "running"), false);
|
|
assert.equal(await versionManagerDb.deleteVersionManagerTool("managed-tool"), true);
|
|
assert.equal(await versionManagerDb.deleteVersionManagerTool("managed-tool"), false);
|
|
});
|
|
});
|