add existing project to workspace feature (#12249)

* add existing project to workspace feature

* update file name

* new test and use URI

* handle workspace with no folder

* add more validation

* and more tests

* use forward slash

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

@@ -0,0 +1,90 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import 'mocha';
+import * as sinon from 'sinon';
+import * as vscode from 'vscode';
+import * as should from 'should';
+import { WorkspaceTreeDataProvider } from '../common/workspaceTreeDataProvider';
+import { WorkspaceService } from '../services/workspaceService';
+import { WorkspaceTreeItem } from '../common/interfaces';
+import { IProjectProvider } from 'dataworkspace';
+import { MockTreeDataProvider } from './projectProviderRegistry.test';
+
+suite('workspaceTreeDataProvider Tests', function (): void {
+	const workspaceService = new WorkspaceService();
+	const treeProvider = new WorkspaceTreeDataProvider(workspaceService);
+
+	this.afterEach(() => {
+		sinon.restore();
+	});
+
+	test('test refresh()', () => {
+		const treeDataChangeHandler = sinon.stub();
+		treeProvider.onDidChangeTreeData!((e) => {
+			treeDataChangeHandler(e);
+		});
+		treeProvider.refresh();
+		should.strictEqual(treeDataChangeHandler.calledOnce, true);
+	});
+
+	test('test getTreeItem()', () => {
+		const getTreeItemStub = sinon.stub();
+		treeProvider.getTreeItem(({
+			treeDataProvider: ({
+				getTreeItem: (arg: WorkspaceTreeItem) => {
+					return getTreeItemStub(arg);
+				}
+			}) as vscode.TreeDataProvider<any>
+		}) as WorkspaceTreeItem);
+		should.strictEqual(getTreeItemStub.calledOnce, true);
+	});
+
+	test('test getChildren() for non-root element', async () => {
+		const getChildrenStub = sinon.stub().resolves([]);
+		const element = {
+			treeDataProvider: ({
+				getChildren: (arg: any) => {
+					return getChildrenStub(arg);
+				}
+			}) as vscode.TreeDataProvider<any>,
+			element: 'obj1'
+		};
+		const children = await treeProvider.getChildren(element);
+		should.strictEqual(children.length, 0, 'children count should be 0');
+		should.strictEqual(getChildrenStub.calledWithExactly('obj1'), true, 'getChildren parameter should be obj1')
+	});
+
+	test('test getChildren() for root element', async () => {
+		const getProjectsInWorkspaceStub = sinon.stub(workspaceService, 'getProjectsInWorkspace').resolves(
+			[
+				vscode.Uri.file('test/proj1/proj1.sqlproj'),
+				vscode.Uri.file('test/proj2/proj2.csproj')
+			]
+		);
+		const treeDataProvider = new MockTreeDataProvider();
+		const projectProvider: IProjectProvider = {
+			supportedProjectTypes: [{
+				projectFileExtension: 'sqlproj',
+				icon: '',
+				displayName: 'sql project'
+			}],
+			getProjectTreeDataProvider: (projectFile: vscode.Uri): Promise<vscode.TreeDataProvider<any>> => {
+				return Promise.resolve(treeDataProvider);
+			}
+		};
+		const getProjectProviderStub = sinon.stub(workspaceService, 'getProjectProvider');
+		getProjectProviderStub.onFirstCall().resolves(undefined);
+		getProjectProviderStub.onSecondCall().resolves(projectProvider);
+		sinon.stub(treeDataProvider, 'getChildren').resolves(['treeitem1']);
+		const showErrorMessageStub = sinon.stub(vscode.window, 'showErrorMessage');
+		const children = await treeProvider.getChildren(undefined);
+		should.strictEqual(children.length, 1, 'there should be 1 tree item returned');
+		should.strictEqual(children[0].element, 'treeitem1');
+		should.strictEqual(getProjectsInWorkspaceStub.calledOnce, true, 'getProjectsInWorkspaceStub should be called');
+		should.strictEqual(getProjectProviderStub.calledTwice, true, 'getProjectProvider should be called twice');
+		should.strictEqual(showErrorMessageStub.calledOnce, true, 'showErrorMessage should be called once');
+	});
+});