@babblevoice/babble-drachtio-callmanager 2.0.1 → 2.0.2

package/lib/call.js

@@ -73,6 +73,10 @@ var callmanager = {
 /** @class */
 class call {
 
+  #state = { 
+    "waitingforevent": false
+  }
+
   /**
   Construct our call object with all defaults, including a default UUID.
   @constructs call
@@ -1455,7 +1459,7 @@ class call {
   /**
     Private helper function to add events to our RTP channel.
     @param {object} e - the rtp event
-    @private
+    @internal
   */
   _handlechannelevents( e ) {
 
@@ -1485,6 +1489,16 @@ class call {
       this._tevent( e.event )
     }
 
+    if( !this._promises.resolve.channelevent ) {
+      this.#state.waitingforevent = e
+      return
+    }
+
+    this.#matchandthrow( e )
+
+  }
+
+  #matchandthrow( e ) {
     if( this._eventconstraints ) {
       let constraintkeys = Object.keys( this._eventconstraints )
       for( const k of constraintkeys ) {
@@ -1492,11 +1506,11 @@ class call {
         if( "object" === typeof this._eventconstraints[ k ] ) {
           /* regex */
           if( !e[ k ].match( this._eventconstraints[ k ] ) ) {
-            return
+            return false
           }
         } else if( this._eventconstraints[ k ] != e[ k ] ) {
           /* not a match */
-          return
+          return false
         }
       }
     }
@@ -1513,7 +1527,7 @@ class call {
     this._promises.resolve.channelevent = false
     this._promises.promise.channelevent = false
     if( r ) r( e )
-
+    return true
   }
 
   /**
@@ -1526,6 +1540,7 @@ class call {
   A telephone event will resolve this promise as we typically need speech to be interupted
   by the user. Note, peeking a telephone-event (i.e. DTMF) will not clear it like waitfortelevents will.
   @param { regex } constraints - event to filter for from our RTP server - excluding DTMF events - these will always return
+  @returns { Promise< object > }
   */
   waitforanyevent( constraints, timeout = 500 ) {
 
@@ -1545,6 +1560,11 @@ class call {
       if( r ) r( "timeout" )
     }, timeout * 1000 )
 
+    if( this.#state.waitingforevent ) {
+      this.#matchandthrow( this.#state.waitingforevent )
+    }
+    this.#state.waitingforevent = false
+
     return this._promises.promise.channelevent
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babblevoice/babble-drachtio-callmanager",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Call processing to create a PBX",
   "main": "index.js",
   "scripts": {

package/test/interface/serverconnect.js

@@ -0,0 +1,79 @@
+
+const prtp = require( "@babblevoice/projectrtp" )
+const node = require( "@babblevoice/projectrtp/lib/node" )
+const expect = require( "chai" ).expect
+const call = require( "../../lib/call" )
+
+/**
+ * Test file to run tests acting as a remote note. Starts a babble-rtp node in the background
+ * before any tests begin then runs tests to open, play, polly etc.
+ */
+describe( "server connect interface", () => {
+
+  before( async () => {
+    const host = "127.0.0.1"
+    const port = 9002
+    await prtp.projectrtp.node.listen( host, port )
+    prtp.projectrtp.server.addnode( { host, port} )
+    
+  } )
+
+  after( () => {
+    prtp.projectrtp.server.clearnodes()
+    node.interface.destroy()
+  } )
+
+  /**
+   * Primarily testing waitforanyevent and related event handling functions.
+   */
+  it( "server connect and open channel", async function () {
+    this.timeout( 7000 )
+    this.slow( 5000 )
+
+    const totalotherchannelcount = 100
+    let chanclosecount = 0
+    let allchannelsclosedresolve
+    const allchannelsclosed = new Promise( resolve => allchannelsclosedresolve = resolve )
+    const onclose = ( e ) => {
+      if( "close" == e.action ) chanclosecount++
+      if( totalotherchannelcount == chanclosecount ) allchannelsclosedresolve()
+    }
+
+    // A very short wav file
+    prtp.projectrtp.tone.generate( "350+440*0.5:100", "/tmp/serverconnecttestwavghghgh.wav" )
+    prtp.projectrtp.tone.generate( "350+440*0.5:100", "/tmp/otherserverconnecttestwavghhh.wav" )
+
+    const channels = []
+    for( let i = 0; totalotherchannelcount > i; i++ ) {
+      channels.push( await prtp.projectrtp.openchannel( onclose ) )
+    }
+
+    for( let i = 0; 3 > i; i++ ) {
+      const ourcall = new call()
+  
+      const chan = await prtp.projectrtp.openchannel( ourcall._handlechannelevents.bind( ourcall ) )
+
+      ourcall._em.on( "channel", ( e ) => {
+        /* For this test we don't want the call object to run our hangup 
+        handlers as they are  more complex than we are trying to test here */
+        if( "close" == e.event.action ) e.event.action = ""
+       } )
+  
+      chan.play( { "interupt":true, "files": [ { "wav": "/tmp/serverconnecttestwavghghgh.wav" }, { "wav": "/tmp/otherserverconnecttestwavghhh.wav" } ] } )
+
+      await ourcall.waitforanyevent( { "action": "play", "event": "start", "reason": "new" } )
+      await ourcall.waitforanyevent( { "action": "play", "event": "end", "reason": /^((?!replaced).)*$/ } )
+
+      chan.close()
+    }
+
+    for( const chan of channels ) {
+      chan.close()
+    }
+
+    if( 0 != totalotherchannelcount )
+    await allchannelsclosed
+    expect( chanclosecount ).to.equal( totalotherchannelcount )
+  } )
+
+} )