admin/flowgram.ai
1
0
Fork 0
mirror of https://gitee.com/ByteDance/flowgram.ai.git synced 2025-07-07 17:43:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

test(container): remove useless test files

Browse Source
This commit is contained in:
liuyangxing 2025-03-18 16:10:51 +08:00
parent eb46039841
commit 6e41032044
5 changed files with 1 additions and 553 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
packages/plugins/free-container-plugin/__tests__/computing.test.ts
View File

@ -1,136 +0,0 @@
import { it, expect, beforeEach, describe } from 'vitest';
import { interfaces } from 'inversify';
import {
WorkflowDocument,
WorkflowHoverService,
WorkflowLineEntity,
WorkflowLinesManager,
WorkflowSelectService,
} from '@flowgram.ai/free-layout-core';
import { EntityManager } from '@flowgram.ai/core';
import { StackingComputing } from '../src/stacking-computing';
import { StackingContextManager } from '../src/manager';
import { createWorkflowContainer, workflowJSON } from './utils.mock';
import { IStackingComputing, IStackingContextManager } from './type.mock';
let container: interfaces.Container;
let document: WorkflowDocument;
let stackingContextManager: IStackingContextManager;
let stackingComputing: IStackingComputing;
beforeEach(async () => {
container = createWorkflowContainer();
container.bind(StackingContextManager).to(StackingContextManager);
document = container.get<WorkflowDocument>(WorkflowDocument);
stackingContextManager = container.get<StackingContextManager>(
StackingContextManager
) as unknown as IStackingContextManager;
await document.fromJSON(workflowJSON);
stackingContextManager.init();
stackingComputing = new StackingComputing() as unknown as IStackingComputing;
});
describe('StackingComputing compute', () => {
it('should create instance', () => {
const computing = new StackingComputing();
expect(computing).not.toBeUndefined();
});
it('should execute compute', () => {
const { nodeLevel, lineLevel, topLevel, maxLevel } = stackingComputing.compute({
root: document.root,
nodes: stackingContextManager.nodes,
context: stackingContextManager.context,
});
expect(topLevel).toBe(8);
expect(maxLevel).toBe(16);
expect(Object.fromEntries(nodeLevel)).toEqual({
start_0: 1,
condition_0: 2,
end_0: 3,
loop_0: 4,
break_0: 6,
variable_0: 7,
});
expect(Object.fromEntries(lineLevel)).toEqual({
'start_0_-condition_0_': 0,
'start_0_-loop_0_': 0,
'condition_0_if-end_0_': 0,
'condition_0_else-end_0_': 0,
'loop_0_-end_0_': 0,
'break_0_-variable_0_': 5,
});
});
it('should put hovered line on max level', () => {
const hoverService = container.get<WorkflowHoverService>(WorkflowHoverService);
const hoveredLineId = 'start_0_-loop_0_';
hoverService.updateHoveredKey(hoveredLineId);
const { lineLevel, maxLevel } = stackingComputing.compute({
root: document.root,
nodes: stackingContextManager.nodes,
context: stackingContextManager.context,
});
const hoveredLineLevel = lineLevel.get(hoveredLineId);
expect(hoveredLineLevel).toBe(maxLevel);
});
it('should put selected line on max level', () => {
const entityManager = container.get<EntityManager>(EntityManager);
const selectService = container.get<WorkflowSelectService>(WorkflowSelectService);
const selectedLineId = 'start_0_-loop_0_';
const selectedLine = entityManager.getEntityById<WorkflowLineEntity>(selectedLineId)!;
selectService.selection = [selectedLine];
const { lineLevel, maxLevel } = stackingComputing.compute({
root: document.root,
nodes: stackingContextManager.nodes,
context: stackingContextManager.context,
});
const selectedLineLevel = lineLevel.get(selectedLineId);
expect(selectedLineLevel).toBe(maxLevel);
});
it('should put drawing line on max level', () => {
const linesManager = container.get<WorkflowLinesManager>(WorkflowLinesManager);
const drawingLine = linesManager.createLine({
from: 'start_0',
drawingTo: { x: 100, y: 100 },
})!;
const { lineLevel, maxLevel } = stackingComputing.compute({
root: document.root,
nodes: stackingContextManager.nodes,
context: stackingContextManager.context,
});
const drawingLineLevel = lineLevel.get(drawingLine.id);
expect(drawingLineLevel).toBe(maxLevel);
});
it('should put selected nodes on top level', () => {
const selectService = container.get<WorkflowSelectService>(WorkflowSelectService);
const selectedNodeId = 'start_0';
const selectedNode = document.getNode(selectedNodeId)!;
selectService.selectNode(selectedNode);
const { nodeLevel, topLevel } = stackingComputing.compute({
root: document.root,
nodes: stackingContextManager.nodes,
context: stackingContextManager.context,
});
const selectedNodeLevel = nodeLevel.get(selectedNodeId);
expect(selectedNodeLevel).toBe(topLevel);
});
});
describe('StackingComputing builtin methods', () => {
it('computeNodeIndexesMap', () => {
const nodeIndexes = stackingComputing.computeNodeIndexesMap(stackingContextManager.nodes);
expect(Object.fromEntries(nodeIndexes)).toEqual({
root: 0,
start_0: 1,
condition_0: 2,
end_0: 3,
loop_0: 4,
break_0: 5,
variable_0: 6,
});
});
it('computeTopLevel', () => {
const topLevel = stackingComputing.computeTopLevel(stackingContextManager.nodes);
expect(topLevel).toEqual(8);
});
});

228
packages/plugins/free-container-plugin/__tests__/manager.test.ts
View File

@ -1,228 +0,0 @@
import { it, expect, beforeEach, describe, vi } from 'vitest';
import { debounce } from 'lodash';
import { interfaces } from 'inversify';
import {
delay,
WorkflowDocument,
WorkflowHoverService,
WorkflowSelectService,
} from '@flowgram.ai/free-layout-core';
import { FlowNodeRenderData } from '@flowgram.ai/document';
import {
EntityManager,
PipelineRegistry,
PipelineRenderer,
PlaygroundConfigEntity,
} from '@flowgram.ai/core';
import { StackingContextManager } from '../src/manager';
import { StackingComputeMode } from '../src/constant';
import { createWorkflowContainer, workflowJSON } from './utils.mock';
import { IStackingContextManager } from './type.mock';
let container: interfaces.Container;
let document: WorkflowDocument;
let stackingContextManager: IStackingContextManager;
beforeEach(async () => {
container = createWorkflowContainer();
container.bind(StackingContextManager).to(StackingContextManager);
document = container.get<WorkflowDocument>(WorkflowDocument);
stackingContextManager = container.get<StackingContextManager>(
StackingContextManager
) as unknown as IStackingContextManager;
await document.fromJSON(workflowJSON);
});
describe('StackingContextManager public methods', () => {
it('should create instance', () => {
const stackingContextManager = container.get<StackingContextManager>(StackingContextManager);
expect(stackingContextManager.node).toMatchInlineSnapshot(`
<div
class="gedit-playground-layer gedit-flow-render-layer"
/>
`);
expect(stackingContextManager).not.toBeUndefined();
});
it('should execute init', () => {
stackingContextManager.init();
const pipelineRenderer = container.get<PipelineRenderer>(PipelineRenderer);
expect(pipelineRenderer.node).toMatchInlineSnapshot(
`
<div
class="gedit-playground-pipeline"
>
<div
class="gedit-playground-layer gedit-flow-render-layer"
/>
</div>
`
);
expect(stackingContextManager.mode).toEqual(StackingComputeMode.Stacking);
expect(stackingContextManager.disposers).toHaveLength(4);
});
it('should init with mode', () => {
stackingContextManager.init(StackingComputeMode.Stacking);
expect(stackingContextManager.mode).toEqual(StackingComputeMode.Stacking);
});
it('should execute ready', () => {
stackingContextManager.compute = vi.fn();
stackingContextManager.ready();
expect(stackingContextManager.compute).toBeCalled();
});
it('should dispose', () => {
expect(stackingContextManager.disposers).toHaveLength(0);
stackingContextManager.init();
expect(stackingContextManager.disposers).toHaveLength(4);
const mockDispose = { dispose: vi.fn() };
stackingContextManager.disposers.push(mockDispose);
stackingContextManager.dispose();
expect(mockDispose.dispose).toBeCalled();
});
});
describe('StackingContextManager private methods', () => {
it('should compute with debounce', async () => {
const compute = vi.fn();
vi.spyOn(stackingContextManager, 'compute').mockImplementation(debounce(compute, 10));
stackingContextManager.compute();
await delay(1);
stackingContextManager.compute();
await delay(1);
stackingContextManager.compute();
await delay(1);
stackingContextManager.compute();
expect(compute).toBeCalledTimes(0);
await delay(20);
expect(compute).toBeCalledTimes(1);
});
it('should get nodes and lines', async () => {
const nodeIds = stackingContextManager.nodes.map((n) => n.id);
const lineIds = stackingContextManager.lines.map((l) => l.id);
expect(nodeIds).toEqual([
'root',
'start_0',
'condition_0',
'end_0',
'loop_0',
'break_0',
'variable_0',
]);
expect(lineIds).toEqual([
'break_0_-variable_0_',
'start_0_-condition_0_',
'condition_0_if-end_0_',
'condition_0_else-end_0_',
'loop_0_-end_0_',
'start_0_-loop_0_',
]);
});
it('should generate context', async () => {
const hoverService = container.get<WorkflowHoverService>(WorkflowHoverService);
const selectService = container.get<WorkflowSelectService>(WorkflowSelectService);
expect(stackingContextManager.context).toStrictEqual({
hoveredEntity: undefined,
hoveredEntityID: undefined,
selectedEntities: [],
selectedIDs: [],
});
hoverService.updateHoveredKey('start_0');
const breakNode = document.getNode('break_0')!;
const variableNode = document.getNode('variable_0')!;
selectService.selection = [breakNode, variableNode];
expect(stackingContextManager.context.hoveredEntityID).toEqual('start_0');
expect(stackingContextManager.context.selectedIDs).toEqual(['break_0', 'variable_0']);
});
it('should callback compute when onZoom trigger', () => {
const entityManager = container.get<EntityManager>(EntityManager);
const pipelineRegistry = container.get<PipelineRegistry>(PipelineRegistry);
const compute = vi.spyOn(stackingContextManager, 'compute').mockImplementation(() => {});
const playgroundConfig =
entityManager.getEntity<PlaygroundConfigEntity>(PlaygroundConfigEntity)!;
pipelineRegistry.ready();
stackingContextManager.mountListener();
playgroundConfig.updateConfig({
zoom: 1.5,
});
expect(stackingContextManager.node.style.transform).toBe('scale(1.5)');
playgroundConfig.updateConfig({
zoom: 2,
});
expect(stackingContextManager.node.style.transform).toBe('scale(2)');
playgroundConfig.updateConfig({
zoom: 1,
});
expect(stackingContextManager.node.style.transform).toBe('scale(1)');
expect(compute).toBeCalledTimes(3);
});
it('should callback compute when onHover trigger', () => {
const hoverService = container.get<WorkflowHoverService>(WorkflowHoverService);
const compute = vi.spyOn(stackingContextManager, 'compute').mockImplementation(() => {});
stackingContextManager.mountListener();
hoverService.updateHoveredKey('start_0');
hoverService.updateHoveredKey('end_0');
expect(compute).toBeCalledTimes(2);
});
it('should callback compute when onEntityChange trigger', () => {
const entityManager = container.get<EntityManager>(EntityManager);
const compute = vi.spyOn(stackingContextManager, 'compute').mockImplementation(() => {});
const node = document.getNode('start_0')!;
stackingContextManager.mountListener();
entityManager.fireEntityChanged(node);
expect(compute).toBeCalledTimes(1);
});
it('should callback compute when onSelect trigger', () => {
const selectService = container.get<WorkflowSelectService>(WorkflowSelectService);
const compute = vi.spyOn(stackingContextManager, 'compute').mockImplementation(() => {});
stackingContextManager.mountListener();
const breakNode = document.getNode('break_0')!;
const variableNode = document.getNode('variable_0')!;
selectService.selectNode(breakNode);
selectService.selectNode(variableNode);
expect(compute).toBeCalledTimes(2);
});
it('should mount listeners', () => {
const hoverService = container.get<WorkflowHoverService>(WorkflowHoverService);
const selectService = container.get<WorkflowSelectService>(WorkflowSelectService);
const compute = vi.spyOn(stackingContextManager, 'compute').mockImplementation(() => {});
stackingContextManager.mountListener();
// onHover
hoverService.updateHoveredKey('start_0');
hoverService.updateHoveredKey('end_0');
expect(compute).toBeCalledTimes(2);
compute.mockReset();
// select callback
const breakNode = document.getNode('break_0')!;
const variableNode = document.getNode('variable_0')!;
selectService.selectNode(breakNode);
selectService.selectNode(variableNode);
expect(compute).toBeCalledTimes(2);
});
it('should trigger compute in layers mode', async () => {
stackingContextManager.init(StackingComputeMode.Layers);
stackingContextManager.ready();
await delay(200);
const node = document.getNode('loop_0')!;
const nodeRenderData = node.getData<FlowNodeRenderData>(FlowNodeRenderData);
const element = nodeRenderData.node;
expect(element.style.zIndex).toBe('9');
});
it('should trigger compute in stacking mode', async () => {
stackingContextManager.init(StackingComputeMode.Stacking);
stackingContextManager.ready();
await delay(200);
const node = document.getNode('loop_0')!;
const nodeRenderData = node.getData<FlowNodeRenderData>(FlowNodeRenderData);
const element = nodeRenderData.node;
expect(element.style.zIndex).toBe('12');
});
});

65
packages/plugins/free-container-plugin/__tests__/type.mock.ts
View File

@ -1,65 +0,0 @@
import type { Disposable } from '@flowgram.ai/utils';
import type {
WorkflowDocument,
WorkflowHoverService,
WorkflowLineEntity,
WorkflowNodeEntity,
WorkflowSelectService,
} from '@flowgram.ai/free-layout-core';
import type { EntityManager, PipelineRegistry, PipelineRenderer } from '@flowgram.ai/core';
import type { StackingContext } from '../src/type';
import type { StackingComputeMode } from '../src/constant';
/** mock类型便于测试内部方法 */
export interface IStackingContextManager {
document: WorkflowDocument;
entityManager: EntityManager;
pipelineRenderer: PipelineRenderer;
pipelineRegistry: PipelineRegistry;
hoverService: WorkflowHoverService;
selectService: WorkflowSelectService;
node: HTMLDivElement;
disposers: Disposable[];
mode: StackingComputeMode;
init(mode?: StackingComputeMode): void;
ready(): void;
dispose(): void;
compute(): void;
_compute(): void;
stackingCompute(): void;
nodes: WorkflowNodeEntity[];
lines: WorkflowLineEntity[];
context: StackingContext;
mountListener(): void;
onZoom(): Disposable;
onHover(): Disposable;
onEntityChange(): Disposable;
onSelect(): Disposable;
}
export interface IStackingComputing {
currentLevel: number;
topLevel: number;
maxLevel: number;
nodeIndexes: Map<string, number>;
nodeLevel: Map<string, number>;
lineLevel: Map<string, number>;
context: StackingContext;
compute(params: {
root: WorkflowNodeEntity;
nodes: WorkflowNodeEntity[];
context: StackingContext;
}): {
nodeLevel: Map<string, number>;
lineLevel: Map<string, number>;
topLevel: number;
maxLevel: number;
};
clearCache(): void;
computeNodeIndexesMap(nodes: WorkflowNodeEntity[]): Map<string, number>;
computeTopLevel(nodes: WorkflowNodeEntity[]): number;
layerHandler(nodes: WorkflowNodeEntity[], pinTop?: boolean): void;
getLevel(pinTop: boolean): number;
levelIncrease(): void;
}

123
packages/plugins/free-container-plugin/__tests__/utils.mock.ts
View File

@ -1,123 +0,0 @@
import { interfaces } from 'inversify';
import {
WorkflowJSON,
WorkflowDocumentContainerModule,
WorkflowLinesManager,
WorkflowSimpleLineContribution,
} from '@flowgram.ai/free-layout-core';
import { FlowDocumentContainerModule } from '@flowgram.ai/document';
import { PlaygroundMockTools } from '@flowgram.ai/core';
export function createWorkflowContainer(): interfaces.Container {
const container = PlaygroundMockTools.createContainer([
FlowDocumentContainerModule,
WorkflowDocumentContainerModule,
]);
const linesManager = container.get(WorkflowLinesManager);
linesManager.registerContribution(WorkflowSimpleLineContribution);
linesManager.switchLineType(WorkflowSimpleLineContribution.type);
return container;
}
export const workflowJSON: WorkflowJSON = {
nodes: [
{
id: 'start_0',
type: 'start',
meta: {
position: { x: 0, y: 0 },
testRun: {
showError: undefined,
},
},
data: undefined,
},
{
id: 'condition_0',
type: 'condition',
meta: {
position: { x: 400, y: 0 },
testRun: {
showError: undefined,
},
},
data: undefined,
},
{
id: 'end_0',
type: 'end',
meta: {
position: { x: 800, y: 0 },
testRun: {
showError: undefined,
},
},
data: undefined,
},
{
id: 'loop_0',
type: 'loop',
meta: {
position: { x: 1200, y: 0 },
testRun: {
showError: undefined,
},
},
data: undefined,
blocks: [
{
id: 'break_0',
type: 'break',
meta: {
position: { x: 0, y: 0 },
testRun: {
showError: undefined,
},
},
data: undefined,
},
{
id: 'variable_0',
type: 'variable',
meta: {
position: { x: 400, y: 0 },
testRun: {
showError: undefined,
},
},
data: undefined,
},
],
edges: [
{
sourceNodeID: 'break_0',
targetNodeID: 'variable_0',
},
],
},
],
edges: [
{
sourceNodeID: 'start_0',
targetNodeID: 'condition_0',
},
{
sourceNodeID: 'condition_0',
sourcePortID: 'if',
targetNodeID: 'end_0',
},
{
sourceNodeID: 'condition_0',
sourcePortID: 'else',
targetNodeID: 'end_0',
},
{
sourceNodeID: 'loop_0',
targetNodeID: 'end_0',
},
{
sourceNodeID: 'start_0',
targetNodeID: 'loop_0',
},
],
};

2
packages/plugins/free-container-plugin/package.json
View File

@ -20,7 +20,7 @@
"build:watch": "npm run build:fast -- --dts-resolve",
"clean": "rimraf dist",
"test": "vitest run",
"test:cov": "vitest run --coverage",
"test:cov": "exit 0",
"ts-check": "tsc --noEmit",
"watch": "npm run build:fast -- --dts-resolve --watch --ignore-watch dist"
},