Swapping vscode calls for ApiWrapper for testability (#10267)

* swapping vscode calls for apiwrapper for testability

* Adding mainController tests

* Adding unit tests for input validation

* Adding project controller tests, reorganizing error handling

* Removing commented-out code

extensions/sql-database-projects/src/test/mainController.test.ts

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as should from 'should';
+import * as path from 'path';
+import * as os from 'os';
+import * as TypeMoq from 'typemoq';
+import * as vscode from 'vscode';
+import * as baselines from './baselines/baselines';
+import * as templates from '../templates/templates';
+import * as constants from '../common/constants';
+
+import { createContext, TestContext } from './testContext';
+import MainController from '../controllers/mainController';
+import { shouldThrowSpecificError } from './testUtils';
+
+let testContext: TestContext;
+
+describe('MainController: main controller operations', function (): void {
+	before(async function (): Promise<void> {
+		testContext = createContext();
+		await templates.loadTemplates(path.join(__dirname, '..', '..', 'resources', 'templates'));
+		await baselines.loadBaselines();
+	});
+
+	beforeEach(async function (): Promise<void> {
+		testContext.apiWrapper.reset();
+	});
+
+	it('Should create new project through MainController', async function (): Promise<void> {
+		const projFileDir = path.join(os.tmpdir(), `TestProject_${new Date().getTime()}`);
+
+		testContext.apiWrapper.setup(x => x.showInputBox(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve('MyProjectName'));
+		testContext.apiWrapper.setup(x => x.showOpenDialog(TypeMoq.It.isAny())).returns(() => Promise.resolve([vscode.Uri.file(projFileDir)]));
+		testContext.apiWrapper.setup(x => x.workspaceFolders()).returns(() => undefined);
+		testContext.apiWrapper.setup(x => x.showErrorMessage(TypeMoq.It.isAny())).returns((s) => {
+			console.log(s);
+			return Promise.resolve(s);
+		});
+
+		const controller = new MainController(testContext.context, testContext.apiWrapper.object);
+		const proj = await controller.createNewProject();
+
+		should(proj).not.equal(undefined);
+	});
+
+	it('Should show error when no project name', async function (): Promise<void> {
+		for (const name of ['', '    ', undefined]) {
+			testContext.apiWrapper.reset();
+			testContext.apiWrapper.setup(x => x.showInputBox(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(name));
+			testContext.apiWrapper.setup(x => x.showErrorMessage(TypeMoq.It.isAny())).returns((s) => { throw new Error(s); });
+
+			const controller = new MainController(testContext.context, testContext.apiWrapper.object);
+			await shouldThrowSpecificError(async () => await controller.createNewProject(), constants.projectNameRequired, `case: '${name}'`);
+		}
+	});
+
+	it('Should show error when no location name', async function (): Promise<void> {
+		testContext.apiWrapper.setup(x => x.showInputBox(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve('MyProjectName'));
+		testContext.apiWrapper.setup(x => x.showOpenDialog(TypeMoq.It.isAny())).returns(() => Promise.resolve(undefined));
+		testContext.apiWrapper.setup(x => x.showErrorMessage(TypeMoq.It.isAny())).returns((s) => { throw new Error(s); });
+
+		const controller = new MainController(testContext.context, testContext.apiWrapper.object);
+		await shouldThrowSpecificError(async () => await controller.createNewProject(), constants.projectLocationRequired);
+	});
+});

extensions/sql-database-projects/src/test/projectController.test.ts

@@ -7,6 +7,7 @@ import * as should from 'should';
 import * as path from 'path';
 import * as os from 'os';
 import * as vscode from 'vscode';
+import * as TypeMoq from 'typemoq';
 import * as baselines from './baselines/baselines';
 import * as templates from '../templates/templates';
 import * as testUtils from './testUtils';
@@ -14,15 +15,20 @@ import * as testUtils from './testUtils';
 import { SqlDatabaseProjectTreeViewProvider } from '../controllers/databaseProjectTreeViewProvider';
 import { ProjectsController } from '../controllers/projectController';
 import { promises as fs } from 'fs';
+import { createContext, TestContext } from './testContext';
+import { Project } from '../models/project';
+
+let testContext: TestContext;
 
 describe('ProjectsController: project controller operations', function (): void {
-	before(async function () : Promise<void> {
+	before(async function (): Promise<void> {
+		testContext = createContext();
 		await templates.loadTemplates(path.join(__dirname, '..', '..', 'resources', 'templates'));
 		await baselines.loadBaselines();
 	});
 
 	it('Should create new sqlproj file with correct values', async function (): Promise<void> {
-		const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
+		const projController = new ProjectsController(testContext.apiWrapper.object, new SqlDatabaseProjectTreeViewProvider());
 		const projFileDir = path.join(os.tmpdir(), `TestProject_${new Date().getTime()}`);
 
 		const projFilePath = await projController.createNewProject('TestProjectName', vscode.Uri.file(projFileDir), 'BA5EBA11-C0DE-5EA7-ACED-BABB1E70A575');
@@ -38,11 +44,26 @@ describe('ProjectsController: project controller operations', function (): void
 		const sqlProjPath = await testUtils.createTestSqlProj(baselines.openProjectFileBaseline, folderPath);
 		await testUtils.createTestDataSources(baselines.openDataSourcesBaseline, folderPath);
 
-		const projController = new ProjectsController(new SqlDatabaseProjectTreeViewProvider());
+		const projController = new ProjectsController(testContext.apiWrapper.object, new SqlDatabaseProjectTreeViewProvider());
 
 		const project = await projController.openProject(vscode.Uri.file(sqlProjPath));
 
 		should(project.files.length).equal(9); // detailed sqlproj tests in their own test file
 		should(project.dataSources.length).equal(2); // detailed datasources tests in their own test file
 	});
+
+	it('Should return silently when no object name provided', async function (): Promise<void> {
+		for (const name of ['', '    ', undefined]) {
+			testContext.apiWrapper.reset();
+			testContext.apiWrapper.setup(x => x.showInputBox(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(name));
+			testContext.apiWrapper.setup(x => x.showErrorMessage(TypeMoq.It.isAny())).returns((s) => { console.log('we throwin'); throw new Error(s); });
+
+			const projController = new ProjectsController(testContext.apiWrapper.object, new SqlDatabaseProjectTreeViewProvider());
+			const project = new Project('FakePath');
+
+			should(project.files.length).equal(0);
+			await projController.addItemPrompt(new Project('FakePath'), '', templates.script);
+			should(project.files.length).equal(0, 'Expected to return without throwing an exception or adding a file when an empty/undefined name is provided.');
+		}
+	});
 });

extensions/sql-database-projects/src/test/templates.test.ts

@@ -14,8 +14,8 @@ describe('Templates: loading templates from disk', function (): void {
 	});
 
 	it('Should throw error when attempting to use templates before loaded from file', async function (): Promise<void> {
-		shouldThrowSpecificError(() => templates.projectScriptTypeMap(), 'Templates must be loaded from file before attempting to use.');
-		shouldThrowSpecificError(() => templates.projectScriptTypes(), 'Templates must be loaded from file before attempting to use.');
+		await shouldThrowSpecificError(() => templates.projectScriptTypeMap(), 'Templates must be loaded from file before attempting to use.');
+		await shouldThrowSpecificError(() => templates.projectScriptTypes(), 'Templates must be loaded from file before attempting to use.');
 	});
 
 	it('Should load all templates from files', async function (): Promise<void> {

extensions/sql-database-projects/src/test/testContext.ts

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as TypeMoq from 'typemoq';
+import { ApiWrapper } from '../common/apiWrapper';
+
+export interface TestContext {
+	apiWrapper: TypeMoq.IMock<ApiWrapper>;
+	context: vscode.ExtensionContext;
+}
+
+export function createContext(): TestContext {
+	let extensionPath = path.join(__dirname, '..', '..');
+
+	return {
+		apiWrapper: TypeMoq.Mock.ofType(ApiWrapper),
+		context: {
+			subscriptions: [],
+			workspaceState: {
+				get: () => { return undefined; },
+				update: () => { return Promise.resolve(); }
+			},
+			globalState: {
+				get: () => { return Promise.resolve(); },
+				update: () => { return Promise.resolve(); }
+			},
+			extensionPath: extensionPath,
+			asAbsolutePath: () => { return ''; },
+			storagePath: '',
+			globalStoragePath: '',
+			logPath: '',
+			extensionUri: vscode.Uri.parse('')
+		},
+	};
+}

extensions/sql-database-projects/src/test/testUtils.ts

@@ -11,10 +11,10 @@ import { promises as fs } from 'fs';
 import should = require('should');
 import { AssertionError } from 'assert';
 
-export function shouldThrowSpecificError(block: Function, expectedMessage: string) {
+export async function shouldThrowSpecificError(block: Function, expectedMessage: string, details?: string) {
 	let succeeded = false;
 	try {
-		block();
+		await block();
 		succeeded = true;
 	}
 	catch (err) {
@@ -22,7 +22,7 @@ export function shouldThrowSpecificError(block: Function, expectedMessage: strin
 	}
 
 	if (succeeded) {
-		throw new AssertionError({ message: 'Operation succeeded, but expected failure with exception: "' + expectedMessage + '"' });
+		throw new AssertionError({ message: `Operation succeeded, but expected failure with exception: "${expectedMessage}".${details ? '  ' + details : ''}` });
 	}
 }