ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-01-29 09:35:38 -05:00
Code Issues Packages Projects Releases Wiki Activity

Add more unit tests for NotebookInput (#8654)

Browse Source
This commit is contained in:
Cory Rivera
2019-12-12 14:59:56 -08:00
committed by GitHub
parent 6638db1f35
commit 866bfc61ba
8 changed files with 419 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/sql/workbench/contrib/notebook/test/electron-browser/cell.test.ts
View File

@@ -11,7 +11,7 @@ import * as objects from 'vs/base/common/objects';
import { CellTypes } from 'sql/workbench/contrib/notebook/common/models/contracts';
import { ModelFactory } from 'sql/workbench/contrib/notebook/browser/models/modelFactory';
import { NotebookModelStub, ClientSessionStub, KernelStub, FutureStub } from './common';
import { NotebookModelStub, ClientSessionStub, KernelStub, FutureStub } from 'sql/workbench/contrib/notebook/test/stubs';
import { EmptyFuture } from 'sql/workbench/services/notebook/browser/sessionManager';
import { ICellModel, ICellModelOptions, IClientSession, INotebookModel } from 'sql/workbench/contrib/notebook/browser/models/modelInterfaces';
import { Deferred } from 'sql/base/common/promise';

2
src/sql/workbench/contrib/notebook/test/electron-browser/clientSession.test.ts
View File

@@ -13,7 +13,7 @@ import { URI } from 'vs/base/common/uri';
import { ClientSession } from 'sql/workbench/contrib/notebook/browser/models/clientSession';
import { SessionManager } from 'sql/workbench/services/notebook/browser/sessionManager';
import { NotebookManagerStub, ServerManagerStub } from './common';
import { NotebookManagerStub, ServerManagerStub } from 'sql/workbench/contrib/notebook/test/stubs';
import { isUndefinedOrNull } from 'vs/base/common/types';
suite('Client Session', function (): void {

374
src/sql/workbench/contrib/notebook/test/electron-browser/common.ts
View File

@@ -1,374 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { nb, IConnectionProfile } from 'azdata';
import { Event, Emitter } from 'vs/base/common/event';
import { INotebookModel, ICellModel, IClientSession, NotebookContentChange, IKernelPreference } from 'sql/workbench/contrib/notebook/browser/models/modelInterfaces';
import { NotebookChangeType, CellType } from 'sql/workbench/contrib/notebook/common/models/contracts';
import { INotebookManager, INotebookService, INotebookEditor, ILanguageMagic, INotebookProvider, INavigationProvider } from 'sql/workbench/services/notebook/browser/notebookService';
import { ISingleNotebookEditOperation } from 'sql/workbench/api/common/sqlExtHostTypes';
import { IStandardKernelWithProvider } from 'sql/workbench/contrib/notebook/browser/models/notebookUtils';
import { URI } from 'vs/workbench/workbench.web.api';
import { RenderMimeRegistry } from 'sql/workbench/contrib/notebook/browser/outputs/registry';
import { ConnectionProfile } from 'sql/platform/connection/common/connectionProfile';
export class NotebookModelStub implements INotebookModel {
constructor(private _languageInfo?: nb.ILanguageInfo) {
}
trustedMode: boolean;
language: string;
standardKernels: IStandardKernelWithProvider[];
get languageInfo(): nb.ILanguageInfo {
return this._languageInfo;
}
onCellChange(cell: ICellModel, change: NotebookChangeType): void {
// Default: do nothing
}
get cells(): ReadonlyArray<ICellModel> {
throw new Error('method not implemented.');
}
get activeCell(): ICellModel {
throw new Error('method not implemented.');
}
get clientSession(): IClientSession {
throw new Error('method not implemented.');
}
get notebookManagers(): INotebookManager[] {
throw new Error('method not implemented.');
}
get kernelChanged(): Event<nb.IKernelChangedArgs> {
throw new Error('method not implemented.');
}
get kernelsChanged(): Event<nb.IKernelSpec> {
throw new Error('method not implemented.');
}
get layoutChanged(): Event<void> {
throw new Error('method not implemented.');
}
get defaultKernel(): nb.IKernelSpec {
throw new Error('method not implemented.');
}
get contextsChanged(): Event<void> {
throw new Error('method not implemented.');
}
get contextsLoading(): Event<void> {
throw new Error('method not implemented.');
}
get contentChanged(): Event<NotebookContentChange> {
throw new Error('method not implemented.');
}
get specs(): nb.IAllKernels {
throw new Error('method not implemented.');
}
get context(): ConnectionProfile {
throw new Error('method not implemented.');
}
get providerId(): string {
throw new Error('method not implemented.');
}
get applicableConnectionProviderIds(): string[] {
throw new Error('method not implemented.');
}
getStandardKernelFromName(name: string): IStandardKernelWithProvider {
throw new Error('Method not implemented.');
}
changeKernel(displayName: string): void {
throw new Error('Method not implemented.');
}
changeContext(host: string, connection?: IConnectionProfile, hideErrorMessage?: boolean): Promise<void> {
throw new Error('Method not implemented.');
}
findCellIndex(cellModel: ICellModel): number {
throw new Error('Method not implemented.');
}
addCell(cellType: CellType, index?: number): void {
throw new Error('Method not implemented.');
}
deleteCell(cellModel: ICellModel): void {
throw new Error('Method not implemented.');
}
pushEditOperations(edits: ISingleNotebookEditOperation[]): void {
throw new Error('Method not implemented.');
}
getApplicableConnectionProviderIds(kernelName: string): string[] {
throw new Error('Method not implemented.');
}
get onValidConnectionSelected(): Event<boolean> {
throw new Error('method not implemented.');
}
get onProviderIdChange(): Event<string> {
throw new Error('method not impelemented.');
}
toJSON(): nb.INotebookContents {
throw new Error('Method not implemented.');
}
serializationStateChanged(changeType: NotebookChangeType): void {
throw new Error('Method not implemented.');
}
get onActiveCellChanged(): Event<ICellModel> {
throw new Error('Method not implemented.');
}
updateActiveCell(cell: ICellModel) {
throw new Error('Method not implemented.');
}
requestConnection(): Promise<boolean> {
throw new Error('Method not implemented.');
}
}
export class NotebookManagerStub implements INotebookManager {
providerId: string;
contentManager: nb.ContentManager;
sessionManager: nb.SessionManager;
serverManager: nb.ServerManager;
}
export class ServerManagerStub implements nb.ServerManager {
onServerStartedEmitter = new Emitter<void>();
onServerStarted: Event<void> = this.onServerStartedEmitter.event;
isStarted: boolean = false;
calledStart: boolean = false;
calledEnd: boolean = false;
result: Promise<void> = undefined;
startServer(): Promise<void> {
this.calledStart = true;
return this.result;
}
stopServer(): Promise<void> {
this.calledEnd = true;
return this.result;
}
}
export class NotebookServiceStub implements INotebookService {
_serviceBrand: undefined;
onNotebookEditorAdd: Event<INotebookEditor>;
onNotebookEditorRemove: Event<INotebookEditor>;
onNotebookEditorRename: Event<INotebookEditor>;
isRegistrationComplete: boolean;
registrationComplete: Promise<void>;
languageMagics: ILanguageMagic[];
registerProvider(providerId: string, provider: INotebookProvider): void {
throw new Error('Method not implemented.');
}
unregisterProvider(providerId: string): void {
throw new Error('Method not implemented.');
}
registerNavigationProvider(provider: INavigationProvider): void {
throw new Error('Method not implemented.');
}
getNavigationProvider(notebookUri: URI): INavigationProvider {
throw new Error('Method not implemented.');
}
getSupportedFileExtensions(): string[] {
throw new Error('Method not implemented.');
}
getProvidersForFileType(fileType: string): string[] {
throw new Error('Method not implemented.');
}
getStandardKernelsForProvider(provider: string): nb.IStandardKernel[] {
throw new Error('Method not implemented.');
}
getOrCreateNotebookManager(providerId: string, uri: URI): Thenable<INotebookManager> {
throw new Error('Method not implemented.');
}
addNotebookEditor(editor: INotebookEditor): void {
throw new Error('Method not implemented.');
}
removeNotebookEditor(editor: INotebookEditor): void {
throw new Error('Method not implemented.');
}
listNotebookEditors(): INotebookEditor[] {
throw new Error('Method not implemented.');
}
findNotebookEditor(notebookUri: URI): INotebookEditor {
throw new Error('Method not implemented.');
}
getMimeRegistry(): RenderMimeRegistry {
throw new Error('Method not implemented.');
}
renameNotebookEditor(oldUri: URI, newUri: URI, currentEditor: INotebookEditor): void {
throw new Error('Method not implemented.');
}
isNotebookTrustCached(notebookUri: URI, isDirty: boolean): Promise<boolean> {
throw new Error('Method not implemented.');
}
serializeNotebookStateChange(notebookUri: URI, changeType: NotebookChangeType, cell?: ICellModel): void {
throw new Error('Method not implemented.');
}
navigateTo(notebookUri: URI, sectionId: string): void {
throw new Error('Method not implemented.');
}
}
export class ClientSessionStub implements IClientSession {
initialize(): Promise<void> {
throw new Error('Method not implemented.');
}
changeKernel(options: nb.IKernelSpec, oldKernel?: nb.IKernel): Promise<nb.IKernel> {
throw new Error('Method not implemented.');
}
configureKernel(options: nb.IKernelSpec): Promise<void> {
throw new Error('Method not implemented.');
}
shutdown(): Promise<void> {
throw new Error('Method not implemented.');
}
selectKernel(): Promise<void> {
throw new Error('Method not implemented.');
}
restart(): Promise<boolean> {
throw new Error('Method not implemented.');
}
setPath(path: string): Promise<void> {
throw new Error('Method not implemented.');
}
setName(name: string): Promise<void> {
throw new Error('Method not implemented.');
}
setType(type: string): Promise<void> {
throw new Error('Method not implemented.');
}
updateConnection(connection: IConnectionProfile): Promise<void> {
throw new Error('Method not implemented.');
}
onKernelChanging(changeHandler: (kernel: nb.IKernelChangedArgs) => Promise<void>): void {
throw new Error('Method not implemented.');
}
dispose(): void {
throw new Error('Method not implemented.');
}
get terminated(): Event<void> {
throw new Error('Method not implemented.');
}
get kernelChanged(): Event<nb.IKernelChangedArgs> {
throw new Error('Method not implemented.');
}
get statusChanged(): Event<nb.ISession> {
throw new Error('Method not implemented.');
}
get iopubMessage(): Event<nb.IMessage> {
throw new Error('Method not implemented.');
}
get unhandledMessage(): Event<nb.IMessage> {
throw new Error('Method not implemented.');
}
get propertyChanged(): Event<'path' | 'name' | 'type'> {
throw new Error('Method not implemented.');
}
get kernel(): nb.IKernel | null {
throw new Error('Method not implemented.');
}
get notebookUri(): URI {
throw new Error('Method not implemented.');
}
get name(): string {
throw new Error('Method not implemented.');
}
get type(): string {
throw new Error('Method not implemented.');
}
get status(): nb.KernelStatus {
throw new Error('Method not implemented.');
}
get isReady(): boolean {
throw new Error('Method not implemented.');
}
get ready(): Promise<void> {
throw new Error('Method not implemented.');
}
get kernelChangeCompleted(): Promise<void> {
throw new Error('Method not implemented.');
}
get kernelPreference(): IKernelPreference {
throw new Error('Method not implemented.');
}
set kernelPreference(value: IKernelPreference) {
throw new Error('Method not implemented.');
}
get kernelDisplayName(): string {
throw new Error('Method not implemented.');
}
get errorMessage(): string {
throw new Error('Method not implemented.');
}
get isInErrorState(): boolean {
throw new Error('Method not implemented.');
}
get cachedKernelSpec(): nb.IKernelSpec {
throw new Error('Method not implemented.');
}
}
export class KernelStub implements nb.IKernel {
get id(): string {
throw new Error('Method not implemented.');
}
get name(): string {
throw new Error('Method not implemented.');
}
get supportsIntellisense(): boolean {
throw new Error('Method not implemented.');
}
get requiresConnection(): boolean {
throw new Error('Method not implemented.');
}
get isReady(): boolean {
throw new Error('Method not implemented.');
}
get ready(): Thenable<void> {
throw new Error('Method not implemented.');
}
get info(): nb.IInfoReply {
throw new Error('Method not implemented.');
}
getSpec(): Thenable<nb.IKernelSpec> {
throw new Error('Method not implemented.');
}
requestExecute(content: nb.IExecuteRequest, disposeOnDone?: boolean): nb.IFuture {
throw new Error('Method not implemented.');
}
requestComplete(content: nb.ICompleteRequest): Thenable<nb.ICompleteReplyMsg> {
throw new Error('Method not implemented.');
}
interrupt(): Thenable<void> {
throw new Error('Method not implemented.');
}
}
export class FutureStub implements nb.IFuture {
constructor(private _msg: nb.IMessage, private _done: Thenable<nb.IShellMessage>) {
}
get msg(): nb.IMessage {
return this._msg;
}
get done(): Thenable<nb.IShellMessage> {
return this._done;
}
setReplyHandler(handler: nb.MessageHandler<nb.IShellMessage>): void {
return;
}
setStdInHandler(handler: nb.MessageHandler<nb.IStdinMessage>): void {
return;
}
setIOPubHandler(handler: nb.MessageHandler<nb.IIOPubMessage>): void {
return;
}
registerMessageHook(hook: (msg: nb.IIOPubMessage) => boolean | Thenable<boolean>): void {
return;
}
removeMessageHook(hook: (msg: nb.IIOPubMessage) => boolean | Thenable<boolean>): void {
return;
}
sendInputReply(content: nb.IInputReply): void {
return;
}
dispose() {
return;
}
}

2
src/sql/workbench/contrib/notebook/test/electron-browser/notebookModel.test.ts
View File

@@ -12,7 +12,7 @@ import { TestNotificationService } from 'vs/platform/notification/test/common/te
import { URI } from 'vs/base/common/uri';
import { LocalContentManager } from 'sql/workbench/services/notebook/common/localContentManager';
import { NotebookManagerStub } from './common';
import { NotebookManagerStub } from 'sql/workbench/contrib/notebook/test/stubs';
import { NotebookModel } from 'sql/workbench/contrib/notebook/browser/models/notebookModel';
import { ModelFactory } from 'sql/workbench/contrib/notebook/browser/models/modelFactory';
import { IClientSession, INotebookModelOptions, NotebookContentChange } from 'sql/workbench/contrib/notebook/browser/models/modelInterfaces';

2
src/sql/workbench/contrib/notebook/test/electron-browser/notebookUtils.test.ts
View File

@@ -9,7 +9,7 @@ import * as TypeMoq from 'typemoq';
import { nb, ServerInfo } from 'azdata';
import { tryMatchCellMagic, getHostAndPortFromEndpoint, isStream, getProvidersForFileName, asyncForEach, clusterEndpointsProperty, getClusterEndpoints, RawEndpoint, IEndpoint, getStandardKernelsForProvider, IStandardKernelWithProvider } from 'sql/workbench/contrib/notebook/browser/models/notebookUtils';
import { INotebookService, DEFAULT_NOTEBOOK_FILETYPE, DEFAULT_NOTEBOOK_PROVIDER } from 'sql/workbench/services/notebook/browser/notebookService';
import { NotebookServiceStub } from 'sql/workbench/contrib/notebook/test/electron-browser/common';
import { NotebookServiceStub } from 'sql/workbench/contrib/notebook/test/stubs';
suite('notebookUtils', function (): void {
const mockNotebookService = TypeMoq.Mock.ofType<INotebookService>(NotebookServiceStub);