Merge pull request #274 from parthlambdatest/Dot-4961

[Dot-4961] Implement node tunnel in cli

Author: parthlambdatest

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lambdatest/smartui-cli",
-  "version": "4.1.9",
+  "version": "4.1.10",
   "description": "A command line interface (CLI) to run SmartUI tests on LambdaTest",
   "files": [
     "dist/**/*"
@@ -30,6 +30,7 @@
     "@types/cross-spawn": "^6.0.4",
     "@types/node": "^20.8.9",
     "@types/which": "^3.0.2",
+    "@lambdatest/node-tunnel": "^4.0.9",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
     "axios": "^1.6.0",

src/commander/exec.ts

@@ -11,6 +11,7 @@ import exec from '../tasks/exec.js'
 import processSnapshots from '../tasks/processSnapshot.js'
 import finalizeBuild from '../tasks/finalizeBuild.js'
 import snapshotQueue from '../lib/snapshotQueue.js'
+import startTunnel from '../tasks/startTunnel.js'
 
 const command = new Command();
 
@@ -42,6 +43,7 @@ command
                 authExec(ctx),
                 startServer(ctx),
                 getGitInfo(ctx),
+                ...(ctx.config.tunnel && ctx.config.tunnel?.type === 'auto' ? [startTunnel(ctx)] : []),
                 createBuildExec(ctx),
                 exec(ctx),
                 processSnapshots(ctx),
@@ -63,6 +65,7 @@ command
             await tasks.run(ctx);
         } catch (error) {
             ctx.log.info('\nRefer docs: https://www.lambdatest.com/support/docs/smart-visual-regression-testing/');
+            throw new Error();
         }
     })
 

src/lib/ctx.ts

@@ -1,4 +1,4 @@
-import { Context, Env, WebConfig, MobileConfig, basicAuth } from '../types.js'
+import { Context, Env, WebConfig, MobileConfig, basicAuth, tunnelConfig } from '../types.js'
 import constants from './constants.js'
 import { version } from '../../package.json'
 import { validateConfig } from './schemaValidation.js'
@@ -12,6 +12,7 @@ export default (options: Record<string, string>): Context => {
     let webConfig: WebConfig;
     let mobileConfig: MobileConfig;
     let basicAuthObj: basicAuth
+    let tunnelObj: tunnelConfig
     let config = constants.DEFAULT_CONFIG;
     let port: number;
     let resolutionOff: boolean;
@@ -77,7 +78,10 @@ export default (options: Record<string, string>): Context => {
     }
     if (config.basicAuthorization) {
         basicAuthObj = config.basicAuthorization
-    }   
+    }
+    if (config.tunnel) {
+        tunnelObj = config.tunnel
+    }
 
     return {
         env: env,
@@ -100,8 +104,7 @@ export default (options: Record<string, string>): Context => {
             useGlobalCache: config.useGlobalCache ?? false,
             ignoreHTTPSErrors: config.ignoreHTTPSErrors ?? false,
             skipBuildCreation: config.skipBuildCreation ?? false,
-            tunnel: config.tunnel ?? false,
-            tunnelName: config.tunnelName || '',
+            tunnel: tunnelObj,
             userAgent: config.userAgent || ''
         },
         uploadFilePath: '',
@@ -144,6 +147,8 @@ export default (options: Record<string, string>): Context => {
         isSnapshotCaptured: false,
         sessionCapabilitiesMap: new Map<string, any[]>(),
         buildToSnapshotCountMap: new Map<string, number>(),
-        fetchResultsForBuild: new Array<string>
+        fetchResultsForBuild: new Array<string>,
+        orgId: 0,
+        userId: 0
     }
 }

src/lib/httpClient.ts

@@ -45,14 +45,17 @@ export default class httpClient {
 
         this.axiosInstance = axios.create(axiosConfig);
 
-
         this.axiosInstance.interceptors.request.use((config) => {
             if (!config.headers['projectToken']) {
                 config.headers['projectToken'] = this.projectToken;
             }
             config.headers['projectName'] = this.projectName;
-            config.headers['username'] = this.username;
-            config.headers['accessKey'] = this.accessKey;
+            if (!config.headers['username'] || config.headers['username'] === '') {
+                config.headers['username'] = this.username;
+            }
+            if (!config.headers['accessKey'] || config.headers['accessKey'] === '') {
+                config.headers['accessKey'] = this.accessKey;
+            }
             return config;
         });
 
@@ -151,6 +154,45 @@ export default class httpClient {
         }
     }
 
+    async authExec(ctx: Context, log: Logger, env: Env): Promise<{ authResult: number, orgId: number, userId: number }> {
+        let authResult = 1;
+        let userName = '';
+        let passWord = '';
+        if (ctx.config.tunnel && ctx.config.tunnel?.user && ctx.config.tunnel?.key) {
+            userName = ctx.config.tunnel.user
+            passWord = ctx.config.tunnel.key
+        }
+        if (this.projectToken) {
+            authResult = 0;
+        }
+        const response = await this.request({
+            url: '/token/verify',
+            method: 'GET',
+            headers: {
+                username: userName,
+                accessKey: passWord
+            }
+        }, log);
+        if (response && response.projectToken) {
+            let orgId = 0;
+            let userId = 0;
+            this.projectToken = response.projectToken;
+            env.PROJECT_TOKEN = response.projectToken;
+            if (response.message && response.message.includes('Project created successfully')) {
+                authResult = 2;
+            }
+            if (response.orgId) {
+                orgId = response.orgId
+            }
+            if (response.userId) {
+                userId = response.userId
+            }
+            return { authResult, orgId, userId };
+        } else {
+            throw new Error('Authentication failed, project token not received. Refer to the smartui.log file for more information');
+        }
+    }
+
     createBuild(git: Git, config: any, log: Logger, buildName: string, isStartExec: boolean) {
         return this.request({
             url: '/build',
@@ -174,16 +216,24 @@ export default class httpClient {
         }, log);
     }
 
-    getTunnelDetails(tunnelName: string, log: Logger) {
+    getTunnelDetails(ctx: Context, log: Logger) {
+        const data: any = { 
+            orgId: ctx.orgId,
+            userId: ctx.userId,
+            userName: ctx.config.tunnel?.user,
+            password: ctx.config.tunnel?.key
+        };
+    
+        if (ctx.config.tunnel?.tunnelName) {
+            data.tunnelName = ctx.config.tunnel.tunnelName;
+        }
+    
         return this.request({
             url: '/tunnel',
             method: 'POST',
-            data: { 
-                tunnelName: tunnelName
-            }
-        }, log)
+            data: data
+        }, log);
     }
-    
 
     ping(buildId: string, log: Logger) {
         return this.request({

src/lib/schemaValidation.ts

@@ -189,12 +189,60 @@ const ConfigSchema = {
             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"
+            type: "object",
+            properties: {
+                type: {
+                    type: "string", 
+                    enum: ["auto", "manual"],
+                    errorMessage: "Invalid config; type is mandatory of type string having value auto or manual",
+                },
+                tunnelName: {
+                    type: "string",
+                    errorMessage: "Invalid config; tunnelName should be a string value"
+                },
+                user: {
+                    type: "string",
+                    errorMessage: "Invalid config; user should be a string value"
+                },
+                key: {
+                    type: "string",
+                    errorMessage: "Invalid config; key should be a string value"
+                },
+                port: {
+                    type: "string",
+                    errorMessage: "Invalid config; port should be a string value"
+                },
+                proxyHost: {
+                    type: "string",
+                    errorMessage: "Invalid config; proxyHost should be a string value"
+                },
+                proxyPort: {
+                    type: "number",
+                    errorMessage: "Invalid config; proxyPort should be an int value"
+                },
+                proxyUser: {
+                    type: "string",
+                    errorMessage: "Invalid config; proxyUser should be a string value"
+                },
+                proxyPass: {
+                    type: "string",
+                    errorMessage: "Invalid config; proxyPass should be a string value"
+                },
+                dir: {
+                    type: "string",
+                    errorMessage: "Invalid config; dir should be a string value"
+                },
+                v: {
+                    type: "boolean",
+                    errorMessage: "Invalid config; v should be a boolean value"
+                },
+                logFile: {
+                    type: "string",
+                    errorMessage: "Invalid config; logFile should be a string value"
+                },
+            },
+            required: ["type"],
+            additionalProperties: false
         },
         userAgent: {
             type: "string",

src/lib/snapshotQueue.ts

@@ -3,7 +3,7 @@ import { Snapshot, Context } from "../types.js";
 import constants from "./constants.js";
 import processSnapshot from "./processSnapshot.js"
 import { v4 as uuidv4 } from 'uuid';
-import { startPolling } from "./utils.js";
+import { startPolling, stopTunnelHelper } from "./utils.js";
 
 export default class Queue {
     private snapshots: Array<Snapshot> = [];
@@ -272,7 +272,7 @@ export default class Queue {
                 this.processingSnapshot = snapshot?.name;
                 let drop = false;
 
-                if (this.ctx.isStartExec) {
+                if (this.ctx.isStartExec && !this.ctx.config.tunnel) {
                     this.ctx.log.info(`Processing Snapshot: ${snapshot?.name}`);
                 }
 
@@ -344,6 +344,9 @@ export default class Queue {
                                     useKafkaFlow: resp.data.useKafkaFlow || false,
                                 }
                             } else {
+                                if (this.ctx.config.tunnel && this.ctx.config.tunnel?.type === 'auto') {
+                                    await stopTunnelHelper(this.ctx)
+                                }
                                 throw new Error('SmartUI capabilities are missing in env variables or in driver capabilities');
                             }
                             if (this.ctx.options.fetchResults) {