@memberjunction/server 5.3.1 → 5.4.0

package/src/resolvers/RunTestResolver.ts

@@ -12,11 +12,11 @@ import {
     Int
 } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
-import { LogError, LogStatus } from '@memberjunction/core';
+import { LogError, LogStatus, UserInfo } from '@memberjunction/core';
 import { TestEngine } from '@memberjunction/testing-engine';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
-import { TestRunVariables, TestLogMessage } from '@memberjunction/testing-engine-base';
+import { TestRunVariables, TestLogMessage, TestRunResult as EngineTestRunResult } from '@memberjunction/testing-engine-base';
 
 // ===== GraphQL Types =====
 
@@ -89,7 +89,7 @@ export class TestExecutionStreamMessage {
     timestamp: Date;
 
     // Not a GraphQL field - used internally
-    testRun?: any;
+    testRun?: Record<string, unknown>;
 }
 
 // ===== Resolver =====
@@ -98,7 +98,8 @@ export class TestExecutionStreamMessage {
 export class RunTestResolver extends ResolverBase {
 
     /**
-     * Execute a single test
+     * Execute a single test.
+     * Supports fire-and-forget mode to avoid Azure proxy timeouts on long-running tests.
      */
     @Mutation(() => TestRunResult)
     async RunTest(
@@ -107,232 +108,307 @@ export class RunTestResolver extends ResolverBase {
         @Arg('environment', { nullable: true }) environment?: string,
         @Arg('tags', { nullable: true }) tags?: string,
         @Arg('variables', { nullable: true }) variables?: string,
+        @Arg('fireAndForget', { nullable: true }) fireAndForget?: boolean,
         @PubSub() pubSub?: PubSubEngine,
         @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<TestRunResult> {
+        const user = this.GetUserFromPayload(userPayload);
+        if (!user) {
+            return { success: false, errorMessage: 'User context required', result: JSON.stringify({}) };
+        }
+
+        if (fireAndForget && pubSub) {
+            // Fire-and-forget: start in background, return immediately
+            this.executeTestInBackground(testId, verbose, environment, tags, variables, pubSub, userPayload, user);
+            LogStatus(`🔥 Fire-and-forget: Test ${testId} execution started in background`);
+            return {
+                success: true,
+                result: JSON.stringify({ accepted: true, fireAndForget: true })
+            };
+        }
+
+        // Synchronous mode (default): wait for execution to complete
+        return this.executeTest(testId, verbose, environment, tags, variables, pubSub, userPayload, user);
+    }
+
+    /**
+     * Execute a test suite.
+     * Supports fire-and-forget mode to avoid Azure proxy timeouts on long-running suites.
+     */
+    @Mutation(() => TestSuiteRunResult)
+    async RunTestSuite(
+        @Arg('suiteId') suiteId: string,
+        @Arg('verbose', { nullable: true }) verbose: boolean = true,
+        @Arg('environment', { nullable: true }) environment?: string,
+        @Arg('parallel', { nullable: true }) parallel: boolean = false,
+        @Arg('tags', { nullable: true }) tags?: string,
+        @Arg('variables', { nullable: true }) variables?: string,
+        @Arg('selectedTestIds', { nullable: true }) selectedTestIds?: string,
+        @Arg('sequenceStart', () => Int, { nullable: true }) sequenceStart?: number,
+        @Arg('sequenceEnd', () => Int, { nullable: true }) sequenceEnd?: number,
+        @Arg('fireAndForget', { nullable: true }) fireAndForget?: boolean,
+        @PubSub() pubSub?: PubSubEngine,
+        @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<TestSuiteRunResult> {
+        const user = this.GetUserFromPayload(userPayload);
+        if (!user) {
+            return { success: false, errorMessage: 'User context required', result: JSON.stringify({}) };
+        }
+
+        if (fireAndForget && pubSub) {
+            // Fire-and-forget: start in background, return immediately
+            this.executeSuiteInBackground(
+                suiteId, verbose, environment, parallel, tags, variables,
+                selectedTestIds, sequenceStart, sequenceEnd, pubSub, userPayload, user
+            );
+            LogStatus(`🔥 Fire-and-forget: Suite ${suiteId} execution started in background`);
+            return {
+                success: true,
+                result: JSON.stringify({ accepted: true, fireAndForget: true })
+            };
+        }
+
+        // Synchronous mode (default): wait for execution to complete
+        return this.executeSuite(
+            suiteId, verbose, environment, parallel, tags, variables,
+            selectedTestIds, sequenceStart, sequenceEnd, pubSub, userPayload, user
+        );
+    }
+
+    /**
+     * Query to check if a test is currently running
+     */
+    @Query(() => Boolean)
+    async IsTestRunning(
+        @Arg('testId') testId: string,
+        @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<boolean> {
+        // TODO: Implement running test tracking
+        // For now, return false
+        return false;
+    }
+
+    // ===== Core Execution Methods =====
+
+    /**
+     * Execute a single test synchronously and return the result.
+     */
+    private async executeTest(
+        testId: string,
+        verbose: boolean,
+        environment: string | undefined,
+        tags: string | undefined,
+        variables: string | undefined,
+        pubSub: PubSubEngine | undefined,
+        userPayload: UserPayload,
+        user: UserInfo
     ): Promise<TestRunResult> {
         const startTime = Date.now();
 
         try {
-            const user = this.GetUserFromPayload(userPayload);
-            if (!user) {
-                throw new Error('User context required');
-            }
-
             LogStatus(`[RunTestResolver] Starting test execution: ${testId}`);
 
-            // Get singleton instance
             const engine = TestEngine.Instance;
-
-            // Configure engine (loads driver and oracle registries)
             await engine.Config(verbose, user);
 
-            // Create progress callback if we have pubSub
-            const progressCallback = pubSub ?
-                this.createProgressCallback(pubSub, userPayload, testId) :
-                undefined;
-
-            // Create log callback to stream driver/engine logs to the UI in real-time
-            const logCallback = pubSub ?
-                this.createLogCallback(pubSub, userPayload, testId) :
-                undefined;
-
-            // Parse variables from JSON string if provided
-            let parsedVariables: TestRunVariables | undefined;
-            if (variables) {
-                try {
-                    parsedVariables = JSON.parse(variables);
-                } catch (e) {
-                    LogError(`[RunTestResolver] Failed to parse variables: ${variables}`);
-                }
-            }
-
-            // Run the test
-            const options = {
-                verbose,
-                environment,
-                tags,
-                variables: parsedVariables,
-                progressCallback,
-                logCallback
-            };
+            const progressCallback = pubSub ? this.createProgressCallback(pubSub, userPayload, testId) : undefined;
+            const logCallback = pubSub ? this.createLogCallback(pubSub, userPayload, testId) : undefined;
+            const parsedVariables = this.parseVariablesJson(variables);
 
+            const options = { verbose, environment, tags, variables: parsedVariables, progressCallback, logCallback };
             const result = await engine.RunTest(testId, options, user);
 
-            // Handle both single result and array of results (RepeatCount > 1)
-            let finalResult;
-            let allPassed = true;
-
-            if (Array.isArray(result)) {
-                // Multiple iterations - check if all passed
-                allPassed = result.every(r => r.status === 'Passed');
-
-                // For GraphQL, return summary information
-                // The full array is serialized in the result field
-                finalResult = {
-                    testRunId: result[0]?.testRunId || '',
-                    status: allPassed ? 'Passed' as const : 'Failed' as const
-                };
-
-                // Publish completion for each iteration
-                if (pubSub) {
-                    for (const iterationResult of result) {
-                        this.publishComplete(pubSub, userPayload, iterationResult);
-                    }
-                }
-
-                LogStatus(`[RunTestResolver] Test completed: ${result.length} iterations, ${allPassed ? 'all passed' : 'some failed'} in ${Date.now() - startTime}ms`);
-            } else {
-                // Single result
-                finalResult = result;
-                allPassed = result.status === 'Passed';
+            const testRunResult = this.buildTestRunResult(result, startTime, pubSub, userPayload);
 
-                // Publish completion
-                if (pubSub && result.testRunId) {
-                    this.publishComplete(pubSub, userPayload, result);
-                }
-
-                LogStatus(`[RunTestResolver] Test completed: ${result.status} in ${Date.now() - startTime}ms`);
+            // Publish fire-and-forget completion event (used by background mode, harmless in sync mode)
+            if (pubSub) {
+                this.publishFireAndForgetComplete(pubSub, userPayload, testId, testRunResult);
             }
 
-            const executionTime = Date.now() - startTime;
-
-            return {
-                success: allPassed,
-                result: JSON.stringify(result), // Full result (single or array)
-                executionTimeMs: executionTime
-            };
+            return testRunResult;
 
         } catch (error) {
             const executionTime = Date.now() - startTime;
             const errorMsg = (error as Error).message;
-
             LogError(`[RunTestResolver] Test execution failed: ${errorMsg}`);
 
-            // Publish error
             if (pubSub) {
                 this.publishError(pubSub, userPayload, testId, errorMsg);
             }
 
-            return {
-                success: false,
-                errorMessage: errorMsg,
-                result: JSON.stringify({}),
-                executionTimeMs: executionTime
-            };
+            return { success: false, errorMessage: errorMsg, result: JSON.stringify({}), executionTimeMs: executionTime };
         }
     }
 
     /**
-     * Execute a test suite
+     * Execute a test in background (fire-and-forget).
+     * Errors are published via PubSub, not propagated.
      */
-    @Mutation(() => TestSuiteRunResult)
-    async RunTestSuite(
-        @Arg('suiteId') suiteId: string,
-        @Arg('verbose', { nullable: true }) verbose: boolean = true,
-        @Arg('environment', { nullable: true }) environment?: string,
-        @Arg('parallel', { nullable: true }) parallel: boolean = false,
-        @Arg('tags', { nullable: true }) tags?: string,
-        @Arg('variables', { nullable: true }) variables?: string,
-        @Arg('selectedTestIds', { nullable: true }) selectedTestIds?: string,
-        @Arg('sequenceStart', () => Int, { nullable: true }) sequenceStart?: number,
-        @Arg('sequenceEnd', () => Int, { nullable: true }) sequenceEnd?: number,
-        @PubSub() pubSub?: PubSubEngine,
-        @Ctx() { userPayload }: AppContext = {} as AppContext
+    private executeTestInBackground(
+        testId: string,
+        verbose: boolean,
+        environment: string | undefined,
+        tags: string | undefined,
+        variables: string | undefined,
+        pubSub: PubSubEngine,
+        userPayload: UserPayload,
+        user: UserInfo
+    ): void {
+        this.executeTest(testId, verbose, environment, tags, variables, pubSub, userPayload, user)
+            .catch((error: unknown) => {
+                const errorMessage = (error instanceof Error) ? error.message : 'Unknown background test execution error';
+                LogError(`🔥 Fire-and-forget test execution failed: ${errorMessage}`, undefined, error);
+                this.publishFireAndForgetError(pubSub, userPayload, testId, errorMessage);
+            });
+    }
+
+    /**
+     * Execute a test suite synchronously and return the result.
+     */
+    private async executeSuite(
+        suiteId: string,
+        verbose: boolean,
+        environment: string | undefined,
+        parallel: boolean,
+        tags: string | undefined,
+        variables: string | undefined,
+        selectedTestIds: string | undefined,
+        sequenceStart: number | undefined,
+        sequenceEnd: number | undefined,
+        pubSub: PubSubEngine | undefined,
+        userPayload: UserPayload,
+        user: UserInfo
     ): Promise<TestSuiteRunResult> {
         const startTime = Date.now();
 
         try {
-            const user = this.GetUserFromPayload(userPayload);
-            if (!user) {
-                throw new Error('User context required');
-            }
-
             LogStatus(`[RunTestResolver] Starting suite execution: ${suiteId}`);
 
             const engine = TestEngine.Instance;
             await engine.Config(verbose, user);
 
-            // Create progress callback
-            const progressCallback = pubSub ?
-                this.createProgressCallback(pubSub, userPayload, suiteId) :
-                undefined;
-
-            // Create log callback to stream driver/engine logs to the UI in real-time
-            const logCallback = pubSub ?
-                this.createLogCallback(pubSub, userPayload, suiteId) :
-                undefined;
-
-            // Parse selectedTestIds from JSON string if provided
-            let parsedSelectedTestIds: string[] | undefined;
-            if (selectedTestIds) {
-                try {
-                    parsedSelectedTestIds = JSON.parse(selectedTestIds);
-                } catch (e) {
-                    LogError(`[RunTestResolver] Failed to parse selectedTestIds: ${selectedTestIds}`);
-                }
-            }
-
-            // Parse variables from JSON string if provided
-            let parsedVariables: TestRunVariables | undefined;
-            if (variables) {
-                try {
-                    parsedVariables = JSON.parse(variables);
-                } catch (e) {
-                    LogError(`[RunTestResolver] Failed to parse variables: ${variables}`);
-                }
-            }
+            const progressCallback = pubSub ? this.createProgressCallback(pubSub, userPayload, suiteId) : undefined;
+            const logCallback = pubSub ? this.createLogCallback(pubSub, userPayload, suiteId) : undefined;
+            const parsedSelectedTestIds = this.parseJsonArray(selectedTestIds, 'selectedTestIds');
+            const parsedVariables = this.parseVariablesJson(variables);
 
             const options = {
-                verbose,
-                environment,
-                parallel,
-                tags,
-                variables: parsedVariables,
-                selectedTestIds: parsedSelectedTestIds,
-                sequenceStart,
-                sequenceEnd,
-                progressCallback,
-                logCallback
+                verbose, environment, parallel, tags,
+                variables: parsedVariables, selectedTestIds: parsedSelectedTestIds,
+                sequenceStart, sequenceEnd, progressCallback, logCallback
             };
 
             const result = await engine.RunSuite(suiteId, options, user);
-
             const executionTime = Date.now() - startTime;
 
             LogStatus(`[RunTestResolver] Suite completed: ${result.totalTests} tests in ${executionTime}ms`);
 
-            return {
+            const suiteRunResult: TestSuiteRunResult = {
                 success: result.status === 'Completed',
                 result: JSON.stringify(result),
                 executionTimeMs: executionTime
             };
 
+            // Publish fire-and-forget completion event
+            if (pubSub) {
+                this.publishFireAndForgetSuiteComplete(pubSub, userPayload, suiteId, suiteRunResult);
+            }
+
+            return suiteRunResult;
+
         } catch (error) {
             const executionTime = Date.now() - startTime;
             const errorMsg = (error as Error).message;
-
             LogError(`[RunTestResolver] Suite execution failed: ${errorMsg}`);
 
-            return {
-                success: false,
-                errorMessage: errorMsg,
-                result: JSON.stringify({}),
-                executionTimeMs: executionTime
-            };
+            return { success: false, errorMessage: errorMsg, result: JSON.stringify({}), executionTimeMs: executionTime };
         }
     }
 
     /**
-     * Query to check if a test is currently running
+     * Execute a test suite in background (fire-and-forget).
+     * Errors are published via PubSub, not propagated.
      */
-    @Query(() => Boolean)
-    async IsTestRunning(
-        @Arg('testId') testId: string,
-        @Ctx() { userPayload }: AppContext = {} as AppContext
-    ): Promise<boolean> {
-        // TODO: Implement running test tracking
-        // For now, return false
-        return false;
+    private executeSuiteInBackground(
+        suiteId: string,
+        verbose: boolean,
+        environment: string | undefined,
+        parallel: boolean,
+        tags: string | undefined,
+        variables: string | undefined,
+        selectedTestIds: string | undefined,
+        sequenceStart: number | undefined,
+        sequenceEnd: number | undefined,
+        pubSub: PubSubEngine,
+        userPayload: UserPayload,
+        user: UserInfo
+    ): void {
+        this.executeSuite(
+            suiteId, verbose, environment, parallel, tags, variables,
+            selectedTestIds, sequenceStart, sequenceEnd, pubSub, userPayload, user
+        ).catch((error: unknown) => {
+            const errorMessage = (error instanceof Error) ? error.message : 'Unknown background suite execution error';
+            LogError(`🔥 Fire-and-forget suite execution failed: ${errorMessage}`, undefined, error);
+            this.publishFireAndForgetSuiteError(pubSub, userPayload, suiteId, errorMessage);
+        });
+    }
+
+    // ===== Result Building =====
+
+    /**
+     * Build a TestRunResult from the engine result, handling both single and array results.
+     */
+    private buildTestRunResult(
+        result: EngineTestRunResult | EngineTestRunResult[],
+        startTime: number,
+        pubSub: PubSubEngine | undefined,
+        userPayload: UserPayload
+    ): TestRunResult {
+        const executionTime = Date.now() - startTime;
+
+        if (Array.isArray(result)) {
+            const allPassed = result.every((r) => r.status === 'Passed');
+
+            if (pubSub) {
+                for (const iterationResult of result) {
+                    this.publishComplete(pubSub, userPayload, iterationResult);
+                }
+            }
+
+            LogStatus(`[RunTestResolver] Test completed: ${result.length} iterations, ${allPassed ? 'all passed' : 'some failed'} in ${executionTime}ms`);
+            return { success: allPassed, result: JSON.stringify(result), executionTimeMs: executionTime };
+        }
+
+        const passed = result.status === 'Passed';
+
+        if (pubSub && result.testRunId) {
+            this.publishComplete(pubSub, userPayload, result);
+        }
+
+        LogStatus(`[RunTestResolver] Test completed: ${result.status} in ${executionTime}ms`);
+        return { success: passed, result: JSON.stringify(result), executionTimeMs: executionTime };
+    }
+
+    // ===== Input Parsing =====
+
+    private parseVariablesJson(variables: string | undefined): TestRunVariables | undefined {
+        if (!variables) return undefined;
+        try {
+            return JSON.parse(variables) as TestRunVariables;
+        } catch (e) {
+            LogError(`[RunTestResolver] Failed to parse variables: ${variables}`);
+            return undefined;
+        }
+    }
+
+    private parseJsonArray(json: string | undefined, fieldName: string): string[] | undefined {
+        if (!json) return undefined;
+        try {
+            return JSON.parse(json) as string[];
+        } catch (e) {
+            LogError(`[RunTestResolver] Failed to parse ${fieldName}: ${json}`);
+            return undefined;
+        }
     }
 
     // ===== Progress Callbacks =====
@@ -349,25 +425,26 @@ export class RunTestResolver extends ResolverBase {
             step: string;
             percentage: number;
             message: string;
-            metadata?: any;
+            metadata?: Record<string, unknown>;
         }) => {
             LogStatus(`[RunTestResolver] Progress: ${progress.step} - ${progress.percentage}%`);
 
-            // Get test run from metadata
-            const testRun = progress.metadata?.testRun;
+            const testRun = progress.metadata?.testRun as Record<string, unknown> | undefined;
 
             const progressMsg: TestExecutionStreamMessage = {
                 sessionId: userPayload.sessionId || '',
-                testRunId: testRun?.ID || testId,
+                testRunId: (testRun as { ID?: string })?.ID || testId,
                 type: 'progress',
-                testRun: testRun ? testRun.GetAll() : undefined,
+                testRun: testRun && typeof (testRun as { GetAll?: () => Record<string, unknown> }).GetAll === 'function'
+                    ? (testRun as { GetAll: () => Record<string, unknown> }).GetAll()
+                    : undefined,
                 progress: {
                     currentStep: progress.step,
                     percentage: progress.percentage,
                     message: progress.message,
-                    testName: progress.metadata?.testName,
-                    driverType: progress.metadata?.driverType,
-                    oracleEvaluation: progress.metadata?.oracleType
+                    testName: progress.metadata?.testName as string | undefined,
+                    driverType: progress.metadata?.driverType as string | undefined,
+                    oracleEvaluation: progress.metadata?.oracleType as string | undefined
                 },
                 timestamp: new Date()
             };
@@ -402,6 +479,8 @@ export class RunTestResolver extends ResolverBase {
         };
     }
 
+    // ===== PubSub Publishing =====
+
     private publishProgress(pubSub: PubSubEngine, data: TestExecutionStreamMessage, userPayload: UserPayload) {
         pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
             message: JSON.stringify({
@@ -414,7 +493,7 @@ export class RunTestResolver extends ResolverBase {
         });
     }
 
-    private publishComplete(pubSub: PubSubEngine, userPayload: UserPayload, result: any) {
+    private publishComplete(pubSub: PubSubEngine, userPayload: UserPayload, result: EngineTestRunResult) {
         pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
             message: JSON.stringify({
                 resolver: 'RunTestResolver',
@@ -449,4 +528,120 @@ export class RunTestResolver extends ResolverBase {
             sessionId: userPayload.sessionId,
         });
     }
+
+    /**
+     * Publish a fire-and-forget completion event for a single test.
+     * Includes testId for client-side correlation and the full result.
+     */
+    private publishFireAndForgetComplete(
+        pubSub: PubSubEngine,
+        userPayload: UserPayload,
+        testId: string,
+        testRunResult: TestRunResult
+    ) {
+        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+            message: JSON.stringify({
+                resolver: 'RunTestResolver',
+                type: 'FireAndForgetComplete',
+                status: 'ok',
+                data: {
+                    sessionId: userPayload.sessionId,
+                    testId,
+                    type: 'complete',
+                    success: testRunResult.success,
+                    errorMessage: testRunResult.errorMessage,
+                    executionTimeMs: testRunResult.executionTimeMs,
+                    result: testRunResult.result,
+                    timestamp: new Date()
+                },
+            }),
+            sessionId: userPayload.sessionId,
+        });
+    }
+
+    /**
+     * Publish a fire-and-forget error event for a single test.
+     */
+    private publishFireAndForgetError(
+        pubSub: PubSubEngine,
+        userPayload: UserPayload,
+        testId: string,
+        errorMessage: string
+    ) {
+        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+            message: JSON.stringify({
+                resolver: 'RunTestResolver',
+                type: 'FireAndForgetComplete',
+                status: 'ok',
+                data: {
+                    sessionId: userPayload.sessionId,
+                    testId,
+                    type: 'complete',
+                    success: false,
+                    errorMessage,
+                    result: JSON.stringify({ success: false, errorMessage }),
+                    timestamp: new Date()
+                },
+            }),
+            sessionId: userPayload.sessionId,
+        });
+    }
+
+    /**
+     * Publish a fire-and-forget completion event for a test suite.
+     * Includes suiteId for client-side correlation and the full result.
+     */
+    private publishFireAndForgetSuiteComplete(
+        pubSub: PubSubEngine,
+        userPayload: UserPayload,
+        suiteId: string,
+        suiteRunResult: TestSuiteRunResult
+    ) {
+        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+            message: JSON.stringify({
+                resolver: 'RunTestResolver',
+                type: 'FireAndForgetSuiteComplete',
+                status: 'ok',
+                data: {
+                    sessionId: userPayload.sessionId,
+                    suiteId,
+                    type: 'complete',
+                    success: suiteRunResult.success,
+                    errorMessage: suiteRunResult.errorMessage,
+                    executionTimeMs: suiteRunResult.executionTimeMs,
+                    result: suiteRunResult.result,
+                    timestamp: new Date()
+                },
+            }),
+            sessionId: userPayload.sessionId,
+        });
+    }
+
+    /**
+     * Publish a fire-and-forget error event for a test suite.
+     */
+    private publishFireAndForgetSuiteError(
+        pubSub: PubSubEngine,
+        userPayload: UserPayload,
+        suiteId: string,
+        errorMessage: string
+    ) {
+        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+            message: JSON.stringify({
+                resolver: 'RunTestResolver',
+                type: 'FireAndForgetSuiteComplete',
+                status: 'ok',
+                data: {
+                    sessionId: userPayload.sessionId,
+                    suiteId,
+                    type: 'complete',
+                    success: false,
+                    errorMessage,
+                    result: JSON.stringify({ success: false, errorMessage }),
+                    timestamp: new Date()
+                },
+            }),
+            sessionId: userPayload.sessionId,
+        });
+    }
 }