Improved getVersion + tests

Author: edriouk

src/json-rpc/csolution-rpc-client.ts

@@ -9,7 +9,7 @@ import * as manifest from '../manifest';
 import { ChildProcess, spawn } from 'node:child_process';
 import { MessageConnection } from 'vscode-jsonrpc';
 import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from 'vscode-jsonrpc/node';
-import { RpcMethods, RpcInterface } from './interface/rpc-interface';
+import { RpcMethods, RpcInterface, GetVersionResult } from './interface/rpc-interface';
 import { constructor } from '../generic/constructor';
 import { Optional } from '../generic/type-helper';
 import { debounce } from 'lodash';
@@ -43,7 +43,7 @@ class CsolutionServiceImpl extends RpcMethods implements CsolutionService {
     private readonly debouncedLoadPacks = debounce(super.loadPacks.bind(this), 1000);
     private csolutionBin = 'csolution';
     private exitPromise: Promise<void> | undefined;
-    private hasReportedVersionForSession = false;
+    private cachedVersion: GetVersionResult = { success: false };
     private readonly mutex: Mutex;
 
     constructor(
@@ -72,22 +72,21 @@ class CsolutionServiceImpl extends RpcMethods implements CsolutionService {
         return (response ?? {}) as TResponse;
     }
 
+    public async getVersion(): Promise<GetVersionResult> {
+        if (!this.cachedVersion.success) {
+            // Query daemon version once per launched session
+            this.cachedVersion = await super.getVersion();
+            console.log('csolution version:', this.cachedVersion);
+        }
+        return this.cachedVersion;
+    }
+
     public async loadPacks() {
         if (this.idxWatcher === undefined) {
             this.watchPackIdxFile();
         }
-
-        // Query daemon version once per launched session right before first LoadPacks.
-        if (!this.hasReportedVersionForSession) {
-            try {
-                const version = await super.getVersion();
-                console.log('csolution version:', version);
-            } catch (error) {
-                console.warn('Unable to query csolution version before loadPacks:', error);
-            } finally {
-                this.hasReportedVersionForSession = true;
-            }
-        }
+        // ensure version is cached
+        await this.getVersion();
 
         return super.loadPacks();
     }
@@ -145,7 +144,7 @@ class CsolutionServiceImpl extends RpcMethods implements CsolutionService {
         this.idxWatcher = undefined;
         this.connection?.dispose();
         this.connection = undefined;
-        this.hasReportedVersionForSession = false;
+        this.cachedVersion = { success: false };
     }
 
     private async launch(): Promise<boolean> {

src/json-rpc/csolution-rpc-helper.test.ts

@@ -207,6 +207,66 @@ describe('csolution-rpc-client', () => {
         });
     });
 
+    describe('csolution-rpc-client getVersion cache', () => {
+        let service: AnyService;
+
+        beforeEach(() => {
+            service = createService();
+            service.cachedVersion = { success: false };
+        });
+
+        it('caches version after first request and reuses it', async () => {
+            const transceiveSpy = jest.spyOn(service as any, 'transceive')
+                .mockResolvedValue({ success: true, version: '1.2.3', apiVersion: '0.0.9' });
+
+            const first = await service.getVersion();
+            const second = await service.getVersion();
+
+            expect(first).toEqual({ success: true, version: '1.2.3', apiVersion: '0.0.9' });
+            expect(second).toEqual({ success: true, version: '1.2.3', apiVersion: '0.0.9' });
+            expect(transceiveSpy).toHaveBeenCalledTimes(1);
+            expect(transceiveSpy).toHaveBeenCalledWith('GetVersion', undefined);
+        });
+
+        it('resets cached version on terminate and fetches again on next getVersion', async () => {
+            const transceiveSpy = jest.spyOn(service as any, 'transceive')
+                .mockResolvedValue({ success: true, version: '1.2.3', apiVersion: '0.0.9' });
+
+            await service.getVersion();
+            expect(transceiveSpy).toHaveBeenCalledTimes(1);
+
+            // Simulate daemon termination lifecycle.
+            service.onTerminate();
+            expect(service.cachedVersion).toEqual({ success: false });
+
+            await service.getVersion();
+            expect(transceiveSpy).toHaveBeenCalledTimes(2);
+        });
+
+        it('primes version cache in loadPacks before LoadPacks RPC', async () => {
+            service.idxWatcher = { close: jest.fn() };
+            const sequence: string[] = [];
+
+            const transceiveSpy = jest.spyOn(service as any, 'transceive').mockImplementation(async (...args: unknown[]) => {
+                const method = String(args[0]);
+                sequence.push(method);
+                if (method === 'GetVersion') {
+                    return { success: true, version: '1.2.3', apiVersion: '0.0.9' };
+                }
+                if (method === 'LoadPacks') {
+                    return { success: true };
+                }
+                return { success: false };
+            });
+
+            await service.loadPacks();
+
+            expect(transceiveSpy).toHaveBeenCalledWith('GetVersion', undefined);
+            expect(transceiveSpy).toHaveBeenCalledWith('LoadPacks', undefined);
+            expect(sequence.indexOf('GetVersion')).toBeLessThan(sequence.indexOf('LoadPacks'));
+        });
+    });
+
 
     describe('csolution-rpc-client watchPackIdxFile', () => {
         let service: AnyService;