Fix interpreter tests

.eslintrc.js

@@ -723,7 +723,6 @@ module.exports = {
         'src/client/datascience/jupyter/interpreter/jupyterInterpreterSelectionCommand.ts',
         'src/client/datascience/jupyter/interpreter/jupyterInterpreterOldCacheStateStore.ts',
         'src/client/datascience/jupyter/interpreter/jupyterInterpreterSelector.ts',
-        'src/client/datascience/jupyter/interpreter/jupyterInterpreterService.ts',
         'src/client/datascience/jupyter/commandLineSelector.ts',
         'src/client/datascience/jupyter/jupyterConnection.ts',
         'src/client/datascience/jupyter/jupyterPasswordConnect.ts',

.github/actions/create-venv-for-tests/action.yml

@@ -21,13 +21,17 @@ runs:
 
         python -m venv .venvkernel
         source .venvkernel/bin/activate
+        python --version
+        python -c "import sys;print(sys.executable)"
         python -m pip install ipykernel
         python -m ipykernel install --user --name .venvkernel --display-name .venvkernel
         python -m pip uninstall jedi --yes
         python -m pip install jedi==0.17.2
 
         python -m venv .venvnokernel
         source .venvnokernel/bin/activate
+        python --version
+        python -c "import sys;print(sys.executable)"
         python -m pip install ipykernel
         python -m ipykernel install --user --name .venvnokernel --display-name .venvnokernel
         python -m pip uninstall jedi --yes

.github/workflows/build-test.yml

@@ -468,6 +468,8 @@ jobs:
       - name: Install Python Libs
         if: env.conda_python == ''
         run: |
+          python --version
+          python -c "import sys;print(sys.executable)"
           python -m pip --disable-pip-version-check install -t ./pythonFiles/lib/python --no-cache-dir --implementation py --no-deps --upgrade -r ./requirements.txt
           python -m pip --disable-pip-version-check install -r build/debugger-install-requirements.txt
           python ./pythonFiles/install_debugpy.py
@@ -556,15 +558,15 @@ jobs:
           check_name: Functional Test Report ${{matrix.os}}
         if: steps.test_functional_group.outcome == 'failure' && failure()
 
-      # Mosts tests are commented, hence nothing runs, thus no coverage (if not commented, CI falls over as this code expects coverage files)
-      # Upload unit test coverage reports for later use in the "reports" job.
-      - name: Upload unit test coverage reports
-        uses: actions/upload-artifact@v2
-        if: "(success() || failure()) && !contains(github.ref, 'refs/heads/release')"
-        with:
-          name: ${{runner.os}}-${{env.COVERAGE_REPORTS}}
-          path: .nyc_output
-          retention-days: 1
+    #   # Mosts tests are commented, hence nothing runs, thus no coverage (if not commented, CI falls over as this code expects coverage files)
+    #   # Upload unit test coverage reports for later use in the "reports" job.
+    #   - name: Upload unit test coverage reports
+    #     uses: actions/upload-artifact@v2
+    #     if: "(success() || failure()) && !contains(github.ref, 'refs/heads/release')"
+    #     with:
+    #       name: ${{runner.os}}-${{env.COVERAGE_REPORTS}}
+    #       path: .nyc_output
+    #       retention-days: 1
 
   vscodeTests:
     name: VS Code Tests # These tests run with Python extension & real Jupyter
@@ -734,6 +736,8 @@ jobs:
       - name: Install Python Libs
         if: matrix.python != 'conda' && matrix.python != 'noPython'
         run: |
+          python --version
+          python -c "import sys;print(sys.executable)"
           python -m pip --disable-pip-version-check install -t ./pythonFiles/lib/python --no-cache-dir --implementation py --no-deps --upgrade -r ./requirements.txt
           python -m pip --disable-pip-version-check install -r build/debugger-install-requirements.txt
           python ./pythonFiles/install_debugpy.py

src/client/api/pythonApi.ts

@@ -14,9 +14,11 @@
 import { inject, injectable, named } from 'inversify';
 import { CancellationToken, Disposable, Event, EventEmitter, Memento, Uri } from 'vscode';
 import { IApplicationShell, ICommandManager, IWorkspaceService } from '../common/application/types';
+import { isCI } from '../common/constants';
 import { trackPackageInstalledIntoInterpreter } from '../common/installer/productInstaller';
 import { ProductNames } from '../common/installer/productNames';
 import { InterpreterUri } from '../common/installer/types';
+import { traceInfo, traceInfoIf } from '../common/logger';
 import {
     GLOBAL_MEMENTO,
     IDisposableRegistry,
@@ -119,6 +121,7 @@ export class PythonApiProvider implements IPythonApiProvider {
         this.hooksRegistered = true;
         if (!pythonExtension.isActive) {
             await pythonExtension.activate();
+            traceInfoIf(isCI, 'Python extension Activated');
             this.didActivatePython.fire();
         }
         pythonExtension.exports.jupyter.registerHooks();
@@ -313,6 +316,8 @@ export class InterpreterSelector implements IInterpreterSelector {
         return this.apiProvider.getApi().then((api) => api.getSuggestions(resource));
     }
 }
+
+const interpreterCacheForCI = new Map<string, PythonEnvironment[]>();
 // eslint-disable-next-line max-classes-per-file
 @injectable()
 export class InterpreterService implements IInterpreterService {
@@ -344,12 +349,36 @@ export class InterpreterService implements IInterpreterService {
 
     @captureTelemetry(Telemetry.InterpreterListingPerf)
     public getInterpreters(resource?: Uri): Promise<PythonEnvironment[]> {
+        // Ensure resource is not undefined, Because of https://github.com/microsoft/vscode-jupyter/issues/7440
+        resource =
+            (this.workspace.workspaceFolders?.length || 0) > 0 ? this.workspace.workspaceFolders![0].uri : undefined;
         this.hookupOnDidChangeInterpreterEvent();
-        return this.apiProvider.getApi().then((api) => api.getInterpreters(resource));
+        const promise = this.apiProvider.getApi().then((api) => api.getInterpreters(resource));
+        if (isCI) {
+            promise
+                .then((items) => {
+                    const current = interpreterCacheForCI.get(resource?.toString() || '');
+                    const itemToStore = items;
+                    if (
+                        current &&
+                        (itemToStore === current || JSON.stringify(itemToStore) === JSON.stringify(current))
+                    ) {
+                        return;
+                    }
+                    interpreterCacheForCI.set(resource?.toString() || '', itemToStore);
+                    traceInfo(`Interpreter list for ${resource?.toString()} is ${JSON.stringify(items)}`);
+                })
+                .catch(noop);
+        }
+        return promise;
     }
     private workspaceCachedActiveInterpreter = new Map<string, Promise<PythonEnvironment | undefined>>();
     @captureTelemetry(Telemetry.ActiveInterpreterListingPerf)
     public getActiveInterpreter(resource?: Uri): Promise<PythonEnvironment | undefined> {
+        // Ensure resource is not undefined, Because of https://github.com/microsoft/vscode-jupyter/issues/7440
+        resource =
+            (this.workspace.workspaceFolders?.length || 0) > 0 ? this.workspace.workspaceFolders![0].uri : undefined;
+        traceInfoIf(isCI, `getActiveInterpreter in Python API for ${resource?.toString()}`);
         this.hookupOnDidChangeInterpreterEvent();
         const workspaceId = this.workspace.getWorkspaceFolderIdentifier(resource);
         let promise = this.workspaceCachedActiveInterpreter.get(workspaceId);
@@ -364,6 +393,13 @@ export class InterpreterService implements IInterpreterService {
                         this.workspaceCachedActiveInterpreter.delete(workspaceId);
                     }
                 });
+                if (isCI) {
+                    promise
+                        .then((item) =>
+                            traceInfo(`Active Interpreter in Python API for ${resource?.toString()} is ${item?.path}`)
+                        )
+                        .catch(noop);
+                }
             }
         }
         return promise;

src/client/datascience/export/exportInterpreterFinder.ts

@@ -1,4 +1,6 @@
 import { inject, injectable } from 'inversify';
+import { isCI } from '../../common/constants';
+import { traceInfoIf } from '../../common/logger';
 import * as localize from '../../common/utils/localize';
 import { PythonEnvironment } from '../../pythonEnvironments/info';
 import { JupyterInterpreterService } from '../jupyter/interpreter/jupyterInterpreterService';
@@ -33,7 +35,7 @@ export class ExportInterpreterFinder {
 
             // If an interpreter was not passed in, work with the main jupyter interperter
             const selectedJupyterInterpreter = await this.jupyterInterpreterService.getSelectedInterpreter();
-
+            traceInfoIf(isCI, `selectedJupyterInterpreter is ${selectedJupyterInterpreter?.path}`);
             if (selectedJupyterInterpreter) {
                 if (await this.checkNotebookInterpreter(selectedJupyterInterpreter)) {
                     return selectedJupyterInterpreter;

src/client/datascience/jupyter/interpreter/jupyterInterpreterService.ts

@@ -7,7 +7,9 @@ import { inject, injectable } from 'inversify';
 import { Event, EventEmitter } from 'vscode';
 import { CancellationToken } from 'vscode-jsonrpc';
 import { createPromiseFromCancellation } from '../../../common/cancellation';
+import { isCI } from '../../../common/constants';
 import '../../../common/extensions';
+import { traceInfoIf } from '../../../common/logger';
 import { noop } from '../../../common/utils/misc';
 import { IInterpreterService } from '../../../interpreter/contracts';
 import { PythonEnvironment } from '../../../pythonEnvironments/info';
@@ -222,11 +224,16 @@ export class JupyterInterpreterService {
         // Nothing saved found, so check our current interpreter
         if (!interpreter) {
             const currentInterpreter = await this.interpreterService.getActiveInterpreter(undefined);
-
+            traceInfoIf(isCI, `Active Interpreter in JupyterInterpreterService is ${currentInterpreter?.path}`);
             if (currentInterpreter) {
                 // If the current active interpreter has everything installed already just use that
                 if (await this.interpreterConfiguration.areDependenciesInstalled(currentInterpreter, token)) {
                     interpreter = currentInterpreter;
+                } else {
+                    traceInfoIf(
+                        isCI,
+                        `Dependencies not installed in ${currentInterpreter?.path} (JupyterInterpreterService)`
+                    );
                 }
             }
         }