Unit tests for extracted components

src/app/components/drawings-listeners/drawing-dragged/drawing-dragged.component.spec.ts

@@ -0,0 +1,65 @@
+import { DrawingDraggedComponent } from "./drawing-dragged.component";
+import { ComponentFixture, async, TestBed } from '@angular/core/testing';
+import { DrawingService } from '../../../services/drawing.service';
+import { MockedDrawingService, MockedDrawingsDataSource } from '../../project-map/project-map.component.spec';
+import { DrawingsDataSource } from '../../../cartography/datasources/drawings-datasource';
+import { DrawingsEventSource } from '../../../cartography/events/drawings-event-source';
+import { MapDrawing } from '../../../cartography/models/map/map-drawing';
+import { DraggedDataEvent } from '../../../cartography/events/event-source';
+import { DrawingElement } from '../../../cartography/models/drawings/drawing-element';
+import { Observable } from 'rxjs';
+
+describe('DrawingDraggedComponent', () => {
+    let component: DrawingDraggedComponent;
+    let fixture: ComponentFixture<DrawingDraggedComponent>;
+    let mockedDrawingService = new MockedDrawingService;
+    let mockedDrawingsDataSource = new MockedDrawingsDataSource;
+    let mockedDrawingsEventSource = new DrawingsEventSource;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            providers: [
+                { provide: DrawingService, useValue: mockedDrawingService },
+                { provide: DrawingsDataSource, useValue: mockedDrawingsDataSource },
+                { provide: DrawingsEventSource, useValue: mockedDrawingsEventSource }
+            ],
+            declarations: [
+                DrawingDraggedComponent
+            ]
+        })
+        .compileComponents();
+    }));
+
+    beforeEach(() => {
+        fixture = TestBed.createComponent(DrawingDraggedComponent);
+        component = fixture.componentInstance;
+    });
+
+    it('should create', () => {
+        expect(component).toBeTruthy();
+    });
+
+    it('should call drawing service when drawing is dragged', () => {
+        fixture.detectChanges();
+        const mapDrawingElement: DrawingElement = {
+            width: 100,
+            height: 100
+        };
+        const mapDrawing: MapDrawing = {
+            id: "sampleId",
+            projectId: "sampleprojectId",
+            rotation: 0,
+            svg: "sampleSvg",
+            x: 0,
+            y: 0,
+            z: 0,
+            element: mapDrawingElement
+        };
+        const drawingDraggedDataEvent = new DraggedDataEvent<MapDrawing>(mapDrawing, 0, 0);
+        spyOn(mockedDrawingService, 'updatePosition').and.returnValue( Observable.of({}));
+
+        mockedDrawingsEventSource.dragged.emit(drawingDraggedDataEvent);
+
+        expect(mockedDrawingService.updatePosition).toHaveBeenCalled();
+    });
+});

src/app/components/drawings-listeners/drawing-resized/drawing-resized.component.spec.ts

@@ -0,0 +1,68 @@
+import { DrawingResizedComponent } from "./drawing-resized.component";
+import { ComponentFixture, TestBed, async } from '@angular/core/testing';
+import { DrawingService } from '../../../services/drawing.service';
+import { MockedDrawingService, MockedDrawingsDataSource } from '../../project-map/project-map.component.spec';
+import { DrawingsDataSource } from '../../../cartography/datasources/drawings-datasource';
+import { DrawingsEventSource } from '../../../cartography/events/drawings-event-source';
+import { MapDrawingToSvgConverter } from '../../../cartography/converters/map/map-drawing-to-svg-converter';
+import { ResizedDataEvent } from '../../../cartography/events/event-source';
+import { MapDrawing } from '../../../cartography/models/map/map-drawing';
+import { DrawingElement } from '../../../cartography/models/drawings/drawing-element';
+import { Observable } from 'rxjs';
+
+describe('DrawingResizedComponent', () => {
+    let component: DrawingResizedComponent;
+    let fixture: ComponentFixture<DrawingResizedComponent>;
+    let mockedDrawingService = new MockedDrawingService;
+    let mockedDrawingsDataSource = new MockedDrawingsDataSource;
+    let mockedDrawingsEventSource = new DrawingsEventSource;
+    let mockedMapDrawingToSvgConverter = new MapDrawingToSvgConverter;
+    
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            providers: [
+                { provide: DrawingService, useValue: mockedDrawingService },
+                { provide: DrawingsDataSource, useValue: mockedDrawingsDataSource },
+                { provide: DrawingsEventSource, useValue: mockedDrawingsEventSource },
+                { provide: MapDrawingToSvgConverter, useValue: mockedMapDrawingToSvgConverter }
+            ],
+            declarations: [
+                DrawingResizedComponent
+            ]
+        })
+        .compileComponents();
+    }));
+
+    beforeEach(() => {
+        fixture = TestBed.createComponent(DrawingResizedComponent);
+        component = fixture.componentInstance;
+    });
+
+    it('should create', () => {
+        expect(component).toBeTruthy();
+    });
+
+    it('should call drawing service when drawing is resized', () => {
+        fixture.detectChanges();
+        const mapDrawingElement: DrawingElement = {
+            width: 100,
+            height: 100
+        };
+        const mapDrawing: MapDrawing = {
+            id: "sampleId",
+            projectId: "sampleprojectId",
+            rotation: 0,
+            svg: "sampleSvg",
+            x: 0,
+            y: 0,
+            z: 0,
+            element: mapDrawingElement
+        };
+        const drawingResizedDataEvent = new ResizedDataEvent<MapDrawing>(mapDrawing, 0, 0, 100, 100);
+        spyOn(mockedDrawingService, 'updateSizeAndPosition').and.returnValue( Observable.of({}));
+
+        mockedDrawingsEventSource.resized.emit(drawingResizedDataEvent);
+
+        expect(mockedDrawingService.updateSizeAndPosition).toHaveBeenCalled();
+    });
+});

src/app/components/drawings-listeners/interface-label-dragged/interface-label-dragged.component.spec.ts

@@ -0,0 +1,83 @@
+import { InterfaceLabelDraggedComponent } from "./interface-label-dragged.component";
+import { ComponentFixture, async, TestBed } from '@angular/core/testing';
+import { MockedLinkService } from '../../project-map/project-map.component.spec';
+import { LinksEventSource } from '../../../cartography/events/links-event-source';
+import { LinkService } from '../../../services/link.service';
+import { LinksDataSource } from '../../../cartography/datasources/links-datasource';
+import { LinkCreatedComponent } from '../link-created/link-created.component';
+import { DraggedDataEvent } from '../../../cartography/events/event-source';
+import { DrawingElement } from '../../../cartography/models/drawings/drawing-element';
+import { MapDrawing } from '../../../cartography/models/map/map-drawing';
+import { MapLinkNode } from '../../../cartography/models/map/map-link-node';
+import { Observable } from 'rxjs';
+import { MapLabel } from '../../../cartography/models/map/map-label';
+import { Link } from '../../../models/link';
+import { Label } from '../../../cartography/models/label';
+
+fdescribe('InterfaceLabelDraggedComponent', () => {
+    let component: InterfaceLabelDraggedComponent;
+    let fixture: ComponentFixture<InterfaceLabelDraggedComponent>;
+    let mockedLinkService = new MockedLinkService;
+    let mockedLinksEventSource = new LinksEventSource;
+    let mockedLinksDataSource = new LinksDataSource;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            providers: [
+                { provide: LinkService, useValue: mockedLinkService },
+                { provide: LinksDataSource, useValue: mockedLinksDataSource },
+                { provide: LinksEventSource, useValue: mockedLinksEventSource }
+            ],
+            declarations: [
+                InterfaceLabelDraggedComponent
+            ]
+        })
+        .compileComponents();
+    }));
+
+    beforeEach(() => {
+        fixture = TestBed.createComponent(InterfaceLabelDraggedComponent);
+        component = fixture.componentInstance;
+    });
+
+    it('should create', () => {
+        expect(component).toBeTruthy();
+    });
+
+    it('should call link service when interface label dragged', () => {
+        fixture.detectChanges();
+        const mapLinkNode: MapLinkNode = {
+            id: 'sampleId',
+            nodeId: 'sampleNodeId',
+            linkId: 'sampleLinkId',
+            adapterNumber: 0,
+            portNumber: 0,
+            label: {} as MapLabel
+        };
+        const interfaceLabelDraggedDataEvent = new DraggedDataEvent<MapLinkNode>(mapLinkNode, 0, 0);
+
+        let link: Link = {} as Link;
+        link.nodes = [
+            { 
+                node_id: "1",
+                adapter_number: 0,
+                port_number: 0,
+                label: {} as Label 
+            },
+            { 
+                node_id: "2",
+                adapter_number: 0,
+                port_number: 0,
+                label: {} as Label 
+            }
+        ];
+        mockedLinksDataSource = TestBed.get(LinksDataSource);
+
+        spyOn(mockedLinksDataSource, 'get').and.returnValue(link);
+        spyOn(mockedLinkService, 'updateNodes').and.returnValue( Observable.of({}));
+
+        mockedLinksEventSource.interfaceDragged.emit(interfaceLabelDraggedDataEvent);
+
+        expect(mockedLinkService.updateNodes).toHaveBeenCalled();
+    });
+});

src/app/components/drawings-listeners/link-created/link-created.component.spec.ts

@@ -0,0 +1,101 @@
+import { LinkCreatedComponent } from "./link-created.component";
+import { ComponentFixture, async, TestBed } from '@angular/core/testing';
+import { ProjectService } from '../../../services/project.service';
+import { MockedProjectService } from '../../../services/project.service.spec';
+import { LinkService } from '../../../services/link.service';
+import { LinksDataSource } from '../../../cartography/datasources/links-datasource';
+import { LinksEventSource } from '../../../cartography/events/links-event-source';
+import { MapNodeToNodeConverter } from '../../../cartography/converters/map/map-node-to-node-converter';
+import { MapPortToPortConverter } from '../../../cartography/converters/map/map-port-to-port-converter';
+import { MockedLinkService } from '../../project-map/project-map.component.spec';
+import { MapLabelToLabelConverter } from '../../../cartography/converters/map/map-label-to-label-converter';
+import { FontBBoxCalculator } from '../../../cartography/helpers/font-bbox-calculator';
+import { CssFixer } from '../../../cartography/helpers/css-fixer';
+import { FontFixer } from '../../../cartography/helpers/font-fixer';
+import { MapLinkCreated } from '../../../cartography/events/links';
+import { MapNode } from '../../../cartography/models/map/map-node';
+import { MapLabel } from '../../../cartography/models/map/map-label';
+import { MapPort } from '../../../cartography/models/map/map-port';
+import { Observable } from 'rxjs';
+import { Project } from '../../../models/project';
+
+describe('LinkCreatedComponent', () => {
+    let component: LinkCreatedComponent;
+    let fixture: ComponentFixture<LinkCreatedComponent>;
+    let mockedLinkService = new MockedLinkService;
+    let mockedMapNodeToNodeConverter: MapNodeToNodeConverter = 
+        new MapNodeToNodeConverter(new MapLabelToLabelConverter(new FontBBoxCalculator, new CssFixer, new FontFixer), new MapPortToPortConverter);
+    let mockedLinksEventSource = new LinksEventSource;
+    let project = new Project();
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            providers: [
+                { provide: ProjectService, useClass: MockedProjectService },
+                { provide: LinkService, useValue: mockedLinkService },
+                { provide: LinksDataSource, useClass: LinksDataSource },
+                { provide: LinksEventSource, useValue: mockedLinksEventSource },
+                { provide: MapNodeToNodeConverter, useValue: mockedMapNodeToNodeConverter },
+                { provide: MapPortToPortConverter, useClass: MapPortToPortConverter }
+            ],
+            declarations: [
+                LinkCreatedComponent
+            ]
+        })
+        .compileComponents();
+    }));
+
+    beforeEach(() => {
+        fixture = TestBed.createComponent(LinkCreatedComponent);
+        component = fixture.componentInstance;
+
+        project.project_id = "sampleId";
+        component.project = project;
+    });
+
+    it('should create', () => {
+        expect(component).toBeTruthy();
+    });
+
+    it('should call link service when link created', () => {
+        fixture.detectChanges();
+        const mapNode: MapNode = {
+            id: 'sampleId',
+            commandLine: 'sampleCommandLine',
+            computeId: 'sampleComputeId',
+            console: 0,
+            consoleHost: 'sampleConsoleHost',
+            consoleType: 'sampleConsoleType',
+            firstPortName: 'sampleFirstPortName',
+            height: 0,
+            label: {} as MapLabel,
+            name: "sampleName",
+            nodeDirectory: "sampleNodeDirectory",
+            nodeType: "sampleNodeType",
+            portNameFormat: "samplePortNameFormat",
+            portSegmentSize: 0,
+            ports: [],
+            projectId: "sampleProjectId",
+            status: "sampleStatus",
+            symbol: "sampleSymbol",
+            symbolUrl: "sampleUrl",
+            width: 0,
+            x: 0,
+            y: 0,
+            z: 0
+        };
+        const mapPort: MapPort = {
+            adapterNumber: 1,
+            linkType: 'sampleLinkType',
+            name: 'sampleName',
+            portNumber: 1,
+            shortName: 'sampleShortName'
+        };
+        const linkCreatedDataEvent = new MapLinkCreated(mapNode, mapPort, mapNode, mapPort);
+        spyOn(mockedLinkService, 'createLink').and.returnValue( Observable.of({}));
+
+        mockedLinksEventSource.created.emit(linkCreatedDataEvent);
+
+        expect(mockedLinkService.createLink).toHaveBeenCalled();
+    });
+});

src/app/components/drawings-listeners/node-dragged/node-dragged.component.spec.ts

@@ -0,0 +1,76 @@
+import { NodeDraggedComponent } from "./node-dragged.component";
+import { ComponentFixture, async, TestBed } from '@angular/core/testing';
+import { NodesDataSource } from '../../../cartography/datasources/nodes-datasource';
+import { NodeService } from '../../../services/node.service';
+import { NodesEventSource } from '../../../cartography/events/nodes-event-source';
+import { MockedNodeService, MockedNodesDataSource } from '../../project-map/project-map.component.spec';
+import { DraggedDataEvent } from '../../../cartography/events/event-source';
+import { MapNode } from '../../../cartography/models/map/map-node';
+import { MapLabel } from '../../../cartography/models/map/map-label';
+import { Observable } from 'rxjs';
+
+describe('NodeDraggedComponent', () => {
+    let component: NodeDraggedComponent;
+    let fixture: ComponentFixture<NodeDraggedComponent>;
+    let mockedNodesDataSource = new MockedNodesDataSource;
+    let mockedNodeService = new MockedNodeService;
+    let mockedNodesEventSource = new NodesEventSource;
+    
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            providers: [
+                { provide: NodesDataSource, useValue: mockedNodesDataSource },
+                { provide: NodeService, useValue: mockedNodeService },
+                { provide: NodesEventSource, useValue: mockedNodesEventSource }
+            ],
+            declarations: [
+                NodeDraggedComponent
+            ]
+        })
+        .compileComponents();
+    }));
+
+    beforeEach(() => {
+        fixture = TestBed.createComponent(NodeDraggedComponent);
+        component = fixture.componentInstance;
+    });
+
+    it('should create', () => {
+        expect(component).toBeTruthy();
+    });
+
+    it('should call node service when node dragged', () => {
+        fixture.detectChanges();
+        const mapNode: MapNode = {
+            id: 'sampleId',
+            commandLine: 'sampleCommandLine',
+            computeId: 'sampleComputeId',
+            console: 0,
+            consoleHost: 'sampleConsoleHost',
+            consoleType: 'sampleConsoleType',
+            firstPortName: 'sampleFirstPortName',
+            height: 0,
+            label: {} as MapLabel,
+            name: "sampleName",
+            nodeDirectory: "sampleNodeDirectory",
+            nodeType: "sampleNodeType",
+            portNameFormat: "samplePortNameFormat",
+            portSegmentSize: 0,
+            ports: [],
+            projectId: "sampleProjectId",
+            status: "sampleStatus",
+            symbol: "sampleSymbol",
+            symbolUrl: "sampleUrl",
+            width: 0,
+            x: 0,
+            y: 0,
+            z: 0
+        };
+        const draggedDataEvent = new DraggedDataEvent<MapNode>(mapNode, 0, 0);
+        spyOn(mockedNodeService, 'updatePosition').and.returnValue( Observable.of({}));
+
+        mockedNodesEventSource.dragged.emit(draggedDataEvent);
+
+        expect(mockedNodeService.updatePosition).toHaveBeenCalled();
+    });
+});

src/app/components/drawings-listeners/node-label-dragged/node-label-dragged.component.spec.ts

@@ -62,7 +62,7 @@ describe('NodeLabelDraggedComponent', () => {
             nodeId: "node id"
         };
         const nodeDraggedDataEvent = new DraggedDataEvent<MapLabel>(mapLabel, 0, 0);
-        spyOn(mockedNodeService, 'updateLabel').and.returnValue( Observable.of({}));;
+        spyOn(mockedNodeService, 'updateLabel').and.returnValue( Observable.of({}));
 
         mockedNodesEventSource.labelDragged.emit(nodeDraggedDataEvent);
 

src/app/components/project-map/project-map.component.spec.ts

@@ -44,6 +44,9 @@ import { MapLabelToLabelConverter } from '../../cartography/converters/map/map-l
 import { DefaultDrawingsFactory } from '../../cartography/helpers/default-drawings-factory';
 import { Label } from '../../cartography/models/label';
 import { Node } from '../../cartography/models/node';
+import { Port } from '../../models/port';
+import { Link } from '../../models/link';
+import { LinkNode } from '../../models/link-node';
 
 export class MockedProgressService {
   public activate() {}
@@ -56,6 +59,10 @@ export class MockedNodeService {
   updateLabel(server: Server, node: Node, label: Label): Observable<Node> {
     return of(this.node);
   }
+
+  updatePosition(server: Server, node: Node, x: number, y: number): Observable<Node> {
+    return of(this.node);
+  }
 }
 
 export class MockedDrawingService {
@@ -87,6 +94,18 @@ export class MockedDrawingService {
   }
 }
 
+export class MockedLinkService {
+  constructor() {}
+
+  createLink(server: Server, source_node: Node, source_port: Port, target_node: Node, target_port: Port) {
+    return of({});
+  }
+
+  updateNodes(server: Server, link: Link, nodes: LinkNode[]){
+    return of({});
+  }
+}
+
 export class MockedDrawingsDataSource {
   add() {}
 

src/app/services/project.service.spec.ts

@@ -35,6 +35,10 @@ export class MockedProjectService {
   isReadOnly(project) {
     return project.readonly;
   }
+
+  links(server: Server, project_id: string) {
+    return of([]);
+  }
 }