Jaymr/zszq-trs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(swaptrade): 债券三字段计算器交互改为回车触发并加源/AUTO/REV 三态标识

Browse Source 
- 约定1：仅在净价/全价/收益率输入框敲回车触发计算器，失焦不触发
- 约定2：计算成功->源字段标"源"、另两字段标"AUTO"；失败->保留源值、清空另两字段与标识
- 约定3：编辑某字段未回车->不联动另两字段，清源/AUTO、仅本字段标"REV"
- swapCalc.js 新增 applyBondCalcSuccess/Failure/ManualEdit 纯函数，applyBondCalcResult 第三参由 manualSet 改为 driver（跳过源字段写回）
- fastVue.base.js 新增 enter 事件区分回车/失焦，向后兼容旧的 input 行为
- TradeEdit.cshtml 三字段 input/enter 分离绑定 + 源/AUTO/REV 三态标签（去除旧铅笔图标）
- 重写 bondCalc.test.js / 更新 swapCalc.test.js 覆盖状态机；jest 68 项全过
This commit is contained in:
hjhan
2026-07-29 14:34:25 +08:00
parent 8c4f452482
commit b9f2bd14f6
6 changed files with 271 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files
YLErpWeb/fe-tests/bondCalc.test.js
+101 -87
View File
@@ -1,126 +1,94 @@
/**
* bondCalc.test.js — 债券净价/全价/收益率三字段互算的"逐字段手动锁定"守卫
* bondCalc.test.js — 债券净价/全价/收益率三字段互算（driver 源 + 交互约定2/3 状态机）
* ============================================================================
* 核心保证（用户最担心的，也是第一天讨论的诉求）：
* 用户手填过的字段 = 被锁定，回写时**绝不**覆盖它；
* 只有"未手填"的字段才从源反算得出、被回写；计算器未返回的值也不覆盖。
* 因此用户可逐个手填全部三个，互算绝不会冲掉其中任何一个。
* 模型（交互约定1/2/3）：
* - driver(bondDriverType)：回车的"源"字段（CP净价 / DP全价 / YD收益率），恒为最后回车者。
* - bondAuto：计算器算出的另两个字段（"AUTO"）。
* - bondRev：编辑未回车的人工输入字段（"REV"）。
* - applyBondCalcResult(state, calc, driver)：回写时跳过 driver 源字段（保留用户手输值），
* 另两字段用计算器结果覆盖——即"回车某字段即以它为源反算另两个"。
*
* 运行：cd YLErpWeb/fe-tests && npm i && npm test
* 纯逻辑在 swapCalc.js::applyBondCalcResult（UMD，node 可直接 require）。
* 纯逻辑在 swapCalc.js（UMD，node 可直接 require）。
*/
const SwapCalc = require('../wwwroot/Scripts/app/swaptrade/swapCalc.js');
const CALC = { cleanPrice: 99, dirtyPrice: 100, ytm: 2.5 };
describe('逐字段手动锁定：手填过的字段永不回写', () => {
test('仅手填净价(CP)：净价保持，全价/收益率被反算覆盖', () => {
const state = { cleanPrice: 99.5, dirtyPrice: null, ytm: null }; // 用户手填净价 99.5
SwapCalc.applyBondCalcResult(state, CALC, { CP: true, DP: false, YD: false });
expect(state.cleanPrice).toBe(99.5); // 手填：绝不回写
expect(state.dirtyPrice).toBe(100); // 未手填：被反算覆盖
describe('以 driver 为源：回写时源字段保持、另两字段被反算覆盖', () => {
test('回车净价(CP)为源：净价保持，全价/收益率被反算覆盖', () => {
const state = { cleanPrice: 99.5, dirtyPrice: null, ytm: null };
SwapCalc.applyBondCalcResult(state, CALC, 'CP');
expect(state.cleanPrice).toBe(99.5); // 源：保持
expect(state.dirtyPrice).toBe(100); // 非源：被反算覆盖
expect(state.ytm).toBe(2.5);
});
test('手填净价+全价(CP&DP)：两者保持，仅收益率被覆盖', () => {
const state = { cleanPrice: 99.5, dirtyPrice: 100.5, ytm: null };
SwapCalc.applyBondCalcResult(state, CALC, { CP: true, DP: true, YD: false });
expect(state.cleanPrice).toBe(99.5); // 手填：保持
expect(state.dirtyPrice).toBe(100.5); // 手填：保持
expect(state.ytm).toBe(2.5); // 未手填：被反算覆盖
test('回车全价(DP)为源：全价保持，净价/收益率被反算覆盖', () => {
const state = { cleanPrice: null, dirtyPrice: 100.5, ytm: null };
SwapCalc.applyBondCalcResult(state, CALC, 'DP');
expect(state.dirtyPrice).toBe(100.5); // 源：保持
expect(state.cleanPrice).toBe(99);
expect(state.ytm).toBe(2.5);
});
test('用户不认可计算结果、手填全部三个：全部保留，无一被回写（核心场景）', () => {
const state = { cleanPrice: 98, dirtyPrice: 101, ytm: 3.0 }; // 用户全手填
SwapCalc.applyBondCalcResult(state, CALC, { CP: true, DP: true, YD: true });
expect(state.cleanPrice).toBe(98); // 全部手填 → 全部保留
expect(state.dirtyPrice).toBe(101);
expect(state.ytm).toBe(3.0);
});
test('手填收益率(YD)：收益率保持，净价/全价被覆盖', () => {
test('回车收益率(YD)为源：收益率保持，净价/全价被反算覆盖', () => {
const state = { cleanPrice: null, dirtyPrice: null, ytm: 2.6 };
SwapCalc.applyBondCalcResult(state, CALC, { CP: false, DP: false, YD: true });
expect(state.ytm).toBe(2.6);
SwapCalc.applyBondCalcResult(state, CALC, 'YD');
expect(state.ytm).toBe(2.6); // 源：保持
expect(state.cleanPrice).toBe(99);
expect(state.dirtyPrice).toBe(100);
});
test('仅手填全价(DP)：全价保持，净价/收益率被反算覆盖（最常用场景）', () => {
const state = { cleanPrice: null, dirtyPrice: 100.5, ytm: null }; // 用户手填全价 100.5
SwapCalc.applyBondCalcResult(state, CALC, { CP: false, DP: true, YD: false });
expect(state.dirtyPrice).toBe(100.5); // 手填：绝不回写
expect(state.cleanPrice).toBe(99); // 未手填：被反算覆盖
expect(state.ytm).toBe(2.5);
});
test('手填净价+收益率(CP&YD)：两者保持，仅全价被覆盖', () => {
const state = { cleanPrice: 98.5, dirtyPrice: null, ytm: 3.2 };
SwapCalc.applyBondCalcResult(state, CALC, { CP: true, DP: false, YD: true });
expect(state.cleanPrice).toBe(98.5); // 手填：保持
expect(state.ytm).toBe(3.2); // 手填：保持
expect(state.dirtyPrice).toBe(100); // 未手填：被反算覆盖
});
test('手填全价+收益率(DP&YD)：两者保持，仅净价被覆盖', () => {
const state = { cleanPrice: null, dirtyPrice: 101, ytm: 2.8 };
SwapCalc.applyBondCalcResult(state, CALC, { CP: false, DP: true, YD: true });
expect(state.dirtyPrice).toBe(101); // 手填：保持
expect(state.ytm).toBe(2.8); // 手填：保持
expect(state.cleanPrice).toBe(99); // 未手填：被反算覆盖
});
});
describe('边界：计算器未返回的值不覆盖、无变化不写', () => {
test('手填净价 且 计算器未返收益率：源与缺失值均不写', () => {
test('回车净价(源) 且 计算器未返收益率：源与缺失值均不写', () => {
const state = { cleanPrice: null, dirtyPrice: null, ytm: 2.6 };
const partial = { cleanPrice: 99, dirtyPrice: 100, ytm: undefined };
SwapCalc.applyBondCalcResult(state, partial, { CP: true, DP: false, YD: false });
expect(state.cleanPrice).toBe(null); // CP 手填：即便 calc 返 99 也不写
expect(state.dirtyPrice).toBe(100); // 未手填：被覆盖
expect(state.ytm).toBe(2.6); // 计算器没返收益率 → 保持用户值
SwapCalc.applyBondCalcResult(state, partial, 'CP');
expect(state.cleanPrice).toBe(null); // CP 源：即便 calc 返 99 也不写
expect(state.dirtyPrice).toBe(100); // 非源：被覆盖
expect(state.ytm).toBe(2.6); // 计算器没返收益率 → 保持用户值
});
test('派生值与当前值差异<EPS：不写（避免光标跳动）', () => {
const state = { cleanPrice: 99.5, dirtyPrice: 100.0, ytm: 2.5 };
const near = { cleanPrice: 99.5, dirtyPrice: 100.00001, ytm: 2.5 };
SwapCalc.applyBondCalcResult(state, near, { CP: true, DP: false, YD: false });
expect(state.cleanPrice).toBe(99.5); // 手填：不写
expect(state.dirtyPrice).toBe(100.0); // 差异 1e-5 < EPS → 不写
SwapCalc.applyBondCalcResult(state, near, 'CP');
expect(state.cleanPrice).toBe(99.5); // 源：不写
expect(state.dirtyPrice).toBe(100.0); // 差异 1e-5 < EPS → 不写
expect(state.ytm).toBe(2.5);
});
// 模拟 calcBondForItem：proxy 统一用【展示态】，模型字段是【存储态】，回写时 bondCalcPriceToStorage。
test('浮动腿 item 写回：仅未手填字段被覆盖，且存储态转换正确', () => {
test('浮动腿 item 写回：仅非源字段被覆盖，且存储态转换正确', () => {
// 用户输入净价 99.5 → vue-number-input(percent:true) 存为存储态 0.995
const item = { PosiNetNoFeePrice: 0.995, PosiGrossPrice: 1.0, InitYtm: 0.026,
bondDriverType: 'CP', bondManual: { CP: true, DP: false, YD: false } };
const item = { PosiNetNoFeePrice: 0.995, PosiGrossPrice: 1.0, InitYtm: 0.026, bondDriverType: 'CP' };
const calc = { cleanPrice: 99, dirtyPrice: 100, ytm: 2.5 }; // 计算器返回展示态
const proxy = {
cleanPrice: SwapCalc.bondPriceToCalc(item.PosiNetNoFeePrice), // 0.995 → 99.5（手填）
cleanPrice: SwapCalc.bondPriceToCalc(item.PosiNetNoFeePrice), // 0.995 → 99.5（源）
dirtyPrice: SwapCalc.bondPriceToCalc(item.PosiGrossPrice), // 1.0 → 100
ytm: SwapCalc.bondPriceToCalc(item.InitYtm) // 0.026 → 2.6
};
SwapCalc.applyBondCalcResult(proxy, calc, item.bondManual);
SwapCalc.applyBondCalcResult(proxy, calc, 'CP');
item.PosiNetNoFeePrice = SwapCalc.bondCalcPriceToStorage(proxy.cleanPrice);
item.PosiGrossPrice = SwapCalc.bondCalcPriceToStorage(proxy.dirtyPrice);
item.InitYtm = SwapCalc.bondCalcPriceToStorage(proxy.ytm);
expect(item.PosiNetNoFeePrice).toBe(0.995); // 手填(净价)：存储态保持 0.995（界面仍显示 99.5）
expect(item.PosiNetNoFeePrice).toBe(0.995); // 源(净价)：存储态保持 0.995（界面仍显示 99.5）
expect(item.PosiGrossPrice).toBe(1.0); // 全价：被反算覆盖，存储态 100/100=1.0
expect(item.InitYtm).toBe(0.025); // 收益率：被反算覆盖，存储态 2.5/100=0.025
});
// 核心回归：用户输入净价 100（存储态 1.0）时，绝不能因 proxy 残留存储态而再 ÷100 变成 0.01
test('核心回归：输入净价 100 不会被二次缩小为 1（存储态 0.01）', () => {
const item = { PosiNetNoFeePrice: 1.0, PosiGrossPrice: null, InitYtm: null,
bondDriverType: 'CP', bondManual: { CP: true, DP: false, YD: false } };
const item = { PosiNetNoFeePrice: 1.0, PosiGrossPrice: null, InitYtm: null, bondDriverType: 'CP' };
const calc = { cleanPrice: 100, dirtyPrice: 102.17928767123287, ytm: 4.860445236 };
const proxy = {
cleanPrice: SwapCalc.bondPriceToCalc(item.PosiNetNoFeePrice), // 1.0 → 100
dirtyPrice: SwapCalc.bondPriceToCalc(item.PosiGrossPrice),
ytm: SwapCalc.bondPriceToCalc(item.InitYtm)
};
SwapCalc.applyBondCalcResult(proxy, calc, item.bondManual);
SwapCalc.applyBondCalcResult(proxy, calc, 'CP');
item.PosiNetNoFeePrice = SwapCalc.bondCalcPriceToStorage(proxy.cleanPrice);
item.PosiGrossPrice = SwapCalc.bondCalcPriceToStorage(proxy.dirtyPrice);
item.InitYtm = SwapCalc.bondCalcPriceToStorage(proxy.ytm);
@@ -135,15 +103,14 @@ describe('边界：计算器未返回的值不覆盖、无变化不写', () => {
[105, 107.3, 4.567890],
[100, 102.17928767123287, 4.860445236]
])('多轮净价校验：输入净价 %s 时，存储态保持 %s/100 且不会被二次缩小', (inputClean, calcDirty, calcYtm) => {
const item = { PosiNetNoFeePrice: inputClean / 100, PosiGrossPrice: null, InitYtm: null,
bondDriverType: 'CP', bondManual: { CP: true, DP: false, YD: false } };
const item = { PosiNetNoFeePrice: inputClean / 100, PosiGrossPrice: null, InitYtm: null, bondDriverType: 'CP' };
const calc = { cleanPrice: inputClean, dirtyPrice: calcDirty, ytm: calcYtm };
const proxy = {
cleanPrice: SwapCalc.bondPriceToCalc(item.PosiNetNoFeePrice),
dirtyPrice: SwapCalc.bondPriceToCalc(item.PosiGrossPrice),
ytm: SwapCalc.bondPriceToCalc(item.InitYtm)
};
SwapCalc.applyBondCalcResult(proxy, calc, item.bondManual);
SwapCalc.applyBondCalcResult(proxy, calc, 'CP');
item.PosiNetNoFeePrice = SwapCalc.bondCalcPriceToStorage(proxy.cleanPrice);
item.PosiGrossPrice = SwapCalc.bondCalcPriceToStorage(proxy.dirtyPrice);
item.InitYtm = SwapCalc.bondCalcPriceToStorage(proxy.ytm);
@@ -212,22 +179,69 @@ describe('错误反馈：getBondCalcErrorMessage（对齐 C# BondCalcHepler 的
expect(SwapCalc.getBondCalcErrorMessage(resp)).toBeNull();
});
test('端到端：业务错误时不覆盖手工输入（仅提示）', () => {
const item = { PosiNetNoFeePrice: 99.5, PosiGrossPrice: 100.0, InitYtm: 2.6,
bondDriverType: 'CP', bondManual: { CP: true, DP: false, YD: false } };
test('端到端：业务错误时保留源字段、清空另两字段与标识（交互约定2 失败）', () => {
const item = { PosiNetNoFeePrice: 99.5, PosiGrossPrice: 100.0, InitYtm: 2.6, bondDriverType: 'CP' };
const respObj = { errCode: 1, errMsg: "债券不存在", dirtyPrice: 0, cleanPrice: 0, ytm: 0 };
const err = SwapCalc.getBondCalcErrorMessage(respObj);
expect(err).toBe("债券不存在"); // 有错 → 调用方会 main.message(err) 并 return
if (!err) {
const proxy = { cleanPrice: item.PosiNetNoFeePrice, dirtyPrice: item.PosiGrossPrice, ytm: item.InitYtm };
SwapCalc.applyBondCalcResult(proxy, respObj, item.bondManual);
item.PosiNetNoFeePrice = proxy.cleanPrice;
item.PosiGrossPrice = proxy.dirtyPrice;
item.InitYtm = proxy.ytm;
}
expect(item.PosiNetNoFeePrice).toBe(99.5);
expect(item.PosiGrossPrice).toBe(100.0);
expect(item.InitYtm).toBe(2.6);
expect(err).toBe("债券不存在"); // 有错 → 调用方会 main.message(err) 并调 applyBondCalcFailure
if (err) SwapCalc.applyBondCalcFailure(item, 'CP');
expect(item.PosiNetNoFeePrice).toBe(99.5); // 源：保留用户输入
expect(item.PosiGrossPrice).toBeNull(); // 非源：清空
expect(item.InitYtm).toBeNull();
expect(item.bondDriverType).toBeNull(); // 三字段标识全清
expect(item.bondAuto).toEqual({ CP: false, DP: false, YD: false });
expect(item.bondRev).toEqual({ CP: false, DP: false, YD: false });
});
});
// ============================================================================
// 交互约定1/2/3 状态机：applyBondCalcSuccess / applyBondCalcFailure / applyBondManualEdit
// ============================================================================
describe('交互约定2/3 状态机：applyBondCalcSuccess / Failure / ManualEdit', () => {
test('applyBondCalcSuccess(CP)：源=CP，AUTO={DP,YD}，REV 清空', () => {
const s = { bondDriverType: null, bondAuto: { CP: false, DP: false, YD: false }, bondRev: { CP: true, DP: false, YD: false } };
SwapCalc.applyBondCalcSuccess(s, 'CP');
expect(s.bondDriverType).toBe('CP');
expect(s.bondAuto).toEqual({ CP: false, DP: true, YD: true });
expect(s.bondRev).toEqual({ CP: false, DP: false, YD: false });
});
test('applyBondCalcSuccess(DP)：源=DP，AUTO={CP,YD}', () => {
const s = {};
SwapCalc.applyBondCalcSuccess(s, 'DP');
expect(s.bondDriverType).toBe('DP');
expect(s.bondAuto).toEqual({ CP: true, DP: false, YD: true });
});
test('applyBondCalcFailure(CP)：源值保留，另两字段清空，标识全清', () => {
const s = { PosiNetNoFeePrice: 99.5, PosiGrossPrice: 100, InitYtm: 2.6,
bondDriverType: 'CP', bondAuto: { CP: false, DP: true, YD: true }, bondRev: { CP: false, DP: false, YD: false } };
SwapCalc.applyBondCalcFailure(s, 'CP');
expect(s.PosiNetNoFeePrice).toBe(99.5); // 源：保留
expect(s.PosiGrossPrice).toBeNull(); // 非源：清空
expect(s.InitYtm).toBeNull();
expect(s.bondDriverType).toBeNull();
expect(s.bondAuto).toEqual({ CP: false, DP: false, YD: false });
expect(s.bondRev).toEqual({ CP: false, DP: false, YD: false });
});
test('applyBondManualEdit(DP)：清 源/AUTO，仅 DP 标 REV（交互约定3）', () => {
const s = { bondDriverType: 'CP', bondAuto: { CP: false, DP: true, YD: true }, bondRev: { CP: false, DP: false, YD: false } };
SwapCalc.applyBondManualEdit(s, 'DP');
expect(s.bondDriverType).toBeNull();
expect(s.bondAuto).toEqual({ CP: false, DP: false, YD: false });
expect(s.bondRev).toEqual({ CP: false, DP: true, YD: false }); // 仅本字段 REV
});
test('全价回车后净价再回车：净价成新源、全价降级为 AUTO（最后回车者恒为源）', () => {
const s = { PosiNetNoFeePrice: null, PosiGrossPrice: null, InitYtm: null,
bondDriverType: null, bondAuto: { CP: false, DP: false, YD: false }, bondRev: { CP: false, DP: false, YD: false } };
SwapCalc.applyBondCalcSuccess(s, 'DP'); // 全价回车
expect(s.bondDriverType).toBe('DP');
expect(s.bondAuto).toEqual({ CP: true, DP: false, YD: true });
SwapCalc.applyBondCalcSuccess(s, 'CP'); // 净价再回车
expect(s.bondDriverType).toBe('CP');
expect(s.bondAuto).toEqual({ CP: false, DP: true, YD: true }); // 全价从源降级为 AUTO
});
});