Fix unhandled promise rejections

src/test/interpreters/condaEnvFileService.test.ts

@@ -108,11 +108,11 @@ suite('Interpreters from Conda Environments Text File', () => {
         fileSystem.setup(fs => fs.fileExistsAsync(TypeMoq.It.isValue(environmentsFilePath))).returns(() => Promise.resolve(true));
         fileSystem.setup(fs => fs.readFile(TypeMoq.It.isValue(environmentsFilePath))).returns(() => Promise.resolve(interpreterPaths.join(EOL)));
 
-        AnacondaCompanyNames.forEach(async companyDisplayName => {
+        for (const _ of AnacondaCompanyNames){
             const interpreters = await condaFileProvider.getInterpreters();
 
             assert.equal(interpreters.length, 1, 'Incorrect number of entries');
             assert.equal(interpreters[0].displayName, `${AnacondaDisplayName} Mock Version (numpy)`, 'Incorrect display name');
-        });
+        }
     });
 });

src/test/refactor/extension.refactor.extract.var.test.ts

@@ -101,13 +101,13 @@ suite('Variable Extraction', () => {
     test('Extract Variable', async () => {
         const startPos = new vscode.Position(234, 29);
         const endPos = new vscode.Position(234, 38);
-        testingVariableExtraction(false, startPos, endPos);
+        await testingVariableExtraction(false, startPos, endPos);
     });
 
     test('Extract Variable fails if whole string not selected', async () => {
         const startPos = new vscode.Position(234, 20);
         const endPos = new vscode.Position(234, 38);
-        testingVariableExtraction(true, startPos, endPos);
+        await testingVariableExtraction(true, startPos, endPos);
     });
 
     function testingVariableExtractionEndToEnd(shouldError: boolean, startPos: Position, endPos: Position) {

src/test/unittests/debugger.test.ts

@@ -71,10 +71,31 @@ suite('Unit Tests - debugging', () => {
         assert.equal(tests.testFunctions.length, 2, 'Incorrect number of test functions');
         assert.equal(tests.testSuites.length, 2, 'Incorrect number of test suites');
 
+        const deferred = createDeferred<string>();
         const testFunction = [tests.testFunctions[0].testFunction];
-        testManager.runTest(CommandSource.commandPalette, { testFunction }, false, true);
-        const launched = await mockDebugLauncher.launched;
-        assert.isTrue(launched, 'Debugger not launched');
+        const runningPromise = testManager.runTest(CommandSource.commandPalette, { testFunction }, false, true);
+
+        // This promise should never resolve nor reject.
+        runningPromise
+           .then(() => 'Debugger stopped when it shouldn\'t have')
+           .catch(() => 'Debugger crashed when it shouldn\'t have')
+           // tslint:disable-next-line:no-floating-promises
+          .then(error => {
+                deferred.reject(error);
+          });
+
+        mockDebugLauncher.launched
+                    // tslint:disable-next-line:no-unsafe-any
+                    .then((launched) => {
+                        if (launched) {
+                            deferred.resolve('');
+                        } else {
+                            deferred.reject('Debugger not launched');
+                        }
+                    })
+                    // tslint:disable-next-line:no-unsafe-any
+                    .catch(ex => deferred.reject(ex));
+        return await deferred.promise;
     }
 
     test('Debugger should start (unittest)', async () => {
@@ -105,8 +126,7 @@ suite('Unit Tests - debugging', () => {
         const launched = await mockDebugLauncher.launched;
         assert.isTrue(launched, 'Debugger not launched');
 
-        testManager.discoverTests(CommandSource.commandPalette, true, true, true);
-
+        await testManager.discoverTests(CommandSource.commandPalette, true, true, true);
         await expect(runningPromise).to.be.rejectedWith(CANCELLATION_REASON, 'Incorrect reason for ending the debugger');
     }
 
@@ -151,6 +171,7 @@ suite('Unit Tests - debugging', () => {
         runningPromise
             .then(() => 'Debugger stopped when it shouldn\'t have')
             .catch(() => 'Debugger crashed when it shouldn\'t have')
+            // tslint:disable-next-line: no-floating-promises
             .then(error => {
                 deferred.reject(error);
             });

src/test/unittests/stoppingDiscoverAndTest.test.ts

@@ -5,6 +5,7 @@ import { expect, use } from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
 import * as path from 'path';
 import { Uri } from 'vscode';
+import {createDeferred} from '../../client/common/helpers';
 import { Product } from '../../client/common/types';
 import { CANCELLATION_REASON, CommandSource, UNITTEST_PROVIDER } from '../../client/unittests/common/constants';
 import { ITestDiscoveryService } from '../../client/unittests/common/types';
@@ -60,9 +61,28 @@ suite('Unit Tests Stopping Discovery and Runner', () => {
 
         const discoveryPromise = mockTestManager.discoverTests(CommandSource.auto);
         mockTestManager.discoveryDeferred.resolve(EmptyTests);
-        mockTestManager.runTest(CommandSource.ui);
+        const runningPromise = mockTestManager.runTest(CommandSource.ui);
+        const deferred = createDeferred<string>();
 
-        await expect(discoveryPromise).to.eventually.equal(EmptyTests);
+        // This promise should never resolve nor reject.
+        runningPromise
+            .then(() => 'Debugger stopped when it shouldn\'t have')
+            .catch(() => 'Debugger crashed when it shouldn\'t have')
+            // tslint:disable-next-line:no-floating-promises
+            .then(error => {
+                deferred.reject(error);
+            });
+
+       discoveryPromise.then(result => {
+            if (result === EmptyTests) {
+                deferred.resolve('');
+            } else {
+                deferred.reject('tests not empty');
+            }
+        }).catch(error => {
+            deferred.reject(error);
+        });
+        await deferred.promise;
     });
 
     test('Discovering tests should stop running tests', async () => {
@@ -75,7 +95,7 @@ suite('Unit Tests Stopping Discovery and Runner', () => {
         await new Promise(resolve => setTimeout(resolve, 1000));
 
         // User manually discovering tests will kill the existing test runner.
-        mockTestManager.discoverTests(CommandSource.ui, true, false, true);
+        await mockTestManager.discoverTests(CommandSource.ui, true, false, true);
         await expect(runPromise).to.eventually.be.rejectedWith(CANCELLATION_REASON);
     });
 });