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

Diff for: 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)
 

Diff for: 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);
 }
 

Diff for: 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);
 }
 

Diff for: 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);
 }

Diff for: 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);
+  }
+});