Expose currently selected interpreter path using API

news/1 Enhancements/11294.md

@@ -0,0 +1 @@
+Expose currently selected interpreter path using API.

src/client/api.ts

@@ -6,7 +6,7 @@
 import { isTestExecution } from './common/constants';
 import { DebugAdapterNewPtvsd } from './common/experimentGroups';
 import { traceError } from './common/logger';
-import { IExperimentsManager } from './common/types';
+import { IConfigurationService, IExperimentsManager, Resource } from './common/types';
 import { getDebugpyLauncherArgs, getPtvsdLauncherScriptArgs } from './debugger/extension/adapter/remoteLaunchers';
 import { IServiceContainer, IServiceManager } from './ioc/types';
 
@@ -34,15 +34,27 @@ export interface IExtensionApi {
          */
         getRemoteLauncherCommand(host: string, port: number, waitUntilDebuggerAttaches: boolean): Promise<string[]>;
     };
+    /**
+     * Return internal settings within the extension which are stored in VSCode storage
+     */
+    settings: {
+        /**
+         * Return the currently selected interpreter path.
+         * @param {Resource} [resource]
+         * @returns {string}
+         */
+        getInterpreterPath(resource?: Resource): string;
+    };
 }
 
 export function buildApi(
     // tslint:disable-next-line:no-any
     ready: Promise<any>,
     serviceManager: IServiceManager,
     serviceContainer: IServiceContainer
-) {
+): IExtensionApi {
     const experimentsManager = serviceContainer.get<IExperimentsManager>(IExperimentsManager);
+    const configurationService = serviceContainer.get<IConfigurationService>(IConfigurationService);
     const api = {
         // 'ready' will propagate the exception, but we must log it here first.
         ready: ready.catch((ex) => {
@@ -71,6 +83,11 @@ export function buildApi(
                     waitUntilDebuggerAttaches
                 });
             }
+        },
+        settings: {
+            getInterpreterPath(resource?: Resource) {
+                return configurationService.getSettings(resource).pythonPath;
+            }
         }
     };
 

src/test/api.functional.test.ts

@@ -8,15 +8,17 @@
 import { expect } from 'chai';
 import * as path from 'path';
 import { anyString, instance, mock, when } from 'ts-mockito';
+import { Uri } from 'vscode';
 import { buildApi } from '../client/api';
+import { ConfigurationService } from '../client/common/configuration/service';
 import { EXTENSION_ROOT_DIR } from '../client/common/constants';
 import { ExperimentsManager } from '../client/common/experiments';
-import { IExperimentsManager } from '../client/common/types';
+import { IConfigurationService, IExperimentsManager } from '../client/common/types';
 import { ServiceContainer } from '../client/ioc/container';
 import { ServiceManager } from '../client/ioc/serviceManager';
 import { IServiceContainer, IServiceManager } from '../client/ioc/types';
 
-suite('Extension API - Debugger', () => {
+suite('Extension API', () => {
     const expectedLauncherPath = `${EXTENSION_ROOT_DIR.fileToCommandArgument()}/pythonFiles/ptvsd_launcher.py`;
     const ptvsdPath = path.join(EXTENSION_ROOT_DIR, 'pythonFiles', 'lib', 'python', 'debugpy', 'no_wheels', 'debugpy');
     const ptvsdHost = 'somehost';
@@ -25,15 +27,33 @@ suite('Extension API - Debugger', () => {
     let serviceContainer: IServiceContainer;
     let serviceManager: IServiceManager;
     let experimentsManager: IExperimentsManager;
+    let configurationService: IConfigurationService;
 
     setup(() => {
         serviceContainer = mock(ServiceContainer);
         serviceManager = mock(ServiceManager);
         experimentsManager = mock(ExperimentsManager);
+        configurationService = mock(ConfigurationService);
 
+        when(serviceContainer.get<IConfigurationService>(IConfigurationService)).thenReturn(
+            instance(configurationService)
+        );
         when(serviceContainer.get<IExperimentsManager>(IExperimentsManager)).thenReturn(instance(experimentsManager));
     });
 
+    test('Test interpreter path settings API', async () => {
+        const resource = Uri.parse('a');
+        when(configurationService.getSettings(resource)).thenReturn({ pythonPath: 'settingValue' } as any);
+
+        const interpreterPath = buildApi(
+            Promise.resolve(),
+            instance(serviceManager),
+            instance(serviceContainer)
+        ).settings.getInterpreterPath(resource);
+
+        expect(interpreterPath).to.equal('settingValue');
+    });
+
     test('Test debug launcher args (no-wait and not in experiment)', async () => {
         const waitForAttach = false;
         when(experimentsManager.inExperiment(anyString())).thenReturn(false);