ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-16 10:58:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

data workspace extension batch 2 (#12208)

Browse Source 
* work in progress

* load projects in view and test cases

* update scope

* make the sql proj menu available in workspace view

* add extension unit test

* address comments

* fix errors
This commit is contained in:
Alan Ren
2020-09-10 17:17:57 -07:00
committed by GitHub
parent cd8102535b
commit 7df132b307
20 changed files with 645 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
extensions/data-workspace/src/test/dataWorkspaceExtension.test.ts Normal file
View File

@@ -0,0 +1,27 @@
/*---------------------------------------------------------------------------------------------
* 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 should from 'should';
import { DataWorkspaceExtension } from '../dataWorkspaceExtension';
import { createProjectProvider } from './projectProviderRegistry.test';
import { ProjectProviderRegistry } from '../common/projectProviderRegistry';
suite('DataWorkspaceExtension Tests', function (): void {
test('register and unregister project provider through the extension api', async () => {
const extension = new DataWorkspaceExtension();
const provider = createProjectProvider([
{
projectFileExtension: 'testproj',
icon: '',
displayName: 'test project'
}
]);
const disposable = extension.registerProjectProvider(provider);
should.strictEqual(ProjectProviderRegistry.providers.length, 1, 'project provider should have been registered');
disposable.dispose();
should.strictEqual(ProjectProviderRegistry.providers.length, 0, 'there should be nothing in the ProjectProviderRegistry');
});
});

48
extensions/data-workspace/src/test/index.ts Normal file
View File

@@ -0,0 +1,48 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as path from 'path';
const testRunner = require('vscodetestcover');
const suite = 'Data Workspace Extension Tests';
const mochaOptions: any = {
ui: 'tdd',
useColors: true,
timeout: 10000
};
// set relevant mocha options from the environment
if (process.env.ADS_TEST_GREP) {
mochaOptions.grep = process.env.ADS_TEST_GREP;
console.log(`setting options.grep to: ${mochaOptions.grep}`);
}
if (process.env.ADS_TEST_INVERT_GREP) {
mochaOptions.invert = parseInt(process.env.ADS_TEST_INVERT_GREP);
console.log(`setting options.invert to: ${mochaOptions.invert}`);
}
if (process.env.ADS_TEST_TIMEOUT) {
mochaOptions.timeout = parseInt(process.env.ADS_TEST_TIMEOUT);
console.log(`setting options.timeout to: ${mochaOptions.timeout}`);
}
if (process.env.ADS_TEST_RETRIES) {
mochaOptions.retries = parseInt(process.env.ADS_TEST_RETRIES);
console.log(`setting options.retries to: ${mochaOptions.retries}`);
}
if (process.env.BUILD_ARTIFACTSTAGINGDIRECTORY) {
mochaOptions.reporter = 'mocha-multi-reporters';
mochaOptions.reporterOptions = {
reporterEnabled: 'spec, mocha-junit-reporter',
mochaJunitReporterReporterOptions: {
testsuitesTitle: `${suite} ${process.platform}`,
mochaFile: path.join(process.env.BUILD_ARTIFACTSTAGINGDIRECTORY, `test-results/${process.platform}-${suite.toLowerCase().replace(/[^\w]/g, '-')}-results.xml`)
}
};
}
testRunner.configure(mochaOptions, { coverConfig: '../../coverConfig.json' });
export = testRunner;

100
extensions/data-workspace/src/test/projectProviderRegistry.test.ts Normal file
View File

@@ -0,0 +1,100 @@
/*---------------------------------------------------------------------------------------------
* 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 vscode from 'vscode';
import * as should from 'should';
import { ProjectProviderRegistry } from '../common/projectProviderRegistry';
import { IProjectProvider, IProjectType } from 'dataworkspace';
export class MockTreeDataProvider implements vscode.TreeDataProvider<any>{
onDidChangeTreeData?: vscode.Event<any> | undefined;
getTreeItem(element: any): vscode.TreeItem | Thenable<vscode.TreeItem> {
throw new Error('Method not implemented.');
}
getChildren(element?: any): vscode.ProviderResult<any[]> {
throw new Error('Method not implemented.');
}
}
export function createProjectProvider(projectTypes: IProjectType[]): IProjectProvider {
const treeDataProvider = new MockTreeDataProvider();
const projectProvider: IProjectProvider = {
supportedProjectTypes: projectTypes,
getProjectTreeDataProvider: (projectFile: string): Promise<vscode.TreeDataProvider<any>> => {
return Promise.resolve(treeDataProvider);
}
};
return projectProvider;
}
suite('ProjectProviderRegistry Tests', function (): void {
test('register and unregister project providers', async () => {
const provider1 = createProjectProvider([
{
projectFileExtension: 'testproj',
icon: '',
displayName: 'test project'
}, {
projectFileExtension: 'testproj1',
icon: '',
displayName: 'test project 1'
}
]);
const provider2 = createProjectProvider([
{
projectFileExtension: 'sqlproj',
icon: '',
displayName: 'sql project'
}
]);
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');
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');
should.equal(providerResult, provider1, 'provider1 should be returned for testproj project type');
providerResult = ProjectProviderRegistry.getProviderByProjectType('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');
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');
should.equal(providerResult, undefined, 'undefined should be returned for testproj project type');
providerResult = ProjectProviderRegistry.getProviderByProjectType('testproj1');
should.equal(providerResult, undefined, 'undefined should be returned for testproj1 project type');
providerResult = ProjectProviderRegistry.getProviderByProjectType('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');
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');
});
test('Clear the project provider registry', async () => {
const provider = createProjectProvider([
{
projectFileExtension: 'testproj',
icon: '',
displayName: 'test project'
}
]);
should.strictEqual(ProjectProviderRegistry.providers.length, 0, 'there should be no project provider at the beginning of the test');
ProjectProviderRegistry.registerProvider(provider);
should.strictEqual(ProjectProviderRegistry.providers.length, 1, 'there should be only one project provider at this time');
ProjectProviderRegistry.clear();
should.strictEqual(ProjectProviderRegistry.providers.length, 0, 'there should be no project provider after clearing the registry');
});
});