Add tests (#5215)

DonJayamanne · web-flow · commit a7e958613345 · 2019-04-11T15:15:11.000-07:00
* Add tests
* Add tests
* Add tests
diff --git a/src/test/application/diagnostics/commands/execVSCCommands.unit.test.ts b/src/test/application/diagnostics/commands/execVSCCommands.unit.test.ts
@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { expect } from 'chai';
+import * as typemoq from 'typemoq';
+import { ExecuteVSCCommand } from '../../../../client/application/diagnostics/commands/execVSCCommand';
+import { DiagnosticsCommandFactory } from '../../../../client/application/diagnostics/commands/factory';
+import { IDiagnosticsCommandFactory } from '../../../../client/application/diagnostics/commands/types';
+import { IDiagnostic } from '../../../../client/application/diagnostics/types';
+import { ICommandManager } from '../../../../client/common/application/types';
+import { IServiceContainer } from '../../../../client/ioc/types';
+
+suite('Application Diagnostics - Exec VSC Commands', () => {
+    let commandFactory: IDiagnosticsCommandFactory;
+    let commandManager: typemoq.IMock<ICommandManager>;
+    setup(() => {
+        const serviceContainer = typemoq.Mock.ofType<IServiceContainer>();
+        commandManager = typemoq.Mock.ofType<ICommandManager>();
+        serviceContainer
+            .setup(svc => svc.get<ICommandManager>(typemoq.It.isValue(ICommandManager), typemoq.It.isAny()))
+            .returns(() => commandManager.object);
+        commandFactory = new DiagnosticsCommandFactory(serviceContainer.object);
+    });
+
+    test('Test creation of VSC Command', async () => {
+        const diagnostic = typemoq.Mock.ofType<IDiagnostic>();
+
+        const command = commandFactory.createCommand(diagnostic.object, { type: 'executeVSCCommand', options: 'editor.action.formatDocument' });
+        expect(command).to.be.instanceOf(ExecuteVSCCommand);
+    });
+
+    test('Test execution of VSC Command', async () => {
+        const diagnostic = typemoq.Mock.ofType<IDiagnostic>();
+        commandManager
+            .setup(cmd => cmd.executeCommand('editor.action.formatDocument'))
+            .returns(() => Promise.resolve(undefined))
+            .verifiable(typemoq.Times.once());
+
+        const command = commandFactory.createCommand(diagnostic.object, { type: 'executeVSCCommand', options: 'editor.action.formatDocument' });
+        await command.invoke();
+
+        expect(command).to.be.instanceOf(ExecuteVSCCommand);
+        commandManager.verifyAll();
+    });
+});
diff --git a/src/test/common/installer/condaInstaller.unit.test.ts b/src/test/common/installer/condaInstaller.unit.test.ts
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import * as assert from 'assert';
+import { instance, mock, when } from 'ts-mockito';
+import { Uri } from 'vscode';
+import { PythonSettings } from '../../../client/common/configSettings';
+import { ConfigurationService } from '../../../client/common/configuration/service';
+import { CondaInstaller } from '../../../client/common/installer/condaInstaller';
+import { IConfigurationService, IPythonSettings } from '../../../client/common/types';
+import { ICondaService } from '../../../client/interpreter/contracts';
+import { CondaService } from '../../../client/interpreter/locators/services/condaService';
+import { ServiceContainer } from '../../../client/ioc/container';
+import { IServiceContainer } from '../../../client/ioc/types';
+
+suite('Common - Conda Installer', () => {
+    let installer: CondaInstaller;
+    let serviceContainer: IServiceContainer;
+    let condaService: ICondaService;
+    let configService: IConfigurationService;
+    setup(() => {
+        serviceContainer = mock(ServiceContainer);
+        condaService = mock(CondaService);
+        configService = mock(ConfigurationService);
+        when(serviceContainer.get<ICondaService>(ICondaService)).thenReturn(instance(condaService));
+        when(serviceContainer.get<IConfigurationService>(IConfigurationService)).thenReturn(instance(configService));
+        installer = new CondaInstaller(instance(serviceContainer));
+    });
+    test('Name and priority', async () => {
+        assert.equal(installer.displayName, 'Conda');
+        assert.equal(installer.priority, 0);
+    });
+    test('Installer is not supported when conda is not available', async () => {
+        const uri = Uri.file(__filename);
+        when(condaService.isCondaAvailable()).thenResolve(false);
+
+        const supported = await installer.isSupported(uri);
+
+        assert.equal(supported, false);
+    });
+    test('Installer is not supported when current env is not a conda env', async () => {
+        const uri = Uri.file(__filename);
+        const settings: IPythonSettings = mock(PythonSettings);
+        const pythonPath = 'my py path';
+
+        when(settings.pythonPath).thenReturn(pythonPath);
+        when(condaService.isCondaAvailable()).thenResolve(true);
+        when(configService.getSettings(uri)).thenReturn(instance(settings));
+        when(condaService.isCondaEnvironment(pythonPath)).thenResolve(false);
+
+        const supported = await installer.isSupported(uri);
+
+        assert.equal(supported, false);
+    });
+    test('Installer is supported when current env is a conda env', async () => {
+        const uri = Uri.file(__filename);
+        const settings: IPythonSettings = mock(PythonSettings);
+        const pythonPath = 'my py path';
+
+        when(settings.pythonPath).thenReturn(pythonPath);
+        when(condaService.isCondaAvailable()).thenResolve(true);
+        when(configService.getSettings(uri)).thenReturn(instance(settings));
+        when(condaService.isCondaEnvironment(pythonPath)).thenResolve(true);
+
+        const supported = await installer.isSupported(uri);
+
+        assert.equal(supported, true);
+    });
+});
