@jupyter-lsp/jupyterlab-lsp/lib/testutils.d.ts

Language Server Protocol integration for JupyterLab

import { IEditorServices } from '@jupyterlab/codeeditor';
import { CodeMirrorEditor, EditorExtensionRegistry } from '@jupyterlab/codemirror';
import { IDocumentWidget } from '@jupyterlab/docregistry';
import { FileEditor } from '@jupyterlab/fileeditor';
import { WidgetLSPAdapter, LanguageServerManager, DocumentConnectionManager, ISocketConnectionOptions, ILSPOptions, ILSPFeatureManager } from '@jupyterlab/lsp';
import { LSPConnection } from '@jupyterlab/lsp/lib/connection';
import * as nbformat from '@jupyterlab/nbformat';
import { Notebook, NotebookPanel } from '@jupyterlab/notebook';
import { PromiseDelegate } from '@lumino/coreutils';
import { Signal } from '@lumino/signaling';
import type * as lsProtocol from 'vscode-languageserver-protocol';
import { FileEditorAdapter } from './adapters/fileeditor';
import { NotebookAdapter } from './adapters/notebook';
import { IFeatureSettings } from './feature';
import { VirtualDocument } from './virtual/document';
export interface ITestEnvironment {
    documentOptions: VirtualDocument.IOptions;
    adapter: WidgetLSPAdapter<any>;
    init(): void;
    dispose(): void;
}
export declare class MockLanguageServerManager extends LanguageServerManager {
    fetchSessions(): Promise<void>;
}
export declare class MockSettings<T> implements IFeatureSettings<T> {
    private settings;
    changed: Signal<IFeatureSettings<T>, void>;
    constructor(settings: T);
    get composite(): Required<T>;
    set(setting: keyof T, value: any): void;
}
declare namespace MockConnection {
    interface IOptions extends ILSPOptions {
        serverCapabilities: lsProtocol.ServerCapabilities;
    }
}
declare class MockConnection extends LSPConnection {
    protected options: MockConnection.IOptions;
    constructor(options: MockConnection.IOptions);
    connect(ws: any): void;
}
declare namespace MockDocumentConnectionManager {
    interface IOptions extends DocumentConnectionManager.IOptions {
        connection?: Partial<MockConnection.IOptions>;
    }
}
declare class MockDocumentConnectionManager extends DocumentConnectionManager {
    protected options: MockDocumentConnectionManager.IOptions;
    constructor(options: MockDocumentConnectionManager.IOptions);
    get ready(): Promise<void>;
    connect(options: ISocketConnectionOptions, firstTimeoutSeconds?: number, secondTimeoutMinutes?: number): Promise<MockConnection | undefined>;
}
export declare namespace TestEnvironment {
    interface IOptions {
        document?: Partial<VirtualDocument.IOptions>;
        connection?: Partial<MockConnection.IOptions>;
    }
}
export declare abstract class TestEnvironment implements ITestEnvironment {
    protected options?: TestEnvironment.IOptions | undefined;
    adapter: WidgetLSPAdapter<any>;
    abstract widget: IDocumentWidget;
    protected abstract getDefaults(): VirtualDocument.IOptions;
    documentOptions: VirtualDocument.IOptions;
    editorExtensionRegistry: EditorExtensionRegistry;
    editorServices: IEditorServices;
    featureManager: ILSPFeatureManager;
    constructor(options?: TestEnvironment.IOptions | undefined);
    protected abstract createWidget(): IDocumentWidget;
    protected abstract getAdapterType(): typeof FileEditorAdapter | typeof NotebookAdapter;
    get activeEditor(): CodeMirrorEditor;
    connectionManager: MockDocumentConnectionManager;
    init(): Promise<void>;
    private _languageServerManager;
    dispose(): void;
}
export declare class MockNotebookAdapter extends NotebookAdapter {
    get language(): string;
    isReady(): boolean;
    foreingDocumentOpened: PromiseDelegate<unknown>;
    onForeignDocumentOpened(_: VirtualDocument, context: any): Promise<void>;
}
export declare class FileEditorTestEnvironment extends TestEnvironment {
    protected getAdapterType(): typeof FileEditorAdapter;
    widget: IDocumentWidget<FileEditor>;
    protected getDefaults(): VirtualDocument.IOptions;
    createWidget(): IDocumentWidget;
    dispose(): void;
}
export declare class NotebookTestEnvironment extends TestEnvironment {
    widget: NotebookPanel;
    protected getAdapterType(): typeof MockNotebookAdapter;
    get notebook(): Notebook;
    protected getDefaults(): VirtualDocument.IOptions;
    createWidget(): IDocumentWidget;
}
export declare function codeCell(source: string[] | string, metadata?: Partial<nbformat.ICodeCellMetadata>): nbformat.ICodeCell;
export declare function setNotebookContent(notebook: Notebook, cells: nbformat.ICodeCell[], metadata?: nbformat.INotebookMetadata): void;
export declare const pythonNotebookMetadata: nbformat.INotebookMetadata;
export declare function showAllCells(notebook: Notebook): void;
export declare function getCellsJSON(notebook: Notebook): Array<nbformat.ICell>;
export {};