mirror of
https://github.com/GNS3/gns3-web-ui.git
synced 2025-05-09 20:12:53 +00:00
547 lines
21 KiB
TypeScript
547 lines
21 KiB
TypeScript
import { async, ComponentFixture, TestBed, fakeAsync, tick } from '@angular/core/testing';
|
|
|
|
import { DraggableSelectionComponent } from './draggable-selection.component';
|
|
import { NodesWidget } from '../../widgets/nodes';
|
|
import { DrawingsWidget } from '../../widgets/drawings';
|
|
import { LinksWidget } from '../../widgets/links';
|
|
import { LabelWidget } from '../../widgets/label';
|
|
import { InterfaceLabelWidget } from '../../widgets/interface-label';
|
|
import { SelectionManager } from '../../managers/selection-manager';
|
|
import { SelectionManagerMock } from '../../managers/selection-manager.spec';
|
|
import { NodesEventSource } from '../../events/nodes-event-source';
|
|
import { DrawingsEventSource } from '../../events/drawings-event-source';
|
|
import { GraphDataManager } from '../../managers/graph-data-manager';
|
|
import { MockedGraphDataManager } from '../../managers/graph-data-manager.spec';
|
|
import { LinksEventSource } from '../../events/links-event-source';
|
|
import { DraggableStart, DraggableDrag, DraggableEnd } from '../../events/draggable';
|
|
import { MapNode } from '../../models/map/map-node';
|
|
import { EventEmitter } from '@angular/core';
|
|
import { MapDrawing } from '../../models/map/map-drawing';
|
|
import { MapLabel } from '../../models/map/map-label';
|
|
import { MapLinkNode } from '../../models/map/map-link-node';
|
|
import { select } from 'd3-selection';
|
|
import { MapLink } from '../../models/map/map-link';
|
|
|
|
describe('DraggableSelectionComponent', () => {
|
|
let component: DraggableSelectionComponent;
|
|
let fixture: ComponentFixture<DraggableSelectionComponent>;
|
|
let mockedGraphDataManager: MockedGraphDataManager;
|
|
let nodesStartEventEmitter: EventEmitter<DraggableStart<MapNode>>;
|
|
let nodesDragEventEmitter: EventEmitter<DraggableDrag<MapNode>>;
|
|
let nodesEndEventEmitter: EventEmitter<DraggableEnd<MapNode>>;
|
|
|
|
let drawingsStartEventEmitter: EventEmitter<DraggableStart<MapDrawing>>;
|
|
let drawingsDragEventEmitter: EventEmitter<DraggableDrag<MapDrawing>>;
|
|
let drawingsEndEventEmitter: EventEmitter<DraggableEnd<MapDrawing>>;
|
|
|
|
let labelStartEventEmitter: EventEmitter<DraggableStart<MapLabel>>;
|
|
let labelDragEventEmitter: EventEmitter<DraggableDrag<MapLabel>>;
|
|
let labelEndEventEmitter: EventEmitter<DraggableEnd<MapLabel>>;
|
|
|
|
let interfaceLabelStartEventEmitter: EventEmitter<DraggableStart<MapLinkNode>>;
|
|
let interfaceLabelDragEventEmitter: EventEmitter<DraggableDrag<MapLinkNode>>;
|
|
let interfaceLabelEndEventEmitter: EventEmitter<DraggableEnd<MapLinkNode>>;
|
|
|
|
beforeEach(async(() => {
|
|
mockedGraphDataManager = new MockedGraphDataManager();
|
|
|
|
nodesStartEventEmitter = new EventEmitter<DraggableStart<MapNode>>();
|
|
nodesDragEventEmitter = new EventEmitter<DraggableDrag<MapNode>>();
|
|
nodesEndEventEmitter = new EventEmitter<DraggableEnd<MapNode>>();
|
|
|
|
drawingsStartEventEmitter = new EventEmitter<DraggableStart<MapDrawing>>();
|
|
drawingsDragEventEmitter = new EventEmitter<DraggableDrag<MapDrawing>>();
|
|
drawingsEndEventEmitter = new EventEmitter<DraggableEnd<MapDrawing>>();
|
|
|
|
labelStartEventEmitter = new EventEmitter<DraggableStart<MapLabel>>();
|
|
labelDragEventEmitter = new EventEmitter<DraggableDrag<MapLabel>>();
|
|
labelEndEventEmitter = new EventEmitter<DraggableEnd<MapLabel>>();
|
|
|
|
interfaceLabelStartEventEmitter = new EventEmitter<DraggableStart<MapLinkNode>>();
|
|
interfaceLabelDragEventEmitter = new EventEmitter<DraggableDrag<MapLinkNode>>();
|
|
interfaceLabelEndEventEmitter = new EventEmitter<DraggableEnd<MapLinkNode>>();
|
|
|
|
const nodesWidgetStub = {
|
|
redrawNode: () => {},
|
|
draggable: {
|
|
start: nodesStartEventEmitter,
|
|
drag: nodesDragEventEmitter,
|
|
end: nodesEndEventEmitter
|
|
}
|
|
};
|
|
|
|
const drawingsWidgetStub = {
|
|
redrawDrawing: () => {},
|
|
draggable: {
|
|
start: drawingsStartEventEmitter,
|
|
drag: drawingsDragEventEmitter,
|
|
end: drawingsEndEventEmitter
|
|
}
|
|
};
|
|
const linksWidgetStub = {
|
|
redrawLink: () => {}
|
|
};
|
|
|
|
const labelWidgetStub = {
|
|
redrawLabel: () => {},
|
|
draggable: {
|
|
start: labelStartEventEmitter,
|
|
drag: labelDragEventEmitter,
|
|
end: labelEndEventEmitter
|
|
}
|
|
};
|
|
|
|
const interfaceLabelWidgetStub = {
|
|
draggable: {
|
|
start: interfaceLabelStartEventEmitter,
|
|
drag: interfaceLabelDragEventEmitter,
|
|
end: interfaceLabelEndEventEmitter
|
|
}
|
|
};
|
|
|
|
const nodesEventSourceStub = {
|
|
dragged: { emit: () => {} },
|
|
labelDragged: { emit: () => {} }
|
|
};
|
|
const drawingsEventSourceStub = {
|
|
dragged: { emit: () => {} }
|
|
};
|
|
const linksEventSourceStub = {
|
|
interfaceDragged: { emit: () => {} }
|
|
};
|
|
|
|
TestBed.configureTestingModule({
|
|
providers: [
|
|
{ provide: NodesWidget, useValue: nodesWidgetStub },
|
|
{ provide: DrawingsWidget, useValue: drawingsWidgetStub },
|
|
{ provide: LinksWidget, useValue: linksWidgetStub },
|
|
{ provide: LabelWidget, useValue: labelWidgetStub },
|
|
{ provide: InterfaceLabelWidget, useValue: interfaceLabelWidgetStub },
|
|
{ provide: SelectionManager, useValue: new SelectionManagerMock() },
|
|
{ provide: NodesEventSource, useValue: nodesEventSourceStub },
|
|
{ provide: DrawingsEventSource, useValue: drawingsEventSourceStub },
|
|
{ provide: GraphDataManager, useValue: mockedGraphDataManager },
|
|
{ provide: LinksEventSource, useValue: linksEventSourceStub }
|
|
],
|
|
declarations: [DraggableSelectionComponent]
|
|
}).compileComponents();
|
|
}));
|
|
|
|
beforeEach(() => {
|
|
fixture = TestBed.createComponent(DraggableSelectionComponent);
|
|
component = fixture.componentInstance;
|
|
component.svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
|
|
fixture.detectChanges();
|
|
});
|
|
|
|
it('should create', () => {
|
|
expect(component).toBeTruthy();
|
|
});
|
|
|
|
describe('nodes dragging', () => {
|
|
let nodesWidgetStub: NodesWidget;
|
|
let linksWidgetStub: LinksWidget;
|
|
let selectionManagerStub: SelectionManager;
|
|
let node: MapNode;
|
|
|
|
beforeEach(() => {
|
|
nodesWidgetStub = fixture.debugElement.injector.get(NodesWidget);
|
|
linksWidgetStub = fixture.debugElement.injector.get(LinksWidget);
|
|
selectionManagerStub = fixture.debugElement.injector.get(SelectionManager);
|
|
node = new MapNode();
|
|
node.id = 'nodeid';
|
|
node.x = 1;
|
|
node.y = 2;
|
|
});
|
|
|
|
it('should select node when started dragging', fakeAsync(() => {
|
|
nodesWidgetStub.draggable.start.emit(new DraggableStart<MapNode>(node));
|
|
tick();
|
|
expect(selectionManagerStub.getSelected().length).toEqual(1);
|
|
}));
|
|
|
|
it('should ignore node when started dragging and node is in selection', fakeAsync(() => {
|
|
selectionManagerStub.setSelected([node]);
|
|
nodesWidgetStub.draggable.start.emit(new DraggableStart<MapNode>(node));
|
|
tick();
|
|
expect(selectionManagerStub.getSelected().length).toEqual(1);
|
|
}));
|
|
|
|
it('should update node position when dragging', fakeAsync(() => {
|
|
spyOn(nodesWidgetStub, 'redrawNode');
|
|
selectionManagerStub.setSelected([node]);
|
|
|
|
const dragEvent = new DraggableDrag<MapNode>(node);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
nodesWidgetStub.draggable.drag.emit(dragEvent);
|
|
tick();
|
|
expect(nodesWidgetStub.redrawNode).toHaveBeenCalledWith(select(fixture.componentInstance.svg), node);
|
|
expect(node.x).toEqual(11);
|
|
expect(node.y).toEqual(22);
|
|
}));
|
|
|
|
it('should redraw related links target when dragging node', fakeAsync(() => {
|
|
spyOn(nodesWidgetStub, 'redrawNode');
|
|
spyOn(linksWidgetStub, 'redrawLink');
|
|
const link = new MapLink();
|
|
link.target = node;
|
|
mockedGraphDataManager.setLinks([link]);
|
|
selectionManagerStub.setSelected([node]);
|
|
nodesWidgetStub.draggable.drag.emit(new DraggableDrag<MapNode>(node));
|
|
|
|
tick();
|
|
expect(linksWidgetStub.redrawLink).toHaveBeenCalledWith(select(fixture.componentInstance.svg), link);
|
|
}));
|
|
|
|
it('should redraw related links source when dragging node', fakeAsync(() => {
|
|
spyOn(nodesWidgetStub, 'redrawNode');
|
|
spyOn(linksWidgetStub, 'redrawLink');
|
|
const link = new MapLink();
|
|
link.source = node;
|
|
mockedGraphDataManager.setLinks([link]);
|
|
selectionManagerStub.setSelected([node]);
|
|
nodesWidgetStub.draggable.drag.emit(new DraggableDrag<MapNode>(node));
|
|
|
|
tick();
|
|
expect(linksWidgetStub.redrawLink).toHaveBeenCalledWith(select(fixture.componentInstance.svg), link);
|
|
}));
|
|
|
|
it('should emit event when node stopped dragging', fakeAsync(() => {
|
|
const nodesEventSourceStub = fixture.debugElement.injector.get(NodesEventSource);
|
|
const spyDragged = spyOn(nodesEventSourceStub.dragged, 'emit');
|
|
|
|
selectionManagerStub.setSelected([node]);
|
|
const dragEvent = new DraggableEnd<MapNode>(node);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
nodesWidgetStub.draggable.end.emit(dragEvent);
|
|
tick();
|
|
expect(nodesEventSourceStub.dragged.emit).toHaveBeenCalled();
|
|
expect(spyDragged.calls.mostRecent().args[0].datum).toEqual(node);
|
|
expect(spyDragged.calls.mostRecent().args[0].dx).toEqual(10);
|
|
expect(spyDragged.calls.mostRecent().args[0].dy).toEqual(20);
|
|
}));
|
|
});
|
|
|
|
describe('drawings dragging', () => {
|
|
let drawingsWidgetStub: DrawingsWidget;
|
|
let selectionManagerStub: SelectionManager;
|
|
let drawing: MapDrawing;
|
|
|
|
beforeEach(() => {
|
|
drawingsWidgetStub = fixture.debugElement.injector.get(DrawingsWidget);
|
|
selectionManagerStub = fixture.debugElement.injector.get(SelectionManager);
|
|
drawing = new MapDrawing();
|
|
drawing.id = 'drawingid';
|
|
drawing.x = 1;
|
|
drawing.y = 2;
|
|
});
|
|
|
|
it('should select drawing when started dragging', fakeAsync(() => {
|
|
drawingsWidgetStub.draggable.start.emit(new DraggableStart<MapDrawing>(drawing));
|
|
tick();
|
|
expect(selectionManagerStub.getSelected().length).toEqual(1);
|
|
}));
|
|
|
|
it('should ignore drawing when started dragging and node is in selection', fakeAsync(() => {
|
|
selectionManagerStub.setSelected([drawing]);
|
|
drawingsWidgetStub.draggable.start.emit(new DraggableStart<MapDrawing>(drawing));
|
|
tick();
|
|
expect(selectionManagerStub.getSelected().length).toEqual(1);
|
|
}));
|
|
|
|
it('should update drawing position when dragging', fakeAsync(() => {
|
|
spyOn(drawingsWidgetStub, 'redrawDrawing');
|
|
selectionManagerStub.setSelected([drawing]);
|
|
|
|
const dragEvent = new DraggableDrag<MapDrawing>(drawing);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
drawingsWidgetStub.draggable.drag.emit(dragEvent);
|
|
tick();
|
|
expect(drawingsWidgetStub.redrawDrawing).toHaveBeenCalledWith(select(fixture.componentInstance.svg), drawing);
|
|
expect(drawing.x).toEqual(11);
|
|
expect(drawing.y).toEqual(22);
|
|
}));
|
|
|
|
it('should emit event when drawing stopped dragging', fakeAsync(() => {
|
|
const drawingsEventSourceStub = fixture.debugElement.injector.get(DrawingsEventSource);
|
|
const spyDragged = spyOn(drawingsEventSourceStub.dragged, 'emit');
|
|
|
|
selectionManagerStub.setSelected([drawing]);
|
|
const dragEvent = new DraggableEnd<MapDrawing>(drawing);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
drawingsWidgetStub.draggable.end.emit(dragEvent);
|
|
tick();
|
|
expect(drawingsEventSourceStub.dragged.emit).toHaveBeenCalled();
|
|
expect(spyDragged.calls.mostRecent().args[0].datum).toEqual(drawing);
|
|
expect(spyDragged.calls.mostRecent().args[0].dx).toEqual(10);
|
|
expect(spyDragged.calls.mostRecent().args[0].dy).toEqual(20);
|
|
}));
|
|
});
|
|
|
|
describe('labels dragging', () => {
|
|
let labelWidgetStub: LabelWidget;
|
|
let selectionManagerStub: SelectionManager;
|
|
let label: MapLabel;
|
|
|
|
beforeEach(() => {
|
|
labelWidgetStub = fixture.debugElement.injector.get(LabelWidget);
|
|
selectionManagerStub = fixture.debugElement.injector.get(SelectionManager);
|
|
label = new MapLabel();
|
|
label.id = 'labelid';
|
|
label.x = 1;
|
|
label.y = 2;
|
|
});
|
|
|
|
it('should select label when started dragging', fakeAsync(() => {
|
|
labelWidgetStub.draggable.start.emit(new DraggableStart<MapLabel>(label));
|
|
tick();
|
|
expect(selectionManagerStub.getSelected().length).toEqual(1);
|
|
}));
|
|
|
|
it('should ignore label when started dragging and node is in selection', fakeAsync(() => {
|
|
selectionManagerStub.setSelected([label]);
|
|
labelWidgetStub.draggable.start.emit(new DraggableStart<MapLabel>(label));
|
|
tick();
|
|
expect(selectionManagerStub.getSelected().length).toEqual(1);
|
|
}));
|
|
|
|
it('should update label position when dragging', fakeAsync(() => {
|
|
spyOn(labelWidgetStub, 'redrawLabel');
|
|
selectionManagerStub.setSelected([label]);
|
|
const node = new MapNode();
|
|
node.id = 'nodeid';
|
|
node.label = label;
|
|
label.nodeId = node.id;
|
|
|
|
mockedGraphDataManager.setNodes([node]);
|
|
|
|
const dragEvent = new DraggableDrag<MapLabel>(label);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
labelWidgetStub.draggable.drag.emit(dragEvent);
|
|
tick();
|
|
expect(labelWidgetStub.redrawLabel).toHaveBeenCalledWith(select(fixture.componentInstance.svg), label);
|
|
expect(label.x).toEqual(11);
|
|
expect(label.y).toEqual(22);
|
|
}));
|
|
|
|
it('should not update label position when dragging and parent is selected', fakeAsync(() => {
|
|
spyOn(labelWidgetStub, 'redrawLabel');
|
|
const node = new MapNode();
|
|
node.id = 'nodeid';
|
|
node.label = label;
|
|
label.nodeId = node.id;
|
|
|
|
selectionManagerStub.setSelected([label, node]);
|
|
mockedGraphDataManager.setNodes([node]);
|
|
|
|
const dragEvent = new DraggableDrag<MapLabel>(label);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
labelWidgetStub.draggable.drag.emit(dragEvent);
|
|
tick();
|
|
expect(labelWidgetStub.redrawLabel).not.toHaveBeenCalled();
|
|
expect(label.x).toEqual(1);
|
|
expect(label.y).toEqual(2);
|
|
}));
|
|
|
|
it('should emit event when label stopped dragging', fakeAsync(() => {
|
|
const nodesEventSourceStub = fixture.debugElement.injector.get(NodesEventSource);
|
|
const spyDragged = spyOn(nodesEventSourceStub.labelDragged, 'emit');
|
|
|
|
selectionManagerStub.setSelected([label]);
|
|
const dragEvent = new DraggableEnd<MapLabel>(label);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
labelWidgetStub.draggable.end.emit(dragEvent);
|
|
tick();
|
|
expect(nodesEventSourceStub.labelDragged.emit).toHaveBeenCalled();
|
|
expect(spyDragged.calls.mostRecent().args[0].datum).toEqual(label);
|
|
expect(spyDragged.calls.mostRecent().args[0].dx).toEqual(10);
|
|
expect(spyDragged.calls.mostRecent().args[0].dy).toEqual(20);
|
|
}));
|
|
|
|
it('should not emit event when label stopped dragging and parent node is selected', fakeAsync(() => {
|
|
const nodesEventSourceStub = fixture.debugElement.injector.get(NodesEventSource);
|
|
spyOn(nodesEventSourceStub.labelDragged, 'emit');
|
|
const node = new MapNode();
|
|
node.id = 'nodeid';
|
|
label.nodeId = node.id;
|
|
|
|
selectionManagerStub.setSelected([label, node]);
|
|
const dragEvent = new DraggableEnd<MapLabel>(label);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
labelWidgetStub.draggable.end.emit(dragEvent);
|
|
tick();
|
|
expect(nodesEventSourceStub.labelDragged.emit).not.toHaveBeenCalled();
|
|
}));
|
|
});
|
|
|
|
describe('interfaces labels dragging', () => {
|
|
let linksWidgetStub: LinksWidget;
|
|
let interfaceLabelWidgetStub: InterfaceLabelWidget;
|
|
let selectionManagerStub: SelectionManager;
|
|
let linkNode: MapLinkNode;
|
|
|
|
beforeEach(() => {
|
|
interfaceLabelWidgetStub = fixture.debugElement.injector.get(InterfaceLabelWidget);
|
|
linksWidgetStub = fixture.debugElement.injector.get(LinksWidget);
|
|
selectionManagerStub = fixture.debugElement.injector.get(SelectionManager);
|
|
linkNode = new MapLinkNode();
|
|
linkNode.label = new MapLabel();
|
|
linkNode.label.x = 1;
|
|
linkNode.label.y = 2;
|
|
linkNode.id = 'linknodeid';
|
|
});
|
|
|
|
it('should select interface label when started dragging', fakeAsync(() => {
|
|
interfaceLabelWidgetStub.draggable.start.emit(new DraggableStart<MapLinkNode>(linkNode));
|
|
tick();
|
|
expect(selectionManagerStub.getSelected().length).toEqual(1);
|
|
}));
|
|
|
|
it('should ignore interface label when started dragging and node is in selection', fakeAsync(() => {
|
|
selectionManagerStub.setSelected([linkNode]);
|
|
interfaceLabelWidgetStub.draggable.start.emit(new DraggableStart<MapLinkNode>(linkNode));
|
|
tick();
|
|
expect(selectionManagerStub.getSelected().length).toEqual(1);
|
|
}));
|
|
|
|
it('should update interface label position when dragging first node', fakeAsync(() => {
|
|
spyOn(linksWidgetStub, 'redrawLink');
|
|
selectionManagerStub.setSelected([linkNode]);
|
|
const node = new MapNode();
|
|
node.id = 'nodeid';
|
|
linkNode.nodeId = node.id;
|
|
|
|
const secondLinkNode = new MapLinkNode();
|
|
secondLinkNode.label = new MapLabel();
|
|
secondLinkNode.label.x = 1;
|
|
secondLinkNode.label.y = 2;
|
|
secondLinkNode.id = 'secondlinknodeid';
|
|
|
|
const link = new MapLink();
|
|
link.nodes = [linkNode, secondLinkNode];
|
|
|
|
mockedGraphDataManager.setLinks([link]);
|
|
|
|
const dragEvent = new DraggableDrag<MapLinkNode>(linkNode);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
interfaceLabelWidgetStub.draggable.drag.emit(dragEvent);
|
|
tick();
|
|
expect(linksWidgetStub.redrawLink).toHaveBeenCalledWith(select(fixture.componentInstance.svg), link);
|
|
expect(linkNode.label.x).toEqual(11);
|
|
expect(linkNode.label.y).toEqual(22);
|
|
}));
|
|
|
|
it('should update interface label position when dragging second node', fakeAsync(() => {
|
|
spyOn(linksWidgetStub, 'redrawLink');
|
|
selectionManagerStub.setSelected([linkNode]);
|
|
const node = new MapNode();
|
|
node.id = 'nodeid';
|
|
linkNode.nodeId = node.id;
|
|
|
|
const secondLinkNode = new MapLinkNode();
|
|
secondLinkNode.label = new MapLabel();
|
|
secondLinkNode.label.x = 1;
|
|
secondLinkNode.label.y = 2;
|
|
secondLinkNode.id = 'secondlinknodeid';
|
|
|
|
const link = new MapLink();
|
|
link.nodes = [secondLinkNode, linkNode];
|
|
|
|
mockedGraphDataManager.setLinks([link]);
|
|
|
|
const dragEvent = new DraggableDrag<MapLinkNode>(linkNode);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
interfaceLabelWidgetStub.draggable.drag.emit(dragEvent);
|
|
tick();
|
|
expect(linksWidgetStub.redrawLink).toHaveBeenCalledWith(select(fixture.componentInstance.svg), link);
|
|
expect(linkNode.label.x).toEqual(11);
|
|
expect(linkNode.label.y).toEqual(22);
|
|
}));
|
|
|
|
it('should not update interface label position when dragging and parent node is selected', fakeAsync(() => {
|
|
spyOn(linksWidgetStub, 'redrawLink');
|
|
const node = new MapNode();
|
|
node.id = 'nodeid';
|
|
linkNode.nodeId = node.id;
|
|
|
|
selectionManagerStub.setSelected([linkNode, node]);
|
|
|
|
const secondLinkNode = new MapLinkNode();
|
|
secondLinkNode.label = new MapLabel();
|
|
secondLinkNode.label.x = 1;
|
|
secondLinkNode.label.y = 2;
|
|
secondLinkNode.id = 'secondlinknodeid';
|
|
|
|
const link = new MapLink();
|
|
link.nodes = [linkNode, secondLinkNode];
|
|
|
|
mockedGraphDataManager.setLinks([link]);
|
|
|
|
const dragEvent = new DraggableDrag<MapLinkNode>(linkNode);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
interfaceLabelWidgetStub.draggable.drag.emit(dragEvent);
|
|
tick();
|
|
expect(linksWidgetStub.redrawLink).not.toHaveBeenCalled();
|
|
expect(linkNode.label.x).toEqual(1);
|
|
expect(linkNode.label.y).toEqual(2);
|
|
}));
|
|
|
|
it('should emit event when interface label stopped dragging', fakeAsync(() => {
|
|
const linksEventSourceStub = fixture.debugElement.injector.get(LinksEventSource);
|
|
const spyDragged = spyOn(linksEventSourceStub.interfaceDragged, 'emit');
|
|
|
|
selectionManagerStub.setSelected([linkNode]);
|
|
const dragEvent = new DraggableEnd<MapLinkNode>(linkNode);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
interfaceLabelWidgetStub.draggable.end.emit(dragEvent);
|
|
tick();
|
|
expect(linksEventSourceStub.interfaceDragged.emit).toHaveBeenCalled();
|
|
expect(spyDragged.calls.mostRecent().args[0].datum).toEqual(linkNode);
|
|
expect(spyDragged.calls.mostRecent().args[0].dx).toEqual(10);
|
|
expect(spyDragged.calls.mostRecent().args[0].dy).toEqual(20);
|
|
}));
|
|
|
|
it('should not emit event when interface label stopped dragging and parent node is selected', fakeAsync(() => {
|
|
const linksEventSourceStub = fixture.debugElement.injector.get(LinksEventSource);
|
|
spyOn(linksEventSourceStub.interfaceDragged, 'emit');
|
|
|
|
const node = new MapNode();
|
|
node.id = 'nodeid';
|
|
linkNode.nodeId = node.id;
|
|
|
|
selectionManagerStub.setSelected([linkNode, node]);
|
|
const dragEvent = new DraggableEnd<MapLinkNode>(linkNode);
|
|
dragEvent.dx = 10;
|
|
dragEvent.dy = 20;
|
|
|
|
interfaceLabelWidgetStub.draggable.end.emit(dragEvent);
|
|
tick();
|
|
expect(linksEventSourceStub.interfaceDragged.emit).not.toHaveBeenCalled();
|
|
}));
|
|
});
|
|
});
|