Port the Azure Resource Explorer extension to core. (#2701)

* Port the Azure Resource Explorer extension to core.

This will enable Azure viewlet by default in the next release.

- Moving this code from the SQL Server 2019 extension to Azure Data Studio core
- Ported tests and verified they work in the integration tests.sh file
- Fixed an issue that caused integration tests to fail if you have a SQL Server 2019 big data cluster endpoint listed, but the extension isn't installed.

extensions/azurecore/src/apiWrapper.ts

@@ -0,0 +1,225 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as vscode from 'vscode';
+import * as sqlops from 'sqlops';
+
+import * as constants from './constants';
+
+/**
+ * Wrapper class to act as a facade over VSCode and Data APIs and allow us to test / mock callbacks into
+ * this API from our code
+ *
+ * @export
+ * @class ApiWrapper
+ */
+export class ApiWrapper {
+	// Data APIs
+	public registerConnectionProvider(provider: sqlops.ConnectionProvider): vscode.Disposable {
+		return sqlops.dataprotocol.registerConnectionProvider(provider);
+	}
+
+	public registerObjectExplorerProvider(provider: sqlops.ObjectExplorerProvider): vscode.Disposable {
+		return sqlops.dataprotocol.registerObjectExplorerProvider(provider);
+	}
+
+	public registerTaskServicesProvider(provider: sqlops.TaskServicesProvider): vscode.Disposable {
+		return sqlops.dataprotocol.registerTaskServicesProvider(provider);
+	}
+
+	public registerFileBrowserProvider(provider: sqlops.FileBrowserProvider): vscode.Disposable {
+		return sqlops.dataprotocol.registerFileBrowserProvider(provider);
+	}
+
+	public registerCapabilitiesServiceProvider(provider: sqlops.CapabilitiesProvider): vscode.Disposable {
+		return sqlops.dataprotocol.registerCapabilitiesServiceProvider(provider);
+	}
+
+	public registerModelViewProvider(widgetId: string, handler: (modelView: sqlops.ModelView) => void): void {
+		return sqlops.ui.registerModelViewProvider(widgetId, handler);
+	}
+
+	public registerWebviewProvider(widgetId: string, handler: (webview: sqlops.DashboardWebview) => void): void {
+		return sqlops.dashboard.registerWebviewProvider(widgetId, handler);
+	}
+
+	public createDialog(title: string): sqlops.window.modelviewdialog.Dialog {
+		return sqlops.window.modelviewdialog.createDialog(title);
+	}
+
+	public openDialog(dialog: sqlops.window.modelviewdialog.Dialog): void {
+		return sqlops.window.modelviewdialog.openDialog(dialog);
+	}
+
+	public closeDialog(dialog: sqlops.window.modelviewdialog.Dialog): void {
+		return sqlops.window.modelviewdialog.closeDialog(dialog);
+	}
+
+	public registerTaskHandler(taskId: string, handler: (profile: sqlops.IConnectionProfile) => void): void {
+		sqlops.tasks.registerTask(taskId, handler);
+	}
+
+	public startBackgroundOperation(operationInfo: sqlops.BackgroundOperationInfo): void {
+		sqlops.tasks.startBackgroundOperation(operationInfo);
+	}
+
+	public getActiveConnections(): Thenable<sqlops.connection.Connection[]> {
+		return sqlops.connection.getActiveConnections();
+	}
+
+	public getCurrentConnection(): Thenable<sqlops.connection.Connection> {
+		return sqlops.connection.getCurrentConnection();
+	}
+
+	public createModelViewEditor(title: string, options?: sqlops.ModelViewEditorOptions): sqlops.workspace.ModelViewEditor {
+		return sqlops.workspace.createModelViewEditor(title, options);
+	}
+
+	// VSCode APIs
+	public createTerminal(name?: string, shellPath?: string, shellArgs?: string[]): vscode.Terminal {
+		return vscode.window.createTerminal(name, shellPath, shellArgs);
+	}
+
+	public createTerminalWithOptions(options: vscode.TerminalOptions): vscode.Terminal {
+		return vscode.window.createTerminal(options);
+	}
+
+	public executeCommand(command: string, ...rest: any[]): Thenable<any> {
+		return vscode.commands.executeCommand(command, ...rest);
+	}
+
+	public getFilePathRelativeToWorkspace(uri: vscode.Uri): string {
+		return vscode.workspace.asRelativePath(uri);
+	}
+
+	public getWorkspaceFolders(): vscode.WorkspaceFolder[] {
+		return vscode.workspace.workspaceFolders;
+	}
+
+	public getWorkspacePathFromUri(uri: vscode.Uri): string | undefined {
+		let workspaceFolder = vscode.workspace.getWorkspaceFolder(uri);
+		return workspaceFolder ? workspaceFolder.uri.fsPath : undefined;
+	}
+
+	public registerCommand(command: string, callback: (...args: any[]) => any, thisArg?: any): vscode.Disposable {
+		return vscode.commands.registerCommand(command, callback, thisArg);
+	}
+
+	public registerDocumentOpenHandler(handler: (doc: vscode.TextDocument) => any): vscode.Disposable {
+		return vscode.workspace.onDidOpenTextDocument(handler);
+	}
+
+	public registerTreeDataProvider<T>(viewId: string, treeDataProvider: vscode.TreeDataProvider<T>): vscode.Disposable {
+		return vscode.window.registerTreeDataProvider(viewId, treeDataProvider);
+	}
+
+	public setCommandContext(key: string, value: any): Thenable<any> {
+		return vscode.commands.executeCommand(constants.BuiltInCommands.SetContext, key, value);
+	}
+
+	/**
+	 * Get the configuration for a extensionName
+	 * @param extensionName The string name of the extension to get the configuration for
+	 * @param resource The optional URI, as a URI object or a string, to use to get resource-scoped configurations
+	 */
+	public getConfiguration(extensionName?: string, resource?: vscode.Uri | string): vscode.WorkspaceConfiguration {
+		if (typeof resource === 'string') {
+			try {
+				resource = this.parseUri(resource);
+			} catch (e) {
+				resource = undefined;
+			}
+		}
+		return vscode.workspace.getConfiguration(extensionName, resource as vscode.Uri);
+	}
+
+	public getExtensionConfiguration(): vscode.WorkspaceConfiguration {
+		return this.getConfiguration(constants.extensionConfigSectionName);
+	}
+
+	/**
+	 * Parse uri
+	 */
+	public parseUri(uri: string): vscode.Uri {
+		return vscode.Uri.parse(uri);
+	}
+
+	public showOpenDialog(options: vscode.OpenDialogOptions): Thenable<vscode.Uri[] | undefined> {
+		return vscode.window.showOpenDialog(options);
+	}
+
+	public showSaveDialog(options: vscode.SaveDialogOptions): Thenable<vscode.Uri> {
+		return vscode.window.showSaveDialog(options);
+	}
+
+	public openTextDocument(uri: vscode.Uri): Thenable<vscode.TextDocument>;
+	public openTextDocument(options: { language?: string; content?: string; }): Thenable<vscode.TextDocument>;
+	public openTextDocument(uriOrOptions): Thenable<vscode.TextDocument> {
+		return vscode.workspace.openTextDocument(uriOrOptions);
+	}
+
+	public showTextDocument(document: vscode.TextDocument, column?: vscode.ViewColumn, preserveFocus?: boolean, preview?: boolean): Thenable<vscode.TextEditor> {
+		let options: vscode.TextDocumentShowOptions = {
+			viewColumn: column,
+			preserveFocus: preserveFocus,
+			preview: preview
+		};
+		return vscode.window.showTextDocument(document, options);
+	}
+
+	public showErrorMessage(message: string, ...items: string[]): Thenable<string | undefined> {
+		return vscode.window.showErrorMessage(message, ...items);
+	}
+
+	public showWarningMessage(message: string, ...items: string[]): Thenable<string | undefined> {
+		return vscode.window.showWarningMessage(message, ...items);
+	}
+
+	public showInformationMessage(message: string, ...items: string[]): Thenable<string | undefined> {
+		return vscode.window.showInformationMessage(message, ...items);
+	}
+
+	public createStatusBarItem(alignment?: vscode.StatusBarAlignment, priority?: number): vscode.StatusBarItem {
+		return vscode.window.createStatusBarItem(alignment, priority);
+	}
+
+	public get workspaceFolders(): vscode.WorkspaceFolder[] {
+		return vscode.workspace.workspaceFolders;
+	}
+
+	public createOutputChannel(name: string): vscode.OutputChannel {
+		return vscode.window.createOutputChannel(name);
+	}
+
+	public createWizardPage(title: string): sqlops.window.modelviewdialog.WizardPage {
+		return sqlops.window.modelviewdialog.createWizardPage(title);
+	}
+
+	public registerCompletionItemProvider(selector: vscode.DocumentSelector, provider: vscode.CompletionItemProvider, ...triggerCharacters: string[]): vscode.Disposable {
+		return vscode.languages.registerCompletionItemProvider(selector, provider, ...triggerCharacters);
+	}
+
+	public createTab(title: string): sqlops.window.modelviewdialog.DialogTab {
+		return sqlops.window.modelviewdialog.createTab(title);
+	}
+
+	// Account APIs
+	public getAllAccounts(): Thenable<sqlops.Account[]> {
+		return sqlops.accounts.getAllAccounts();
+	}
+
+	public getSecurityToken(account: sqlops.Account): Thenable<{}> {
+		return sqlops.accounts.getSecurityToken(account);
+	}
+
+	public readonly onDidChangeAccounts = sqlops.accounts.onDidChangeAccounts;
+
+	// Connection APIs
+	public openConnectionDialog(providers: string[], initialConnectionProfile?: sqlops.IConnectionProfile, connectionCompletionOptions?: sqlops.IConnectionCompletionOptions): Thenable<sqlops.connection.Connection> {
+		return sqlops.connection.openConnectionDialog(providers, initialConnectionProfile, connectionCompletionOptions);
+	}
+}

extensions/azurecore/src/appContext.ts

@@ -0,0 +1,28 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as vscode from 'vscode';
+import { ApiWrapper } from './apiWrapper';
+
+/**
+ * Global context for the application
+ */
+export class AppContext {
+
+	private serviceMap: Map<string, any> = new Map();
+	constructor(public readonly extensionContext: vscode.ExtensionContext, public readonly apiWrapper: ApiWrapper) {
+		this.apiWrapper = apiWrapper || new ApiWrapper();
+	}
+
+	public getService<T>(serviceName: string): T {
+		return this.serviceMap.get(serviceName) as T;
+	}
+
+	public registerService<T>(serviceName: string, service: T): void {
+		this.serviceMap.set(serviceName, service);
+	}
+}

extensions/azurecore/src/azureResource/commands.ts

@@ -0,0 +1,120 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { window, QuickPickItem } from 'vscode';
+import { IConnectionProfile } from 'sqlops';
+import { generateGuid } from './utils';
+import { ApiWrapper } from '../apiWrapper';
+import { TreeNode } from '../treeNodes';
+
+import { AzureResourceTreeProvider } from './tree/treeProvider';
+import { AzureResourceDatabaseServerTreeNode } from './tree/databaseServerTreeNode';
+import { AzureResourceDatabaseTreeNode } from './tree/databaseTreeNode';
+import { AzureResourceAccountTreeNode } from './tree/accountTreeNode';
+import { AzureResourceServicePool } from './servicePool';
+import { AzureResourceSubscription } from './models';
+
+export function registerAzureResourceCommands(apiWrapper: ApiWrapper, tree: AzureResourceTreeProvider): void {
+	apiWrapper.registerCommand('azureresource.selectsubscriptions', async (node?: TreeNode) => {
+		if (!(node instanceof AzureResourceAccountTreeNode)) {
+			return;
+		}
+
+		const accountNode = node as AzureResourceAccountTreeNode;
+
+		const servicePool = AzureResourceServicePool.getInstance();
+
+		let subscriptions = await accountNode.getCachedSubscriptions();
+		if (!subscriptions || subscriptions.length === 0) {
+			const credentials = await servicePool.credentialService.getCredentials(accountNode.account);
+			subscriptions = await servicePool.subscriptionService.getSubscriptions(accountNode.account, credentials);
+		}
+
+		const selectedSubscriptions = (await servicePool.subscriptionFilterService.getSelectedSubscriptions(accountNode.account)) || <AzureResourceSubscription[]>[];
+		const selectedSubscriptionIds: string[] = [];
+		if (selectedSubscriptions.length > 0) {
+			selectedSubscriptionIds.push(...selectedSubscriptions.map((subscription) => subscription.id));
+		} else {
+			// ALL subscriptions are selected by default
+			selectedSubscriptionIds.push(...subscriptions.map((subscription) => subscription.id));
+		}
+
+		interface SubscriptionQuickPickItem extends QuickPickItem {
+			subscription: AzureResourceSubscription;
+		}
+
+		const subscriptionItems: SubscriptionQuickPickItem[] = subscriptions.map((subscription) => {
+			return {
+				label: subscription.name,
+				picked: selectedSubscriptionIds.indexOf(subscription.id) !== -1,
+				subscription: subscription
+			};
+		});
+
+		const pickedSubscriptionItems = (await window.showQuickPick(subscriptionItems, { canPickMany: true }));
+		if (pickedSubscriptionItems && pickedSubscriptionItems.length > 0) {
+			tree.refresh(node, false);
+
+			const pickedSubscriptions = pickedSubscriptionItems.map((subscriptionItem) => subscriptionItem.subscription);
+			await servicePool.subscriptionFilterService.saveSelectedSubscriptions(accountNode.account, pickedSubscriptions);
+		}
+	});
+
+	apiWrapper.registerCommand('azureresource.refreshall', () => tree.notifyNodeChanged(undefined));
+
+	apiWrapper.registerCommand('azureresource.refresh', async (node?: TreeNode) => {
+		tree.refresh(node, true);
+	});
+
+	apiWrapper.registerCommand('azureresource.connectsqldb', async (node?: TreeNode) => {
+		let connectionProfile: IConnectionProfile = {
+			id: generateGuid(),
+			connectionName: undefined,
+			serverName: undefined,
+			databaseName: undefined,
+			userName: undefined,
+			password: '',
+			authenticationType: undefined,
+			savePassword: true,
+			groupFullName: '',
+			groupId: '',
+			providerName: undefined,
+			saveProfile: true,
+			options: {
+			}
+		};
+
+		if (node instanceof AzureResourceDatabaseServerTreeNode) {
+			let databaseServer = node.databaseServer;
+			connectionProfile.connectionName = `connection to '${databaseServer.defaultDatabaseName}' on '${databaseServer.fullName}'`;
+			connectionProfile.serverName = databaseServer.fullName;
+			connectionProfile.databaseName = databaseServer.defaultDatabaseName;
+			connectionProfile.userName = databaseServer.loginName;
+			connectionProfile.authenticationType = 'SqlLogin';
+			connectionProfile.providerName = 'MSSQL';
+		}
+
+		if (node instanceof AzureResourceDatabaseTreeNode) {
+			let database = node.database;
+			connectionProfile.connectionName = `connection to '${database.name}' on '${database.serverFullName}'`;
+			connectionProfile.serverName = database.serverFullName;
+			connectionProfile.databaseName = database.name;
+			connectionProfile.userName = database.loginName;
+			connectionProfile.authenticationType = 'SqlLogin';
+			connectionProfile.providerName = 'MSSQL';
+		}
+
+		const conn = await apiWrapper.openConnectionDialog(undefined, connectionProfile, { saveConnection: true, showDashboard: true });
+		if (conn) {
+			apiWrapper.executeCommand('workbench.view.connections');
+		}
+	});
+
+	apiWrapper.registerCommand('azureresource.signin', async (node?: TreeNode) => {
+		apiWrapper.executeCommand('sql.action.accounts.manageLinkedAccount');
+	});
+}

extensions/azurecore/src/azureResource/constants.ts

@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+export enum AzureResourceItemType {
+	account = 'azureResource.itemType.account',
+	subscription = 'azureResource.itemType.subscription',
+	databaseContainer = 'azureResource.itemType.databaseContainer',
+	database = 'azureResource.itemType.database',
+	databaseServerContainer = 'azureResource.itemType.databaseServerContainer',
+	databaseServer = 'azureResource.itemType.databaseServer',
+	message = 'azureResource.itemType.message'
+}

extensions/azurecore/src/azureResource/errors.ts

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+export class AzureResourceCredentialError extends Error {
+	constructor(
+		message: string,
+		public innerError: Error
+	) {
+		super(message);
+	}
+}

extensions/azurecore/src/azureResource/interfaces.ts

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { ServiceClientCredentials } from 'ms-rest';
+import { Account, DidChangeAccountsParams } from 'sqlops';
+import { Event } from 'vscode';
+
+import { AzureResourceSubscription, AzureResourceDatabaseServer, AzureResourceDatabase } from './models';
+
+export interface IAzureResourceAccountService {
+	getAccounts(): Promise<Account[]>;
+
+	readonly onDidChangeAccounts: Event<DidChangeAccountsParams>;
+}
+
+export interface IAzureResourceCredentialService {
+	getCredentials(account: Account): Promise<ServiceClientCredentials[]>;
+}
+
+export interface IAzureResourceSubscriptionService {
+	getSubscriptions(account: Account, credentials: ServiceClientCredentials[]): Promise<AzureResourceSubscription[]>;
+}
+
+export interface IAzureResourceSubscriptionFilterService {
+	getSelectedSubscriptions(account: Account): Promise<AzureResourceSubscription[]>;
+
+	saveSelectedSubscriptions(account: Account, selectedSubscriptions: AzureResourceSubscription[]): Promise<void>;
+}
+
+export interface IAzureResourceDatabaseServerService {
+	getDatabaseServers(subscription: AzureResourceSubscription, credentials: ServiceClientCredentials[]): Promise<AzureResourceDatabaseServer[]>;
+}
+
+export interface IAzureResourceDatabaseService {
+	getDatabases(subscription: AzureResourceSubscription, credentials: ServiceClientCredentials[]): Promise<AzureResourceDatabase[]>;
+}
+
+export interface IAzureResourceCacheService {
+	get<T>(key: string): T | undefined;
+
+	update<T>(key: string, value: T): void;
+}
+
+export interface IAzureResourceContextService {
+	getAbsolutePath(relativePath: string): string;
+
+	executeCommand(commandId: string, ...args: any[]): void;
+
+	showErrorMessage(errorMessage: string): void;
+}

extensions/azurecore/src/azureResource/models.ts

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+export interface AzureResourceSubscription {
+	id: string;
+	name: string;
+}
+
+export interface AzureResourceDatabaseServer {
+	name: string;
+	fullName: string;
+	loginName: string;
+	defaultDatabaseName: string;
+}
+
+export interface AzureResourceDatabase {
+	name: string;
+	serverName: string;
+	serverFullName: string;
+	loginName: string;
+}

extensions/azurecore/src/azureResource/servicePool.ts

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import {
+	IAzureResourceAccountService,
+	IAzureResourceCredentialService,
+	IAzureResourceSubscriptionService,
+	IAzureResourceSubscriptionFilterService,
+	IAzureResourceDatabaseService,
+	IAzureResourceDatabaseServerService,
+	IAzureResourceCacheService,
+	IAzureResourceContextService } from './interfaces';
+
+export class AzureResourceServicePool {
+	private constructor() { }
+
+	public static getInstance(): AzureResourceServicePool {
+		return AzureResourceServicePool._instance;
+	}
+
+	public contextService: IAzureResourceContextService;
+	public cacheService: IAzureResourceCacheService;
+	public accountService: IAzureResourceAccountService;
+	public credentialService: IAzureResourceCredentialService;
+	public subscriptionService: IAzureResourceSubscriptionService;
+	public subscriptionFilterService: IAzureResourceSubscriptionFilterService;
+	public databaseService: IAzureResourceDatabaseService;
+	public databaseServerService: IAzureResourceDatabaseServerService;
+
+	private static readonly _instance = new AzureResourceServicePool();
+}

extensions/azurecore/src/azureResource/services/accountService.ts

@@ -0,0 +1,32 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { Event } from 'vscode';
+import { Account, DidChangeAccountsParams } from 'sqlops';
+import { ApiWrapper } from '../../apiWrapper';
+
+import { IAzureResourceAccountService } from '../interfaces';
+
+export class AzureResourceAccountService implements IAzureResourceAccountService {
+	public constructor(
+		apiWrapper: ApiWrapper
+	) {
+		this._apiWrapper = apiWrapper;
+		this._onDidChangeAccounts = this._apiWrapper.onDidChangeAccounts;
+	}
+
+	public async getAccounts(): Promise<Account[]> {
+		return await this._apiWrapper.getAllAccounts();
+	}
+
+	public get onDidChangeAccounts(): Event<DidChangeAccountsParams> {
+		return this._onDidChangeAccounts;
+	}
+
+	private _apiWrapper: ApiWrapper = undefined;
+	private _onDidChangeAccounts: Event<DidChangeAccountsParams> = undefined;
+}

extensions/azurecore/src/azureResource/services/cacheService.ts

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { ExtensionContext } from "vscode";
+
+import { IAzureResourceCacheService } from "../interfaces";
+
+export class AzureResourceCacheService implements IAzureResourceCacheService {
+	public constructor(
+		public readonly context: ExtensionContext
+	) {
+	}
+
+	public get<T>(key: string): T | undefined {
+		return this.context.workspaceState.get(key);
+	}
+
+	public update<T>(key: string, value: T): void {
+		this.context.workspaceState.update(key, value);
+	}
+}

extensions/azurecore/src/azureResource/services/contextService.ts

@@ -0,0 +1,36 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { ExtensionContext } from "vscode";
+import { ApiWrapper } from "../../apiWrapper";
+
+import { IAzureResourceContextService } from "../interfaces";
+
+export class AzureResourceContextService implements IAzureResourceContextService {
+	public constructor(
+		context: ExtensionContext,
+		apiWrapper: ApiWrapper
+	) {
+		this._context = context;
+		this._apiWrapper = apiWrapper;
+	}
+
+	public getAbsolutePath(relativePath: string): string {
+		return this._context.asAbsolutePath(relativePath);
+	}
+
+	public executeCommand(commandId: string, ...args: any[]): void {
+		this._apiWrapper.executeCommand(commandId, args);
+	}
+
+	public showErrorMessage(errorMessage: string): void {
+		this._apiWrapper.showErrorMessage(errorMessage);
+	}
+
+	private _context: ExtensionContext = undefined;
+	private _apiWrapper: ApiWrapper = undefined;
+}

extensions/azurecore/src/azureResource/services/credentialService.ts

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { Account } from 'sqlops';
+import { TokenCredentials, ServiceClientCredentials } from 'ms-rest';
+import { ApiWrapper } from '../../apiWrapper';
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+import { IAzureResourceCredentialService } from '../interfaces';
+import { AzureResourceCredentialError } from '../errors';
+
+export class AzureResourceCredentialService implements IAzureResourceCredentialService {
+	public constructor(
+		apiWrapper: ApiWrapper
+	) {
+		this._apiWrapper = apiWrapper;
+	}
+
+	public async getCredentials(account: Account): Promise<ServiceClientCredentials[]> {
+		try {
+			let credentials: TokenCredentials[] = [];
+			let tokens = await this._apiWrapper.getSecurityToken(account);
+
+			for (let tenant of account.properties.tenants) {
+				let token = tokens[tenant.id].token;
+				let tokenType = tokens[tenant.id].tokenType;
+
+				credentials.push(new TokenCredentials(token, tokenType));
+			}
+
+			return credentials;
+		} catch (error) {
+			throw new AzureResourceCredentialError(localize('azureResource.services.credentialService.credentialError', 'Failed to get credential for account {0}. Please refresh the account.', account.key.accountId), error);
+		}
+	}
+
+	private _apiWrapper: ApiWrapper = undefined;
+}

extensions/azurecore/src/azureResource/services/databaseServerService.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.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { ServiceClientCredentials } from 'ms-rest';
+import { SqlManagementClient } from 'azure-arm-sql';
+
+import { IAzureResourceDatabaseServerService } from '../interfaces';
+import { AzureResourceSubscription, AzureResourceDatabaseServer } from '../models';
+
+export class AzureResourceDatabaseServerService implements IAzureResourceDatabaseServerService {
+	public async getDatabaseServers(subscription: AzureResourceSubscription, credentials: ServiceClientCredentials[]): Promise<AzureResourceDatabaseServer[]> {
+		let databaseServers: AzureResourceDatabaseServer[] = [];
+		for (let cred of credentials) {
+			let sqlManagementClient = new SqlManagementClient(cred, subscription.id);
+			try {
+				let svrs = await sqlManagementClient.servers.list();
+				svrs.forEach((svr) => databaseServers.push({
+					name: svr.name,
+					fullName: svr.fullyQualifiedDomainName,
+					loginName: svr.administratorLogin,
+					defaultDatabaseName: 'master'
+				}));
+			} catch (error) {
+				if (error.code === 'InvalidAuthenticationTokenTenant' && error.statusCode === 401) {
+					/**
+					 * There may be multiple tenants for an account and it may throw exceptions like following. Just swallow the exception here.
+					 *   The access token is from the wrong issuer. It must match one of the tenants associated with this subscription.
+					 */
+				}
+			}
+		}
+
+		return databaseServers;
+	}
+}

extensions/azurecore/src/azureResource/services/databaseService.ts

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { ServiceClientCredentials } from 'ms-rest';
+import { SqlManagementClient } from 'azure-arm-sql';
+
+import { IAzureResourceDatabaseService } from '../interfaces';
+import { AzureResourceSubscription, AzureResourceDatabase } from '../models';
+
+export class AzureResourceDatabaseService implements IAzureResourceDatabaseService {
+	public async getDatabases(subscription: AzureResourceSubscription, credentials: ServiceClientCredentials[]): Promise<AzureResourceDatabase[]> {
+		let databases: AzureResourceDatabase[] = [];
+		for (let cred of credentials) {
+			let sqlManagementClient = new SqlManagementClient(cred, subscription.id);
+			try {
+				let svrs = await sqlManagementClient.servers.list();
+				for (let svr of svrs) {
+					// Extract resource group name from svr.id
+					let svrIdRegExp = new RegExp(`\/subscriptions\/${subscription.id}\/resourceGroups\/(.+)\/providers\/Microsoft\.Sql\/servers\/${svr.name}`);
+					if (!svrIdRegExp.test(svr.id)) {
+						continue;
+					}
+
+					let founds = svrIdRegExp.exec(svr.id);
+					let resouceGroup = founds[1];
+
+					let dbs = await sqlManagementClient.databases.listByServer(resouceGroup, svr.name);
+					dbs.forEach((db) => databases.push({
+						name: db.name,
+						serverName: svr.name,
+						serverFullName: svr.fullyQualifiedDomainName,
+						loginName: svr.administratorLogin
+					}));
+				}
+			} catch (error) {
+				if (error.code === 'InvalidAuthenticationTokenTenant' && error.statusCode === 401) {
+					/**
+					 * There may be multiple tenants for an account and it may throw exceptions like following. Just swallow the exception here.
+					 *   The access token is from the wrong issuer. It must match one of the tenants associated with this subscription.
+					 */
+				}
+			}
+		}
+
+		return databases;
+	}
+}

extensions/azurecore/src/azureResource/services/subscriptionFilterService.ts

@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { WorkspaceConfiguration, ConfigurationTarget } from 'vscode';
+import { Account } from 'sqlops';
+
+import { IAzureResourceSubscriptionFilterService, IAzureResourceCacheService } from '../interfaces';
+import { AzureResourceSubscription } from '../models';
+
+interface AzureResourceSelectedSubscriptionsCache {
+	selectedSubscriptions: { [accountId: string]: AzureResourceSubscription[]};
+}
+
+export class AzureResourceSubscriptionFilterService implements IAzureResourceSubscriptionFilterService {
+	public constructor(
+		cacheService: IAzureResourceCacheService
+	) {
+		this._cacheService = cacheService;
+	}
+
+	public async getSelectedSubscriptions(account: Account): Promise<AzureResourceSubscription[]> {
+		let selectedSubscriptions: AzureResourceSubscription[] = [];
+
+		const cache = this._cacheService.get<AzureResourceSelectedSubscriptionsCache>(AzureResourceSubscriptionFilterService.CacheKey);
+		if (cache) {
+			selectedSubscriptions = cache.selectedSubscriptions[account.key.accountId];
+		}
+
+		return selectedSubscriptions;
+	}
+
+	public async saveSelectedSubscriptions(account: Account, selectedSubscriptions: AzureResourceSubscription[]): Promise<void> {
+		let selectedSubscriptionsCache: { [accountId: string]: AzureResourceSubscription[]} = {};
+
+		const cache = this._cacheService.get<AzureResourceSelectedSubscriptionsCache>(AzureResourceSubscriptionFilterService.CacheKey);
+		if (cache) {
+			selectedSubscriptionsCache = cache.selectedSubscriptions;
+		}
+
+		if (!selectedSubscriptionsCache) {
+			selectedSubscriptionsCache = {};
+		}
+
+		selectedSubscriptionsCache[account.key.accountId] = selectedSubscriptions;
+
+		this._cacheService.update<AzureResourceSelectedSubscriptionsCache>(AzureResourceSubscriptionFilterService.CacheKey, { selectedSubscriptions: selectedSubscriptionsCache });
+
+		const filters: string[] = [];
+		for (const accountId in selectedSubscriptionsCache) {
+			filters.push(...selectedSubscriptionsCache[accountId].map((subcription) => `${accountId}/${subcription.id}/${subcription.name}`));
+		}
+
+		const resourceFilterConfig = this._config.inspect<string[]>(AzureResourceSubscriptionFilterService.FilterConfigName);
+		let configTarget = ConfigurationTarget.Global;
+		if (resourceFilterConfig) {
+			if (resourceFilterConfig.workspaceFolderValue) {
+				configTarget = ConfigurationTarget.WorkspaceFolder;
+			} else if (resourceFilterConfig.workspaceValue) {
+				configTarget = ConfigurationTarget.Workspace;
+			} else if (resourceFilterConfig.globalValue) {
+				configTarget = ConfigurationTarget.Global;
+			}
+		}
+
+		await this._config.update(AzureResourceSubscriptionFilterService.FilterConfigName, filters, configTarget);
+	}
+
+	private _config: WorkspaceConfiguration = undefined;
+	private _cacheService: IAzureResourceCacheService = undefined;
+
+	private static readonly FilterConfigName = 'resourceFilter';
+	private static readonly CacheKey = 'azureResource.cache.selectedSubscriptions';
+}

extensions/azurecore/src/azureResource/services/subscriptionService.ts

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { Account } from 'sqlops';
+import { ServiceClientCredentials } from 'ms-rest';
+import { SubscriptionClient } from 'azure-arm-resource';
+
+import { IAzureResourceSubscriptionService } from '../interfaces';
+import { AzureResourceSubscription } from '../models';
+
+export class AzureResourceSubscriptionService implements IAzureResourceSubscriptionService {
+	public async getSubscriptions(account: Account, credentials: ServiceClientCredentials[]): Promise<AzureResourceSubscription[]> {
+		let subscriptions: AzureResourceSubscription[] = [];
+		for (let cred of credentials) {
+			let subClient = new SubscriptionClient.SubscriptionClient(cred);
+			try {
+				let subs = await subClient.subscriptions.list();
+				subs.forEach((sub) => subscriptions.push({
+					id: sub.subscriptionId,
+					name: sub.displayName
+				}));
+			} catch (error) {
+				// Swallow the exception here.
+			}
+		}
+
+		return subscriptions;
+	}
+}

extensions/azurecore/src/azureResource/tree/accountNotSignedInTreeNode.ts

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TreeItem, TreeItemCollapsibleState } from 'vscode';
+import { NodeInfo } from 'sqlops';
+import { TreeNode } from '../../treeNodes';
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+import { AzureResourceItemType } from '../constants';
+
+export class AzureResourceAccountNotSignedInTreeNode extends TreeNode {
+	public getChildren(): TreeNode[] | Promise<TreeNode[]> {
+		return [];
+	}
+
+	public getTreeItem(): TreeItem | Promise<TreeItem> {
+		let item = new TreeItem(AzureResourceAccountNotSignedInTreeNode.SignInLabel, TreeItemCollapsibleState.None);
+		item.contextValue = AzureResourceItemType.message;
+		item.command = {
+			title: AzureResourceAccountNotSignedInTreeNode.SignInLabel,
+			command: 'azureresource.signin',
+			arguments: [this]
+		};
+		return item;
+	}
+
+	public getNodeInfo(): NodeInfo {
+		return {
+			label: AzureResourceAccountNotSignedInTreeNode.SignInLabel,
+			isLeaf: true,
+			errorMessage: undefined,
+			metadata: undefined,
+			nodePath: this.generateNodePath(),
+			nodeStatus: undefined,
+			nodeType: AzureResourceItemType.message,
+			nodeSubType: undefined,
+			iconType: AzureResourceItemType.message
+		};
+	}
+
+	public get nodePathValue(): string {
+		return 'message_accountNotSignedIn';
+	}
+
+	private static readonly SignInLabel = localize('azureResource.tree.accountNotSignedInTreeNode.signIn', 'Sign in to Azure ...');
+}

extensions/azurecore/src/azureResource/tree/accountTreeNode.ts

@@ -0,0 +1,155 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TreeItem, TreeItemCollapsibleState } from 'vscode';
+import { Account, NodeInfo } from 'sqlops';
+import { TreeNode } from '../../treeNodes';
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+import { AzureResourceContainerTreeNodeBase } from './baseTreeNodes';
+import { AzureResourceItemType } from '../constants';
+import { AzureResourceSubscriptionTreeNode } from './subscriptionTreeNode';
+import { AzureResourceMessageTreeNode } from './messageTreeNode';
+import { AzureResourceErrorMessageUtil } from '../utils';
+import { AzureResourceSubscription } from '../models';
+import { IAzureResourceTreeChangeHandler } from './treeProvider';
+
+export class AzureResourceAccountTreeNode extends AzureResourceContainerTreeNodeBase {
+	public constructor(
+		account: Account,
+		treeChangeHandler: IAzureResourceTreeChangeHandler
+	) {
+		super(account, treeChangeHandler, undefined);
+
+		this._id = `account_${this.account.key.accountId}`;
+		this._label = this.generateLabel();
+	}
+
+	public async getChildren(): Promise<TreeNode[]> {
+		try {
+			let subscriptions: AzureResourceSubscription[] = [];
+
+			if (this._isClearingCache) {
+				const credentials = await this.getCredentials();
+				subscriptions = (await this.servicePool.subscriptionService.getSubscriptions(this.account, credentials)) || <AzureResourceSubscription[]>[];
+
+				let cache = this.getCache<AzureResourceSubscriptionsCache>();
+				if (!cache) {
+					cache = { subscriptions: { } };
+				}
+				cache.subscriptions[this.account.key.accountId] = subscriptions;
+				this.updateCache<AzureResourceSubscriptionsCache>(cache);
+
+				this._isClearingCache = false;
+			} else {
+				subscriptions = await this.getCachedSubscriptions();
+			}
+
+			this._totalSubscriptionCount = subscriptions.length;
+
+			let selectedSubscriptions = await this.servicePool.subscriptionFilterService.getSelectedSubscriptions(this.account);
+			let selectedSubscriptionIds = (selectedSubscriptions || <AzureResourceSubscription[]>[]).map((subscription) => subscription.id);
+			if (selectedSubscriptionIds.length > 0) {
+				subscriptions = subscriptions.filter((subscription) => selectedSubscriptionIds.indexOf(subscription.id) !== -1);
+				this._selectedSubscriptionCount = selectedSubscriptionIds.length;
+			} else {
+				// ALL subscriptions are listed by default
+				this._selectedSubscriptionCount = this._totalSubscriptionCount;
+			}
+
+			this.refreshLabel();
+
+			if (subscriptions.length === 0) {
+				return [AzureResourceMessageTreeNode.create(AzureResourceAccountTreeNode.NoSubscriptions, this)];
+			} else {
+				return subscriptions.map((subscription) => new AzureResourceSubscriptionTreeNode(subscription, this.account, this.treeChangeHandler, this));
+			}
+		} catch (error) {
+			return [AzureResourceMessageTreeNode.create(AzureResourceErrorMessageUtil.getErrorMessage(error), this)];
+		}
+	}
+
+	public async getCachedSubscriptions(): Promise<AzureResourceSubscription[]> {
+		const subscriptions: AzureResourceSubscription[] = [];
+		const cache = this.getCache<AzureResourceSubscriptionsCache>();
+		if (cache) {
+			subscriptions.push(...cache.subscriptions[this.account.key.accountId]);
+		}
+		return subscriptions;
+	}
+
+	public getTreeItem(): TreeItem | Promise<TreeItem> {
+		let item = new TreeItem(this._label, TreeItemCollapsibleState.Collapsed);
+		item.id = this._id;
+		item.contextValue = AzureResourceItemType.account;
+		item.iconPath = {
+			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/account_inverse.svg'),
+			light: this.servicePool.contextService.getAbsolutePath('resources/light/account.svg')
+		};
+		return item;
+	}
+
+	public getNodeInfo(): NodeInfo {
+		return {
+			label: this._label,
+			isLeaf: false,
+			errorMessage: undefined,
+			metadata: undefined,
+			nodePath: this.generateNodePath(),
+			nodeStatus: undefined,
+			nodeType: AzureResourceItemType.account,
+			nodeSubType: undefined,
+			iconType: AzureResourceItemType.account
+		};
+	}
+
+	public get nodePathValue(): string {
+		return this._id;
+	}
+
+	public get totalSubscriptionCount(): number {
+		return this._totalSubscriptionCount;
+	}
+
+	public get selectedSubscriptionCount(): number {
+		return this._selectedSubscriptionCount;
+	}
+
+	protected refreshLabel(): void {
+		const newLabel = this.generateLabel();
+		if (this._label !== newLabel) {
+			this._label = newLabel;
+			this.treeChangeHandler.notifyNodeChanged(this);
+		}
+	}
+
+	protected get cacheKey(): string {
+		return 'azureResource.cache.subscriptions';
+	}
+
+	private generateLabel(): string {
+		let label = `${this.account.displayInfo.displayName} (${this.account.key.accountId})`;
+
+		if (this._totalSubscriptionCount !== 0) {
+			label += ` (${this._selectedSubscriptionCount} / ${this._totalSubscriptionCount} subscriptions)`;
+		}
+
+		return label;
+	}
+
+	private _id: string = undefined;
+	private _label: string = undefined;
+	private _totalSubscriptionCount = 0;
+	private _selectedSubscriptionCount = 0;
+
+	private static readonly NoSubscriptions = localize('azureResource.tree.accountTreeNode.noSubscriptions', 'No Subscriptions found.');
+}
+
+interface AzureResourceSubscriptionsCache {
+	subscriptions: { [accountId: string]: AzureResourceSubscription[] };
+}

extensions/azurecore/src/azureResource/tree/baseTreeNodes.ts

@@ -0,0 +1,71 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { Account } from 'sqlops';
+import { ServiceClientCredentials } from 'ms-rest';
+import { TreeNode } from '../../treeNodes';
+
+import { AzureResourceServicePool } from '../servicePool';
+import { AzureResourceCredentialError } from '../errors';
+import { IAzureResourceTreeChangeHandler } from './treeChangeHandler';
+
+export abstract class AzureResourceTreeNodeBase extends TreeNode {
+	public constructor(
+		public readonly treeChangeHandler: IAzureResourceTreeChangeHandler,
+		parent: TreeNode
+	) {
+		super();
+
+		this.parent = parent;
+	}
+
+	public readonly servicePool = AzureResourceServicePool.getInstance();
+}
+
+export abstract class AzureResourceContainerTreeNodeBase extends AzureResourceTreeNodeBase {
+	public constructor(
+		public readonly account: Account,
+		treeChangeHandler: IAzureResourceTreeChangeHandler,
+		parent: TreeNode
+	) {
+		super(treeChangeHandler, parent);
+	}
+
+	public clearCache(): void {
+		this._isClearingCache = true;
+	}
+
+	public get isClearingCache(): boolean {
+		return this._isClearingCache;
+	}
+
+	protected async getCredentials(): Promise<ServiceClientCredentials[]> {
+		try {
+			return await this.servicePool.credentialService.getCredentials(this.account);
+		} catch (error) {
+			if (error instanceof AzureResourceCredentialError) {
+				this.servicePool.contextService.showErrorMessage(error.message);
+
+				this.servicePool.contextService.executeCommand('azureresource.signin');
+			} else {
+				throw error;
+			}
+		}
+	}
+
+	protected updateCache<T>(cache: T): void {
+		this.servicePool.cacheService.update<T>(this.cacheKey, cache);
+	}
+
+	protected getCache<T>(): T {
+		return this.servicePool.cacheService.get<T>(this.cacheKey);
+	}
+
+	protected abstract get cacheKey(): string;
+
+	protected _isClearingCache = true;
+}

extensions/azurecore/src/azureResource/tree/databaseContainerTreeNode.ts

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TreeItem, TreeItemCollapsibleState } from 'vscode';
+import { Account, NodeInfo } from 'sqlops';
+import { TreeNode } from '../../treeNodes';
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+import { AzureResourceContainerTreeNodeBase } from './baseTreeNodes';
+import { AzureResourceItemType } from '../constants';
+import { AzureResourceErrorMessageUtil } from '../utils';
+import { AzureResourceDatabaseTreeNode } from './databaseTreeNode';
+import { AzureResourceMessageTreeNode } from './messageTreeNode';
+import { AzureResourceSubscription, AzureResourceDatabase } from '../models';
+import { IAzureResourceTreeChangeHandler } from './treeProvider';
+
+export class AzureResourceDatabaseContainerTreeNode extends AzureResourceContainerTreeNodeBase {
+	public constructor(
+		public readonly subscription: AzureResourceSubscription,
+		account: Account,
+		treeChangeHandler: IAzureResourceTreeChangeHandler,
+		parent: TreeNode
+	) {
+		super(account, treeChangeHandler, parent);
+	}
+
+	public async getChildren(): Promise<TreeNode[]> {
+		try {
+			let databases: AzureResourceDatabase[] = [];
+
+			if (this._isClearingCache) {
+				let credentials = await this.getCredentials();
+				databases = (await this.servicePool.databaseService.getDatabases(this.subscription, credentials)) || <AzureResourceDatabase[]>[];
+
+				let cache = this.getCache<AzureResourceDatabasesCache>();
+				if (!cache) {
+					cache = { databases: { } };
+				}
+				cache.databases[this.subscription.id] = databases;
+				this.updateCache(cache);
+
+				this._isClearingCache = false;
+			} else {
+				const cache = this.getCache<AzureResourceDatabasesCache>();
+				if (cache) {
+					databases = cache.databases[this.subscription.id] || <AzureResourceDatabase[]>[];
+				}
+			}
+
+			if (databases.length === 0) {
+				return [AzureResourceMessageTreeNode.create(AzureResourceDatabaseContainerTreeNode.NoDatabases, this)];
+			} else {
+				return databases.map((database) => new AzureResourceDatabaseTreeNode(database, this.treeChangeHandler, this));
+			}
+		} catch (error) {
+			return [AzureResourceMessageTreeNode.create(AzureResourceErrorMessageUtil.getErrorMessage(error), this)];
+		}
+	}
+
+	public getTreeItem(): TreeItem | Promise<TreeItem> {
+		let item = new TreeItem(AzureResourceDatabaseContainerTreeNode.Label, TreeItemCollapsibleState.Collapsed);
+		item.contextValue = AzureResourceItemType.databaseContainer;
+		item.iconPath = {
+			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/folder_inverse.svg'),
+			light: this.servicePool.contextService.getAbsolutePath('resources/light/folder.svg')
+		};
+		return item;
+	}
+
+	public getNodeInfo(): NodeInfo {
+		return {
+			label: AzureResourceDatabaseContainerTreeNode.Label,
+			isLeaf: false,
+			errorMessage: undefined,
+			metadata: undefined,
+			nodePath: this.generateNodePath(),
+			nodeStatus: undefined,
+			nodeType: AzureResourceItemType.databaseContainer,
+			nodeSubType: undefined,
+			iconType: AzureResourceItemType.databaseContainer
+		};
+	}
+
+	public get nodePathValue(): string {
+		return 'databaseContainer';
+	}
+
+	protected get cacheKey(): string {
+		return 'azureResource.cache.databases';
+	}
+
+	private static readonly Label = localize('azureResource.tree.databaseContainerTreeNode.label', 'SQL Databases');
+	private static readonly NoDatabases = localize('azureResource.tree.databaseContainerTreeNode.noDatabases', 'No SQL Databases found.');
+}
+
+interface AzureResourceDatabasesCache {
+	databases: { [subscriptionId: string]: AzureResourceDatabase[] };
+}

extensions/azurecore/src/azureResource/tree/databaseServerContainerTreeNode.ts

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TreeItem, TreeItemCollapsibleState } from 'vscode';
+import { Account, NodeInfo } from 'sqlops';
+import { TreeNode } from '../../treeNodes';
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+import { AzureResourceContainerTreeNodeBase } from './baseTreeNodes';
+import { AzureResourceItemType } from '../constants';
+import { AzureResourceMessageTreeNode } from './messageTreeNode';
+import { AzureResourceErrorMessageUtil } from '../utils';
+import { AzureResourceSubscription, AzureResourceDatabaseServer } from '../models';
+import { AzureResourceDatabaseServerTreeNode } from './databaseServerTreeNode';
+import { IAzureResourceTreeChangeHandler } from './treeProvider';
+
+export class AzureResourceDatabaseServerContainerTreeNode extends AzureResourceContainerTreeNodeBase {
+	public constructor(
+		public readonly subscription: AzureResourceSubscription,
+		account: Account,
+		treeChangeHandler: IAzureResourceTreeChangeHandler,
+		parent: TreeNode
+	) {
+		super(account, treeChangeHandler, parent);
+	}
+
+	public async getChildren(): Promise<TreeNode[]> {
+		try {
+			let databaseServers: AzureResourceDatabaseServer[] = [];
+
+			if (this._isClearingCache) {
+				let credentials = await this.getCredentials();
+				databaseServers = (await this.servicePool.databaseServerService.getDatabaseServers(this.subscription, credentials)) || <AzureResourceDatabaseServer[]>[];
+
+				let cache = this.getCache<AzureResourceDatabaseServersCache>();
+				if (!cache) {
+					cache = { databaseServers: { } };
+				}
+				cache.databaseServers[this.subscription.id] = databaseServers;
+				this.updateCache<AzureResourceDatabaseServersCache>(cache);
+
+				this._isClearingCache = false;
+			} else {
+				const cache = this.getCache<AzureResourceDatabaseServersCache>();
+				if (cache) {
+					databaseServers = cache.databaseServers[this.subscription.id] || <AzureResourceDatabaseServer[]>[];
+				}
+			}
+
+			if (databaseServers.length === 0) {
+				return [AzureResourceMessageTreeNode.create(AzureResourceDatabaseServerContainerTreeNode.NoDatabaseServers, this)];
+			} else {
+				return databaseServers.map((server) => new AzureResourceDatabaseServerTreeNode(server, this.treeChangeHandler, this));
+			}
+		} catch (error) {
+			return [AzureResourceMessageTreeNode.create(AzureResourceErrorMessageUtil.getErrorMessage(error), this)];
+		}
+	}
+
+	public getTreeItem(): TreeItem | Promise<TreeItem> {
+		let item = new TreeItem(AzureResourceDatabaseServerContainerTreeNode.Label, TreeItemCollapsibleState.Collapsed);
+		item.contextValue = AzureResourceItemType.databaseServerContainer;
+		item.iconPath = {
+			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/folder_inverse.svg'),
+			light: this.servicePool.contextService.getAbsolutePath('resources/light/folder.svg')
+		};
+		return item;
+	}
+
+	public getNodeInfo(): NodeInfo {
+		return {
+			label: AzureResourceDatabaseServerContainerTreeNode.Label,
+			isLeaf: false,
+			errorMessage: undefined,
+			metadata: undefined,
+			nodePath: this.generateNodePath(),
+			nodeStatus: undefined,
+			nodeType: AzureResourceItemType.databaseServerContainer,
+			nodeSubType: undefined,
+			iconType: AzureResourceItemType.databaseServerContainer
+		};
+	}
+
+	public get nodePathValue(): string {
+		return 'databaseServerContainer';
+	}
+
+	protected get cacheKey(): string {
+		return 'azureResource.cache.databaseServers';
+	}
+
+	private static readonly Label = localize('azureResource.tree.databaseServerContainerTreeNode.label', 'SQL Servers');
+	private static readonly NoDatabaseServers = localize('azureResource.tree.databaseContainerTreeNode.noDatabaseServers', 'No SQL Servers found.');
+}
+
+interface AzureResourceDatabaseServersCache {
+	databaseServers: { [subscriptionId: string]: AzureResourceDatabaseServer[] };
+}

extensions/azurecore/src/azureResource/tree/databaseServerTreeNode.ts

@@ -0,0 +1,57 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TreeItem, TreeItemCollapsibleState } from 'vscode';
+import { NodeInfo } from 'sqlops';
+import { TreeNode } from '../../treeNodes';
+
+import { AzureResourceTreeNodeBase } from './baseTreeNodes';
+import { AzureResourceItemType } from '../constants';
+import { AzureResourceDatabaseServer } from '../models';
+import { IAzureResourceTreeChangeHandler } from './treeProvider';
+
+export class AzureResourceDatabaseServerTreeNode extends AzureResourceTreeNodeBase {
+	public constructor(
+		public readonly databaseServer: AzureResourceDatabaseServer,
+		treeChangeHandler: IAzureResourceTreeChangeHandler,
+		parent: TreeNode
+	) {
+		super(treeChangeHandler, parent);
+	}
+
+	public async getChildren(): Promise<TreeNode[]> {
+		return [];
+	}
+
+	public getTreeItem(): TreeItem | Promise<TreeItem> {
+		let item = new TreeItem(this.databaseServer.name, TreeItemCollapsibleState.None);
+		item.contextValue = AzureResourceItemType.databaseServer;
+		item.iconPath = {
+			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/sql_server_inverse.svg'),
+			light: this.servicePool.contextService.getAbsolutePath('resources/light/sql_server.svg')
+		};
+		return item;
+	}
+
+	public getNodeInfo(): NodeInfo {
+		return {
+			label: this.databaseServer.name,
+			isLeaf: true,
+			errorMessage: undefined,
+			metadata: undefined,
+			nodePath: this.generateNodePath(),
+			nodeStatus: undefined,
+			nodeType: AzureResourceItemType.databaseServer,
+			nodeSubType: undefined,
+			iconType: AzureResourceItemType.databaseServer
+		};
+	}
+
+	public get nodePathValue(): string {
+		return `databaseServer_${this.databaseServer.name}`;
+	}
+}

extensions/azurecore/src/azureResource/tree/databaseTreeNode.ts

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TreeItem, TreeItemCollapsibleState } from 'vscode';
+import { NodeInfo } from 'sqlops';
+import { TreeNode } from '../../treeNodes';
+
+import { AzureResourceTreeNodeBase } from './baseTreeNodes';
+import { AzureResourceItemType } from '../constants';
+import { AzureResourceDatabase } from '../models';
+import { IAzureResourceTreeChangeHandler } from './treeProvider';
+
+export class AzureResourceDatabaseTreeNode extends AzureResourceTreeNodeBase {
+	public constructor(
+		public readonly database: AzureResourceDatabase,
+		treeChangeHandler: IAzureResourceTreeChangeHandler,
+		parent: TreeNode
+	) {
+		super(treeChangeHandler, parent);
+
+		this._label = `${this.database.name} (${this.database.serverName})`;
+	}
+
+	public async getChildren(): Promise<TreeNode[]> {
+		return [];
+	}
+
+	public getTreeItem(): TreeItem | Promise<TreeItem> {
+		let item = new TreeItem(this._label, TreeItemCollapsibleState.None);
+		item.contextValue = AzureResourceItemType.database;
+		item.iconPath = {
+			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/sql_database_inverse.svg'),
+			light: this.servicePool.contextService.getAbsolutePath('resources/light/sql_database.svg')
+		};
+		return item;
+	}
+
+	public getNodeInfo(): NodeInfo {
+		return {
+			label: this._label,
+			isLeaf: true,
+			errorMessage: undefined,
+			metadata: undefined,
+			nodePath: this.generateNodePath(),
+			nodeStatus: undefined,
+			nodeType: AzureResourceItemType.database,
+			nodeSubType: undefined,
+			iconType: AzureResourceItemType.database
+		};
+	}
+
+	public get nodePathValue(): string {
+		return `database_${this.database.name}`;
+	}
+
+	private _label: string = undefined;
+}

extensions/azurecore/src/azureResource/tree/messageTreeNode.ts

@@ -0,0 +1,60 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TreeItem, TreeItemCollapsibleState } from 'vscode';
+import { NodeInfo } from 'sqlops';
+import { TreeNode } from '../../treeNodes';
+
+import { AzureResourceItemType } from '../constants';
+
+export class AzureResourceMessageTreeNode extends TreeNode {
+	public constructor(
+		public readonly message: string,
+		parent: TreeNode
+	) {
+		super();
+
+		this.parent = parent;
+		this._id = `message_${AzureResourceMessageTreeNode._messageNum++}`;
+	}
+
+	public static create(message: string, parent: TreeNode): AzureResourceMessageTreeNode {
+		return new AzureResourceMessageTreeNode(message, parent);
+	}
+
+	public getChildren(): TreeNode[] | Promise<TreeNode[]> {
+		return [];
+	}
+
+	public getTreeItem(): TreeItem | Promise<TreeItem> {
+		let item = new TreeItem(this.message, TreeItemCollapsibleState.None);
+		item.contextValue = AzureResourceItemType.message;
+		return item;
+	}
+
+	public getNodeInfo(): NodeInfo {
+		return {
+			label: this.message,
+			isLeaf: true,
+			errorMessage: undefined,
+			metadata: undefined,
+			nodePath: this.generateNodePath(),
+			nodeStatus: undefined,
+			nodeType: AzureResourceItemType.message,
+			nodeSubType: undefined,
+			iconType: AzureResourceItemType.message
+		};
+	}
+
+	public get nodePathValue(): string {
+		return this._id;
+	}
+
+	private _id: string;
+
+	private static _messageNum: number = 0;
+}

extensions/azurecore/src/azureResource/tree/subscriptionTreeNode.ts

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TreeItem, TreeItemCollapsibleState } from 'vscode';
+import { Account, NodeInfo } from 'sqlops';
+import { TreeNode } from '../../treeNodes';
+
+import { AzureResourceTreeNodeBase, AzureResourceContainerTreeNodeBase } from './baseTreeNodes';
+import { AzureResourceItemType } from '../constants';
+import { AzureResourceDatabaseContainerTreeNode } from './databaseContainerTreeNode';
+import { AzureResourceDatabaseServerContainerTreeNode } from './databaseServerContainerTreeNode';
+import { AzureResourceSubscription } from '../models';
+import { IAzureResourceTreeChangeHandler } from './treeChangeHandler';
+
+export class AzureResourceSubscriptionTreeNode extends AzureResourceTreeNodeBase {
+	public constructor(
+		public readonly subscription: AzureResourceSubscription,
+		account: Account,
+		treeChangeHandler: IAzureResourceTreeChangeHandler,
+		parent: TreeNode
+	) {
+		super(treeChangeHandler, parent);
+
+		this._children.push(new AzureResourceDatabaseContainerTreeNode(subscription, account, treeChangeHandler, this));
+		this._children.push(new AzureResourceDatabaseServerContainerTreeNode(subscription, account, treeChangeHandler, this));
+	}
+
+	public async getChildren(): Promise<TreeNode[]> {
+		return this._children;
+	}
+
+	public getTreeItem(): TreeItem | Promise<TreeItem> {
+		let item = new TreeItem(this.subscription.name, TreeItemCollapsibleState.Collapsed);
+		item.contextValue = AzureResourceItemType.subscription;
+		item.iconPath = {
+			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/subscription_inverse.svg'),
+			light: this.servicePool.contextService.getAbsolutePath('resources/light/subscription.svg')
+		};
+		return item;
+	}
+
+	public getNodeInfo(): NodeInfo {
+		return {
+			label: this.subscription.name,
+			isLeaf: false,
+			errorMessage: undefined,
+			metadata: undefined,
+			nodePath: this.generateNodePath(),
+			nodeStatus: undefined,
+			nodeType: AzureResourceItemType.subscription,
+			nodeSubType: undefined,
+			iconType: AzureResourceItemType.subscription
+		};
+	}
+
+	public get nodePathValue(): string {
+		return `subscription_${this.subscription.id}`;
+	}
+
+	private _children: AzureResourceContainerTreeNodeBase[] = [];
+}

extensions/azurecore/src/azureResource/tree/treeChangeHandler.ts

@@ -0,0 +1,12 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TreeNode } from '../../treeNodes';
+
+export interface IAzureResourceTreeChangeHandler {
+	notifyNodeChanged(node: TreeNode): void;
+}

extensions/azurecore/src/azureResource/tree/treeProvider.ts

@@ -0,0 +1,101 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TreeDataProvider, EventEmitter, Event, TreeItem } from 'vscode';
+import { DidChangeAccountsParams } from 'sqlops';
+import { TreeNode } from '../../treeNodes';
+import { setInterval, clearInterval } from 'timers';
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+import { AzureResourceServicePool } from '../servicePool';
+import { AzureResourceAccountTreeNode } from './accountTreeNode';
+import { AzureResourceAccountNotSignedInTreeNode } from './accountNotSignedInTreeNode';
+import { AzureResourceMessageTreeNode } from './messageTreeNode';
+import { AzureResourceContainerTreeNodeBase, AzureResourceTreeNodeBase } from './baseTreeNodes';
+import { AzureResourceErrorMessageUtil } from '../utils';
+
+export interface IAzureResourceTreeChangeHandler {
+	notifyNodeChanged(node: TreeNode): void;
+}
+
+export class AzureResourceTreeProvider implements TreeDataProvider<TreeNode>, IAzureResourceTreeChangeHandler {
+	public constructor() {
+		AzureResourceServicePool.getInstance().accountService.onDidChangeAccounts((e: DidChangeAccountsParams) => { this._onDidChangeTreeData.fire(undefined); });
+	}
+
+	public async getChildren(element?: TreeNode): Promise<TreeNode[]> {
+		if (element) {
+			return element.getChildren(true);
+		}
+
+		if (!this.isSystemInitialized) {
+			this._loadingTimer = setInterval(async () => {
+				try {
+					// Call sqlops.accounts.getAllAccounts() to determine whether the system has been initialized.
+					await AzureResourceServicePool.getInstance().accountService.getAccounts();
+
+					// System has been initialized
+					this.isSystemInitialized = true;
+
+					if (this._loadingTimer) {
+						clearInterval(this._loadingTimer);
+					}
+
+					this._onDidChangeTreeData.fire(undefined);
+				} catch (error) {
+					// System not initialized yet
+					this.isSystemInitialized = false;
+				}
+			}, AzureResourceTreeProvider.LoadingTimerInterval);
+
+			return [AzureResourceMessageTreeNode.create(AzureResourceTreeProvider.Loading, undefined)];
+		}
+
+		try {
+			const accounts = await AzureResourceServicePool.getInstance().accountService.getAccounts();
+
+			if (accounts && accounts.length > 0) {
+				return accounts.map((account) => new AzureResourceAccountTreeNode(account, this));
+			} else {
+				return [new AzureResourceAccountNotSignedInTreeNode()];
+			}
+		} catch (error) {
+			return [AzureResourceMessageTreeNode.create(AzureResourceErrorMessageUtil.getErrorMessage(error), undefined)];
+		}
+	}
+
+	public get onDidChangeTreeData(): Event<TreeNode> {
+		return this._onDidChangeTreeData.event;
+	}
+
+	public notifyNodeChanged(node: TreeNode): void {
+		this._onDidChangeTreeData.fire(node);
+	}
+
+	public async refresh(node: TreeNode, isClearingCache: boolean): Promise<void> {
+		if (isClearingCache) {
+			if ((node instanceof AzureResourceContainerTreeNodeBase)) {
+				node.clearCache();
+			}
+		}
+
+		this._onDidChangeTreeData.fire(node);
+	}
+
+	public getTreeItem(element: TreeNode): TreeItem | Thenable<TreeItem> {
+		return element.getTreeItem();
+	}
+
+	public isSystemInitialized: boolean = false;
+
+	private _loadingTimer: NodeJS.Timer = undefined;
+	private _onDidChangeTreeData = new EventEmitter<TreeNode>();
+
+	private static readonly Loading = localize('azureResource.tree.treeProvider.loading', 'Loading ...');
+	private static readonly LoadingTimerInterval = 5000;
+}

extensions/azurecore/src/azureResource/utils.ts

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+export function getErrorMessage(error: Error | string): string {
+    return (error instanceof Error) ? error.message : error;
+}
+
+
+export class AzureResourceErrorMessageUtil {
+	public static getErrorMessage(error: Error | string): string {
+		return localize('azureResource.error', 'Error: {0}', getErrorMessage(error));
+	}
+}
+
+export function generateGuid(): string {
+    let hexValues: string[] = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'];
+    // c.f. rfc4122 (UUID version 4 = xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx)
+    let oct: string = '';
+    let tmp: number;
+    /* tslint:disable:no-bitwise */
+    for (let a: number = 0; a < 4; a++) {
+        tmp = (4294967296 * Math.random()) | 0;
+        oct += hexValues[tmp & 0xF] +
+            hexValues[tmp >> 4 & 0xF] +
+            hexValues[tmp >> 8 & 0xF] +
+            hexValues[tmp >> 12 & 0xF] +
+            hexValues[tmp >> 16 & 0xF] +
+            hexValues[tmp >> 20 & 0xF] +
+            hexValues[tmp >> 24 & 0xF] +
+            hexValues[tmp >> 28 & 0xF];
+    }
+
+    // 'Set the two most significant bits (bits 6 and 7) of the clock_seq_hi_and_reserved to zero and one, respectively'
+    let clockSequenceHi: string = hexValues[8 + (Math.random() * 4) | 0];
+    return oct.substr(0, 8) + '-' + oct.substr(9, 4) + '-4' + oct.substr(13, 3) + '-' + clockSequenceHi + oct.substr(16, 3) + '-' + oct.substr(19, 12);
+    /* tslint:enable:no-bitwise */
+}

extensions/azurecore/src/constants.ts

@@ -0,0 +1,8 @@
+'use strict';
+
+export const extensionConfigSectionName = 'azure';
+export const ViewType = 'view';
+
+export enum BuiltInCommands {
+	SetContext = 'setContext'
+}

extensions/azurecore/src/controllers/controllerBase.ts

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as vscode from 'vscode';
+
+import { AppContext } from '../appContext';
+import { ApiWrapper } from '../apiWrapper';
+
+export default abstract class ControllerBase implements vscode.Disposable {
+
+	public constructor(protected appContext: AppContext) {
+	}
+
+	protected get apiWrapper(): ApiWrapper {
+		return this.appContext.apiWrapper;
+	}
+
+	public get extensionContext(): vscode.ExtensionContext {
+		return this.appContext && this.appContext.extensionContext;
+	}
+
+	abstract activate(): Promise<boolean>;
+
+	abstract deactivate(): void;
+
+	public dispose(): void {
+		this.deactivate();
+	}
+}
+

extensions/azurecore/src/controllers/mainController.ts

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import ControllerBase from './controllerBase';
+
+import { AzureResourceTreeProvider } from '../azureResource/tree/treeProvider';
+import { registerAzureResourceCommands } from '../azureResource/commands';
+import { AzureResourceServicePool } from '../azureResource/servicePool';
+import { AzureResourceCredentialService } from '../azureResource/services/credentialService';
+import { AzureResourceAccountService } from '../azureResource/services/accountService';
+import { AzureResourceSubscriptionService } from '../azureResource/services/subscriptionService';
+import { AzureResourceSubscriptionFilterService } from '../azureResource/services/subscriptionFilterService';
+import { AzureResourceDatabaseServerService } from '../azureResource/services/databaseServerService';
+import { AzureResourceDatabaseService } from '../azureResource/services/databaseService';
+import { AzureResourceCacheService } from '../azureResource/services/cacheService';
+import { AzureResourceContextService } from '../azureResource/services/contextService';
+
+/**
+ * The main controller class that initializes the extension
+ */
+export default class MainController extends ControllerBase {
+	// PUBLIC METHODS //////////////////////////////////////////////////////
+	/**
+	 * Deactivates the extension
+	 */
+	public deactivate(): void {
+	}
+
+	public activate(): Promise<boolean> {
+		this.configureAzureResource();
+		return Promise.resolve(true);
+	}
+
+	private configureAzureResource(): void {
+		let servicePool = AzureResourceServicePool.getInstance();
+		servicePool.cacheService = new AzureResourceCacheService(this.extensionContext);
+		servicePool.contextService = new AzureResourceContextService(this.extensionContext, this.apiWrapper);
+		servicePool.accountService = new AzureResourceAccountService(this.apiWrapper);
+		servicePool.credentialService = new AzureResourceCredentialService(this.apiWrapper);
+		servicePool.subscriptionService = new AzureResourceSubscriptionService();
+		servicePool.subscriptionFilterService = new AzureResourceSubscriptionFilterService(new AzureResourceCacheService(this.extensionContext));
+		servicePool.databaseService = new AzureResourceDatabaseService();
+		servicePool.databaseServerService = new AzureResourceDatabaseServerService();
+
+		let azureResourceTree = new AzureResourceTreeProvider();
+		this.extensionContext.subscriptions.push(this.apiWrapper.registerTreeDataProvider('azureResourceExplorer', azureResourceTree));
+
+		registerAzureResourceCommands(this.apiWrapper, azureResourceTree);
+	}
+}

extensions/azurecore/src/extension.ts

@@ -0,0 +1,40 @@
+'use strict';
+
+import * as vscode from 'vscode';
+
+import MainController from './controllers/mainController';
+import { AppContext } from './appContext';
+import ControllerBase from './controllers/controllerBase';
+import { ApiWrapper } from './apiWrapper';
+
+let controllers: ControllerBase[] = [];
+
+// this method is called when your extension is activated
+// your extension is activated the very first time the command is executed
+export function activate(extensionContext: vscode.ExtensionContext) {
+	let appContext = new AppContext(extensionContext, new ApiWrapper());
+	let activations: Promise<boolean>[] = [];
+
+	// Start the main controller
+	let mainController = new MainController(appContext);
+	controllers.push(mainController);
+	extensionContext.subscriptions.push(mainController);
+	activations.push(mainController.activate());
+
+	return Promise.all(activations)
+		.then((results: boolean[]) => {
+			for (let result of results) {
+				if (!result) {
+					return false;
+				}
+			}
+			return true;
+		});
+}
+
+// this method is called when your extension is deactivated
+export function deactivate() {
+	for (let controller of controllers) {
+		controller.deactivate();
+	}
+}

extensions/azurecore/src/test/azureResource/tree/accountNotSignedInTreeNode.test.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.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as should from 'should';
+import * as vscode from 'vscode';
+import 'mocha';
+
+import { AzureResourceItemType } from '../../../azureResource/constants';
+import { AzureResourceAccountNotSignedInTreeNode } from '../../../azureResource/tree/accountNotSignedInTreeNode';
+
+describe('AzureResourceAccountNotSignedInTreeNode.info', function(): void {
+	it('Should be correct.', async function(): Promise<void> {
+		const label = 'Sign in to Azure ...';
+
+		const treeNode = new AzureResourceAccountNotSignedInTreeNode();
+
+		should(treeNode.nodePathValue).equal('message_accountNotSignedIn');
+
+		const treeItem = await treeNode.getTreeItem();
+		should(treeItem.label).equal(label);
+		should(treeItem.contextValue).equal(AzureResourceItemType.message);
+		should(treeItem.collapsibleState).equal(vscode.TreeItemCollapsibleState.None);
+		should(treeItem.command).not.undefined();
+		should(treeItem.command.title).equal(label);
+		should(treeItem.command.command).equal('azureresource.signin');
+
+		const nodeInfo = treeNode.getNodeInfo();
+		should(nodeInfo.isLeaf).true();
+		should(nodeInfo.label).equal(label);
+		should(nodeInfo.nodeType).equal(AzureResourceItemType.message);
+		should(nodeInfo.iconType).equal(AzureResourceItemType.message);
+	});
+});

extensions/azurecore/src/test/azureResource/tree/accountTreeNode.test.ts

@@ -0,0 +1,294 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as should from 'should';
+import * as TypeMoq from 'typemoq';
+import * as sqlops from 'sqlops';
+import * as vscode from 'vscode';
+import 'mocha';
+import { ServiceClientCredentials } from 'ms-rest';
+
+import { AzureResourceServicePool } from '../../../azureResource/servicePool';
+import {
+	IAzureResourceCacheService,
+	IAzureResourceContextService,
+	IAzureResourceCredentialService,
+	IAzureResourceSubscriptionService,
+	IAzureResourceSubscriptionFilterService
+} from '../../../azureResource/interfaces';
+import { IAzureResourceTreeChangeHandler } from '../../../azureResource/tree/treeChangeHandler';
+import { AzureResourceAccountTreeNode } from '../../../azureResource/tree/accountTreeNode';
+import { AzureResourceSubscription } from '../../../azureResource/models';
+import { AzureResourceSubscriptionTreeNode } from '../../../azureResource/tree/subscriptionTreeNode';
+import { AzureResourceItemType } from '../../../azureResource/constants';
+import { AzureResourceMessageTreeNode } from '../../../azureResource/tree/messageTreeNode';
+
+// Mock services
+const mockServicePool = AzureResourceServicePool.getInstance();
+
+let mockCacheService: TypeMoq.IMock<IAzureResourceCacheService>;
+let mockContextService: TypeMoq.IMock<IAzureResourceContextService>;
+let mockCredentialService: TypeMoq.IMock<IAzureResourceCredentialService>;
+let mockSubscriptionService: TypeMoq.IMock<IAzureResourceSubscriptionService>;
+let mockSubscriptionFilterService: TypeMoq.IMock<IAzureResourceSubscriptionFilterService>;
+
+let mockTreeChangeHandler: TypeMoq.IMock<IAzureResourceTreeChangeHandler>;
+
+// Mock test data
+const mockAccount: sqlops.Account = {
+	key: {
+		accountId: 'mock_account',
+		providerId: 'mock_provider'
+	},
+	displayInfo: {
+		displayName: 'mock_account@test.com',
+		accountType: 'Microsoft',
+		contextualDisplayName: 'test'
+	},
+	properties: undefined,
+	isStale: false
+};
+
+const mockCredential = TypeMoq.Mock.ofType<ServiceClientCredentials>().object;
+const mockCredentials = [mockCredential];
+
+const mockSubscription1: AzureResourceSubscription = {
+	id: 'mock_subscription_1',
+	name: 'mock subscription 1'
+};
+const mockSubscription2: AzureResourceSubscription = {
+	id: 'mock_subscription_2',
+	name: 'mock subscription 2'
+};
+const mockSubscriptions = [mockSubscription1, mockSubscription2];
+const mockFilteredSubscriptions = [mockSubscription1];
+
+let mockSubscriptionCache: { subscriptions: { [accountId: string]: AzureResourceSubscription[]} };
+
+describe('AzureResourceAccountTreeNode.info', function(): void {
+	beforeEach(() => {
+		mockContextService = TypeMoq.Mock.ofType<IAzureResourceContextService>();
+		mockCacheService = TypeMoq.Mock.ofType<IAzureResourceCacheService>();
+		mockCredentialService = TypeMoq.Mock.ofType<IAzureResourceCredentialService>();
+		mockSubscriptionService = TypeMoq.Mock.ofType<IAzureResourceSubscriptionService>();
+		mockSubscriptionFilterService = TypeMoq.Mock.ofType<IAzureResourceSubscriptionFilterService>();
+
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+
+		mockSubscriptionCache = { subscriptions: {} };
+
+		mockServicePool.contextService = mockContextService.object;
+		mockServicePool.cacheService = mockCacheService.object;
+		mockServicePool.credentialService = mockCredentialService.object;
+		mockServicePool.subscriptionService = mockSubscriptionService.object;
+		mockServicePool.subscriptionFilterService = mockSubscriptionFilterService.object;
+
+		mockCredentialService.setup((o) => o.getCredentials(mockAccount)).returns(() => Promise.resolve(mockCredentials));
+		mockCacheService.setup((o) => o.get(TypeMoq.It.isAnyString())).returns(() => mockSubscriptionCache);
+		mockCacheService.setup((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny())).returns(() => mockSubscriptionCache.subscriptions[mockAccount.key.accountId] = mockSubscriptions);
+	});
+
+	it('Should be correct when created.', async function(): Promise<void> {
+		const accountTreeNode = new AzureResourceAccountTreeNode(mockAccount, mockTreeChangeHandler.object);
+
+		const accountTreeNodeId = `account_${mockAccount.key.accountId}`;
+		const accountTreeNodeLabel = `${mockAccount.displayInfo.displayName} (${mockAccount.key.accountId})`;
+
+		should(accountTreeNode.nodePathValue).equal(accountTreeNodeId);
+
+		const treeItem = await accountTreeNode.getTreeItem();
+		should(treeItem.id).equal(accountTreeNodeId);
+		should(treeItem.label).equal(accountTreeNodeLabel);
+		should(treeItem.contextValue).equal(AzureResourceItemType.account);
+		should(treeItem.collapsibleState).equal(vscode.TreeItemCollapsibleState.Collapsed);
+
+		const nodeInfo = accountTreeNode.getNodeInfo();
+		should(nodeInfo.label).equal(accountTreeNodeLabel);
+		should(nodeInfo.isLeaf).false();
+		should(nodeInfo.nodeType).equal(AzureResourceItemType.account);
+		should(nodeInfo.iconType).equal(AzureResourceItemType.account);
+	});
+
+	it('Should be correct when there are subscriptions listed.', async function(): Promise<void> {
+		mockSubscriptionService.setup((o) => o.getSubscriptions(mockAccount, mockCredentials)).returns(() => Promise.resolve(mockSubscriptions));
+		mockSubscriptionFilterService.setup((o) => o.getSelectedSubscriptions(mockAccount)).returns(() => Promise.resolve(undefined));
+
+		const accountTreeNodeLabel = `${mockAccount.displayInfo.displayName} (${mockAccount.key.accountId}) (${mockSubscriptions.length} / ${mockSubscriptions.length} subscriptions)`;
+
+		const accountTreeNode = new AzureResourceAccountTreeNode(mockAccount, mockTreeChangeHandler.object);
+
+		await accountTreeNode.getChildren();
+
+		const treeItem = await accountTreeNode.getTreeItem();
+		should(treeItem.label).equal(accountTreeNodeLabel);
+
+		const nodeInfo = accountTreeNode.getNodeInfo();
+		should(nodeInfo.label).equal(accountTreeNodeLabel);
+	});
+
+	it('Should be correct when there are subscriptions filtered.', async function(): Promise<void> {
+		mockSubscriptionService.setup((o) => o.getSubscriptions(mockAccount, mockCredentials)).returns(() => Promise.resolve(mockSubscriptions));
+		mockSubscriptionFilterService.setup((o) => o.getSelectedSubscriptions(mockAccount)).returns(() => Promise.resolve(mockFilteredSubscriptions));
+
+		const accountTreeNodeLabel = `${mockAccount.displayInfo.displayName} (${mockAccount.key.accountId}) (${mockFilteredSubscriptions.length} / ${mockSubscriptions.length} subscriptions)`;
+
+		const accountTreeNode = new AzureResourceAccountTreeNode(mockAccount, mockTreeChangeHandler.object);
+
+		await accountTreeNode.getChildren();
+
+		const treeItem = await accountTreeNode.getTreeItem();
+		should(treeItem.label).equal(accountTreeNodeLabel);
+
+		const nodeInfo = accountTreeNode.getNodeInfo();
+		should(nodeInfo.label).equal(accountTreeNodeLabel);
+	});
+});
+
+describe('AzureResourceAccountTreeNode.getChildren', function(): void {
+	beforeEach(() => {
+		mockCacheService = TypeMoq.Mock.ofType<IAzureResourceCacheService>();
+		mockCredentialService = TypeMoq.Mock.ofType<IAzureResourceCredentialService>();
+		mockSubscriptionService = TypeMoq.Mock.ofType<IAzureResourceSubscriptionService>();
+		mockSubscriptionFilterService = TypeMoq.Mock.ofType<IAzureResourceSubscriptionFilterService>();
+
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+
+		mockSubscriptionCache = { subscriptions: {} };
+
+		mockServicePool.cacheService = mockCacheService.object;
+		mockServicePool.credentialService = mockCredentialService.object;
+		mockServicePool.subscriptionService = mockSubscriptionService.object;
+		mockServicePool.subscriptionFilterService = mockSubscriptionFilterService.object;
+
+		mockCredentialService.setup((o) => o.getCredentials(mockAccount)).returns(() => Promise.resolve(mockCredentials));
+		mockCacheService.setup((o) => o.get(TypeMoq.It.isAnyString())).returns(() => mockSubscriptionCache);
+		mockCacheService.setup((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny())).returns(() => mockSubscriptionCache.subscriptions[mockAccount.key.accountId] = mockSubscriptions);
+	});
+
+	it('Should load subscriptions from scratch and update cache when it is clearing cache.', async function(): Promise<void> {
+		mockSubscriptionService.setup((o) => o.getSubscriptions(mockAccount, mockCredentials)).returns(() => Promise.resolve(mockSubscriptions));
+		mockSubscriptionFilterService.setup((o) => o.getSelectedSubscriptions(mockAccount)).returns(() => Promise.resolve(undefined));
+
+		const accountTreeNode = new AzureResourceAccountTreeNode(mockAccount, mockTreeChangeHandler.object);
+
+		const children = await accountTreeNode.getChildren();
+
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockSubscriptionService.verify((o) => o.getSubscriptions(mockAccount, mockCredentials), TypeMoq.Times.once());
+		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
+		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.once());
+		mockSubscriptionFilterService.verify((o) => o.getSelectedSubscriptions(mockAccount), TypeMoq.Times.once());
+
+		mockTreeChangeHandler.verify((o) => o.notifyNodeChanged(accountTreeNode), TypeMoq.Times.once());
+
+		should(accountTreeNode.totalSubscriptionCount).equal(mockSubscriptions.length);
+		should(accountTreeNode.selectedSubscriptionCount).equal(mockSubscriptions.length);
+		should(accountTreeNode.isClearingCache).false();
+
+		should(children).Array();
+		should(children.length).equal(mockSubscriptions.length);
+
+		should(Object.keys(mockSubscriptionCache.subscriptions)).deepEqual([mockAccount.key.accountId]);
+		should(mockSubscriptionCache.subscriptions[mockAccount.key.accountId]).deepEqual(mockSubscriptions);
+
+		for (let ix = 0; ix < mockSubscriptions.length; ix++) {
+			const child = children[ix];
+			const subscription = mockSubscriptions[ix];
+
+			should(child).instanceof(AzureResourceSubscriptionTreeNode);
+			should(child.nodePathValue).equal(`subscription_${subscription.id}`);
+		}
+	});
+
+	it('Should load subscriptions from cache when it is not clearing cache.', async function(): Promise<void> {
+		mockSubscriptionService.setup((o) => o.getSubscriptions(mockAccount, mockCredentials)).returns(() => Promise.resolve(mockSubscriptions));
+		mockSubscriptionFilterService.setup((o) => o.getSelectedSubscriptions(mockAccount)).returns(() => Promise.resolve(undefined));
+
+		const accountTreeNode = new AzureResourceAccountTreeNode(mockAccount, mockTreeChangeHandler.object);
+
+		await accountTreeNode.getChildren();
+		const children = await accountTreeNode.getChildren();
+
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.exactly(1));
+		mockSubscriptionService.verify((o) => o.getSubscriptions(mockAccount, mockCredentials), TypeMoq.Times.exactly(1));
+		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.exactly(2));
+		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.exactly(1));
+
+		should(children.length).equal(mockSubscriptionCache.subscriptions[mockAccount.key.accountId].length);
+
+		for (let ix = 0; ix < mockSubscriptionCache.subscriptions[mockAccount.key.accountId].length; ix++) {
+			should(children[ix].nodePathValue).equal(`subscription_${mockSubscriptionCache.subscriptions[mockAccount.key.accountId][ix].id}`);
+		}
+	});
+
+	it('Should handle when there is no subscriptions.', async function(): Promise<void> {
+		mockSubscriptionService.setup((o) => o.getSubscriptions(mockAccount, mockCredentials)).returns(() => Promise.resolve(undefined));
+
+		const accountTreeNode = new AzureResourceAccountTreeNode(mockAccount, mockTreeChangeHandler.object);
+
+		const children = await accountTreeNode.getChildren();
+
+		should(accountTreeNode.totalSubscriptionCount).equal(0);
+
+		should(children).Array();
+		should(children.length).equal(1);
+		should(children[0]).instanceof(AzureResourceMessageTreeNode);
+		should(children[0].nodePathValue).startWith('message_');
+		should(children[0].getNodeInfo().label).equal('No Subscriptions found.');
+	});
+
+	it('Should honor subscription filtering.', async function(): Promise<void> {
+		mockSubscriptionService.setup((o) => o.getSubscriptions(mockAccount, mockCredentials)).returns(() => Promise.resolve(mockSubscriptions));
+		mockSubscriptionFilterService.setup((o) => o.getSelectedSubscriptions(mockAccount)).returns(() => Promise.resolve(mockFilteredSubscriptions));
+
+		const accountTreeNode = new AzureResourceAccountTreeNode(mockAccount, mockTreeChangeHandler.object);
+
+		const children = await accountTreeNode.getChildren();
+
+		mockSubscriptionFilterService.verify((o) => o.getSelectedSubscriptions(mockAccount), TypeMoq.Times.once());
+
+		should(accountTreeNode.selectedSubscriptionCount).equal(mockFilteredSubscriptions.length);
+		should(children.length).equal(mockFilteredSubscriptions.length);
+
+		for (let ix = 0; ix < mockFilteredSubscriptions.length; ix++) {
+			should(children[ix].nodePathValue).equal(`subscription_${mockFilteredSubscriptions[ix].id}`);
+		}
+	});
+
+	it('Should handle errors.', async function(): Promise<void> {
+		const mockError = 'Test error';
+		mockSubscriptionService.setup((o) => o.getSubscriptions(mockAccount, mockCredentials)).returns(() => { throw new Error(mockError); });
+
+		const accountTreeNode = new AzureResourceAccountTreeNode(mockAccount, mockTreeChangeHandler.object);
+
+		const children = await accountTreeNode.getChildren();
+
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockSubscriptionService.verify((o) => o.getSubscriptions(mockAccount, mockCredentials), TypeMoq.Times.once());
+		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.never());
+		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.never());
+		mockSubscriptionFilterService.verify((o) => o.getSelectedSubscriptions(mockAccount), TypeMoq.Times.never());
+
+		should(children).Array();
+		should(children.length).equal(1);
+		should(children[0]).instanceof(AzureResourceMessageTreeNode);
+		should(children[0].nodePathValue).startWith('message_');
+		should(children[0].getNodeInfo().label).equal(`Error: ${mockError}`);
+	});
+});
+
+describe('AzureResourceAccountTreeNode.clearCache', function() : void {
+	beforeEach(() => {
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+	});
+
+	it('Should clear cache.', async function(): Promise<void> {
+		const accountTreeNode = new AzureResourceAccountTreeNode(mockAccount, mockTreeChangeHandler.object);
+		accountTreeNode.clearCache();
+		should(accountTreeNode.isClearingCache).true();
+	});
+});

extensions/azurecore/src/test/azureResource/tree/databaseContainerTreeNode.test.ts

@@ -0,0 +1,219 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as should from 'should';
+import * as TypeMoq from 'typemoq';
+import * as sqlops from 'sqlops';
+import * as vscode from 'vscode';
+import 'mocha';
+import { ServiceClientCredentials } from 'ms-rest';
+
+import { AzureResourceServicePool } from '../../../azureResource/servicePool';
+import {
+	IAzureResourceCacheService,
+	IAzureResourceContextService,
+	IAzureResourceCredentialService,
+	IAzureResourceDatabaseService
+} from '../../../azureResource/interfaces';
+import { IAzureResourceTreeChangeHandler } from '../../../azureResource/tree/treeChangeHandler';
+import { AzureResourceSubscription, AzureResourceDatabase } from '../../../azureResource/models';
+import { AzureResourceItemType } from '../../../azureResource/constants';
+import { AzureResourceMessageTreeNode } from '../../../azureResource/tree/messageTreeNode';
+import { AzureResourceDatabaseContainerTreeNode } from '../../../azureResource/tree/databaseContainerTreeNode';
+import { AzureResourceDatabaseTreeNode } from '../../../azureResource/tree/databaseTreeNode';
+
+// Mock services
+const mockServicePool = AzureResourceServicePool.getInstance();
+
+let mockCacheService: TypeMoq.IMock<IAzureResourceCacheService>;
+let mockContextService: TypeMoq.IMock<IAzureResourceContextService>;
+let mockCredentialService: TypeMoq.IMock<IAzureResourceCredentialService>;
+let mockDatabaseService: TypeMoq.IMock<IAzureResourceDatabaseService>;
+
+let mockTreeChangeHandler: TypeMoq.IMock<IAzureResourceTreeChangeHandler>;
+
+// Mock test data
+const mockAccount: sqlops.Account = {
+	key: {
+		accountId: 'mock_account',
+		providerId: 'mock_provider'
+	},
+	displayInfo: {
+		displayName: 'mock_account@test.com',
+		accountType: 'Microsoft',
+		contextualDisplayName: 'test'
+	},
+	properties: undefined,
+	isStale: false
+};
+
+const mockCredential = TypeMoq.Mock.ofType<ServiceClientCredentials>().object;
+const mockCredentials = [mockCredential];
+
+const mockSubscription: AzureResourceSubscription = {
+	id: 'mock_subscription',
+	name: 'mock subscription'
+};
+
+const mockDatabase1: AzureResourceDatabase = {
+	name: 'mock database 1',
+	serverName: 'mock server 1',
+	serverFullName: 'mock server 1',
+	loginName: 'mock user 1'
+};
+const mockDatabase2: AzureResourceDatabase = {
+	name: 'mock database 2',
+	serverName: 'mock server 2',
+	serverFullName: 'mock server 2',
+	loginName: 'mock user 2'
+};
+const mockDatabases = [mockDatabase1, mockDatabase2];
+
+let mockDatabaseContainerCache: { databases: { [subscriptionId: string]: AzureResourceDatabase[] } };
+
+describe('AzureResourceDatabaseContainerTreeNode.info', function(): void {
+	beforeEach(() => {
+		mockContextService = TypeMoq.Mock.ofType<IAzureResourceContextService>();
+
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+
+		mockServicePool.contextService = mockContextService.object;
+	});
+
+	it('Should be correct when created.', async function(): Promise<void> {
+		const databaseContainerTreeNode = new AzureResourceDatabaseContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+
+		const databaseContainerTreeNodeLabel = 'SQL Databases';
+
+		should(databaseContainerTreeNode.nodePathValue).equal('databaseContainer');
+
+		const treeItem = await databaseContainerTreeNode.getTreeItem();
+		should(treeItem.label).equal(databaseContainerTreeNodeLabel);
+		should(treeItem.contextValue).equal(AzureResourceItemType.databaseContainer);
+		should(treeItem.collapsibleState).equal(vscode.TreeItemCollapsibleState.Collapsed);
+
+		const nodeInfo = databaseContainerTreeNode.getNodeInfo();
+		should(nodeInfo.isLeaf).false();
+		should(nodeInfo.label).equal(databaseContainerTreeNodeLabel);
+		should(nodeInfo.nodeType).equal(AzureResourceItemType.databaseContainer);
+		should(nodeInfo.iconType).equal(AzureResourceItemType.databaseContainer);
+	});
+});
+
+describe('AzureResourceDatabaseContainerTreeNode.getChildren', function(): void {
+	beforeEach(() => {
+		mockCacheService = TypeMoq.Mock.ofType<IAzureResourceCacheService>();
+		mockCredentialService = TypeMoq.Mock.ofType<IAzureResourceCredentialService>();
+		mockDatabaseService = TypeMoq.Mock.ofType<IAzureResourceDatabaseService>();
+
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+
+		mockDatabaseContainerCache = { databases: {} };
+
+		mockServicePool.cacheService = mockCacheService.object;
+		mockServicePool.credentialService = mockCredentialService.object;
+		mockServicePool.databaseService = mockDatabaseService.object;
+
+		mockCredentialService.setup((o) => o.getCredentials(mockAccount)).returns(() => Promise.resolve(mockCredentials));
+		mockCacheService.setup((o) => o.get(TypeMoq.It.isAnyString())).returns(() => mockDatabaseContainerCache);
+		mockCacheService.setup((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny())).returns(() => mockDatabaseContainerCache.databases[mockSubscription.id] = mockDatabases);
+	});
+
+	it('Should load databases from scratch and update cache when it is clearing cache.', async function(): Promise<void> {
+		mockDatabaseService.setup((o) => o.getDatabases(mockSubscription, mockCredentials)).returns(() => Promise.resolve(mockDatabases));
+
+		const databaseContainerTreeNode = new AzureResourceDatabaseContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+
+		const children = await databaseContainerTreeNode.getChildren();
+
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockDatabaseService.verify((o) => o.getDatabases(mockSubscription, mockCredentials), TypeMoq.Times.once());
+		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
+		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.once());
+
+		should(databaseContainerTreeNode.isClearingCache).false();
+
+		should(children).Array();
+		should(children.length).equal(mockDatabases.length);
+
+		should(Object.keys(mockDatabaseContainerCache.databases)).deepEqual([mockSubscription.id]);
+		should(mockDatabaseContainerCache.databases[mockSubscription.id]).deepEqual(mockDatabases);
+
+		for (let ix = 0; ix < mockDatabases.length; ix++) {
+			const child = children[ix];
+			const database = mockDatabases[ix];
+
+			should(child).instanceof(AzureResourceDatabaseTreeNode);
+			should(child.nodePathValue).equal(`database_${database.name}`);
+		}
+	});
+
+	it('Should load databases from cache when it is not clearing cache.', async function(): Promise<void> {
+		mockDatabaseService.setup((o) => o.getDatabases(mockSubscription, mockCredentials)).returns(() => Promise.resolve(mockDatabases));
+
+		const databaseContainerTreeNode = new AzureResourceDatabaseContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+
+		await databaseContainerTreeNode.getChildren();
+		const children = await databaseContainerTreeNode.getChildren();
+
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.exactly(1));
+		mockDatabaseService.verify((o) => o.getDatabases(mockSubscription, mockCredentials), TypeMoq.Times.exactly(1));
+		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.exactly(2));
+		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.exactly(1));
+
+		should(children.length).equal(mockDatabaseContainerCache.databases[mockSubscription.id].length);
+
+		for (let ix = 0; ix < mockDatabaseContainerCache.databases[mockSubscription.id].length; ix++) {
+			should(children[ix].nodePathValue).equal(`database_${mockDatabaseContainerCache.databases[mockSubscription.id][ix].name}`);
+		}
+	});
+
+	it('Should handle when there is no databases.', async function(): Promise<void> {
+		mockDatabaseService.setup((o) => o.getDatabases(mockSubscription, mockCredentials)).returns(() => Promise.resolve(undefined));
+
+		const databaseContainerTreeNode = new AzureResourceDatabaseContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+
+		const children = await databaseContainerTreeNode.getChildren();
+
+		should(children).Array();
+		should(children.length).equal(1);
+		should(children[0]).instanceof(AzureResourceMessageTreeNode);
+		should(children[0].nodePathValue).startWith('message_');
+		should(children[0].getNodeInfo().label).equal('No SQL Databases found.');
+	});
+
+	it('Should handle errors.', async function(): Promise<void> {
+		const mockError = 'Test error';
+		mockDatabaseService.setup((o) => o.getDatabases(mockSubscription, mockCredentials)).returns(() => { throw new Error(mockError); });
+
+		const databaseContainerTreeNode = new AzureResourceDatabaseContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+		const children = await databaseContainerTreeNode.getChildren();
+
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockDatabaseService.verify((o) => o.getDatabases(mockSubscription, mockCredentials), TypeMoq.Times.once());
+		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.never());
+		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.never());
+
+		should(children).Array();
+		should(children.length).equal(1);
+		should(children[0]).instanceof(AzureResourceMessageTreeNode);
+		should(children[0].nodePathValue).startWith('message_');
+		should(children[0].getNodeInfo().label).equal(`Error: ${mockError}`);
+	});
+});
+
+describe('AzureResourceDatabaseContainerTreeNode.clearCache', function() : void {
+	beforeEach(() => {
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+	});
+
+	it('Should clear cache.', async function(): Promise<void> {
+		const databaseContainerTreeNode = new AzureResourceDatabaseContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+		databaseContainerTreeNode.clearCache();
+		should(databaseContainerTreeNode.isClearingCache).true();
+	});
+});

extensions/azurecore/src/test/azureResource/tree/databaseServerContainerTreeNode.test.ts

@@ -0,0 +1,219 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as should from 'should';
+import * as TypeMoq from 'typemoq';
+import * as sqlops from 'sqlops';
+import * as vscode from 'vscode';
+import 'mocha';
+import { ServiceClientCredentials } from 'ms-rest';
+
+import { AzureResourceServicePool } from '../../../azureResource/servicePool';
+import {
+	IAzureResourceCacheService,
+	IAzureResourceContextService,
+	IAzureResourceCredentialService,
+	IAzureResourceDatabaseServerService
+} from '../../../azureResource/interfaces';
+import { IAzureResourceTreeChangeHandler } from '../../../azureResource/tree/treeChangeHandler';
+import { AzureResourceSubscription, AzureResourceDatabaseServer } from '../../../azureResource/models';
+import { AzureResourceItemType } from '../../../azureResource/constants';
+import { AzureResourceMessageTreeNode } from '../../../azureResource/tree/messageTreeNode';
+import { AzureResourceDatabaseServerContainerTreeNode } from '../../../azureResource/tree/databaseServerContainerTreeNode';
+import { AzureResourceDatabaseServerTreeNode } from '../../../azureResource/tree/databaseServerTreeNode';
+
+// Mock services
+const mockServicePool = AzureResourceServicePool.getInstance();
+
+let mockCacheService: TypeMoq.IMock<IAzureResourceCacheService>;
+let mockContextService: TypeMoq.IMock<IAzureResourceContextService>;
+let mockCredentialService: TypeMoq.IMock<IAzureResourceCredentialService>;
+let mockDatabaseServerService: TypeMoq.IMock<IAzureResourceDatabaseServerService>;
+
+let mockTreeChangeHandler: TypeMoq.IMock<IAzureResourceTreeChangeHandler>;
+
+// Mock test data
+const mockAccount: sqlops.Account = {
+	key: {
+		accountId: 'mock_account',
+		providerId: 'mock_provider'
+	},
+	displayInfo: {
+		displayName: 'mock_account@test.com',
+		accountType: 'Microsoft',
+		contextualDisplayName: 'test'
+	},
+	properties: undefined,
+	isStale: false
+};
+
+const mockCredential = TypeMoq.Mock.ofType<ServiceClientCredentials>().object;
+const mockCredentials = [mockCredential];
+
+const mockSubscription: AzureResourceSubscription = {
+	id: 'mock_subscription',
+	name: 'mock subscription'
+};
+
+const mockDatabaseServer1: AzureResourceDatabaseServer = {
+	name: 'mock server 1',
+	fullName: 'mock server 1',
+	loginName: 'mock user 1',
+	defaultDatabaseName: 'master'
+};
+const mockDatabaseServer2: AzureResourceDatabaseServer = {
+	name: 'mock server 2',
+	fullName: 'mock server 2',
+	loginName: 'mock user 2',
+	defaultDatabaseName: 'master'
+};
+const mockDatabaseServers = [mockDatabaseServer1, mockDatabaseServer2];
+
+let mockDatabaseServerContainerCache: { databaseServers: { [subscriptionId: string]: AzureResourceDatabaseServer[] } };
+
+describe('AzureResourceDatabaseServerContainerTreeNode.info', function(): void {
+	beforeEach(() => {
+		mockContextService = TypeMoq.Mock.ofType<IAzureResourceContextService>();
+
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+
+		mockServicePool.contextService = mockContextService.object;
+	});
+
+	it('Should be correct when created.', async function(): Promise<void> {
+		const databaseServerContainerTreeNode = new AzureResourceDatabaseServerContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+
+		const databaseServerContainerTreeNodeLabel = 'SQL Servers';
+
+		should(databaseServerContainerTreeNode.nodePathValue).equal('databaseServerContainer');
+
+		const treeItem = await databaseServerContainerTreeNode.getTreeItem();
+		should(treeItem.label).equal(databaseServerContainerTreeNodeLabel);
+		should(treeItem.contextValue).equal(AzureResourceItemType.databaseServerContainer);
+		should(treeItem.collapsibleState).equal(vscode.TreeItemCollapsibleState.Collapsed);
+
+		const nodeInfo = databaseServerContainerTreeNode.getNodeInfo();
+		should(nodeInfo.isLeaf).false();
+		should(nodeInfo.label).equal(databaseServerContainerTreeNodeLabel);
+		should(nodeInfo.nodeType).equal(AzureResourceItemType.databaseServerContainer);
+		should(nodeInfo.iconType).equal(AzureResourceItemType.databaseServerContainer);
+	});
+});
+
+describe('AzureResourceDatabaseServerContainerTreeNode.getChildren', function(): void {
+	beforeEach(() => {
+		mockCacheService = TypeMoq.Mock.ofType<IAzureResourceCacheService>();
+		mockCredentialService = TypeMoq.Mock.ofType<IAzureResourceCredentialService>();
+		mockDatabaseServerService = TypeMoq.Mock.ofType<IAzureResourceDatabaseServerService>();
+
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+
+		mockDatabaseServerContainerCache = { databaseServers: {} };
+
+		mockServicePool.cacheService = mockCacheService.object;
+		mockServicePool.credentialService = mockCredentialService.object;
+		mockServicePool.databaseServerService = mockDatabaseServerService.object;
+
+		mockCredentialService.setup((o) => o.getCredentials(mockAccount)).returns(() => Promise.resolve(mockCredentials));
+		mockCacheService.setup((o) => o.get(TypeMoq.It.isAnyString())).returns(() => mockDatabaseServerContainerCache);
+		mockCacheService.setup((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny())).returns(() => mockDatabaseServerContainerCache.databaseServers[mockSubscription.id] = mockDatabaseServers);
+	});
+
+	it('Should load database servers from scratch and update cache when it is clearing cache.', async function(): Promise<void> {
+		mockDatabaseServerService.setup((o) => o.getDatabaseServers(mockSubscription, mockCredentials)).returns(() => Promise.resolve(mockDatabaseServers));
+
+		const databaseServerContainerTreeNode = new AzureResourceDatabaseServerContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+
+		const children = await databaseServerContainerTreeNode.getChildren();
+
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockDatabaseServerService.verify((o) => o.getDatabaseServers(mockSubscription, mockCredentials), TypeMoq.Times.once());
+		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
+		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.once());
+
+		should(databaseServerContainerTreeNode.isClearingCache).false();
+
+		should(children).Array();
+		should(children.length).equal(mockDatabaseServers.length);
+
+		should(Object.keys(mockDatabaseServerContainerCache.databaseServers)).deepEqual([mockSubscription.id]);
+		should(mockDatabaseServerContainerCache.databaseServers[mockSubscription.id]).deepEqual(mockDatabaseServers);
+
+		for (let ix = 0; ix < mockDatabaseServers.length; ix++) {
+			const child = children[ix];
+			const databaseServer = mockDatabaseServers[ix];
+
+			should(child).instanceof(AzureResourceDatabaseServerTreeNode);
+			should(child.nodePathValue).equal(`databaseServer_${databaseServer.name}`);
+		}
+	});
+
+	it('Should load database servers from cache when it is not clearing cache.', async function(): Promise<void> {
+		mockDatabaseServerService.setup((o) => o.getDatabaseServers(mockSubscription, mockCredentials)).returns(() => Promise.resolve(mockDatabaseServers));
+
+		const databaseServerContainerTreeNode = new AzureResourceDatabaseServerContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+
+		await databaseServerContainerTreeNode.getChildren();
+		const children = await databaseServerContainerTreeNode.getChildren();
+
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.exactly(1));
+		mockDatabaseServerService.verify((o) => o.getDatabaseServers(mockSubscription, mockCredentials), TypeMoq.Times.exactly(1));
+		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.exactly(2));
+		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.exactly(1));
+
+		should(children.length).equal(mockDatabaseServerContainerCache.databaseServers[mockSubscription.id].length);
+
+		for (let ix = 0; ix < mockDatabaseServerContainerCache.databaseServers[mockSubscription.id].length; ix++) {
+			should(children[ix].nodePathValue).equal(`databaseServer_${mockDatabaseServerContainerCache.databaseServers[mockSubscription.id][ix].name}`);
+		}
+	});
+
+	it('Should handle when there is no database servers.', async function(): Promise<void> {
+		mockDatabaseServerService.setup((o) => o.getDatabaseServers(mockSubscription, mockCredentials)).returns(() => Promise.resolve(undefined));
+
+		const databaseContainerTreeNode = new AzureResourceDatabaseServerContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+
+		const children = await databaseContainerTreeNode.getChildren();
+
+		should(children).Array();
+		should(children.length).equal(1);
+		should(children[0]).instanceof(AzureResourceMessageTreeNode);
+		should(children[0].nodePathValue).startWith('message_');
+		should(children[0].getNodeInfo().label).equal('No SQL Servers found.');
+	});
+
+	it('Should handle errors.', async function(): Promise<void> {
+		const mockError = 'Test error';
+		mockDatabaseServerService.setup((o) => o.getDatabaseServers(mockSubscription, mockCredentials)).returns(() => { throw new Error(mockError); });
+
+		const databaseServerContainerTreeNode = new AzureResourceDatabaseServerContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+		const children = await databaseServerContainerTreeNode.getChildren();
+
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockDatabaseServerService.verify((o) => o.getDatabaseServers(mockSubscription, mockCredentials), TypeMoq.Times.once());
+		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.never());
+		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.never());
+
+		should(children).Array();
+		should(children.length).equal(1);
+		should(children[0]).instanceof(AzureResourceMessageTreeNode);
+		should(children[0].nodePathValue).startWith('message_');
+		should(children[0].getNodeInfo().label).equal(`Error: ${mockError}`);
+	});
+});
+
+describe('AzureResourceDatabaseServerContainerTreeNode.clearCache', function() : void {
+	beforeEach(() => {
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+	});
+
+	it('Should clear cache.', async function(): Promise<void> {
+		const databaseServerContainerTreeNode = new AzureResourceDatabaseServerContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+		databaseServerContainerTreeNode.clearCache();
+		should(databaseServerContainerTreeNode.isClearingCache).true();
+	});
+});

extensions/azurecore/src/test/azureResource/tree/databaseServerTreeNode.test.ts

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as should from 'should';
+import * as TypeMoq from 'typemoq';
+import * as vscode from 'vscode';
+import 'mocha';
+
+import { AzureResourceServicePool } from '../../../azureResource/servicePool';
+import { IAzureResourceContextService } from '../../../azureResource/interfaces';
+import { IAzureResourceTreeChangeHandler } from '../../../azureResource/tree/treeChangeHandler';
+import { AzureResourceDatabaseServer } from '../../../azureResource/models';
+import { AzureResourceItemType } from '../../../azureResource/constants';
+import { AzureResourceDatabaseServerTreeNode } from '../../../azureResource/tree/databaseServerTreeNode';
+
+// Mock services
+const mockServicePool = AzureResourceServicePool.getInstance();
+
+let mockContextService: TypeMoq.IMock<IAzureResourceContextService>;
+
+let mockTreeChangeHandler: TypeMoq.IMock<IAzureResourceTreeChangeHandler>;
+
+// Mock test data
+const mockDatabaseServer: AzureResourceDatabaseServer = {
+	name: 'mock database 1',
+	fullName: 'mock server 1',
+	loginName: 'mock user 1',
+	defaultDatabaseName: 'master'
+};
+
+describe('AzureResourceDatabaseServerTreeNode.info', function(): void {
+	beforeEach(() => {
+		mockContextService = TypeMoq.Mock.ofType<IAzureResourceContextService>();
+
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+
+		mockServicePool.contextService = mockContextService.object;
+	});
+
+	it('Should be correct when created.', async function(): Promise<void> {
+		const databaseServerTreeNode = new AzureResourceDatabaseServerTreeNode(mockDatabaseServer, mockTreeChangeHandler.object, undefined);
+
+		const databaseServerTreeNodeLabel = mockDatabaseServer.name;
+
+		should(databaseServerTreeNode.nodePathValue).equal(`databaseServer_${mockDatabaseServer.name}`);
+
+		const treeItem = await databaseServerTreeNode.getTreeItem();
+		should(treeItem.label).equal(databaseServerTreeNodeLabel);
+		should(treeItem.contextValue).equal(AzureResourceItemType.databaseServer);
+		should(treeItem.collapsibleState).equal(vscode.TreeItemCollapsibleState.None);
+
+		const nodeInfo = databaseServerTreeNode.getNodeInfo();
+		should(nodeInfo.isLeaf).true();
+		should(nodeInfo.label).equal(databaseServerTreeNodeLabel);
+		should(nodeInfo.nodeType).equal(AzureResourceItemType.databaseServer);
+		should(nodeInfo.iconType).equal(AzureResourceItemType.databaseServer);
+	});
+});

extensions/azurecore/src/test/azureResource/tree/databaseTreeNode.test.ts

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as should from 'should';
+import * as TypeMoq from 'typemoq';
+import * as vscode from 'vscode';
+import 'mocha';
+
+import { AzureResourceServicePool } from '../../../azureResource/servicePool';
+import { IAzureResourceContextService } from '../../../azureResource/interfaces';
+import { IAzureResourceTreeChangeHandler } from '../../../azureResource/tree/treeChangeHandler';
+import { AzureResourceDatabase } from '../../../azureResource/models';
+import { AzureResourceItemType } from '../../../azureResource/constants';
+import { AzureResourceDatabaseTreeNode } from '../../../azureResource/tree/databaseTreeNode';
+
+// Mock services
+const mockServicePool = AzureResourceServicePool.getInstance();
+
+let mockContextService: TypeMoq.IMock<IAzureResourceContextService>;
+
+let mockTreeChangeHandler: TypeMoq.IMock<IAzureResourceTreeChangeHandler>;
+
+// Mock test data
+const mockDatabase: AzureResourceDatabase = {
+	name: 'mock database 1',
+	serverName: 'mock server 1',
+	serverFullName: 'mock server 1',
+	loginName: 'mock user 1'
+};
+
+describe('AzureResourceDatabaseTreeNode.info', function(): void {
+	beforeEach(() => {
+		mockContextService = TypeMoq.Mock.ofType<IAzureResourceContextService>();
+
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+
+		mockServicePool.contextService = mockContextService.object;
+	});
+
+	it('Should be correct.', async function(): Promise<void> {
+		const databaseTreeNode = new AzureResourceDatabaseTreeNode(mockDatabase, mockTreeChangeHandler.object, undefined);
+
+		const databaseTreeNodeLabel = `${mockDatabase.name} (${mockDatabase.serverName})`;
+
+		should(databaseTreeNode.nodePathValue).equal(`database_${mockDatabase.name}`);
+
+		const treeItem = await databaseTreeNode.getTreeItem();
+		should(treeItem.label).equal(databaseTreeNodeLabel);
+		should(treeItem.contextValue).equal(AzureResourceItemType.database);
+		should(treeItem.collapsibleState).equal(vscode.TreeItemCollapsibleState.None);
+
+		const nodeInfo = databaseTreeNode.getNodeInfo();
+		should(nodeInfo.isLeaf).true();
+		should(nodeInfo.label).equal(databaseTreeNodeLabel);
+		should(nodeInfo.nodeType).equal(AzureResourceItemType.database);
+		should(nodeInfo.iconType).equal(AzureResourceItemType.database);
+	});
+});

extensions/azurecore/src/test/azureResource/tree/messageTreeNode.test.ts

@@ -0,0 +1,41 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as should from 'should';
+import * as vscode from 'vscode';
+import 'mocha';
+
+import { AzureResourceItemType } from '../../../azureResource/constants';
+import { AzureResourceMessageTreeNode } from '../../../azureResource/tree/messageTreeNode';
+
+describe('AzureResourceMessageTreeNode.info', function(): void {
+	it('Should be correct when created.', async function(): Promise<void> {
+		const mockMessage = 'Test messagse';
+		const treeNode = new AzureResourceMessageTreeNode(mockMessage, undefined);
+
+		should(treeNode.nodePathValue).startWith('message_');
+
+		const treeItem = await treeNode.getTreeItem();
+		should(treeItem.label).equal(mockMessage);
+		should(treeItem.contextValue).equal(AzureResourceItemType.message);
+		should(treeItem.collapsibleState).equal(vscode.TreeItemCollapsibleState.None);
+
+		const nodeInfo = treeNode.getNodeInfo();
+		should(nodeInfo.isLeaf).true();
+		should(nodeInfo.label).equal(mockMessage);
+		should(nodeInfo.nodeType).equal(AzureResourceItemType.message);
+		should(nodeInfo.iconType).equal(AzureResourceItemType.message);
+	});
+});
+
+describe('AzureResourceMessageTreeNode.create', function(): void {
+	it('Should create a message node.', async function(): Promise<void> {
+		const mockMessage = 'Test messagse';
+		const treeNode = AzureResourceMessageTreeNode.create(mockMessage, undefined);
+		should(treeNode).instanceof(AzureResourceMessageTreeNode);
+	});
+});

extensions/azurecore/src/test/azureResource/tree/subscriptionTreeNode.test.ts

@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as should from 'should';
+import * as TypeMoq from 'typemoq';
+import * as sqlops from 'sqlops';
+import * as vscode from 'vscode';
+import 'mocha';
+
+import { AzureResourceServicePool } from '../../../azureResource/servicePool';
+import { IAzureResourceContextService } from '../../../azureResource/interfaces';
+import { IAzureResourceTreeChangeHandler } from '../../../azureResource/tree/treeChangeHandler';
+import { AzureResourceSubscription } from '../../../azureResource/models';
+import { AzureResourceSubscriptionTreeNode } from '../../../azureResource/tree/subscriptionTreeNode';
+import { AzureResourceDatabaseContainerTreeNode } from '../../../azureResource/tree/databaseContainerTreeNode';
+import { AzureResourceDatabaseServerContainerTreeNode } from '../../../azureResource/tree/databaseServerContainerTreeNode';
+import { AzureResourceItemType } from '../../../azureResource/constants';
+
+// Mock services
+const mockServicePool = AzureResourceServicePool.getInstance();
+
+let mockContextService: TypeMoq.IMock<IAzureResourceContextService>;
+
+let mockTreeChangeHandler: TypeMoq.IMock<IAzureResourceTreeChangeHandler>;
+
+// Mock test data
+const mockAccount: sqlops.Account = {
+	key: {
+		accountId: 'mock_account',
+		providerId: 'mock_provider'
+	},
+	displayInfo: {
+		displayName: 'mock_account@test.com',
+		accountType: 'Microsoft',
+		contextualDisplayName: 'test'
+	},
+	properties: undefined,
+	isStale: false
+};
+
+const mockSubscription: AzureResourceSubscription = {
+	id: 'mock_subscription',
+	name: 'mock subscription'
+};
+
+describe('AzureResourceSubscriptionTreeNode.info', function(): void {
+	beforeEach(() => {
+		mockContextService = TypeMoq.Mock.ofType<IAzureResourceContextService>();
+
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+
+		mockServicePool.contextService = mockContextService.object;
+	});
+
+	it('Should be correct when created.', async function(): Promise<void> {
+		const subscriptionTreeNode = new AzureResourceSubscriptionTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+
+		should(subscriptionTreeNode.nodePathValue).equal(`subscription_${mockSubscription.id}`);
+
+		const treeItem = await subscriptionTreeNode.getTreeItem();
+		should(treeItem.label).equal(mockSubscription.name);
+		should(treeItem.collapsibleState).equal(vscode.TreeItemCollapsibleState.Collapsed);
+		should(treeItem.contextValue).equal(AzureResourceItemType.subscription);
+
+		const nodeInfo = subscriptionTreeNode.getNodeInfo();
+		should(nodeInfo.label).equal(mockSubscription.name);
+		should(nodeInfo.isLeaf).equal(false);
+		should(nodeInfo.nodeType).equal(AzureResourceItemType.subscription);
+		should(nodeInfo.iconType).equal(AzureResourceItemType.subscription);
+	});
+});
+
+describe('AzureResourceSubscriptionTreeNode.getChildren', function(): void {
+	beforeEach(() => {
+		mockTreeChangeHandler = TypeMoq.Mock.ofType<IAzureResourceTreeChangeHandler>();
+	});
+
+	it('Should load database containers.', async function(): Promise<void> {
+		const subscriptionTreeNode = new AzureResourceSubscriptionTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
+		const children = await subscriptionTreeNode.getChildren();
+
+		should(children).Array();
+		should(children.length).equal(2);
+		should(children[0]).instanceof(AzureResourceDatabaseContainerTreeNode);
+		should(children[1]).instanceof(AzureResourceDatabaseServerContainerTreeNode);
+	});
+});

extensions/azurecore/src/test/azureResource/tree/treeProvider.test.ts

@@ -0,0 +1,113 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as should from 'should';
+import * as TypeMoq from 'typemoq';
+import * as sqlops from 'sqlops';
+import 'mocha';
+
+import { AzureResourceServicePool } from '../../../azureResource/servicePool';
+import { IAzureResourceAccountService } from '../../../azureResource/interfaces';
+import { AzureResourceTreeProvider } from '../../../azureResource/tree/treeProvider';
+import { AzureResourceAccountTreeNode } from '../../../azureResource/tree/accountTreeNode';
+import { AzureResourceAccountNotSignedInTreeNode } from '../../../azureResource/tree/accountNotSignedInTreeNode';
+import { AzureResourceMessageTreeNode } from '../../../azureResource/tree/messageTreeNode';
+
+// Mock services
+const mockServicePool = AzureResourceServicePool.getInstance();
+
+let mockAccountService: TypeMoq.IMock<IAzureResourceAccountService>;
+
+// Mock test data
+const mockAccount1: sqlops.Account = {
+	key: {
+		accountId: 'mock_account_1',
+		providerId: 'mock_provider'
+	},
+	displayInfo: {
+		displayName: 'mock_account_1@test.com',
+		accountType: 'Microsoft',
+		contextualDisplayName: 'test'
+	},
+	properties: undefined,
+	isStale: false
+};
+const mockAccount2: sqlops.Account = {
+	key: {
+		accountId: 'mock_account_2',
+		providerId: 'mock_provider'
+	},
+	displayInfo: {
+		displayName: 'mock_account_2@test.com',
+		accountType: 'Microsoft',
+		contextualDisplayName: 'test'
+	},
+	properties: undefined,
+	isStale: false
+};
+const mockAccounts = [mockAccount1, mockAccount2];
+
+describe('AzureResourceTreeProvider.getChildren', function(): void {
+	beforeEach(() => {
+		mockAccountService = TypeMoq.Mock.ofType<IAzureResourceAccountService>();
+
+		mockServicePool.accountService = mockAccountService.object;
+	});
+
+	it('Should load accounts.', async function(): Promise<void> {
+		mockAccountService.setup((o) => o.getAccounts()).returns(() => Promise.resolve(mockAccounts));
+
+		const treeProvider = new AzureResourceTreeProvider();
+		treeProvider.isSystemInitialized = true;
+
+		const children = await treeProvider.getChildren(undefined);
+
+		mockAccountService.verify((o) => o.getAccounts(), TypeMoq.Times.once());
+
+		should(children).Array();
+		should(children.length).equal(mockAccounts.length);
+
+		for (let ix = 0; ix < mockAccounts.length; ix++) {
+			const child = children[ix];
+			const account = mockAccounts[ix];
+
+			should(child).instanceof(AzureResourceAccountTreeNode);
+			should(child.nodePathValue).equal(`account_${account.key.accountId}`);
+		}
+	});
+
+	it('Should handle when there is no accounts.', async function(): Promise<void> {
+		mockAccountService.setup((o) => o.getAccounts()).returns(() => Promise.resolve(undefined));
+
+		const treeProvider = new AzureResourceTreeProvider();
+		treeProvider.isSystemInitialized = true;
+
+		const children = await treeProvider.getChildren(undefined);
+
+		should(children).Array();
+		should(children.length).equal(1);
+		should(children[0]).instanceof(AzureResourceAccountNotSignedInTreeNode);
+	});
+
+	it('Should handle errors.', async function(): Promise<void> {
+		const mockAccountError = 'Test account error';
+		mockAccountService.setup((o) => o.getAccounts()).returns(() => { throw new Error(mockAccountError); });
+
+		const treeProvider = new AzureResourceTreeProvider();
+		treeProvider.isSystemInitialized = true;
+
+		const children = await treeProvider.getChildren(undefined);
+
+		mockAccountService.verify((o) => o.getAccounts(), TypeMoq.Times.once());
+
+		should(children).Array();
+		should(children.length).equal(1);
+		should(children[0]).instanceof(AzureResourceMessageTreeNode);
+		should(children[0].nodePathValue).startWith('message_');
+		should(children[0].getNodeInfo().label).equal(`Error: ${mockAccountError}`);
+	});
+});

extensions/azurecore/src/test/index.ts

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const path = require('path');
+const testRunner = require('vscode/lib/testrunner');
+
+const suite = 'Integration Azure Tests';
+
+const options: any = {
+	ui: 'bdd',
+	useColors: true,
+	timeout: 60000
+};
+
+if (process.env.BUILD_ARTIFACTSTAGINGDIRECTORY) {
+	options.reporter = 'mocha-multi-reporters';
+	options.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(options);
+
+export = testRunner;

extensions/azurecore/src/treeNodes.ts

@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as sqlops from 'sqlops';
+import * as vscode from 'vscode';
+
+type TreeNodePredicate = (node: TreeNode) => boolean;
+
+export abstract class TreeNode {
+	private _parent: TreeNode = undefined;
+
+	public get parent(): TreeNode {
+		return this._parent;
+	}
+
+	public set parent(node: TreeNode) {
+		this._parent = node;
+	}
+
+	public generateNodePath(): string {
+		let path = undefined;
+		if (this.parent) {
+			path = this.parent.generateNodePath();
+		}
+		path = path ? `${path}/${this.nodePathValue}` : this.nodePathValue;
+		return path;
+	}
+
+	public findNodeByPath(path: string, expandIfNeeded: boolean = false): Promise<TreeNode> {
+		let condition: TreeNodePredicate = (node: TreeNode) => node.getNodeInfo().nodePath === path;
+		let filter: TreeNodePredicate = (node: TreeNode) => path.startsWith(node.getNodeInfo().nodePath);
+		return TreeNode.findNode(this, condition, filter, true);
+	}
+
+	public static async findNode(node: TreeNode, condition: TreeNodePredicate, filter: TreeNodePredicate, expandIfNeeded: boolean): Promise<TreeNode> {
+		if (!node) {
+			return undefined;
+		}
+
+		if (condition(node)) {
+			return node;
+		}
+
+		let nodeInfo = node.getNodeInfo();
+		if (nodeInfo.isLeaf) {
+			return undefined;
+		}
+
+		// TODO support filtering by already expanded / not yet expanded
+		let children = await node.getChildren(false);
+		if (children) {
+			for (let child of children) {
+				if (filter && filter(child)) {
+					let childNode =  await this.findNode(child, condition, filter, expandIfNeeded);
+					if (childNode) {
+						return childNode;
+					}
+				}
+			}
+		}
+		return undefined;
+	}
+
+	/**
+	 * The value to use for this node in the node path
+	 */
+	public abstract get nodePathValue(): string;
+
+	abstract getChildren(refreshChildren: boolean): TreeNode[] | Promise<TreeNode[]>;
+	abstract getTreeItem(): vscode.TreeItem | Promise<vscode.TreeItem>;
+
+	abstract getNodeInfo(): sqlops.NodeInfo;
+}

extensions/azurecore/src/typings/ref.d.ts

@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path='../../../../src/vs/vscode.d.ts'/>
+/// <reference path='../../../../src/sql/sqlops.d.ts'/>
+/// <reference path='../../../../src/sql/sqlops.proposed.d.ts'/>
+/// <reference types='@types/node'/>