wehub-resource-sync
79 lines
3.5 KiB
TypeScript
79 lines
3.5 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import {
|
|
PRESERVE_SYSTEM_PROMPT_MODES,
|
|
isPreserveSystemPromptMode,
|
|
normalizePreserveSystemPromptMode,
|
|
resolvePreserveSystemPrompt,
|
|
modeToBaselineBoolean,
|
|
} from "../../../open-sse/services/compression/preserveSystemPromptMode.ts";
|
|
|
|
// T05/C5 — preserveSystemPrompt boolean -> enum (always | whenNoCache | never) + back-compat shim.
|
|
|
|
test("isPreserveSystemPromptMode only accepts the three known tokens", () => {
|
|
for (const m of PRESERVE_SYSTEM_PROMPT_MODES) assert.equal(isPreserveSystemPromptMode(m), true);
|
|
for (const bad of ["", "Always", "no-cache", true, false, 1, null, undefined, {}]) {
|
|
assert.equal(isPreserveSystemPromptMode(bad), false, `${String(bad)} must be rejected`);
|
|
}
|
|
});
|
|
|
|
test("normalize: an explicit mode wins over the legacy boolean", () => {
|
|
assert.equal(
|
|
normalizePreserveSystemPromptMode({ preserveSystemPrompt: true, preserveSystemPromptMode: "never" }),
|
|
"never"
|
|
);
|
|
assert.equal(
|
|
normalizePreserveSystemPromptMode({ preserveSystemPrompt: false, preserveSystemPromptMode: "always" }),
|
|
"always"
|
|
);
|
|
});
|
|
|
|
test("normalize: the shim maps the legacy boolean 1:1 (true->always, false->whenNoCache)", () => {
|
|
// The shim is a behaviour identity: legacy `false` already meant "compress unless
|
|
// there is a cache" via the #3890/#3955 guard, i.e. exactly `whenNoCache`.
|
|
assert.equal(normalizePreserveSystemPromptMode({ preserveSystemPrompt: true }), "always");
|
|
assert.equal(normalizePreserveSystemPromptMode({ preserveSystemPrompt: false }), "whenNoCache");
|
|
});
|
|
|
|
test("normalize: an invalid mode string falls back to the legacy boolean", () => {
|
|
assert.equal(
|
|
normalizePreserveSystemPromptMode({
|
|
preserveSystemPrompt: false,
|
|
preserveSystemPromptMode: "garbage" as unknown as "always",
|
|
}),
|
|
"whenNoCache"
|
|
);
|
|
});
|
|
|
|
test("resolve: always preserves and never compresses regardless of cache", () => {
|
|
assert.equal(resolvePreserveSystemPrompt("always", { hasCache: true }), true);
|
|
assert.equal(resolvePreserveSystemPrompt("always", { hasCache: false }), true);
|
|
assert.equal(resolvePreserveSystemPrompt("never", { hasCache: true }), false);
|
|
assert.equal(resolvePreserveSystemPrompt("never", { hasCache: false }), false);
|
|
});
|
|
|
|
test("resolve: whenNoCache preserves only when a cache is present", () => {
|
|
assert.equal(resolvePreserveSystemPrompt("whenNoCache", { hasCache: true }), true);
|
|
assert.equal(resolvePreserveSystemPrompt("whenNoCache", { hasCache: false }), false);
|
|
});
|
|
|
|
test("modeToBaselineBoolean is the no-cache projection", () => {
|
|
assert.equal(modeToBaselineBoolean("always"), true);
|
|
assert.equal(modeToBaselineBoolean("whenNoCache"), false);
|
|
assert.equal(modeToBaselineBoolean("never"), false);
|
|
});
|
|
|
|
test("back-compat identity: legacy config resolves to the old cache-guard outcome", () => {
|
|
// Old behaviour: preserveSystemPrompt=false stays false without cache, forced true with cache.
|
|
const legacyFalse = { preserveSystemPrompt: false };
|
|
const mode = normalizePreserveSystemPromptMode(legacyFalse);
|
|
assert.equal(resolvePreserveSystemPrompt(mode, { hasCache: false }), false);
|
|
assert.equal(resolvePreserveSystemPrompt(mode, { hasCache: true }), true);
|
|
|
|
// Old behaviour: preserveSystemPrompt=true is always preserved.
|
|
const legacyTrue = { preserveSystemPrompt: true };
|
|
const modeT = normalizePreserveSystemPromptMode(legacyTrue);
|
|
assert.equal(resolvePreserveSystemPrompt(modeT, { hasCache: false }), true);
|
|
assert.equal(resolvePreserveSystemPrompt(modeT, { hasCache: true }), true);
|
|
});
|