Merge pull request #252 from parthlambdatest/Dot-4847

Release Version: 4.1.5

Author: sushobhit-lt

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lambdatest/smartui-cli",
-  "version": "4.1.4",
+  "version": "4.1.5",
   "description": "A command line interface (CLI) to run SmartUI tests on LambdaTest",
   "files": [
     "dist/**/*"

src/lib/ctx.ts

@@ -98,7 +98,9 @@ export default (options: Record<string, string>): Context => {
             delayedUpload: config.delayedUpload ?? false,
             useGlobalCache: config.useGlobalCache ?? false,
             ignoreHTTPSErrors: config.ignoreHTTPSErrors ?? false,
-            skipBuildCreation: config.skipBuildCreation ?? false
+            skipBuildCreation: config.skipBuildCreation ?? false,
+            tunnel: config.tunnel ?? false,
+            tunnelName: config.tunnelName || ''
         },
         uploadFilePath: '',
         webStaticConfig: [],
@@ -116,6 +118,11 @@ export default (options: Record<string, string>): Context => {
             url: ''
         },
         args: {},
+        tunnelDetails: {
+            tunnelPort: -1,
+            tunnelHost: '',
+            tunnelName: ''
+        },
         options: {
             parallel: parallelObj,
             force: options.force ? true : false,

src/lib/httpClient.ts

@@ -102,7 +102,11 @@ export default class httpClient {
                         headers: resp.headers,
                         body: resp.data
                     })}`)
-                    return resp.data;
+                    if (resp.data !== ""){
+                        return resp.data;
+                    } else {
+                        return resp;
+                    }
                 } else {
                     log.debug(`empty response: ${JSON.stringify(resp)}`)
                     return {};
@@ -155,7 +159,8 @@ export default class httpClient {
                 git,
                 config,
                 buildName,
-                isStartExec
+                isStartExec,
+                packageVersion: pkgJSON.version
             }
         }, log)
     }
@@ -169,6 +174,17 @@ export default class httpClient {
         }, log);
     }
 
+    getTunnelDetails(tunnelName: string, log: Logger) {
+        return this.request({
+            url: '/tunnel',
+            method: 'POST',
+            data: { 
+                tunnelName: tunnelName
+            }
+        }, log)
+    }
+    
+
     ping(buildId: string, log: Logger) {
         return this.request({
             url: '/build/ping',

src/lib/processSnapshot.ts

@@ -306,7 +306,15 @@ export default async function processSnapshot(snapshot: Snapshot, ctx: Context):
         }
     }
 
-        // process for every viewport
+    if (ctx.config.tunnel) {
+        if (ctx.tunnelDetails && ctx.tunnelDetails.tunnelPort != -1 && ctx.tunnelDetails.tunnelHost != '') {
+            const tunnelAddress = `http://${ctx.tunnelDetails.tunnelHost}:${ctx.tunnelDetails.tunnelPort}`;
+            processedOptions.tunnelAddress = tunnelAddress;
+            ctx.log.debug(`Tunnel address added to processedOptions: ${tunnelAddress}`);
+        }
+    }
+
+    // process for every viewport
     let navigated: boolean = false;
     let previousDeviceType: string | null = null;
 
@@ -354,7 +362,19 @@ export default async function processSnapshot(snapshot: Snapshot, ctx: Context):
                 ctx.log.debug(`Navigated to ${snapshot.url}`);
             } catch (error: any) {
                 ctx.log.debug(`Navigation to discovery page failed; ${error}`)
-                throw new Error(error.message)
+                if (error && error.name && error.name === 'TimeoutError') {
+                    ctx.log.debug(`Payload uploaded tough navigation to discovery page failed; ${error}`)
+                    return {
+                        processedSnapshot: {
+                            name: snapshot.name,
+                            url: snapshot.url,
+                            dom: Buffer.from(snapshot.dom.html).toString('base64'),
+                            resources: cache,
+                            options: processedOptions
+                        },
+                        warnings: [...optionWarnings, ...snapshot.dom.warnings]
+                    };
+                }
             }
 
         }

src/lib/schemaValidation.ts

@@ -173,6 +173,14 @@ const ConfigSchema = {
             type: "boolean",
             errorMessage: "Invalid config; skipBuildCreation must be true/false"
         },
+        tunnel: {
+            type: "boolean",
+            errorMessage: "Invalid config; tunnel must be true/false"
+        },
+        tunnelName: {
+            type: "string",
+            errorMessage: "Invalid config; tunnelName must be string"
+        },
     },
     anyOf: [
         { required: ["web"] },

src/lib/snapshotQueue.ts

@@ -357,8 +357,24 @@ export default class Queue {
                             const presignedResponse = await this.ctx.client.getS3PresignedURLForSnapshotUpload(this.ctx, processedSnapshot.name, snapshotUuid);
                             const uploadUrl = presignedResponse.data.url;
 
-                            await this.ctx.client.uploadSnapshotToS3(this.ctx, uploadUrl, processedSnapshot)
-                            await this.ctx.client.processSnapshot(this.ctx, processedSnapshot, snapshotUuid, discoveryErrors);
+                            let snapshotUploadResponse = await this.ctx.client.uploadSnapshotToS3(this.ctx, uploadUrl, processedSnapshot);
+                            if (!snapshotUploadResponse || Object.keys(snapshotUploadResponse).length === 0) {
+                                this.ctx.log.debug(`snapshot failed; Unable to upload dom to S3`);
+                                this.processedSnapshots.push({ name: snapshot?.name, error: `snapshot failed; Unable to upload dom to S3` });
+                                if (this.ctx.browser) {
+                                    for (let context of this.ctx.browser.contexts()) {
+                                        for (let page of context.pages()) {
+                                            await page.close();
+                                            this.ctx.log.debug(`Closed browser page for snapshot ${snapshot.name}`);
+                                        }
+                                        await context.close();
+                                        this.ctx.log.debug(`Closed browser context for snapshot ${snapshot.name}`);
+                                    }
+                                }
+                                this.processNext();
+                            } else {
+                                await this.ctx.client.processSnapshot(this.ctx, processedSnapshot, snapshotUuid, discoveryErrors);
+                            }
                         } else {
                             await this.ctx.client.uploadSnapshot(this.ctx, processedSnapshot,  discoveryErrors);
                         }

src/tasks/createBuildExec.ts

@@ -19,12 +19,38 @@ export default (ctx: Context): ListrTask<Context, ListrRendererFactory, ListrRen
                         baseline: resp.data.baseline,
                         useKafkaFlow: resp.data.useKafkaFlow || false,
                     }
+                    if (ctx.build.id === '') {
+                        ctx.log.debug('Build creation failed: Build ID is empty');
+                        task.output = chalk.red('Build creation failed: Build ID is empty');
+                        throw new Error('SmartUI build creation failed');
+                    }
                     task.output = chalk.gray(`build id: ${resp.data.buildId}`);
                     task.title = 'SmartUI build created'
                 } else {
                     task.output = chalk.gray(`Empty PROJECT_TOKEN and PROJECT_NAME. Skipping Creation of Build!`)
                     task.title = 'Skipped SmartUI build creation'
                 }
+
+                if (ctx.config.tunnel) {
+                    let tunnelResp = await ctx.client.getTunnelDetails(ctx.config.tunnelName, ctx.log);
+                    ctx.log.debug(`Tunnel Response: ${JSON.stringify(tunnelResp)}`)
+                    if (tunnelResp && tunnelResp.data && tunnelResp.data.host && tunnelResp.data.port && tunnelResp.data.tunnel_name) {
+                        ctx.tunnelDetails = {
+                            tunnelHost: tunnelResp.data.host,
+                            tunnelPort: tunnelResp.data.port,
+                            tunnelName: tunnelResp.data.tunnel_name
+                        }
+                        ctx.log.debug(`Tunnel Details: ${JSON.stringify(ctx.tunnelDetails)}`)
+                    } else if (tunnelResp && tunnelResp.error) {
+                        if (tunnelResp.error.message) {
+                            if (tunnelResp.error.code && tunnelResp.error.code === 400) {
+                                ctx.log.warn(tunnelResp.error.message)
+                            } else {
+                                ctx.log.warn(`Error while fetch tunnel details; Either tunnel is not running or tunnel parameters are different`)
+                            }
+                        }
+                    }
+                }
             } catch (error: any) {
                 ctx.log.debug(error);
                 task.output = chalk.gray(error.message);

src/types.ts

@@ -32,6 +32,8 @@ export interface Context {
         figma?: FigmaWebConfig;
         ignoreHTTPSErrors : boolean;
         skipBuildCreation?: boolean;
+        tunnel?: boolean;
+        tunnelName?: string;
     };
     uploadFilePath: string;
     webStaticConfig: WebStaticConfig;
@@ -40,6 +42,11 @@ export interface Context {
     args: {
         execCommand?: Array<string>
     }
+    tunnelDetails: {
+        tunnelPort: number;
+        tunnelHost: string;
+        tunnelName: string;
+    }
     options: {
         parallel?: number,
         force?: boolean,