Data workspace projects changes (#13466)

* Fix project context menu actions (#12541)

* delete works again

* make fewer changes

* update all sql db project commands

* cleanup

* Remove old projects view (#12563)

* remove old projects view from file explorer view

* fix tests failing

* remove projects in open folder opening up in old view

* Update db reference dialog to show projects in the workspace (#12580)

* update database reference dialog to show projects in the workspace in the project dropdown

* remove workspace stuff from sql projects extension

* undo change

* add class that implements IExtension

* undo a change

* update DataWorkspaceExtension to take workspaceService as a parameter

* add type

* Update sql database project commands (#12595)

* remove sql proj's open and create new project from comman palette

* hook up create project from database to data workspace

* rename the remaining import databases to create project from database

* remove open, new, and close commands

* expose addProjectsToWorkspace() in IExtension instead of calling command

* Addressing comments

* fix failing sql project tests (#12651)

* update SSDT projects opened in projects viewlet (#12669)

* fix action not refreshing the tree issue (#12692)

* fix adding project references in new projects viewlet (#12688)

* Remove old projects tree provider (#12702)

* Remove old projects tree provider and fix tests

* formatting

* update refreshProjectsTree() to accept workspaceTreeItem()

* Cleanup ProjectsController (#12718)

* remove openProject from ProjectController and some cleanup

* rename

* add project and open project dialogs (#12729)

* empty dialogs

* wip

* new project dialog implementation

* revert gitattributes

* open project dialog

* implement add project

* remove icon helper

* refactor

* revert script change

* adjust views

* more updates

* make data-workspace a builtin extension

* show the view only when project provider is detected (#12819)

* only show the view when proj provider is available

* update

* fix sql project tests after merge (#12793)

* Update dialogs to be closer to mockups (#12879)

* small UI changes to dialogs

* center radio card group text

* Create workspace if needed when opening/new project (#12930)

* empty dialogs

* wip

* new project dialog implementation

* revert gitattributes

* open project dialog

* implement add project

* remove icon helper

* refactor

* revert script change

* create workspace

* initial changes

* create new workspace working

* fix tests

* cleanup

* remove showWorkspaceRequiredNotification()

* Add test for no workspace open

* update blue buttons

* move loading temp project to activate() instead of workspaceService constructor

* move workspace creation warning message to before project is created

* pass uri to createWorkspace

* add tests

Co-authored-by: Alan Ren <alanren@microsoft.com>

* Additional create workspace changes (#13004)

* Dialogs workspace updates (#13010)

* adding workspace text boxes

* match new project dialog to mockups

* Add validation error message for workspace file

* add enterWorkspace api

* add warning message for opening workspace

* cleanup

* update commands to remove project so they're more generic

* remove 'empty' from string

* Move default project location setting to data workspace extension (#13022)

* remove project location setting and notification from sql database projects extension

* add default project location setting to data workspace extension

* fix typo

* Add back project name incrementing

* other merge fixes

* fix strings from other PR

* default to last opened directory instead of home directory if no specified default location

* A few small updates (#13092)

* fix build error

* update title for inputboxes

* add missing file

* Add tests for data workspace dialogs (#13324)

* add tests for dialogs

* create helper functions

* New project dialog workspace inputbox fixes (#13407)

* workspace inputbox fixes

* fix folder icons

* Update package.jsons and readme (#13451)

* update package.jsons

* update readme

* add workspace information to open existing dialog (#13455)

Co-authored-by: Alan Ren <alanren@microsoft.com>

extensions/data-workspace/src/test/dialogs/newProjectDialog.test.ts

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 TypeMoq from 'typemoq';
+import * as os from 'os';
+import * as path from 'path';
+import * as vscode from 'vscode';
+import * as sinon from 'sinon';
+import { promises as fs } from 'fs';
+import { NewProjectDialog } from '../../dialogs/newProjectDialog';
+import { WorkspaceService } from '../../services/workspaceService';
+import { testProjectType } from '../testUtils';
+
+suite('New Project Dialog', function (): void {
+	test('Should validate project location', async function (): Promise<void> {
+		const workspaceServiceMock = TypeMoq.Mock.ofType<WorkspaceService>();
+		workspaceServiceMock.setup(x => x.getAllProjectTypes()).returns(() => Promise.resolve([testProjectType]));
+
+		const dialog = new NewProjectDialog(workspaceServiceMock.object);
+		await dialog.open();
+
+		dialog.model.name = 'TestProject';
+		dialog.model.location = '';
+		should.equal(await dialog.validate(), false, 'Validation should fail becausee the parent directory does not exist');
+
+		// create a folder with the same name
+		const folderPath = path.join(os.tmpdir(), dialog.model.name);
+		await fs.mkdir(folderPath, { recursive: true });
+		dialog.model.location = os.tmpdir();
+		should.equal(await dialog.validate(), false, 'Validation should fail because a folder with the same name exists');
+
+		// change project name to be unique
+		dialog.model.name = `TestProject_${new Date().getTime()}`;
+		should.equal(await dialog.validate(), true, 'Validation should pass because name is unique and parent directory exists');
+	});
+
+	test('Should validate workspace in onComplete', async function (): Promise<void> {
+		const workspaceServiceMock = TypeMoq.Mock.ofType<WorkspaceService>();
+		workspaceServiceMock.setup(x => x.validateWorkspace()).returns(() => Promise.resolve(true));
+		workspaceServiceMock.setup(x => x.getAllProjectTypes()).returns(() => Promise.resolve([testProjectType]));
+
+		const dialog = new NewProjectDialog(workspaceServiceMock.object);
+		await dialog.open();
+
+		dialog.model.name = 'TestProject';
+		dialog.model.location = '';
+		should.doesNotThrow(async () => await dialog.onComplete());
+
+		workspaceServiceMock.setup(x => x.validateWorkspace()).throws(new Error('test error'));
+		const spy = sinon.spy(vscode.window, 'showErrorMessage');
+		should.doesNotThrow(async () => await dialog.onComplete(), 'Error should be caught');
+		should(spy.calledOnce).be.true();
+	});
+});
+

extensions/data-workspace/src/test/dialogs/openExistingDialog.test.ts

@@ -0,0 +1,106 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 TypeMoq from 'typemoq';
+import * as sinon from 'sinon';
+import * as vscode from 'vscode';
+import * as constants from '../../common/constants';
+import { promises as fs } from 'fs';
+import { WorkspaceService } from '../../services/workspaceService';
+import { OpenExistingDialog } from '../../dialogs/openExistingDialog';
+import { createProjectFile, generateUniqueProjectFilePath, generateUniqueWorkspaceFilePath, testProjectType } from '../testUtils';
+
+suite('Open Existing Dialog', function (): void {
+	const mockExtensionContext = TypeMoq.Mock.ofType<vscode.ExtensionContext>();
+
+	this.afterEach(() => {
+		sinon.restore();
+	});
+
+	test('Should validate project file exists', async function (): Promise<void> {
+		const workspaceServiceMock = TypeMoq.Mock.ofType<WorkspaceService>();
+		const dialog = new OpenExistingDialog(workspaceServiceMock.object, mockExtensionContext.object);
+		await dialog.open();
+
+		dialog._targetTypeRadioCardGroup?.updateProperty( 'selectedCardId', constants.Project);
+		dialog._projectFile = '';
+		should.equal(await dialog.validate(), false, 'Validation fail because project file does not exist');
+
+		// create a project file
+		dialog._projectFile = await createProjectFile('testproj');
+		should.equal(await dialog.validate(), true, 'Validation pass because project file exists');
+	});
+
+	test('Should validate workspace file exists', async function (): Promise<void> {
+		const workspaceServiceMock = TypeMoq.Mock.ofType<WorkspaceService>();
+		const dialog = new OpenExistingDialog(workspaceServiceMock.object, mockExtensionContext.object);
+		await dialog.open();
+
+		dialog._targetTypeRadioCardGroup?.updateProperty( 'selectedCardId', constants.Workspace);
+		dialog._workspaceFile = '';
+		should.equal(await dialog.validate(), false, 'Validation fail because workspace file does not exist');
+
+		// create a workspace file
+		dialog._workspaceFile = generateUniqueWorkspaceFilePath();
+		await fs.writeFile(dialog._workspaceFile, '');
+		should.equal(await dialog.validate(), true, 'Validation pass because workspace file exists');
+	});
+
+	test('Should validate workspace in onComplete when opening project', async function (): Promise<void> {
+		const workspaceServiceMock = TypeMoq.Mock.ofType<WorkspaceService>();
+		workspaceServiceMock.setup(x => x.validateWorkspace()).returns(() => Promise.resolve(true));
+		workspaceServiceMock.setup(x => x.addProjectsToWorkspace(TypeMoq.It.isAny())).returns(() => Promise.resolve());
+
+		const dialog = new OpenExistingDialog(workspaceServiceMock.object, mockExtensionContext.object);
+		await dialog.open();
+
+		dialog._projectFile = generateUniqueProjectFilePath('testproj');
+		should.doesNotThrow(async () => await dialog.onComplete());
+
+		workspaceServiceMock.setup(x => x.validateWorkspace()).throws(new Error('test error'));
+		const spy = sinon.spy(vscode.window, 'showErrorMessage');
+		should.doesNotThrow(async () => await dialog.onComplete(), 'Error should be caught');
+		should(spy.calledOnce).be.true();
+	});
+
+	test('workspace browse', async function (): Promise<void> {
+		const workspaceServiceMock = TypeMoq.Mock.ofType<WorkspaceService>();
+		sinon.stub(vscode.window, 'showOpenDialog').returns(Promise.resolve([]));
+
+		const dialog = new OpenExistingDialog(workspaceServiceMock.object, mockExtensionContext.object);
+		await dialog.open();
+		should.equal(dialog._workspaceFile, '');
+		await dialog.workspaceBrowse();
+		should.equal(dialog._workspaceFile, '', 'Workspace file should not be set when no file is selected');
+
+		sinon.restore();
+		const workspaceFile = vscode.Uri.file(generateUniqueWorkspaceFilePath());
+		sinon.stub(vscode.window, 'showOpenDialog').returns(Promise.resolve([workspaceFile]));
+		await dialog.workspaceBrowse();
+		should.equal(dialog._workspaceFile, workspaceFile.fsPath, 'Workspace file should get set');
+		should.equal(dialog._filePathTextBox?.value, workspaceFile.fsPath);
+	});
+
+	test('project browse', async function (): Promise<void> {
+		const workspaceServiceMock = TypeMoq.Mock.ofType<WorkspaceService>();
+		workspaceServiceMock.setup(x => x.getAllProjectTypes()).returns(() => Promise.resolve([testProjectType]));
+		sinon.stub(vscode.window, 'showOpenDialog').returns(Promise.resolve([]));
+
+		const dialog = new OpenExistingDialog(workspaceServiceMock.object, mockExtensionContext.object);
+		await dialog.open();
+		should.equal(dialog._projectFile, '');
+		await dialog.projectBrowse();
+		should.equal(dialog._projectFile, '', 'Project file should not be set when no file is selected');
+
+		sinon.restore();
+		const projectFile = vscode.Uri.file(generateUniqueProjectFilePath('testproj'));
+		sinon.stub(vscode.window, 'showOpenDialog').returns(Promise.resolve([projectFile]));
+		await dialog.projectBrowse();
+		should.equal(dialog._projectFile, projectFile.fsPath, 'Project file should be set');
+		should.equal(dialog._filePathTextBox?.value, projectFile.fsPath);
+	});
+});
+

extensions/data-workspace/src/test/projectProviderRegistry.test.ts

@@ -28,6 +28,9 @@ export function createProjectProvider(projectTypes: IProjectType[]): IProjectPro
 		},
 		getProjectTreeDataProvider: (projectFile: vscode.Uri): Promise<vscode.TreeDataProvider<any>> => {
 			return Promise.resolve(treeDataProvider);
+		},
+		createProject: (name: string, location: vscode.Uri): Promise<vscode.Uri> => {
+			return Promise.resolve(location);
 		}
 	};
 	return projectProvider;
@@ -37,51 +40,57 @@ suite('ProjectProviderRegistry Tests', function (): void {
 	test('register and unregister project providers', async () => {
 		const provider1 = createProjectProvider([
 			{
+				id: 'tp1',
 				projectFileExtension: 'testproj',
 				icon: '',
-				displayName: 'test project'
+				displayName: 'test project',
+				description: ''
 			}, {
+				id: 'tp2',
 				projectFileExtension: 'testproj1',
 				icon: '',
-				displayName: 'test project 1'
+				displayName: 'test project 1',
+				description: ''
 			}
 		]);
 		const provider2 = createProjectProvider([
 			{
+				id: 'sp1',
 				projectFileExtension: 'sqlproj',
 				icon: '',
-				displayName: 'sql project'
+				displayName: 'sql project',
+				description: ''
 			}
 		]);
 		should.strictEqual(ProjectProviderRegistry.providers.length, 0, 'there should be no project provider at the beginning of the test');
 		const disposable1 = ProjectProviderRegistry.registerProvider(provider1);
-		let providerResult = ProjectProviderRegistry.getProviderByProjectType('testproj');
+		let providerResult = ProjectProviderRegistry.getProviderByProjectExtension('testproj');
 		should.equal(providerResult, provider1, 'provider1 should be returned for testproj project type');
 		// make sure the project type is case-insensitive for getProviderByProjectType method
-		providerResult = ProjectProviderRegistry.getProviderByProjectType('TeStProJ');
+		providerResult = ProjectProviderRegistry.getProviderByProjectExtension('TeStProJ');
 		should.equal(providerResult, provider1, 'provider1 should be returned for testproj project type');
-		providerResult = ProjectProviderRegistry.getProviderByProjectType('testproj1');
+		providerResult = ProjectProviderRegistry.getProviderByProjectExtension('testproj1');
 		should.equal(providerResult, provider1, 'provider1 should be returned for testproj1 project type');
 		should.strictEqual(ProjectProviderRegistry.providers.length, 1, 'there should be only one project provider at this time');
 		const disposable2 = ProjectProviderRegistry.registerProvider(provider2);
-		providerResult = ProjectProviderRegistry.getProviderByProjectType('sqlproj');
+		providerResult = ProjectProviderRegistry.getProviderByProjectExtension('sqlproj');
 		should.equal(providerResult, provider2, 'provider2 should be returned for sqlproj project type');
 		should.strictEqual(ProjectProviderRegistry.providers.length, 2, 'there should be 2 project providers at this time');
 
 		// unregister provider1
 		disposable1.dispose();
-		providerResult = ProjectProviderRegistry.getProviderByProjectType('testproj');
+		providerResult = ProjectProviderRegistry.getProviderByProjectExtension('testproj');
 		should.equal(providerResult, undefined, 'undefined should be returned for testproj project type');
-		providerResult = ProjectProviderRegistry.getProviderByProjectType('testproj1');
+		providerResult = ProjectProviderRegistry.getProviderByProjectExtension('testproj1');
 		should.equal(providerResult, undefined, 'undefined should be returned for testproj1 project type');
-		providerResult = ProjectProviderRegistry.getProviderByProjectType('sqlproj');
+		providerResult = ProjectProviderRegistry.getProviderByProjectExtension('sqlproj');
 		should.equal(providerResult, provider2, 'provider2 should be returned for sqlproj project type after provider1 is disposed');
 		should.strictEqual(ProjectProviderRegistry.providers.length, 1, 'there should be only one project provider after unregistering a provider');
 		should.strictEqual(ProjectProviderRegistry.providers[0].supportedProjectTypes[0].projectFileExtension, 'sqlproj', 'the remaining project provider should be sqlproj');
 
 		// unregister provider2
 		disposable2.dispose();
-		providerResult = ProjectProviderRegistry.getProviderByProjectType('sqlproj');
+		providerResult = ProjectProviderRegistry.getProviderByProjectExtension('sqlproj');
 		should.equal(providerResult, undefined, 'undefined should be returned for sqlproj project type after provider2 is disposed');
 		should.strictEqual(ProjectProviderRegistry.providers.length, 0, 'there should be no project provider after unregistering the providers');
 	});
@@ -89,9 +98,11 @@ suite('ProjectProviderRegistry Tests', function (): void {
 	test('Clear the project provider registry', async () => {
 		const provider = createProjectProvider([
 			{
+				id: 'tp1',
 				projectFileExtension: 'testproj',
 				icon: '',
-				displayName: 'test project'
+				displayName: 'test project',
+				description: ''
 			}
 		]);
 		should.strictEqual(ProjectProviderRegistry.providers.length, 0, 'there should be no project provider at the beginning of the test');

extensions/data-workspace/src/test/testUtils.ts

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as os from 'os';
+import * as path from 'path';
+import { IProjectType } from 'dataworkspace';
+import { promises as fs } from 'fs';
+
+export const testProjectType: IProjectType = {
+	id: 'tp1',
+	description: '',
+	projectFileExtension: 'testproj',
+	icon: '',
+	displayName: 'test project'
+};
+
+/**
+ * Creates a unique test project file
+ * @param fileExt
+ * @param contents
+ */
+export async function createProjectFile(fileExt: string, contents?: string): Promise<string> {
+	const filepath = generateUniqueProjectFilePath(fileExt);
+	await fs.writeFile(filepath, contents ?? '');
+
+	return filepath;
+}
+
+export function generateUniqueProjectFilePath(fileExt: string): string {
+	return path.join(os.tmpdir(), `TestProject_${new Date().getTime()}.${fileExt}`);
+}
+
+export function generateUniqueWorkspaceFilePath(): string {
+	return path.join(os.tmpdir(), `TestWorkspace_${new Date().getTime()}.code-workspace`);
+}

extensions/data-workspace/src/test/workspaceService.test.ts

@@ -5,9 +5,11 @@
 
 import 'mocha';
 import * as vscode from 'vscode';
+import * as azdata from 'azdata';
 import * as sinon from 'sinon';
 import * as should from 'should';
 import * as path from 'path';
+import * as TypeMoq from 'typemoq';
 import { WorkspaceService } from '../services/workspaceService';
 import { ProjectProviderRegistry } from '../common/projectProviderRegistry';
 import { createProjectProvider } from './projectProviderRegistry.test';
@@ -61,7 +63,12 @@ function createMockExtension(id: string, isActive: boolean, projectTypes: string
 }
 
 suite('WorkspaceService Tests', function (): void {
-	const service = new WorkspaceService();
+	const mockExtensionContext = TypeMoq.Mock.ofType<vscode.ExtensionContext>();
+	const mockGlobalState = TypeMoq.Mock.ofType<vscode.Memento>();
+	mockGlobalState.setup(x => x.update(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve());
+	mockExtensionContext.setup(x => x.globalState).returns(() => mockGlobalState.object);
+
+	const service = new WorkspaceService(mockExtensionContext.object);
 
 	this.afterEach(() => {
 		sinon.restore();
@@ -111,10 +118,14 @@ suite('WorkspaceService Tests', function (): void {
 
 		const provider1 = createProjectProvider([
 			{
+				id: 'tp1',
+				description: '',
 				projectFileExtension: 'testproj',
 				icon: '',
 				displayName: 'test project'
 			}, {
+				id: 'tp2',
+				description: '',
 				projectFileExtension: 'testproj1',
 				icon: '',
 				displayName: 'test project 1'
@@ -122,6 +133,8 @@ suite('WorkspaceService Tests', function (): void {
 		]);
 		const provider2 = createProjectProvider([
 			{
+				id: 'sp1',
+				description: '',
 				projectFileExtension: 'sqlproj',
 				icon: '',
 				displayName: 'sql project'
@@ -149,10 +162,12 @@ suite('WorkspaceService Tests', function (): void {
 		const extension2 = createMockExtension('ext2', false, ['sqlproj']);
 		const extension3 = createMockExtension('ext3', false, ['dbproj']);
 		stubAllExtensions([extension1, extension2, extension3].map(ext => ext.extension));
-		const getProviderByProjectTypeStub = sinon.stub(ProjectProviderRegistry, 'getProviderByProjectType');
+		const getProviderByProjectTypeStub = sinon.stub(ProjectProviderRegistry, 'getProviderByProjectExtension');
 		getProviderByProjectTypeStub.onFirstCall().returns(undefined);
 		getProviderByProjectTypeStub.onSecondCall().returns(createProjectProvider([
 			{
+				id: 'sp1',
+				description: '',
 				projectFileExtension: 'sqlproj',
 				icon: '',
 				displayName: 'test project'
@@ -167,6 +182,8 @@ suite('WorkspaceService Tests', function (): void {
 
 		getProviderByProjectTypeStub.reset();
 		getProviderByProjectTypeStub.returns(createProjectProvider([{
+			id: 'tp2',
+			description: '',
 			projectFileExtension: 'csproj',
 			icon: '',
 			displayName: 'test cs project'
@@ -215,6 +232,45 @@ suite('WorkspaceService Tests', function (): void {
 		onWorkspaceProjectsChangedDisposable.dispose();
 	});
 
+	test('test addProjectsToWorkspace when no workspace open', async () => {
+		stubWorkspaceFile(undefined);
+		const onWorkspaceProjectsChangedStub = sinon.stub();
+		const onWorkspaceProjectsChangedDisposable = service.onDidWorkspaceProjectsChange(() => {
+			onWorkspaceProjectsChangedStub();
+		});
+		const createWorkspaceStub = sinon.stub(azdata.workspace, 'createWorkspace').resolves(undefined);
+
+		await service.addProjectsToWorkspace([
+			vscode.Uri.file('/test/folder/proj1.sqlproj')
+		]);
+
+		should.strictEqual(createWorkspaceStub.calledOnce, true, 'createWorkspace should have been called once');
+		should.strictEqual(onWorkspaceProjectsChangedStub.notCalled, true, 'the onDidWorkspaceProjectsChange event should not have been fired');
+		onWorkspaceProjectsChangedDisposable.dispose();
+	});
+
+	test('test loadTempProjects', async () => {
+		const processPath = (original: string): string => {
+			return original.replace(/\//g, path.sep);
+		};
+		stubWorkspaceFile('/test/folder/proj1.code-workspace');
+		const updateConfigurationStub = sinon.stub();
+		const getConfigurationStub = sinon.stub().returns([processPath('folder1/proj2.sqlproj')]);
+		const onWorkspaceProjectsChangedStub = sinon.stub();
+		const onWorkspaceProjectsChangedDisposable = service.onDidWorkspaceProjectsChange(() => {
+			onWorkspaceProjectsChangedStub();
+		});
+		stubGetConfigurationValue(getConfigurationStub, updateConfigurationStub);
+		sinon.stub(azdata.workspace, 'createWorkspace').resolves(undefined);
+		sinon.stub(vscode.workspace, 'workspaceFolders').value(['folder1']);
+		mockGlobalState.setup(x => x.get(TypeMoq.It.isAny())).returns(() => [processPath('folder1/proj2.sqlproj')]);
+
+		await service.loadTempProjects();
+
+		should.strictEqual(onWorkspaceProjectsChangedStub.calledOnce, true, 'the onDidWorkspaceProjectsChange event should have been fired');
+		onWorkspaceProjectsChangedDisposable.dispose();
+	});
+
 	test('test removeProject', async () => {
 		const processPath = (original: string): string => {
 			return original.replace(/\//g, path.sep);

extensions/data-workspace/src/test/workspaceTreeDataProvider.test.ts

@@ -7,13 +7,19 @@ import 'mocha';
 import * as sinon from 'sinon';
 import * as vscode from 'vscode';
 import * as should from 'should';
+import * as TypeMoq from 'typemoq';
 import { WorkspaceTreeDataProvider } from '../common/workspaceTreeDataProvider';
 import { WorkspaceService } from '../services/workspaceService';
 import { IProjectProvider, WorkspaceTreeItem } from 'dataworkspace';
 import { MockTreeDataProvider } from './projectProviderRegistry.test';
 
 suite('workspaceTreeDataProvider Tests', function (): void {
-	const workspaceService = new WorkspaceService();
+	const mockExtensionContext = TypeMoq.Mock.ofType<vscode.ExtensionContext>();
+	const mockGlobalState = TypeMoq.Mock.ofType<vscode.Memento>();
+	mockGlobalState.setup(x => x.update(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve());
+	mockExtensionContext.setup(x => x.globalState).returns(() => mockGlobalState.object);
+
+	const workspaceService = new WorkspaceService(mockExtensionContext.object);
 	const treeProvider = new WorkspaceTreeDataProvider(workspaceService);
 
 	this.afterEach(() => {
@@ -66,15 +72,20 @@ suite('workspaceTreeDataProvider Tests', function (): void {
 		const treeDataProvider = new MockTreeDataProvider();
 		const projectProvider: IProjectProvider = {
 			supportedProjectTypes: [{
+				id: 'sp1',
 				projectFileExtension: 'sqlproj',
 				icon: '',
-				displayName: 'sql project'
+				displayName: 'sql project',
+				description: ''
 			}],
 			RemoveProject: (projectFile: vscode.Uri): Promise<void> => {
 				return Promise.resolve();
 			},
 			getProjectTreeDataProvider: (projectFile: vscode.Uri): Promise<vscode.TreeDataProvider<any>> => {
 				return Promise.resolve(treeDataProvider);
+			},
+			createProject: (name: string, location: vscode.Uri): Promise<vscode.Uri> => {
+				return Promise.resolve(location);
 			}
 		};
 		const getProjectProviderStub = sinon.stub(workspaceService, 'getProjectProvider');