test & doc

Author: refack

doc/api/async_hooks.md

@@ -131,6 +131,16 @@ provided by AsyncHooks itself. The logging should then be skipped when
 it was the logging itself that caused AsyncHooks callback to call. By
 doing this the otherwise infinite recursion is broken.
 
+#### `async_hooks.getTypes()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: `{Array}` list of async resource type names
+
+Return the list of async resource type names. Names are simple strings.
+
 #### `asyncHook.enable()`
 
 * Returns {AsyncHook} A reference to `asyncHook`.
@@ -428,6 +438,13 @@ const server = net.createServer(function onConnection(conn) {
 });
 ```
 
+#### `async_hooks.registerTypeName(type)`
+
+* `type` {string} a new type of async resource
+* Returns {string} the type name to use
+
+Registers the type name for a new async resource.
+
 #### `async_hooks.triggerId()`
 
 * Returns {number} the ID of the resource responsible for calling the callback

test/parallel/test-async-hooks-type-registry.js

@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const async_hooks = require('async_hooks');
+
+const types1 = async_hooks.getTypes();
+types1.forEach((v, k) => assert.strictEqual(
+  typeof v,
+  'string',
+  `${v} from types[${k}] should be a string`)
+);
+
+const sillyName = 'gaga';
+const newType = async_hooks.getTypes(sillyName);
+assert.strictEqual(
+  typeof newType,
+  'string',
+  `${newType} should be a string`
+);
+assert.strictEqual(newType, sillyName);
+
+assert.throws(() => async_hooks.getTypes(sillyName),
+              common.expectsError(
+                'ERR_ASYNC_PROVIDER_NAME',
+                TypeError,
+                `${sillyName} type name already registered`
+              ));
+
+const types2 = async_hooks.getTypes();
+assert.strictEqual(types2.length, types1 + 1);
+assert.strictEqual(types2.includes(newType), true);