mirror of
https://github.com/vrtmrz/obsidian-livesync.git
synced 2026-09-10 12:47:05 +00:00
576 lines
23 KiB
TypeScript
576 lines
23 KiB
TypeScript
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
import {
|
|
DEFAULT_SETTINGS,
|
|
REMOTE_COUCHDB,
|
|
TweakValuesTemplate,
|
|
type RemoteDBSettings,
|
|
type TweakValues,
|
|
} from "@vrtmrz/livesync-commonlib/compat/common/types";
|
|
import { extractObject } from "octagonal-wheels/object";
|
|
import { assessTweakCompatibility } from "@vrtmrz/livesync-commonlib/settings";
|
|
import { ModuleResolvingMismatchedTweaks } from "./ModuleResolveMismatchedTweaks";
|
|
import { setLang } from "@/common/translation";
|
|
import {
|
|
CENTRAL_COMPATIBILITY_REJECTION_REASONS,
|
|
REMOTE_RESOURCE_KINDS,
|
|
USER_INITIATED_REPLICATION_AUTHORITY,
|
|
type ReplicationAttemptFailure,
|
|
} from "@vrtmrz/livesync-commonlib/replication";
|
|
|
|
const BASE_TWEAKS = {
|
|
...extractObject(TweakValuesTemplate, DEFAULT_SETTINGS),
|
|
handleFilenameCaseSensitive: false,
|
|
};
|
|
|
|
function createModule(settingsOverride: Partial<typeof DEFAULT_SETTINGS> = {}) {
|
|
const askSelectStringDialogue = vi.fn(async (..._args: unknown[]): Promise<string | undefined> => undefined);
|
|
const applyPartial = vi.fn(async (_partial: Record<string, unknown>): Promise<void> => undefined);
|
|
const reinitialise = vi.fn(async () => undefined);
|
|
const publication = {};
|
|
const core = {
|
|
_services: {
|
|
API: {
|
|
addLog: vi.fn(),
|
|
addCommand: vi.fn(),
|
|
registerWindow: vi.fn(),
|
|
addRibbonIcon: vi.fn(),
|
|
registerProtocolHandler: vi.fn(),
|
|
},
|
|
setting: {
|
|
saveSettingData: vi.fn(async () => undefined),
|
|
applyPartial,
|
|
},
|
|
replicator: {
|
|
acquireActiveReplicatorContext: vi.fn(async () => publication),
|
|
},
|
|
},
|
|
localDatabase: {
|
|
managers: {
|
|
reinitialise,
|
|
},
|
|
},
|
|
settings: {
|
|
...DEFAULT_SETTINGS,
|
|
handleFilenameCaseSensitive: false,
|
|
remoteType: REMOTE_COUCHDB,
|
|
...settingsOverride,
|
|
},
|
|
confirm: {
|
|
askSelectStringDialogue,
|
|
},
|
|
} as any;
|
|
applyPartial.mockImplementation(async (partial: Record<string, unknown>) => {
|
|
core.settings = { ...core.settings, ...partial };
|
|
});
|
|
|
|
Object.defineProperty(core, "services", {
|
|
get() {
|
|
return core._services;
|
|
},
|
|
});
|
|
|
|
const module = new ModuleResolvingMismatchedTweaks(core);
|
|
return { module, core, askSelectStringDialogue, applyPartial, reinitialise };
|
|
}
|
|
|
|
describe("ModuleResolvingMismatchedTweaks", () => {
|
|
it("compatibility: offers ordinary application for a missing legacy filename-case setting", async () => {
|
|
const { module, askSelectStringDialogue } = createModule({
|
|
autoAcceptCompatibleTweak: false,
|
|
customChunkSize: 60,
|
|
usePluginSyncV2: true,
|
|
handleFilenameCaseSensitive: false,
|
|
});
|
|
const preferred: TweakValues = {
|
|
...DEFAULT_SETTINGS,
|
|
customChunkSize: 0,
|
|
usePluginSyncV2: false,
|
|
};
|
|
delete preferred.handleFilenameCaseSensitive;
|
|
|
|
await module._checkAndAskResolvingMismatchedTweaks(preferred);
|
|
|
|
expect(askSelectStringDialogue.mock.calls[0][1]).toContain("Apply settings to this device");
|
|
expect(askSelectStringDialogue.mock.calls[0][0]).not.toContain("Handle files as Case-Sensitive");
|
|
});
|
|
|
|
it("compares the trial configuration when deciding whether to accept compatible remote values", async () => {
|
|
const { module, askSelectStringDialogue } = createModule({
|
|
autoAcceptCompatibleTweak: true,
|
|
hashAlg: "xxhash32",
|
|
tweakModified: 300,
|
|
});
|
|
const trial = {
|
|
...DEFAULT_SETTINGS,
|
|
hashAlg: "xxhash64",
|
|
tweakModified: 100,
|
|
} as RemoteDBSettings;
|
|
const preferred = { ...trial, hashAlg: "xxhash32", tweakModified: 200 } as TweakValues;
|
|
|
|
const result = await module._askUseRemoteConfiguration(trial, preferred);
|
|
|
|
expect(result).toEqual({ result: { ...trial, ...preferred }, requireFetch: false });
|
|
expect(askSelectStringDialogue).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("discards remote profile adoption if the active publication changed while awaiting it", async () => {
|
|
const { module, core, askSelectStringDialogue } = createModule({
|
|
autoAcceptCompatibleTweak: false,
|
|
usePluginSyncV2: true,
|
|
});
|
|
let publication = {};
|
|
core._services.replicator.acquireActiveReplicatorContext.mockImplementation(async () => publication);
|
|
askSelectStringDialogue.mockImplementation(async () => {
|
|
publication = {};
|
|
return "Use configured settings";
|
|
});
|
|
const trial = { ...core.settings } as RemoteDBSettings;
|
|
const preferred = { ...trial, usePluginSyncV2: false };
|
|
|
|
const result = await module._askUseRemoteConfiguration(trial, preferred);
|
|
|
|
expect(askSelectStringDialogue).toHaveBeenCalled();
|
|
expect(result).toEqual({ result: false, requireFetch: false });
|
|
});
|
|
|
|
it("discards a decision if the connection settings changed while awaiting it", async () => {
|
|
const { module, core, reinitialise } = createModule({ hashAlg: "xxhash64" });
|
|
const preferred = { ...DEFAULT_SETTINGS, hashAlg: "xxhash32" } as TweakValues;
|
|
core._services.tweakValue = {
|
|
checkAndAskResolvingMismatched: vi.fn(async () => {
|
|
core.settings.couchDB_DBNAME = "another-database";
|
|
return [preferred, false];
|
|
}),
|
|
};
|
|
const updatePreferredRemote = vi.fn(async () => true);
|
|
|
|
const result = await module._askResolvingMismatchedTweaks(preferred, updatePreferredRemote);
|
|
|
|
expect(result).toBe("IGNORE");
|
|
expect(core.settings.hashAlg).toBe("xxhash64");
|
|
expect(core._services.setting.saveSettingData).not.toHaveBeenCalled();
|
|
expect(reinitialise).not.toHaveBeenCalled();
|
|
expect(updatePreferredRemote).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("discards a decision if its active publication was replaced while awaiting it", async () => {
|
|
const { module, core, reinitialise } = createModule({ hashAlg: "xxhash64" });
|
|
const preferred = { ...BASE_TWEAKS, hashAlg: "xxhash32" } as TweakValues;
|
|
core._services.tweakValue = {
|
|
checkAndAskResolvingMismatched: vi.fn(async () => [preferred, false]),
|
|
};
|
|
core._services.replicator.acquireActiveReplicatorContext.mockResolvedValueOnce({}).mockResolvedValueOnce({});
|
|
const updatePreferredRemote = vi.fn(async () => true);
|
|
|
|
await expect(module._askResolvingMismatchedTweaks(preferred, updatePreferredRemote)).resolves.toBe("IGNORE");
|
|
|
|
expect(core._services.setting.saveSettingData).not.toHaveBeenCalled();
|
|
expect(reinitialise).not.toHaveBeenCalled();
|
|
expect(updatePreferredRemote).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("uses each direction's assessed reconstruction consequence in the available choices", async () => {
|
|
const { module, core, askSelectStringDialogue } = createModule({ autoAcceptCompatibleTweak: false });
|
|
const preferred = { ...BASE_TWEAKS, encrypt: true };
|
|
const assessment = assessTweakCompatibility(core.settings, preferred);
|
|
const directionalAssessment = {
|
|
...assessment,
|
|
adoptCurrent: { ...assessment.adoptCurrent, reconstruction: "none" as const },
|
|
};
|
|
askSelectStringDialogue.mockResolvedValueOnce("Update remote database settings");
|
|
|
|
const result = await module._checkAndAskResolvingMismatchedTweaks(preferred, directionalAssessment);
|
|
|
|
expect(result).toEqual([true, false]);
|
|
expect(askSelectStringDialogue.mock.calls[0][1]).toContain("Apply settings to this device, and fetch again");
|
|
expect(askSelectStringDialogue.mock.calls[0][1]).not.toContain("Apply settings to this device");
|
|
});
|
|
|
|
it("keeps explicitly chosen Fetch failures from becoming a successful retry", async () => {
|
|
const { module, core } = createModule({ hashAlg: "xxhash64" });
|
|
const preferred = { ...BASE_TWEAKS, hashAlg: "xxhash32" } as TweakValues;
|
|
core._services.tweakValue = {
|
|
checkAndAskResolvingMismatched: vi.fn(async () => [preferred, true]),
|
|
};
|
|
const failure = new Error("Fetch failed");
|
|
core.rebuilder = {
|
|
$fetchLocal: vi.fn(async () => {
|
|
throw failure;
|
|
}),
|
|
};
|
|
|
|
await expect(module._askResolvingMismatchedTweaks(preferred, async () => true)).rejects.toBe(failure);
|
|
});
|
|
|
|
it("does not erase an explicit local setting when accepting a partial remote configuration", async () => {
|
|
const { module, core } = createModule({ handleFilenameCaseSensitive: false });
|
|
core._services.tweakValue = {
|
|
checkAndAskResolvingMismatched: vi.fn(async () => [{ customChunkSize: 30 }, false]),
|
|
};
|
|
|
|
await expect(module._askResolvingMismatchedTweaks({ customChunkSize: 30 }, async () => true)).resolves.toBe(
|
|
"CHECKAGAIN"
|
|
);
|
|
expect(core.settings.handleFilenameCaseSensitive).toBe(false);
|
|
expect(core.settings.customChunkSize).toBe(30);
|
|
});
|
|
|
|
it("preserves a remote recommendation which this device has not advertised", async () => {
|
|
const { module, core } = createModule({ hashAlg: "xxhash64" });
|
|
delete core.settings.readChunksOnline;
|
|
const preferred = { ...BASE_TWEAKS, hashAlg: "xxhash32", readChunksOnline: false } as TweakValues;
|
|
core._services.tweakValue = {
|
|
checkAndAskResolvingMismatched: vi.fn(async () => [true, false]),
|
|
};
|
|
const updateRemote = vi.fn(async () => true);
|
|
|
|
await expect(module._askResolvingMismatchedTweaks(preferred, updateRemote)).resolves.toBe("CHECKAGAIN");
|
|
expect(updateRemote).toHaveBeenCalledWith(
|
|
expect.objectContaining({ hashAlg: "xxhash64", readChunksOnline: false })
|
|
);
|
|
});
|
|
|
|
it("uses the failed attempt hint and writes only through that exact active publication", async () => {
|
|
const { module, core } = createModule();
|
|
const attemptPreferred = {
|
|
...BASE_TWEAKS,
|
|
customChunkSize: 60,
|
|
};
|
|
const replacementPreferred = {
|
|
...BASE_TWEAKS,
|
|
customChunkSize: 99,
|
|
};
|
|
let updatePreferredRemote: ((setting: typeof core.settings) => Promise<boolean>) | undefined;
|
|
const askResolvingMismatched = vi.fn(
|
|
async (_preferred: unknown, update: (setting: typeof core.settings) => Promise<boolean>) => {
|
|
updatePreferredRemote = update;
|
|
return "IGNORE" as const;
|
|
}
|
|
);
|
|
core._services.tweakValue = { askResolvingMismatched };
|
|
core.replicator = {
|
|
tweakSettingsMismatched: true,
|
|
preferredTweakValue: replacementPreferred,
|
|
};
|
|
const failedSetPreferred = vi.fn(async (_setting: typeof core.settings) => undefined);
|
|
const replacementSetPreferred = vi.fn(async (_setting: typeof core.settings) => undefined);
|
|
const failedContext = {
|
|
provider: {},
|
|
replicator: { setPreferredRemoteTweakSettings: failedSetPreferred },
|
|
configurationIdentity: "profile-a",
|
|
};
|
|
const replacementContext = {
|
|
provider: {},
|
|
replicator: { setPreferredRemoteTweakSettings: replacementSetPreferred },
|
|
configurationIdentity: "profile-b",
|
|
};
|
|
let activeContext = failedContext;
|
|
core._services.replicator = {
|
|
runWithActiveReplicatorContext: vi.fn(async (task: (context: typeof failedContext) => unknown) =>
|
|
task(activeContext)
|
|
),
|
|
};
|
|
const request = {
|
|
context: failedContext,
|
|
setting: core.settings,
|
|
outcome: {
|
|
status: "failed" as const,
|
|
error: new Error("directional replication failed"),
|
|
recoveryHint: {
|
|
reason: CENTRAL_COMPATIBILITY_REJECTION_REASONS.TWEAK_MISMATCH,
|
|
preferredTweakValue: attemptPreferred,
|
|
},
|
|
},
|
|
showMessage: true,
|
|
interaction: USER_INITIATED_REPLICATION_AUTHORITY,
|
|
} as unknown as ReplicationAttemptFailure;
|
|
|
|
await expect(module._anyAfterConnectCheckFailed(request)).resolves.toBe(true);
|
|
|
|
expect(askResolvingMismatched).toHaveBeenCalledWith(
|
|
attemptPreferred,
|
|
expect.any(Function),
|
|
expect.objectContaining({ alignment: "mismatched" })
|
|
);
|
|
const effectiveSetting = { ...core.settings, customChunkSize: 64 };
|
|
await expect(updatePreferredRemote?.(effectiveSetting)).resolves.toBe(true);
|
|
expect(failedSetPreferred).toHaveBeenCalledWith(effectiveSetting);
|
|
expect(failedSetPreferred.mock.calls[0][0]).not.toBe(effectiveSetting);
|
|
|
|
activeContext = replacementContext;
|
|
await expect(updatePreferredRemote?.({ ...effectiveSetting, customChunkSize: 72 })).resolves.toBe(false);
|
|
expect(failedSetPreferred).toHaveBeenCalledOnce();
|
|
expect(replacementSetPreferred).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("returns an unconfigured remote result without a separate connection preflight", async () => {
|
|
const { module, core } = createModule();
|
|
const read = vi.fn(async () => ({
|
|
status: "not-configured" as const,
|
|
reason: "milestone-missing" as const,
|
|
}));
|
|
const dispose = vi.fn(async () => undefined);
|
|
const createRemoteResource = vi.fn(async () => ({ read, dispose }));
|
|
core._services.replicator = {
|
|
createRemoteResource,
|
|
getNewReplicator: vi.fn(() => Promise.reject(new Error("must not borrow a Replicator"))),
|
|
};
|
|
|
|
await expect(module._fetchRemotePreferredTweakValues(core.settings)).resolves.toEqual({
|
|
status: "not-configured",
|
|
reason: "milestone-missing",
|
|
});
|
|
expect(createRemoteResource).toHaveBeenCalledWith(REMOTE_RESOURCE_KINDS.PREFERRED_TWEAK, core.settings);
|
|
expect(read).toHaveBeenCalledOnce();
|
|
expect(dispose).toHaveBeenCalledOnce();
|
|
expect(core._services.replicator.getNewReplicator).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("returns unsupported when no replicator implements the remote type", async () => {
|
|
const { module, core } = createModule();
|
|
core._services.replicator = {
|
|
createRemoteResource: vi.fn(async () => undefined),
|
|
};
|
|
|
|
await expect(module._fetchRemotePreferredTweakValues(core.settings)).resolves.toEqual({
|
|
status: "unsupported",
|
|
});
|
|
});
|
|
|
|
it("disposes the preferred-tweak probe when reading fails", async () => {
|
|
const { module, core } = createModule();
|
|
const error = new Error("remote unavailable");
|
|
const dispose = vi.fn(async () => undefined);
|
|
core._services.replicator = {
|
|
createRemoteResource: vi.fn(async () => ({
|
|
read: vi.fn(async () => {
|
|
throw error;
|
|
}),
|
|
dispose,
|
|
})),
|
|
};
|
|
|
|
await expect(module._fetchRemotePreferredTweakValues(core.settings)).resolves.toEqual({
|
|
status: "unavailable",
|
|
error,
|
|
});
|
|
expect(dispose).toHaveBeenCalledOnce();
|
|
});
|
|
|
|
it("should enable and auto-accept compatible mismatches when the preference is undefined", async () => {
|
|
const { module, core, askSelectStringDialogue, applyPartial } = createModule({
|
|
autoAcceptCompatibleTweak: undefined,
|
|
hashAlg: "xxhash64",
|
|
tweakModified: 100,
|
|
});
|
|
const initialSettings = core.settings;
|
|
|
|
const preferred = {
|
|
...BASE_TWEAKS,
|
|
hashAlg: "xxhash32",
|
|
tweakModified: 200,
|
|
} as Partial<TweakValues>;
|
|
|
|
const [conf, rebuild] = await module._checkAndAskResolvingMismatchedTweaks(preferred);
|
|
|
|
expect(conf).toEqual(preferred);
|
|
expect(rebuild).toBe(false);
|
|
expect(core.settings).toBe(initialSettings);
|
|
expect(core.settings.autoAcceptCompatibleTweak).toBe(true);
|
|
expect(core._services.setting.saveSettingData).toHaveBeenCalledTimes(1);
|
|
expect(applyPartial).not.toHaveBeenCalled();
|
|
expect(askSelectStringDialogue).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("should auto-accept compatible mismatches on connect check using newer remote tweakModified", async () => {
|
|
const { module, askSelectStringDialogue } = createModule({
|
|
autoAcceptCompatibleTweak: true,
|
|
hashAlg: "xxhash64",
|
|
tweakModified: 100,
|
|
});
|
|
|
|
const preferred = {
|
|
...BASE_TWEAKS,
|
|
hashAlg: "xxhash32",
|
|
tweakModified: 200,
|
|
} as Partial<TweakValues>;
|
|
|
|
const [conf, rebuild] = await module._checkAndAskResolvingMismatchedTweaks(preferred);
|
|
|
|
expect(conf).toEqual(preferred);
|
|
expect(rebuild).toBe(false);
|
|
expect(askSelectStringDialogue).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it.each([
|
|
{ label: "neither side has a recorded time", currentModified: 0, preferredModified: 0 },
|
|
{ label: "the recorded times are equal", currentModified: 200, preferredModified: 200 },
|
|
])("should use the remote compatible value when $label", async ({ currentModified, preferredModified }) => {
|
|
const { module, askSelectStringDialogue } = createModule({
|
|
autoAcceptCompatibleTweak: true,
|
|
hashAlg: "xxhash64",
|
|
tweakModified: currentModified,
|
|
});
|
|
const preferred = {
|
|
...BASE_TWEAKS,
|
|
hashAlg: "xxhash32",
|
|
tweakModified: preferredModified,
|
|
} as Partial<TweakValues>;
|
|
|
|
const [conf, rebuild] = await module._checkAndAskResolvingMismatchedTweaks(preferred);
|
|
|
|
expect(conf).toEqual(preferred);
|
|
expect(rebuild).toBe(false);
|
|
expect(askSelectStringDialogue).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("should fallback to manual confirmation when mismatches are mixed on connect check", async () => {
|
|
const { module, askSelectStringDialogue } = createModule({
|
|
autoAcceptCompatibleTweak: true,
|
|
hashAlg: "xxhash64",
|
|
encrypt: false,
|
|
tweakModified: 100,
|
|
});
|
|
|
|
const preferred = {
|
|
...BASE_TWEAKS,
|
|
hashAlg: "xxhash32",
|
|
encrypt: true,
|
|
tweakModified: 200,
|
|
} as Partial<TweakValues>;
|
|
|
|
const [conf, rebuild] = await module._checkAndAskResolvingMismatchedTweaks(preferred);
|
|
|
|
expect(conf).toBe(false);
|
|
expect(rebuild).toBe(false);
|
|
expect(askSelectStringDialogue).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it("should fetch after applying a compatible remote setting when the user selects the rebuild option", async () => {
|
|
const { module, askSelectStringDialogue } = createModule({
|
|
autoAcceptCompatibleTweak: false,
|
|
hashAlg: "xxhash64",
|
|
});
|
|
askSelectStringDialogue.mockResolvedValueOnce("Apply settings to this device, and fetch again");
|
|
|
|
const preferred = {
|
|
...BASE_TWEAKS,
|
|
hashAlg: "xxhash32",
|
|
} as TweakValues;
|
|
|
|
const [conf, rebuild] = await module._checkAndAskResolvingMismatchedTweaks(preferred);
|
|
|
|
expect(conf).toEqual(preferred);
|
|
expect(rebuild).toBe(true);
|
|
});
|
|
|
|
it("should auto-accept compatible mismatches on remote-config check using newer local tweakModified", async () => {
|
|
const { module, askSelectStringDialogue } = createModule({
|
|
autoAcceptCompatibleTweak: true,
|
|
hashAlg: "xxhash64",
|
|
tweakModified: 300,
|
|
});
|
|
|
|
const trialSetting = {
|
|
...DEFAULT_SETTINGS,
|
|
remoteType: REMOTE_COUCHDB,
|
|
hashAlg: "xxhash64",
|
|
tweakModified: 300,
|
|
} as RemoteDBSettings;
|
|
|
|
const preferred = {
|
|
...(trialSetting as unknown as TweakValues),
|
|
hashAlg: "xxhash32",
|
|
tweakModified: 200,
|
|
} as TweakValues;
|
|
|
|
const result = await module._askUseRemoteConfiguration(trialSetting, preferred);
|
|
|
|
expect(result).toEqual({ result: false, requireFetch: false });
|
|
expect(askSelectStringDialogue).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("should apply remote compatible settings in place and reinitialise managers before retrying", async () => {
|
|
const { module, core, reinitialise } = createModule({
|
|
autoAcceptCompatibleTweak: true,
|
|
hashAlg: "xxhash64",
|
|
tweakModified: 100,
|
|
});
|
|
const initialSettings = core.settings;
|
|
const preferred = {
|
|
...BASE_TWEAKS,
|
|
hashAlg: "xxhash32",
|
|
tweakModified: 200,
|
|
} as TweakValues;
|
|
const calls: string[] = [];
|
|
core._services.tweakValue = {
|
|
checkAndAskResolvingMismatched: vi.fn(async () => [preferred, false]),
|
|
};
|
|
core._services.setting.saveSettingData = vi.fn(async () => {
|
|
calls.push("save");
|
|
});
|
|
core.replicator = {
|
|
tweakSettingsMismatched: true,
|
|
preferredTweakValue: preferred,
|
|
setPreferredRemoteTweakSettings: vi.fn(async () => {
|
|
calls.push("set-preferred");
|
|
}),
|
|
};
|
|
reinitialise.mockImplementation(async () => {
|
|
calls.push("reinitialise");
|
|
});
|
|
const updatePreferredRemote = vi.fn(async () => {
|
|
calls.push("set-preferred");
|
|
return true;
|
|
});
|
|
|
|
const result = await module._askResolvingMismatchedTweaks(preferred, updatePreferredRemote);
|
|
|
|
expect(result).toBe("CHECKAGAIN");
|
|
expect(core.settings).toBe(initialSettings);
|
|
expect(core.settings.hashAlg).toBe("xxhash32");
|
|
expect(calls).toEqual(["save", "reinitialise", "set-preferred"]);
|
|
expect(core.replicator.setPreferredRemoteTweakSettings).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("ModuleResolvingMismatchedTweaks setting labels", () => {
|
|
afterEach(() => setLang("def"));
|
|
|
|
async function renderMismatchTable() {
|
|
const { module, askSelectStringDialogue } = createModule({
|
|
autoAcceptCompatibleTweak: true,
|
|
hashAlg: "xxhash64",
|
|
encrypt: false,
|
|
tweakModified: 100,
|
|
});
|
|
const preferred = {
|
|
...BASE_TWEAKS,
|
|
hashAlg: "xxhash32",
|
|
encrypt: true,
|
|
tweakModified: 200,
|
|
} as Partial<TweakValues>;
|
|
|
|
await module._checkAndAskResolvingMismatchedTweaks(preferred);
|
|
|
|
return String(askSelectStringDialogue.mock.calls[0]?.[0] ?? "");
|
|
}
|
|
|
|
it("localises the setting names and keeps the status suffix", async () => {
|
|
setLang("zh-tw");
|
|
|
|
const message = await renderMismatchTable();
|
|
|
|
expect(message).toContain("chunk ID 的雜湊演算法 (Experimental)");
|
|
expect(message).toContain("端對端加密");
|
|
expect(message).not.toContain("The Hash algorithm for chunk IDs");
|
|
});
|
|
|
|
it("leaves English unchanged", async () => {
|
|
const message = await renderMismatchTable();
|
|
|
|
expect(message).toContain("The Hash algorithm for chunk IDs (Experimental)");
|
|
expect(message).toContain("End-to-End Encryption");
|
|
});
|
|
});
|