each component instance has it's own session information (#824)

* each component instance has it's own session information
* removing residual functions
* changing finally to catch to print error message
* updating tests to accommodate change
* throwing errors if payload session is different than that of active session

Author: omarArm

src/views/component-viewer/component-viewer-instance.ts

@@ -104,10 +104,6 @@ export class ComponentViewerInstance {
         return `${text}, Time: ${timeUsage} ms, Mem: ${memUsage}, Mem Increase: ${memIncrease} MB, (Total: ${memCurrent} MB)`;
     }
 
-    public updateActiveSession(debugSession: GDBTargetDebugSession): void {
-        this._scvdEvalContext?.updateActiveSession(debugSession);
-    }
-
     public async readModel(filename: URI, debugSession: GDBTargetDebugSession, debugTracker: GDBTargetDebugTracker): Promise<void> {
         const stats: string[] = [];
         this._fileKey = ComponentViewerInstance.getFileKey(filename);

src/views/component-viewer/component-viewer-main.ts

@@ -171,8 +171,7 @@ export class ComponentViewer {
     private async handleOnStackTrace(session: GDBTargetDebugSession): Promise<void> {
         // Clear active session if it is NOT the one being stopped
         if (this._activeSession?.session.id !== session.session.id) {
-            this._activeSession = undefined;
-            return;
+            throw new Error(`Component Viewer: Received stack trace event for session ${session.session.id} while active session is ${this._activeSession?.session.id}`);
         }
         // Update component viewer instance(s)
         this.schedulePendingUpdate('stackTrace');
@@ -182,8 +181,7 @@ export class ComponentViewer {
         // If the active session is not the one being updated, update it.
         // This can happen when a session is started and stack trace/item events are emitted before the session is set as active in the component viewer.
         if (this._activeSession?.session.id !== session.session.id) {
-            this._activeSession = session;
-            this._instances.forEach((instance) => instance.componentViewerInstance.updateActiveSession(session));
+            throw new Error(`Component Viewer: Received stack item changed event for session ${session.session.id} while active session is ${this._activeSession?.session.id}`);
         }
         // Update component viewer instance(s)
         this.schedulePendingUpdate('stackItemChanged');
@@ -226,11 +224,6 @@ export class ComponentViewer {
     private async handleOnDidChangeActiveDebugSession(session: GDBTargetDebugSession | undefined): Promise<void> {
         // Update debug session
         this._activeSession = session;
-        if (session === undefined) {
-            return;
-        }
-        // update active debug session for all instances
-        this._instances.forEach((instance) => instance.componentViewerInstance.updateActiveSession(session));
     }
 
     private schedulePendingUpdate(updateReason: fifoUpdateReason): void {
@@ -253,9 +246,8 @@ export class ComponentViewer {
             this._pendingUpdate = false;
             try {
                 await this.updateInstances(updateReason);
-            } finally {
-                this._runningUpdate = false;
-                //logger.error('Component Viewer: Error during update');
+            } catch (error) {
+                componentViewerLogger.error(`Component Viewer: Error during update - ${(error as Error).message}`);
             }
         }
         this._runningUpdate = false;
@@ -273,11 +265,12 @@ export class ComponentViewer {
         }
         perf?.resetBackendStats();
         perf?.resetUiStats();
+        const activeSessionID = this._activeSession.session.id;
         const roots: ScvdGuiInterface[] = [];
         for (const instance of this._instances) {
             // Check if instance belongs to the active session, if not skip it and clear its data from the tree view.
             // However, lockedState should be maintained.
-            if (instance.sessionId !== this._activeSession.session.id) {
+            if (instance.sessionId !== activeSessionID) {
                 instance.componentViewerInstance.getGuiTree()?.forEach(root => root.clear());
                 continue;
             }

src/views/component-viewer/scvd-debug-target.ts

@@ -106,12 +106,6 @@ export class ScvdDebugTarget {
         this.symbolCaches.clearAll();
     }
 
-    public setActiveSession(session: GDBTargetDebugSession): void {
-        componentViewerLogger.debug('updating active session');
-        this.activeSession = session;
-        this.targetAccess.setActiveSession(session);
-    }
-
     public async beginUpdateCycle(): Promise<void> {
         componentViewerLogger.debug('reset read stats and prime cache');
         targetReadStats?.reset();

src/views/component-viewer/scvd-eval-context.ts

@@ -125,10 +125,6 @@ export class ScvdEvalContext {
         })();
     }
 
-    public updateActiveSession(debugSession: GDBTargetDebugSession): void {
-        this._debugTarget.setActiveSession(debugSession);
-    }
-
     public setIntegerModelKind(kind: IntegerModelKind | undefined): void {
         if (!kind) {
             return;

src/views/component-viewer/test/integration/scvd-debug-target.test.ts

@@ -302,10 +302,6 @@ describe('scvd-debug-target', () => {
         const target = new ScvdDebugTarget();
         target.init(session, tracker);
 
-        const otherSession = { session: { id: 'sess-2' } } as unknown as GDBTargetDebugSession;
-        target.setActiveSession(otherSession);
-        expect(accessMock.setActiveSession).toHaveBeenCalledWith(otherSession);
-
         (target as unknown as { targetReadCache: TargetReadCache | undefined }).targetReadCache = undefined;
         await target.beginUpdateCycle();
 

src/views/component-viewer/test/unit/component-viewer-instance.test.ts

@@ -267,20 +267,6 @@ describe('ComponentViewerInstance', () => {
         expect(second).toContain('Mem Increase:');
     });
 
-    it('stores scvd eval context and forwards active session updates', () => {
-        const instance = new ComponentViewerInstance();
-        const updateActiveSession = jest.fn();
-        const evalContext = { updateActiveSession } as unknown as ScvdEvalContext;
-        const debugSession = {} as unknown as GDBTargetDebugSession;
-
-        expect(instance.scvdEvalContext).toBeUndefined();
-        instance.scvdEvalContext = evalContext;
-        expect(instance.scvdEvalContext).toBe(evalContext);
-
-        instance.updateActiveSession(debugSession);
-        expect(updateActiveSession).toHaveBeenCalledWith(debugSession);
-    });
-
     it('reuses existing file key for the same path', () => {
         const keyMap = (ComponentViewerInstance as unknown as { _fileKeysByPath: Map<string, string> })._fileKeysByPath;
         const countMap = (ComponentViewerInstance as unknown as { _fileKeyCounts: Map<string, number> })._fileKeyCounts;

src/views/component-viewer/test/unit/component-viewer-main.test.ts

@@ -281,13 +281,11 @@ describe('ComponentViewer', () => {
 
         (controller as unknown as { _activeSession?: Session })._activeSession = session;
         await tracker.callbacks.stackTrace?.({ session });
-        await tracker.callbacks.stackTrace?.({ session: otherSession });
+        await expect(tracker.callbacks.stackTrace?.({ session: otherSession }) as Promise<void>).rejects.toThrow(
+            'Component Viewer: Received stack trace event for session s2 while active session is s1'
+        );
+        expect((controller as unknown as { _activeSession?: Session })._activeSession).toBe(session);
 
-        // stackTrace from a different session clears active session
-        expect((controller as unknown as { _activeSession?: Session })._activeSession).toBeUndefined();
-
-        await tracker.callbacks.activeStackItem?.({ session: otherSession });
-        expect((controller as unknown as { _activeSession?: Session })._activeSession).toBe(otherSession);
 
         (controller as unknown as { _activeSession?: Session })._activeSession = session;
         await tracker.callbacks.willStop?.(session);
@@ -336,32 +334,28 @@ describe('ComponentViewer', () => {
         expect((controller as unknown as { _instances: unknown[] })._instances).toHaveLength(0);
     });
 
-    it('updates active session and instances on stack item change', async () => {
+    it('updates instances on stack item change', async () => {
         const controller = new ComponentViewer(extensionContextFactory());
         const sessionA = makeSession('s1');
-        const sessionB = makeSession('s2');
-        const updateSpy = jest.fn();
+        const updateSpy = jest.fn().mockResolvedValue(undefined);
 
         (controller as unknown as { _activeSession?: Session })._activeSession = sessionA;
         (controller as unknown as { _instances: ComponentViewerInstancesWrapper[] })._instances = [
             {
-                componentViewerInstance: { updateActiveSession: updateSpy } as unknown as ComponentViewerInstancesWrapper['componentViewerInstance'],
+                componentViewerInstance: { update: updateSpy, getGuiTree: jest.fn(() => []) } as unknown as ComponentViewerInstancesWrapper['componentViewerInstance'],
                 lockState: false,
                 sessionId: 's1',
             },
         ];
 
-        const scheduleSpy = jest.spyOn(
-            controller as unknown as { schedulePendingUpdate: (reason: fifoUpdateReason) => void },
-            'schedulePendingUpdate'
-        ).mockImplementation(() => undefined);
-
         const handleOnStackItemChanged = (controller as unknown as { handleOnStackItemChanged: (s: Session) => Promise<void> }).handleOnStackItemChanged.bind(controller);
-        await handleOnStackItemChanged(sessionB);
+        jest.useFakeTimers();
+        await handleOnStackItemChanged(sessionA);
+        jest.advanceTimersByTime(200);
+        await Promise.resolve();
 
-        expect((controller as unknown as { _activeSession?: Session })._activeSession).toBe(sessionB);
-        expect(updateSpy).toHaveBeenCalledWith(sessionB);
-        expect(scheduleSpy).toHaveBeenCalledWith('stackItemChanged');
+        expect(updateSpy).toHaveBeenCalled();
+        jest.useRealTimers();
     });
 
     it('does not update active session when stack item matches the active session', async () => {
@@ -629,17 +623,17 @@ describe('ComponentViewer', () => {
         expect(updateInstances).toHaveBeenCalledWith('stackTrace');
     });
 
-    it('propagates errors during a coalescing update', async () => {
+    it('swallows errors during a coalescing update', async () => {
         const controller = new ComponentViewer(extensionContextFactory());
         (controller as unknown as { _pendingUpdate: boolean })._pendingUpdate = true;
         (controller as unknown as { _runningUpdate: boolean })._runningUpdate = false;
-        (controller as unknown as { updateInstances: (reason: fifoUpdateReason) => Promise<void> }).updateInstances = jest
-            .fn()
+        const updateInstances = jest.spyOn(controller as unknown as { updateInstances: (reason: fifoUpdateReason) => Promise<void> }, 'updateInstances')
             .mockRejectedValue(new Error('fail'));
         const runUpdate = (controller as unknown as { runUpdate: (reason: fifoUpdateReason) => Promise<void> }).runUpdate.bind(controller);
 
-        await expect(runUpdate('stackTrace')).rejects.toThrow('fail');
-        // Clears running state if runUpdate throws
+        await expect(runUpdate('stackTrace')).resolves.toBeUndefined();
+        expect(updateInstances).toHaveBeenCalledWith('stackTrace');
+        // Clears running state after runUpdate completes
         expect((controller as unknown as { _runningUpdate: boolean })._runningUpdate).toBe(false);
     });
 

src/views/component-viewer/test/unit/scvd-eval-context.test.ts

@@ -108,16 +108,6 @@ describe('ScvdEvalContext', () => {
         expect(debugTarget.init).toHaveBeenCalledWith(fakeSession, fakeTracker);
     });
 
-    it('updates active session on debug target', () => {
-        const { viewer } = buildViewerWithObject();
-        const ctx = new ScvdEvalContext(viewer);
-        const debugTarget = ctx.getExecutionContext().debugTarget;
-        const spy = jest.spyOn(debugTarget, 'setActiveSession').mockImplementation(() => undefined as unknown as void);
-        const fakeSession = {} as unknown as Parameters<typeof debugTarget.setActiveSession>[0];
-        ctx.updateActiveSession(fakeSession);
-        expect(spy).toHaveBeenCalledWith(fakeSession);
-    });
-
     it('updates integer model when setIntegerModelKind is provided', () => {
         const { viewer } = buildViewerWithObject();
         const ctx = new ScvdEvalContext(viewer);