fix: build & test

Author: karthiknadig

src/managers/conda/condaEnvManager.ts

@@ -38,6 +38,8 @@ import { createDeferred, Deferred } from '../../common/utils/deferred';
 import { withProgress } from '../../common/window.apis';
 import { CondaStrings } from '../../common/localize';
 import { showErrorMessage } from '../../common/errors/utils';
+import { isWindows } from '../common/utils';
+import { normalizePath } from '../../common/utils/pathUtils';
 
 export class CondaEnvManager implements EnvironmentManager, Disposable {
     private collection: PythonEnvironment[] = [];
@@ -74,6 +76,16 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
         this.disposablesMap.forEach((d) => d.dispose());
     }
 
+    private setFsPathToEnv(fsPath: string, environment: PythonEnvironment): void {
+        this.fsPathToEnv.set(isWindows() ? normalizePath(fsPath) : fsPath, environment);
+    }
+    private getFsPathToEnv(fsPath: string): PythonEnvironment | undefined {
+        return this.fsPathToEnv.get(isWindows() ? normalizePath(fsPath) : fsPath);
+    }
+    private deleteFsPathToEnv(fsPath: string): void {
+        this.fsPathToEnv.delete(isWindows() ? normalizePath(fsPath) : fsPath);
+    }
+
     private _initialized: Deferred<void> | undefined;
     async initialize(): Promise<void> {
         if (this._initialized) {
@@ -174,7 +186,7 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
                             this.collection = this.collection.filter((env) => env.envId.id !== result?.envId.id);
                             Array.from(this.fsPathToEnv.entries())
                                 .filter(([, env]) => env.envId.id === result?.envId.id)
-                                .forEach(([uri]) => this.fsPathToEnv.delete(uri));
+                                .forEach(([uri]) => this.deleteFsPathToEnv(uri));
                             this.disposablesMap.delete(result.envId.id);
                         }
                     }),
@@ -236,13 +248,13 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
     async get(scope: GetEnvironmentScope): Promise<PythonEnvironment | undefined> {
         await this.initialize();
         if (scope instanceof Uri) {
-            let env = this.fsPathToEnv.get(scope.fsPath);
+            let env = this.getFsPathToEnv(scope.fsPath);
             if (env) {
                 return env;
             }
             const project = this.api.getPythonProject(scope);
             if (project) {
-                env = this.fsPathToEnv.get(project.uri.fsPath);
+                env = this.getFsPathToEnv(project.uri.fsPath);
                 if (env) {
                     return env;
                 }
@@ -260,9 +272,9 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
             const fsPath = folder?.uri?.fsPath ?? scope.fsPath;
             if (fsPath) {
                 if (environment) {
-                    this.fsPathToEnv.set(fsPath, environment);
+                    this.setFsPathToEnv(fsPath, environment);
                 } else {
-                    this.fsPathToEnv.delete(fsPath);
+                    this.deleteFsPathToEnv(fsPath);
                 }
                 await setCondaForWorkspace(fsPath, environment?.environmentPath.fsPath);
             }
@@ -278,11 +290,11 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
 
             const before: Map<string, PythonEnvironment | undefined> = new Map();
             projects.forEach((p) => {
-                before.set(p.uri.fsPath, this.fsPathToEnv.get(p.uri.fsPath));
+                before.set(p.uri.fsPath, this.getFsPathToEnv(p.uri.fsPath));
                 if (environment) {
-                    this.fsPathToEnv.set(p.uri.fsPath, environment);
+                    this.setFsPathToEnv(p.uri.fsPath, environment);
                 } else {
-                    this.fsPathToEnv.delete(p.uri.fsPath);
+                    this.deleteFsPathToEnv(p.uri.fsPath);
                 }
             });
 
@@ -371,14 +383,14 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
                 const found = this.findEnvironmentByPath(env);
 
                 if (found) {
-                    this.fsPathToEnv.set(p, found);
+                    this.setFsPathToEnv(p, found);
                 } else {
                     // If not found, resolve the conda path. Could be portable conda.
                     const resolved = await resolveCondaPath(env, this.nativeFinder, this.api, this.log, this);
 
                     if (resolved) {
                         // If resolved add it to the collection
-                        this.fsPathToEnv.set(p, resolved);
+                        this.setFsPathToEnv(p, resolved);
                         this.collection.push(resolved);
                     } else {
                         this.log.error(`Failed to resolve conda environment: ${env}`);
@@ -388,7 +400,7 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
                 // If there is not an environment already assigned by user to this project
                 // then see if there is one in the collection
                 if (pathSorted.length === 1) {
-                    this.fsPathToEnv.set(p, pathSorted[0]);
+                    this.setFsPathToEnv(p, pathSorted[0]);
                 } else {
                     // If there is more than one environment then we need to check if the project
                     // is a subfolder of one of the environments
@@ -397,7 +409,7 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
                         return t && path.normalize(t) === p;
                     });
                     if (found) {
-                        this.fsPathToEnv.set(p, found);
+                        this.setFsPathToEnv(p, found);
                     }
                 }
             }
@@ -406,15 +418,15 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
 
     private fromEnvMap(uri: Uri): PythonEnvironment | undefined {
         // Find environment directly using the URI mapping
-        const env = this.fsPathToEnv.get(uri.fsPath);
+        const env = this.getFsPathToEnv(uri.fsPath);
         if (env) {
             return env;
         }
 
         // Find environment using the Python project for the Uri
         const project = this.api.getPythonProject(uri);
         if (project) {
-            return this.fsPathToEnv.get(project.uri.fsPath);
+            return this.getFsPathToEnv(project.uri.fsPath);
         }
 
         return undefined;

src/test/common/pathUtils.unit.test.ts

@@ -5,15 +5,6 @@ import { getResourceUri, normalizePath } from '../../common/utils/pathUtils';
 import * as utils from '../../managers/common/utils';
 
 suite('Path Utilities', () => {
-    let isWindowsStub: sinon.SinonStub;
-
-    setup(() => {
-        isWindowsStub = sinon.stub(utils, 'isWindows');
-    });
-
-    teardown(() => {
-        sinon.restore();
-    });
     suite('getResourceUri', () => {
         const testRoot = process.cwd();
 
@@ -36,13 +27,16 @@ suite('Path Utilities', () => {
             assert.strictEqual(result?.path, testPath);
         });
 
-        test('creates file URI from Windows path', () => {
+        test('creates file URI from Windows path', function () {
+            if (!utils.isWindows()) {
+                this.skip();
+            }
             const testPath = 'C:\\path\\to\\file.txt';
             const result = getResourceUri(testPath, testRoot);
 
             assert.ok(result instanceof Uri);
             assert.strictEqual(result?.scheme, 'file');
-            assert.strictEqual(result?.path, 'C:/path/to/file.txt');
+            assert.strictEqual(result?.path, '/C:/path/to/file.txt');
         });
 
         test('parses existing URI correctly', () => {
@@ -99,6 +93,15 @@ suite('Path Utilities', () => {
     });
 
     suite('normalizePath', () => {
+        let isWindowsStub: sinon.SinonStub;
+
+        setup(() => {
+            isWindowsStub = sinon.stub(utils, 'isWindows');
+        });
+
+        teardown(() => {
+            sinon.restore();
+        });
         test('replaces backslashes with forward slashes', () => {
             const testPath = 'C:\\path\\to\\file.txt';
             const result = normalizePath(testPath);