async_wrap: update providers and add test

Several provider ids have been removed that are no longer in use. Others
have been updated to match their class constructors.

Add test to ensure all internally listed providers are used.

PR-URL: #3139
Reviewed-By: Fedor Indutny <[email protected]>
Reviewed-By: Ben Noordhuis <[email protected]>
Reviewed-by: Stephen Belanger <[email protected]>

Author: trevnorris

src/async-wrap.h

@@ -12,26 +12,26 @@ namespace node {
 
 #define NODE_ASYNC_PROVIDER_TYPES(V)                                          \
   V(NONE)                                                                     \
-  V(CARES)                                                                    \
-  V(CONNECTWRAP)                                                              \
   V(CRYPTO)                                                                   \
   V(FSEVENTWRAP)                                                              \
   V(FSREQWRAP)                                                                \
   V(GETADDRINFOREQWRAP)                                                       \
   V(GETNAMEINFOREQWRAP)                                                       \
   V(JSSTREAM)                                                                 \
   V(PIPEWRAP)                                                                 \
+  V(PIPECONNECTWRAP)                                                          \
   V(PROCESSWRAP)                                                              \
   V(QUERYWRAP)                                                                \
-  V(REQWRAP)                                                                  \
   V(SHUTDOWNWRAP)                                                             \
   V(SIGNALWRAP)                                                               \
   V(STATWATCHER)                                                              \
   V(TCPWRAP)                                                                  \
+  V(TCPCONNECTWRAP)                                                           \
   V(TIMERWRAP)                                                                \
   V(TLSWRAP)                                                                  \
   V(TTYWRAP)                                                                  \
   V(UDPWRAP)                                                                  \
+  V(UDPSENDWRAP)                                                              \
   V(WRITEWRAP)                                                                \
   V(ZLIB)
 

src/pipe_wrap.cc

@@ -42,7 +42,7 @@ class PipeConnectWrap : public ReqWrap<uv_connect_t> {
 
 
 PipeConnectWrap::PipeConnectWrap(Environment* env, Local<Object> req_wrap_obj)
-    : ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_PIPEWRAP) {
+    : ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_PIPECONNECTWRAP) {
   Wrap(req_wrap_obj, this);
 }
 

src/tcp_wrap.cc

@@ -41,7 +41,7 @@ class TCPConnectWrap : public ReqWrap<uv_connect_t> {
 
 
 TCPConnectWrap::TCPConnectWrap(Environment* env, Local<Object> req_wrap_obj)
-    : ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_TCPWRAP) {
+    : ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_TCPCONNECTWRAP) {
   Wrap(req_wrap_obj, this);
 }
 

src/udp_wrap.cc

@@ -44,7 +44,7 @@ class SendWrap : public ReqWrap<uv_udp_send_t> {
 SendWrap::SendWrap(Environment* env,
                    Local<Object> req_wrap_obj,
                    bool have_callback)
-    : ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_UDPWRAP),
+    : ReqWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_UDPSENDWRAP),
       have_callback_(have_callback) {
   Wrap(req_wrap_obj, this);
 }

test/parallel/test-async-wrap-check-providers.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const crypto = require('crypto');
+const dgram = require('dgram');
+const dns = require('dns');
+const fs = require('fs');
+const net = require('net');
+const tls = require('tls');
+const zlib = require('zlib');
+const ChildProcess = require('child_process').ChildProcess;
+const StreamWrap = require('_stream_wrap').StreamWrap;
+const async_wrap = process.binding('async_wrap');
+const pkeys = Object.keys(async_wrap.Providers);
+
+let keyList = pkeys.slice();
+// Drop NONE
+keyList.splice(0, 1);
+
+
+function init(id) {
+  keyList = keyList.filter(e => e != pkeys[id]);
+}
+
+function noop() { }
+
+async_wrap.setupHooks(init, noop, noop);
+
+async_wrap.enable();
+
+
+setTimeout(function() { });
+
+fs.stat(__filename, noop);
+fs.watchFile(__filename, noop);
+fs.unwatchFile(__filename);
+fs.watch(__filename).close();
+
+dns.lookup('localhost', noop);
+dns.lookupService('::', 0, noop);
+dns.resolve('localhost', noop);
+
+new StreamWrap(new net.Socket());
+
+new (process.binding('tty_wrap').TTY)();
+
+crypto.randomBytes(1, noop);
+
+try {
+  fs.unlinkSync(common.PIPE);
+} catch(e) { }
+
+net.createServer(function(c) {
+  c.end();
+  this.close();
+}).listen(common.PIPE, function() {
+  net.connect(common.PIPE, noop);
+});
+
+net.createServer(function(c) {
+  c.end();
+  this.close(checkTLS);
+}).listen(common.PORT, function() {
+  net.connect(common.PORT, noop);
+});
+
+dgram.createSocket('udp4').bind(common.PORT, function() {
+  this.send(new Buffer(2), 0, 2, common.PORT, '::', () => {
+    this.close();
+  });
+});
+
+process.on('SIGINT', () => process.exit());
+
+// Run from closed net server above.
+function checkTLS() {
+  let options = {
+    key: fs.readFileSync(common.fixturesDir + '/keys/ec-key.pem'),
+    cert: fs.readFileSync(common.fixturesDir + '/keys/ec-cert.pem')
+  };
+  let server = tls.createServer(options, noop).listen(common.PORT, function() {
+    tls.connect(common.PORT, { rejectUnauthorized: false }, function() {
+      this.destroy();
+      server.close();
+    });
+  });
+}
+
+zlib.createGzip();
+
+new ChildProcess();
+
+process.on('exit', function() {
+  if (keyList.length !== 0) {
+    process._rawDebug('Not all keys have been used:');
+    process._rawDebug(keyList);
+    assert.equal(keyList.length, 0);
+  }
+});