ff-automationv2 2.1.3-beta.5 → 2.1.3-beta.6

package/RELEASE_GUIDE.md

@@ -3,7 +3,7 @@
 git checkout feature/your-feature-name
 git add .
 git commit -m "feat: new changes"
-git pull --rebase
+git pull 
 npm version prerelease --preid=beta
 git push --follow-tags
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ff-automationv2",
-  "version": "2.1.3-beta.5",
+  "version": "2.1.3-beta.6",
   "private": false,
   "type": "module",
   "description": "This lib is used to automate the manual testcase",

package/src/automation/actions/executor.ts

@@ -27,7 +27,7 @@ export class ActionExecutor implements IActionExecutor {
             });
         }
         catch (error) {
-            throw new Error(`Click action failed ${error}`);
+            throw error;
         }
     }
 
@@ -39,7 +39,7 @@ export class ActionExecutor implements IActionExecutor {
             });
         }
         catch (error) {
-            throw new Error(`Click action failed ${error}`);
+            throw error;
         }
     }
 
@@ -51,7 +51,7 @@ export class ActionExecutor implements IActionExecutor {
             });
         }
         catch (error) {
-            throw new Error(`Click action failed ${error}`);
+            throw error;
         }
     }
 
@@ -65,7 +65,7 @@ export class ActionExecutor implements IActionExecutor {
             });
         }
         catch (error) {
-            throw new Error(`Click action failed ${error}`);
+            throw error;
         }
     }
     async click(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
@@ -83,7 +83,7 @@ export class ActionExecutor implements IActionExecutor {
             });
         }
         catch (error) {
-            throw new Error(`Click action failed ${error}`);
+            throw error;
         }
     }
     async enterInput(selector: string, value: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
@@ -102,7 +102,7 @@ export class ActionExecutor implements IActionExecutor {
             });
         }
         catch (error) {
-            throw new Error(`Click action failed ${error}`);
+            throw error;
         }
     }
     async maximize(): Promise<void> {
@@ -113,7 +113,7 @@ export class ActionExecutor implements IActionExecutor {
             });
         }
         catch (error) {
-            throw new Error(`Click action failed ${error}`);
+            throw error;
         }
     }
 
@@ -132,7 +132,7 @@ export class ActionExecutor implements IActionExecutor {
             });
         }
         catch (error) {
-            throw new Error(`Click action failed ${error}`);
+            throw error;
         }
     }
 
@@ -152,7 +152,7 @@ export class ActionExecutor implements IActionExecutor {
             });
         }
         catch (error) {
-            throw new Error(`Click action failed ${error}`);
+            throw error;
         }
     }
 

package/src/automation/actions/interaction/click.ts

@@ -20,6 +20,6 @@ export async function click(args: ClickInterface): Promise<void> {
                 }]
             });
     } catch (error: any) {
-        throw new Error(`Click action failed ${error}`);
+        throw new Error(`Click action failed :`, { cause: error });
     }
 }

package/src/automation/actions/interaction/enterInput.ts

@@ -29,7 +29,7 @@ export async function enterInput(args: EnterInputInterface): Promise<void> {
 
     }
     catch (error: any) {
-        throw new Error(`enter action failed ${error}`);
+        throw new Error(`enter action failed:`, { cause: error });
     }
 
 }

package/src/core/interfaces/automationRunnerInterface.ts

@@ -1,3 +1,4 @@
+import { AutomationRequest } from "../../core/interfaces/executionDetails.js";
 export interface IAutomationRunner {
-  run(): Promise<void>;
+  run(args:AutomationRequest): Promise<void>;
 }

package/src/core/main/actionHandlerFactory.ts

@@ -24,107 +24,112 @@ export function createActionHandlers(
                     await fn(executor, result);
                 }
                 catch (error) {
-                    throw new Error(`Error occuried in createActionHandlers , error : ${error}`)
+                    throw error
                 }
             };
+    try {
+        return {
+
+            open: async () => {
+                try {
+                    await context.session.open({
+                        browserName: "chrome",
+                        pageLoad,
+                        implicit
+                    });
+
+                    context.executor = new ActionExecutor(
+                        await context.session.getCurrentBrowser(),
+                        context.scriptAppender,
+                        context.locator,
+                        context.request.platform
+                    );
+
+                    context.scriptAppender.add({
+                        nlpName: "OpenBrowser",
+                        elementsData: [],
+                        stepInputs: []
+                    });
+                }
+                catch (error) {
+                    throw new Error(`Error occuried in createActionHandlers , error : ${error}`)
+                }
+            },
 
-    return {
-
-        open: async () => {
-            try {
-                await context.session.open({
-                    browserName: "chrome",
-                    pageLoad,
-                    implicit
-                });
-
-                context.executor = new ActionExecutor(
-                    await context.session.getCurrentBrowser(),
-                    context.scriptAppender,
-                    context.locator,
-                    context.request.platform
+            close: async () => {
+                try {
+                    await context.session.close();
+                }
+                catch (error) {
+                    throw new Error(`Error occuried in createActionHandlers , error : ${error}`)
+                }
+            },
+
+            navigate: withExecutor(async (executor, result) => {
+                await executor.navigate(result.response.keywords[0]);
+            }),
+
+            maximize: withExecutor(async (executor) => {
+                await executor.maximize();
+            }),
+
+            goBack: withExecutor(async (executor) => {
+                await executor.goBack();
+            }),
+
+            refresh: withExecutor(async (executor) => {
+                await executor.refresh();
+            }),
+
+            wait: withExecutor(async (executor, result) => {
+                await executor.wait(result.value);
+            }),
+
+            click: withExecutor(async (executor, result) => {
+                await executor.click(
+                    result.pageDOM,
+                    result.selector,
+                    result.fireflinkIndex,
+                    result.elementName,
+                    result.elementType
                 );
+            }),
+
+            enter: withExecutor(async (executor, result) => {
+                await executor.enterInput(
+                    result.selector,
+                    result.value,
+                    result.fireflinkIndex,
+                    result.pageDOM,
+                    result.elementName,
+                    result.elementType
+                );
+            }),
+
+            clear: withExecutor(async (executor, result) => {
+                await executor.clear(
+                    result.pageDOM,
+                    result.selector,
+                    result.fireflinkIndex,
+                    result.elementName,
+                    result.elementType
+                );
+            }),
+
+            clearThenEnterInput: withExecutor(async (executor, result) => {
+                await executor.clearAndEnter(
+                    result.pageDOM,
+                    result.selector,
+                    result.value,
+                    result.fireflinkIndex,
+                    result.elementName,
+                    result.elementType
+                );
+            }),
+        };
+    }
+    catch (error) {
+        throw error
+    }
 
-                context.scriptAppender.add({
-                    nlpName: "OpenBrowser",
-                    elementsData: [],
-                    stepInputs: []
-                });
-            }
-            catch (error) {
-                throw new Error(`Error occuried in createActionHandlers , error : ${error}`)
-            }
-        },
-
-        close: async () => {
-            try {
-                await context.session.close();
-            }
-            catch (error) {
-                throw new Error(`Error occuried in createActionHandlers , error : ${error}`)
-            }
-        },
-
-        navigate: withExecutor(async (executor, result) => {
-            await executor.navigate(result.response.keywords[0]);
-        }),
-
-        maximize: withExecutor(async (executor) => {
-            await executor.maximize();
-        }),
-
-        goBack: withExecutor(async (executor) => {
-            await executor.goBack();
-        }),
-
-        refresh: withExecutor(async (executor) => {
-            await executor.refresh();
-        }),
-
-        wait: withExecutor(async (executor, result) => {
-            await executor.wait(result.value);
-        }),
-
-        click: withExecutor(async (executor, result) => {
-            await executor.click(
-                result.pageDOM,
-                result.selector,
-                result.fireflinkIndex,
-                result.elementName,
-                result.elementType
-            );
-        }),
-
-        enter: withExecutor(async (executor, result) => {
-            await executor.enterInput(
-                result.selector,
-                result.value,
-                result.fireflinkIndex,
-                result.pageDOM,
-                result.elementName,
-                result.elementType
-            );
-        }),
-
-        clear: withExecutor(async (executor, result) => {
-            await executor.clear(
-                result.pageDOM,
-                result.selector,
-                result.fireflinkIndex,
-                result.elementName,
-                result.elementType
-            );
-        }),
-
-        clearThenEnterInput: withExecutor(async (executor, result) => {
-            await executor.clearAndEnter(
-                result.pageDOM,
-                result.selector,
-                result.value,
-                result.fireflinkIndex,
-                result.elementName,
-                result.elementType
-            );
-        }),
-    };
 }

package/src/core/main/runAutomationScript.ts

@@ -16,12 +16,10 @@ import { logger } from "../../utils/logger/logData.js"
 export class AutomationRunner implements IAutomationRunner {
   static sessionTerminationDetails: Record<string, boolean> = {};
   constructor(
-    private readonly request: AutomationRequest,
     private pageLoad: number = 20000,
     private implicit: number = 15000,
-    private tokensConsumed: number = 0
 
-  ) { AutomationRunner.sessionTerminationDetails[request.testCaseId] = false }
+  ) { }
 
   static getSessionTerminationInfo(testCaseId: string): boolean {
     return AutomationRunner.sessionTerminationDetails[testCaseId]
@@ -35,16 +33,14 @@ export class AutomationRunner implements IAutomationRunner {
     domInfo: any,
     extractedRelevantDom: any,
     stepProcessor: StepProcessor,
-    scriptRunner: ScriptRunner
+    scriptRunner: ScriptRunner,
+    request: AutomationRequest
   ) {
     try {
       logger.info("Starting cleanup process...");
       if (context?.session) {
         try {
           const browser = await context.session.getCurrentBrowser();
-          // if (browser) {
-          //   await browser.deleteSession?.();
-          // }
         } catch (e) {
           logger.error("Browser cleanup failed:", e);
         }
@@ -59,7 +55,7 @@ export class AutomationRunner implements IAutomationRunner {
 
       scriptRunner = null as any;
 
-      delete AutomationRunner.sessionTerminationDetails[this.request.testCaseId];
+      delete AutomationRunner.sessionTerminationDetails[request.testCaseId];
 
       if (global.gc) {
         global.gc();
@@ -73,18 +69,19 @@ export class AutomationRunner implements IAutomationRunner {
   }
 
 
-  async run(): Promise<void> {
+  async run(request: AutomationRequest): Promise<void> {
+    AutomationRunner.sessionTerminationDetails[request.testCaseId] = false;
     const apiService = new FireFlinkApiService();
     const scriptRunner = new ScriptRunner(apiService);
-    const context = new ExecutionContext(this.request);
+    const context = new ExecutionContext(request);
     const configProvider = new ServiceProviderBaseUrlProvider();
-    const baseUrl = configProvider.getBaseUrl(this.request.serviceProvider);
+    const baseUrl = configProvider.getBaseUrl(request.serviceProvider);
     let domInfo: any = null;
     let extractedRelevantDom: any = null;
-    const llm = new llmAction(this.request.apiKey, baseUrl, this.request.model, this.request.visionApikey);
+    const llm = new llmAction(request.apiKey, baseUrl, request.model, request.visionApikey);
     const stepProcessor = new StepProcessor(llm);
 
-    const stepResult = await stepProcessor.getLLMResponse({ type: PromptType.USER_STORY_TO_LIST, args: {}, input: { userStory: this.request.userStory } });
+    const stepResult = await stepProcessor.getLLMResponse({ type: PromptType.USER_STORY_TO_LIST, args: {}, input: { userStory: request.userStory } });
 
     const actionHandlers = createActionHandlers(
       context,
@@ -103,7 +100,7 @@ export class AutomationRunner implements IAutomationRunner {
 
     for (const step of listOfSteps) {
       try {
-        if (AutomationRunner.getSessionTerminationInfo(this.request.testCaseId)) { break; }
+        if (AutomationRunner.getSessionTerminationInfo(request.testCaseId)) { break; }
 
         logger.info
           (
@@ -167,7 +164,7 @@ export class AutomationRunner implements IAutomationRunner {
         await logger.saveJSON(extractedRelevantDom, `relevant-dom-${stepCount}`);
         let stepResult: any;
         if (action == "verify") {
-          const stepResult = await stepProcessor.getLLMResponse({
+          stepResult = await stepProcessor.getLLMResponse({
             type: PromptType.VERIFY_PROMPT,
             args: {
               extractedDomJson: JSON.stringify(extractedRelevantDom, null, 2),
@@ -224,35 +221,35 @@ export class AutomationRunner implements IAutomationRunner {
           elementsData: [],
           stepInputs: []
         });
-
         logger.error(`Error executing step "${step}":`, error);
         break;
       }
     }
     const payload: IPayload = {
-      scriptName: this.request.scriptName,
-      scriptType: this.request.scriptType,
-      projectId: this.request.projectId,
-      testCaseId: this.request.testCaseId,
-      promptId: this.request.promptId,
-      pageDetails: this.request.pageDetails,
-      generatedBy: this.request.generatedBy,
-      webSocketId: this.request.webSocketId,
-      licenseType: this.request.licenseType,
-      licenseId: this.request.licenseId,
-      userId: this.request.userId,
-      topic: this.request.topic,
-      projectType: this.request.projectType,
+      scriptName: request.scriptName,
+      scriptType: request.scriptType,
+      projectId: request.projectId,
+      testCaseId: request.testCaseId,
+      promptId: request.promptId,
+      pageDetails: request.pageDetails,
+      generatedBy: request.generatedBy,
+      webSocketId: request.webSocketId,
+      licenseType: request.licenseType,
+      licenseId: request.licenseId,
+      userId: request.userId,
+      topic: request.topic,
+      projectType: request.projectType,
       tokensConsumed: (await stepProcessor.getResultTokenUsage()).totalTokens,
     }
     try {
-      // await scriptRunner.runScriptFromPayload(
-      //   context.scriptAppender.getData(),
-      //   payload,
-      //   this.request.token,
-      //   this.request.serverHost
-      // );
+      await scriptRunner.runScriptFromPayload(
+        context.scriptAppender.getData(),
+        payload,
+        request.token,
+        request.serverHost
+      );
     } catch (error: any) {
+
       throw new Error(
         "Failed to send payload to FireFlink API:", { cause: error }
       );
@@ -263,7 +260,8 @@ export class AutomationRunner implements IAutomationRunner {
         domInfo,
         extractedRelevantDom,
         stepProcessor,
-        scriptRunner
+        scriptRunner,
+        request
       );
     }
   }

package/src/utils/logger/logData.ts

@@ -40,15 +40,38 @@ export const logger = {
 
         fs.appendFileSync(logFilePath, message, "utf-8");
     },
-
     error: (...args: any[]) => {
-        const formattedArgs = args.map(arg =>
-            typeof arg === "object"
-                ? JSON.stringify(arg, null, 2)
-                : arg
-        );
+        const formatted = args.map(arg => {
+            if (arg instanceof Error) {
+                let output = arg.stack || `${arg.name}: ${arg.message}`;
+                output = output.replace(
+                    /invalid session id:\s*invalid session id:/gi,
+                    "invalid session id:"
+                );
+
+                if (arg.cause instanceof Error) {
+                    let causeStack = arg.cause.stack || "";
+
+                    causeStack = causeStack.replace(
+                        /invalid session id:\s*invalid session id:/gi,
+                        "invalid session id:"
+                    );
+
+                    output += `\nCaused by: ${causeStack}`;
+                }
+
+                return output;
+            }
+
+            if (typeof arg === "object") {
+                return JSON.stringify(arg, null, 2);
+            }
+
+            return String(arg);
+        });
 
-        const message = `[ERROR] ${istDate}+05:30 - ${formattedArgs.join(" ")}\n`;
+        const message =
+            `[ERROR] ${new Date().toISOString()} - ${formatted.join(" ")}\n`;
 
         fs.appendFileSync(logFilePath, message, "utf-8");
     },