Support Notebook integration testing by adding APIs & fixing others (#3848)

- Added `runCell` API. Updated runCell button to listen to events on the model so it'll reflect run cell when called from other sources
- Plumbed through kernelspec info to the extension side so when changed, it's updated
- Fixed bug in ConnectionProfile where it didn't copy from options but instead overrode with empty wrapper functions

Here's the rough test code (it's in the sql-vnext extension and will be out in a separate PR)
```ts

    it('Should connect to local notebook server with result 2', async function() {
        this.timeout(60000);
        let pythonNotebook = Object.assign({}, expectedNotebookContent, { metadata: { kernelspec: { name: "python3", display_name: "Python 3" }}});
        let uri = writeNotebookToFile(pythonNotebook);
        await ensureJupyterInstalled();

        let notebook = await sqlops.nb.showNotebookDocument(uri);
        should(notebook.document.cells).have.length(1);
        let ran = await notebook.runCell(notebook.document.cells[0]);
        should(ran).be.true('Notebook runCell failed');
        let cellOutputs = notebook.document.cells[0].contents.outputs;
        should(cellOutputs).have.length(1);
        let result = (<sqlops.nb.IExecuteResult>cellOutputs[0]).data['text/plain'];
        should(result).equal('2');

        try {
            // TODO support closing the editor. Right now this prompts and there's no override for this. Need to fix in core
            // Close the editor using the recommended vscode API
            //await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
        }
        catch (e) {}
    });

    it('Should connect to remote spark server with result 2', async function() {
        this.timeout(240000);
        let uri = writeNotebookToFile(expectedNotebookContent);
        await ensureJupyterInstalled();

        // Given a connection to a server exists
        let connectionId = await connectToSparkIntegrationServer();

        // When I open a Spark notebook and run the cell
        let notebook = await sqlops.nb.showNotebookDocument(uri, {
            connectionId: connectionId
        });
        should(notebook.document.cells).have.length(1);
        let ran = await notebook.runCell(notebook.document.cells[0]);
        should(ran).be.true('Notebook runCell failed');

        // Then I expect to get the output result of 1+1, executed remotely against the Spark endpoint
        let cellOutputs = notebook.document.cells[0].contents.outputs;
        should(cellOutputs).have.length(4);
        let sparkResult = (<sqlops.nb.IStreamResult>cellOutputs[3]).text;
        should(sparkResult).equal('2');

        try {
            // TODO support closing the editor. Right now this prompts and there's no override for this. Need to fix in core
            // Close the editor using the recommended vscode API
            //await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
        }
        catch (e) {}
    });
});
```

src/sql/parts/notebook/models/clientSession.ts

@@ -20,6 +20,7 @@ import * as notebookUtils from '../notebookUtils';
 import { INotebookManager } from 'sql/workbench/services/notebook/common/notebookService';
 import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
 
+type KernelChangeHandler = (kernel: nb.IKernelChangedArgs) => Promise<void>;
 /**
  * Implementation of a client session. This is a model over session operations,
  * which may come from the session manager or a specific session.
@@ -41,6 +42,9 @@ export class ClientSession implements IClientSession {
 	private _kernelPreference: IKernelPreference;
 	private _kernelDisplayName: string;
 	private _errorMessage: string;
+	private _cachedKernelSpec: nb.IKernelSpec;
+	private _kernelChangeHandlers: KernelChangeHandler[] = [];
+
 	//#endregion
 
 	private _serverLoadFinished: Promise<void>;
@@ -62,6 +66,7 @@ export class ClientSession implements IClientSession {
 			this._serverLoadFinished = this.startServer();
 			await this._serverLoadFinished;
 			await this.initializeSession();
+			await this.updateCachedKernelSpec();
 		} catch (err) {
 			this._errorMessage = notebookUtils.getErrorMessage(err);
 		}
@@ -150,6 +155,12 @@ export class ClientSession implements IClientSession {
 	public get kernelChanged(): Event<nb.IKernelChangedArgs> {
 		return this._kernelChangedEmitter.event;
 	}
+
+	public onKernelChanging(changeHandler: (kernel: nb.IKernelChangedArgs) => Promise<void>): void {
+		if (changeHandler) {
+			this._kernelChangeHandlers.push(changeHandler);
+		}
+	}
 	public get statusChanged(): Event<nb.ISession> {
 		return this._statusChangedEmitter.event;
 	}
@@ -204,6 +215,10 @@ export class ClientSession implements IClientSession {
 	public get isInErrorState(): boolean {
 		return !!this._errorMessage;
 	}
+
+	public get cachedKernelSpec(): nb.IKernelSpec {
+		return this._cachedKernelSpec;
+	}
 	//#endregion
 
 	//#region Not Yet Implemented
@@ -227,15 +242,28 @@ export class ClientSession implements IClientSession {
 		}
 		newKernel = this._session ? kernel : this._session.kernel;
 		this._isReady = kernel.isReady;
+		await this.updateCachedKernelSpec();
 		// Send resolution events to listeners
-		this._kernelChangeCompleted.resolve();
-		this._kernelChangedEmitter.fire({
+		let changeArgs: nb.IKernelChangedArgs = {
 			oldValue: oldKernel,
 			newValue: newKernel
-		});
+		};
+		let changePromises = this._kernelChangeHandlers.map(handler => handler(changeArgs));
+		await Promise.all(changePromises);
+		// Wait on connection configuration to complete before resolving full kernel change
+		this._kernelChangeCompleted.resolve();
+		this._kernelChangedEmitter.fire(changeArgs);
 		return kernel;
 	}
 
+	private async updateCachedKernelSpec(): Promise<void> {
+		this._cachedKernelSpec = undefined;
+		let kernel = this.kernel;
+		if (kernel && kernel.isReady) {
+			this._cachedKernelSpec = await this.kernel.getSpec();
+		}
+	}
+
 	/**
 	 * Helper method to either call ChangeKernel on current session, or start a new session
 	 * @param options