20260919211702

code/fms/fms-vue/tests/views/module-unsaved-after-save.spec.js

@@ -31,7 +31,6 @@ vi.mock('@/components/ui/message/message-manager.js', () => {
 
 import { loadDataApi, saveObjectApi } from '@/services/api'
 import { Message } from '@/components/ui/message/message-manager.js'
-import { createRefRuleRow } from '@/views/module/module-management/ruleUtils'
 
 /** 库中的一条关系：demo.b_name → other.b_name（一对多，源侧即当前模块） */
 function relationRow() {
@@ -110,7 +109,7 @@ function buildDb() {
     s_autocode: [],
     s_power: [],
     s_relation: [],
-    s_rule: [],
+    s_delete_rule: [],
     s_i18n: [{ b_key: 'module.demo', b_locale: 'en-US', b_value: 'Demo module' }],
   }
 }
@@ -130,20 +129,6 @@ beforeEach(() => {
           { b_id: 'en-US', b_name: 'English', b_default: 0 },
         ],
       })
-    // s_rule 的 scope 条件是两列（模块级 / 关系级）拼在同一个查询条件里，
-    // 这里按条件过滤，模拟后端 search_condition 的真实行为
-    if (view === 's_rule' && typeof condition === 'string') {
-      if (condition.includes("b_scope_type = 'module'")) {
-        return Promise.resolve({
-          data: rowsOf(view).filter((row) => row.b_scope_type === 'module'),
-        })
-      }
-      if (condition.includes("b_scope_type = 'relation'")) {
-        return Promise.resolve({
-          data: rowsOf(view).filter((row) => row.b_scope_type === 'relation'),
-        })
-      }
-    }
     return Promise.resolve({ data: rowsOf(view) })
   })
 
@@ -487,34 +472,14 @@ describe('模块管理：保存后的未保存判定', () => {
     ])
   })
 
-  it('删除规则：模块级规则加载不脏，只提交变更（雪花主键）', async () => {
+  it('删除 SQL 规则：加载不脏，只提交变更（雪花主键）', async () => {
     db.s_relation = [relationRow()]
-    db.s_rule = [
+    db.s_delete_rule = [
       {
         b_id: '1900000000000000001',
-        b_scope_type: 'module',
-        b_scope_id: 'demo',
-        b_hook: 'delete.pre',
-        b_predicate: JSON.stringify({
-          kind: 'dsl',
-          expr: {
-            type: 'group',
-            children: [
-              { type: 'condition', field: 'b_name', operator: 'like', value: 'a', join: 'and' },
-            ],
-          },
-        }),
-        b_message: null,
-        b_canuse: 1,
-        b_xh: 10,
-      },
-      {
-        b_id: '1900000000000000002',
-        b_scope_type: 'relation',
-        b_scope_id: 'demo|b_name|other|b_name',
-        b_hook: 'delete.pre',
-        b_predicate: null,
-        b_message: null,
+        b_module_id: 'demo',
+        b_sql: 'select b_id from demo where b_id in (:ids) and b_name like N\'a\'',
+        b_message: '示例模块记录已锁定，不能删除',
         b_canuse: 1,
         b_xh: 10,
       },
@@ -526,9 +491,8 @@ describe('模块管理：保存后的未保存判定', () => {
     await flushPromises()
     await flushPromises()
 
-    // 模块级规则进 rules，关系级进 refRules；打开即干净
+    // 规则进 rules；打开即干净
     expect(wrapper.vm.rules).toHaveLength(1)
-    expect(wrapper.vm.refRules).toHaveLength(1)
     expect(wrapper.vm.hasUnsavedChanges()).toBe(false)
 
     wrapper.vm.rules[0].b_canuse = 0
@@ -537,13 +501,12 @@ describe('模块管理：保存后的未保存判定', () => {
     await wrapper.vm.handleSave()
     await settleConfigReload(wrapper)
 
-    const ruleReq = savedRequests.find((request) => request.table === 's_rule')
-    expect(ruleReq, '规则变更应提交 s_rule').toBeTruthy()
+    const ruleReq = savedRequests.find((request) => request.table === 's_delete_rule')
+    expect(ruleReq, '规则变更应提交 s_delete_rule').toBeTruthy()
     expect(ruleReq.key_field).toBe('b_id')
     expect(ruleReq.updates?.[0]).toMatchObject({
       b_id: '1900000000000000001',
-      b_scope_type: 'module',
-      b_scope_id: 'demo',
+      b_module_id: 'demo',
       b_canuse: 0,
     })
     // 关系未变：不产生 s_relation 请求
@@ -551,7 +514,7 @@ describe('模块管理：保存后的未保存判定', () => {
     expect(wrapper.vm.hasUnsavedChanges()).toBe(false)
   })
 
-  it('关联面板勾选引用保护：保存时新增一条 relation 范围的规则', async () => {
+  it('关联删除处理：改 b_on_delete 随 s_relation 一起提交，不产生规则行', async () => {
     db.s_relation = [relationRow()]
     const wrapper = await mountManagement()
     await flushPromises()
@@ -559,41 +522,34 @@ describe('模块管理：保存后的未保存判定', () => {
     await flushPromises()
     await flushPromises()
 
-    expect(wrapper.vm.refRules).toEqual([])
-    wrapper.vm.refRules = [createRefRuleRow('demo|b_name|other|b_name', '1900000000000000003')]
+    expect(wrapper.vm.rules).toEqual([])
+    wrapper.vm.relations[0].b_on_delete = 'cascade'
     expect(wrapper.vm.hasUnsavedChanges()).toBe(true)
 
     await wrapper.vm.handleSave()
     await settleConfigReload(wrapper)
 
-    const refReq = savedRequests.find((request) => request.table === 's_rule')
-    expect(refReq?.key_field).toBe('b_id')
-    expect(refReq?.inserts?.[0]).toMatchObject({
-      b_id: '1900000000000000003',
-      b_scope_type: 'relation',
-      b_scope_id: 'demo|b_name|other|b_name',
-      b_predicate: null,
-      b_hook: 'delete.pre',
-    })
+    const relationReq = savedRequests.find((request) => request.table === 's_relation')
+    expect(relationReq?.updates?.[0]).toMatchObject({ b_on_delete: 'cascade' })
+    // 关联处置收敛到 s_relation，不再生成任何规则表请求
+    expect(savedRequests.some((request) => request.table === 's_delete_rule')).toBe(false)
     expect(wrapper.vm.hasUnsavedChanges()).toBe(false)
   })
 
-  it('删除模块应一并清理模块级与关系级删除规则（s_rule）', async () => {
+  it('删除模块应一并清理删除 SQL 规则（s_delete_rule）', async () => {
     db.s_relation = [relationRow()]
-    db.s_rule = [
+    db.s_delete_rule = [
       {
         b_id: '1900000000000000001',
-        b_scope_type: 'module',
-        b_scope_id: 'demo',
-        b_hook: 'delete.pre',
-        b_predicate: 'select 1 as b_id',
+        b_module_id: 'demo',
+        b_sql: 'select 1 as b_id',
+        b_message: '不能删除',
       },
       {
         b_id: '1900000000000000002',
-        b_scope_type: 'relation',
-        b_scope_id: 'demo|b_name|other|b_name',
-        b_hook: 'delete.pre',
-        b_predicate: null,
+        b_module_id: 'other',
+        b_sql: 'select 1 as b_id',
+        b_message: '不能删除',
       },
     ]
     const wrapper = await mountManagement()
@@ -607,16 +563,12 @@ describe('模块管理：保存后的未保存判定', () => {
     await wrapper.vm.onConfirmOk()
     await flushPromises()
 
-    const ruleReqs = savedRequests.filter((request) => request.table === 's_rule')
-    const moduleReq = ruleReqs.find(
-      (request) => request.deletes?.[0]?.b_scope_type === 'module' && request.deletes.length === 1,
+    const ruleReqs = savedRequests.filter((request) => request.table === 's_delete_rule')
+    const moduleReq = ruleReqs.find((request) => request.deletes?.[0]?.b_module_id === 'demo')
+    expect(moduleReq?.deletes).toEqual([{ b_module_id: 'demo' }])
+    // 只按模块列清理，不误伤其他模块的规则
+    expect(ruleReqs.every((request) => request.deletes.every((row) => row.b_module_id === 'demo'))).toBe(
+      true,
     )
-    expect(moduleReq?.deletes).toEqual([{ b_scope_type: 'module', b_scope_id: 'demo' }])
-    const relationReq = ruleReqs.find((request) =>
-      request.deletes?.some((row) => row.b_scope_type === 'relation'),
-    )
-    expect(relationReq?.deletes).toEqual([
-      { b_scope_type: 'relation', b_scope_id: 'demo|b_name|other|b_name' },
-    ])
   })
 })