From 9ac57bf8cf4224706381d62acba679ba85a84841 Mon Sep 17 00:00:00 2001
From: Sushobhit Dua <38429226+sushobhit-lt@users.noreply.github.com>
Date: Fri, 24 Apr 2026 20:22:08 +0530
Subject: [PATCH 1/2] feat(TE-4324): propagate testName from session
 capabilities to snapshot options

Add testIdTestNameMap cache parallel to sessionTestIdMap so that testName
is restored on subsequent LTMS-fallback cache hits. Populate
snapshot.options.testName from LSRS getSmartUICapabilities response
across all 3 resolution paths (Redis-success, sessionCapabilitiesMap
cache-hit, LTMS-fallback).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/lib/ctx.ts    |  1 +
 src/lib/server.ts | 23 ++++++++++++++++++++++-
 src/types.ts      |  2 ++
 3 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/lib/ctx.ts b/src/lib/ctx.ts
index 42c3a68..c0bafc5 100644
--- a/src/lib/ctx.ts
+++ b/src/lib/ctx.ts
@@ -295,6 +295,7 @@ export default (options: Record<string, string>): Context => {
         isSnapshotCaptured: false,
         sessionCapabilitiesMap: new Map<string, any[]>(),
         sessionTestIdMap: new Map<string, string>(),
+        testIdTestNameMap: new Map<string, string>(),
         buildToSnapshotCountMap: new Map<string, number>(),
         sessionIdToSnapshotNameMap: new Map<string, string[]>(),
         fetchResultsForBuild: new Array<string>,
diff --git a/src/lib/server.ts b/src/lib/server.ts
index 441fb8f..6aff699 100644
--- a/src/lib/server.ts
+++ b/src/lib/server.ts
@@ -96,18 +96,36 @@ export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMes
 			if (sessionId) {
 				if (ctx.sessionTestIdMap?.has(sessionId)) {
 					// Already have testId from LTMS fallback, skip getSmartUICapabilities
-					snapshot.options.testId = ctx.sessionTestIdMap.get(sessionId);
+					const cachedTestId = ctx.sessionTestIdMap.get(sessionId);
+					snapshot.options.testId = cachedTestId;
 					ctx.log.debug(`Using cached testId for sessionId ${sessionId}: ${snapshot.options.testId}`);
+					if (cachedTestId && ctx.testIdTestNameMap?.has(cachedTestId)) {
+						snapshot.options.testName = ctx.testIdTestNameMap.get(cachedTestId);
+						ctx.log.debug(`Using cached testName for testId ${cachedTestId}: ${snapshot.options.testName}`);
+					}
 				} else if (ctx.sessionCapabilitiesMap?.has(sessionId)) {
 					// Use cached capabilities if available
 					const cachedCapabilities = ctx.sessionCapabilitiesMap.get(sessionId);
 					capsBuildId = cachedCapabilities?.buildId || ''
+					if (cachedCapabilities?.name) {
+						snapshot.options.testName = cachedCapabilities.name;
+						if (cachedCapabilities?.id) {
+							ctx.testIdTestNameMap?.set(cachedCapabilities.id, cachedCapabilities.name);
+						}
+					}
 				} else {
 					// If not cached, fetch from API and cache it
 					try {
 						let fetchedCapabilitiesResp = await ctx.client.getSmartUICapabilities(sessionId, ctx.config, ctx.git, ctx.log, ctx.isStartExec, ctx.options.baselineBuild, ctx.env);
 						capsBuildId = fetchedCapabilitiesResp?.buildId || ''
 						ctx.log.debug(`fetch caps for sessionId: ${sessionId} are ${JSON.stringify(fetchedCapabilitiesResp)}`)
+						if (fetchedCapabilitiesResp?.name) {
+							snapshot.options.testName = fetchedCapabilitiesResp.name;
+							const testIdForCache = fetchedCapabilitiesResp?.id || fetchedCapabilitiesResp?.testId;
+							if (testIdForCache) {
+								ctx.testIdTestNameMap?.set(testIdForCache, fetchedCapabilitiesResp.name);
+							}
+						}
 						if (capsBuildId) {
 							ctx.sessionCapabilitiesMap.set(sessionId, fetchedCapabilitiesResp);
 						} else if (fetchedCapabilitiesResp && fetchedCapabilitiesResp?.sessionId) {
@@ -116,6 +134,9 @@ export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMes
 							// LTMS fallback: only testId returned, no buildId
 							ctx.sessionTestIdMap?.set(sessionId, fetchedCapabilitiesResp.testId);
 							snapshot.options.testId = fetchedCapabilitiesResp.testId;
+							if (fetchedCapabilitiesResp?.name) {
+								ctx.testIdTestNameMap?.set(fetchedCapabilitiesResp.testId, fetchedCapabilitiesResp.name);
+							}
 							ctx.log.debug(`Cached LTMS fallback testId for sessionId ${sessionId}: ${fetchedCapabilitiesResp.testId}`);
 						}
 					} catch (error: any) {
diff --git a/src/types.ts b/src/types.ts
index ccc3d5b..bdae9c3 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -97,6 +97,7 @@ export interface Context {
     isSnapshotCaptured ?: boolean;
     sessionCapabilitiesMap?: Map<string, any[]>;
     sessionTestIdMap?: Map<string, string>;
+    testIdTestNameMap?: Map<string, string>;
     buildToSnapshotCountMap?: Map<string, number>;
     fetchResultsForBuild?: Array<string>;
     sessionIdToSnapshotNameMap?: Map<string, string[]>;
@@ -189,6 +190,7 @@ export interface Snapshot {
         ignoreType?: string[],
         sessionId?: string
         testId?: string
+        testName?: string
         sync?: boolean;
         contextId?: string;
         useExtendedViewport?: boolean;

From 096a939e254ed061ebe368817213894796492d3b Mon Sep 17 00:00:00 2001
From: Sushobhit Dua <38429226+sushobhit-lt@users.noreply.github.com>
Date: Fri, 24 Apr 2026 23:33:26 +0530
Subject: [PATCH 2/2] fix(TE-4324): carry testName through
 processSnapshot/prepareSnapshot

The option-processing step built processedOptions from an explicit
allowlist that only forwarded sessionId and testId, silently dropping
testName. Add testName propagation in both prepareSnapshot and
processSnapshot, mirroring the testId resolution order: inline option,
then testIdTestNameMap lookup, then sessionCapabilitiesMap.name
fallback.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 src/lib/processSnapshot.ts | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/lib/processSnapshot.ts b/src/lib/processSnapshot.ts
index 581240c..1b697c4 100644
--- a/src/lib/processSnapshot.ts
+++ b/src/lib/processSnapshot.ts
@@ -89,6 +89,16 @@ export async function prepareSnapshot(snapshot: Snapshot, ctx: Context): Promise
                     processedOptions.testId = sessionCapabilities.id;
                 }
             }
+            if (options.testName) {
+                processedOptions.testName = options.testName;
+            } else if (processedOptions.testId && ctx.testIdTestNameMap?.has(processedOptions.testId)) {
+                processedOptions.testName = ctx.testIdTestNameMap.get(processedOptions.testId);
+            } else if (ctx.sessionCapabilitiesMap && ctx.sessionCapabilitiesMap.has(sessionId)) {
+                const sessionCapabilities = ctx.sessionCapabilitiesMap.get(sessionId);
+                if (sessionCapabilities && sessionCapabilities.name) {
+                    processedOptions.testName = sessionCapabilities.name;
+                }
+            }
         }
 
         if (options.web && Object.keys(options.web).length) {
@@ -578,6 +588,16 @@ export default async function processSnapshot(snapshot: Snapshot, ctx: Context):
                     processedOptions.testId = sessionCapabilities.id;
                 }
             }
+            if (options.testName) {
+                processedOptions.testName = options.testName;
+            } else if (processedOptions.testId && ctx.testIdTestNameMap?.has(processedOptions.testId)) {
+                processedOptions.testName = ctx.testIdTestNameMap.get(processedOptions.testId);
+            } else if (ctx.sessionCapabilitiesMap && ctx.sessionCapabilitiesMap.has(sessionId)) {
+                const sessionCapabilities = ctx.sessionCapabilitiesMap.get(sessionId);
+                if (sessionCapabilities && sessionCapabilities.name) {
+                    processedOptions.testName = sessionCapabilities.name;
+                }
+            }
         }
 
         if (options.web && Object.keys(options.web).length) {