Files
Netcatty/domain/syncMerge.test.ts
T

467 lines
11 KiB
TypeScript

import test from "node:test";
import assert from "node:assert/strict";
import { mergeSyncPayloads } from "./syncMerge.ts";
import { withSyncReliabilityMeta } from "./syncReliability.ts";
import type { SyncPayload } from "./sync.ts";
function payload(overrides: Partial<SyncPayload> = {}): SyncPayload {
return {
hosts: [],
keys: [],
identities: [],
snippets: [],
customGroups: [],
snippetPackages: [],
notes: [],
noteGroups: [],
portForwardingRules: [],
groupConfigs: [],
settings: undefined,
syncedAt: 0,
...overrides,
};
}
const knownHosts = (n: number): SyncPayload["knownHosts"] =>
Array.from({ length: n }, (_, i) => ({
id: `kh-${i}`,
hostname: `host-${i}.example.com`,
port: 22,
keyType: "ssh-ed25519",
publicKey: `SHA256:${i}`,
discoveredAt: 1,
}));
test("mergeSyncPayloads does not carry legacy known hosts forward", () => {
const result = mergeSyncPayloads(
payload({ knownHosts: knownHosts(2) }),
payload(),
payload({ knownHosts: knownHosts(3) }),
);
assert.equal("knownHosts" in result.payload, false);
});
test("mergeSyncPayloads merges reusable proxy profiles by id", () => {
const localProfile = {
id: "proxy-local",
label: "Local Proxy",
config: { type: "http", host: "local.example.com", port: 3128 },
createdAt: 1,
updatedAt: 1,
};
const remoteProfile = {
id: "proxy-remote",
label: "Remote Proxy",
config: { type: "socks5", host: "remote.example.com", port: 1080 },
createdAt: 2,
updatedAt: 2,
};
const result = mergeSyncPayloads(
payload(),
payload({ proxyProfiles: [localProfile] } as Partial<SyncPayload>),
payload({ proxyProfiles: [remoteProfile] } as Partial<SyncPayload>),
);
assert.deepEqual(result.payload.proxyProfiles?.map((item) => item.id).sort(), [
"proxy-local",
"proxy-remote",
]);
});
test("mergeSyncPayloads keeps local and remote notes", () => {
const result = mergeSyncPayloads(
payload(),
payload({
notes: [{
id: "local",
title: "Local",
content: "",
createdAt: 1,
updatedAt: 2,
}],
noteGroups: ["Local"],
}),
payload({
notes: [{
id: "remote",
title: "Remote",
content: "",
createdAt: 1,
updatedAt: 3,
}],
noteGroups: ["Remote"],
}),
);
assert.deepEqual(result.payload.notes?.map((note) => note.id).sort(), ["local", "remote"]);
assert.deepEqual(result.payload.noteGroups?.sort(), ["Local", "Remote"]);
});
test("mergeSyncPayloads preserves proxy profiles when remote payload predates them", () => {
const proxy = {
id: "proxy-1",
label: "Office Proxy",
config: { type: "http", host: "proxy.example.com", port: 3128 },
createdAt: 1,
};
const result = mergeSyncPayloads(
payload({ proxyProfiles: [proxy] } as Partial<SyncPayload>),
payload({ proxyProfiles: [proxy] } as Partial<SyncPayload>),
payload(),
);
assert.deepEqual(result.payload.proxyProfiles, [proxy]);
});
test("mergeSyncPayloads keeps missing proxy references visible to connection guards", () => {
const result = mergeSyncPayloads(
payload({
hosts: [{
id: "host-1",
label: "Host",
hostname: "example.com",
username: "root",
tags: [],
os: "linux",
proxyProfileId: "proxy-1",
}],
proxyProfiles: [{
id: "proxy-1",
label: "Old Proxy",
config: { type: "http", host: "old.example.com", port: 3128 },
createdAt: 1,
}],
groupConfigs: [{ path: "prod", proxyProfileId: "proxy-1" }],
}),
payload({
hosts: [{
id: "host-1",
label: "Host",
hostname: "example.com",
username: "root",
tags: [],
os: "linux",
proxyProfileId: "proxy-1",
}],
proxyProfiles: [],
groupConfigs: [{ path: "prod", proxyProfileId: "proxy-1" }],
}),
payload({
hosts: [{
id: "host-1",
label: "Host",
hostname: "example.com",
username: "root",
tags: [],
os: "linux",
proxyProfileId: "proxy-1",
}],
proxyProfiles: [],
groupConfigs: [{ path: "prod", proxyProfileId: "proxy-1" }],
}),
);
assert.equal(result.payload.hosts[0]?.proxyProfileId, "proxy-1");
assert.equal(result.payload.groupConfigs?.[0]?.proxyProfileId, "proxy-1");
});
test("mergeSyncPayloads honors remote deletion records when base is unavailable", () => {
const result = mergeSyncPayloads(
null,
payload({
hosts: [{
id: "host-1",
label: "Stale local copy",
hostname: "old.example.com",
username: "root",
tags: [],
os: "linux",
}],
}),
payload({
syncMeta: {
schemaVersion: 1,
generatedAt: 123,
localChanged: true,
deletions: [{
entityType: "hosts",
id: "host-1",
deletedAt: 123,
deviceId: "remote-device",
}],
changeSummary: {
hasLocalChanges: true,
hasRemoteChanges: false,
hasConflicts: false,
byEntity: {},
conflicts: [],
},
},
}),
);
assert.deepEqual(result.payload.hosts, []);
assert.equal(result.summary.deleted.remote, 1);
});
test("mergeSyncPayloads carries deletion records forward after applying a tombstone", () => {
const remote = payload({
syncMeta: {
schemaVersion: 1,
generatedAt: 123,
localChanged: true,
deletions: [{
entityType: "hosts",
id: "host-1",
deletedAt: 123,
deviceId: "remote-device",
}],
changeSummary: {
hasLocalChanges: true,
hasRemoteChanges: false,
hasConflicts: false,
byEntity: {},
conflicts: [],
},
},
});
const result = mergeSyncPayloads(
null,
payload({
hosts: [{
id: "host-1",
label: "Stale local copy",
hostname: "old.example.com",
username: "root",
tags: [],
os: "linux",
}],
}),
remote,
);
const enriched = withSyncReliabilityMeta(result.payload, null, {
deviceId: "local-device",
now: 456,
});
assert.deepEqual(enriched.syncMeta?.deletions, [{
entityType: "hosts",
id: "host-1",
deletedAt: 123,
deviceId: "remote-device",
}]);
});
test("mergeSyncPayloads adopts cloud settings on the first merge without a base", () => {
const result = mergeSyncPayloads(
null,
payload({
settings: {
theme: "dark",
terminalFontSize: 14,
terminalSettings: {
cursorBlink: true,
copyOnSelect: false,
},
},
}),
payload({
settings: {
theme: "light",
terminalFontSize: 18,
terminalSettings: {
cursorBlink: false,
copyOnSelect: true,
},
},
}),
);
assert.deepEqual(result.payload.settings, {
theme: "light",
terminalFontSize: 18,
terminalSettings: {
cursorBlink: false,
copyOnSelect: true,
},
});
});
test("mergeSyncPayloads preserves one-sided settings on the first merge", () => {
const result = mergeSyncPayloads(
null,
payload({
settings: {
customCSS: ".terminal { opacity: 0.9; }",
terminalSettings: { copyOnSelect: true },
},
}),
payload({
settings: {
theme: "system",
terminalSettings: { cursorBlink: false },
},
}),
);
assert.deepEqual(result.payload.settings, {
customCSS: ".terminal { opacity: 0.9; }",
theme: "system",
terminalSettings: {
copyOnSelect: true,
cursorBlink: false,
},
});
});
test("mergeSyncPayloads honors empty cloud setting maps as resets on the first merge", () => {
const result = mergeSyncPayloads(
null,
payload({
settings: {
customKeyBindings: {
copy: { mac: "meta+c", pc: "ctrl+c" },
},
ai: {
agentModelMap: { codex: "gpt-local" },
agentProviderMap: { codex: "openai-local" },
activeModelId: "local-model",
},
},
}),
payload({
settings: {
customKeyBindings: {},
ai: {
agentModelMap: {},
agentProviderMap: {},
activeProviderId: "cloud-provider",
},
},
}),
);
assert.deepEqual(result.payload.settings, {
customKeyBindings: {},
ai: {
agentModelMap: {},
agentProviderMap: {},
activeModelId: "local-model",
activeProviderId: "cloud-provider",
},
});
});
test("mergeSyncPayloads retains unique nested setting entries while cloud wins duplicate ids", () => {
const result = mergeSyncPayloads(
null,
payload({
settings: {
ai: {
providers: [
{ id: "shared", name: "Local shared" },
{ id: "local-only", name: "Local only" },
],
},
},
}),
payload({
settings: {
ai: {
providers: [
{ id: "shared", name: "Cloud shared" },
{ id: "cloud-only", name: "Cloud only" },
],
},
},
}),
);
assert.deepEqual(result.payload.settings?.ai?.providers, [
{ id: "shared", name: "Cloud shared" },
{ id: "cloud-only", name: "Cloud only" },
{ id: "local-only", name: "Local only" },
]);
});
test("mergeSyncPayloads keeps local settings conflict policy when a base exists", () => {
const base = payload({
settings: {
theme: "system",
terminalSettings: { cursorBlink: true },
},
});
const result = mergeSyncPayloads(
base,
payload({
settings: {
theme: "dark",
terminalSettings: { cursorBlink: false },
},
}),
payload({
settings: {
theme: "light",
terminalSettings: { cursorBlink: true },
},
}),
);
assert.deepEqual(result.payload.settings, {
theme: "dark",
terminalSettings: { cursorBlink: false },
});
});
test("mergeSyncPayloads treats missing optional arrays as legacy payloads, not deletions", () => {
const identity = {
id: "identity-1",
label: "Prod",
username: "root",
authMethod: "password" as const,
created: 1,
};
const rule = {
id: "rule-1",
name: "Web",
hostId: "host-1",
type: "local" as const,
localHost: "127.0.0.1",
localPort: 8080,
remoteHost: "127.0.0.1",
remotePort: 80,
enabled: true,
createdAt: 1,
};
const base = payload({
identities: [identity],
snippetPackages: ["ops"],
portForwardingRules: [rule],
groupConfigs: [{ path: "prod", username: "root" }],
});
const local = payload({
identities: [identity],
snippetPackages: ["ops"],
portForwardingRules: [rule],
groupConfigs: [{ path: "prod", username: "root" }],
});
const remote = payload();
delete remote.identities;
delete remote.snippetPackages;
delete remote.portForwardingRules;
delete remote.groupConfigs;
const result = mergeSyncPayloads(base, local, remote);
assert.deepEqual(result.payload.identities, [identity]);
assert.deepEqual(result.payload.snippetPackages, ["ops"]);
assert.deepEqual(result.payload.portForwardingRules, [rule]);
assert.deepEqual(result.payload.groupConfigs, [{ path: "prod", username: "root" }]);
});