Files
NetMesh/components/portForwardingUtils.test.ts

81 lines
2.4 KiB
TypeScript
Raw Normal View History

import assert from "node:assert/strict";
import test from "node:test";
import type { PortForwardingRule } from "../domain/models";
import en from "../application/i18n/locales/en";
import es from "../application/i18n/locales/es";
import zhCN from "../application/i18n/locales/zh-CN";
import ru from "../application/i18n/locales/ru";
import { buildRuleSummary, stopRuntimeTunnelBeforeDelete } from "./port-forwarding/utils";
const interpolate = (template: string, vars?: Record<string, unknown>) =>
template.replace(/\{(\w+)\}/g, (_, key) => String(vars?.[key] ?? ""));
const t = (key: string, vars?: Record<string, unknown>) => interpolate(en[key] ?? key, vars);
const baseRule: PortForwardingRule = {
id: "rule-1",
label: "Database tunnel",
type: "local",
hostId: "host-1",
localPort: 15432,
bindAddress: "127.0.0.1",
remoteHost: "db.internal",
remotePort: 5432,
autoStart: false,
status: "inactive",
createdAt: Date.now(),
updatedAt: Date.now(),
};
test("buildRuleSummary describes local, remote, and dynamic forwarding directions separately", () => {
assert.equal(
buildRuleSummary(t, baseRule),
"Local 127.0.0.1:15432 -> SSH tunnel -> db.internal:5432",
);
assert.equal(
buildRuleSummary(t, { ...baseRule, type: "remote" }),
"Remote 127.0.0.1:15432 -> SSH tunnel -> local db.internal:5432",
);
assert.equal(
buildRuleSummary(t, { ...baseRule, type: "dynamic" }),
"SOCKS on 127.0.0.1:15432",
);
});
test("bundled locales include port forwarding summary copy for every forwarding type", () => {
for (const [locale, messages] of Object.entries({ en, es, zhCN, ru })) {
for (const key of [
"pf.rule.summary.local",
"pf.rule.summary.remote",
"pf.rule.summary.dynamic",
]) {
assert.equal(typeof messages[key], "string", `${locale} is missing ${key}`);
assert.notEqual(messages[key], "", `${locale} has empty ${key}`);
}
}
});
test("delete always verifies backend cleanup and retains the rule on failure", async () => {
let stopCalls = 0;
assert.equal(await stopRuntimeTunnelBeforeDelete(
"rule-1",
async () => {
stopCalls++;
return { success: false };
},
), false);
assert.equal(stopCalls, 1);
assert.equal(await stopRuntimeTunnelBeforeDelete(
"rule-1",
async () => {
stopCalls++;
return { success: true };
},
), true);
assert.equal(stopCalls, 2);
});