fix(NODE-5064): consolidate connection cleanup logic and ensure socket is always closed

[baileympearson]

Description

What is changing?

This PR primarily does three things:

• ensures that the message stream is always destroyed and ensure that the socket is always destroyed
• consolidate the connection clean up logic into a single function that is called from each point where the connection is cleaned out
• improves the unit tests to properly assert on the state of the connection after _cleanup has been called. Additionally, the unit tests now in for synchronous versus asynchronous behavior for the various error and clean up scenarios.

Example unit test output:

  new Connection()
    ✔ should support fire-and-forget messages
    ✔ should destroy streams which time out (55ms)
    ✔ should throw a network error with kBeforeHandshake set to false on timeout after handshake (56ms)
    ✔ should throw a network error with kBeforeHandshake set to true on timeout before handshake (53ms)
    #onMessage
      when the connection is a monitoring connection
        when multiple hellos exist on the stream
          ✔ calls the callback with the last hello document
        when requestId/responseTo do not match
          ✔ calls the operation description callback with the document
        when requestId/reponseTo match
          ✔ calls the operation description callback with the document
        when no operation description is in the queue
          ✔ does not error
        when more than one operation description is in the queue
          ✔ calls all operation description callbacks with an error
    when the socket times out
      delayed timeout for lambda behavior
        ✔ should delay timeout errors by one tick
        ✔ should clear timeout errors if more data is available
      when the timeout expires and no more data has come in
        ✔ destroys the message stream
        ✔ ends the socket
        ✔ destroys the socket after ending it
        ✔ passes the error along to any callbacks in the operation description queue (asynchronously)
        ✔ emits a Connection.CLOSE event (asynchronously)
        ✔ removes all listeners on the message stream
        ✔ removes all listeners on the socket
    when the message stream errors
      ✔ destroys the message stream synchronously
      ✔ ends the socket
      ✔ destroys the socket after ending it (asynchronously)
      ✔ passes the error along to any callbacks in the operation description queue (asynchronously)
      ✔ emits a Connection.CLOSE event (asynchronously)
      ✔ removes all listeners on the message stream
      ✔ removes all listeners on the socket
    when the underlying socket closes
      ✔ destroys the message stream synchronously
      ✔ ends the socket
      ✔ destroys the socket after ending it (asynchronously)
      ✔ calls any callbacks in the queue with a MongoNetworkError (asynchronously)
      ✔ emits a Connection.CLOSE event (asynchronously)
      ✔ removes all listeners on the message stream
      ✔ removes all listeners on the socket
    .hasSessionSupport
      when logicalSessionTimeoutMinutes is present
        ✔ returns true
      when logicalSessionTimeoutMinutes is not present
        when in load balancing mode
          ✔ returns true
        when not in load balancing mode
          ✔ returns false
    destroy()
      when a callback is provided
        when the connection was already destroyed
          ✔ does not attempt to cleanup the socket again
          ✔ calls the callback (asynchronously)
        when the connection was not destroyed
          ✔ cleans up the connection
          ✔ calls the callback (asynchronously)
      when options.force == true
        ✔ destroys the tcp socket (synchronously)
        ✔ does not call stream.end
        ✔ destroys the messageStream (synchronously)
        ✔ when destroy({ force: true }) is called multiple times, it calls stream.destroy exactly once
      when options.force == false
        ✔ destroys the tcp socket (asynchronously)
        ✔ ends the tcp socket (synchronously)
        ✔ destroys the messageStream (synchronously)
        ✔ calls stream.end exactly once when destroy is called multiple times

Is there new documentation needed for these changes?

What is the motivation for this change?

Double check the following

• Ran npm run check:lint script
• Self-review completed using the steps outlined here
• PR title follows the correct format: type(NODE-xxxx)[!]: description
  • Example: feat(NODE-1234)!: rewriting everything in coffeescript
• Changes are covered by tests
• New TODOs have a related JIRA ticket