Increases code coverage of UI

front-end/__tests__/components/API.test.js

@@ -0,0 +1,180 @@
+import React from 'react'
+import { render } from '@testing-library/react'
+import * as API from '../../src/API';
+import VPLinkModel from '../../src/components/VPLink/VPLinkModel';
+import CustomNodeModel from '../../src/components/CustomNode/CustomNodeModel';
+import VPPortModel from '../../src/components/VPPort/VPPortModel'
+
+global.console = {log: jest.fn()}
+global.URL.createObjectURL = jest.fn(() => 'http://localhost:8080/');
+global.URL.revokeObjectURL = jest.fn();
+
+describe('Validates API calls', () => {
+
+  beforeEach(() => {
+    global.fetch = jest.fn(() => Promise.resolve({
+      ok: true,
+      data: [],
+      json: jest.fn(() => []),
+      text: jest.fn(() => Promise.resolve({})),
+      headers:{
+        get: (s)=>{
+          if (s === "content-type") {
+            return "text";
+          }
+
+          if (s === "Content-Disposition") {
+            return "filenameToDownload";
+          }
+        }
+      }
+    }));
+  });
+
+  it('Validates executionOrder', () => {
+    API.executionOrder();
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][1]).toStrictEqual({});
+    expect(global.fetch.mock.calls[0][0]).toBe("/workflow/execute");
+  });
+
+  it('Validates execute', () => {
+    const node = {
+      options: {
+        id: 'nodeId'
+      }
+    };
+
+    API.execute(node);
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][1]).toStrictEqual({});
+    expect(global.fetch.mock.calls[0][0]).toBe("/node/nodeId/execute");
+  });
+
+  it('Validates retrieveData', () => {
+    API.retrieveData("nodeId");
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][1]).toStrictEqual({});
+    expect(global.fetch.mock.calls[0][0]).toBe("/node/nodeId/retrieve_data");
+  });
+
+  it('Validates downloadDataFile', () => {
+    const node = {
+      options: {
+        id: 'nodeId'
+      },
+      config: {}
+    };
+
+    API.downloadDataFile(node);
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][0]).toBe("/workflow/download");
+  });
+
+  it('Validates uploadDataFile', () => {
+    const formData = { data: {}};
+    const options = {method: "POST", body: formData};
+    API.uploadDataFile(formData);
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][1]).toStrictEqual(options);
+    expect(global.fetch.mock.calls[0][0]).toBe("/workflow/upload");
+  });
+
+  it('Validates deleteEdge', () => {
+    const sourceModel = new CustomNodeModel({id: "myId1", num_in: 2, num_out: 1});
+    const targetModel = new CustomNodeModel({id: "myId2", num_in: 2, num_out: 1});
+
+    const sourcePort = new VPPortModel({name: 'source-port-name'});
+    sourcePort.setParent(sourceModel);
+    const targetPort = new VPPortModel({name: 'target-port-name'});
+    targetPort.setParent(targetModel);
+    const linkModel = new VPLinkModel();
+    linkModel.setSourcePort(sourcePort);
+    linkModel.setTargetPort(targetPort);
+
+    const options = {method: "POST"};
+    API.deleteEdge(linkModel);
+
+    expect(global.fetch.mock.calls.length).toBe(2);
+    expect(global.fetch.mock.calls[0][1]).toStrictEqual(options);
+    expect(global.fetch.mock.calls[0][0]).toBe("/node/edge/myId1/myId2");
+
+  });
+
+  it('Validates addEdge', () => {
+    const sourceModel = new CustomNodeModel({id: "myId1", num_in: 2, num_out: 1});
+    const targetModel = new CustomNodeModel({id: "myId2", num_in: 2, num_out: 1});
+
+    const sourcePort = new VPPortModel({name: 'source-port-name', in: true});
+    sourcePort.setParent(sourceModel);
+    const targetPort = new VPPortModel({name: 'target-port-name'});
+    targetPort.setParent(targetModel);
+    const linkModel = new VPLinkModel();
+    linkModel.setSourcePort(sourcePort);
+    linkModel.setTargetPort(targetPort);
+
+    const options = {method: "POST"};
+    API.addEdge(linkModel);
+
+    expect(global.fetch.mock.calls.length).toBe(2);
+    expect(global.fetch.mock.calls[0][1]).toStrictEqual(options);
+    expect(global.fetch.mock.calls[0][0]).toBe("/node/edge/myId2/myId1");
+
+  });
+
+  it('Validates uploadWorkflow', () => {
+    const formData = { data: {}};
+    const options = {method: "POST", body: formData};
+    API.uploadWorkflow(formData);
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][1]).toStrictEqual(options);
+    expect(global.fetch.mock.calls[0][0]).toBe("/workflow/open");
+  });
+
+  it('Validates initWorkflow', () => {
+    const sourceModel = new CustomNodeModel({id: "myId1", num_in: 2, num_out: 1});
+    API.initWorkflow(sourceModel);
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][0]).toBe("/workflow/new");
+  });
+
+  it('Validates getGlobalVars', () => {
+    API.getGlobalVars();
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][0]).toBe("/workflow/globals");
+  });
+
+  it('Validates getNodes', () => {
+    API.getNodes();
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][0]).toBe("/workflow/nodes");
+  });
+
+  it('Validates updateNode', () => {
+    const sourceModel = new CustomNodeModel({id: "myId1", num_in: 2, num_out: 1});
+    API.updateNode(sourceModel);
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][0]).toBe("/node/myId1");
+  });
+
+  it('Validates deleteNode', () => {
+    const sourceModel = new CustomNodeModel({id: "myId1", num_in: 2, num_out: 1});
+    API.deleteNode(sourceModel);
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][0]).toBe("/node/myId1");
+  });
+
+  it('Validates addNode', () => {
+    const sourceModel = new CustomNodeModel({id: "myId1", num_in: 2, num_out: 1});
+    API.addNode(sourceModel);
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][0]).toBe("/node/");
+  });
+
+  it('Validates getNode', () => {
+    API.getNode("myId1");
+    expect(global.fetch.mock.calls.length).toBe(1);
+    expect(global.fetch.mock.calls[0][0]).toBe("/node/myId1");
+  });
+
+});

front-end/__tests__/components/About.test.js

@@ -0,0 +1,42 @@
+import React from 'react'
+import { render } from '@testing-library/react'
+import ReactDOM from 'react-dom';
+import About from '../../src/components/About';
+
+global.console = {error: jest.fn()}
+
+global.fetch = jest.fn(() => Promise.resolve({
+  data: [],
+  json: jest.fn(() => [])
+}));
+
+describe('Validates About', () => {
+  it('Does not display About info', () => {
+    const div = React.createElement('div');
+    const app = render(<About show={false} />, div);
+    expect(app).toMatchSnapshot();
+  });
+
+  it('Displays About info', () => {
+    const div = React.createElement('div');
+    const app = render(<About show={true} />, div);
+    expect(app).toMatchSnapshot();
+  });
+
+  it('Validates closing', () => {
+    const props = {
+      show: true
+    };
+
+    const event = {
+      preventDefault: jest.fn(() => [])
+    };
+
+    const about = new About(props);
+    about.componentDidMount();
+    about.handleShow(event);
+    about.handleClose();
+
+    expect(event.preventDefault.mock.calls.length).toBe(1);
+  });
+});

front-end/__tests__/components/App.test.js

@@ -0,0 +1,17 @@
+import React from 'react'
+import { render } from '@testing-library/react'
+import App from '../../src/components/App';
+
+global.console = {log: jest.fn()}
+
+global.fetch = jest.fn(() => Promise.resolve({
+  data: [],
+  json: jest.fn(() => [])
+}));
+
+describe('Validates App initialization', () => {
+  it('Creates App', () => {
+    const app = render(<App />);
+    expect(app).toMatchSnapshot();
+  });
+});

front-end/__tests__/components/CustomNode/CustomNodeFactory.test.js

@@ -0,0 +1,28 @@
+import React from 'react'
+import { render } from '@testing-library/react'
+import CustomNodeFactory from '../../../src/components/CustomNode/CustomNodeFactory';
+import CustomNodeModel from '../../../src/components/CustomNode/CustomNodeModel';
+import CustomNodeWidget from '../../../src/components/CustomNode/CustomNodeWidget';
+
+describe('Validate CustomNodeFactory', () => {
+  it('CustomNodeFactory generates CustomNodeWidget', () => {
+    const customNodeFactory = new CustomNodeFactory();
+    const node = new CustomNodeModel({id: "myId"});
+    const model = {
+      node: node,
+    };
+    const event = {
+      model: model,
+      initialConfig: {
+        options: { id: "modelId"},
+        config: {}
+      }
+    };
+    const widget = customNodeFactory.generateReactWidget(event);
+    expect(React.isValidElement(widget)).toBe(true);
+
+    const nodeModel = customNodeFactory.generateModel(event);
+    expect(nodeModel instanceof CustomNodeModel).toBe(true);
+    expect(nodeModel.getNodeId()).toBe("modelId");
+  });
+})

front-end/__tests__/components/CustomNode/CustomNodeModel.test.js

@@ -0,0 +1,27 @@
+import React from 'react'
+import CustomNodeModel from '../../../src/components/CustomNode/CustomNodeModel';
+import CustomNodeFactory from '../../../src/components/CustomNode/CustomNodeFactory';
+import VPPortFactory from '../../../src/components/VPPort/VPPortFactory';
+import createEngine from '@projectstorm/react-diagrams';
+
+
+describe('Validates CustomNodeModel', () => {
+  it('Validates serialization/deserialization', () => {
+    const node = new CustomNodeModel({id: "myId", num_in: 2, num_out: 1});
+    node.setStatus("Complete");
+    const engine = createEngine();
+    engine.getNodeFactories().registerFactory(new CustomNodeFactory());
+    engine.getPortFactories().registerFactory(new VPPortFactory());
+
+    const serializedModel = node.serialize();
+    const event = {
+        data: serializedModel,
+        engine: engine,
+        registerModel: jest.fn(() => [])
+    };
+    const otherNode = new CustomNodeModel();
+    otherNode.deserialize(event, engine);
+
+    expect(event.registerModel.mock.calls.length).toBe(4);
+  });
+});