Inital platform relayering (#6385)

* moving test files and inital refactoring

* relayer extension host code

* fix imports

* make insights work

* relayer dashboard

* relayer notebooks

* moveing more code around

* formatting

* accept angular as browser

* fix serializer

* add missing files

* remove declarations from extensions

* fix build errors

* more relayering

* change urls to relative to help code relayering

* remove layering to prep for merge

* fix hygiene errors

* fix hygiene errors

* fix tests

src/sql/workbench/test/electron-browser/api/extHostDataProtocol.test.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.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { Mock } from 'typemoq';
+import * as azdata from 'azdata';
+import { ExtHostDataProtocol } from 'sql/workbench/api/common/extHostDataProtocol';
+import { DataProviderType } from 'sql/workbench/api/common/sqlExtHostTypes';
+
+suite('ExtHostDataProtocol', () => {
+
+	let extHostDataProtocol: ExtHostDataProtocol;
+
+	setup(() => {
+		extHostDataProtocol = new ExtHostDataProtocol({
+			getProxy: identifier => {
+				return {
+					$registerMetadataProvider: (providerId, handle) => Promise.resolve(),
+					$registerConnectionProvider: (providerId, handle) => Promise.resolve()
+				} as any;
+			}
+		} as any);
+	});
+
+	test('Providers are exposed to other extensions', () => {
+		let extension1Id = 'provider1';
+		let extension1MetadataMock = Mock.ofInstance({
+			getMetadata: () => undefined,
+			getDatabases: () => undefined,
+			getTableInfo: () => undefined,
+			getViewInfo: () => undefined,
+			providerId: extension1Id
+		} as azdata.MetadataProvider);
+
+		let extension2Id = 'provider2';
+		let extension2MetadataMock = Mock.ofInstance({
+			getMetadata: () => undefined,
+			getDatabases: () => undefined,
+			getTableInfo: () => undefined,
+			getViewInfo: () => undefined,
+			providerId: extension2Id
+		} as azdata.MetadataProvider);
+
+		// If I register both providers and then get them using the getProvider API
+		extHostDataProtocol.$registerMetadataProvider(extension1MetadataMock.object);
+		extHostDataProtocol.$registerMetadataProvider(extension2MetadataMock.object);
+		extHostDataProtocol.$registerConnectionProvider({} as azdata.ConnectionProvider);
+		let retrievedProvider1 = extHostDataProtocol.getProvider<azdata.MetadataProvider>(extension1Id, DataProviderType.MetadataProvider);
+		let retrievedProvider2 = extHostDataProtocol.getProvider<azdata.MetadataProvider>(extension2Id, DataProviderType.MetadataProvider);
+		let allProviders = extHostDataProtocol.getProvidersByType<azdata.MetadataProvider>(DataProviderType.MetadataProvider);
+
+		// Then each provider was retrieved successfully
+		assert.equal(retrievedProvider1, extension1MetadataMock.object, 'Expected metadata provider was not retrieved for extension 1');
+		assert.equal(retrievedProvider2, extension2MetadataMock.object, 'Expected metadata provider was not retrieved for extension 2');
+		assert.equal(allProviders.length, 2, 'All metadata providers had unexpected length');
+		assert.equal(allProviders.some(provider => provider === extension1MetadataMock.object), true, 'All metadata providers did not include extension 1 metadata provider');
+		assert.equal(allProviders.some(provider => provider === extension2MetadataMock.object), true, 'All metadata providers did not include extension 2 metadata provider');
+	});
+});