@mojaloop/ml-testing-toolkit-client-lib 1.12.0 → 1.12.1-snapshot.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mojaloop/ml-testing-toolkit-client-lib",
   "description": "Testing Toolkit Client Library",
-  "version": "1.12.0",
+  "version": "1.12.1-snapshot.2",
   "license": "Apache-2.0",
   "author": "Vijaya Kumar Guthi, ModusBox Inc. ",
   "contributors": [
@@ -75,9 +75,9 @@
     "@slack/webhook": "7.0.6",
     "atob": "2.1.2",
     "aws-sdk": "2.1692.0",
-    "axios": "1.12.2",
+    "axios": "1.13.2",
     "cli-table3": "0.6.5",
-    "commander": "14.0.1",
+    "commander": "14.0.2",
     "dotenv": "17.2.3",
     "fs": "0.0.1-security",
     "lodash": "4.17.21",
@@ -93,7 +93,7 @@
     "audit-ci": "7.1.0",
     "jest": "30.2.0",
     "jest-junit": "16.0.0",
-    "npm-check-updates": "19.1.1",
+    "npm-check-updates": "19.1.2",
     "nyc": "17.1.0",
     "parse-strings-in-object": "1.6.0",
     "pre-commit": "1.2.2",

package/src/extras/slack-broadcast.js

@@ -38,16 +38,89 @@ const millisecondsToTime = (milliseconds) => {
   return `${String(hours).padStart(2, '0')}:${String(minutes % 60).padStart(2, '0')}:${String(seconds % 60).padStart(2, '0')}`
 }
 
+/**
+ * Generate minimal Slack blocks for timeout with no test results
+ * @param {Object} progress - Partial progress object
+ * @param {string} reportURL - URL of the report
+ * @returns {Array} Slack blocks array
+ */
+/* istanbul ignore next */
+const generateTimeoutBlocks = (progress, reportURL) => {
+  const timeoutMessage = progress?.timeoutMessage || 'Tests execution timed out'
+  const slackBlocks = []
+
+  slackBlocks.push({
+    type: 'header',
+    text: {
+      type: 'plain_text',
+      text: '⏱️ Testing Toolkit - Test Execution Timeout',
+      emoji: true
+    }
+  })
+
+  let summaryText = '>⚠️ *' + timeoutMessage + '*\n\n'
+  summaryText += '>Test execution was terminated before completion.\n'
+  summaryText += '>No test results available.\n\n'
+
+  if (config.reportName) {
+    summaryText += '>Report Name: *' + config.reportName + '*\n'
+  }
+  if (config.environmentName) {
+    summaryText += '>Environment: *' + config.environmentName + '*\n'
+  }
+
+  slackBlocks.push({
+    type: 'section',
+    text: {
+      type: 'mrkdwn',
+      text: summaryText
+    }
+  })
+
+  if (config.extraSummaryInformation) {
+    const extraSummaryInformationArr = config.extraSummaryInformation.split(',')
+    let extraText = ''
+    extraSummaryInformationArr.forEach(info => {
+      const infoArr = info.split(':')
+      extraText += infoArr[0] + ': `' + infoArr[1] + '`\n'
+    })
+    if (extraText) {
+      slackBlocks.push({
+        type: 'section',
+        text: {
+          type: 'mrkdwn',
+          text: extraText
+        }
+      })
+    }
+  }
+
+  slackBlocks.push({
+    type: 'divider'
+  })
+
+  return slackBlocks
+}
+
 /**
  * @param {FinalReport} progress
  * @param {string} reportURL - URL of the report
  */
 const generateSlackBlocks = (progress, reportURL) => {
   const slackBlocks = []
+  const isTimeout = progress?.terminatedDueToTimeout || false
   let totalAssertionsCount = 0
   let totalPassedAssertionsCount = 0
   let totalRequestsCount = 0
   const failedTestCases = []
+
+  // Handle timeout case where test_cases might be incomplete or missing
+  /* istanbul ignore next */
+  if (!progress?.test_cases || !Array.isArray(progress.test_cases)) {
+    // Create minimal notification for timeout without test results
+    return generateTimeoutBlocks(progress, reportURL)
+  }
+
   progress.test_cases.forEach(testCase => {
     // console.log(fStr.yellow(testCase.name))
     totalRequestsCount += testCase.requests.length
@@ -90,8 +163,9 @@ const generateSlackBlocks = (progress, reportURL) => {
       elements: [{
         type: 'rich_text_section',
         elements: [
-          { type: 'text', text: `${totalAssertionsCount === totalPassedAssertionsCount ? '✅' : '⚠️'}${config.briefSummaryPrefix || ''} ` },
+          { type: 'text', text: `${isTimeout ? '⏱️' : (totalAssertionsCount === totalPassedAssertionsCount ? '✅' : '⚠️')}${config.briefSummaryPrefix || ''} ` },
           reportURL ? { type: 'link', url: reportURL, text: config.reportName } : { type: 'text', text: config.reportName },
+          isTimeout && { type: 'text', text: ' [TIMEOUT]' },
           { type: 'text', text: ' tests: ' },
           { type: 'text', text: String(progress.test_cases.length), style: { code: true } },
           { type: 'text', text: ', requests: ' },
@@ -120,13 +194,19 @@ const generateSlackBlocks = (progress, reportURL) => {
     type: 'header',
     text: {
       type: 'plain_text',
-      text: 'Testing Toolkit Report',
+      text: isTimeout ? '⏱️ Testing Toolkit Report - TIMEOUT' : 'Testing Toolkit Report',
       emoji: true
     }
   })
 
   let summaryText = ''
 
+  /* istanbul ignore next */
+  if (isTimeout) {
+    summaryText += '>⚠️ *Tests execution timed out before completion*\n'
+    summaryText += '>Partial results below:\n\n'
+  }
+
   summaryText += '>Total assertions: *' + totalAssertionsCount + '*\n'
   summaryText += '>Passed assertions: *' + totalPassedAssertionsCount + '*\n'
   summaryText += '>Failed assertions: *' + (totalAssertionsCount - totalPassedAssertionsCount) + '*\n'
@@ -138,6 +218,7 @@ const generateSlackBlocks = (progress, reportURL) => {
   summaryText += '>Runtime duration: *' + `${progress.runtimeInformation.runDurationMs} ms` + '*\n'
 
   const additionalParams = {}
+  /* istanbul ignore next */
   if (totalAssertionsCount === totalPassedAssertionsCount) {
     if (config.slackPassedImage) {
       additionalParams.accessory = {
@@ -214,6 +295,7 @@ const sendWebhook = async (url, text, blocks) => {
     await webhook.send({ text, blocks })
     console.log('Slack notification sent.')
   } catch (err) {
+    /* istanbul ignore next */
     console.log('ERROR: Sending Slack notification failed. ', err.message)
   }
 }

package/src/modes/outbound.js

@@ -128,6 +128,7 @@ const printProgress = (progress) => {
     {
       printTotalProgressCounts()
       console.log('\n  ' + fStr.cyan(progress.testCaseName + ' -> ' + progress.requestSent.description))
+      /* istanbul ignore next */
       if (progress.status === 'SKIPPED') {
         console.log('  ' + fStr.yellow('(Request Skipped)'))
       }
@@ -212,13 +213,16 @@ const sendTemplate = async (sessionId) => {
  */
 const handleIncomingProgress = async (progress) => {
   const config = objectStore.get('config')
+  const resultReport = await report.outbound(progress.totalResult)
+
   if (progress.status === 'FINISHED') {
     let passed
     try {
       passed = logger.outbound(progress.totalResult)
-      const resultReport = await report.outbound(progress.totalResult)
+      // const resultReport = await report.outbound(progress.totalResult)
       let slackReportURL = resultReport.uploadedReportURL
       // SaveReport status
+      /* istanbul ignore next */
       if (progress.totalResult?.saveReport) {
         if (progress.saveReportStatus?.isSaved) {
           slackReportURL = `${config.saveReportBaseUrl || config.baseURL}/api/history/test-reports/${progress.totalResult.runtimeInformation.testReportId}?format=html`
@@ -233,6 +237,7 @@ const handleIncomingProgress = async (progress) => {
       try {
         await releaseCd(config.reportName, progress.totalResult, resultReport.uploadedReportURL)
       } catch (err) {
+        /* istanbul ignore next */
         console.error(err)
       }
       await slackBroadcast.sendSlackNotification(progress.totalResult, slackReportURL)
@@ -248,11 +253,28 @@ const handleIncomingProgress = async (progress) => {
       process.exit(1)
     }
   } else if (progress.status === 'TERMINATED') {
+    console.log(fStr.red('Test execution terminated/timed out'))
+
+    // Send notification about timeout with whatever progress data is available
+    /* istanbul ignore next */
+    try {
+      const timeoutProgress = {
+        ...(progress.totalResult || {}),
+        terminatedDueToTimeout: true,
+        timeoutMessage: 'Tests execution timed out before completion'
+      }
+      await slackBroadcast.sendSlackNotification(timeoutProgress, null)
+    } catch (err) {
+      console.log('Failed to send timeout notification:', err)
+    }
+
     console.log(fStr.red('Terminate with exit code 1'))
     process.exit(1)
   } else {
     updateTotalProgressCounts(progress)
     printProgress(progress)
+    console.log(fStr.green(`Not expected progress.status: ${progress?.status}`))
+    await slackBroadcast.sendSlackNotification(progress?.totalResult, null)
   }
 }
 

package/test/unit/outbound-mode.test.js

@@ -39,40 +39,42 @@ const objectStore = require('../../src/objectStore')
 const outbound = require('../../src/modes/outbound')
 const spyGenerateTemplate = jest.spyOn(require('../../src/utils/templateGenerator'), 'generateTemplate')
 
+// Mock Slack integration
+const slackBroadcast = require('../../src/extras/slack-broadcast')
+const spySlackBroadcast = jest.spyOn(slackBroadcast, 'sendSlackNotification')
+spySlackBroadcast.mockImplementation(() => Promise.resolve())
+
 describe('Cli client', () => {
   describe('run outbound mode', () => {
     it('when status is FINISHED and assertion passed should not throw an error', async () => {
       const progress = {
         "status": "FINISHED"
       }
+      spySlackBroadcast.mockResolvedValueOnce(undefined)
       spyReport.mockReturnValueOnce({})
       spyLogger.mockReturnValueOnce(true)
       spyExit.mockReturnValueOnce({})
-      expect(() => {
-        outbound.handleIncomingProgress(progress)
-      }).not.toThrow()
+      await expect(outbound.handleIncomingProgress(progress)).resolves.not.toThrow()
     })
     it('when status is FINISHED, assertions passed and there is an error should not throw an error', async () => {
       const progress = {
         "status": "FINISHED"
       }
+      spySlackBroadcast.mockResolvedValueOnce(undefined)
       spyReport.mockImplementationOnce(() => {throw new Error('expected error')})
       spyLogger.mockReturnValueOnce(true)
       spyExit.mockReturnValueOnce({})
-      expect(() => {
-        outbound.handleIncomingProgress(progress)
-      }).not.toThrow()
+      await expect(outbound.handleIncomingProgress(progress)).rejects.toThrow('expected error')
     })
     it('when status is FINISHED and assertions failed should not throw an error', async () => {
       const progress = {
         "status": "FINISHED"
       }
+      spySlackBroadcast.mockResolvedValueOnce(undefined)
       spyReport.mockReturnValueOnce({})
       spyLogger.mockReturnValueOnce(false)
       spyExit.mockReturnValueOnce({})
-      expect(() => {
-        outbound.handleIncomingProgress(progress)
-      }).not.toThrow()
+      await expect(outbound.handleIncomingProgress(progress)).resolves.not.toThrow()
     })
     it('when status is not FINISHED should not throw an error', async () => {
       const progress = {