Fixes local file system unit tests

.eslintrc

@@ -0,0 +1,72 @@
+{
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+      "project": "./tsconfig.json"
+    },
+    "plugins": ["@typescript-eslint", "react"],
+    "extends": [
+        "plugin:@typescript-eslint/recommended",
+        "react-app",
+        "react-app/jest"
+    ],
+    "rules": {
+      "quotes": ["off", "double"],
+      "@typescript-eslint/indent": [
+        "off",
+        2
+      ],
+      "@typescript-eslint/no-explicit-any": 0,
+      "@typescript-eslint/explicit-function-return-type": 0,
+      "@typescript-eslint/no-parameter-properties": 0,
+      "@typescript-eslint/no-use-before-define": 0,
+      "@typescript-eslint/no-object-literal-type-assertion": 0,
+
+      "@typescript-eslint/await-thenable": "off",
+        "@typescript-eslint/ban-types": "off",
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        "@typescript-eslint/no-empty-function": "off",
+        "@typescript-eslint/no-floating-promises": "off",
+        "@typescript-eslint/no-implied-eval": "off",
+        "@typescript-eslint/no-misused-promises": "off",
+        "@typescript-eslint/no-non-null-assertion": "off",
+        "@typescript-eslint/no-unnecessary-type-assertion": "off",
+        "@typescript-eslint/no-unsafe-assignment": "off",
+        "@typescript-eslint/no-unsafe-call": "off",
+        "@typescript-eslint/no-unsafe-member-access": "off",
+        "@typescript-eslint/no-unsafe-return": "off",
+        "@typescript-eslint/no-unused-vars": "off",
+        "@typescript-eslint/no-var-requires": "off",
+        "@typescript-eslint/prefer-regexp-exec": "off",
+        "@typescript-eslint/require-await": "off",
+        "@typescript-eslint/restrict-plus-operands": "off",
+        "@typescript-eslint/restrict-template-expressions": "off",
+        "@typescript-eslint/unbound-method": "off",
+        "@typescript-eslint/no-inferrable-types": "off",
+
+        "no-extend-native":"off",
+        "no-multi-str": "off",
+        "no-template-curly-in-string": "off",
+        "no-async-promise-executor": "off",
+        "no-case-declarations": "off",
+        "no-useless-escape": "off",
+        "prefer-const": "off",
+        "prefer-spread": "off",
+        "react/no-find-dom-node": "off",
+        "react/prop-types": "off",
+        "react/jsx-no-target-blank": "off",
+        "react/jsx-no-comment-textnodes": "off",
+        "import/first": "off",
+        "getter-return":"off",
+        "dot-location": "off",
+        "no-new-func": "off",
+
+        "jsx-a11y/anchor-is-valid": "off",
+        "jsx-a11y/alt-text": "off",
+
+        "jest/no-identical-title": "off",
+        "jest/valid-expect": "off",
+        "jest/no-jasmine-globals": "off",
+        "jest/no-conditional-expect": "off",
+        "jest/valid-describe": "off"
+    }
+  }

README.md

@@ -67,7 +67,7 @@ VoTT is available for Windows, Linux and OSX. Download the appropriate platform
 
 ### Build and run from source
 
-VoTT requires [NodeJS (>= 10.x, Dubnium) and NPM](https://github.com/nodejs/Release)
+VoTT requires [NodeJS (>= 12.x, Dubnium) and NPM](https://github.com/nodejs/Release)
 
    ```bash
     git clone https://github.com/Microsoft/VoTT.git

azure-pipelines/linux/continuous-build-linux.yml

@@ -16,7 +16,7 @@ steps:
 
 - task: NodeTool@0
   inputs:
-    versionSpec: '10.x'
+    versionSpec: '12.x'
   displayName: 'Install Node.js'
 
 - bash: |

azure-pipelines/mac/continuous-build-mac.yml

@@ -5,7 +5,7 @@
 steps:
 - task: NodeTool@0
   inputs:
-    versionSpec: '10.x'
+    versionSpec: '12.x'
   displayName: 'Install Node.js'
 
 - bash: |

azure-pipelines/templates/build-artifact.yml

@@ -7,9 +7,9 @@ jobs:
     - template: git-pull-current-branch.yml
 
     - task: NodeTool@0
-      displayName: 'Use Node 10.x'
+      displayName: 'Use Node 12.x'
       inputs:
-        versionSpec: 10.x
+        versionSpec: 12.x
 
     - bash: |
         set -ex

azure-pipelines/templates/create-web-release.yml

@@ -7,9 +7,9 @@ jobs:
       - template: git-pull-current-branch.yml
 
       - task: NodeTool@0
-        displayName: 'Use Node 10.x'
+        displayName: 'Use Node 12.x'
         inputs:
-          versionSpec: 10.x
+          versionSpec: 12.x
 
       - task: Npm@1
         displayName: 'npm ci'

azure-pipelines/templates/npm-version-bump.yml

@@ -16,7 +16,7 @@ jobs:
   steps:
   - task: NodeTool@0
     inputs:
-      versionSpec: 10.x
+      versionSpec: 12.x
     displayName: 'Install Node.js'
 
   # Download secure file

azure-pipelines/upload-plato-report.yml

@@ -35,9 +35,9 @@ steps:
     displayName: "Verify storage account cred exists"
 
   - task: NodeTool@0
-    displayName: "Use Node 10.x"
+    displayName: "Use Node 12.x"
     inputs:
-      versionSpec: 10.x
+      versionSpec: 12.x
 
   - task: Npm@1
     displayName: 'Run `npm ci`'

azure-pipelines/windows/continuous-build-windows.yml

@@ -5,12 +5,12 @@
 steps:
 - task: NodeTool@0
   inputs:
-    versionSpec: '10.x'
+    versionSpec: '12.x'
   displayName: 'Install Node.js'
 
-- bash: | 
+- bash: |
     set -e
-    
+
     export DISPLAY=:99.0
 
     npm ci  # do a clean install

package.json

@@ -15,15 +15,15 @@
     "private": true,
     "main": "build/main.js",
     "dependencies": {
-        "@azure/storage-blob": "^10.3.0",
+        "@azure/storage-blob": "10.3.0",
         "@tensorflow/tfjs": "^1.0.3",
-        "@types/snapsvg": "^0.4.35",
         "axios": "^0.18.0",
         "bootstrap": "^4.1.3",
         "buffer-reverse": "^1.0.1",
         "crypto-js": "^3.1.9-1",
         "dotenv": "^7.0.0",
         "express-request-id": "^1.4.1",
+        "fibers": "^5.0.0",
         "google-protobuf": "^3.6.1",
         "jpeg-js": "^0.3.4",
         "json2csv": "^4.5.0",
@@ -38,13 +38,15 @@
         "react": "^16.7.0",
         "react-appinsights": "^3.0.0-rc.5",
         "react-color": "^2.17.0",
+        "react-dnd": "^5.0.0",
+        "react-dnd-html5-backend": "^3.0.2",
         "react-dom": "^16.7.0",
         "react-jsonschema-form": "^1.3.0",
         "react-localization": "^1.0.13",
         "react-modal": "^3.8.1",
         "react-redux": "^5.1.1",
-        "react-router-dom": "^4.3.1",
-        "react-scripts": "2.1.1",
+        "react-router-dom": "4.3.1",
+        "react-scripts": "4.0.0",
         "react-split-pane": "^0.1.87",
         "react-tag-input": "^6.1.0",
         "react-toastify": "^4.5.2",
@@ -54,6 +56,7 @@
         "redux": "^4.0.1",
         "redux-thunk": "^2.3.0",
         "rimraf": "^2.6.2",
+        "sass": "^1.28.0",
         "shortid": "^2.2.14",
         "video-react": "^0.13.2",
         "vott-ct": "2.1.24",
@@ -76,8 +79,8 @@
         "release-web": "npm run build && npm run webpack:prod",
         "release-ci": "bash ./scripts/build.sh",
         "release": "npm run build && npm run webpack:prod && electron-builder",
-        "pretest": "./node_modules/.bin/tslint 'src/**/*.ts*'",
-        "lintfix": "./node_modules/.bin/tslint 'src/**/*.ts*' --fix",
+        "pretest": "npx eslint \"src/**/*.ts*\"",
+        "lintfix": "npx eslint \"src/**/*.ts*\" --fix",
         "test": "react-scripts test --env=jsdom --silent",
         "test:ci": "cross-env CI=true npm run test",
         "test:coverage": "npm run test -- --coverage",
@@ -88,32 +91,37 @@
     "eslintConfig": {
         "extends": "react-app"
     },
-    "browserslist": [
-        ">0.2%",
-        "not dead",
-        "not ie <= 11",
-        "not op_mini all"
-    ],
+    "browserslist": {
+        "production": [
+            ">0.2%",
+            "not dead",
+            "not op_mini all"
+        ],
+        "development": [
+            "last 1 chrome version",
+            "last 1 firefox version",
+            "last 1 safari version"
+        ]
+    },
     "devDependencies": {
         "@fortawesome/fontawesome-free": "^5.5.0",
-        "@types/axios": "^0.14.0",
         "@types/dotenv": "^6.1.0",
         "@types/enzyme": "^3.1.15",
-        "@types/jest": "23.3.9",
+        "@types/jest": "26.0.15",
         "@types/json2csv": "^4.4.0",
-        "@types/node": "10.12.7",
+        "@types/node": "12.19.0",
         "@types/react": "16.7.6",
         "@types/react-dom": "16.0.9",
         "@types/react-jsonschema-form": "^1.0.12",
-        "@types/react-router-dom": "^4.3.1",
-        "@types/react-split-pane": "^0.1.67",
-        "@types/react-toastify": "^4.0.1",
+        "@types/react-router": "5.0.0",
+        "@types/react-router-dom": "4.3.1",
         "@types/reactstrap": "^6.4.3",
         "@types/redux-logger": "^3.0.6",
         "@types/redux-mock-store": "^1.0.0",
+        "@types/snapsvg": "^0.4.35",
         "cross-env": "^5.2.0",
-        "electron": "^3.0.13",
-        "electron-builder": "^22.6.0",
+        "electron": "^10.1.5",
+        "electron-builder": "^22.9.1",
         "enzyme": "^3.7.0",
         "enzyme-adapter-react-16": "^1.7.0",
         "foreman": "^3.0.1",
@@ -125,14 +133,11 @@
         "redux-logger": "^3.0.6",
         "redux-mock-store": "^1.5.3",
         "ts-loader": "^5.3.0",
-        "tslint": "^5.11.0",
-        "typescript": "^3.1.6",
-        "webpack": "^4.19.1",
-        "webpack-cli": "^3.1.2",
-        "webpack-merge": "^4.1.5"
+        "typescript": "^4.0.5",
+        "webpack-cli": "^4.1.0"
     },
     "engines": {
-        "node": ">=10.14.2",
-        "npm": ">=6.4.1"
+        "node": ">=12.19.0",
+        "npm": ">=6.14.8"
     }
 }

server/azure-deploy.yml

@@ -28,7 +28,7 @@ stages:
     steps:
     - task: NodeTool@0
       inputs:
-        versionSpec: '10.x'
+        versionSpec: '12.x'
       displayName: 'Install Node.js'
 
     - script: |

src/common/mockFactory.ts

@@ -818,16 +818,16 @@ export default class MockFactory {
      */
     public static projectActions(): IProjectActions {
         return {
-            loadProject: jest.fn(() => Promise.resolve()),
-            saveProject: jest.fn(() => Promise.resolve()),
+            loadProject: jest.fn(() => Promise.resolve()) as any,
+            saveProject: jest.fn(() => Promise.resolve()) as any,
             deleteProject: jest.fn(() => Promise.resolve()),
             closeProject: jest.fn(() => Promise.resolve()),
-            loadAssets: jest.fn(() => Promise.resolve()),
+            loadAssets: jest.fn(() => Promise.resolve()) as any,
             exportProject: jest.fn(() => Promise.resolve()),
-            loadAssetMetadata: jest.fn(() => Promise.resolve()),
-            saveAssetMetadata: jest.fn(() => Promise.resolve()),
-            updateProjectTag: jest.fn(() => Promise.resolve()),
-            deleteProjectTag: jest.fn(() => Promise.resolve()),
+            loadAssetMetadata: jest.fn(() => Promise.resolve()) as any,
+            saveAssetMetadata: jest.fn(() => Promise.resolve()) as any,
+            updateProjectTag: jest.fn(() => Promise.resolve()) as any,
+            deleteProjectTag: jest.fn(() => Promise.resolve()) as any,
         };
     }
 
@@ -836,8 +836,8 @@ export default class MockFactory {
      */
     public static connectionActions(): IConnectionActions {
         return {
-            loadConnection: jest.fn((connection: IConnection) => Promise.resolve()),
-            saveConnection: jest.fn((connection: IConnection) => Promise.resolve()),
+            loadConnection: jest.fn((connection: IConnection) => Promise.resolve()) as any,
+            saveConnection: jest.fn((connection: IConnection) => Promise.resolve()) as any,
             deleteConnection: jest.fn((connection: IConnection) => Promise.resolve()),
         };
     }
@@ -1036,7 +1036,7 @@ export default class MockFactory {
     }
 
     public static mockElement(assetTestCache: Map<string, IAsset>) {
-        document.createElement = jest.fn((elementType) => {
+        document.createElement = jest.fn((elementType: string) => {
             switch (elementType) {
                 case "img":
                     const mockImage = MockFactory.mockImage(assetTestCache);

src/electron/main.ts

@@ -72,7 +72,7 @@ function registerContextMenu(browserWindow: BrowserWindow): void {
     const selectionMenu = Menu.buildFromTemplate([
         { role: "copy", accelerator: "CmdOrCtrl+C" },
         { type: "separator" },
-        { role: "selectall", accelerator: "CmdOrCtrl+A" },
+        { role: "selectAll", accelerator: "CmdOrCtrl+A" },
     ]);
 
     const inputMenu = Menu.buildFromTemplate([
@@ -83,7 +83,7 @@ function registerContextMenu(browserWindow: BrowserWindow): void {
         { role: "copy", accelerator: "CmdOrCtrl+C" },
         { role: "paste", accelerator: "CmdOrCtrl+V" },
         { type: "separator" },
-        { role: "selectall", accelerator: "CmdOrCtrl+A" },
+        { role: "selectAll", accelerator: "CmdOrCtrl+A" },
     ]);
 
     browserWindow.webContents.on("context-menu", (e, props) => {
@@ -111,7 +111,7 @@ function registerContextMenu(browserWindow: BrowserWindow): void {
                 { role: "reload" },
                 { type: "separator" },
                 { role: "toggleDevTools" },
-                { role: "toggleFullScreen" },
+                { role: "togglefullscreen" },
                 { type: "separator" },
                 { role: "resetZoom" },
                 { role: "zoomIn" },

src/electron/providers/storage/localFileSystem.test.ts

@@ -5,7 +5,7 @@ import LocalFileSystem from "./localFileSystem";
 
 jest.mock("electron", () => ({
     dialog: {
-        showOpenDialog: jest.fn(),
+        showOpenDialogSync: jest.fn(),
     },
 }));
 import { dialog } from "electron";
@@ -72,7 +72,7 @@ describe("LocalFileSystem Storage Provider", () => {
 
     it("selectContainer opens a dialog and resolves with selected path", async () => {
         const expectedContainerPath = "/path/to/container";
-        const mockMethod = dialog.showOpenDialog as jest.Mock;
+        const mockMethod = dialog.showOpenDialogSync as jest.Mock;
         mockMethod.mockReturnValue([expectedContainerPath]);
 
         const result = await localFileSystem.selectContainer();
@@ -80,7 +80,7 @@ describe("LocalFileSystem Storage Provider", () => {
     });
 
     it("selectContainer rejects when a folder path is not returned", async () => {
-        const mockMethod = dialog.showOpenDialog as jest.Mock;
+        const mockMethod = dialog.showOpenDialogSync as jest.Mock;
         mockMethod.mockReturnValue([]);
 
         await expect(localFileSystem.selectContainer()).rejects.not.toBeNull();

src/electron/providers/storage/localFileSystem.ts

@@ -14,7 +14,7 @@ export default class LocalFileSystem implements IStorageProvider {
 
     public selectContainer(): Promise<string> {
         return new Promise<string>((resolve, reject) => {
-            const filePaths = dialog.showOpenDialog(this.browserWindow, {
+            const filePaths = dialog.showOpenDialogSync(this.browserWindow, {
                 title: strings.connections.providers.local.selectFolder,
                 buttonLabel: strings.connections.providers.local.chooseFolder,
                 properties: ["openDirectory", "createDirectory"],

src/providers/export/azureCustomVision/azureCustomVisionService.test.ts

@@ -17,9 +17,7 @@ describe("Azure Custom Vision Service", () => {
             apiKey: "ABC123",
         };
         customVisionService = new AzureCustomVisionService(customVisionOptions);
-    });
 
-    beforeAll(() => {
         axios.get = jest.fn();
         axios.post = jest.fn();
         getMock = axios.get as jest.Mock;
@@ -70,13 +68,12 @@ describe("Azure Custom Vision Service", () => {
                 });
             });
 
+            await expect(customVisionService.create(testProject)).rejects.not.toBeNull();
             expect(axios.post).toBeCalledWith(
                 expect.stringContaining(`${customVisionOptions.baseUrl}/projects?`),
                 null,
                 expect.anything(),
             );
-
-            await expect(customVisionService.create(testProject)).rejects.not.toBeNull();
         });
     });
 

src/providers/export/csv.test.ts

@@ -42,7 +42,7 @@ describe("CSV Format Export Provider", () => {
 
     const expectedFileName = "vott-csv-export/" + testProject.name.replace(" ", "-") + "-export.csv";
 
-    beforeAll(() => {
+    beforeEach(() => {
         HtmlFileReader.getAssetBlob = jest.fn(() => {
             return Promise.resolve(new Blob(["Some binary data"]));
         });
@@ -52,9 +52,7 @@ describe("CSV Format Export Provider", () => {
                 getAssets: jest.fn(() => Promise.resolve(testAssets)),
             };
         });
-    });
 
-    beforeEach(() => {
         registerProviders();
     });
 

src/providers/export/exportProvider.test.ts

@@ -14,7 +14,7 @@ describe("Export Provider Base", () => {
     let testProject: IProject = null;
     const testAssets = MockFactory.createTestAssets(10, 1);
 
-    beforeAll(() => {
+    beforeEach(() => {
         AssetProviderFactory.create = jest.fn(() => {
             return {
                 getAssets: jest.fn(() => Promise.resolve(testAssets)),
@@ -26,7 +26,7 @@ describe("Export Provider Base", () => {
                 asset: { ...asset },
                 regions: [],
             };
-        });
+        }) as any;
 
         testProject = {
             ...MockFactory.createTestProject("TestProject"),

src/providers/export/pascalVOC.test.ts

@@ -34,19 +34,17 @@ describe("PascalVOC Json Export Provider", () => {
 
     const tagLengthInPbtxt = 31;
 
-    HtmlFileReader.getAssetArray = jest.fn(() => {
-        return Promise.resolve(new Uint8Array([1, 2, 3]).buffer);
-    });
+    beforeEach(() => {
+        HtmlFileReader.getAssetArray = jest.fn(() => {
+            return Promise.resolve(new Uint8Array([1, 2, 3]).buffer);
+        });
 
-    beforeAll(() => {
         AssetProviderFactory.create = jest.fn(() => {
             return {
                 getAssets: jest.fn(() => Promise.resolve(testAssets)),
             };
         });
-    });
 
-    beforeEach(() => {
         registerProviders();
     });
 

src/providers/export/tensorFlowRecords.test.ts

@@ -35,17 +35,15 @@ describe("TFRecords Json Export Provider", () => {
 
     const tagLengthInPbtxt = 31;
 
-    HtmlFileReader.getAssetArray = jest.fn(() => Promise.resolve(new Uint8Array([1, 2, 3]).buffer));
+    beforeEach(() => {
+        HtmlFileReader.getAssetArray = jest.fn(() => Promise.resolve(new Uint8Array([1, 2, 3]).buffer));
 
-    beforeAll(() => {
         AssetProviderFactory.create = jest.fn(() => {
             return {
                 getAssets: jest.fn(() => Promise.resolve(testAssets)),
             };
         });
-    });
 
-    beforeEach(() => {
         registerProviders();
     });
 

src/providers/export/vottJson.test.ts

@@ -39,7 +39,7 @@ describe("VoTT Json Export Provider", () => {
 
     const expectedFileName = "vott-json-export/" + testProject.name.replace(" ", "-") + constants.exportFileExtension;
 
-    beforeAll(() => {
+    beforeEach(() => {
         HtmlFileReader.getAssetBlob = jest.fn(() => {
             return Promise.resolve(new Blob(["Some binary data"]));
         });
@@ -49,9 +49,7 @@ describe("VoTT Json Export Provider", () => {
                 getAssets: jest.fn(() => Promise.resolve(testAssets)),
             };
         });
-    });
 
-    beforeEach(() => {
         registerProviders();
     });
 

src/providers/storage/assetProviderFactory.ts

@@ -89,7 +89,7 @@ export class AssetProviderFactory {
      * @param connection - Connection for an Asset Provider
      */
     public static createFromConnection(connection: IConnection): IAssetProvider {
-        return this.create(connection.providerType, connection.providerOptions);
+        return AssetProviderFactory.create(connection.providerType, connection.providerOptions);
     }
 
     /**

src/providers/storage/azureBlobStorage.test.ts

@@ -8,30 +8,36 @@ import { AssetService } from "../../services/assetService";
 import { AssetType } from "../../models/applicationState";
 
 describe("Azure blob functions", () => {
-
-    const ad = MockFactory.createAzureData();
-    const options = ad.options;
-
-    const serviceURL = ServiceURL as jest.Mocked<typeof ServiceURL>;
-    serviceURL.prototype.listContainersSegment = jest.fn(() => Promise.resolve(ad.containers));
-
-    ContainerURL.fromServiceURL = jest.fn(() => new ContainerURL(null, null));
-    const containerURL = ContainerURL as jest.Mocked<typeof ContainerURL>;
-    containerURL.prototype.create = jest.fn(() => Promise.resolve({ statusCode: 201 }));
-    containerURL.prototype.delete = jest.fn(() => Promise.resolve({ statusCode: 204 }));
-    containerURL.prototype.listBlobFlatSegment = jest.fn(() => Promise.resolve(ad.blobs));
-
-    BlockBlobURL.fromContainerURL = jest.fn(() => new BlockBlobURL(null, null));
+    let ad = null;
+    let options = null;
+    let serviceURL = null;
+    let containerURL = null;
 
     registerProviders();
 
+    beforeEach(() => {
+        ad = MockFactory.createAzureData();
+        options = ad.options;
+
+        serviceURL = ServiceURL as jest.Mocked<typeof ServiceURL>;
+        serviceURL.prototype.listContainersSegment = jest.fn(() => Promise.resolve(ad.containers)) as any;
+
+        ContainerURL.fromServiceURL = jest.fn(() => new ContainerURL(null, null));
+        containerURL = ContainerURL as jest.Mocked<typeof ContainerURL>;
+        containerURL.prototype.create = jest.fn(() => Promise.resolve({ statusCode: 201 })) as any;
+        containerURL.prototype.delete = jest.fn(() => Promise.resolve({ statusCode: 204 })) as any;
+        containerURL.prototype.listBlobFlatSegment = jest.fn(() => Promise.resolve(ad.blobs)) as any;
+
+        BlockBlobURL.fromContainerURL = jest.fn(() => new BlockBlobURL(null, null));
+    });
+
     it("Reads text from a blob", async () => {
         const blockBlobURL = BlockBlobURL as jest.Mocked<typeof BlockBlobURL>;
 
         const blob = MockFactory.blob(ad.blobName, ad.blobText, ad.fileType);
         blockBlobURL.prototype.download = jest.fn(() => Promise.resolve({
             blobBody: Promise.resolve(blob),
-        }));
+        })) as any;
 
         const provider: AzureBlobStorage = new AzureBlobStorage(options);
 
@@ -55,7 +61,7 @@ describe("Azure blob functions", () => {
         );
         blockBlobURL.prototype.download = jest.fn(() => Promise.resolve({
             blobBody: Promise.resolve(blob),
-        }));
+        })) as any;
 
         const provider: AzureBlobStorage = new AzureBlobStorage(options);
 
@@ -76,7 +82,7 @@ describe("Azure blob functions", () => {
         const blob = MockFactory.blob(ad.blobName, ad.blobText, ad.fileType);
         blockBlobURL.prototype.download = jest.fn(() => Promise.resolve({
             blobBody: Promise.resolve(blob),
-        }));
+        })) as any;
 
         const provider: AzureBlobStorage = new AzureBlobStorage(options);
 
@@ -188,7 +194,7 @@ describe("Azure blob functions", () => {
             return {
                 type: AssetType.Image,
             };
-        });
+        }) as any;
         provider.getFileName = jest.fn();
         const assets = await provider.getAssets();
         expect(provider.getFileName).toBeCalled();

src/providers/storage/bingImageSearch.test.ts

@@ -18,12 +18,14 @@ describe("Bing Image Search", () => {
         { contentUrl: "http://images.com/image4.jpg" },
     ];
 
-    axios.get = jest.fn(() => {
-        return Promise.resolve({
-            data: {
-                value: assets,
-            },
-        });
+    beforeEach(() => {
+        axios.get = jest.fn(() => {
+            return Promise.resolve({
+                data: {
+                    value: assets,
+                },
+            });
+        }) as any;
     });
 
     it("calls the Bing image search API", async () => {

src/providers/storage/localFileSystemProxy.test.ts

@@ -27,7 +27,7 @@ describe("LocalFileSystem Proxy Storage Provider", () => {
 
         it("selectContainer", async () => {
             const expectedFolderPath = "/test";
-            IpcRendererProxy.send = jest.fn(() => Promise.resolve(expectedFolderPath));
+            IpcRendererProxy.send = jest.fn(() => Promise.resolve(expectedFolderPath)) as any;
 
             const actualFolderPath = await provider.selectContainer();
             expect(IpcRendererProxy.send).toBeCalledWith("LocalFileSystem:selectContainer");
@@ -35,7 +35,7 @@ describe("LocalFileSystem Proxy Storage Provider", () => {
         });
 
         it("writeText", async () => {
-            IpcRendererProxy.send = jest.fn(() => Promise.resolve());
+            IpcRendererProxy.send = jest.fn(() => Promise.resolve()) as any;
 
             const fileName = "test.txt";
             const contents = "Hello World!";
@@ -47,7 +47,7 @@ describe("LocalFileSystem Proxy Storage Provider", () => {
 
         it("readText", async () => {
             const expectedContents = "Hello World!";
-            IpcRendererProxy.send = jest.fn(() => Promise.resolve(expectedContents));
+            IpcRendererProxy.send = jest.fn(() => Promise.resolve(expectedContents)) as any;
 
             const fileName = "test.txt";
             const expectedFilePath = [options.folderPath, fileName].join("/");
@@ -58,7 +58,7 @@ describe("LocalFileSystem Proxy Storage Provider", () => {
         });
 
         it("deleteFile", async () => {
-            IpcRendererProxy.send = jest.fn(() => Promise.resolve());
+            IpcRendererProxy.send = jest.fn(() => Promise.resolve()) as any;
 
             const fileName = "test.txt";
             const expectedFilePath = [options.folderPath, fileName].join("/");
@@ -68,7 +68,7 @@ describe("LocalFileSystem Proxy Storage Provider", () => {
         });
 
         it("createContainer", async () => {
-            IpcRendererProxy.send = jest.fn(() => Promise.resolve());
+            IpcRendererProxy.send = jest.fn(() => Promise.resolve()) as any;
 
             const containerName = "test";
             const expectedFolderPath = [options.folderPath, containerName].join("/");
@@ -78,7 +78,7 @@ describe("LocalFileSystem Proxy Storage Provider", () => {
         });
 
         it("deleteContainer", async () => {
-            IpcRendererProxy.send = jest.fn(() => Promise.resolve());
+            IpcRendererProxy.send = jest.fn(() => Promise.resolve()) as any;
 
             const containerName = "test";
             const expectedContainerPath = [options.folderPath, containerName].join("/");
@@ -95,7 +95,7 @@ describe("LocalFileSystem Proxy Storage Provider", () => {
                 "/test/file4.txt",
             ];
 
-            IpcRendererProxy.send = jest.fn(() => Promise.resolve(expectedFiles));
+            IpcRendererProxy.send = jest.fn(() => Promise.resolve(expectedFiles)) as any;
 
             const containerName = "test";
             const expectedContainerPath = [options.folderPath, containerName].join("/");
@@ -113,7 +113,7 @@ describe("LocalFileSystem Proxy Storage Provider", () => {
                 "/test/folder4",
             ];
 
-            IpcRendererProxy.send = jest.fn(() => Promise.resolve(expectedFolders));
+            IpcRendererProxy.send = jest.fn(() => Promise.resolve(expectedFolders)) as any;
 
             const containerName = "test";
             const expectedContainerPath = [options.folderPath, containerName].join("/");

src/providers/storage/storageProviderFactory.ts

@@ -101,7 +101,7 @@ export class StorageProviderFactory {
      * @param connection Connection for a Storage Provider
      */
     public static createFromConnection(connection: IConnection) {
-        return this.create(connection.providerType, connection.providerOptions);
+        return StorageProviderFactory.create(connection.providerType, connection.providerOptions);
     }
 
     /**

src/react/components/common/alert/alert.test.tsx

@@ -3,25 +3,30 @@ import { mount, ReactWrapper } from "enzyme";
 import Alert, { IAlertProps, IAlertState } from "./alert";
 
 describe("Alert component", () => {
-    const modalCloseHandler = jest.fn();
-    const defaultProps: IAlertProps = {
-        title: "Test Title",
-        message: "Test Message",
-        onClose: modalCloseHandler,
-        show: false,
-    };
+    let modalCloseHandler = null;
+    let defaultProps: IAlertProps = null;
 
     function createComponent(props: IAlertProps): ReactWrapper<IAlertProps, IAlertState, Alert> {
         return mount(<Alert {...props}></Alert>);
     }
 
+    beforeEach(() => {
+        modalCloseHandler = jest.fn();
+        defaultProps = {
+            title: "Test Title",
+            message: "Test Message",
+            onClose: modalCloseHandler,
+            show: false,
+        };
+    });
+
     it("Is defined", () => {
         expect(Alert).toBeDefined();
     });
 
     it("Renders nothing if not activated", () => {
         const wrapper = createComponent(defaultProps);
-        expect(wrapper.html()).toBeNull();
+        expect(wrapper.html()).toEqual("");
     });
 
     it("Renders modal when activated", () => {
@@ -52,7 +57,7 @@ describe("Alert component", () => {
     });
 
     it("Calls onClose handler when clicking positive button", () => {
-        const arg = {value: "test"};
+        const arg = { value: "test" };
         const wrapper = createComponent(defaultProps);
 
         wrapper.instance().open(arg);

src/react/components/common/assetPreview/assetPreview.test.tsx

@@ -11,29 +11,15 @@ describe("Asset Preview Component", () => {
     let wrapper: ReactWrapper<IAssetPreviewProps, IAssetPreviewState> = null;
     // tslint:disable-next-line:max-line-length
     const dataUri = "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7";
-    const onLoadedHandler = jest.fn();
-    const onErrorHandler = jest.fn();
-    const onActivatedHandler = jest.fn();
-    const onDeactivatedHandler = jest.fn();
-    const onChildAssetSelectedHandler = jest.fn();
-    const onAssetChangedHandler = jest.fn();
-    const onBeforeAssetChangedHandler = jest.fn(() => true);
+    let onLoadedHandler = null;
+    let onErrorHandler = null;
+    let onActivatedHandler = null;
+    let onDeactivatedHandler = null;
+    let onChildAssetSelectedHandler = null;
+    let onAssetChangedHandler = null;
+    let onBeforeAssetChangedHandler = null;
 
-    const defaultProps: IAssetPreviewProps = {
-        asset: {
-            ...MockFactory.createTestAsset("test-image-asset"),
-            path: dataUri,
-        },
-        autoPlay: false,
-        controlsEnabled: true,
-        onLoaded: onLoadedHandler,
-        onError: onErrorHandler,
-        onActivated: onActivatedHandler,
-        onDeactivated: onDeactivatedHandler,
-        onBeforeAssetChanged: onBeforeAssetChangedHandler,
-        onAssetChanged: onAssetChangedHandler,
-        onChildAssetSelected: onChildAssetSelectedHandler,
-    };
+    let defaultProps: IAssetPreviewProps = null;
 
     function createComponent(props?: IAssetPreviewProps): ReactWrapper<IAssetPreviewProps, IAssetPreviewState> {
         props = props || defaultProps;
@@ -41,6 +27,31 @@ describe("Asset Preview Component", () => {
     }
 
     beforeEach(() => {
+        onLoadedHandler = jest.fn();
+        onErrorHandler = jest.fn();
+        onActivatedHandler = jest.fn();
+        onDeactivatedHandler = jest.fn();
+        onChildAssetSelectedHandler = jest.fn();
+        onAssetChangedHandler = jest.fn();
+        onBeforeAssetChangedHandler = jest.fn(() => true);
+
+        defaultProps = {
+            asset: {
+                ...MockFactory.createTestAsset("test-image-asset"),
+                path: dataUri,
+            },
+            autoPlay: false,
+            controlsEnabled: true,
+            onLoaded: onLoadedHandler,
+            onError: onErrorHandler,
+            onActivated: onActivatedHandler,
+            onDeactivated: onDeactivatedHandler,
+            onBeforeAssetChanged: onBeforeAssetChangedHandler,
+            onAssetChanged: onAssetChangedHandler,
+            onChildAssetSelected: onChildAssetSelectedHandler,
+        };
+
+
         onLoadedHandler.mockClear();
         onErrorHandler.mockClear();
         onActivatedHandler.mockClear();

src/react/components/common/assetPreview/tfrecordAsset.test.tsx

@@ -14,13 +14,21 @@ describe("TFRecord Asset Component", () => {
 
     let wrapper: ReactWrapper<IAssetProps> = null;
 
-    const onLoadHandler = jest.fn();
-    const onActivatedHandler = jest.fn();
-    const onDeactivatedHandler = jest.fn();
-    const onErrorHandler = jest.fn();
+    let onLoadHandler = null;
+    let onActivatedHandler = null;
+    let onDeactivatedHandler = null;
+    let onErrorHandler = null;
 
     let tfRecords: Buffer;
+
+    let defaultProps: IAssetProps = null;
+
     beforeEach(() => {
+        onLoadHandler = jest.fn();
+        onActivatedHandler = jest.fn();
+        onDeactivatedHandler = jest.fn();
+        onErrorHandler = jest.fn();
+
         let builder: TFRecordsBuilder;
         builder = new TFRecordsBuilder();
         builder.addFeature("image/encoded", FeatureType.Binary, dataImage);
@@ -30,22 +38,22 @@ describe("TFRecord Asset Component", () => {
 
         onLoadHandler.mockClear();
         onErrorHandler.mockClear();
-    });
 
-    HtmlFileReader.getAssetArray = jest.fn((asset) => {
-        return Promise.resolve<ArrayBuffer>(new Uint8Array(tfRecords).buffer);
-    });
+        HtmlFileReader.getAssetArray = jest.fn((asset) => {
+            return Promise.resolve<ArrayBuffer>(new Uint8Array(tfRecords).buffer);
+        });
 
-    const defaultProps: IAssetProps = {
-        asset: {
-            ...MockFactory.createTestAsset("test"),
-            path: "abc",
-        },
-        onLoaded: onLoadHandler,
-        onActivated: onActivatedHandler,
-        onDeactivated: onDeactivatedHandler,
-        onError: onErrorHandler,
-    };
+        defaultProps = {
+            asset: {
+                ...MockFactory.createTestAsset("test"),
+                path: "abc",
+            },
+            onLoaded: onLoadHandler,
+            onActivated: onActivatedHandler,
+            onDeactivated: onDeactivatedHandler,
+            onError: onErrorHandler,
+        };
+    });
 
     function createComponent(props?: IAssetProps): ReactWrapper<IAssetProps, ITFRecordState> {
         props = props || defaultProps;
@@ -98,7 +106,7 @@ describe("TFRecord Asset Component", () => {
     });
 
     it("raises onError handler when there is an error reading image data from tf record", async () => {
-        HtmlFileReader.getAssetArray = jest.fn(() => Promise.resolve());
+        HtmlFileReader.getAssetArray = jest.fn(() => Promise.resolve()) as any;
 
         wrapper = createComponent();
         await MockFactory.flushUi();

src/react/components/common/assetPreview/videoAsset.test.tsx

@@ -17,25 +17,32 @@ describe("Video Asset Component", () => {
         seeking: false,
     };
     const videoPlayerMock = Player as jest.Mocked<typeof Player>;
-    const onLoadedHandler = jest.fn();
-    const onActivatedHandler = jest.fn();
-    const onDeactivatedHandler = jest.fn();
-    const onChildSelectedHandler = jest.fn();
-    const onBeforeAssetChangedHandler = jest.fn(() => true);
-    const defaultProps: IVideoAssetProps = {
-        asset: MockFactory.createVideoTestAsset("test-video"),
-        autoPlay: true,
-        controlsEnabled: true,
-        timestamp: 0,
-        onLoaded: onLoadedHandler,
-        onActivated: onActivatedHandler,
-        onDeactivated: onDeactivatedHandler,
-        onChildAssetSelected: onChildSelectedHandler,
-        onBeforeAssetChanged: onBeforeAssetChangedHandler,
-        additionalSettings: { videoSettings: { frameExtractionRate: 1 } },
-    };
+    let onLoadedHandler = null;
+    let onActivatedHandler = null;
+    let onDeactivatedHandler = null;
+    let onChildSelectedHandler = null;
+    let onBeforeAssetChangedHandler = null;
+    let defaultProps: IVideoAssetProps = null;
 
     beforeEach(() => {
+        onLoadedHandler = jest.fn();
+        onActivatedHandler = jest.fn();
+        onDeactivatedHandler = jest.fn();
+        onChildSelectedHandler = jest.fn();
+        onBeforeAssetChangedHandler = jest.fn(() => true);
+        defaultProps = {
+            asset: MockFactory.createVideoTestAsset("test-video"),
+            autoPlay: true,
+            controlsEnabled: true,
+            timestamp: 0,
+            onLoaded: onLoadedHandler,
+            onActivated: onActivatedHandler,
+            onDeactivated: onDeactivatedHandler,
+            onChildAssetSelected: onChildSelectedHandler,
+            onBeforeAssetChanged: onBeforeAssetChangedHandler,
+            additionalSettings: { videoSettings: { frameExtractionRate: 1 } },
+        };
+
         videoPlayerMock.prototype.getState = jest.fn(() => ({ player: videoPlayerState }));
         videoPlayerMock.prototype.subscribeToStateChange = jest.fn((handler) => onVideoStateChangeHandler = handler);
         videoPlayerMock.prototype.pause = jest.fn();

src/react/components/common/cloudFilePicker/cloudFilePicker.test.tsx

@@ -8,20 +8,23 @@ import { IConnection } from "../../../../models/applicationState";
 describe("CloudFilePicker", () => {
 
     const mockFiles = MockFactory.createFileList();
-
-    const mockStorageProvider = MockFactory.createStorageProvider();
-    StorageProviderFactory.createFromConnection = jest.fn(
-        (connection: IConnection) => MockFactory.createStorageProviderFromConnection(connection));
+    let mockStorageProvider = null;
 
     function createComponent(props: ICloudFilePickerProps):
-            ReactWrapper<ICloudFilePickerProps, ICloudFilePickerState, CloudFilePicker> {
-        return mount(<CloudFilePicker {...props}/>);
+        ReactWrapper<ICloudFilePickerProps, ICloudFilePickerState, CloudFilePicker> {
+        return mount(<CloudFilePicker {...props} />);
     }
 
     function flushPromises() {
         return new Promise((resolve) => setImmediate(resolve));
     }
 
+    beforeEach(() => {
+        mockStorageProvider = MockFactory.createStorageProvider();
+        StorageProviderFactory.createFromConnection = jest.fn(
+            (connection: IConnection) => MockFactory.createStorageProviderFromConnection(connection));
+    });
+
     it("modal is visible", async () => {
         const connections = MockFactory.createTestConnections();
         const onCancel = jest.fn();

src/react/components/common/confirm/confirm.test.tsx

@@ -3,29 +3,35 @@ import { mount, ReactWrapper } from "enzyme";
 import Confirm, { IConfirmProps, IConfirmState } from "./confirm";
 
 describe("Confirm component", () => {
-    const modalConfirmHandler = jest.fn();
-    const modalCancelHandler = jest.fn();
-    const defaultProps: IConfirmProps = {
-        title: "Test Title",
-        message: "Test Message",
-        onConfirm: modalConfirmHandler,
-        onCancel: modalCancelHandler,
-    };
+    let modalConfirmHandler = null;
+    let modalCancelHandler = null;
+    let defaultProps: IConfirmProps = null;
 
     function createComponent(props: IConfirmProps): ReactWrapper<IConfirmProps, IConfirmState, Confirm> {
         return mount(<Confirm {...props}></Confirm>);
     }
 
+    beforeEach(() => {
+        modalConfirmHandler = jest.fn();
+        modalCancelHandler = jest.fn();
+        defaultProps = {
+            title: "Test Title",
+            message: "Test Message",
+            onConfirm: modalConfirmHandler,
+            onCancel: modalCancelHandler,
+        };
+    });
+
     it("Is defined", () => {
         expect(Confirm).toBeDefined();
     });
 
-    it("Renders nothing if not activiated", () => {
+    it("Renders nothing if not activated", () => {
         const wrapper = createComponent(defaultProps);
-        expect(wrapper.html()).toBeNull();
+        expect(wrapper.html()).toEqual("");
     });
 
-    it("Renders modal when activiated", () => {
+    it("Renders modal when activated", () => {
         const wrapper = createComponent(defaultProps);
 
         wrapper.instance().open();

src/react/components/common/connectionProviderPicker/connectionProviderPicker.test.tsx

@@ -10,29 +10,35 @@ jest.mock("../../../../providers/storage/assetProviderFactory");
 import { AssetProviderFactory } from "../../../../providers/storage/assetProviderFactory";
 
 describe("Connection Provider Picker", () => {
-    const storageProviderRegistrations = MockFactory.createStorageProviderRegistrations();
-    const assetProviderRegistrations = MockFactory.createAssetProviderRegistrations();
-
+    let storageProviderRegistrations = [];
+    let assetProviderRegistrations = [];
     let wrapper: ReactWrapper;
-
-    const onChangeHandler = jest.fn();
-    const defaultProps: IConnectionProviderPickerProps = {
-        id: "test-connection-provider-picker",
-        value: "",
-        onChange: onChangeHandler,
-    };
+    let onChangeHandler = null;
+    let defaultProps: IConnectionProviderPickerProps = null;
 
     function createComponent(props: IConnectionProviderPickerProps) {
         return mount(<ConnectionProviderPicker {...props} />);
     }
 
-    beforeAll(() => {
+    beforeEach(() => {
+        storageProviderRegistrations = MockFactory.createStorageProviderRegistrations();
+        assetProviderRegistrations = MockFactory.createAssetProviderRegistrations();
+
+        onChangeHandler = jest.fn();
+        defaultProps = {
+            id: "test-connection-provider-picker",
+            value: "",
+            onChange: onChangeHandler,
+        };
+
         Object.defineProperty(StorageProviderFactory, "providers", {
             get: jest.fn(() => storageProviderRegistrations),
+            configurable: true,
         });
 
         Object.defineProperty(AssetProviderFactory, "providers", {
             get: jest.fn(() => assetProviderRegistrations),
+            configurable: true,
         });
     });
 
@@ -61,7 +67,7 @@ describe("Connection Provider Picker", () => {
             expect(picker.find("option").length).toEqual(allProviders.length + 1);
         });
 
-        it("Calls registred onChange handler when value changes", async () => {
+        it("Calls registered onChange handler when value changes", async () => {
             await MockFactory.flushUi(() => {
                 wrapper.find("select").simulate("change", { target: { value: assetProviderRegistrations[1].name } });
             });

src/react/components/common/exportProviderPicker/exportProviderPicker.test.tsx

@@ -1,75 +1,78 @@
-import React from "react";
-import { mount, ReactWrapper } from "enzyme";
-import _ from "lodash";
-import ExportProviderPicker, { IExportProviderPickerProps } from "./exportProviderPicker";
-import MockFactory from "../../../../common/mockFactory";
-
-jest.mock("../../../../providers/export/exportProviderFactory");
-import { ExportProviderFactory } from "../../../../providers/export/exportProviderFactory";
-
-describe("Export Provider Picker", () => {
-    const exportProviderRegistrations = MockFactory.createExportProviderRegistrations();
-
-    let wrapper: ReactWrapper;
-
-    const onChangeHandler = jest.fn();
-    const defaultProps: IExportProviderPickerProps = {
-        id: "test-export-provider-picker",
-        value: "azureCustomVision",
-        onChange: onChangeHandler,
-    };
-
-    function createComponent(props: IExportProviderPickerProps) {
-        return mount(<ExportProviderPicker {...props} />);
-    }
-
-    beforeAll(() => {
-        Object.defineProperty(ExportProviderFactory, "providers", {
-            get: jest.fn(() => exportProviderRegistrations),
-        });
-    });
-
-    describe("With default properties", () => {
-        beforeEach(() => {
-            wrapper = createComponent(defaultProps);
-        });
-
-        it("Renders a dropdown with all export providers", () => {
-            const exportProviders = _.values(exportProviderRegistrations);
-
-            const allProviders = _([])
-                .concat(exportProviders)
-                .orderBy("displayName")
-                .value();
-
-            const picker = wrapper.find("select");
-            const htmlNode = picker.getDOMNode() as HTMLSelectElement;
-
-            // Count of unique providers + the "Select" option
-            expect(htmlNode.id).toEqual(defaultProps.id);
-            expect(htmlNode.value).toEqual(defaultProps.value);
-            expect(picker.find("option").length).toEqual(allProviders.length);
-        });
-
-        it("Calls registred onChange handler when value changes", async () => {
-            await MockFactory.flushUi(() => {
-                wrapper.find("select").simulate("change", { target: { value: exportProviderRegistrations[1].name } });
-            });
-
-            expect(onChangeHandler).toBeCalledWith(exportProviderRegistrations[1].name);
-        });
-    });
-
-    describe("With property overrides", () => {
-        it("Selects correct option based on value", () => {
-            const props = {
-                ...defaultProps,
-                value: exportProviderRegistrations[1].name,
-            };
-            wrapper = createComponent(props);
-
-            const htmlNode = wrapper.find("select").getDOMNode() as HTMLSelectElement;
-            expect(htmlNode.value).toEqual(props.value);
-        });
-    });
-});
+import React from "react";
+import { mount, ReactWrapper } from "enzyme";
+import _ from "lodash";
+import ExportProviderPicker, { IExportProviderPickerProps } from "./exportProviderPicker";
+import MockFactory from "../../../../common/mockFactory";
+
+jest.mock("../../../../providers/export/exportProviderFactory");
+import { ExportProviderFactory } from "../../../../providers/export/exportProviderFactory";
+
+describe("Export Provider Picker", () => {
+    let exportProviderRegistrations = null;
+    let wrapper: ReactWrapper;
+    let onChangeHandler = null;
+    let defaultProps: IExportProviderPickerProps = null;
+
+    function createComponent(props: IExportProviderPickerProps) {
+        return mount(<ExportProviderPicker {...props} />);
+    }
+
+    beforeEach(() => {
+        exportProviderRegistrations = MockFactory.createExportProviderRegistrations();
+        onChangeHandler = jest.fn();
+        defaultProps = {
+            id: "test-export-provider-picker",
+            value: "azureCustomVision",
+            onChange: onChangeHandler,
+        };
+
+        Object.defineProperty(ExportProviderFactory, "providers", {
+            get: jest.fn(() => exportProviderRegistrations),
+            configurable: true
+        });
+    });
+
+    describe("With default properties", () => {
+        beforeEach(() => {
+            wrapper = createComponent(defaultProps);
+        });
+
+        it("Renders a dropdown with all export providers", () => {
+            const exportProviders = _.values(exportProviderRegistrations);
+
+            const allProviders = _([])
+                .concat(exportProviders)
+                .orderBy("displayName")
+                .value();
+
+            const picker = wrapper.find("select");
+            const htmlNode = picker.getDOMNode() as HTMLSelectElement;
+
+            // Count of unique providers + the "Select" option
+            expect(htmlNode.id).toEqual(defaultProps.id);
+            expect(htmlNode.value).toEqual(defaultProps.value);
+            expect(picker.find("option").length).toEqual(allProviders.length);
+        });
+
+        it("Calls registred onChange handler when value changes", async () => {
+            await MockFactory.flushUi(() => {
+                wrapper.find("select").simulate("change", { target: { value: exportProviderRegistrations[1].name } });
+            });
+
+            expect(onChangeHandler).toBeCalledWith(exportProviderRegistrations[1].name);
+        });
+    });
+
+    describe("With property overrides", () => {
+        it("Selects correct option based on value", () => {
+            const props = {
+                ...defaultProps,
+                value: exportProviderRegistrations[1].name,
+            };
+            wrapper = createComponent(props);
+
+            const htmlNode = wrapper.find("select").getDOMNode() as HTMLSelectElement;
+            expect(htmlNode.value).toEqual(props.value);
+        });
+    });
+});

src/react/components/common/externalPicker/externalPicker.test.tsx

@@ -5,29 +5,8 @@ import ExternalPicker, { IExternalPickerProps, IExternalPickerState, FilterOpera
 import MockFactory from "../../../../common/mockFactory";
 
 describe("External Picker", () => {
-    const onChangeHandler = jest.fn();
-    const defaultProps = createProps({
-        id: "my-custom-control",
-        value: "",
-        schema: {
-            title: "Item Name",
-        },
-        formContext: {
-            providerOptions: {
-                apiKey: "",
-                region: "",
-            },
-        },
-        onChange: onChangeHandler,
-        options: {
-            method: "GET",
-            url: "https://${props.formContext.providerOptions.region}.server.com/api",
-            keySelector: "${item.key}",
-            valueSelector: "${item.value}",
-            authHeaderName: "Authorization",
-            authHeaderValue: "${props.formContext.providerOptions.apiKey}",
-        },
-    });
+    let onChangeHandler = null;
+    let defaultProps = null;
 
     const testResponse = [
         { key: "1", value: "Option 1" },
@@ -40,12 +19,36 @@ describe("External Picker", () => {
         return mount(<ExternalPicker {...props} />);
     }
 
-    beforeAll(() => {
+    beforeEach(() => {
+        onChangeHandler = jest.fn();
+        defaultProps = createProps({
+            id: "my-custom-control",
+            value: "",
+            schema: {
+                title: "Item Name",
+            },
+            formContext: {
+                providerOptions: {
+                    apiKey: "",
+                    region: "",
+                },
+            },
+            onChange: onChangeHandler,
+            options: {
+                method: "GET",
+                url: "https://${props.formContext.providerOptions.region}.server.com/api",
+                keySelector: "${item.key}",
+                valueSelector: "${item.value}",
+                authHeaderName: "Authorization",
+                authHeaderValue: "${props.formContext.providerOptions.apiKey}",
+            },
+        });
+
         axios.request = jest.fn(() => {
             return Promise.resolve({
                 data: testResponse,
             });
-        });
+        }) as any;
     });
 
     it("Renders select element with default option", () => {

src/react/components/common/filePicker/filePicker.test.tsx

@@ -1,12 +1,13 @@
-import React, { RefObject } from "react";
+import React from "react";
 import { ReactWrapper, mount } from "enzyme";
 import FilePicker from "./filePicker";
 import HtmlFileReader from "../../../../common/htmlFileReader";
+import MockFactory from "../../../../common/mockFactory";
 
 describe("File Picker Component", () => {
     let wrapper: ReactWrapper = null;
-    const onChangeHandler = jest.fn();
-    const onErrorHandler = jest.fn();
+    let onChangeHandler = null;
+    let onErrorHandler = null;
 
     function createComponent(): ReactWrapper {
         return mount(
@@ -17,6 +18,8 @@ describe("File Picker Component", () => {
     }
 
     beforeEach(() => {
+        onChangeHandler = jest.fn();
+        onErrorHandler = jest.fn();
         wrapper = createComponent();
     });
 
@@ -26,9 +29,9 @@ describe("File Picker Component", () => {
         expect(input.prop("type")).toEqual("file");
     });
 
-    it("Calls the onChange handler on successfull file upload", (done) => {
+    it("Calls the onChange handler on successfully file upload", (done) => {
         const expectedContent = "test file content";
-        HtmlFileReader.readAsText = jest.fn(() => Promise.resolve(expectedContent));
+        HtmlFileReader.readAsText = jest.fn(() => Promise.resolve(expectedContent)) as any;
         const event: any = {
             target: {
                 files: ["text.txt"],
@@ -43,7 +46,7 @@ describe("File Picker Component", () => {
         });
     });
 
-    it("Calls the onError handler on errored / cancelled file upload", (done) => {
+    it("Calls the onError handler on error / cancelled file upload", async () => {
         const event: any = {
             target: {
                 files: [],
@@ -52,9 +55,7 @@ describe("File Picker Component", () => {
 
         wrapper.find("input").first().simulate("change", event);
 
-        setImmediate(() => {
-            expect(onErrorHandler).toBeCalledWith(expect.anything(), "No files were selected");
-            done();
-        });
+        await MockFactory.flushUi();
+        expect(onErrorHandler).toBeCalledWith(expect.anything(), "No files were selected");
     });
 });

src/react/components/common/filePicker/filePicker.tsx

@@ -42,7 +42,7 @@ export default class FilePicker extends React.Component<IFilePickerProps> {
 
     private onFileUploaded = (e) => {
         if (e.target.files.length === 0) {
-            this.props.onError(e, "No files were selected");
+            return this.props.onError(e, "No files were selected");
         }
 
         HtmlFileReader.readAsText(e.target.files[0])

src/react/components/common/keyboardBinding/keyboardBinding.test.tsx

@@ -8,19 +8,12 @@ import { KeyboardRegistrationManager } from "../keyboardManager/keyboardRegistra
 
 describe("Keyboard Binding Component", () => {
     let wrapper: ReactWrapper = null;
-    const onKeyDownHandler = jest.fn();
-    const deregisterFunc = jest.fn();
-
+    let onKeyDownHandler = null;
+    let deregisterFunc = null;
+    let defaultProps: IKeyboardBindingProps = null
     const accelerators = ["CmdOrCtrl+1"];
-    const defaultProps: IKeyboardBindingProps = {
-        displayName: "Keyboard binding",
-        keyEventType: KeyEventType.KeyDown,
-        accelerators,
-        handler: onKeyDownHandler,
-    };
 
-    const registrationMock = KeyboardRegistrationManager as jest.Mocked<typeof KeyboardRegistrationManager>;
-    registrationMock.prototype.registerBinding = jest.fn(() => deregisterFunc);
+    let registrationMock = null;
 
     function createComponent(props?: IKeyboardBindingProps): ReactWrapper {
         props = props || defaultProps;
@@ -32,6 +25,21 @@ describe("Keyboard Binding Component", () => {
         );
     }
 
+    beforeEach(() => {
+        onKeyDownHandler = jest.fn();
+        deregisterFunc = jest.fn();
+
+        defaultProps = {
+            displayName: "Keyboard binding",
+            keyEventType: KeyEventType.KeyDown,
+            accelerators,
+            handler: onKeyDownHandler,
+        };
+
+        registrationMock = KeyboardRegistrationManager as jest.Mocked<typeof KeyboardRegistrationManager>;
+        registrationMock.prototype.registerBinding = jest.fn(() => deregisterFunc);
+    });
+
     it("is defined", () => {
         wrapper = createComponent();
         expect(wrapper).not.toBeNull();

src/react/components/pages/activeLearning/activeLearningForm.test.tsx

@@ -72,16 +72,16 @@ describe("Active Learning Form", () => {
         };
 
         // Set type to URL
-        wrapper.find(Form).props().onChange({ formData: { modelPathType: ModelPathType.Url } });
+        wrapper.find(Form).props().onChange({ formData: { modelPathType: ModelPathType.Url } } as any);
         // Set the remaining settings
-        wrapper.find(Form).props().onChange({ formData });
+        wrapper.find(Form).props().onChange({ formData } as any);
         expect(wrapper.state().formData).toEqual(formData);
         expect(onChangeHandler).toBeCalledWith(formData);
     });
 
     it("submits form data to the registered submit handler", () => {
         const wrapper = createComponent();
-        wrapper.find(Form).props().onSubmit({ formData: defaultProps.settings });
+        wrapper.find(Form).props().onSubmit({ formData: defaultProps.settings } as any);
 
         expect(onSubmitHandler).toBeCalledWith(defaultProps.settings);
     });

src/react/components/pages/editorPage/canvas.test.tsx

@@ -66,7 +66,7 @@ describe("Editor Canvas", () => {
 
     const editorMock = Editor as any;
 
-    beforeAll(() => {
+    beforeEach(() => {
         let selectionMode = {
             mode: SelectionMode.NONE,
             template: null,

src/react/components/pages/editorPage/editorPage.test.tsx

@@ -75,7 +75,7 @@ describe("Editor Page Component", () => {
 
     beforeAll(() => {
         registerToolbar();
-        window["require"] = jest.fn(() => electronMock);
+        window["require"] = jest.fn(() => electronMock) as any;
 
         const editorMock = Editor as any;
         editorMock.prototype.addContentSource = jest.fn(() => Promise.resolve());

src/react/components/pages/export/exportForm.test.tsx

@@ -11,6 +11,7 @@ import { IVottJsonExportProviderOptions } from "../../../../providers/export/vot
 
 describe("Export Form Component", () => {
     const exportProviderRegistrations = MockFactory.createExportProviderRegistrations();
+    let onSubmitHandler = null;
 
     function createComponent(props: IExportFormProps) {
         return mount(
@@ -18,17 +19,19 @@ describe("Export Form Component", () => {
         );
     }
 
-    beforeAll(() => {
+    beforeEach(() => {
+        onSubmitHandler = jest.fn();
+
         Object.defineProperty(ExportProviderFactory, "providers", {
             get: jest.fn(() => exportProviderRegistrations),
+            configurable: true,
         });
         Object.defineProperty(ExportProviderFactory, "defaultProvider", {
             get: jest.fn(() => exportProviderRegistrations[0]),
+            configurable: true,
         });
     });
 
-    const onSubmitHandler = jest.fn();
-
     it("State is initialized without export settings", () => {
         const defaultExportType = "vottJson";
         const props: IExportFormProps = {

src/react/components/pages/export/exportPage.test.tsx

@@ -84,7 +84,7 @@ describe("Export Page", () => {
             return {
                 export: jest.fn(() => Promise.resolve()),
             };
-        });
+        }) as any;
 
         projectServiceMock.prototype.save = jest.fn((project) => Promise.resolve(project));
 

src/react/components/pages/homepage/homePage.test.tsx

@@ -36,7 +36,7 @@ describe("Homepage Component", () => {
         writeText: jest.fn((project) => Promise.resolve(project)),
         deleteFile: jest.fn(() => Promise.resolve()),
     };
-    StorageProviderFactory.create = jest.fn(() => storageProviderMock);
+    StorageProviderFactory.create = jest.fn(() => storageProviderMock) as any;
 
     function createComponent(store, props: IHomePageProps): ReactWrapper {
         return mount(

src/react/components/pages/projectSettings/projectSettingsPage.test.tsx

@@ -53,7 +53,7 @@ describe("Project settings page", () => {
         localStorageMock.removeItem.mockClear();
 
         projectServiceMock = ProjectService as jest.Mocked<typeof ProjectService>;
-        projectServiceMock.prototype.load = jest.fn((project) => ({ ...project }));
+        projectServiceMock.prototype.load = jest.fn((project) => ({ ...project })) as any;
     });
 
     it("Form submission calls save project action", async () => {

src/react/components/shell/helpMenu.test.tsx

@@ -2,8 +2,10 @@ import { mount } from "enzyme";
 import React from "react";
 import MockFactory from "../../../common/mockFactory";
 import { KeyboardManager } from "../common/keyboardManager/keyboardManager";
-import { IKeyboardRegistrations,
-    KeyboardRegistrationManager } from "../common/keyboardManager/keyboardRegistrationManager";
+import {
+    IKeyboardRegistrations,
+    KeyboardRegistrationManager
+} from "../common/keyboardManager/keyboardRegistrationManager";
 import { HelpMenu, IHelpMenuProps } from "./helpMenu";
 jest.mock("../common/keyboardManager/keyboardRegistrationManager");
 
@@ -11,16 +13,20 @@ describe("Help Menu", () => {
     function createComponent(props?: IHelpMenuProps) {
         return mount(
             <KeyboardManager>
-                <HelpMenu {...props}/>
+                <HelpMenu {...props} />
             </KeyboardManager>,
         );
     }
     const numberRegistrations = 5;
     const keyboardRegistrations: IKeyboardRegistrations = MockFactory.createKeyboardRegistrations(numberRegistrations);
-    const registrationMock = KeyboardRegistrationManager as jest.Mocked<typeof KeyboardRegistrationManager>;
+    let registrationMock = null;
 
-    registrationMock.prototype.getRegistrations = jest.fn(() => keyboardRegistrations);
-    registrationMock.prototype.registerBinding = jest.fn(() => jest.fn());
+    beforeEach(() => {
+        registrationMock = KeyboardRegistrationManager as jest.Mocked<typeof KeyboardRegistrationManager>;
+
+        registrationMock.prototype.getRegistrations = jest.fn(() => keyboardRegistrations);
+        registrationMock.prototype.registerBinding = jest.fn(() => jest.fn());
+    });
 
     it("Opens when button is clicked", () => {
         const wrapper = createComponent();
@@ -51,7 +57,7 @@ describe("Help Menu", () => {
 
     it("Calls onClose handler when closed", () => {
         const onClose = jest.fn();
-        const wrapper = createComponent({onClose});
+        const wrapper = createComponent({ onClose });
         wrapper.find("div.help-menu-button").simulate("click");
         expect(wrapper.exists("div.modal-content")).toBe(true);
         wrapper.find("button.close").simulate("click");

src/react/components/shell/mainContentRouter.test.tsx

@@ -34,7 +34,7 @@ describe("Main Content Router", () => {
     it("renders correct routes", () => {
         const wrapper = shallow(<MainContentRouter />);
         const pathMap = wrapper.find(Route).reduce((pathMap, route) => {
-            const routeProps = route.props();
+            const routeProps = route.props() as any;
             pathMap[routeProps.path] = routeProps.component;
             return pathMap;
         }, {});

src/react/components/shell/titleBar.test.tsx

@@ -98,7 +98,7 @@ describe("TileBar Component", () => {
 
     describe("Electron", () => {
         beforeAll(() => {
-            window["require"] = jest.fn(() => electronMock);
+            window["require"] = jest.fn(() => electronMock) as any;
         });
 
         describe("Windows", () => {

src/react/components/shell/titleBar.tsx

@@ -27,7 +27,7 @@ export class TitleBar extends React.Component<ITitleBarProps, ITitleBarState> {
         menu: null,
     };
 
-    private menu: Menu = React.createRef();
+    private menu: Menu = React.createRef() as any;
     private remote: Electron.Remote;
     private currentWindow: Electron.BrowserWindow;
 
@@ -73,11 +73,11 @@ export class TitleBar extends React.Component<ITitleBarProps, ITitleBarState> {
                 }
                 {this.state.platform === PlatformType.Windows &&
                     <div className="title-bar-menu">
-                        <Menu ref={this.menu}
+                        <Menu ref={this.menu as any}
                             mode="horizontal"
                             selectable={false}
                             triggerSubMenuAction="click"
-                            onClick={this.onMenuItemSelected}>
+                            onClick={this.onMenuItemSelected as any}>
                             {this.renderMenu(this.state.menu)}
                         </Menu>
                     </div>
@@ -211,7 +211,7 @@ export class TitleBar extends React.Component<ITitleBarProps, ITitleBarState> {
 
     private onMenuItemSelected = (key: string, item: React.Component) => {
         // Required to auto-close the menu after user selects an item.
-        this.menu.current.store.setState({
+        (this.menu as any).current.store.setState({
             openKeys: [],
             selectedKeys: [],
         });

src/react/components/toolbar/saveProject.test.tsx

@@ -40,7 +40,7 @@ describe("Save Project Toolbar Item", () => {
     });
 
     it("Calls save project action with successfull result", async () => {
-        actions.saveProject = jest.fn(() => Promise.resolve());
+        actions.saveProject = jest.fn(() => Promise.resolve()) as any;
         const props = createProps();
         wrapper = createComponent(props);
 

src/redux/actions/applicationActions.test.ts

@@ -13,7 +13,7 @@ describe("Application Redux Actions", () => {
     const appSettings = MockFactory.appSettings();
 
     beforeEach(() => {
-        IpcRendererProxy.send = jest.fn(() => Promise.resolve());
+        IpcRendererProxy.send = jest.fn(() => Promise.resolve()) as any;
         const middleware = [thunk];
         const mockState: IApplicationState = {
             ...initialState,

src/redux/actions/projectActions.test.ts

@@ -154,7 +154,7 @@ describe("Project Redux Actions", () => {
         const asset = MockFactory.createTestAsset("Asset1");
         const assetMetadata = MockFactory.createTestAssetMetadata(asset);
         const mockAssetService = AssetService as jest.Mocked<typeof AssetService>;
-        mockAssetService.prototype.getAssetMetadata = jest.fn(() => assetMetadata);
+        mockAssetService.prototype.getAssetMetadata = jest.fn(() => assetMetadata) as any;
 
         const project = MockFactory.createTestProject("TestProject");
         const result = await projectActions.loadAssetMetadata(project, asset)(store.dispatch);
@@ -174,7 +174,7 @@ describe("Project Redux Actions", () => {
         const asset = MockFactory.createTestAsset("Asset1");
         const assetMetadata = MockFactory.createTestAssetMetadata(asset);
         const mockAssetService = AssetService as jest.Mocked<typeof AssetService>;
-        mockAssetService.prototype.save = jest.fn(() => assetMetadata);
+        mockAssetService.prototype.save = jest.fn(() => assetMetadata) as any;
 
         const project = MockFactory.createTestProject("TestProject");
         const result = await projectActions.saveAssetMetadata(project, assetMetadata)(store.dispatch);
@@ -194,7 +194,7 @@ describe("Project Redux Actions", () => {
         const asset = MockFactory.createTestAsset("Asset1");
         const assetMetadata = MockFactory.createTestAssetMetadata(asset);
         const mockAssetService = AssetService as jest.Mocked<typeof AssetService>;
-        mockAssetService.prototype.save = jest.fn(() => assetMetadata);
+        mockAssetService.prototype.save = jest.fn(() => assetMetadata) as any;
 
         const project = MockFactory.createTestProject("TestProject");
         const result = await projectActions.saveAssetMetadata(project, assetMetadata)(store.dispatch);

src/redux/reducers/currentProjectReducer.ts

@@ -46,7 +46,7 @@ export const reducer = (state: IProject = null, action: AnyAction): IProject =>
             const newTags: ITag[] = state.tags ? [...state.tags] : [];
             let updateTags = false;
 
-            assetTags.forEach((tag) => {
+            assetTags.forEach((tag: string) => {
                 if (!state.tags || state.tags.length === 0 ||
                     !state.tags.find((projectTag) => tag === projectTag.name)) {
                     newTags.push({

src/services/activeLearningService.test.ts

@@ -13,20 +13,19 @@ describe("Active Learning Service", () => {
     };
 
     let activeLearningService: ActiveLearningService = null;
-
-    const electronMock = {
-        remote: {
-            app: {
-                getAppPath: jest.fn(),
-            },
-        },
-    };
-
-    beforeAll(() => {
-        window["require"] = jest.fn(() => electronMock);
-    });
+    let electronMock = null;
 
     beforeEach(() => {
+        electronMock = {
+            remote: {
+                app: {
+                    getAppPath: jest.fn(),
+                },
+            },
+        };
+
+        window["require"] = jest.fn(() => electronMock) as any;
+
         activeLearningService = new ActiveLearningService(defaultSettings);
         objectDetectionMock.prototype.load = jest.fn(() => Promise.resolve());
         objectDetectionMock.prototype.predictImage = jest.fn(() => Promise.resolve([]));

src/services/assetService.test.ts

@@ -296,10 +296,10 @@ describe("Asset Service", () => {
 
             const buffer = builder.build();
             tfrecords = TFRecordsBuilder.buildTFRecords([buffer]);
-        });
 
-        HtmlFileReader.getAssetArray = jest.fn((asset) => {
-            return Promise.resolve<ArrayBuffer>(new Uint8Array(tfrecords).buffer);
+            HtmlFileReader.getAssetArray = jest.fn((asset) => {
+                return Promise.resolve<ArrayBuffer>(new Uint8Array(tfrecords).buffer);
+            });
         });
 
         it("Loads the asset metadata from the tfrecord file", async () => {

src/services/connectionService.test.ts

@@ -7,7 +7,11 @@ describe("Connection Service", () => {
 
     const storageProvider = MockFactory.createStorageProvider();
 
-    AssetProviderFactory.create = jest.fn(() => storageProvider);
+
+    beforeEach(() => {
+        AssetProviderFactory.create = jest.fn(() => storageProvider);
+
+    });
 
     it("Saves connections", async () => {
         const connection = {

src/services/projectService.test.ts

@@ -1,7 +1,7 @@
 import _ from "lodash";
 import ProjectService, { IProjectService } from "./projectService";
 import MockFactory from "../common/mockFactory";
-import { StorageProviderFactory } from "../providers/storage/storageProviderFactory";
+import { IStorageProvider, StorageProviderFactory } from "../providers/storage/storageProviderFactory";
 import {
     IProject, IExportFormat, ISecurityToken,
     AssetState, IActiveLearningSettings, ModelPathType,
@@ -10,36 +10,39 @@ import { constants } from "../common/constants";
 import { ExportProviderFactory } from "../providers/export/exportProviderFactory";
 import { generateKey } from "../common/crypto";
 import { encryptProject, decryptProject } from "../common/utils";
-import { ExportAssetState } from "../providers/export/exportProvider";
+import { ExportAssetState, IExportProvider } from "../providers/export/exportProvider";
 import { IVottJsonExportProviderOptions } from "../providers/export/vottJson";
 import { IPascalVOCExportProviderOptions } from "../providers/export/pascalVOC";
 
 describe("Project Service", () => {
-    let projectSerivce: IProjectService = null;
+    let projectService: IProjectService = null;
     let testProject: IProject = null;
     let projectList: IProject[] = null;
     let securityToken: ISecurityToken = null;
 
-    const storageProviderMock = {
-        writeText: jest.fn((project) => Promise.resolve(project)),
-        deleteFile: jest.fn(() => Promise.resolve()),
-    };
-
-    const exportProviderMock = {
-        export: jest.fn(() => Promise.resolve()),
-        save: jest.fn((exportFormat: IExportFormat) => Promise.resolve(exportFormat.providerOptions)),
-    };
-
-    StorageProviderFactory.create = jest.fn(() => storageProviderMock);
-    ExportProviderFactory.create = jest.fn(() => exportProviderMock);
+    let storageProviderMock: any;
+    let exportProviderMock: any;
 
     beforeEach(() => {
+        storageProviderMock = {
+            writeText: jest.fn((project) => Promise.resolve(project)),
+            deleteFile: jest.fn(() => Promise.resolve()),
+        } as any;
+
+        exportProviderMock = {
+            export: jest.fn(() => Promise.resolve()),
+            save: jest.fn((exportFormat: IExportFormat) => Promise.resolve(exportFormat.providerOptions)),
+        } as any;
+
+        StorageProviderFactory.create = jest.fn(() => storageProviderMock);
+        ExportProviderFactory.create = jest.fn(() => exportProviderMock);
+
         securityToken = {
             name: "TestToken",
             key: generateKey(),
         };
         testProject = MockFactory.createTestProject("TestProject");
-        projectSerivce = new ProjectService();
+        projectService = new ProjectService();
 
         storageProviderMock.writeText.mockClear();
         storageProviderMock.deleteFile.mockClear();
@@ -47,13 +50,13 @@ describe("Project Service", () => {
 
     it("Load decrypts any project settings using the specified key", async () => {
         const encryptedProject = encryptProject(testProject, securityToken);
-        const decryptedProject = await projectSerivce.load(encryptedProject, securityToken);
+        const decryptedProject = await projectService.load(encryptedProject, securityToken);
 
         expect(decryptedProject).toEqual(testProject);
     });
 
     it("Saves calls project storage provider to write project", async () => {
-        const result = await projectSerivce.save(testProject, securityToken);
+        const result = await projectService.save(testProject, securityToken);
 
         const encryptedProject: IProject = {
             ...testProject,
@@ -84,7 +87,7 @@ describe("Project Service", () => {
 
     it("sets default export settings when not defined", async () => {
         testProject.exportFormat = null;
-        const result = await projectSerivce.save(testProject, securityToken);
+        const result = await projectService.save(testProject, securityToken);
 
         const vottJsonExportProviderOptions: IVottJsonExportProviderOptions = {
             assetState: ExportAssetState.Visited,
@@ -103,7 +106,7 @@ describe("Project Service", () => {
 
     it("sets default active learning setting when not defined", async () => {
         testProject.activeLearningSettings = null;
-        const result = await projectSerivce.save(testProject, securityToken);
+        const result = await projectService.save(testProject, securityToken);
 
         const activeLearningSettings: IActiveLearningSettings = {
             autoDetect: false,
@@ -116,7 +119,7 @@ describe("Project Service", () => {
 
     it("initializes tags to empty array if not defined", async () => {
         testProject.tags = null;
-        const result = await projectSerivce.save(testProject, securityToken);
+        const result = await projectService.save(testProject, securityToken);
 
         expect(result.tags).toEqual([]);
     });
@@ -127,7 +130,7 @@ describe("Project Service", () => {
             providerOptions: null,
         };
 
-        await projectSerivce.save(testProject, securityToken);
+        await projectService.save(testProject, securityToken);
 
         expect(ExportProviderFactory.create).toBeCalledWith(
             testProject.exportFormat.providerType,
@@ -140,7 +143,7 @@ describe("Project Service", () => {
     it("Save throws error if writing to storage provider fails", async () => {
         const expectedError = "Error writing to storage provider";
         storageProviderMock.writeText.mockImplementationOnce(() => Promise.reject(expectedError));
-        await expect(projectSerivce.save(testProject, securityToken)).rejects.toEqual(expectedError);
+        await expect(projectService.save(testProject, securityToken)).rejects.toEqual(expectedError);
     });
 
     it("Save throws error if storage provider cannot be created", async () => {
@@ -148,11 +151,11 @@ describe("Project Service", () => {
         const createMock = StorageProviderFactory.create as jest.Mock;
         createMock.mockImplementationOnce(() => { throw expectedError; });
 
-        await expect(projectSerivce.save(testProject, securityToken)).rejects.toEqual(expectedError);
+        await expect(projectService.save(testProject, securityToken)).rejects.toEqual(expectedError);
     });
 
     it("Delete calls project storage provider to delete project", async () => {
-        await projectSerivce.delete(testProject);
+        await projectService.delete(testProject);
 
         expect(StorageProviderFactory.create).toBeCalledWith(
             testProject.targetConnection.providerType,
@@ -167,7 +170,7 @@ describe("Project Service", () => {
         storageProviderMock.deleteFile
             .mockImplementationOnce(() => Promise.reject(expectedError));
 
-        await expect(projectSerivce.delete(testProject)).rejects.toEqual(expectedError);
+        await expect(projectService.delete(testProject)).rejects.toEqual(expectedError);
     });
 
     it("Delete call fails if storage provider cannot be created", async () => {
@@ -175,20 +178,20 @@ describe("Project Service", () => {
         const createMock = StorageProviderFactory.create as jest.Mock;
         createMock.mockImplementationOnce(() => { throw expectedError; });
 
-        await expect(projectSerivce.delete(testProject)).rejects.toEqual(expectedError);
+        await expect(projectService.delete(testProject)).rejects.toEqual(expectedError);
     });
 
     it("isDuplicate returns false when called with a unique project", async () => {
         testProject = MockFactory.createTestProject("TestProject");
         projectList = MockFactory.createTestProjects();
-        expect(projectSerivce.isDuplicate(testProject, projectList)).toEqual(false);
+        expect(projectService.isDuplicate(testProject, projectList)).toEqual(false);
     });
 
     it("isDuplicate returns true when called with a duplicate project", async () => {
         testProject = MockFactory.createTestProject("1");
         testProject.id = undefined;
         projectList = MockFactory.createTestProjects();
-        expect(projectSerivce.isDuplicate(testProject, projectList)).toEqual(true);
+        expect(projectService.isDuplicate(testProject, projectList)).toEqual(true);
     });
 
     it("deletes all asset metadata files when project is deleted", async () => {
@@ -199,7 +202,7 @@ describe("Project Service", () => {
 
         testProject.assets = _.keyBy(assets, (asset) => asset.id);
 
-        await projectSerivce.delete(testProject);
+        await projectService.delete(testProject);
         expect(storageProviderMock.deleteFile.mock.calls).toHaveLength(assets.length + 1);
     });
 
@@ -216,7 +219,7 @@ describe("Project Service", () => {
         };
 
         const encryptedProject = encryptProject(testProject, securityToken);
-        const decryptedProject = await projectSerivce.load(encryptedProject, securityToken);
+        const decryptedProject = await projectService.load(encryptedProject, securityToken);
 
         expect(decryptedProject.exportFormat.providerType).toEqual("pascalVOC");
         expect(decryptedProject.exportFormat.providerOptions).toEqual(testProject.exportFormat.providerOptions);

tsconfig.json

@@ -1,29 +1,30 @@
 {
-    "compilerOptions": {
-        "target": "es6",
-        "allowJs": false,
-        "skipLibCheck": false,
-        "esModuleInterop": true,
-        "allowSyntheticDefaultImports": true,
-        "strict": false,
-        "forceConsistentCasingInFileNames": true,
-        "module": "esnext",
-        "moduleResolution": "node",
-        "resolveJsonModule": true,
-        "isolatedModules": true,
-        "noEmit": true,
-        "jsx": "preserve",
-        "experimentalDecorators": true,
-        "lib": [
-            "es2015",
-            "dom"
-        ],
-        "typeRoots": [
-            "./typings",
-            "./node_modules/@types"
-        ],
-    },
-    "include": [
-        "src"
-    ]
+  "compilerOptions": {
+    "target": "es6",
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": false,
+    "forceConsistentCasingInFileNames": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react",
+    "experimentalDecorators": true,
+    "lib": [
+      "es2015",
+      "dom"
+    ],
+    "typeRoots": [
+      "./typings",
+      "./node_modules/@types"
+    ],
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": [
+    "src"
+  ]
 }

tslint.json

@@ -1,17 +0,0 @@
-{
-    "defaultSeverity": "error",
-    "extends": [
-        "tslint:recommended"
-    ],
-    "jsRules": {},
-    "rules": {
-        "object-literal-sort-keys": false,
-        "no-console": false,
-        "no-shadowed-variable": false,
-        "ordered-imports": false,
-        "no-string-literal": false,
-        "no-bitwise": false,
-        "function-constructor": false
-    },
-    "rulesDirectory": []
-}