mirror of
https://github.com/router-for-me/Cli-Proxy-API-Management-Center.git
synced 2026-11-22 16:37:49 +08:00
372 lines
14 KiB
TypeScript
372 lines
14 KiB
TypeScript
import { describe, expect, test } from 'bun:test';
|
|
import { createElement, useState } from 'react';
|
|
import { renderToStaticMarkup } from 'react-dom/server';
|
|
import { parse, stringify } from 'yaml';
|
|
import { useVisualConfig } from '../src/hooks/useVisualConfig';
|
|
import {
|
|
buildConfigPatch,
|
|
ConfigDraftConflictError,
|
|
rebaseConfigDraft,
|
|
} from '../src/services/api/configPatch';
|
|
|
|
type Visual = ReturnType<typeof useVisualConfig>;
|
|
|
|
// Render-phase updates exercise the actual hook/reducer without mocking React.
|
|
function runSteps(...steps: ((visual: Visual) => void)[]) {
|
|
function Harness() {
|
|
const visual = useVisualConfig();
|
|
const [step, setStep] = useState(0);
|
|
steps[step](visual);
|
|
if (step + 1 < steps.length) setStep(step + 1);
|
|
return null;
|
|
}
|
|
renderToStaticMarkup(createElement(Harness));
|
|
}
|
|
|
|
const before = 'server: {port: 8317}\nrouting: {retry: {request-retry: 3}}\n';
|
|
const server = 'server: {port: 9000}\nrouting: {retry: {request-retry: 3}}\n';
|
|
|
|
describe('visual config rebase', () => {
|
|
test('advances baseline after partial save, retains deletions and concurrent unedited values', () => {
|
|
let draft = '';
|
|
const latest = `${server}observability: {logs: {debug: true}}\n`;
|
|
runSteps(
|
|
(v) => {
|
|
v.loadVisualValuesFromYaml(before);
|
|
},
|
|
(v) => {
|
|
v.setVisualValues({ port: '9000', requestRetry: '' });
|
|
},
|
|
(v) => {
|
|
draft = v.applyVisualChangesToYaml(latest);
|
|
expect(v.rebaseVisualValuesFromYaml(latest, draft)).toEqual({ ok: true });
|
|
},
|
|
(v) => {
|
|
expect([...v.visualDirtyFields]).toEqual(['requestRetry']);
|
|
expect(v.visualValues.debug).toBe(true);
|
|
expect(buildConfigPatch(latest, v.applyVisualChangesToYaml(latest))).toEqual({
|
|
patch: {},
|
|
deletions: [['routing', 'retry', 'request-retry']],
|
|
});
|
|
v.setVisualValues({ port: '8317' });
|
|
},
|
|
(v) => {
|
|
expect(v.visualDirtyFields.has('port')).toBe(true);
|
|
expect(buildConfigPatch(latest, v.applyVisualChangesToYaml(latest)).patch).toEqual({
|
|
server: { port: 8317 },
|
|
});
|
|
v.loadVisualValuesFromYaml(latest);
|
|
},
|
|
(v) => {
|
|
expect(v.visualDirty).toBe(false);
|
|
expect(v.visualValues.port).toBe('9000');
|
|
expect(v.visualValues.requestRetry).toBe('3');
|
|
}
|
|
);
|
|
});
|
|
|
|
const rule = (name: string, value: number) => ({
|
|
models: [
|
|
{ name, 'future-model': name, match: [{ count: value }], headers: { 'X-Test': name } },
|
|
],
|
|
params: { temperature: value },
|
|
'future-rule': name,
|
|
});
|
|
|
|
for (const section of ['default', 'default-raw', 'override', 'override-raw', 'filter']) {
|
|
test(`${section}: deletion, modification, reorder and append retain the draft AST on retry`, () => {
|
|
const rules = [rule('a', 1), rule('b', 2), rule('c', 3)];
|
|
const desired = [rule('c', 9), rule('b-renamed', 2), rule('new', 4)];
|
|
if (section.endsWith('-raw')) {
|
|
for (const entry of [...rules, ...desired]) {
|
|
Object.assign(entry, { params: { temperature: String(entry.params.temperature) } });
|
|
}
|
|
}
|
|
if (section === 'filter') {
|
|
for (const entry of [...rules, ...desired]) {
|
|
Object.assign(entry, { params: ['secret'] });
|
|
}
|
|
}
|
|
const saved = stringify({
|
|
requests: { payload: { [section]: rules } },
|
|
server: { port: 9000 },
|
|
});
|
|
const draft = stringify({
|
|
requests: { payload: { [section]: desired } },
|
|
server: { port: 9000 },
|
|
});
|
|
runSteps(
|
|
(v) => {
|
|
v.loadVisualValuesFromYaml(saved);
|
|
},
|
|
(v) => {
|
|
v.rebaseVisualValuesFromYaml(saved, draft);
|
|
},
|
|
(v) => {
|
|
expect(v.visualDirtyFields.size).toBe(1);
|
|
const retry = v.applyVisualChangesToYaml(saved);
|
|
expect(parse(retry)).toEqual(parse(draft));
|
|
expect(v.applyVisualChangesToYaml(saved)).toBe(retry);
|
|
v.rebaseVisualValuesFromYaml(retry, retry);
|
|
},
|
|
(v) => {
|
|
expect(v.visualDirty).toBe(false);
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
for (const [section, field] of [
|
|
['default', 'payloadDefaultRules'],
|
|
['default-raw', 'payloadDefaultRawRules'],
|
|
['override', 'payloadOverrideRules'],
|
|
['override-raw', 'payloadOverrideRawRules'],
|
|
['filter', 'payloadFilterRules'],
|
|
] as const) {
|
|
test(`${section}: recovery does not replay old list indexes after a successful PATCH`, () => {
|
|
const rules = [rule('a', 1), rule('b', 2), rule('c', 3)].map((entry) => ({
|
|
...entry,
|
|
params:
|
|
section === 'filter'
|
|
? ['secret']
|
|
: {
|
|
temperature: section.endsWith('-raw')
|
|
? String(entry.params.temperature)
|
|
: entry.params.temperature,
|
|
},
|
|
}));
|
|
const original = stringify({
|
|
requests: { payload: { [section]: rules } },
|
|
routing: { retry: { 'request-retry': 3 } },
|
|
});
|
|
let confirmed = '';
|
|
let readback = '';
|
|
runSteps(
|
|
(v) => {
|
|
v.loadVisualValuesFromYaml(original);
|
|
},
|
|
(v) => {
|
|
// Delete A and reorder the survivors. Their original indexes no longer exist.
|
|
const entries = v.visualValues[field];
|
|
v.setVisualValues({ [field]: [entries[2], entries[1]], requestRetry: '' });
|
|
},
|
|
(v) => {
|
|
confirmed = v.applyVisualChangesToYaml(original);
|
|
const saved = parse(confirmed);
|
|
// PATCH applied, DELETE failed; another client also changed an unrelated value.
|
|
saved.routing = { retry: { 'request-retry': 3 } };
|
|
saved.observability = { logs: { debug: true } };
|
|
readback = stringify(saved);
|
|
const recovered = rebaseConfigDraft(original, confirmed, readback);
|
|
expect(parse(recovered).requests.payload[section]).toEqual([rules[2], rules[1]]);
|
|
expect(v.rebaseVisualValuesFromYaml(readback, recovered)).toEqual({ ok: true });
|
|
},
|
|
(v) => {
|
|
expect([...v.visualDirtyFields]).toEqual(['requestRetry']);
|
|
expect(v.visualValues.debug).toBe(true);
|
|
expect(buildConfigPatch(readback, v.applyVisualChangesToYaml(readback))).toEqual({
|
|
patch: {},
|
|
deletions: [['routing', 'retry', 'request-retry']],
|
|
});
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
test('recovery retains unapplied list intent and adopts concurrent unrelated fields', () => {
|
|
const original = stringify({
|
|
requests: { payload: { default: [rule('a', 1), rule('b', 2)] } },
|
|
});
|
|
let confirmed = '';
|
|
const readback = `${original}server: {port: 9000}\n`;
|
|
runSteps(
|
|
(v) => {
|
|
v.loadVisualValuesFromYaml(original);
|
|
},
|
|
(v) => {
|
|
v.setVisualValues({ payloadDefaultRules: [v.visualValues.payloadDefaultRules[1]] });
|
|
},
|
|
(v) => {
|
|
confirmed = v.applyVisualChangesToYaml(original);
|
|
const recovered = rebaseConfigDraft(original, confirmed, readback);
|
|
expect(parse(recovered).requests.payload.default).toEqual([rule('b', 2)]);
|
|
v.rebaseVisualValuesFromYaml(readback, recovered);
|
|
},
|
|
(v) => {
|
|
expect(v.visualValues.port).toBe('9000');
|
|
expect([...v.visualDirtyFields]).toEqual(['payloadDefaultRules']);
|
|
expect(parse(v.applyVisualChangesToYaml(readback)).requests.payload.default).toEqual([
|
|
rule('b', 2),
|
|
]);
|
|
}
|
|
);
|
|
});
|
|
|
|
for (const section of ['default', 'default-raw', 'override', 'override-raw', 'filter']) {
|
|
test(`${section}: a retry blocks concurrent list changes instead of replacing the snapshot`, () => {
|
|
const entry = (value: number) => ({
|
|
...rule('b', 1),
|
|
params:
|
|
section === 'filter'
|
|
? [value === 1 ? 'secret' : 'other-secret']
|
|
: { temperature: section.endsWith('-raw') ? String(value) : value },
|
|
});
|
|
const saved = stringify({ requests: { payload: { [section]: [entry(1)] } } });
|
|
const draft = stringify({ requests: { payload: { [section]: [entry(2)] } } });
|
|
const concurrent = entry(1);
|
|
concurrent.models[0].match = [{ count: 99 }];
|
|
const latest = stringify({ requests: { payload: { [section]: [concurrent] } } });
|
|
runSteps(
|
|
(v) => {
|
|
v.rebaseVisualValuesFromYaml(saved, draft);
|
|
},
|
|
(v) => {
|
|
expect(() => v.applyVisualChangesToYaml(latest)).toThrow(ConfigDraftConflictError);
|
|
// Repeated previews/confirmations cannot silently accept the stale snapshot.
|
|
expect(() => v.applyVisualChangesToYaml(latest)).toThrow(ConfigDraftConflictError);
|
|
expect(v.visualDirty).toBe(true);
|
|
expect(parse(v.applyVisualChangesToYaml(saved))).toEqual(parse(draft));
|
|
// A lost response from an already-applied write is not a conflict.
|
|
expect(parse(v.applyVisualChangesToYaml(draft))).toEqual(parse(draft));
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
test('retry adopts concurrent unrelated lists, but detects unknown fields and list deletion', () => {
|
|
const saved = stringify({ requests: { payload: { default: [rule('a', 1)] } } });
|
|
const draft = stringify({ requests: { payload: { default: [rule('a', 2)] } } });
|
|
const unrelated = `${saved}access: {api-keys: [fixture-only]}\n`;
|
|
const changed = parse(saved);
|
|
changed.requests.payload.default[0]['future-rule'] = 'concurrent';
|
|
runSteps(
|
|
(v) => {
|
|
v.rebaseVisualValuesFromYaml(saved, draft);
|
|
},
|
|
(v) => {
|
|
expect(parse(v.applyVisualChangesToYaml(unrelated)).access).toEqual({
|
|
'api-keys': ['fixture-only'],
|
|
});
|
|
expect(() => v.applyVisualChangesToYaml(stringify(changed))).toThrow(
|
|
ConfigDraftConflictError
|
|
);
|
|
expect(() => v.applyVisualChangesToYaml('server: {}')).toThrow(ConfigDraftConflictError);
|
|
}
|
|
);
|
|
});
|
|
|
|
test('local source previews are not treated as concurrent server snapshots', () => {
|
|
const saved = stringify({ requests: { payload: { default: [rule('a', 1)] } } });
|
|
const draft = stringify({ requests: { payload: { default: [rule('a', 2)] } } });
|
|
let sourcePreview = '';
|
|
runSteps(
|
|
(v) => {
|
|
v.rebaseVisualValuesFromYaml(saved, draft);
|
|
},
|
|
(v) => {
|
|
sourcePreview = v.applyVisualChangesToYaml(saved, 'draft');
|
|
const entry = v.visualValues.payloadDefaultRules[0];
|
|
v.setVisualValues({
|
|
payloadDefaultRules: [
|
|
{ ...entry, params: entry.params.map((param) => ({ ...param, value: '3' })) },
|
|
],
|
|
});
|
|
},
|
|
(v) => {
|
|
const nextPreview = v.applyVisualChangesToYaml(sourcePreview, 'draft');
|
|
expect(parse(nextPreview).requests.payload.default[0].params.temperature).toBe(3);
|
|
expect(parse(v.applyVisualChangesToYaml(saved))).toEqual(parse(nextPreview));
|
|
// The same document from a real server must still trigger a conflict.
|
|
expect(() => v.applyVisualChangesToYaml(sourcePreview)).toThrow(ConfigDraftConflictError);
|
|
}
|
|
);
|
|
});
|
|
|
|
test('subsequent nested edits use the rebased draft IDs, not old positional nodes', () => {
|
|
const saved = stringify({ requests: { payload: { default: [rule('a', 1), rule('b', 2)] } } });
|
|
const draft = stringify({ requests: { payload: { default: [rule('b', 8)] } } });
|
|
runSteps(
|
|
(v) => {
|
|
v.rebaseVisualValuesFromYaml(saved, draft);
|
|
},
|
|
(v) => {
|
|
const entry = v.visualValues.payloadDefaultRules[0];
|
|
v.setVisualValues({
|
|
payloadDefaultRules: [
|
|
{
|
|
...entry,
|
|
models: [{ ...entry.models[0], name: 'renamed' }],
|
|
params: entry.params.map((param) => ({ ...param, value: '10' })),
|
|
},
|
|
],
|
|
});
|
|
},
|
|
(v) => {
|
|
const rules = parse(v.applyVisualChangesToYaml(saved)).requests.payload.default;
|
|
expect(rules).toHaveLength(1);
|
|
expect(rules[0]['future-rule']).toBe('b');
|
|
expect(rules[0].models[0]['future-model']).toBe('b');
|
|
expect(rules[0].models[0].name).toBe('renamed');
|
|
expect(rules[0].params.temperature).toBe(10);
|
|
v.loadVisualValuesFromYaml(saved);
|
|
},
|
|
(v) => {
|
|
const entries = v.visualValues.payloadDefaultRules;
|
|
v.setVisualValues({ payloadDefaultRules: [entries[0]] });
|
|
},
|
|
(v) => {
|
|
expect(parse(v.applyVisualChangesToYaml(saved)).requests.payload.default).toEqual([
|
|
rule('a', 1),
|
|
]);
|
|
}
|
|
);
|
|
});
|
|
|
|
test('equal rules and plugin auth do not acquire spurious dirty IDs', () => {
|
|
const yaml = stringify({
|
|
requests: { payload: { default: [rule('a', 1), rule('b', 2)] } },
|
|
plugins: {
|
|
'store-auth': [{ match: 'example.test', type: 'bearer', 'token-env': 'TEST_TOKEN' }],
|
|
},
|
|
});
|
|
runSteps(
|
|
(v) => {
|
|
v.loadVisualValuesFromYaml(before);
|
|
},
|
|
(v) => {
|
|
v.rebaseVisualValuesFromYaml(yaml, yaml);
|
|
},
|
|
(v) => {
|
|
expect(v.visualDirty).toBe(false);
|
|
v.setVisualValues({ payloadDefaultRules: [...v.visualValues.payloadDefaultRules] });
|
|
},
|
|
(v) => {
|
|
expect(v.visualDirty).toBe(false);
|
|
}
|
|
);
|
|
});
|
|
|
|
test('failed parse does not partially replace values or baseline', () => {
|
|
runSteps(
|
|
(v) => {
|
|
v.loadVisualValuesFromYaml(before);
|
|
},
|
|
(v) => {
|
|
v.setVisualValues({ port: '9000' });
|
|
},
|
|
(v) => {
|
|
expect(v.rebaseVisualValuesFromYaml(server, 'bad: [')).toMatchObject({ ok: false });
|
|
},
|
|
(v) => {
|
|
expect(v.visualValues.port).toBe('9000');
|
|
expect(v.visualDirty).toBe(true);
|
|
expect(v.visualParseError).toBeNull();
|
|
v.setVisualValues({ port: '8317' });
|
|
},
|
|
(v) => {
|
|
expect(v.visualDirty).toBe(false);
|
|
}
|
|
);
|
|
});
|
|
});
|