mirror of
https://github.com/Syngnat/GoNavi.git
synced 2026-07-23 13:47:12 +08:00
60eb696859
- 事件右键编辑定义改为打开 object-edit 查询 - 拉取 CREATE EVENT 作为可编辑 SQL，避免只显示 SHOW CREATE EVENT - 补充事件定义编辑与菜单入口回归测试 Fixes #540
634 lines
22 KiB
TypeScript
634 lines
22 KiB
TypeScript
import React from 'react';
|
|
import { act, create } from 'react-test-renderer';
|
|
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
|
|
|
import type { TabData } from '../types';
|
|
import { I18nProvider } from '../i18n/provider';
|
|
import DefinitionViewer from './DefinitionViewer';
|
|
|
|
const storeState = vi.hoisted(() => ({
|
|
connections: [
|
|
{
|
|
id: 'conn-1',
|
|
name: 'local',
|
|
config: {
|
|
type: 'postgres',
|
|
host: '127.0.0.1',
|
|
port: 5432,
|
|
user: 'postgres',
|
|
password: '',
|
|
database: 'main',
|
|
},
|
|
},
|
|
],
|
|
theme: 'light',
|
|
addTab: vi.fn(),
|
|
setActiveContext: vi.fn(),
|
|
}));
|
|
|
|
const backendApp = vi.hoisted(() => ({
|
|
DBQuery: vi.fn(),
|
|
}));
|
|
|
|
vi.mock('../store', () => ({
|
|
useStore: (selector: (state: typeof storeState) => any) => selector(storeState),
|
|
}));
|
|
|
|
vi.mock('../../wailsjs/go/app/App', () => backendApp);
|
|
vi.mock('../i18n/runtime', () => ({
|
|
syncLanguageRuntime: vi.fn(async () => undefined),
|
|
}));
|
|
|
|
vi.mock('@ant-design/icons', () => ({
|
|
EditOutlined: () => <span data-icon="edit" />,
|
|
}));
|
|
|
|
vi.mock('./MonacoEditor', () => ({
|
|
default: ({ value, options }: any) => (
|
|
<pre data-editor="true" data-readonly={String(options?.readOnly)}>
|
|
{value}
|
|
</pre>
|
|
),
|
|
}));
|
|
|
|
vi.mock('antd', () => ({
|
|
Spin: ({ tip }: any) => <div>{tip}</div>,
|
|
Alert: ({ message, description }: any) => <div>{message}{description}</div>,
|
|
Button: ({ children, onClick, icon }: any) => (
|
|
<button type="button" onClick={onClick}>
|
|
{icon}
|
|
{children}
|
|
</button>
|
|
),
|
|
}));
|
|
|
|
const flushPromises = async (count = 6) => {
|
|
for (let i = 0; i < count; i += 1) {
|
|
await Promise.resolve();
|
|
}
|
|
};
|
|
|
|
const renderWithI18n = (tab: TabData) => (
|
|
<I18nProvider
|
|
preference="en-US"
|
|
systemLanguages={['en-US']}
|
|
onPreferenceChange={() => undefined}
|
|
>
|
|
<DefinitionViewer tab={tab} />
|
|
</I18nProvider>
|
|
);
|
|
|
|
const findButtonText = (node: any): string => (
|
|
(node.children || [])
|
|
.map((item: any) => (typeof item === 'string' ? item : findButtonText(item)))
|
|
.join('')
|
|
);
|
|
|
|
const createTab = (overrides: Partial<TabData> = {}): TabData => ({
|
|
id: 'view-def-conn-1-main-reporting.active_users',
|
|
title: '视图: reporting.active_users',
|
|
type: 'view-def',
|
|
connectionId: 'conn-1',
|
|
dbName: 'main',
|
|
viewName: 'reporting.active_users',
|
|
viewKind: 'view',
|
|
schemaName: 'reporting',
|
|
...overrides,
|
|
});
|
|
|
|
describe('DefinitionViewer object edit entry', () => {
|
|
beforeEach(() => {
|
|
storeState.addTab.mockReset();
|
|
storeState.setActiveContext.mockReset();
|
|
storeState.theme = 'light';
|
|
storeState.connections[0].config.type = 'postgres';
|
|
backendApp.DBQuery.mockReset();
|
|
backendApp.DBQuery.mockResolvedValue({
|
|
success: true,
|
|
data: [{ view_definition: 'SELECT id, name FROM users' }],
|
|
});
|
|
});
|
|
|
|
it('opens an editable query tab for view definitions', async () => {
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab()));
|
|
await flushPromises();
|
|
});
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
|
|
await act(async () => {
|
|
button.props.onClick();
|
|
});
|
|
|
|
expect(storeState.setActiveContext).toHaveBeenCalledWith({ connectionId: 'conn-1', dbName: 'main' });
|
|
expect(storeState.addTab).toHaveBeenCalledWith(expect.objectContaining({
|
|
title: 'Edit View: reporting.active_users',
|
|
type: 'query',
|
|
connectionId: 'conn-1',
|
|
dbName: 'main',
|
|
queryMode: 'object-edit',
|
|
query: expect.stringContaining('CREATE OR REPLACE VIEW reporting.active_users AS'),
|
|
}));
|
|
expect(storeState.addTab.mock.calls[0][0].query).toContain('-- Edit View: reporting.active_users');
|
|
expect(storeState.addTab.mock.calls[0][0].query).toContain('-- Confirm the syntax is compatible with the current database before running it');
|
|
expect(storeState.addTab.mock.calls[0][0].query).toContain('SELECT id, name FROM users;');
|
|
});
|
|
|
|
it('adds CREATE OR REPLACE without duplicating view fragments returned without ddl prefix', async () => {
|
|
backendApp.DBQuery.mockResolvedValue({
|
|
success: true,
|
|
data: [{ view_definition: 'VIEW reporting.active_users AS\nSELECT id, name FROM users' }],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab()));
|
|
await flushPromises();
|
|
});
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
|
|
await act(async () => {
|
|
button.props.onClick();
|
|
});
|
|
|
|
const query = storeState.addTab.mock.calls[0][0].query;
|
|
expect(query).toContain('CREATE OR REPLACE VIEW reporting.active_users AS');
|
|
expect(query).toContain('SELECT id, name FROM users;');
|
|
expect(query).not.toContain('AS\nVIEW reporting.active_users AS');
|
|
});
|
|
|
|
it('opens an editable query tab for routine definitions', async () => {
|
|
backendApp.DBQuery.mockResolvedValue({
|
|
success: true,
|
|
data: [{ routine_definition: 'CREATE OR REPLACE FUNCTION reporting.refresh_stats() RETURNS void AS $$ BEGIN END; $$ LANGUAGE plpgsql;' }],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab({
|
|
id: 'routine-def-conn-1-main-reporting.refresh_stats',
|
|
title: '函数: reporting.refresh_stats',
|
|
type: 'routine-def',
|
|
routineName: 'reporting.refresh_stats',
|
|
routineType: 'FUNCTION',
|
|
viewName: undefined,
|
|
viewKind: undefined,
|
|
})));
|
|
await flushPromises();
|
|
});
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
|
|
await act(async () => {
|
|
button.props.onClick();
|
|
});
|
|
|
|
expect(storeState.addTab).toHaveBeenCalledWith(expect.objectContaining({
|
|
title: 'Edit Function/procedure: reporting.refresh_stats',
|
|
type: 'query',
|
|
queryMode: 'object-edit',
|
|
query: expect.stringContaining('CREATE OR REPLACE FUNCTION reporting.refresh_stats()'),
|
|
}));
|
|
});
|
|
|
|
it('opens an editable query tab for event definitions', async () => {
|
|
storeState.connections[0].config.type = 'mysql';
|
|
backendApp.DBQuery.mockResolvedValue({
|
|
success: true,
|
|
data: [{
|
|
Event: 'daily_cleanup',
|
|
'Create Event': 'CREATE EVENT `daily_cleanup`\nON SCHEDULE EVERY 1 DAY\nDO DELETE FROM logs',
|
|
}],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab({
|
|
id: 'event-def-conn-1-main-daily_cleanup',
|
|
title: '事件: daily_cleanup',
|
|
type: 'event-def',
|
|
eventName: 'daily_cleanup',
|
|
viewName: undefined,
|
|
viewKind: undefined,
|
|
})));
|
|
await flushPromises();
|
|
});
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
|
|
await act(async () => {
|
|
button.props.onClick();
|
|
});
|
|
|
|
const query = storeState.addTab.mock.calls[0][0].query;
|
|
expect(storeState.addTab).toHaveBeenCalledWith(expect.objectContaining({
|
|
title: 'Edit Event: daily_cleanup',
|
|
type: 'query',
|
|
queryMode: 'object-edit',
|
|
query: expect.stringContaining('CREATE EVENT `daily_cleanup`'),
|
|
}));
|
|
expect(query).toContain('-- Edit Event: daily_cleanup');
|
|
expect(query).toContain('ON SCHEDULE EVERY 1 DAY');
|
|
expect(query).not.toContain('SHOW CREATE EVENT');
|
|
});
|
|
|
|
it('uses SQL Server catalog metadata when loading routine definitions', async () => {
|
|
storeState.connections[0].config.type = 'sqlserver';
|
|
backendApp.DBQuery.mockResolvedValue({
|
|
success: true,
|
|
data: [{ routine_definition: 'CREATE PROCEDURE [reporting].[refresh_stats]\nAS\nSELECT 1;' }],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab({
|
|
id: 'routine-def-conn-1-main-reporting.refresh_stats',
|
|
title: '存储过程: reporting.refresh_stats',
|
|
type: 'routine-def',
|
|
routineName: 'reporting.refresh_stats',
|
|
routineType: 'PROCEDURE',
|
|
viewName: undefined,
|
|
viewKind: undefined,
|
|
})));
|
|
await flushPromises();
|
|
});
|
|
|
|
const sql = String(backendApp.DBQuery.mock.calls[0][2] || '');
|
|
expect(sql).toContain('FROM [main].sys.all_sql_modules AS m');
|
|
expect(sql).toContain("WHERE o.name = N'refresh_stats'");
|
|
expect(sql).toContain("AND s.name = N'reporting'");
|
|
expect(sql).not.toContain('OBJECT_DEFINITION');
|
|
expect(String(renderer.root.findAll((node: any) => node.props['data-editor'] === 'true')[0].children.join(''))).toContain('CREATE PROCEDURE [reporting].[refresh_stats]');
|
|
});
|
|
|
|
it('joins SQL Server sp_helptext rows when catalog metadata is empty', async () => {
|
|
storeState.connections[0].config.type = 'sqlserver';
|
|
backendApp.DBQuery
|
|
.mockResolvedValueOnce({ success: true, data: [] })
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [
|
|
{ Text: 'CREATE PROCEDURE [reporting].[refresh_stats]\n' },
|
|
{ Text: 'AS\n' },
|
|
{ Text: 'BEGIN\n SELECT 1;\nEND' },
|
|
],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab({
|
|
id: 'routine-def-conn-1-main-reporting.refresh_stats',
|
|
title: '存储过程: reporting.refresh_stats',
|
|
type: 'routine-def',
|
|
routineName: 'reporting.refresh_stats',
|
|
routineType: 'PROCEDURE',
|
|
viewName: undefined,
|
|
viewKind: undefined,
|
|
})));
|
|
await flushPromises();
|
|
});
|
|
|
|
expect(backendApp.DBQuery.mock.calls[1][2]).toBe("EXEC [main].sys.sp_helptext @objname = N'[reporting].[refresh_stats]'");
|
|
const editorText = String(renderer.root.findAll((node: any) => node.props['data-editor'] === 'true')[0].children.join(''));
|
|
expect(editorText).toContain('CREATE PROCEDURE [reporting].[refresh_stats]');
|
|
expect(editorText).toContain('BEGIN\n SELECT 1;\nEND');
|
|
});
|
|
|
|
it('adds CREATE OR REPLACE for routine source snippets returned without ddl prefix', async () => {
|
|
storeState.connections[0].config.type = 'oracle';
|
|
backendApp.DBQuery.mockResolvedValue({
|
|
success: true,
|
|
data: [
|
|
{ TEXT: 'PROCEDURE proc_tally2accept(p_id IN NUMBER) IS\n' },
|
|
{ TEXT: ' v_count PLS_INTEGER;\n' },
|
|
{ TEXT: 'BEGIN\n' },
|
|
{ TEXT: ' SELECT COUNT(*) INTO v_count FROM dual;\n' },
|
|
{ TEXT: 'END;\n' },
|
|
],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab({
|
|
id: 'routine-def-conn-1-main-proc_tally2accept',
|
|
title: '存储过程: proc_tally2accept',
|
|
type: 'routine-def',
|
|
routineName: 'proc_tally2accept',
|
|
routineType: 'PROCEDURE',
|
|
viewName: undefined,
|
|
viewKind: undefined,
|
|
})));
|
|
await flushPromises();
|
|
});
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
|
|
await act(async () => {
|
|
button.props.onClick();
|
|
});
|
|
|
|
const query = storeState.addTab.mock.calls[0][0].query;
|
|
expect(query).toContain('CREATE OR REPLACE PROCEDURE proc_tally2accept(p_id IN NUMBER)');
|
|
expect(query).toContain('v_count PLS_INTEGER;');
|
|
expect(query).toContain('SELECT COUNT(*) INTO v_count FROM dual;');
|
|
});
|
|
|
|
it('opens an editable query tab for Oracle sequence definitions', async () => {
|
|
storeState.connections[0].config.type = 'oracle';
|
|
backendApp.DBQuery.mockResolvedValue({
|
|
success: true,
|
|
data: [{
|
|
SEQUENCE_OWNER: 'H2',
|
|
SEQUENCE_NAME: 'HWMS_PACK_SEQNO',
|
|
MIN_VALUE: 1,
|
|
MAX_VALUE: 999999999999,
|
|
INCREMENT_BY: 1,
|
|
CYCLE_FLAG: 'N',
|
|
ORDER_FLAG: 'N',
|
|
CACHE_SIZE: 20,
|
|
}],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab({
|
|
id: 'sequence-def-conn-1-H2-H2.HWMS_PACK_SEQNO',
|
|
title: 'Sequence: H2.HWMS_PACK_SEQNO',
|
|
type: 'sequence-def',
|
|
sequenceName: 'H2.HWMS_PACK_SEQNO',
|
|
viewName: undefined,
|
|
viewKind: undefined,
|
|
})));
|
|
await flushPromises();
|
|
});
|
|
|
|
expect(String(backendApp.DBQuery.mock.calls[0][2] || '')).toContain('FROM ALL_SEQUENCES');
|
|
const editorText = String(renderer.root.findAll((node: any) => node.props['data-editor'] === 'true')[0].children.join(''));
|
|
expect(editorText).toContain('CREATE SEQUENCE H2.HWMS_PACK_SEQNO');
|
|
expect(editorText).toContain('CACHE 20');
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
await act(async () => {
|
|
await button.props.onClick();
|
|
await flushPromises();
|
|
});
|
|
|
|
expect(storeState.addTab).toHaveBeenCalledWith(expect.objectContaining({
|
|
type: 'query',
|
|
queryMode: 'object-edit',
|
|
query: expect.stringContaining('CREATE SEQUENCE H2.HWMS_PACK_SEQNO'),
|
|
}));
|
|
});
|
|
|
|
it('loads Oracle package specification and body definitions without dropping lines', async () => {
|
|
storeState.connections[0].config.type = 'oracle';
|
|
backendApp.DBQuery
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [
|
|
{ TEXT: 'PACKAGE pkg_order AS\n' },
|
|
{ TEXT: ' PROCEDURE sync_order(p_id IN NUMBER);\n' },
|
|
{ TEXT: 'END pkg_order;\n' },
|
|
],
|
|
})
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [
|
|
{ TEXT: 'PACKAGE BODY pkg_order AS\n' },
|
|
{ TEXT: ' PROCEDURE sync_order(p_id IN NUMBER) IS\n' },
|
|
{ TEXT: ' BEGIN\n' },
|
|
{ TEXT: ' NULL;\n' },
|
|
{ TEXT: ' END;\n' },
|
|
{ TEXT: 'END pkg_order;\n' },
|
|
],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab({
|
|
id: 'package-def-conn-1-H2-H2.PKG_ORDER',
|
|
title: 'Package: H2.PKG_ORDER',
|
|
type: 'package-def',
|
|
packageName: 'H2.PKG_ORDER',
|
|
viewName: undefined,
|
|
viewKind: undefined,
|
|
})));
|
|
await flushPromises();
|
|
});
|
|
|
|
expect(String(backendApp.DBQuery.mock.calls[0][2] || '')).toContain("TYPE = 'PACKAGE'");
|
|
expect(String(backendApp.DBQuery.mock.calls[1][2] || '')).toContain("TYPE = 'PACKAGE BODY'");
|
|
const editorText = String(renderer.root.findAll((node: any) => node.props['data-editor'] === 'true')[0].children.join(''));
|
|
expect(editorText).toContain('PACKAGE pkg_order AS');
|
|
expect(editorText).toContain('PROCEDURE sync_order(p_id IN NUMBER);');
|
|
expect(editorText).toContain('PACKAGE BODY pkg_order AS');
|
|
expect(editorText).toContain('NULL;');
|
|
|
|
backendApp.DBQuery
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [
|
|
{ TEXT: 'PACKAGE pkg_order AS\n' },
|
|
{ TEXT: ' PROCEDURE sync_order(p_id IN NUMBER);\n' },
|
|
{ TEXT: 'END pkg_order;\n' },
|
|
],
|
|
})
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [
|
|
{ TEXT: 'PACKAGE BODY pkg_order AS\n' },
|
|
{ TEXT: ' PROCEDURE sync_order(p_id IN NUMBER) IS\n' },
|
|
{ TEXT: ' BEGIN\n' },
|
|
{ TEXT: ' NULL;\n' },
|
|
{ TEXT: ' END sync_order;\n' },
|
|
{ TEXT: 'END pkg_order;\n' },
|
|
],
|
|
});
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
await act(async () => {
|
|
await button.props.onClick();
|
|
await flushPromises();
|
|
});
|
|
|
|
const editQuery = String(storeState.addTab.mock.calls[0][0].query || '');
|
|
expect(editQuery).toContain('CREATE OR REPLACE PACKAGE pkg_order AS');
|
|
expect(editQuery).toContain('/\nCREATE OR REPLACE PACKAGE BODY pkg_order AS');
|
|
expect(editQuery).toContain('END sync_order;');
|
|
});
|
|
|
|
it('keeps Oracle routine SQLPlus slash delimiters executable when opening object edit', async () => {
|
|
storeState.connections[0].config.type = 'oracle';
|
|
backendApp.DBQuery
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [
|
|
{ TEXT: 'CREATE OR REPLACE PROCEDURE cproc_tzhssr_order2sale_A1 AS\n' },
|
|
{ TEXT: 'BEGIN\n' },
|
|
{ TEXT: ' NULL;\n' },
|
|
{ TEXT: 'END cproc_tzhssr_order2sale_A1;\n' },
|
|
{ TEXT: '/\n' },
|
|
],
|
|
})
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [
|
|
{ TEXT: 'CREATE OR REPLACE PROCEDURE cproc_tzhssr_order2sale_A1 AS\n' },
|
|
{ TEXT: 'BEGIN\n' },
|
|
{ TEXT: ' NULL;\n' },
|
|
{ TEXT: 'END cproc_tzhssr_order2sale_A1;\n' },
|
|
{ TEXT: '/\n' },
|
|
],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab({
|
|
id: 'routine-def-conn-1-H2-H2.CPROC_TZHSSR_ORDER2SALE_A1',
|
|
title: 'Procedure: H2.CPROC_TZHSSR_ORDER2SALE_A1',
|
|
type: 'routine-def',
|
|
routineName: 'H2.CPROC_TZHSSR_ORDER2SALE_A1',
|
|
routineType: 'PROCEDURE',
|
|
viewName: undefined,
|
|
viewKind: undefined,
|
|
})));
|
|
await flushPromises();
|
|
});
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
await act(async () => {
|
|
await button.props.onClick();
|
|
await flushPromises();
|
|
});
|
|
|
|
const editQuery = String(storeState.addTab.mock.calls[0][0].query || '');
|
|
expect(editQuery).toContain('END cproc_tzhssr_order2sale_A1;\n/');
|
|
expect(editQuery).not.toContain('/;');
|
|
});
|
|
|
|
it('reloads the latest object definition before opening object edit', async () => {
|
|
backendApp.DBQuery
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [{ view_definition: 'SELECT id FROM users' }],
|
|
})
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [{ view_definition: 'SELECT id, name, updated_at FROM users' }],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab()));
|
|
await flushPromises();
|
|
});
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
|
|
await act(async () => {
|
|
await button.props.onClick();
|
|
await flushPromises();
|
|
});
|
|
|
|
expect(backendApp.DBQuery).toHaveBeenCalledTimes(2);
|
|
const query = storeState.addTab.mock.calls[0][0].query;
|
|
expect(query).toContain('SELECT id, name, updated_at FROM users;');
|
|
expect(query).not.toContain('SELECT id FROM users;');
|
|
|
|
const editor = renderer.root.findAll((node: any) => node.props['data-editor'] === 'true')[0];
|
|
expect(String(editor.children.join(''))).toContain('SELECT id, name, updated_at FROM users');
|
|
});
|
|
|
|
it('keeps the current definition visible when refresh for object edit fails', async () => {
|
|
backendApp.DBQuery
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [{ view_definition: 'SELECT id, name FROM users' }],
|
|
})
|
|
.mockResolvedValueOnce({
|
|
success: false,
|
|
message: 'network down',
|
|
data: [],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab()));
|
|
await flushPromises();
|
|
});
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
|
|
await act(async () => {
|
|
await button.props.onClick();
|
|
await flushPromises();
|
|
});
|
|
|
|
expect(storeState.addTab).not.toHaveBeenCalled();
|
|
expect(String(renderer.root.findAll((node: any) => node.props['data-editor'] === 'true')[0].children.join(''))).toContain('SELECT id, name FROM users');
|
|
expect(findButtonText(renderer.root)).toContain('Failed to refresh the latest definition');
|
|
expect(findButtonText(renderer.root)).toContain('network down');
|
|
});
|
|
|
|
it('does not keep the previous object definition when switching objects and the new load fails', async () => {
|
|
backendApp.DBQuery
|
|
.mockResolvedValueOnce({
|
|
success: true,
|
|
data: [{ view_definition: 'SELECT id, name FROM users' }],
|
|
})
|
|
.mockResolvedValueOnce({
|
|
success: false,
|
|
message: 'load failed',
|
|
data: [],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab()));
|
|
await flushPromises();
|
|
});
|
|
|
|
await act(async () => {
|
|
renderer.update(renderWithI18n(createTab({
|
|
id: 'view-def-conn-1-main-reporting.archived_users',
|
|
title: '视图: reporting.archived_users',
|
|
viewName: 'reporting.archived_users',
|
|
})));
|
|
await flushPromises();
|
|
});
|
|
|
|
expect(findButtonText(renderer.root)).toContain('Load failed');
|
|
expect(findButtonText(renderer.root)).toContain('load failed');
|
|
expect(renderer.root.findAll((node: any) => node.props['data-editor'] === 'true')).toHaveLength(0);
|
|
expect(findButtonText(renderer.root)).not.toContain('SELECT id, name FROM users');
|
|
});
|
|
|
|
it('keeps comment-only fallback definitions editable without reintroducing locale-specific detection', async () => {
|
|
backendApp.DBQuery.mockResolvedValue({
|
|
success: true,
|
|
data: [],
|
|
});
|
|
|
|
let renderer: any;
|
|
await act(async () => {
|
|
renderer = create(renderWithI18n(createTab()));
|
|
await flushPromises();
|
|
});
|
|
|
|
const button = renderer.root.findAll((node: any) => node.type === 'button' && findButtonText(node).includes('Edit object'))[0];
|
|
|
|
await act(async () => {
|
|
await button.props.onClick();
|
|
await flushPromises();
|
|
});
|
|
|
|
const query = String(storeState.addTab.mock.calls[0][0].query || '');
|
|
expect(query).toContain('-- Edit View: reporting.active_users');
|
|
expect(query).toContain('-- View definition not found');
|
|
expect(query).not.toContain('CREATE OR REPLACE VIEW reporting.active_users AS');
|
|
});
|
|
});
|