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

Smoke tests (#9814)

Browse Source 
* move

* add inital test; need basic sqllite connection

* before sqlite

* sqlite

* add smoke tests

* working tests

* fix app names

* fix quick open

* fix smoke tests

* add win32 smoke tests

* fix smoke test

* fix win32 smoke

* no continue

* continue on error

* add vscode smokes

* remove vscode tests

* continue on error

* allow sqlite to use relative paths

* add linux smoke tests

* fix build files

* use dispatch instead of select

* fix linux build again

* fix darwin

* get select working

* try and use screen shots

* screen shots

* remove smoke tests linux

* try vscodes sqlite

* fix compile

* fix webpack

* fix deps

* try this again

* try force a rebuild

* try npm rebuild

* add sqlite to be rebuilt

* distro

* try vscode sqlite again

* revert changes to driver and simplify edits

* fix compile

* fix imports

* move sqlite out

* remove unneeded change

* add extensions path

* fix web tests

* no continue on error
This commit is contained in:
Anthony Dresser
2020-04-03 00:01:32 -07:00
committed by GitHub
parent 589de854d5
commit 6e6649d006
33 changed files with 234 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
extensions/integration-tests/src/main.ts
View File

@@ -4,122 +4,11 @@
*--------------------------------------------------------------------------------------------*/
import * as vscode from 'vscode';
import * as azdata from 'azdata';
import { normalize, join } from 'path';
import * as fs from 'fs';
const TEST_SETUP_COMPLETED_TEXT: string = 'Test Setup Completed';
const EXTENSION_LOADED_TEXT: string = 'Test Extension Loaded';
const ALL_EXTENSION_LOADED_TEXT: string = 'All Extensions Loaded';
let statusBarItemTimer: NodeJS.Timer;
export function activate(context: vscode.ExtensionContext) {
let statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
vscode.commands.registerCommand('test.setupIntegrationTest', async () => {
let extensionInstallersFolder = normalize(join(__dirname, '../extensionInstallers'));
console.info(`extensionInstallersFolder=${extensionInstallersFolder}`);
// eslint-disable-next-line no-sync
let installers = fs.readdirSync(extensionInstallersFolder);
for (let i = 0; i < installers.length; i++) {
if (installers[i].endsWith('.vsix')) {
let installerFullPath = join(extensionInstallersFolder, installers[i]);
console.info(`installing extension at ${installerFullPath}`);
await azdata.extensions.install(installerFullPath);
console.info(`extension has been installed successfully. vsix: ${installers[i]}`);
}
}
await setConfiguration('workbench.enablePreviewFeatures', true);
await setConfiguration('workbench.showConnectDialogOnStartup', false);
await setConfiguration('test.testSetupCompleted', true);
showStatusBarItem(statusBarItem, TEST_SETUP_COMPLETED_TEXT);
});
vscode.commands.registerCommand('test.waitForExtensionsToLoad', async () => {
const expectedExtensions = ['Microsoft.agent', 'Microsoft.import', 'Microsoft.mssql', 'Microsoft.profiler', 'Microsoft.azuredatastudio-postgresql'];
const commonFeatures: azdata.DataProviderType[] = [
azdata.DataProviderType.AdminServicesProvider,
azdata.DataProviderType.BackupProvider,
azdata.DataProviderType.CapabilitiesProvider,
azdata.DataProviderType.ConnectionProvider,
azdata.DataProviderType.FileBrowserProvider,
azdata.DataProviderType.MetadataProvider,
azdata.DataProviderType.ObjectExplorerProvider,
azdata.DataProviderType.ProfilerProvider,
azdata.DataProviderType.QueryProvider,
azdata.DataProviderType.RestoreProvider,
azdata.DataProviderType.ScriptingProvider,
azdata.DataProviderType.TaskServicesProvider];
const features_mssql: azdata.DataProviderType[] = [
azdata.DataProviderType.AgentServicesProvider,
azdata.DataProviderType.IconProvider
];
features_mssql.push(...commonFeatures);
const providerFeatureMapping: { providerId: string, features: azdata.DataProviderType[] }[] = [
{
providerId: 'MSSQL',
features: features_mssql
}, {
providerId: 'PGSQL',
features: commonFeatures
}];
do {
let extensions = vscode.extensions.all.filter(ext => { return expectedExtensions.indexOf(ext.id) !== -1; });
const extensionsNotInReadyState: string[] = [];
extensions.forEach(extension => {
if (!extension.isActive) {
extensionsNotInReadyState.push(extension.id);
}
});
const providerTypesNotInReadyState: string[] = [];
if (extensionsNotInReadyState.length === 0) {
providerFeatureMapping.forEach(entry => {
entry.features.forEach(feature => {
const provider = azdata.dataprotocol.getProvider(entry.providerId, feature);
if (!provider) {
providerTypesNotInReadyState.push(`${entry.providerId}:${feature}`);
}
});
});
}
if (extensionsNotInReadyState.length === 0 && providerTypesNotInReadyState.length === 0) {
console.info('All extensions are ready');
showStatusBarItem(statusBarItem, ALL_EXTENSION_LOADED_TEXT);
break;
} else if (extensionsNotInReadyState.length !== 0) {
console.warn(`the following extensions are not ready: ${extensionsNotInReadyState.join(',')}`);
} else {
console.warn(`the following providers are not ready: ${providerTypesNotInReadyState.join(',')}`);
}
await new Promise(resolve => { setTimeout(resolve, 2000); });
}
while (true);
});
showStatusBarItem(statusBarItem, EXTENSION_LOADED_TEXT);
}
function showStatusBarItem(statusBarItem: vscode.StatusBarItem, text: string) {
statusBarItem.text = text;
statusBarItem.tooltip = text;
statusBarItem.show();
clearTimeout(statusBarItemTimer);
statusBarItemTimer = setTimeout(function () {
statusBarItem.hide();
}, 5000);
}
// this method is called when your extension is deactivated
export function deactivate(): void {
}
async function setConfiguration(name: string, value: any) {
await vscode.workspace.getConfiguration().update(name, value, true);
}