ml-testing-toolkit 18.16.0-snapshot.6 → 18.16.1

package/src/lib/eventListenerClient/inboundEventListener.js

@@ -27,9 +27,6 @@
  --------------
  ******/
 
-// Ignore temporarily to get the snapshot release done
-/* istanbul ignore file */
-
 const MyEventEmitter = require('../MyEventEmitter')
 const EventEmitter = require('events')
 class MyEmitter extends EventEmitter {}
@@ -46,17 +43,11 @@ class InboundEventListener {
       this.consoleFn = console
     }
     this.emitter = MyEventEmitter.getEmitter('inboundRequest')
-    this.newInboundHandler = null
   }
 
   async init () {
     this.userConfig = await Config.getStoredUserConfig()
-
-    if (this.newInboundHandler) {
-      this.emitter.removeListener('newInbound', this.newInboundHandler)
-    }
-
-    this.newInboundHandler = (data) => {
+    this.emitter.on('newInbound', (data) => {
       for (const [, eventListener] of Object.entries(this.eventListeners)) {
         // Match method, path and condition for each inbound request
         if (eventListener.method === data.method && eventListener.path === data.path) {
@@ -70,9 +61,7 @@ class InboundEventListener {
           }
         }
       }
-    }
-
-    this.emitter.on('newInbound', this.newInboundHandler)
+    })
   }
 
   customLog (logMessage) {
@@ -109,74 +98,59 @@ class InboundEventListener {
 
   getMessage (clientName, timeout = 5000) {
     return new Promise((resolve, reject) => {
-      let timer = null
-
-      const cleanup = () => {
-        if (timer) {
-          clearTimeout(timer)
-          timer = null
-        }
-        if (this.eventListeners[clientName] && this.eventListeners[clientName].eventEmitter) {
-          this.eventListeners[clientName].eventEmitter.removeAllListeners('newMessage')
-        }
-      }
-
       if (!this.eventListeners[clientName]) {
         resolve(null)
-        return
-      }
-
-      // Check for the message received already
-      if (this.eventListeners[clientName].message !== null) {
-        // Store the message somewhere
-        const retMessage = this.parseMessage(this.eventListeners[clientName].message)
-        // Destroy the event listener
-        this.destroy(clientName)
-        // Return the stored message
-        // this.customLog('Returning stored message...')
-        if (this.transformer.reverseTransform) {
-          this.transformer.reverseTransform(retMessage).then((result) => {
-            resolve(result)
-          }).catch((err) => {
-            this.customLog('Error transforming message: ' + err)
-            resolve(retMessage)
-          })
-        } else {
-          resolve(retMessage)
-        }
-        return
-      }
-
-      // Listen for the new message for some time
-      // Set the timer
-      timer = setTimeout(() => {
-        try {
-          this.customLog('Error: Timeout')
+      } else {
+        // Check for the message received already
+        if (this.eventListeners[clientName].message !== null) {
+          // Store the message somewhere
+          const retMessage = this.parseMessage(this.eventListeners[clientName].message)
           // Destroy the event listener
           this.destroy(clientName)
-          resolve(null)
-        } catch (err) {
-          reject(err)
-        }
-      }, timeout)
-
-      // Listen for message
-      this.eventListeners[clientName].eventEmitter.once('newMessage', (message) => {
-        cleanup()
-        this.destroy(clientName)
-        const retMessage = this.parseMessage(message)
-
-        if (this.transformer.reverseTransform) {
-          this.transformer.reverseTransform(retMessage).then((result) => {
-            resolve(result)
-          }).catch((err) => {
-            this.customLog('Error transforming message: ' + err)
+          // Return the stored message
+          // this.customLog('Returning stored message...')
+          if (this.transformer.reverseTransform) {
+            this.transformer.reverseTransform(retMessage).then((result) => {
+              resolve(result)
+            }).catch((err) => {
+              this.customLog('Error transforming message: ' + err)
+              resolve(retMessage)
+            })
+          } else {
             resolve(retMessage)
-          })
+          }
         } else {
-          resolve(retMessage)
+          // Listen for the new message for some time
+          let timer = null
+          // Set the timer
+          timer = setTimeout(() => {
+            try {
+              this.customLog('Error: Timeout')
+              // Destroy the event listener
+              this.destroy(clientName)
+              resolve(null)
+            } catch (err) {
+              reject(err)
+            }
+          }, timeout)
+          // Listen for message
+          this.eventListeners[clientName].eventEmitter.once('newMessage', (message) => {
+            clearTimeout(timer)
+            this.destroy(clientName)
+            const retMessage = this.parseMessage(message)
+            if (this.transformer.reverseTransform) {
+              this.transformer.reverseTransform(retMessage).then((result) => {
+                resolve(result)
+              }).catch((err) => {
+                this.customLog('Error transforming message: ' + err)
+                resolve(retMessage)
+              })
+            } else {
+              resolve(retMessage)
+            }
+          })
         }
-      })
+      }
     })
   }
 
@@ -195,20 +169,6 @@ class InboundEventListener {
     }
     return true
   }
-
-  // Add a new cleanup method
-  cleanup () {
-    // Remove the newInbound listener
-    if (this.newInboundHandler) {
-      this.emitter.removeListener('newInbound', this.newInboundHandler)
-      this.newInboundHandler = null
-    }
-
-    // Clean up all event listeners
-    Object.keys(this.eventListeners).forEach(clientName => {
-      this.destroy(clientName)
-    })
-  }
 }
 
 module.exports = {

package/src/lib/scripting-engines/vm-javascript-sandbox.js

@@ -265,9 +265,6 @@ const executeAsync = async (script, data, contextObj) => {
     }
     consoleLog.push([{ execution: 0 }, 'executionError', err.toString()])
   }
-  // finally {
-  //   contextObj.inboundEvent.cleanup()
-  // }
   const result = {
     consoleLog,
     environment: { ...contextObj.environment }

package/src/lib/webSocketClient/WebSocketClientManager.js

@@ -28,9 +28,6 @@
  --------------
  ******/
 
-// Ignore temporarily to get the snapshot release done
-/* istanbul ignore file */
-
 const WebSocket = require('ws')
 const EventEmitter = require('events')
 class MyEmitter extends EventEmitter {}
@@ -110,48 +107,41 @@ class WebSocketClientManager {
 
   getMessage (clientName, timeout = 5000) {
     return new Promise((resolve, reject) => {
-      let timer = null
-
-      const cleanup = () => {
-        if (timer) {
-          clearTimeout(timer)
-          timer = null
-        }
-        if (this.ws[clientName] && this.ws[clientName].eventEmitter) {
-          this.ws[clientName].eventEmitter.removeAllListeners('newMessage')
-        }
-      }
-
       if (!this.ws[clientName]) {
         resolve(null)
-        return
-      }
-
-      // Check for already received message
-      if (this.ws[clientName].message !== null) {
-        const retMessage = this.parseMessage(this.ws[clientName].message)
-        this.disconnect(clientName)
-        resolve(retMessage)
-        return
-      }
-
-      // Set timeout
-      timer = setTimeout(() => {
-        try {
-          cleanup()
+      } else {
+        // Check for the message received already
+        if (this.ws[clientName].message !== null) {
+          // Store the message somewhere
+          const retMessage = this.parseMessage(this.ws[clientName].message)
+          // Disconnect the websocket connection
           this.disconnect(clientName)
-          resolve(null)
-        } catch (err) {
-          reject(err)
+          // Return the stored message
+          // this.customLog('Returning stored message...')
+          resolve(retMessage)
+        } else {
+          // Listen for the new message for some time
+          let timer = null
+          // Set the timer
+          timer = setTimeout(() => {
+            try {
+              this.ws[clientName].eventEmitter.removeAllListeners('newMessage')
+              // Disconnect the websocket connection
+              this.disconnect(clientName)
+              resolve(null)
+            } catch (err) {
+              reject(err)
+            }
+          }, timeout)
+          // Listen for message
+          this.ws[clientName].eventEmitter.once('newMessage', (message) => {
+            clearTimeout(timer)
+            this.ws[clientName].eventEmitter.removeAllListeners('newMessage')
+            this.disconnect(clientName)
+            resolve(this.parseMessage(message))
+          })
         }
-      }, timeout)
-
-      // Listen for message
-      this.ws[clientName].eventEmitter.once('newMessage', (message) => {
-        cleanup()
-        this.disconnect(clientName)
-        resolve(this.parseMessage(message))
-      })
+      }
     })
   }