9cbb48afa1
* fix(#2753): scan every key occurrence when asserting a documented default The settings-default assertion located each key with indexOf and checked only a 400-char window after the FIRST match. Its stated contract is "the workflow documents the default for this key"; what it actually asserted was "the first mention of this key is followed by the default" - an ordering assumption that was never part of the contract and that breaks the moment a workflow names a key in prose before its settings-table entry. PR #2558 does exactly that: a shared language directive puts response_language at index 6 while the table documents null at 7185, so the gate failed a document that was correct, and the failure message showed the prose window rather than the cause. Extracted findDocumentedDefault, which scans every occurrence and reports how many it examined. Widening the window to the whole file was rejected - it would pass on any unrelated occurrence of the token - as was parsing the settings table, which would couple the check to table markup. The negative case still fails: a key that no occurrence documents is a failure, now with the occurrence count so a genuine miss stays distinguishable from this false negative. * fix(#2753): guard the empty needle and de-vacuum the newline test Isolated review found a real hang: String#indexOf('', pos) clamps to str.length rather than returning -1, so an empty key made the scan loop stabilize at the end of the document and spin forever. Unreachable from SPEC_FIELDS today, but the docstring claimed termination while reasoning only about self-overlap. Guarded, with the clamping behavior named so the guard is not tidied away later. The newline test asserted only that CRLF and LF agree, which a constant stub satisfies. It now pins the absolute verdict on both, plus a document neither style can rescue. Added the property test the review noted was missing: windowSize is a budget limit, so the verdict is asserted to be exactly "key + gap + default fits the window" over disjoint alphabets. It would have caught the empty-key hang on its own. * fix(#2753): assert examined-occurrence count, not the document's total The no-regression test asserted occurrences === 2 because the fixture mentions the key twice. The scan short-circuits on the first documenting window, so exactly one occurrence is examined - the assertion was describing the fixture rather than the function. Documented the semantic properly instead of just correcting the number: occurrences is how many were EXAMINED before deciding, so on success it is the 1-based position of the match and on failure the document's full count. The asymmetry is deliberate - the failure path is where the number must be trustworthy, since "examined N, none documented it" is what separates a genuine miss from the first-occurrence false negative this function removes.
996 lines
43 KiB
JavaScript
996 lines
43 KiB
JavaScript
// allow-test-rule: source-text-is-the-product
|
|
// Workflow .md / agent .md / command .md / reference .md files — their text
|
|
// IS what the runtime loads. Testing text content tests the deployed contract.
|
|
// Per CONTRIBUTING.md exception matrix.
|
|
'use strict';
|
|
|
|
|
|
/**
|
|
* Tests for `/gsd-settings-advanced` — power-user configuration command (#2528).
|
|
*
|
|
* Covers:
|
|
* - Command file exists with correct frontmatter
|
|
* - Workflow file exists with required section structure
|
|
* - Every field in the issue spec is rendered in the workflow with its default
|
|
* - Current values are pre-selected in prompts
|
|
* - Config merge preserves unrelated keys (sibling preservation)
|
|
* - Confirmation table is rendered after save
|
|
* - Every field is accepted by VALID_CONFIG_KEYS
|
|
* - /gsd-settings confirmation output advertises /gsd-settings-advanced
|
|
* - Negative: non-numeric value rejected for numeric field via config-set
|
|
*/
|
|
|
|
const { describe, test } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
|
|
const { createTempProject, cleanup, runGsdTools } = require('./helpers.cjs');
|
|
const { VALID_CONFIG_KEYS } = require('../gsd-core/bin/lib/config-schema.cjs');
|
|
const fc = require('fast-check');
|
|
|
|
/** How far after a key mention the default may appear and still count as documenting it. */
|
|
const DEFAULT_PROXIMITY_WINDOW = 400;
|
|
|
|
/**
|
|
* Is `defaultToken` documented near ANY occurrence of `key` in `workflow`?
|
|
*
|
|
* Scans every occurrence, not just the first (#2753). The contract this enforces is "the
|
|
* workflow documents the default for this key". A first-occurrence search asserts something
|
|
* narrower and different — "the FIRST mention of this key is followed by the default" — which
|
|
* silently breaks the moment a workflow names a key in prose before its settings-table entry.
|
|
* That is a normal thing for a workflow to do, and #2558 does it: a shared language directive
|
|
* puts `response_language` at index 6 while the table documents `null` at 7185, so the check
|
|
* failed on a document that was correct.
|
|
*
|
|
* Deliberately still forgiving about WHERE the evidence sits (any occurrence) and strict about
|
|
* WHAT counts (the token inside a bounded window). Widening the window to the whole file would
|
|
* pass on any unrelated occurrence of the token and gut the check; parsing the settings table
|
|
* would couple this to table markup. Both rejected.
|
|
*
|
|
* @returns {{ok: boolean, occurrences: number, window: string}}
|
|
* `occurrences` is how many key occurrences were EXAMINED before deciding — not how many
|
|
* exist. The scan short-circuits on the first documenting window, so on success this is the
|
|
* 1-based position of the match, and on failure it is the document's full count. That
|
|
* asymmetry is deliberate: the failure path is where the number has to be trustworthy, since
|
|
* "examined N, none documented it" is what distinguishes a genuine miss from the
|
|
* first-occurrence false negative this function exists to remove. `occurrences: 0` = key absent.
|
|
*/
|
|
function findDocumentedDefault(workflow, key, defaultToken, windowSize = DEFAULT_PROXIMITY_WINDOW) {
|
|
let occurrences = 0;
|
|
let lastWindow = '';
|
|
// An empty needle would HANG this loop, not end it: String#indexOf('', pos) clamps to
|
|
// str.length instead of returning -1, so `idx` stabilizes at the end and never goes
|
|
// negative. Every SPEC_FIELDS key is non-empty today, which is exactly why this has to be
|
|
// guarded rather than assumed.
|
|
if (typeof key !== 'string' || key === '') {
|
|
return { ok: false, occurrences: 0, window: '' };
|
|
}
|
|
// Advance by one char, not by key length: a key that overlaps itself or sits inside the
|
|
// default token must still terminate.
|
|
for (let idx = workflow.indexOf(key); idx >= 0; idx = workflow.indexOf(key, idx + 1)) {
|
|
occurrences += 1;
|
|
lastWindow = workflow.slice(idx, idx + windowSize);
|
|
if (lastWindow.includes(defaultToken)) {
|
|
return { ok: true, occurrences, window: lastWindow };
|
|
}
|
|
}
|
|
return { ok: false, occurrences, window: lastWindow };
|
|
}
|
|
|
|
const ROOT = path.resolve(__dirname, '..');
|
|
// #2790: settings-advanced.md was consolidated into config.md as the --advanced flag.
|
|
const COMMAND_PATH = path.join(ROOT, 'commands', 'gsd', 'config.md');
|
|
const WORKFLOW_PATH = path.join(ROOT, 'gsd-core', 'workflows', 'settings-advanced.md');
|
|
const SETTINGS_WORKFLOW_PATH = path.join(ROOT, 'gsd-core', 'workflows', 'settings.md');
|
|
|
|
// ─── Spec — every field the advanced command must expose ──────────────────────
|
|
|
|
const SPEC_FIELDS = {
|
|
planning: [
|
|
{ key: 'workflow.plan_bounce', default: 'false' },
|
|
{ key: 'workflow.plan_bounce_passes', default: '2' },
|
|
{ key: 'workflow.plan_bounce_script', default: 'null' },
|
|
{ key: 'workflow.subagent_timeout', default: '300000' },
|
|
{ key: 'workflow.inline_plan_threshold', default: '3' },
|
|
],
|
|
execution: [
|
|
{ key: 'workflow.node_repair', default: 'true' },
|
|
{ key: 'workflow.node_repair_budget', default: '2' },
|
|
{ key: 'workflow.auto_prune_state', default: 'false' },
|
|
],
|
|
discussion: [
|
|
{ key: 'workflow.max_discuss_passes', default: '3' },
|
|
],
|
|
cross_ai: [
|
|
{ key: 'workflow.cross_ai_execution', default: 'false' },
|
|
{ key: 'workflow.cross_ai_command', default: 'null' },
|
|
{ key: 'workflow.cross_ai_timeout', default: '300' },
|
|
],
|
|
git: [
|
|
{ key: 'git.base_branch', default: 'main' },
|
|
{ key: 'git.phase_branch_template', default: 'gsd/phase-{phase}-{slug}' },
|
|
{ key: 'git.milestone_branch_template', default: 'gsd/{milestone}-{slug}' },
|
|
],
|
|
runtime: [
|
|
{ key: 'response_language', default: 'null' },
|
|
{ key: 'context_window', default: '200000' },
|
|
{ key: 'search_gitignored', default: 'false' },
|
|
{ key: 'graphify.build_timeout', default: '300' },
|
|
],
|
|
};
|
|
|
|
const ALL_SPEC_KEYS = Object.values(SPEC_FIELDS).flat().map((f) => f.key);
|
|
|
|
// ─── File existence + frontmatter ─────────────────────────────────────────────
|
|
|
|
describe('gsd-settings-advanced — file scaffolding', () => {
|
|
test('consolidated config.md command exists (#2790: settings-advanced absorbed)', () => {
|
|
assert.ok(fs.existsSync(COMMAND_PATH), `missing ${COMMAND_PATH}`);
|
|
});
|
|
|
|
test('workflow file exists at gsd-core/workflows/settings-advanced.md', () => {
|
|
assert.ok(fs.existsSync(WORKFLOW_PATH), `missing ${WORKFLOW_PATH}`);
|
|
});
|
|
|
|
test('command frontmatter has name, description, allowed-tools', () => {
|
|
const text = fs.readFileSync(COMMAND_PATH, 'utf-8');
|
|
const fmMatch = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
|
|
assert.ok(fmMatch, 'command file missing frontmatter block');
|
|
const fm = fmMatch[1];
|
|
assert.match(fm, /name:\s*gsd:config/, 'frontmatter missing name (gsd:config)');
|
|
assert.match(fm, /description:\s*\S/, 'frontmatter missing non-empty description');
|
|
assert.match(fm, /allowed-tools:/, 'frontmatter missing allowed-tools');
|
|
});
|
|
|
|
test('command routes to the settings-advanced workflow via --advanced flag', () => {
|
|
const text = fs.readFileSync(COMMAND_PATH, 'utf-8');
|
|
assert.ok(
|
|
text.includes('workflows/settings-advanced.md') || text.includes('--advanced'),
|
|
'config.md must reference settings-advanced workflow or --advanced flag'
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── Workflow content — sections and fields ───────────────────────────────────
|
|
|
|
describe('gsd-settings-advanced — workflow structure', () => {
|
|
let workflow;
|
|
try {
|
|
workflow = fs.readFileSync(WORKFLOW_PATH, 'utf-8');
|
|
} catch { workflow = ''; }
|
|
|
|
const requiredSteps = [
|
|
'ensure_and_load_config',
|
|
'read_current',
|
|
'present_settings',
|
|
'update_config',
|
|
'confirm',
|
|
];
|
|
for (const step of requiredSteps) {
|
|
test(`workflow defines <step name="${step}">`, () => {
|
|
assert.ok(
|
|
workflow.includes(`<step name="${step}">`),
|
|
`workflow missing step ${step}`
|
|
);
|
|
});
|
|
}
|
|
|
|
const requiredSections = [
|
|
'Planning Tuning',
|
|
'Execution Tuning',
|
|
'Discussion Tuning',
|
|
'Cross-AI Execution',
|
|
'Git Customization',
|
|
'Runtime / Output',
|
|
];
|
|
for (const section of requiredSections) {
|
|
test(`workflow renders section "${section}"`, () => {
|
|
assert.ok(
|
|
workflow.includes(section),
|
|
`workflow missing section heading "${section}"`
|
|
);
|
|
});
|
|
}
|
|
|
|
for (const field of Object.values(SPEC_FIELDS).flat()) {
|
|
test(`workflow mentions key \`${field.key}\``, () => {
|
|
assert.ok(
|
|
workflow.includes(field.key),
|
|
`workflow missing field ${field.key}`
|
|
);
|
|
});
|
|
test(`workflow documents default for \`${field.key}\` (${field.default})`, () => {
|
|
// Proximity search across EVERY occurrence of the key, not just the first (#2753).
|
|
const found = findDocumentedDefault(workflow, field.key, field.default);
|
|
assert.ok(found.occurrences > 0, `key ${field.key} not found`);
|
|
assert.ok(
|
|
found.ok,
|
|
`default "${field.default}" not found within ${DEFAULT_PROXIMITY_WINDOW} chars of any ` +
|
|
`of the ${found.occurrences} occurrence(s) of key ${field.key}. Last window:\n${found.window}`
|
|
);
|
|
});
|
|
}
|
|
|
|
test('workflow pre-selects current values from loaded config', () => {
|
|
assert.match(
|
|
workflow,
|
|
/pre-selected|current value|Current:/i,
|
|
'workflow must document that current values are pre-selected'
|
|
);
|
|
});
|
|
|
|
test('confirmation step renders a table with saved settings', () => {
|
|
const confirmStart = workflow.indexOf('<step name="confirm">');
|
|
assert.ok(confirmStart >= 0, 'confirm step missing');
|
|
const confirmBlock = workflow.slice(confirmStart);
|
|
assert.ok(
|
|
confirmBlock.includes('|') && /\|[^\n]*Setting[^\n]*\|/.test(confirmBlock),
|
|
'confirm step must render a markdown table with a Setting column'
|
|
);
|
|
});
|
|
|
|
test('update_config step describes merge-preserving-siblings behavior', () => {
|
|
assert.match(
|
|
workflow,
|
|
/(preserv(e|ing) (unrelated|sibling)|do not clobber|merge .*existing|...existing_config)/i,
|
|
'update_config step must describe preserving unrelated keys'
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── VALID_CONFIG_KEYS membership ─────────────────────────────────────────────
|
|
|
|
describe('gsd-settings-advanced — VALID_CONFIG_KEYS coverage', () => {
|
|
for (const key of ALL_SPEC_KEYS) {
|
|
test(`VALID_CONFIG_KEYS contains "${key}"`, () => {
|
|
assert.ok(
|
|
VALID_CONFIG_KEYS.has(key),
|
|
`VALID_CONFIG_KEYS missing ${key} — add it to gsd-core/bin/lib/config-schema.cjs`
|
|
);
|
|
});
|
|
}
|
|
});
|
|
|
|
// ─── /gsd-settings mentions /gsd-settings-advanced ────────────────────────────
|
|
|
|
describe('/gsd-settings advertises /gsd-settings-advanced', () => {
|
|
test('settings workflow mentions canonical /gsd-config --advanced', () => {
|
|
const text = fs.readFileSync(SETTINGS_WORKFLOW_PATH, 'utf-8');
|
|
assert.ok(
|
|
text.includes('/gsd:config --advanced'),
|
|
'gsd-core/workflows/settings.md must mention /gsd:config --advanced'
|
|
);
|
|
assert.ok(
|
|
!text.includes('gsd-settings-advanced') && !text.includes('gsd:settings-advanced'),
|
|
'gsd-core/workflows/settings.md must not mention legacy /gsd-settings-advanced variants'
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── Sibling-preservation via config-set ──────────────────────────────────────
|
|
|
|
describe('gsd-settings-advanced — config merge preserves unrelated keys', () => {
|
|
test('setting workflow.plan_bounce_passes does not clobber model_profile or git.branching_strategy', (t) => {
|
|
const tmpDir = createTempProject();
|
|
t.after(() => cleanup(tmpDir));
|
|
|
|
// Seed config
|
|
const configPath = path.join(tmpDir, '.planning', 'config.json');
|
|
const initial = {
|
|
model_profile: 'quality',
|
|
git: {
|
|
branching_strategy: 'phase',
|
|
phase_branch_template: 'feature/{phase}-{slug}',
|
|
},
|
|
workflow: {
|
|
research: true,
|
|
plan_check: false,
|
|
},
|
|
hooks: {
|
|
context_warnings: true,
|
|
},
|
|
};
|
|
fs.writeFileSync(configPath, JSON.stringify(initial, null, 2), 'utf-8');
|
|
|
|
const result = runGsdTools(
|
|
['config-set', 'workflow.plan_bounce_passes', '5'],
|
|
tmpDir,
|
|
{ HOME: tmpDir }
|
|
);
|
|
assert.ok(result.success, `config-set failed: ${result.error || result.output}`);
|
|
|
|
const updated = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
|
|
assert.strictEqual(updated.model_profile, 'quality', 'model_profile clobbered');
|
|
assert.strictEqual(updated.git.branching_strategy, 'phase', 'git.branching_strategy clobbered');
|
|
assert.strictEqual(updated.git.phase_branch_template, 'feature/{phase}-{slug}', 'git.phase_branch_template clobbered');
|
|
assert.strictEqual(updated.workflow.research, true, 'workflow.research clobbered');
|
|
assert.strictEqual(updated.workflow.plan_check, false, 'workflow.plan_check clobbered');
|
|
assert.strictEqual(updated.hooks.context_warnings, true, 'hooks.context_warnings clobbered');
|
|
assert.strictEqual(updated.workflow.plan_bounce_passes, 5, 'new value not written');
|
|
});
|
|
|
|
test('setting context_window preserves existing top-level keys', (t) => {
|
|
const tmpDir = createTempProject();
|
|
t.after(() => cleanup(tmpDir));
|
|
|
|
const configPath = path.join(tmpDir, '.planning', 'config.json');
|
|
fs.writeFileSync(configPath, JSON.stringify({
|
|
model_profile: 'balanced',
|
|
response_language: 'Japanese',
|
|
search_gitignored: true,
|
|
}, null, 2));
|
|
|
|
const result = runGsdTools(
|
|
['config-set', 'context_window', '1000000'],
|
|
tmpDir,
|
|
{ HOME: tmpDir }
|
|
);
|
|
assert.ok(result.success, `config-set context_window failed: ${result.error || result.output}`);
|
|
|
|
const updated = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
|
|
assert.strictEqual(updated.context_window, 1000000);
|
|
assert.strictEqual(updated.model_profile, 'balanced');
|
|
assert.strictEqual(updated.response_language, 'Japanese');
|
|
assert.strictEqual(updated.search_gitignored, true);
|
|
});
|
|
});
|
|
|
|
// ─── Negative: non-numeric for numeric field / unknown key rejected ───────────
|
|
|
|
describe('gsd-settings-advanced — negative scenarios', () => {
|
|
test('config-set rejects an unknown key with a helpful error', (t) => {
|
|
const tmpDir = createTempProject();
|
|
t.after(() => cleanup(tmpDir));
|
|
|
|
const result = runGsdTools(
|
|
['config-set', 'workflow.no_such_knob_at_all', 'true'],
|
|
tmpDir,
|
|
{ HOME: tmpDir }
|
|
);
|
|
assert.ok(!result.success, 'config-set should reject unknown keys');
|
|
const combined = (result.error || '') + (result.output || '');
|
|
assert.match(combined, /Unknown config key/i);
|
|
});
|
|
|
|
test('workflow.subagent_timeout numeric input is coerced and stored as Number', (t) => {
|
|
// The config-set parser coerces numeric-looking strings to Number.
|
|
// This test locks in the coercion so users can't accidentally save
|
|
// a string for a numeric knob. A non-numeric string would be stored
|
|
// verbatim — we assert the parser prefers Number for numeric literals.
|
|
const tmpDir = createTempProject();
|
|
t.after(() => cleanup(tmpDir));
|
|
|
|
const configPath = path.join(tmpDir, '.planning', 'config.json');
|
|
fs.writeFileSync(configPath, '{}');
|
|
|
|
const okNum = runGsdTools(
|
|
['config-set', 'workflow.subagent_timeout', '900'],
|
|
tmpDir,
|
|
{ HOME: tmpDir }
|
|
);
|
|
assert.ok(okNum.success);
|
|
const c1 = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
|
|
assert.strictEqual(typeof c1.workflow.subagent_timeout, 'number');
|
|
assert.strictEqual(c1.workflow.subagent_timeout, 900);
|
|
});
|
|
|
|
test('workflow documents numeric-input rejection for non-numeric answers', () => {
|
|
const workflow = fs.readFileSync(WORKFLOW_PATH, 'utf-8');
|
|
assert.match(
|
|
workflow,
|
|
/(non-numeric|must be a number|integer|numeric input|re-?prompt)/i,
|
|
'workflow must document how non-numeric input is handled for numeric fields'
|
|
);
|
|
});
|
|
|
|
// Behavioral coverage for numeric-key inputs at the config-set boundary.
|
|
// The /gsd-settings-advanced workflow promises non-numeric input is never
|
|
// silently coerced — that promise is enforced by the AskUserQuestion
|
|
// re-prompt loop in the workflow runner, not by config-set itself. The
|
|
// CLI parser passes numeric-looking strings through Number() and stores
|
|
// anything else verbatim. These tests lock in both behaviors so a future
|
|
// regression that changes either layer surfaces immediately.
|
|
test('config-set on a numeric key stores non-numeric input verbatim as string (workflow layer must reject before reaching here)', (t) => {
|
|
const tmpDir = createTempProject();
|
|
t.after(() => cleanup(tmpDir));
|
|
|
|
const configPath = path.join(tmpDir, '.planning', 'config.json');
|
|
fs.writeFileSync(configPath, '{}');
|
|
|
|
const result = runGsdTools(
|
|
['config-set', 'workflow.subagent_timeout', 'not-a-number'],
|
|
tmpDir,
|
|
{ HOME: tmpDir }
|
|
);
|
|
// The CLI layer accepts the write — type validation lives in the
|
|
// /gsd-settings-advanced workflow. If a future change adds a numeric
|
|
// type-check at config-set, flip this assertion to !result.success.
|
|
assert.ok(result.success, `config-set should accept the raw value at the CLI boundary: ${result.error || result.output}`);
|
|
const stored = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
|
|
assert.strictEqual(
|
|
typeof stored.workflow.subagent_timeout,
|
|
'string',
|
|
'non-numeric input on a numeric key currently lands as a string at the CLI boundary'
|
|
);
|
|
assert.strictEqual(stored.workflow.subagent_timeout, 'not-a-number');
|
|
});
|
|
|
|
test('config-set on a numeric key coerces a numeric string to Number (parser invariant)', (t) => {
|
|
const tmpDir = createTempProject();
|
|
t.after(() => cleanup(tmpDir));
|
|
|
|
const configPath = path.join(tmpDir, '.planning', 'config.json');
|
|
fs.writeFileSync(configPath, '{}');
|
|
|
|
const result = runGsdTools(
|
|
['config-set', 'workflow.max_discuss_passes', '7'],
|
|
tmpDir,
|
|
{ HOME: tmpDir }
|
|
);
|
|
assert.ok(result.success, `config-set failed: ${result.error || result.output}`);
|
|
const stored = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
|
|
assert.strictEqual(typeof stored.workflow.max_discuss_passes, 'number');
|
|
assert.strictEqual(stored.workflow.max_discuss_passes, 7);
|
|
});
|
|
});
|
|
|
|
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
// Folded from tests/bug-2506-settings-profile-nonclaude-warning.test.cjs — consolidation epic #1969 (B4 #1973)
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
{
|
|
const { describe: __foldDescribe } = require('node:test');
|
|
__foldDescribe("folded:bug-2506-settings-profile-nonclaude-warning (consolidation epic #1969 B4 #1973)", () => {
|
|
/**
|
|
* Regression test for bug #2506
|
|
*
|
|
* /gsd-settings presents Quality/Balanced/Budget model profiles without any
|
|
* warning that on non-Claude runtimes (Codex, Gemini CLI, etc.) these profiles
|
|
* select Claude model tiers and have no effect on actual agent model selection.
|
|
*
|
|
* Fix: settings.md must include a non-Claude runtime note instructing users to
|
|
* use "Inherit" or configure model_overrides manually, and the Inherit option
|
|
* description must explicitly call out non-Claude runtimes.
|
|
*
|
|
* Closes: #2506
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
const { describe, test, before } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
const SETTINGS_PATH = path.join(__dirname, '..', 'gsd-core', 'workflows', 'settings.md');
|
|
|
|
describe('bug #2506: settings.md non-Claude runtime warning for model profiles', () => {
|
|
let content;
|
|
|
|
before(() => {
|
|
content = fs.readFileSync(SETTINGS_PATH, 'utf-8');
|
|
});
|
|
|
|
test('settings.md contains a non-Claude runtime note for model profiles', () => {
|
|
assert.ok(
|
|
content.includes('non-Claude runtime') || content.includes('non-Claude runtimes'),
|
|
'settings.md must include a note about non-Claude runtimes and model profiles'
|
|
);
|
|
});
|
|
|
|
test('non-Claude note explains profiles are no-ops without model_overrides', () => {
|
|
assert.ok(
|
|
content.includes('model_overrides') || content.includes('no effect'),
|
|
'note must explain profiles have no effect on non-Claude runtimes without model_overrides'
|
|
);
|
|
});
|
|
|
|
test('Inherit option description explicitly mentions non-Claude runtimes', () => {
|
|
// The Inherit option in AskUserQuestion must call out non-Claude runtimes
|
|
const inheritOptionMatch = content.match(/label:\s*"Inherit"[^}]*description:\s*"([^"]+)"/s);
|
|
assert.ok(inheritOptionMatch, 'Inherit option with label/description must exist in settings.md');
|
|
const desc = inheritOptionMatch[1];
|
|
assert.ok(
|
|
desc.includes('non-Claude') || desc.includes('Codex') || desc.includes('Gemini'),
|
|
`Inherit option description must mention non-Claude runtimes; got: "${desc}"`
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
// Folded from tests/bug-3784-gsd-settings-model-profile-ui-omits-adaptive.test.cjs — consolidation epic #1969 (B4 #1973)
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
{
|
|
const { describe: __foldDescribe } = require('node:test');
|
|
__foldDescribe("folded:bug-3784-gsd-settings-model-profile-ui-omits-adaptive (consolidation epic #1969 B4 #1973)", () => {
|
|
'use strict';
|
|
|
|
// allow-test-rule: source-text-is-the-product (see #3784)
|
|
// The deployed settings.md IS the product — testing its text content tests the deployed contract.
|
|
|
|
/**
|
|
* Regression test for bug #3784
|
|
*
|
|
* /gsd-settings model profile UI omits `adaptive`. The AskUserQuestion block
|
|
* for model_profile in settings.md lists only four options (Quality, Balanced,
|
|
* Budget, Inherit) but the settings schema registers five valid profiles:
|
|
* quality, balanced, budget, adaptive, inherit. The `adaptive` profile is
|
|
* reachable by name via `gsd:config --profile adaptive` but cannot be selected
|
|
* interactively through `/gsd:settings`.
|
|
*
|
|
* Root cause: the options array in the model-profile AskUserQuestion block was
|
|
* written before the `adaptive` profile was introduced and was never updated.
|
|
* Because AskUserQuestion enforces a hard 4-option cap, the fix uses a two-
|
|
* question split: Q1 asks "Standard tier or Adaptive?" (2 options); if the
|
|
* user picks Standard, Q2 asks which of the three standard profiles to use
|
|
* (Quality, Balanced, Budget). This keeps every call within the 4-option cap
|
|
* while making all five profiles reachable.
|
|
*
|
|
* Fixes: #3784
|
|
*/
|
|
|
|
const { describe, test, before } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
const SETTINGS_PATH = path.join(__dirname, '..', 'gsd-core', 'workflows', 'settings.md');
|
|
|
|
/**
|
|
* Extract all AskUserQuestion option labels from a text block.
|
|
* Returns them lowercased for case-insensitive comparison.
|
|
*/
|
|
function extractOptionLabels(block) {
|
|
const labelPattern = /label:\s*"([^"]+)"/g;
|
|
const labels = [];
|
|
let match;
|
|
while ((match = labelPattern.exec(block)) !== null) {
|
|
labels.push(match[1].toLowerCase());
|
|
}
|
|
return labels;
|
|
}
|
|
|
|
describe('bug #3784: settings.md model profile UI exposes all 5 profiles', () => {
|
|
let content;
|
|
let presentBlock;
|
|
|
|
before(() => {
|
|
content = fs.readFileSync(SETTINGS_PATH, 'utf-8');
|
|
const presentMatch = content.match(/<step name="present_settings">[\s\S]*?<\/step>/);
|
|
assert.ok(presentMatch, 'settings.md must have a present_settings step');
|
|
presentBlock = presentMatch[0];
|
|
});
|
|
|
|
// ── Core contract: all five valid profiles reachable via the settings UI ──
|
|
|
|
test('present_settings step includes Adaptive as a selectable option (#3784)', () => {
|
|
// This is the primary assertion for bug #3784 — adaptive was missing.
|
|
const labels = extractOptionLabels(presentBlock);
|
|
assert.ok(
|
|
labels.some(l => l === 'adaptive' || l.startsWith('adaptive')),
|
|
[
|
|
'Bug #3784: present_settings step must include an "Adaptive" label in',
|
|
'its model profile AskUserQuestion options so users can select it',
|
|
`interactively. Got labels: [${labels.join(', ')}]`,
|
|
].join(' ')
|
|
);
|
|
});
|
|
|
|
test('present_settings step includes Quality as a selectable option', () => {
|
|
const labels = extractOptionLabels(presentBlock);
|
|
assert.ok(
|
|
labels.some(l => l === 'quality' || l.startsWith('quality')),
|
|
`present_settings step must include a "Quality" option. Got: [${labels.join(', ')}]`
|
|
);
|
|
});
|
|
|
|
test('present_settings step includes Balanced as a selectable option', () => {
|
|
const labels = extractOptionLabels(presentBlock);
|
|
assert.ok(
|
|
labels.some(l => l === 'balanced' || l.startsWith('balanced')),
|
|
`present_settings step must include a "Balanced" option. Got: [${labels.join(', ')}]`
|
|
);
|
|
});
|
|
|
|
test('present_settings step includes Budget as a selectable option', () => {
|
|
const labels = extractOptionLabels(presentBlock);
|
|
assert.ok(
|
|
labels.some(l => l === 'budget' || l.startsWith('budget')),
|
|
`present_settings step must include a "Budget" option. Got: [${labels.join(', ')}]`
|
|
);
|
|
});
|
|
|
|
test('present_settings step includes Inherit as a selectable option', () => {
|
|
const labels = extractOptionLabels(presentBlock);
|
|
assert.ok(
|
|
labels.some(l => l === 'inherit' || l.startsWith('inherit')),
|
|
`present_settings step must include an "Inherit" option. Got: [${labels.join(', ')}]`
|
|
);
|
|
});
|
|
|
|
// ── update_config step writes adaptive as a valid value ──
|
|
|
|
test('update_config step lists adaptive as a valid model_profile value', () => {
|
|
const updateMatch = content.match(/<step name="update_config">[\s\S]*?<\/step>/);
|
|
assert.ok(updateMatch, 'settings.md must have an update_config step');
|
|
const block = updateMatch[0];
|
|
assert.ok(
|
|
block.includes('adaptive'),
|
|
'update_config step must list "adaptive" as a valid model_profile value'
|
|
);
|
|
});
|
|
|
|
// ── confirm step displays adaptive as a possible profile value ──
|
|
|
|
test('confirm step table shows adaptive as a possible model profile value', () => {
|
|
const confirmMatch = content.match(/<step name="confirm">[\s\S]*?<\/step>/);
|
|
assert.ok(confirmMatch, 'settings.md must have a confirm step');
|
|
const block = confirmMatch[0];
|
|
assert.ok(
|
|
block.includes('adaptive'),
|
|
'confirm step must include "adaptive" in the Model Profile row placeholder'
|
|
);
|
|
});
|
|
|
|
// ── adaptive described with role-based routing semantics ──
|
|
|
|
test('settings.md describes adaptive profile with role-based routing semantics', () => {
|
|
// Adaptive uses heavy/light role tiers per routingTier.
|
|
// The UI description must convey role-based cost optimization and the heavy/light tier
|
|
// split — not just mention "Adaptive" somewhere (that word appears 6+ times in the file).
|
|
const lower = content.toLowerCase();
|
|
assert.ok(
|
|
lower.includes('role-based cost optimization') && lower.includes('heavy roles'),
|
|
'settings.md must describe the adaptive profile with "role-based cost optimization" and "heavy roles" wording so the description is meaningful across all supported runtimes'
|
|
);
|
|
});
|
|
|
|
// ── 4-option cap enforcement ──
|
|
|
|
test('each question object in present_settings AskUserQuestion blocks has at most 4 options (AskUserQuestion runtime cap)', () => {
|
|
// The AskUserQuestion runtime enforces a hard 4-option cap per individual question object
|
|
// (each { question:..., options:[...] } entry). This test guards against a naïve revert
|
|
// that puts all 5 profiles into a single question object instead of using the Q1/Q2 split.
|
|
const ASK_USER_QUESTION_OPTION_CAP = 4; // hard limit enforced by the AskUserQuestion runtime
|
|
|
|
// Extract each individual options array by finding 'options: [' and walking to the
|
|
// matching balanced ']', then count label: entries within that span.
|
|
const optionsKeyRe = /\boptions\s*:\s*\[/g;
|
|
let match;
|
|
let questionIndex = 0;
|
|
while ((match = optionsKeyRe.exec(presentBlock)) !== null) {
|
|
questionIndex++;
|
|
// Walk forward from the opening '[' to find the balanced close ']'.
|
|
let depth = 0;
|
|
const start = match.index + match[0].length - 1; // points at '['
|
|
let end = start;
|
|
for (let k = start; k < presentBlock.length; k++) {
|
|
if (presentBlock[k] === '[') { depth++; }
|
|
else if (presentBlock[k] === ']') {
|
|
depth--;
|
|
if (depth === 0) { end = k; break; }
|
|
}
|
|
}
|
|
const optionsBody = presentBlock.slice(start, end + 1);
|
|
const labelMatches = optionsBody.match(/label:\s*"[^"]+"/g) || [];
|
|
const optionCount = labelMatches.length;
|
|
assert.ok(
|
|
optionCount <= ASK_USER_QUESTION_OPTION_CAP,
|
|
`Question object ${questionIndex} in present_settings has ${optionCount} options — exceeds the runtime cap of ${ASK_USER_QUESTION_OPTION_CAP}. Split into multiple questions (as #3784 did for model_profile).`
|
|
);
|
|
}
|
|
// Sanity check: there must be at least one options array found.
|
|
assert.ok(questionIndex > 0, 'present_settings must contain at least one AskUserQuestion options array');
|
|
});
|
|
|
|
// ── Brace-balance regression (bd53925f fixed duplicate '{' from 35fc1d21) ──
|
|
|
|
test('present_settings step has balanced braces — regression: brace-balance after #3784 split', () => {
|
|
// commit bd53925f fixed a duplicate '{' introduced by 35fc1d21 when the model-profile
|
|
// AskUserQuestion was split into Q1+Q2. This test guards against a recurrence.
|
|
let depth = 0;
|
|
for (const ch of presentBlock) {
|
|
if (ch === '{') { depth++; }
|
|
if (ch === '}') { depth--; }
|
|
}
|
|
assert.strictEqual(
|
|
depth,
|
|
0,
|
|
`present_settings step has unbalanced braces: net depth after full scan is ${depth} (positive = extra '{', negative = extra '}'). Regression guard for bd53925f / #3784.`
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
// Folded from tests/bug-33-settings-model-profile-adaptive.test.cjs — consolidation epic #1969 (B8 #1977)
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
{
|
|
const { describe: __foldDescribe } = require('node:test');
|
|
__foldDescribe("folded:bug-33-settings-model-profile-adaptive (consolidation epic #1969 B8 #1977)", () => {
|
|
'use strict';
|
|
|
|
// allow-test-rule: source-text-is-the-product (see #33)
|
|
// The deployed settings.md IS the product — testing its text content tests the deployed contract.
|
|
|
|
/**
|
|
* Regression test for issue #33
|
|
*
|
|
* model_profile UI shows 4 options, schema has 5 — `adaptive` missing from
|
|
* `settings.md` AskUserQuestion.
|
|
*
|
|
* The schema (gsd-core/bin/shared/model-catalog.json `profiles` array) defines 5 valid
|
|
* model_profile values: quality, balanced, budget, adaptive, inherit. The
|
|
* settings.md AskUserQuestion block for model_profile originally listed only 4
|
|
* options (Quality, Balanced, Budget, Inherit) — `adaptive` was missing.
|
|
*
|
|
* Fix: the model_profile selection uses a two-question split. Q1 routes between
|
|
* Adaptive / Standard-tier / Inherit (3 options). Q2 (only when Q1 = Standard)
|
|
* asks Quality / Balanced / Budget. This keeps every individual options array
|
|
* within the AskUserQuestion 4-option cap while making all 5 profiles reachable.
|
|
*
|
|
* Fixes: #33
|
|
*/
|
|
|
|
const { describe, test, before } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
|
|
const REPO_ROOT = path.join(__dirname, '..');
|
|
const SETTINGS_PATH = path.join(REPO_ROOT, 'gsd-core', 'workflows', 'settings.md');
|
|
const CATALOG_PATH = path.join(REPO_ROOT, 'gsd-core', 'bin', 'shared', 'model-catalog.json');
|
|
|
|
/**
|
|
* Collect every label: "..." value within a text block, lowercased.
|
|
*/
|
|
function extractOptionLabels(block) {
|
|
const re = /label:\s*"([^"]+)"/g;
|
|
const labels = [];
|
|
let m;
|
|
while ((m = re.exec(block)) !== null) {
|
|
labels.push(m[1].toLowerCase());
|
|
}
|
|
return labels;
|
|
}
|
|
|
|
describe('issue #33: model_profile schema and settings.md UI are in sync', () => {
|
|
let catalog;
|
|
let settingsContent;
|
|
let presentBlock;
|
|
|
|
before(() => {
|
|
catalog = JSON.parse(fs.readFileSync(CATALOG_PATH, 'utf-8'));
|
|
settingsContent = fs.readFileSync(SETTINGS_PATH, 'utf-8');
|
|
const presentMatch = settingsContent.match(/<step name="present_settings">[\s\S]*?<\/step>/);
|
|
assert.ok(presentMatch, 'settings.md must contain a present_settings step');
|
|
presentBlock = presentMatch[0];
|
|
});
|
|
|
|
// -- (a) Schema contract ---------------------------------------------------
|
|
|
|
test('schema includes the adaptive model_profile value', () => {
|
|
assert.ok(
|
|
Array.isArray(catalog.profiles),
|
|
'model-catalog.json must have a "profiles" array'
|
|
);
|
|
assert.ok(
|
|
catalog.profiles.includes('adaptive'),
|
|
'model-catalog should include the adaptive profile. Got: [' + catalog.profiles.join(', ') + ']'
|
|
);
|
|
});
|
|
|
|
test('schema includes adaptive as a model_profile value', () => {
|
|
assert.ok(
|
|
catalog.profiles.includes('adaptive'),
|
|
'"adaptive" must be in model-catalog.json profiles. Got: [' + catalog.profiles.join(', ') + ']'
|
|
);
|
|
});
|
|
|
|
test('schema includes all expected model_profile values', () => {
|
|
const expected = ['quality', 'balanced', 'budget', 'adaptive', 'inherit'];
|
|
for (const profile of expected) {
|
|
assert.ok(
|
|
catalog.profiles.includes(profile),
|
|
'Schema must include "' + profile + '" in profiles. Got: [' + catalog.profiles.join(', ') + ']'
|
|
);
|
|
}
|
|
});
|
|
|
|
// -- (b) UI contract — all 5 profiles reachable via present_settings -------
|
|
|
|
test('present_settings includes Adaptive as a selectable option (#33)', () => {
|
|
const labels = extractOptionLabels(presentBlock);
|
|
assert.ok(
|
|
labels.some(l => l === 'adaptive' || l.startsWith('adaptive')),
|
|
'Issue #33: present_settings must include an "Adaptive" label in its model_profile AskUserQuestion options so users can select it interactively. Got labels: [' + labels.join(', ') + ']'
|
|
);
|
|
});
|
|
|
|
test('present_settings includes Quality as a selectable option', () => {
|
|
const labels = extractOptionLabels(presentBlock);
|
|
assert.ok(
|
|
labels.some(l => l === 'quality' || l.startsWith('quality')),
|
|
'present_settings must include a "Quality" option. Got: [' + labels.join(', ') + ']'
|
|
);
|
|
});
|
|
|
|
test('present_settings includes Balanced as a selectable option', () => {
|
|
const labels = extractOptionLabels(presentBlock);
|
|
assert.ok(
|
|
labels.some(l => l === 'balanced' || l.startsWith('balanced')),
|
|
'present_settings must include a "Balanced" option. Got: [' + labels.join(', ') + ']'
|
|
);
|
|
});
|
|
|
|
test('present_settings includes Budget as a selectable option', () => {
|
|
const labels = extractOptionLabels(presentBlock);
|
|
assert.ok(
|
|
labels.some(l => l === 'budget' || l.startsWith('budget')),
|
|
'present_settings must include a "Budget" option. Got: [' + labels.join(', ') + ']'
|
|
);
|
|
});
|
|
|
|
test('present_settings includes Inherit as a selectable option', () => {
|
|
const labels = extractOptionLabels(presentBlock);
|
|
assert.ok(
|
|
labels.some(l => l === 'inherit' || l.startsWith('inherit')),
|
|
'present_settings must include an "Inherit" option. Got: [' + labels.join(', ') + ']'
|
|
);
|
|
});
|
|
|
|
// -- update_config and confirm steps reference adaptive --------------------
|
|
|
|
test('update_config step lists adaptive as a valid model_profile value', () => {
|
|
const m = settingsContent.match(/<step name="update_config">[\s\S]*?<\/step>/);
|
|
assert.ok(m, 'settings.md must have an update_config step');
|
|
assert.ok(
|
|
m[0].includes('adaptive'),
|
|
'update_config step must list "adaptive" as a valid model_profile value'
|
|
);
|
|
});
|
|
|
|
test('confirm step table shows adaptive as a possible model profile value', () => {
|
|
const m = settingsContent.match(/<step name="confirm">[\s\S]*?<\/step>/);
|
|
assert.ok(m, 'settings.md must have a confirm step');
|
|
assert.ok(
|
|
m[0].includes('adaptive'),
|
|
'confirm step must include "adaptive" in the Model Profile row'
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
// ─── findDocumentedDefault: the proximity scan itself (#2753) ────────────────
|
|
//
|
|
// The generated `workflow documents default for ...` tests above instantiate this helper
|
|
// against the ONE real workflow, which documents every key — so they can only ever exercise
|
|
// the passing path. The negative cases that stop this from degrading into "the token appears
|
|
// somewhere in the file" are only reachable on synthetic documents, which is what these do.
|
|
|
|
describe('findDocumentedDefault', () => {
|
|
const KEY = 'response_language';
|
|
const DEF = 'null';
|
|
const pad = (n) => 'x'.repeat(n);
|
|
|
|
test('documents default on a single occurrence', () => {
|
|
const r = findDocumentedDefault(`| ${KEY} | ${DEF} | prose`, KEY, DEF);
|
|
assert.equal(r.ok, true);
|
|
assert.equal(r.occurrences, 1);
|
|
});
|
|
|
|
test('documents default when a LATER occurrence carries it (#2558 shape)', () => {
|
|
// Prose directive names the key first; the settings table documents it much later.
|
|
const doc = `Apply ${KEY} to all user-facing prose.\n${pad(2000)}\n| ${KEY} | ${DEF} |`;
|
|
const r = findDocumentedDefault(doc, KEY, DEF);
|
|
assert.equal(r.ok, true, 'a later occurrence must satisfy the contract');
|
|
assert.equal(r.occurrences, 2);
|
|
});
|
|
|
|
test('documents default when the FIRST occurrence carries it (no regression)', () => {
|
|
const doc = `| ${KEY} | ${DEF} |\n${pad(2000)}\nlater prose about ${KEY}.`;
|
|
const r = findDocumentedDefault(doc, KEY, DEF);
|
|
assert.equal(r.ok, true);
|
|
// The document contains the key twice, but the scan short-circuits on the first
|
|
// documenting window, so exactly one occurrence is EXAMINED. Asserting 2 here would be
|
|
// asserting the document's contents rather than the function's behavior.
|
|
assert.equal(r.occurrences, 1, 'must short-circuit rather than scan the whole document');
|
|
});
|
|
|
|
test('documents default on the LAST of many occurrences', () => {
|
|
const doc = [pad(500), KEY, pad(500), KEY, pad(500), KEY, pad(10), DEF].join('\n');
|
|
const r = findDocumentedDefault(doc, KEY, DEF);
|
|
assert.equal(r.ok, true);
|
|
assert.equal(r.occurrences, 3);
|
|
});
|
|
|
|
test('FAILS when no occurrence documents the default', () => {
|
|
// The load-bearing negative: scanning more occurrences must not turn a real miss into a pass.
|
|
const doc = [pad(500), KEY, pad(500), KEY, pad(500), KEY, pad(500)].join('\n');
|
|
const r = findDocumentedDefault(doc, KEY, DEF);
|
|
assert.equal(r.ok, false);
|
|
assert.equal(r.occurrences, 3, 'the count is what makes a genuine miss diagnosable');
|
|
});
|
|
|
|
test('reports zero occurrences when the key is absent', () => {
|
|
const r = findDocumentedDefault(`nothing relevant here ${DEF}`, KEY, DEF);
|
|
assert.equal(r.ok, false);
|
|
assert.equal(r.occurrences, 0);
|
|
assert.equal(r.window, '');
|
|
});
|
|
|
|
test('window boundary holds at limit-1 / limit / limit+1', () => {
|
|
// Offset measured from the start of the key, matching slice(idx, idx + windowSize).
|
|
const at = (gap) => `${KEY}${pad(gap)}${DEF}`;
|
|
const inside = DEFAULT_PROXIMITY_WINDOW - KEY.length - DEF.length - 1;
|
|
assert.equal(findDocumentedDefault(at(inside), KEY, DEF).ok, true, 'limit-1 must pass');
|
|
assert.equal(findDocumentedDefault(at(inside + 1), KEY, DEF).ok, true, 'limit must pass');
|
|
assert.equal(findDocumentedDefault(at(inside + 2), KEY, DEF).ok, false, 'limit+1 must fail');
|
|
});
|
|
|
|
test('fails cleanly on an empty document', () => {
|
|
const r = findDocumentedDefault('', KEY, DEF);
|
|
assert.deepEqual(r, { ok: false, occurrences: 0, window: '' });
|
|
});
|
|
|
|
test('terminates when the key overlaps itself', () => {
|
|
// Advance-by-one must not loop forever on a self-overlapping needle.
|
|
const r = findDocumentedDefault('aaaa', 'aa', 'zz');
|
|
assert.equal(r.ok, false);
|
|
assert.equal(r.occurrences, 3);
|
|
});
|
|
|
|
test('is newline-agnostic (CRLF reaches the same verdict as LF)', () => {
|
|
const lf = `prose ${KEY}\n${pad(2000)}\n| ${KEY} | ${DEF} |`;
|
|
const crlf = lf.replace(/\n/g, '\r\n');
|
|
// Asserting only that the two agree is vacuous — a stub returning a constant satisfies it.
|
|
// Pin the ABSOLUTE verdict on both, then that they agree.
|
|
assert.equal(findDocumentedDefault(lf, KEY, DEF).ok, true);
|
|
assert.equal(findDocumentedDefault(crlf, KEY, DEF).ok, true);
|
|
// And a document neither newline style can rescue must fail under both.
|
|
const missLf = [pad(500), KEY, pad(500), KEY, pad(500)].join('\n');
|
|
assert.equal(findDocumentedDefault(missLf, KEY, DEF).ok, false);
|
|
assert.equal(findDocumentedDefault(missLf.replace(/\n/g, '\r\n'), KEY, DEF).ok, false);
|
|
});
|
|
|
|
test('an empty key is refused rather than hanging the scan', () => {
|
|
// String#indexOf('', pos) clamps to str.length instead of returning -1, so an unguarded
|
|
// scan loops forever. Guarded above; this pins it. A timeout here means the guard is gone.
|
|
const r = findDocumentedDefault('some workflow text', '', DEF);
|
|
assert.deepEqual(r, { ok: false, occurrences: 0, window: '' });
|
|
assert.deepEqual(
|
|
findDocumentedDefault('', '', ''),
|
|
{ ok: false, occurrences: 0, window: '' }
|
|
);
|
|
});
|
|
|
|
test('property: verdict is exactly "default fits inside the window from the key"', () => {
|
|
// windowSize is a budget limit, so it carries a property test (CLAUDE.md TEST RULES).
|
|
// Disjoint alphabets keep key/default/filler from colliding, so the expected verdict is
|
|
// pure arithmetic: the window starts AT the key and spans windowSize chars.
|
|
fc.assert(
|
|
fc.property(
|
|
fc.stringMatching(/^[a-f]{1,12}$/),
|
|
fc.stringMatching(/^[m-r]{1,8}$/),
|
|
fc.integer({ min: 0, max: 600 }),
|
|
fc.integer({ min: 20, max: 400 }),
|
|
(key, def, gap, windowSize) => {
|
|
const doc = `${key}${'z'.repeat(gap)}${def}`;
|
|
const expected = key.length + gap + def.length <= windowSize;
|
|
const r = findDocumentedDefault(doc, key, def, windowSize);
|
|
assert.equal(r.ok, expected);
|
|
assert.ok(r.occurrences >= 1, 'the key is present by construction');
|
|
return true;
|
|
}
|
|
),
|
|
{ numRuns: 300, seed: 2753 }
|
|
);
|
|
});
|
|
});
|