Fixes

Author: DonJayamanne

src/client/common/utils/cacheUtils.ts

@@ -78,27 +78,15 @@ export function clearCache() {
     resourceSpecificCacheStores.clear();
 }
 
-export class InMemoryInterpreterSpecificCache<T> {
-    private readonly resource: Resource;
-    private readonly args: any[];
-    constructor(
-        private readonly keyPrefix: string,
-        protected readonly expiryDurationMs: number,
-        args: [Uri | undefined, ...any[]],
-        private readonly vscode: VSCodeType = require('vscode')
-    ) {
-        this.resource = args[0];
-        this.args = args.slice(1);
+export class InMemoryCache<T> {
+    private readonly _store = new Map<string, CacheData>();
+    protected get store(): Map<string, CacheData> {
+        return this._store;
     }
+    constructor(protected readonly expiryDurationMs: number, protected readonly cacheKey: string = '') {}
     public get hasData() {
-        const store = getCacheStore(this.resource, this.vscode);
-        const key = getCacheKeyFromFunctionArgs(this.keyPrefix, this.args);
-        const data = store.get(key);
-        if (!store.has(key) || !data) {
-            return false;
-        }
-        if (this.hasExpired(data.expiry)) {
-            store.delete(key);
+        if (!this.store.get(this.cacheKey) || this.hasExpired(this.store.get(this.cacheKey)!.expiry)) {
+            this.store.delete(this.cacheKey);
             return false;
         }
         return true;
@@ -107,33 +95,24 @@ export class InMemoryInterpreterSpecificCache<T> {
      * Returns undefined if there is no data.
      * Uses `hasData` to determine whether any cached data exists.
      *
+     * @readonly
      * @type {(T | undefined)}
-     * @memberof InMemoryInterpreterSpecificCache
+     * @memberof InMemoryCache
      */
     public get data(): T | undefined {
-        if (!this.hasData) {
+        if (!this.hasData || !this.store.has(this.cacheKey)) {
             return;
         }
-        const store = getCacheStore(this.resource, this.vscode);
-        const key = getCacheKeyFromFunctionArgs(this.keyPrefix, this.args);
-        const data = store.get(key);
-        if (!store.has(key) || !data) {
-            return;
-        }
-        return data.value as T;
+        return this.store.get(this.cacheKey)?.value as T;
     }
     public set data(value: T | undefined) {
-        const store = getCacheStore(this.resource, this.vscode);
-        const key = getCacheKeyFromFunctionArgs(this.keyPrefix, this.args);
-        store.set(key, {
+        this.store.set(this.cacheKey, {
             expiry: this.calculateExpiry(),
             value
         });
     }
     public clear() {
-        const store = getCacheStore(this.resource, this.vscode);
-        const key = getCacheKeyFromFunctionArgs(this.keyPrefix, this.args);
-        store.delete(key);
+        this.store.clear();
     }
 
     /**
@@ -144,7 +123,7 @@ export class InMemoryInterpreterSpecificCache<T> {
      * @returns true if the data expired, false otherwise.
      */
     protected hasExpired(expiry: number): boolean {
-        return expiry < Date.now();
+        return expiry <= Date.now();
     }
 
     /**
@@ -158,58 +137,13 @@ export class InMemoryInterpreterSpecificCache<T> {
     }
 }
 
-export class InMemoryCache<T> {
-    private readonly _data: { data?: T; hasData: boolean; expiry?: number } = { hasData: false };
-    constructor(protected readonly expiryDurationMs: number) {}
-    public get hasData() {
-        if (!this._data.hasData || !this._data.expiry || this.hasExpired(this._data.expiry)) {
-            this._data.data = undefined;
-            this._data.expiry = undefined;
-            this._data.hasData = false;
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Returns undefined if there is no data.
-     * Uses `hasData` to determine whether any cached data exists.
-     *
-     * @readonly
-     * @type {(T | undefined)}
-     * @memberof InMemoryCache
-     */
-    public get data(): T | undefined {
-        return this.hasData ? this._data.data : undefined;
-    }
-    public set data(value: T | undefined) {
-        this._data.expiry = this.calculateExpiry();
-        this._data.data = value;
-        this._data.hasData = true;
-    }
-    public clear() {
-        this._data.data = undefined;
-        this._data.expiry = undefined;
-        this._data.hasData = false;
-    }
-
-    /**
-     * Has this data expired?
-     * (protected class member to allow for reliable non-data-time-based testing)
-     *
-     * @param expiry The date to be tested for expiry.
-     * @returns true if the data expired, false otherwise.
-     */
-    protected hasExpired(expiry: number): boolean {
-        return expiry <= Date.now();
+export class InMemoryInterpreterSpecificCache<T> extends InMemoryCache<T> {
+    private readonly resource: Resource;
+    protected get store() {
+        return getCacheStore(this.resource, this.vscode);
     }
-
-    /**
-     * When should this data item expire?
-     * (protected class method to allow for reliable non-data-time-based testing)
-     *
-     * @returns number representing the expiry time for this item.
-     */
-    protected calculateExpiry(): number {
-        return Date.now() + this.expiryDurationMs;
+    constructor(keyPrefix: string, expiryDurationMs: number, args: [Uri | undefined, ...any[]], private readonly vscode: VSCodeType = require('vscode')) {
+        super(expiryDurationMs, getCacheKeyFromFunctionArgs(keyPrefix, args.slice(1)));
+        this.resource = args[0];
     }
 }

src/test/common/utils/cacheUtils.unit.test.ts

@@ -48,6 +48,11 @@ class TestInMemoryInterpreterSpecificCache extends InMemoryInterpreterSpecificCa
 // tslint:disable:no-any max-func-body-length
 suite('Common Utils - CacheUtils', () => {
     suite('InMemory Cache', () => {
+        let clock: sinon.SinonFakeTimers;
+        setup(() => {
+            clock = sinon.useFakeTimers();
+        });
+        teardown(() => clock.restore());
         test('Cached item should exist', () => {
             const cache = new InMemoryCache(5_000);
             cache.data = 'Hello World';
@@ -68,7 +73,6 @@ suite('Common Utils - CacheUtils', () => {
             assert.isOk(cache.hasData);
         });
         test('Cached item should not exist after time expires', () => {
-            const clock = sinon.useFakeTimers();
             const cache = new InMemoryCache(5_000);
             cache.data = 'Hello World';
 

src/test/common/utils/decorators.unit.test.ts

@@ -20,9 +20,8 @@ suite('Common Utils - Decorators', function() {
     // tslint:disable-next-line: no-invalid-this
     this.retries(3);
     suite('Cache', () => {
-        teardown(() => {
-            clearCache();
-        });
+        setup(clearCache);
+        teardown(clearCache);
         function createMockVSC(pythonPath: string): typeof import('vscode') {
             return {
                 workspace: {