// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT License.

//tslint:disable:trailing-comma no-any

import * as child_process from 'child_process';

import { ReactWrapper } from 'enzyme';

import * as fs from 'fs-extra';

import * as glob from 'glob';

import { interfaces } from 'inversify';

import * as os from 'os';

import * as path from 'path';

import { SemVer } from 'semver';

import { anything, instance, mock, reset, when } from 'ts-mockito';

import * as TypeMoq from 'typemoq';

import {

CancellationTokenSource,

ConfigurationChangeEvent,

Disposable,

Event,

EventEmitter,

FileSystemWatcher,

Memento,

Uri,

WorkspaceFolder,

WorkspaceFoldersChangeEvent

} from 'vscode';

import * as vsls from 'vsls/vscode';

import { KernelDaemonPool } from '../../client/datascience/kernel-launcher/kernelDaemonPool';

import { promisify } from 'util';

import { LanguageServerExtensionActivationService } from '../../client/activation/activationService';

import { LanguageServerDownloader } from '../../client/activation/common/downloader';

import { JediExtensionActivator } from '../../client/activation/jedi';

import { DotNetLanguageServerActivator } from '../../client/activation/languageServer/activator';

import { LanguageServerCompatibilityService } from '../../client/activation/languageServer/languageServerCompatibilityService';

import { LanguageServerExtension } from '../../client/activation/languageServer/languageServerExtension';

import { DotNetLanguageServerFolderService } from '../../client/activation/languageServer/languageServerFolderService';

import { DotNetLanguageServerPackageService } from '../../client/activation/languageServer/languageServerPackageService';

import { DotNetLanguageServerManager } from '../../client/activation/languageServer/manager';

import { NodeLanguageServerActivator } from '../../client/activation/node/activator';

import { NodeLanguageServerManager } from '../../client/activation/node/manager';

import {

IExtensionSingleActivationService,

ILanguageServerActivator,

ILanguageServerAnalysisOptions,

ILanguageServerCache,

ILanguageServerCompatibilityService,

ILanguageServerDownloader,

ILanguageServerExtension,

ILanguageServerFolderService,

ILanguageServerManager,

ILanguageServerPackageService,

ILanguageServerProxy,

LanguageServerType

} from '../../client/activation/types';

import {

LSNotSupportedDiagnosticService,

LSNotSupportedDiagnosticServiceId

} from '../../client/application/diagnostics/checks/lsNotSupported';

import { DiagnosticFilterService } from '../../client/application/diagnostics/filter';

import {

DiagnosticCommandPromptHandlerService,

DiagnosticCommandPromptHandlerServiceId,

MessageCommandPrompt

} from '../../client/application/diagnostics/promptHandler';

import {

IDiagnosticFilterService,

IDiagnosticHandlerService,

IDiagnosticsService

} from '../../client/application/diagnostics/types';

import { ApplicationEnvironment } from '../../client/common/application/applicationEnvironment';

import { ClipboardService } from '../../client/common/application/clipboard';

import { VSCodeNotebook } from '../../client/common/application/notebook';

import { TerminalManager } from '../../client/common/application/terminalManager';

import {

IApplicationEnvironment,

IApplicationShell,

IClipboard,

ICommandManager,

ICustomEditorService,

IDebugService,

IDocumentManager,

ILiveShareApi,

ILiveShareTestingApi,

ITerminalManager,

IVSCodeNotebook,

IWebPanel,

IWebPanelMessageListener,

IWebPanelOptions,

IWebPanelProvider,

IWorkspaceService

} from '../../client/common/application/types';

import { WebPanel } from '../../client/common/application/webPanels/webPanel';

import { WebPanelProvider } from '../../client/common/application/webPanels/webPanelProvider';

import { WorkspaceService } from '../../client/common/application/workspace';

import { AsyncDisposableRegistry } from '../../client/common/asyncDisposableRegistry';

import { PythonSettings } from '../../client/common/configSettings';

import { EXTENSION_ROOT_DIR, UseCustomEditorApi, UseProposedApi } from '../../client/common/constants';

import { CryptoUtils } from '../../client/common/crypto';

import { DotNetCompatibilityService } from '../../client/common/dotnet/compatibilityService';

import { IDotNetCompatibilityService } from '../../client/common/dotnet/types';

import { LocalZMQKernel } from '../../client/common/experiments/groups';

import { ExperimentsManager } from '../../client/common/experiments/manager';

import { ExperimentService } from '../../client/common/experiments/service';

import { InstallationChannelManager } from '../../client/common/installer/channelManager';

import { ProductInstaller } from '../../client/common/installer/productInstaller';

import {

CTagsProductPathService,

DataScienceProductPathService,

FormatterProductPathService,

LinterProductPathService,

RefactoringLibraryProductPathService,

TestFrameworkProductPathService

} from '../../client/common/installer/productPath';

import { ProductService } from '../../client/common/installer/productService';

import { IInstallationChannelManager, IProductPathService, IProductService } from '../../client/common/installer/types';

import { InterpreterPathService } from '../../client/common/interpreterPathService';

import { BrowserService } from '../../client/common/net/browser';

import { HttpClient } from '../../client/common/net/httpClient';

import { IS_WINDOWS } from '../../client/common/platform/constants';

import { PathUtils } from '../../client/common/platform/pathUtils';

import { RegistryImplementation } from '../../client/common/platform/registry';

import { IFileSystem, IRegistry } from '../../client/common/platform/types';

import { CurrentProcess } from '../../client/common/process/currentProcess';

import { BufferDecoder } from '../../client/common/process/decoder';

import { ProcessLogger } from '../../client/common/process/logger';

import { ProcessServiceFactory } from '../../client/common/process/processFactory';

import { PythonExecutionFactory } from '../../client/common/process/pythonExecutionFactory';

import {

IBufferDecoder,

IProcessLogger,

IProcessServiceFactory,

IPythonExecutionFactory

} from '../../client/common/process/types';

import { StartPage } from '../../client/common/startPage/startPage';

import { IStartPage } from '../../client/common/startPage/types';

import { Bash } from '../../client/common/terminal/environmentActivationProviders/bash';

import { CommandPromptAndPowerShell } from '../../client/common/terminal/environmentActivationProviders/commandPrompt';

import { CondaActivationCommandProvider } from '../../client/common/terminal/environmentActivationProviders/condaActivationProvider';

import { PipEnvActivationCommandProvider } from '../../client/common/terminal/environmentActivationProviders/pipEnvActivationProvider';

import { PyEnvActivationCommandProvider } from '../../client/common/terminal/environmentActivationProviders/pyenvActivationProvider';

import { TerminalHelper } from '../../client/common/terminal/helper';

import { TerminalNameShellDetector } from '../../client/common/terminal/shellDetectors/terminalNameShellDetector';

import {

IShellDetector,

ITerminalActivationCommandProvider,

ITerminalHelper,

TerminalActivationProviders

} from '../../client/common/terminal/types';

import {

BANNER_NAME_LS_SURVEY,

GLOBAL_MEMENTO,

IAsyncDisposableRegistry,

IBrowserService,

IConfigurationService,

ICryptoUtils,

ICurrentProcess,

IDataScienceSettings,

IExperimentService,

IExperimentsManager,

IExtensionContext,

IExtensions,

IHttpClient,

IInstaller,

IInterpreterPathService,

IMemento,

IOutputChannel,

IPathUtils,

IPersistentStateFactory,

IPythonExtensionBanner,

IPythonSettings,

IsWindows,

ProductType,

Resource,

WORKSPACE_MEMENTO

} from '../../client/common/types';

import { Deferred, sleep } from '../../client/common/utils/async';

import { noop } from '../../client/common/utils/misc';

import { IMultiStepInputFactory, MultiStepInputFactory } from '../../client/common/utils/multiStepInput';

import { Architecture } from '../../client/common/utils/platform';

import { EnvironmentVariablesService } from '../../client/common/variables/environment';

import { EnvironmentVariablesProvider } from '../../client/common/variables/environmentVariablesProvider';

import { IEnvironmentVariablesProvider, IEnvironmentVariablesService } from '../../client/common/variables/types';

import { CodeCssGenerator } from '../../client/datascience/codeCssGenerator';

import { Identifiers, JUPYTER_OUTPUT_CHANNEL } from '../../client/datascience/constants';

import { ActiveEditorContextService } from '../../client/datascience/context/activeEditorContext';

import { DataViewer } from '../../client/datascience/data-viewing/dataViewer';

import { DataViewerDependencyService } from '../../client/datascience/data-viewing/dataViewerDependencyService';

import { DataViewerFactory } from '../../client/datascience/data-viewing/dataViewerFactory';

import { JupyterVariableDataProvider } from '../../client/datascience/data-viewing/jupyterVariableDataProvider';

import { JupyterVariableDataProviderFactory } from '../../client/datascience/data-viewing/jupyterVariableDataProviderFactory';

import { IDataViewer, IDataViewerFactory } from '../../client/datascience/data-viewing/types';

import { DebugLocationTrackerFactory } from '../../client/datascience/debugLocationTrackerFactory';

import { CellHashProvider } from '../../client/datascience/editor-integration/cellhashprovider';

import { CodeLensFactory } from '../../client/datascience/editor-integration/codeLensFactory';

import { DataScienceCodeLensProvider } from '../../client/datascience/editor-integration/codelensprovider';

import { CodeWatcher } from '../../client/datascience/editor-integration/codewatcher';

import { HoverProvider } from '../../client/datascience/editor-integration/hoverProvider';

import { DataScienceErrorHandler } from '../../client/datascience/errorHandler/errorHandler';

import { GatherProvider } from '../../client/datascience/gather/gather';

import { GatherListener } from '../../client/datascience/gather/gatherListener';

import { GatherLogger } from '../../client/datascience/gather/gatherLogger';

import { IntellisenseProvider } from '../../client/datascience/interactive-common/intellisense/intellisenseProvider';

import { NotebookProvider } from '../../client/datascience/interactive-common/notebookProvider';

import { NotebookServerProvider } from '../../client/datascience/interactive-common/notebookServerProvider';

import { AutoSaveService } from '../../client/datascience/interactive-ipynb/autoSaveService';

import { NativeEditor } from '../../client/datascience/interactive-ipynb/nativeEditor';

import { NativeEditorCommandListener } from '../../client/datascience/interactive-ipynb/nativeEditorCommandListener';

import { NativeEditorOldWebView } from '../../client/datascience/interactive-ipynb/nativeEditorOldWebView';

import { NativeEditorRunByLineListener } from '../../client/datascience/interactive-ipynb/nativeEditorRunByLineListener';

import { NativeEditorStorage } from '../../client/datascience/interactive-ipynb/nativeEditorStorage';

import { NativeEditorSynchronizer } from '../../client/datascience/interactive-ipynb/nativeEditorSynchronizer';

import {

INotebookStorageProvider,

NotebookStorageProvider

} from '../../client/datascience/interactive-ipynb/notebookStorageProvider';

import { InteractiveWindow } from '../../client/datascience/interactive-window/interactiveWindow';

import { InteractiveWindowCommandListener } from '../../client/datascience/interactive-window/interactiveWindowCommandListener';

import { IPyWidgetHandler } from '../../client/datascience/ipywidgets/ipywidgetHandler';

import { IPyWidgetMessageDispatcherFactory } from '../../client/datascience/ipywidgets/ipyWidgetMessageDispatcherFactory';

import { IPyWidgetScriptSource } from '../../client/datascience/ipywidgets/ipyWidgetScriptSource';

import { DebuggerVariableRegistration } from '../../client/datascience/jupyter/debuggerVariableRegistration';

import { DebuggerVariables } from '../../client/datascience/jupyter/debuggerVariables';

import { JupyterCommandFactory } from '../../client/datascience/jupyter/interpreter/jupyterCommand';

import { JupyterInterpreterDependencyService } from '../../client/datascience/jupyter/interpreter/jupyterInterpreterDependencyService';

import { JupyterInterpreterOldCacheStateStore } from '../../client/datascience/jupyter/interpreter/jupyterInterpreterOldCacheStateStore';

import { JupyterInterpreterSelectionCommand } from '../../client/datascience/jupyter/interpreter/jupyterInterpreterSelectionCommand';

import { JupyterInterpreterSelector } from '../../client/datascience/jupyter/interpreter/jupyterInterpreterSelector';

import { JupyterInterpreterService } from '../../client/datascience/jupyter/interpreter/jupyterInterpreterService';

import { JupyterInterpreterStateStore } from '../../client/datascience/jupyter/interpreter/jupyterInterpreterStateStore';

import { JupyterInterpreterSubCommandExecutionService } from '../../client/datascience/jupyter/interpreter/jupyterInterpreterSubCommandExecutionService';

import { JupyterDebugger } from '../../client/datascience/jupyter/jupyterDebugger';

import { JupyterExecutionFactory } from '../../client/datascience/jupyter/jupyterExecutionFactory';

import { JupyterExporter } from '../../client/datascience/jupyter/jupyterExporter';

import { JupyterImporter } from '../../client/datascience/jupyter/jupyterImporter';

import { JupyterNotebookProvider } from '../../client/datascience/jupyter/jupyterNotebookProvider';

import { JupyterPasswordConnect } from '../../client/datascience/jupyter/jupyterPasswordConnect';

import { JupyterServerWrapper } from '../../client/datascience/jupyter/jupyterServerWrapper';

import { JupyterSessionManagerFactory } from '../../client/datascience/jupyter/jupyterSessionManagerFactory';

import { JupyterVariables } from '../../client/datascience/jupyter/jupyterVariables';

import { KernelDependencyService } from '../../client/datascience/jupyter/kernels/kernelDependencyService';

import { KernelSelectionProvider } from '../../client/datascience/jupyter/kernels/kernelSelections';

import { KernelSelector } from '../../client/datascience/jupyter/kernels/kernelSelector';

import { KernelService } from '../../client/datascience/jupyter/kernels/kernelService';

import { KernelSwitcher } from '../../client/datascience/jupyter/kernels/kernelSwitcher';

import { KernelVariables } from '../../client/datascience/jupyter/kernelVariables';

import { NotebookStarter } from '../../client/datascience/jupyter/notebookStarter';

import { OldJupyterVariables } from '../../client/datascience/jupyter/oldJupyterVariables';

import { ServerPreload } from '../../client/datascience/jupyter/serverPreload';

import { JupyterServerSelector } from '../../client/datascience/jupyter/serverSelector';

import { JupyterDebugService } from '../../client/datascience/jupyterDebugService';

import { KernelDaemonPreWarmer } from '../../client/datascience/kernel-launcher/kernelDaemonPreWarmer';

import { KernelFinder } from '../../client/datascience/kernel-launcher/kernelFinder';

import { KernelLauncher } from '../../client/datascience/kernel-launcher/kernelLauncher';

import { IKernelFinder, IKernelLauncher } from '../../client/datascience/kernel-launcher/types';

import { NotebookAndInteractiveWindowUsageTracker } from '../../client/datascience/notebookAndInteractiveTracker';

import { PlotViewer } from '../../client/datascience/plotting/plotViewer';

import { PlotViewerProvider } from '../../client/datascience/plotting/plotViewerProvider';

import { ProgressReporter } from '../../client/datascience/progress/progressReporter';

import { RawNotebookProviderWrapper } from '../../client/datascience/raw-kernel/rawNotebookProviderWrapper';

import { RawNotebookSupportedService } from '../../client/datascience/raw-kernel/rawNotebookSupportedService';

import { StatusProvider } from '../../client/datascience/statusProvider';

import { ThemeFinder } from '../../client/datascience/themeFinder';

import {

ICellHashListener,

ICellHashProvider,

ICodeCssGenerator,

ICodeLensFactory,

ICodeWatcher,

IDataScience,

IDataScienceCodeLensProvider,

IDataScienceCommandListener,

IDataScienceErrorHandler,

IDebugLocationTracker,

IGatherLogger,

IGatherProvider,

IInteractiveWindow,

IInteractiveWindowListener,

IInteractiveWindowProvider,

IJupyterCommandFactory,

IJupyterDebugger,

IJupyterDebugService,

IJupyterExecution,

IJupyterInterpreterDependencyManager,

IJupyterNotebookProvider,

IJupyterPasswordConnect,

IJupyterServerProvider,

IJupyterSessionManagerFactory,

IJupyterSubCommandExecutionService,

IJupyterVariableDataProvider,

IJupyterVariableDataProviderFactory,

IJupyterVariables,

IKernelDependencyService,

INotebookAndInteractiveWindowUsageTracker,

INotebookEditor,

INotebookEditorProvider,

INotebookExecutionLogger,

INotebookExporter,

INotebookImporter,

INotebookProvider,

INotebookServer,

INotebookStorage,

IPlotViewer,

IPlotViewerProvider,

IRawNotebookProvider,

IRawNotebookSupportedService,

IStatusProvider,

IThemeFinder

} from '../../client/datascience/types';

import { ProtocolParser } from '../../client/debugger/debugAdapter/Common/protocolParser';

import { IProtocolParser } from '../../client/debugger/debugAdapter/types';

import {

EnvironmentActivationService,

EnvironmentActivationServiceCache

} from '../../client/interpreter/activation/service';

import { IEnvironmentActivationService } from '../../client/interpreter/activation/types';

import { InterpreterEvaluation } from '../../client/interpreter/autoSelection/interpreterSecurity/interpreterEvaluation';

import { InterpreterSecurityService } from '../../client/interpreter/autoSelection/interpreterSecurity/interpreterSecurityService';

import { InterpreterSecurityStorage } from '../../client/interpreter/autoSelection/interpreterSecurity/interpreterSecurityStorage';

import {

IInterpreterEvaluation,

IInterpreterSecurityService,

IInterpreterSecurityStorage

} from '../../client/interpreter/autoSelection/types';

import { InterpreterComparer } from '../../client/interpreter/configuration/interpreterComparer';

import { InterpreterSelector } from '../../client/interpreter/configuration/interpreterSelector/interpreterSelector';

import { PythonPathUpdaterService } from '../../client/interpreter/configuration/pythonPathUpdaterService';

import { PythonPathUpdaterServiceFactory } from '../../client/interpreter/configuration/pythonPathUpdaterServiceFactory';

import {

IInterpreterComparer,

IInterpreterSelector,

IPythonPathUpdaterServiceFactory,

IPythonPathUpdaterServiceManager

} from '../../client/interpreter/configuration/types';

import {

CONDA_ENV_FILE_SERVICE,

CONDA_ENV_SERVICE,

CURRENT_PATH_SERVICE,

GLOBAL_VIRTUAL_ENV_SERVICE,

ICondaService,

IInterpreterDisplay,

IInterpreterHelper,

IInterpreterLocatorHelper,

IInterpreterLocatorService,

IInterpreterService,

IInterpreterVersionService,

IInterpreterWatcher,

IInterpreterWatcherBuilder,

IKnownSearchPathsForInterpreters,

INTERPRETER_LOCATOR_SERVICE,

IShebangCodeLensProvider,

IVirtualEnvironmentsSearchPathProvider,

KNOWN_PATH_SERVICE,

PIPENV_SERVICE,

WINDOWS_REGISTRY_SERVICE,

WORKSPACE_VIRTUAL_ENV_SERVICE

} from '../../client/interpreter/contracts';

import { ShebangCodeLensProvider } from '../../client/interpreter/display/shebangCodeLensProvider';

import { InterpreterHelper } from '../../client/interpreter/helpers';

import { InterpreterVersionService } from '../../client/interpreter/interpreterVersion';

import { IPipEnvServiceHelper, IPythonInPathCommandProvider } from '../../client/interpreter/locators/types';

import { registerInterpreterTypes } from '../../client/interpreter/serviceRegistry';

import { VirtualEnvironmentManager } from '../../client/interpreter/virtualEnvs';

import { IVirtualEnvironmentManager } from '../../client/interpreter/virtualEnvs/types';

import { LanguageServerSurveyBanner } from '../../client/languageServices/languageServerSurveyBanner';

import { traceInfo } from '../../client/logging';

import { PythonInterpreterLocatorService } from '../../client/pythonEnvironments/discovery/locators';

import { InterpreterLocatorHelper } from '../../client/pythonEnvironments/discovery/locators/helpers';

import { CacheableLocatorPromiseCache } from '../../client/pythonEnvironments/discovery/locators/services/cacheableLocatorService';

import { CondaEnvFileService } from '../../client/pythonEnvironments/discovery/locators/services/condaEnvFileService';

import { CondaEnvService } from '../../client/pythonEnvironments/discovery/locators/services/condaEnvService';

import {

CurrentPathService,

PythonInPathCommandProvider

} from '../../client/pythonEnvironments/discovery/locators/services/currentPathService';

import {

GlobalVirtualEnvironmentsSearchPathProvider,

GlobalVirtualEnvService

} from '../../client/pythonEnvironments/discovery/locators/services/globalVirtualEnvService';

import { InterpreterHashProvider } from '../../client/pythonEnvironments/discovery/locators/services/hashProvider';

import { InterpeterHashProviderFactory } from '../../client/pythonEnvironments/discovery/locators/services/hashProviderFactory';

import { InterpreterFilter } from '../../client/pythonEnvironments/discovery/locators/services/interpreterFilter';

import { InterpreterWatcherBuilder } from '../../client/pythonEnvironments/discovery/locators/services/interpreterWatcherBuilder';

import {

KnownPathsService,

KnownSearchPathsForInterpreters

} from '../../client/pythonEnvironments/discovery/locators/services/KnownPathsService';

import { PipEnvService } from '../../client/pythonEnvironments/discovery/locators/services/pipEnvService';

import { PipEnvServiceHelper } from '../../client/pythonEnvironments/discovery/locators/services/pipEnvServiceHelper';

import { WindowsRegistryService } from '../../client/pythonEnvironments/discovery/locators/services/windowsRegistryService';

import { WindowsStoreInterpreter } from '../../client/pythonEnvironments/discovery/locators/services/windowsStoreInterpreter';

import {

WorkspaceVirtualEnvironmentsSearchPathProvider,

WorkspaceVirtualEnvService

} from '../../client/pythonEnvironments/discovery/locators/services/workspaceVirtualEnvService';

import { WorkspaceVirtualEnvWatcherService } from '../../client/pythonEnvironments/discovery/locators/services/workspaceVirtualEnvWatcherService';

import { InterpreterType, PythonInterpreter } from '../../client/pythonEnvironments/discovery/types';

import { CodeExecutionHelper } from '../../client/terminals/codeExecution/helper';

import { ICodeExecutionHelper } from '../../client/terminals/types';

import { IVsCodeApi } from '../../datascience-ui/react-common/postOffice';

import { MockOutputChannel } from '../mockClasses';

import { MockAutoSelectionService } from '../mocks/autoSelector';

import { UnitTestIocContainer } from '../testing/serviceRegistry';

import { MockCommandManager } from './mockCommandManager';

import { MockCustomEditorService } from './mockCustomEditorService';

import { MockDebuggerService } from './mockDebugService';

import { MockDocumentManager } from './mockDocumentManager';

import { MockExtensions } from './mockExtensions';

import { MockFileSystem } from './mockFileSystem';

import { MockJupyterManager, SupportedCommands } from './mockJupyterManager';

import { MockJupyterManagerFactory } from './mockJupyterManagerFactory';

import { MockLanguageServerAnalysisOptions } from './mockLanguageServerAnalysisOptions';

import { MockLanguageServerProxy } from './mockLanguageServerProxy';

import { MockLiveShareApi } from './mockLiveShare';

import { MockPythonSettings } from './mockPythonSettings';

import { MockWorkspaceConfiguration } from './mockWorkspaceConfig';

import { MockWorkspaceFolder } from './mockWorkspaceFolder';

import { TestExecutionLogger } from './testexecutionLogger';

import { TestInteractiveWindowProvider } from './testInteractiveWindowProvider';

import { TestNativeEditorProvider } from './testNativeEditorProvider';

import { TestPersistentStateFactory } from './testPersistentStateFactory';

import { WebBrowserPanelProvider } from './uiTests/webBrowserPanelProvider';

export class DataScienceIocContainer extends UnitTestIocContainer {

public get workingInterpreter() {

return this.workingPython;

}

public get workingInterpreter2() {

return this.workingPython2;

}

public get onContextSet(): Event<{ name: string; value: boolean }> {

return this.contextSetEvent.event;

}

public get mockJupyter(): MockJupyterManager | undefined {

return this.jupyterMock ? this.jupyterMock.getManager() : undefined;

}

public get kernelService() {

return this.kernelServiceMock;

}

private static jupyterInterpreters: PythonInterpreter[] = [];

private static foundPythonPath: string | undefined;

public webPanelListener: IWebPanelMessageListener | undefined;

public wrapper: ReactWrapper<any, Readonly<{}>, React.Component> | undefined;

public wrapperCreatedPromise: Deferred<boolean> | undefined;

public postMessage: ((ev: MessageEvent) => void) | undefined;

public applicationShell!: TypeMoq.IMock<IApplicationShell>;

// tslint:disable-next-line:no-any

public datascience!: TypeMoq.IMock<IDataScience>;

public shouldMockJupyter: boolean;

private missedMessages: any[] = [];

private commandManager: MockCommandManager = new MockCommandManager();

private setContexts: Record<string, boolean> = {};

private contextSetEvent: EventEmitter<{ name: string; value: boolean }> = new EventEmitter<{

name: string;

value: boolean;

}>();

private jupyterMock: MockJupyterManagerFactory | undefined;

private asyncRegistry: AsyncDisposableRegistry;

private configChangeEvent = new EventEmitter<ConfigurationChangeEvent>();

private worksaceFoldersChangedEvent = new EventEmitter<WorkspaceFoldersChangeEvent>();

private documentManager = new MockDocumentManager();

private workingPython: PythonInterpreter = {

path: '/foo/bar/python.exe',

version: new SemVer('3.6.6-final'),

sysVersion: '1.0.0.0',

sysPrefix: 'Python',

displayName: 'Python',

type: InterpreterType.Unknown,

architecture: Architecture.x64

};

private workingPython2: PythonInterpreter = {

path: '/foo/baz/python.exe',

version: new SemVer('3.6.7-final'),

sysVersion: '1.0.0.0',

sysPrefix: 'Python',

displayName: 'Python',

type: InterpreterType.Unknown,

architecture: Architecture.x64

};

private extraListeners: ((m: string, p: any) => void)[] = [];

private webPanelProvider = mock(WebPanelProvider);

private settingsMap = new Map<string, any>();

private configMap = new Map<string, MockWorkspaceConfiguration>();

private emptyConfig = new MockWorkspaceConfiguration();

private workspaceFolders: MockWorkspaceFolder[] = [];

private defaultPythonPath: string | undefined;

private kernelServiceMock = mock(KernelService);

private disposed = false;

private experimentState = new Map<string, boolean>();

private extensionRootPath: string | undefined;

private languageServerType: LanguageServerType = LanguageServerType.Microsoft;

constructor(private readonly uiTest: boolean = false) {

super();

this.useVSCodeAPI = false;

const isRollingBuild = process.env ? process.env.VSCODE_PYTHON_ROLLING !== undefined : false;

this.shouldMockJupyter = !isRollingBuild;

this.asyncRegistry = new AsyncDisposableRegistry();

}

public async dispose(): Promise<void> {

// Make sure to disable all command handling during dispose. Don't want

// anything to startup again.

this.commandManager.dispose();

try {

// Make sure to delete any temp files written by native editor storage

const globPr = promisify(glob);

const tempLocation = os.tmpdir;

const tempFiles = await globPr(`${tempLocation}/*.ipynb`);

if (tempFiles && tempFiles.length) {

await Promise.all(tempFiles.map((t) => fs.remove(t)));

}

} catch (exc) {

// tslint:disable-next-line: no-console

console.log(`Exception on cleanup: ${exc}`);

}

await this.asyncRegistry.dispose();

await super.dispose();

this.disposed = true;

if (!this.uiTest) {

// Blur window focus so we don't have editors polling

// tslint:disable-next-line: no-require-imports

const reactHelpers = require('./reactHelpers') as typeof import('./reactHelpers');

reactHelpers.blurWindow();

}

if (this.wrapper && this.wrapper.length) {

this.wrapper.unmount();

this.wrapper = undefined;

}

// Bounce this so that our editor has time to shutdown

await sleep(150);

if (!this.uiTest) {

// Clear out the monaco global services. Some of these services are preventing shutdown.

// tslint:disable: no-require-imports

const services = require('monaco-editor/esm/vs/editor/standalone/browser/standaloneServices') as any;

if (services.StaticServices) {

const keys = Object.keys(services.StaticServices);

keys.forEach((k) => {

const service = services.StaticServices[k] as any;

if (service && service._value && service._value.dispose) {

if (typeof service._value.dispose === 'function') {

service._value.dispose();

}

}

});

}

// This file doesn't have an export so we can't force a dispose. Instead it has a 5 second timeout

const config = require('monaco-editor/esm/vs/editor/browser/config/configuration') as any;

if (config.getCSSBasedConfiguration) {

config.getCSSBasedConfiguration().dispose();

}

}

// Because there are outstanding promises holding onto this object, clear out everything we can

this.workspaceFolders = [];

this.settingsMap.clear();

this.configMap.clear();

this.setContexts = {};

this.extraListeners = [];

this.webPanelListener = undefined;

reset(this.webPanelProvider);

// Turn off the static maps for the environment and conda services. Otherwise this

// can mess up tests that don't depend upon them

CacheableLocatorPromiseCache.forceUseNormal();

EnvironmentActivationServiceCache.forceUseNormal();

}

//tslint:disable:max-func-body-length

public registerDataScienceTypes(

useCustomEditor: boolean = false,

languageServerType: LanguageServerType = LanguageServerType.Microsoft

) {

// Save our language server type

this.languageServerType = languageServerType;

// Inform the cacheable locator service to use a static map so that it stays in memory in between tests

CacheableLocatorPromiseCache.forceUseStatic();

// Do the same thing for the environment variable activation service.

EnvironmentActivationServiceCache.forceUseStatic();

// Make sure the default python path is set.

this.defaultPythonPath = this.findPythonPath();

// Create the workspace service first as it's used to set config values.

this.createWorkspaceService();

// Setup our webpanel provider to create our dummy web panel

when(this.webPanelProvider.create(anything())).thenCall(this.onCreateWebPanel.bind(this));

if (this.uiTest) {

this.serviceManager.addSingleton<IWebPanelProvider>(IWebPanelProvider, WebBrowserPanelProvider);

this.serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, IPyWidgetScriptSource);

this.serviceManager.addSingleton<IHttpClient>(IHttpClient, HttpClient);

} else {

this.serviceManager.addSingletonInstance<IWebPanelProvider>(

IWebPanelProvider,

instance(this.webPanelProvider)

);

}

this.registerFileSystemTypes();

this.serviceManager.rebindInstance<IFileSystem>(IFileSystem, new MockFileSystem());

this.serviceManager.addSingleton<IJupyterExecution>(IJupyterExecution, JupyterExecutionFactory);

this.serviceManager.addSingleton<IInteractiveWindowProvider>(

IInteractiveWindowProvider,

TestInteractiveWindowProvider

);

this.serviceManager.addSingletonInstance(UseProposedApi, false);

this.serviceManager.addSingletonInstance(UseCustomEditorApi, useCustomEditor);

this.serviceManager.addSingleton<IDataViewerFactory>(IDataViewerFactory, DataViewerFactory);

this.serviceManager.add<IJupyterVariableDataProvider>(

IJupyterVariableDataProvider,

JupyterVariableDataProvider

);

this.serviceManager.addSingleton<IJupyterVariableDataProviderFactory>(

IJupyterVariableDataProviderFactory,

JupyterVariableDataProviderFactory

);

this.serviceManager.addSingleton<IPlotViewerProvider>(IPlotViewerProvider, PlotViewerProvider);

this.serviceManager.add<IInteractiveWindow>(IInteractiveWindow, InteractiveWindow);

this.serviceManager.add<IDataViewer>(IDataViewer, DataViewer);

this.serviceManager.add<IPlotViewer>(IPlotViewer, PlotViewer);

this.serviceManager.add<IStartPage>(IStartPage, StartPage);

this.serviceManager.addSingleton<IExperimentService>(IExperimentService, ExperimentService);

this.serviceManager.addSingleton<IApplicationEnvironment>(IApplicationEnvironment, ApplicationEnvironment);

this.serviceManager.add<INotebookImporter>(INotebookImporter, JupyterImporter);

this.serviceManager.add<INotebookExporter>(INotebookExporter, JupyterExporter);

this.serviceManager.addSingleton<ILiveShareApi>(ILiveShareApi, MockLiveShareApi);

this.serviceManager.addSingleton<IExtensions>(IExtensions, MockExtensions);

this.serviceManager.add<INotebookServer>(INotebookServer, JupyterServerWrapper);

this.serviceManager.add<IJupyterCommandFactory>(IJupyterCommandFactory, JupyterCommandFactory);

this.serviceManager.addSingleton<IRawNotebookProvider>(IRawNotebookProvider, RawNotebookProviderWrapper);

this.serviceManager.addSingleton<IRawNotebookSupportedService>(

IRawNotebookSupportedService,

RawNotebookSupportedService

);

this.serviceManager.addSingleton<IThemeFinder>(IThemeFinder, ThemeFinder);

this.serviceManager.addSingleton<ICodeCssGenerator>(ICodeCssGenerator, CodeCssGenerator);

this.serviceManager.addSingleton<IStatusProvider>(IStatusProvider, StatusProvider);

this.serviceManager.addSingleton<IInterpreterPathService>(IInterpreterPathService, InterpreterPathService);

this.serviceManager.addSingleton<IBrowserService>(IBrowserService, BrowserService);

this.serviceManager.addSingletonInstance<IAsyncDisposableRegistry>(

IAsyncDisposableRegistry,

this.asyncRegistry

);

this.serviceManager.addSingleton<IEnvironmentActivationService>(

IEnvironmentActivationService,

EnvironmentActivationService

);

this.serviceManager.add<ICodeWatcher>(ICodeWatcher, CodeWatcher);

this.serviceManager.add<IDataScienceCodeLensProvider>(

IDataScienceCodeLensProvider,

DataScienceCodeLensProvider

);

this.serviceManager.add<ICodeExecutionHelper>(ICodeExecutionHelper, CodeExecutionHelper);

this.serviceManager.add<IDataScienceCommandListener>(

IDataScienceCommandListener,

InteractiveWindowCommandListener

);

this.serviceManager.addSingleton<IDataScienceErrorHandler>(IDataScienceErrorHandler, DataScienceErrorHandler);

this.serviceManager.add<IInstallationChannelManager>(IInstallationChannelManager, InstallationChannelManager);

this.serviceManager.addSingleton<IExtensionSingleActivationService>(

IExtensionSingleActivationService,

DebuggerVariableRegistration

);

this.serviceManager.addSingleton<IJupyterVariables>(

IJupyterVariables,

JupyterVariables,

Identifiers.ALL_VARIABLES

);

this.serviceManager.addSingleton<IJupyterVariables>(

IJupyterVariables,

OldJupyterVariables,

Identifiers.OLD_VARIABLES

);

this.serviceManager.addSingleton<IJupyterVariables>(

IJupyterVariables,

KernelVariables,

Identifiers.KERNEL_VARIABLES

);

this.serviceManager.addSingleton<IJupyterVariables>(

IJupyterVariables,

DebuggerVariables,

Identifiers.DEBUGGER_VARIABLES

);

this.serviceManager.addSingleton<IJupyterDebugger>(IJupyterDebugger, JupyterDebugger, undefined, [

ICellHashListener

]);

this.serviceManager.addSingleton<IDebugLocationTracker>(IDebugLocationTracker, DebugLocationTrackerFactory);

this.serviceManager.addSingleton<INotebookEditorProvider>(INotebookEditorProvider, TestNativeEditorProvider);

this.serviceManager.addSingleton<DataViewerDependencyService>(

DataViewerDependencyService,

DataViewerDependencyService

);

this.serviceManager.add<INotebookEditor>(

INotebookEditor,

useCustomEditor ? NativeEditor : NativeEditorOldWebView

);

this.serviceManager.addSingleton<IDataScienceCommandListener>(

IDataScienceCommandListener,

NativeEditorCommandListener

);

this.serviceManager.addSingletonInstance<IOutputChannel>(

IOutputChannel,

mock(MockOutputChannel),

JUPYTER_OUTPUT_CHANNEL

);

this.serviceManager.addSingleton<ICryptoUtils>(ICryptoUtils, CryptoUtils);

this.serviceManager.addSingleton<IExtensionSingleActivationService>(

IExtensionSingleActivationService,

ServerPreload

);

const mockExtensionContext = TypeMoq.Mock.ofType<IExtensionContext>();

mockExtensionContext.setup((m) => m.globalStoragePath).returns(() => os.tmpdir());

mockExtensionContext.setup((m) => m.extensionPath).returns(() => this.extensionRootPath || os.tmpdir());

this.serviceManager.addSingletonInstance<IExtensionContext>(IExtensionContext, mockExtensionContext.object);

const mockServerSelector = mock(JupyterServerSelector);

this.serviceManager.addSingletonInstance<JupyterServerSelector>(

JupyterServerSelector,

instance(mockServerSelector)

);

this.serviceManager.addSingleton<ITerminalHelper>(ITerminalHelper, TerminalHelper);

this.serviceManager.addSingleton<ITerminalActivationCommandProvider>(

ITerminalActivationCommandProvider,

Bash,

TerminalActivationProviders.bashCShellFish

);

this.serviceManager.addSingleton<ITerminalActivationCommandProvider>(

ITerminalActivationCommandProvider,

CommandPromptAndPowerShell,

TerminalActivationProviders.commandPromptAndPowerShell

);

this.serviceManager.addSingleton<ITerminalActivationCommandProvider>(

ITerminalActivationCommandProvider,

PyEnvActivationCommandProvider,

TerminalActivationProviders.pyenv

);

this.serviceManager.addSingleton<ITerminalActivationCommandProvider>(

ITerminalActivationCommandProvider,

CondaActivationCommandProvider,

TerminalActivationProviders.conda

);

this.serviceManager.addSingleton<ITerminalActivationCommandProvider>(

ITerminalActivationCommandProvider,

PipEnvActivationCommandProvider,

TerminalActivationProviders.pipenv

);

this.serviceManager.addSingleton<ITerminalManager>(ITerminalManager, TerminalManager);

this.serviceManager.addSingleton<ILanguageServerProxy>(ILanguageServerProxy, MockLanguageServerProxy);

this.serviceManager.addSingleton<ILanguageServerCache>(

ILanguageServerCache,

LanguageServerExtensionActivationService

);

this.serviceManager.addSingleton<ILanguageServerExtension>(ILanguageServerExtension, LanguageServerExtension);

this.serviceManager.add<ILanguageServerActivator>(

ILanguageServerActivator,

JediExtensionActivator,

LanguageServerType.Jedi

);

this.serviceManager.addSingleton<ILanguageServerAnalysisOptions>(

ILanguageServerAnalysisOptions,

MockLanguageServerAnalysisOptions

);

if (languageServerType === LanguageServerType.Microsoft) {

this.serviceManager.add<ILanguageServerActivator>(

ILanguageServerActivator,

DotNetLanguageServerActivator,

LanguageServerType.Microsoft

);

this.serviceManager.add<ILanguageServerManager>(ILanguageServerManager, DotNetLanguageServerManager);

} else if (languageServerType === LanguageServerType.Node) {

this.serviceManager.add<ILanguageServerActivator>(

ILanguageServerActivator,

NodeLanguageServerActivator,

LanguageServerType.Node

);

this.serviceManager.add<ILanguageServerManager>(ILanguageServerManager, NodeLanguageServerManager);

}

this.serviceManager.addSingleton<INotebookProvider>(INotebookProvider, NotebookProvider);

this.serviceManager.addSingleton<IJupyterNotebookProvider>(IJupyterNotebookProvider, JupyterNotebookProvider);

this.serviceManager.addSingleton<IJupyterServerProvider>(IJupyterServerProvider, NotebookServerProvider);

this.serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, IntellisenseProvider);

this.serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, AutoSaveService);

this.serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, GatherListener);

this.serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, NativeEditorRunByLineListener);

this.serviceManager.addSingleton<IPyWidgetMessageDispatcherFactory>(

IPyWidgetMessageDispatcherFactory,

IPyWidgetMessageDispatcherFactory

);

if (this.uiTest) {

this.serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, IPyWidgetHandler);

}

this.serviceManager.add<IProtocolParser>(IProtocolParser, ProtocolParser);

this.serviceManager.addSingleton<IJupyterDebugService>(

IJupyterDebugService,

JupyterDebugService,

Identifiers.RUN_BY_LINE_DEBUGSERVICE

);

const mockDebugService = new MockDebuggerService(

this.serviceManager.get<IJupyterDebugService>(IJupyterDebugService, Identifiers.RUN_BY_LINE_DEBUGSERVICE)

);

this.serviceManager.addSingletonInstance<IDebugService>(IDebugService, mockDebugService);

this.serviceManager.addSingletonInstance<IJupyterDebugService>(

IJupyterDebugService,

mockDebugService,

Identifiers.MULTIPLEXING_DEBUGSERVICE

);

this.serviceManager.add<ICellHashProvider>(ICellHashProvider, CellHashProvider, undefined, [

INotebookExecutionLogger

]);

this.serviceManager.add<INotebookExecutionLogger>(INotebookExecutionLogger, HoverProvider);

this.serviceManager.add<IGatherProvider>(IGatherProvider, GatherProvider);

this.serviceManager.add<IGatherLogger>(IGatherLogger, GatherLogger, undefined, [INotebookExecutionLogger]);

this.serviceManager.add<INotebookExecutionLogger>(INotebookExecutionLogger, TestExecutionLogger);

this.serviceManager.addSingleton<ICodeLensFactory>(ICodeLensFactory, CodeLensFactory, undefined, [

IInteractiveWindowListener

]);

this.serviceManager.addSingleton<IShellDetector>(IShellDetector, TerminalNameShellDetector);

this.serviceManager.addSingleton<IDiagnosticsService>(

IDiagnosticsService,

LSNotSupportedDiagnosticService,

LSNotSupportedDiagnosticServiceId

);

this.serviceManager.addSingleton<ILanguageServerCompatibilityService>(

ILanguageServerCompatibilityService,

LanguageServerCompatibilityService

);

this.serviceManager.addSingleton<IDiagnosticHandlerService<MessageCommandPrompt>>(

IDiagnosticHandlerService,

DiagnosticCommandPromptHandlerService,

DiagnosticCommandPromptHandlerServiceId

);

this.serviceManager.addSingleton<IDiagnosticFilterService>(IDiagnosticFilterService, DiagnosticFilterService);

this.serviceManager.addSingleton<NotebookStarter>(NotebookStarter, NotebookStarter);

this.serviceManager.addSingleton<KernelSelector>(KernelSelector, KernelSelector);

this.serviceManager.addSingleton<KernelSelectionProvider>(KernelSelectionProvider, KernelSelectionProvider);

this.serviceManager.addSingleton<KernelSwitcher>(KernelSwitcher, KernelSwitcher);

this.serviceManager.addSingleton<IKernelDependencyService>(IKernelDependencyService, KernelDependencyService);

this.serviceManager.addSingleton<INotebookAndInteractiveWindowUsageTracker>(

INotebookAndInteractiveWindowUsageTracker,

NotebookAndInteractiveWindowUsageTracker

);

this.serviceManager.addSingleton<IProductService>(IProductService, ProductService);

this.serviceManager.addSingleton<KernelDaemonPool>(KernelDaemonPool, KernelDaemonPool);

this.serviceManager.addSingleton<KernelDaemonPreWarmer>(KernelDaemonPreWarmer, KernelDaemonPreWarmer);

this.serviceManager.addSingleton<IVSCodeNotebook>(IVSCodeNotebook, VSCodeNotebook);

this.serviceManager.addSingleton<IProductPathService>(

IProductPathService,

CTagsProductPathService,

ProductType.WorkspaceSymbols

);

this.serviceManager.addSingleton<IProductPathService>(

IProductPathService,

FormatterProductPathService,

ProductType.Formatter

);

this.serviceManager.addSingleton<IProductPathService>(

IProductPathService,

LinterProductPathService,

ProductType.Linter

);

this.serviceManager.addSingleton<IProductPathService>(

IProductPathService,

TestFrameworkProductPathService,

ProductType.TestFramework

);

this.serviceManager.addSingleton<IProductPathService>(

IProductPathService,

RefactoringLibraryProductPathService,

ProductType.RefactoringLibrary

);

this.serviceManager.addSingleton<IProductPathService>(

IProductPathService,

DataScienceProductPathService,

ProductType.DataScience

);

this.serviceManager.addSingleton<IMultiStepInputFactory>(IMultiStepInputFactory, MultiStepInputFactory);

// No need of reporting progress.

const progressReporter = mock(ProgressReporter);

when(progressReporter.createProgressIndicator(anything())).thenReturn({

dispose: noop,

token: new CancellationTokenSource().token

});

this.serviceManager.addSingletonInstance<ProgressReporter>(ProgressReporter, instance(progressReporter));

// Don't check for dot net compatibility

const dotNetCompability = mock(DotNetCompatibilityService);

when(dotNetCompability.isSupported()).thenResolve(true);

this.serviceManager.addSingletonInstance<IDotNetCompatibilityService>(

IDotNetCompatibilityService,

instance(dotNetCompability)

);

// Don't allow a banner to show up

const extensionBanner = mock(LanguageServerSurveyBanner);

this.serviceManager.addSingletonInstance<IPythonExtensionBanner>(

IPythonExtensionBanner,

instance(extensionBanner),

BANNER_NAME_LS_SURVEY

);

// Don't allow the download to happen

const downloader = mock(LanguageServerDownloader);

this.serviceManager.addSingletonInstance<ILanguageServerDownloader>(

ILanguageServerDownloader,

instance(downloader)

);

const folderService = mock(DotNetLanguageServerFolderService);

const packageService = mock(DotNetLanguageServerPackageService);

this.serviceManager.addSingletonInstance<ILanguageServerFolderService>(

ILanguageServerFolderService,

instance(folderService)

);

this.serviceManager.addSingletonInstance<ILanguageServerPackageService>(

ILanguageServerPackageService,

instance(packageService)

);

// Turn off experiments.

const experimentManager = mock(ExperimentsManager);

when(experimentManager.inExperiment(anything())).thenCall((exp) => {

const setState = this.experimentState.get(exp);

if (setState === undefined) {

// Default to true if not the zmq kernel

return exp !== LocalZMQKernel.experiment;

}

return setState;

});

when(experimentManager.activate()).thenResolve();

this.serviceManager.addSingletonInstance<IExperimentsManager>(IExperimentsManager, instance(experimentManager));

// Setup our command list

this.commandManager.registerCommand('setContext', (name: string, value: boolean) => {

this.setContexts[name] = value;

this.contextSetEvent.fire({ name: name, value: value });

});

this.serviceManager.addSingletonInstance<ICommandManager>(ICommandManager, this.commandManager);

// Mock the app shell

const appShell = (this.applicationShell = TypeMoq.Mock.ofType<IApplicationShell>());

const configurationService = TypeMoq.Mock.ofType<IConfigurationService>();

configurationService.setup((c) => c.getSettings(TypeMoq.It.isAny())).returns(this.getSettings.bind(this));

this.serviceManager.addSingleton<IEnvironmentVariablesProvider>(

IEnvironmentVariablesProvider,

EnvironmentVariablesProvider

);

this.serviceManager.addSingletonInstance<IApplicationShell>(IApplicationShell, appShell.object);

this.serviceManager.addSingleton<IClipboard>(IClipboard, ClipboardService);

this.serviceManager.addSingletonInstance<IDocumentManager>(IDocumentManager, this.documentManager);

this.serviceManager.addSingletonInstance<IConfigurationService>(

IConfigurationService,

configurationService.object

);

const startTime = Date.now();

this.datascience = TypeMoq.Mock.ofType<IDataScience>();

this.datascience.setup((d) => d.activationStartTime).returns(() => startTime);

this.serviceManager.addSingletonInstance<IDataScience>(IDataScience, this.datascience.object);

this.serviceManager.addSingleton<IBufferDecoder>(IBufferDecoder, BufferDecoder);

this.serviceManager.addSingleton<IEnvironmentVariablesService>(

IEnvironmentVariablesService,

EnvironmentVariablesService

);

this.serviceManager.addSingleton<IPathUtils>(IPathUtils, PathUtils);

this.serviceManager.addSingletonInstance<boolean>(IsWindows, IS_WINDOWS);

const globalStorage = this.serviceManager.get<Memento>(IMemento, GLOBAL_MEMENTO);

const localStorage = this.serviceManager.get<Memento>(IMemento, WORKSPACE_MEMENTO);

// Create a custom persistent state factory that remembers specific things between tests

this.serviceManager.addSingletonInstance<IPersistentStateFactory>(

IPersistentStateFactory,

new TestPersistentStateFactory(globalStorage, localStorage)

);

const currentProcess = new CurrentProcess();

this.serviceManager.addSingletonInstance<ICurrentProcess>(ICurrentProcess, currentProcess);

this.serviceManager.addSingleton<IRegistry>(IRegistry, RegistryImplementation);

this.serviceManager.addSingleton<JupyterInterpreterStateStore>(