Address crash for unmatched server responses

lib/client/client.js

@@ -881,7 +881,13 @@ Client.prototype.connect = function connect () {
     // object.
     tracker.parser.on('message', function onMessage (message) {
       message.connection = self._socket
-      const { message: trackedMessage, callback } = tracker.fetch(message.messageId)
+      const trackedObject = tracker.fetch(message.messageId)
+      if (!trackedObject) {
+        log.error({ message: message.pojo }, 'unmatched server message received')
+        return false
+      }
+
+      const { message: trackedMessage, callback } = trackedObject
 
       if (!callback) {
         log.error({ message: message.pojo }, 'unsolicited message')

test/issue-890.test.js

@@ -0,0 +1,103 @@
+'use strict'
+
+// This test is complicated. It must simulate a server sending an unsolicited,
+// or a mismatched, message in order to force the client's internal message
+// tracker to try and find a corresponding sent message that does not exist.
+// In order to do that, we need to set a high test timeout and wait for the
+// error message to be logged.
+
+const tap = require('tap')
+const ldapjs = require('../')
+const { SearchResultEntry } = require('@ldapjs/messages')
+const server = ldapjs.createServer()
+const SUFFIX = ''
+
+tap.timeout = 10000
+
+server.bind(SUFFIX, (res, done) => {
+  res.end()
+  return done()
+})
+
+server.search(SUFFIX, (req, res, done) => {
+  const result = new SearchResultEntry({
+    objectName: `dc=${req.scopeName}`
+  })
+
+  // Respond to the search request with a matched response.
+  res.send(result)
+  res.end()
+
+  // After a short delay, send ANOTHER response to the client that will not
+  // be matched by the client's internal tracker.
+  setTimeout(
+    () => {
+      res.send(result)
+      res.end()
+      done()
+    },
+    100
+  )
+})
+
+tap.beforeEach(t => {
+  return new Promise((resolve, reject) => {
+    server.listen(0, '127.0.0.1', (err) => {
+      if (err) return reject(err)
+
+      t.context.logMessages = []
+      t.context.logger = {
+        child () { return this },
+        debug () {},
+        error (...args) {
+          t.context.logMessages.push(args)
+        },
+        trace () {}
+      }
+
+      t.context.url = server.url
+      t.context.client = ldapjs.createClient({
+        url: [server.url],
+        timeout: 5,
+        log: t.context.logger
+      })
+
+      resolve()
+    })
+  })
+})
+
+tap.afterEach(t => {
+  return new Promise((resolve, reject) => {
+    t.context.client.destroy()
+    server.close((err) => {
+      if (err) return reject(err)
+      resolve()
+    })
+  })
+})
+
+tap.test('handle null messages', t => {
+  const { client, logMessages } = t.context
+
+  // There's no way to get an error from the client when it has received an
+  // unmatched response from the server. So we need to poll our logger instance
+  // and detect when the corresponding error message has been logged.
+  const timer = setInterval(
+    () => {
+      if (logMessages.length > 0) {
+        t.equal(
+          logMessages.some(msg => msg[1] === 'unmatched server message received'),
+          true
+        )
+        clearInterval(timer)
+        t.end()
+      }
+    },
+    100
+  )
+
+  client.search('dc=test', (error) => {
+    t.error(error)
+  })
+})