张翔
265 lines
10 KiB
TypeScript
265 lines
10 KiB
TypeScript
import { test, expect } from '../test-fixtures';
|
|
|
|
test.describe('DataStrategyManager - 数据策略管理器测试', () => {
|
|
|
|
test('应该能够初始化并获取默认策略', async ({ dataStrategyManager }) => {
|
|
const strategy = dataStrategyManager.getStrategy();
|
|
expect(strategy).toBe('hybrid');
|
|
|
|
const config = dataStrategyManager.getConfig();
|
|
expect(config.strategy).toBe('hybrid');
|
|
expect(config.mockEnabled).toBe(true);
|
|
expect(config.realDataEnabled).toBe(true);
|
|
expect(config.autoCleanup).toBe(true);
|
|
});
|
|
|
|
test('应该能够设置和获取数据策略', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('mock');
|
|
expect(dataStrategyManager.getStrategy()).toBe('mock');
|
|
|
|
dataStrategyManager.setStrategy('real');
|
|
expect(dataStrategyManager.getStrategy()).toBe('real');
|
|
|
|
dataStrategyManager.setStrategy('hybrid');
|
|
expect(dataStrategyManager.getStrategy()).toBe('hybrid');
|
|
});
|
|
|
|
test('应该能够根据@smoke标签选择Mock数据源', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('hybrid');
|
|
const dataSource = dataStrategyManager.selectDataSource(['@smoke']);
|
|
expect(dataSource).toBe('mock');
|
|
});
|
|
|
|
test('应该能够根据@regression标签选择混合数据源', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('hybrid');
|
|
const dataSource = dataStrategyManager.selectDataSource(['@regression']);
|
|
expect(dataSource).toBe('hybrid');
|
|
});
|
|
|
|
test('应该能够根据@full标签选择真实数据源', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('hybrid');
|
|
const dataSource = dataStrategyManager.selectDataSource(['@full']);
|
|
expect(dataSource).toBe('real');
|
|
});
|
|
|
|
test('应该能够根据@critical标签选择真实数据源', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('hybrid');
|
|
const dataSource = dataStrategyManager.selectDataSource(['@critical']);
|
|
expect(dataSource).toBe('real');
|
|
});
|
|
|
|
test('应该能够创建Mock用户数据', async ({ dataStrategyManager }) => {
|
|
const userData = {
|
|
username: 'testuser',
|
|
password: 'password123'
|
|
};
|
|
|
|
const result = await dataStrategyManager.createData('user', userData, ['@smoke']);
|
|
expect(result).toBeDefined();
|
|
expect(result.username).toBe('testuser');
|
|
expect(result.password).toBe('password123');
|
|
expect(result.email).toBeDefined();
|
|
expect(result.phone).toBeDefined();
|
|
});
|
|
|
|
test('应该能够创建Mock角色数据', async ({ dataStrategyManager }) => {
|
|
const roleData = {
|
|
roleName: '测试角色',
|
|
roleKey: 'test_role'
|
|
};
|
|
|
|
const result = await dataStrategyManager.createData('role', roleData, ['@smoke']);
|
|
expect(result).toBeDefined();
|
|
expect(result.roleName).toBe('测试角色');
|
|
expect(result.roleKey).toBe('test_role');
|
|
expect(result.description).toBeDefined();
|
|
});
|
|
|
|
test('应该能够创建Mock菜单数据', async ({ dataStrategyManager }) => {
|
|
const menuData = {
|
|
menuName: '测试菜单',
|
|
path: '/test'
|
|
};
|
|
|
|
const result = await dataStrategyManager.createData('menu', menuData, ['@smoke']);
|
|
expect(result).toBeDefined();
|
|
expect(result.menuName).toBe('测试菜单');
|
|
expect(result.path).toBe('/test');
|
|
expect(result.icon).toBeDefined();
|
|
});
|
|
|
|
test('应该能够创建数据快照', async ({ dataStrategyManager }) => {
|
|
const snapshotName = 'test-snapshot';
|
|
const snapshot = await dataStrategyManager.createSnapshot(snapshotName);
|
|
|
|
expect(snapshot).toBeDefined();
|
|
expect(snapshot.name).toBe(snapshotName);
|
|
expect(snapshot.timestamp).toBeGreaterThan(0);
|
|
expect(snapshot.data).toBeDefined();
|
|
});
|
|
|
|
test('应该能够回滚到数据快照', async ({ dataStrategyManager }) => {
|
|
const snapshotName = 'rollback-test-snapshot';
|
|
|
|
await dataStrategyManager.createData('user', { username: 'user1' }, ['@smoke']);
|
|
await dataStrategyManager.createSnapshot(snapshotName);
|
|
|
|
await dataStrategyManager.createData('user', { username: 'user2' }, ['@smoke']);
|
|
|
|
await dataStrategyManager.rollbackToSnapshot(snapshotName);
|
|
|
|
const users = dataStrategyManager.getTestData('user');
|
|
expect(users.length).toBe(1);
|
|
expect(users[0].username).toBe('user1');
|
|
});
|
|
|
|
test('应该能够获取所有快照', async ({ dataStrategyManager }) => {
|
|
await dataStrategyManager.createSnapshot('snapshot1');
|
|
await dataStrategyManager.createSnapshot('snapshot2');
|
|
await dataStrategyManager.createSnapshot('snapshot3');
|
|
|
|
const snapshots = dataStrategyManager.getAllSnapshots();
|
|
expect(snapshots.length).toBe(3);
|
|
expect(snapshots[0].name).toBe('snapshot1');
|
|
expect(snapshots[1].name).toBe('snapshot2');
|
|
expect(snapshots[2].name).toBe('snapshot3');
|
|
});
|
|
|
|
test('应该能够删除快照', async ({ dataStrategyManager }) => {
|
|
const snapshotName = 'delete-test-snapshot';
|
|
await dataStrategyManager.createSnapshot(snapshotName);
|
|
|
|
expect(dataStrategyManager.getSnapshot(snapshotName)).toBeDefined();
|
|
|
|
dataStrategyManager.deleteSnapshot(snapshotName);
|
|
|
|
expect(dataStrategyManager.getSnapshot(snapshotName)).toBeUndefined();
|
|
});
|
|
|
|
test('应该能够获取统计信息', async ({ dataStrategyManager }) => {
|
|
await dataStrategyManager.createData('user', { username: 'user1' }, ['@smoke']);
|
|
await dataStrategyManager.createData('user', { username: 'user2' }, ['@smoke']);
|
|
await dataStrategyManager.createData('role', { roleName: 'role1' }, ['@smoke']);
|
|
await dataStrategyManager.createSnapshot('snapshot1');
|
|
await dataStrategyManager.createSnapshot('snapshot2');
|
|
|
|
const stats = dataStrategyManager.getStatistics();
|
|
|
|
expect(stats.totalTestData).toBe(3);
|
|
expect(stats.totalSnapshots).toBe(2);
|
|
expect(stats.strategy).toBe('hybrid');
|
|
expect(stats.config).toBeDefined();
|
|
});
|
|
|
|
test('应该能够清理所有测试数据', async ({ dataStrategyManager }) => {
|
|
await dataStrategyManager.createData('user', { username: 'user1' }, ['@smoke']);
|
|
await dataStrategyManager.createData('role', { roleName: 'role1' }, ['@smoke']);
|
|
await dataStrategyManager.createSnapshot('snapshot1');
|
|
|
|
expect(dataStrategyManager.getTestData('user').length).toBeGreaterThan(0);
|
|
expect(dataStrategyManager.getAllSnapshots().length).toBeGreaterThan(0);
|
|
|
|
await dataStrategyManager.cleanupAll();
|
|
|
|
expect(dataStrategyManager.getTestData('user').length).toBe(0);
|
|
expect(dataStrategyManager.getAllSnapshots().length).toBe(0);
|
|
});
|
|
|
|
test('应该能够处理多个标签的情况', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('hybrid');
|
|
|
|
const dataSource1 = dataStrategyManager.selectDataSource(['@smoke', '@normal']);
|
|
expect(dataSource1).toBe('mock');
|
|
|
|
const dataSource2 = dataStrategyManager.selectDataSource(['@regression', '@normal']);
|
|
expect(dataSource2).toBe('hybrid');
|
|
|
|
const dataSource3 = dataStrategyManager.selectDataSource(['@full', '@complete']);
|
|
expect(dataSource3).toBe('real');
|
|
|
|
const dataSource4 = dataStrategyManager.selectDataSource(['@critical', '@smoke']);
|
|
expect(dataSource4).toBe('real');
|
|
});
|
|
|
|
test('应该能够处理未知数据类型', async ({ dataStrategyManager }) => {
|
|
const unknownData = { name: 'unknown' };
|
|
const result = await dataStrategyManager.createData('unknown', unknownData, ['@smoke']);
|
|
|
|
expect(result).toBeDefined();
|
|
expect(result.name).toBe('unknown');
|
|
});
|
|
|
|
test('应该能够处理强制真实数据策略', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('real');
|
|
|
|
const dataSource = dataStrategyManager.selectDataSource(['@smoke']);
|
|
expect(dataSource).toBe('real');
|
|
});
|
|
|
|
test('应该能够处理强制Mock数据策略', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('mock');
|
|
|
|
const dataSource = dataStrategyManager.selectDataSource(['@full']);
|
|
expect(dataSource).toBe('mock');
|
|
});
|
|
|
|
test('应该能够处理没有标签的情况', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('hybrid');
|
|
|
|
const dataSource = dataStrategyManager.selectDataSource([]);
|
|
expect(dataSource).toBe('mock');
|
|
});
|
|
|
|
test('应该能够创建混合数据', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('hybrid');
|
|
|
|
const userData = { username: 'hybrid_user' };
|
|
const result = await dataStrategyManager.createData('user', userData, ['@regression']);
|
|
|
|
expect(result).toBeDefined();
|
|
expect(result.username).toBe('hybrid_user');
|
|
expect(result._dataSource).toBe('hybrid');
|
|
expect(result._mockData).toBeDefined();
|
|
expect(result._realData).toBeDefined();
|
|
});
|
|
});
|
|
|
|
test.describe('DataStrategyManager - 集成测试', () => {
|
|
|
|
test('应该在测试用例中正常使用数据策略管理器', async ({ dataStrategyManager, page }) => {
|
|
dataStrategyManager.setStrategy('hybrid');
|
|
|
|
const userData = await dataStrategyManager.createData('user', {
|
|
username: 'integration_test_user',
|
|
password: 'password123'
|
|
}, ['@smoke']);
|
|
|
|
expect(userData).toBeDefined();
|
|
expect(userData.username).toBe('integration_test_user');
|
|
|
|
await page.goto('http://localhost:3000/login');
|
|
await page.fill('input[name="username"]', userData.username);
|
|
await page.fill('input[name="password"]', userData.password);
|
|
});
|
|
|
|
test('应该能够在不同测试标签下使用不同数据源', async ({ dataStrategyManager }) => {
|
|
dataStrategyManager.setStrategy('hybrid');
|
|
|
|
const mockData = await dataStrategyManager.createData('user', {
|
|
username: 'mock_user'
|
|
}, ['@smoke']);
|
|
|
|
const hybridData = await dataStrategyManager.createData('user', {
|
|
username: 'hybrid_user'
|
|
}, ['@regression']);
|
|
|
|
const realData = await dataStrategyManager.createData('user', {
|
|
username: 'real_user'
|
|
}, ['@full']);
|
|
|
|
expect(mockData).toBeDefined();
|
|
expect(hybridData).toBeDefined();
|
|
expect(realData).toBeDefined();
|
|
});
|
|
});
|