getEnv -> filterEnvs

Author: kimadeline

src/client/pythonEnvironments/base/envsCache.ts

@@ -3,7 +3,8 @@
 
 import { cloneDeep } from 'lodash';
 import { getGlobalPersistentStore, IPersistentStore } from '../common/externalDependencies';
-import { areSameEnvironment, PythonEnvInfo } from './info';
+import { PythonEnvInfo } from './info';
+import { areSameEnvironment } from './info/env';
 
 /**
  * Represents the environment info cache to be used by the cache locator.
@@ -29,15 +30,17 @@ export interface IEnvsCache {
     setAllEnvs(envs: PythonEnvInfo[]): void;
 
     /**
-     * Return a specific environmnent info object.
+     * If the cache has been initialized, return environmnent info objects that match a query object.
+     * If none of the environments in the cache match the query data, return an empty array.
+     * If the in-memory cache has not been initialized prior to calling `filterEnvs`, return `undefined`.
      *
      * @param env The environment info data that will be used to look for
-     * an environment info object in the cache, or a unique environment key.
+     * environment info objects in the cache, or a unique environment key.
      * If passing an environment info object, it may contain incomplete environment info.
-     * @return The environment info object that matches all non-undefined keys from the `env` param,
-     *  `undefined` otherwise.
+     * @return The environment info objects matching the `env` param,
+     * or `undefined` if the in-memory cache is not initialized.
      */
-    getEnv(env: PythonEnvInfo | string): PythonEnvInfo | undefined;
+    filterEnvs(env: PythonEnvInfo | string): PythonEnvInfo[] | undefined;
 
     /**
      * Writes the content of the in-memory cache to persistent storage.
@@ -77,8 +80,8 @@ export class PythonEnvInfoCache implements IEnvsCache {
         this.envsList = cloneDeep(envs);
     }
 
-    public getEnv(env: PythonEnvInfo | string): PythonEnvInfo | undefined {
-        const result = this.envsList?.find((info) => areSameEnvironment(info, env));
+    public filterEnvs(env: PythonEnvInfo | string): PythonEnvInfo[] | undefined {
+        const result = this.envsList?.filter((info) => areSameEnvironment(info, env));
 
         if (result) {
             return cloneDeep(result);

src/test/pythonEnvironments/base/envsCache.unit.test.ts

@@ -4,37 +4,38 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
 import { PythonEnvInfoCache } from '../../../client/pythonEnvironments/base/envsCache';
-import * as envInfo from '../../../client/pythonEnvironments/base/info';
+import { PythonEnvInfo, PythonEnvKind } from '../../../client/pythonEnvironments/base/info';
+import * as envInfo from '../../../client/pythonEnvironments/base/info/env';
 import * as externalDependencies from '../../../client/pythonEnvironments/common/externalDependencies';
 
 suite('Environment Info cache', () => {
     let getGlobalPersistentStoreStub: sinon.SinonStub;
     let areSameEnvironmentStub: sinon.SinonStub;
-    let updatedValues: envInfo.PythonEnvInfo[] | undefined;
+    let updatedValues: PythonEnvInfo[] | undefined;
 
     const allEnvsComplete = () => true;
     const envInfoArray = [
         {
-            kind: envInfo.PythonEnvKind.Conda, name: 'my-conda-env', defaultDisplayName: 'env-one',
+            kind: PythonEnvKind.Conda, name: 'my-conda-env', defaultDisplayName: 'env-one',
         },
         {
-            kind: envInfo.PythonEnvKind.Venv, name: 'my-venv-env', defaultDisplayName: 'env-two',
+            kind: PythonEnvKind.Venv, name: 'my-venv-env', defaultDisplayName: 'env-two',
         },
         {
-            kind: envInfo.PythonEnvKind.Pyenv, name: 'my-pyenv-env', defaultDisplayName: 'env-three',
+            kind: PythonEnvKind.Pyenv, name: 'my-pyenv-env', defaultDisplayName: 'env-three',
         },
-    ] as envInfo.PythonEnvInfo[];
+    ] as PythonEnvInfo[];
 
     setup(() => {
         areSameEnvironmentStub = sinon.stub(envInfo, 'areSameEnvironment');
         areSameEnvironmentStub.callsFake(
-            (env1: envInfo.PythonEnvInfo, env2:envInfo.PythonEnvInfo) => env1.name === env2.name,
+            (env1: PythonEnvInfo, env2:PythonEnvInfo) => env1.name === env2.name,
         );
 
         getGlobalPersistentStoreStub = sinon.stub(externalDependencies, 'getGlobalPersistentStore');
         getGlobalPersistentStoreStub.returns({
             get() { return envInfoArray; },
-            set(envs: envInfo.PythonEnvInfo[]) {
+            set(envs: PythonEnvInfo[]) {
                 updatedValues = envs;
                 return Promise.resolve();
             },
@@ -94,54 +95,63 @@ suite('Environment Info cache', () => {
         assert.strictEqual(envs === envInfoArray, false);
     });
 
-    test('`getEnv` should return an environment that matches all non-undefined properties of its argument', () => {
-        const env:envInfo.PythonEnvInfo = { name: 'my-venv-env' } as unknown as envInfo.PythonEnvInfo;
+    test('`filterEnvs` should return environments that match its argument using areSameEnvironmnet', () => {
+        const env:PythonEnvInfo = { name: 'my-venv-env' } as unknown as PythonEnvInfo;
         const envsCache = new PythonEnvInfoCache(allEnvsComplete);
 
         envsCache.initialize();
 
-        const result = envsCache.getEnv(env);
+        const result = envsCache.filterEnvs(env);
 
-        assert.deepStrictEqual(result, {
-            kind: envInfo.PythonEnvKind.Venv, name: 'my-venv-env', defaultDisplayName: 'env-two',
-        });
+        assert.deepStrictEqual(result, [{
+            kind: PythonEnvKind.Venv, name: 'my-venv-env', defaultDisplayName: 'env-two',
+        }]);
     });
 
-    test('`getEnv` should return a deep copy of an environment', () => {
+    test('`filterEnvs` should return a deep copy of the matched environments', () => {
         const envToFind = {
-            kind: envInfo.PythonEnvKind.System, name: 'my-system-env', defaultDisplayName: 'env-system',
-        } as unknown as envInfo.PythonEnvInfo;
-        const env:envInfo.PythonEnvInfo = { name: 'my-system-env' } as unknown as envInfo.PythonEnvInfo;
+            kind: PythonEnvKind.System, name: 'my-system-env', defaultDisplayName: 'env-system',
+        } as unknown as PythonEnvInfo;
+        const env:PythonEnvInfo = { name: 'my-system-env' } as unknown as PythonEnvInfo;
         const envsCache = new PythonEnvInfoCache(allEnvsComplete);
 
         envsCache.setAllEnvs([...envInfoArray, envToFind]);
 
-        const result = envsCache.getEnv(env)!;
-        result.name = 'some-other-name';
+        const result = envsCache.filterEnvs(env)!;
+        result[0].name = 'some-other-name';
 
-        assert.ok(result !== envToFind);
+        assert.notDeepStrictEqual(result[0], envToFind);
     });
 
-    test('`getEnv` should return undefined if no environment matches the properties of its argument', () => {
-        const env:envInfo.PythonEnvInfo = { name: 'my-nonexistent-env' } as unknown as envInfo.PythonEnvInfo;
+    test('`filterEnvs` should return an empty array if no environment matches the properties of its argument', () => {
+        const env:PythonEnvInfo = { name: 'my-nonexistent-env' } as unknown as PythonEnvInfo;
         const envsCache = new PythonEnvInfoCache(allEnvsComplete);
 
         envsCache.initialize();
 
-        const result = envsCache.getEnv(env);
+        const result = envsCache.filterEnvs(env);
+
+        assert.deepStrictEqual(result, []);
+    });
+
+    test('`filterEnvs` should return undefined if the cache hasn\'t been initialized', () => {
+        const env:PythonEnvInfo = { name: 'my-nonexistent-env' } as unknown as PythonEnvInfo;
+        const envsCache = new PythonEnvInfoCache(allEnvsComplete);
+
+        const result = envsCache.filterEnvs(env);
 
         assert.strictEqual(result, undefined);
     });
 
     test('`flush` should write complete environment info objects to persistent storage', async () => {
         const otherEnv = {
-            kind: envInfo.PythonEnvKind.OtherGlobal,
+            kind: PythonEnvKind.OtherGlobal,
             name: 'my-other-env',
             defaultDisplayName: 'env-five',
         };
         const updatedEnvInfoArray = [
-            otherEnv, { kind: envInfo.PythonEnvKind.System, name: 'my-system-env' },
-        ] as envInfo.PythonEnvInfo[];
+            otherEnv, { kind: PythonEnvKind.System, name: 'my-system-env' },
+        ] as PythonEnvInfo[];
         const expected = [
             otherEnv,
         ];
@@ -155,15 +165,15 @@ suite('Environment Info cache', () => {
     });
 
     test('`flush` should not write to persistent storage if there are no environment info objects in-memory', async () => {
-        const envsCache = new PythonEnvInfoCache((env) => env.kind === envInfo.PythonEnvKind.MacDefault);
+        const envsCache = new PythonEnvInfoCache((env) => env.kind === PythonEnvKind.MacDefault);
 
         await envsCache.flush();
 
         assert.strictEqual(updatedValues, undefined);
     });
 
     test('`flush` should not write to persistent storage if there are no complete environment info objects', async () => {
-        const envsCache = new PythonEnvInfoCache((env) => env.kind === envInfo.PythonEnvKind.MacDefault);
+        const envsCache = new PythonEnvInfoCache((env) => env.kind === PythonEnvKind.MacDefault);
 
         envsCache.initialize();
         await envsCache.flush();