dns: add promisified dns module

PR-URL: https://github.com/nodejs/node/pull/21264
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>

11 files changed, 658 insertions, 292 deletions

diff --git a/test/internet/test-dns-any.js b/test/internet/test-dns-any.js
index a83040801f..be5fc4b1ad 100644
--- a/test/internet/test-dns-any.js
+++ b/test/internet/test-dns-any.js
@@ -9,6 +9,9 @@ const net = require('net');
 let running = false;
 const queue = [];
 
+common.crashOnUnhandledRejection();
+
+const dnsPromises = dns.promises;
 const isIPv4 = net.isIPv4;
 const isIPv6 = net.isIPv6;
 
@@ -101,93 +104,95 @@ function TEST(f) {
   }
 }
 
-TEST(function test_google(done) {
+function processResult(res) {
+  assert.ok(Array.isArray(res));
+  assert.ok(res.length > 0);
+
+  const types = {};
+  res.forEach((obj) => {
+    types[obj.type] = true;
+    checkers[`check${obj.type}`](obj);
+  });
+
+  return types;
+}
+
+TEST(async function test_google(done) {
+  function validateResult(res) {
+    const types = processResult(res);
+    assert.ok(
+      types.A && types.AAAA && types.MX &&
+      types.NS && types.TXT && types.SOA);
+  }
+
+  validateResult(await dnsPromises.resolve('google.com', 'ANY'));
+
   const req = dns.resolve(
     'google.com',
     'ANY',
     common.mustCall(function(err, ret) {
       assert.ifError(err);
-      assert.ok(Array.isArray(ret));
-      assert.ok(ret.length > 0);
-
-      /* current google.com has A / AAAA / MX / NS / TXT and SOA records */
-      const types = {};
-      ret.forEach((obj) => {
-        types[obj.type] = true;
-        checkers[`check${obj.type}`](obj);
-      });
-      assert.ok(
-        types.A && types.AAAA && types.MX &&
-        types.NS && types.TXT && types.SOA);
-
+      validateResult(ret);
       done();
     }));
 
   checkWrap(req);
 });
 
-TEST(function test_sip2sip_for_naptr(done) {
+TEST(async function test_sip2sip_for_naptr(done) {
+  function validateResult(res) {
+    const types = processResult(res);
+    assert.ok(types.A && types.NS && types.NAPTR && types.SOA);
+  }
+
+  validateResult(await dnsPromises.resolve('sip2sip.info', 'ANY'));
+
   const req = dns.resolve(
     'sip2sip.info',
     'ANY',
     common.mustCall(function(err, ret) {
       assert.ifError(err);
-      assert.ok(Array.isArray(ret));
-      assert.ok(ret.length > 0);
-
-      /* current sip2sip.info has A / NS / NAPTR and SOA records */
-      const types = {};
-      ret.forEach((obj) => {
-        types[obj.type] = true;
-        checkers[`check${obj.type}`](obj);
-      });
-      assert.ok(types.A && types.NS && types.NAPTR && types.SOA);
-
+      validateResult(ret);
       done();
     }));
 
   checkWrap(req);
 });
 
-TEST(function test_google_for_cname_and_srv(done) {
+TEST(async function test_google_for_cname_and_srv(done) {
+  function validateResult(res) {
+    const types = processResult(res);
+    assert.ok(types.SRV);
+  }
+
+  validateResult(await dnsPromises.resolve('_jabber._tcp.google.com', 'ANY'));
+
   const req = dns.resolve(
     '_jabber._tcp.google.com',
     'ANY',
     common.mustCall(function(err, ret) {
       assert.ifError(err);
-      assert.ok(Array.isArray(ret));
-      assert.ok(ret.length > 0);
-
-      const types = {};
-      ret.forEach((obj) => {
-        types[obj.type] = true;
-        checkers[`check${obj.type}`](obj);
-      });
-      assert.ok(types.SRV);
-
+      validateResult(ret);
       done();
     }));
 
   checkWrap(req);
 });
 
-TEST(function test_ptr(done) {
+TEST(async function test_ptr(done) {
+  function validateResult(res) {
+    const types = processResult(res);
+    assert.ok(types.PTR);
+  }
+
+  validateResult(await dnsPromises.resolve('8.8.8.8.in-addr.arpa', 'ANY'));
+
   const req = dns.resolve(
     '8.8.8.8.in-addr.arpa',
     'ANY',
     common.mustCall(function(err, ret) {
       assert.ifError(err);
-      assert.ok(Array.isArray(ret));
-      assert.ok(ret.length > 0);
-
-      /* current 8.8.8.8.in-addr.arpa has PTR record */
-      const types = {};
-      ret.forEach((obj) => {
-        types[obj.type] = true;
-        checkers[`check${obj.type}`](obj);
-      });
-      assert.ok(types.PTR);
-
+      validateResult(ret);
       done();
     }));
 
diff --git a/test/internet/test-dns-ipv4.js b/test/internet/test-dns-ipv4.js
index 4c6e0ae686..837d45f2ad 100644
--- a/test/internet/test-dns-ipv4.js
+++ b/test/internet/test-dns-ipv4.js
@@ -9,6 +9,7 @@ const isIPv4 = net.isIPv4;
 
 common.crashOnUnhandledRejection();
 
+const dnsPromises = dns.promises;
 let running = false;
 const queue = [];
 
@@ -38,139 +39,187 @@ function checkWrap(req) {
   assert.ok(typeof req === 'object');
 }
 
-TEST(function test_resolve4(done) {
+TEST(async function test_resolve4(done) {
+  function validateResult(res) {
+    assert.ok(res.length > 0);
+
+    for (let i = 0; i < res.length; i++) {
+      assert.ok(isIPv4(res[i]));
+    }
+  }
+
+  validateResult(await dnsPromises.resolve4(addresses.INET4_HOST));
+
   const req = dns.resolve4(
     addresses.INET4_HOST,
     common.mustCall((err, ips) => {
       assert.ifError(err);
-
-      assert.ok(ips.length > 0);
-
-      for (let i = 0; i < ips.length; i++) {
-        assert.ok(isIPv4(ips[i]));
-      }
-
+      validateResult(ips);
       done();
     }));
 
   checkWrap(req);
 });
 
-TEST(function test_reverse_ipv4(done) {
+TEST(async function test_reverse_ipv4(done) {
+  function validateResult(res) {
+    assert.ok(res.length > 0);
+
+    for (let i = 0; i < res.length; i++) {
+      assert.ok(res[i]);
+      assert.ok(typeof res[i] === 'string');
+    }
+  }
+
+  validateResult(await dnsPromises.reverse(addresses.INET4_IP));
+
   const req = dns.reverse(
     addresses.INET4_IP,
     common.mustCall((err, domains) => {
       assert.ifError(err);
-
-      assert.ok(domains.length > 0);
-
-      for (let i = 0; i < domains.length; i++) {
-        assert.ok(domains[i]);
-        assert.ok(typeof domains[i] === 'string');
-      }
-
+      validateResult(domains);
       done();
     }));
 
   checkWrap(req);
 });
 
-TEST(function test_lookup_ipv4_explicit(done) {
+TEST(async function test_lookup_ipv4_explicit(done) {
+  function validateResult(res) {
+    assert.ok(net.isIPv4(res.address));
+    assert.strictEqual(res.family, 4);
+  }
+
+  validateResult(await dnsPromises.lookup(addresses.INET4_HOST, 4));
+
   const req = dns.lookup(
     addresses.INET4_HOST, 4,
     common.mustCall((err, ip, family) => {
       assert.ifError(err);
-      assert.ok(net.isIPv4(ip));
-      assert.strictEqual(family, 4);
-
+      validateResult({ address: ip, family });
       done();
     }));
 
   checkWrap(req);
 });
 
-TEST(function test_lookup_ipv4_implicit(done) {
+TEST(async function test_lookup_ipv4_implicit(done) {
+  function validateResult(res) {
+    assert.ok(net.isIPv4(res.address));
+    assert.strictEqual(res.family, 4);
+  }
+
+  validateResult(await dnsPromises.lookup(addresses.INET4_HOST));
+
   const req = dns.lookup(
     addresses.INET4_HOST,
     common.mustCall((err, ip, family) => {
       assert.ifError(err);
-      assert.ok(net.isIPv4(ip));
-      assert.strictEqual(family, 4);
-
+      validateResult({ address: ip, family });
       done();
     }));
 
   checkWrap(req);
 });
 
-TEST(function test_lookup_ipv4_explicit_object(done) {
+TEST(async function test_lookup_ipv4_explicit_object(done) {
+  function validateResult(res) {
+    assert.ok(net.isIPv4(res.address));
+    assert.strictEqual(res.family, 4);
+  }
+
+  validateResult(await dnsPromises.lookup(addresses.INET4_HOST, { family: 4 }));
+
   const req = dns.lookup(addresses.INET4_HOST, {
     family: 4
   }, common.mustCall((err, ip, family) => {
     assert.ifError(err);
-    assert.ok(net.isIPv4(ip));
-    assert.strictEqual(family, 4);
-
+    validateResult({ address: ip, family });
     done();
   }));
 
   checkWrap(req);
 });
 
-TEST(function test_lookup_ipv4_hint_addrconfig(done) {
+TEST(async function test_lookup_ipv4_hint_addrconfig(done) {
+  function validateResult(res) {
+    assert.ok(net.isIPv4(res.address));
+    assert.strictEqual(res.family, 4);
+  }
+
+  validateResult(await dnsPromises.lookup(addresses.INET4_HOST, {
+    hints: dns.ADDRCONFIG
+  }));
+
   const req = dns.lookup(addresses.INET4_HOST, {
     hints: dns.ADDRCONFIG
   }, common.mustCall((err, ip, family) => {
     assert.ifError(err);
-    assert.ok(net.isIPv4(ip));
-    assert.strictEqual(family, 4);
-
+    validateResult({ address: ip, family });
     done();
   }));
 
   checkWrap(req);
 });
 
-TEST(function test_lookup_ip_ipv4(done) {
+TEST(async function test_lookup_ip_ipv4(done) {
+  function validateResult(res) {
+    assert.strictEqual(res.address, '127.0.0.1');
+    assert.strictEqual(res.family, 4);
+  }
+
+  validateResult(await dnsPromises.lookup('127.0.0.1'));
+
   const req = dns.lookup('127.0.0.1',
                          common.mustCall((err, ip, family) => {
                            assert.ifError(err);
-                           assert.strictEqual(ip, '127.0.0.1');
-                           assert.strictEqual(family, 4);
-
+                           validateResult({ address: ip, family });
                            done();
                          }));
 
   checkWrap(req);
 });
 
-TEST(function test_lookup_localhost_ipv4(done) {
+TEST(async function test_lookup_localhost_ipv4(done) {
+  function validateResult(res) {
+    assert.strictEqual(res.address, '127.0.0.1');
+    assert.strictEqual(res.family, 4);
+  }
+
+  validateResult(await dnsPromises.lookup('localhost', 4));
+
   const req = dns.lookup('localhost', 4,
                          common.mustCall((err, ip, family) => {
                            assert.ifError(err);
-                           assert.strictEqual(ip, '127.0.0.1');
-                           assert.strictEqual(family, 4);
-
+                           validateResult({ address: ip, family });
                            done();
                          }));
 
   checkWrap(req);
 });
 
-TEST(function test_lookup_all_ipv4(done) {
+TEST(async function test_lookup_all_ipv4(done) {
+  function validateResult(res) {
+    assert.ok(Array.isArray(res));
+    assert.ok(res.length > 0);
+
+    res.forEach((ip) => {
+      assert.ok(isIPv4(ip.address));
+      assert.strictEqual(ip.family, 4);
+    });
+  }
+
+  validateResult(await dnsPromises.lookup(addresses.INET4_HOST, {
+    all: true,
+    family: 4
+  }));
+
   const req = dns.lookup(
     addresses.INET4_HOST,
     { all: true, family: 4 },
     common.mustCall((err, ips) => {
       assert.ifError(err);
-      assert.ok(Array.isArray(ips));
-      assert.ok(ips.length > 0);
-
-      ips.forEach((ip) => {
-        assert.ok(isIPv4(ip.address));
-        assert.strictEqual(ip.family, 4);
-      });
-
+      validateResult(ips);
       done();
     })
   );
@@ -178,14 +227,20 @@ TEST(function test_lookup_all_ipv4(done) {
   checkWrap(req);
 });
 
-TEST(function test_lookupservice_ip_ipv4(done) {
+TEST(async function test_lookupservice_ip_ipv4(done) {
+  function validateResult(res) {
+    assert.strictEqual(typeof res.hostname, 'string');
+    assert(res.hostname);
+    assert(['http', 'www', '80'].includes(res.service));
+  }
+
+  validateResult(await dnsPromises.lookupService('127.0.0.1', 80));
+
   const req = dns.lookupService(
     '127.0.0.1', 80,
-    common.mustCall((err, host, service) => {
+    common.mustCall((err, hostname, service) => {
       assert.ifError(err);
-      assert.strictEqual(typeof host, 'string');
-      assert(host);
-      assert(['http', 'www', '80'].includes(service));
+      validateResult({ hostname, service });
       done();
     })
   );
diff --git a/test/internet/test-dns-ipv6.js b/test/internet/test-dns-ipv6.js
index 8b1a893680..283b182390 100644
--- a/test/internet/test-dns-ipv6.js
+++ b/test/internet/test-dns-ipv6.js
@@ -4,9 +4,12 @@ const { addresses } = require('../common/internet');
 if (!common.hasIPv6)
   common.skip('this test, no IPv6 support');
 
+common.crashOnUnhandledRejection();
+
 const assert = require('assert');
 const dns = require('dns');
 const net = require('net');
+const dnsPromises = dns.promises;
 const isIPv6 = net.isIPv6;
 
 let running = false;
@@ -38,49 +41,64 @@ function checkWrap(req) {
   assert.ok(typeof req === 'object');
 }
 
-TEST(function test_resolve6(done) {
+TEST(async function test_resolve6(done) {
+  function validateResult(res) {
+    assert.ok(res.length > 0);
+
+    for (let i = 0; i < res.length; i++) {
+      assert.ok(isIPv6(res[i]));
+    }
+  }
+
+  validateResult(await dnsPromises.resolve6(addresses.INET6_HOST));
+
   const req = dns.resolve6(
     addresses.INET6_HOST,
     common.mustCall((err, ips) => {
       assert.ifError(err);
-
-      assert.ok(ips.length > 0);
-
-      for (let i = 0; i < ips.length; i++)
-        assert.ok(isIPv6(ips[i]));
-
+      validateResult(ips);
       done();
     }));
 
   checkWrap(req);
 });
 
-TEST(function test_reverse_ipv6(done) {
+TEST(async function test_reverse_ipv6(done) {
+  function validateResult(res) {
+    assert.ok(res.length > 0);
+
+    for (let i = 0; i < res.length; i++) {
+      assert.ok(typeof res[i] === 'string');
+    }
+  }
+
+  validateResult(await dnsPromises.reverse(addresses.INET6_IP));
+
   const req = dns.reverse(
     addresses.INET6_IP,
     common.mustCall((err, domains) => {
       assert.ifError(err);
-
-      assert.ok(domains.length > 0);
-
-      for (let i = 0; i < domains.length; i++)
-        assert.ok(typeof domains[i] === 'string');
-
+      validateResult(domains);
       done();
     }));
 
   checkWrap(req);
 });
 
-TEST(function test_lookup_ipv6_explicit(done) {
+TEST(async function test_lookup_ipv6_explicit(done) {
+  function validateResult(res) {
+    assert.ok(isIPv6(res.address));
+    assert.strictEqual(res.family, 6);
+  }
+
+  validateResult(await dnsPromises.lookup(addresses.INET6_HOST, 6));
+
   const req = dns.lookup(
     addresses.INET6_HOST,
     6,
     common.mustCall((err, ip, family) => {
       assert.ifError(err);
-      assert.ok(isIPv6(ip));
-      assert.strictEqual(family, 6);
-
+      validateResult({ address: ip, family });
       done();
     }));
 
@@ -101,14 +119,19 @@ TEST(function test_lookup_ipv6_implicit(done) {
 });
 */
 
-TEST(function test_lookup_ipv6_explicit_object(done) {
+TEST(async function test_lookup_ipv6_explicit_object(done) {
+  function validateResult(res) {
+    assert.ok(isIPv6(res.address));
+    assert.strictEqual(res.family, 6);
+  }
+
+  validateResult(await dnsPromises.lookup(addresses.INET6_HOST, { family: 6 }));
+
   const req = dns.lookup(addresses.INET6_HOST, {
     family: 6
   }, common.mustCall((err, ip, family) => {
     assert.ifError(err);
-    assert.ok(isIPv6(ip));
-    assert.strictEqual(family, 6);
-
+    validateResult({ address: ip, family });
     done();
   }));
 
@@ -143,35 +166,48 @@ TEST(function test_lookup_ipv6_hint(done) {
   checkWrap(req);
 });
 
-TEST(function test_lookup_ip_ipv6(done) {
+TEST(async function test_lookup_ip_ipv6(done) {
+  function validateResult(res) {
+    assert.ok(isIPv6(res.address));
+    assert.strictEqual(res.family, 6);
+  }
+
+  validateResult(await dnsPromises.lookup('::1'));
+
   const req = dns.lookup(
     '::1',
     common.mustCall((err, ip, family) => {
       assert.ifError(err);
-      assert.ok(isIPv6(ip));
-      assert.strictEqual(family, 6);
-
+      validateResult({ address: ip, family });
       done();
     }));
 
   checkWrap(req);
 });
 
-TEST(function test_lookup_all_ipv6(done) {
+TEST(async function test_lookup_all_ipv6(done) {
+  function validateResult(res) {
+    assert.ok(Array.isArray(res));
+    assert.ok(res.length > 0);
+
+    res.forEach((ip) => {
+      assert.ok(isIPv6(ip.address),
+                `Invalid IPv6: ${ip.address.toString()}`);
+      assert.strictEqual(ip.family, 6);
+    });
+  }
+
+  validateResult(await dnsPromises.lookup(addresses.INET6_HOST, {
+    all: true,
+    family: 6
+  }));
+
   const req = dns.lookup(
     addresses.INET6_HOST,
     { all: true, family: 6 },
     common.mustCall((err, ips) => {
       assert.ifError(err);
-      assert.ok(Array.isArray(ips));
-      assert.ok(ips.length > 0);
-
-      ips.forEach((ip) => {
-        assert.ok(isIPv6(ip.address),
-                  `Invalid IPv6: ${ip.address.toString()}`);
-        assert.strictEqual(ip.family, 6);
-      });
-
+      validateResult(ips);
       done();
     })
   );
diff --git a/test/internet/test-dns-txt-sigsegv.js b/test/internet/test-dns-txt-sigsegv.js
index 54cc464851..b572c6bb7f 100644
--- a/test/internet/test-dns-txt-sigsegv.js
+++ b/test/internet/test-dns-txt-sigsegv.js
@@ -1,7 +1,15 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const dns = require('dns');
+const dnsPromises = dns.promises;
+
+common.crashOnUnhandledRejection();
+
+(async function() {
+  const result = await dnsPromises.resolveTxt('www.microsoft.com');
+  assert.strictEqual(result.length, 0);
+})();
 
 dns.resolveTxt('www.microsoft.com', function(err, records) {
   assert.strictEqual(err, null);
diff --git a/test/internet/test-dns.js b/test/internet/test-dns.js
index 56fa370fce..593d621e82 100644
--- a/test/internet/test-dns.js
+++ b/test/internet/test-dns.js
@@ -28,6 +28,7 @@ const net = require('net');
 const isIPv4 = net.isIPv4;
 const isIPv6 = net.isIPv6;
 const util = require('util');
+const dnsPromises = dns.promises;
 
 common.crashOnUnhandledRejection();
 
@@ -68,17 +69,18 @@ function checkWrap(req) {
 
 
 TEST(function test_reverse_bogus(done) {
+  dnsPromises.reverse('bogus ip')
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ errno: 'EINVAL' }));
+
   assert.throws(() => {
     dns.reverse('bogus ip', common.mustNotCall());
   }, /^Error: getHostByAddr EINVAL bogus ip$/);
   done();
 });
 
-TEST(function test_resolve4_ttl(done) {
-  const req = dns.resolve4(addresses.INET4_HOST, {
-    ttl: true
-  }, function(err, result) {
-    assert.ifError(err);
+TEST(async function test_resolve4_ttl(done) {
+  function validateResult(result) {
     assert.ok(result.length > 0);
 
     for (let i = 0; i < result.length; i++) {
@@ -90,18 +92,25 @@ TEST(function test_resolve4_ttl(done) {
       assert.ok(item.ttl > 0);
       assert.ok(isIPv4(item.address));
     }
+  }
+
+  validateResult(await dnsPromises.resolve4(addresses.INET4_HOST, {
+    ttl: true
+  }));
 
+  const req = dns.resolve4(addresses.INET4_HOST, {
+    ttl: true
+  }, function(err, result) {
+    assert.ifError(err);
+    validateResult(result);
     done();
   });
 
   checkWrap(req);
 });
 
-TEST(function test_resolve6_ttl(done) {
-  const req = dns.resolve6(addresses.INET6_HOST, {
-    ttl: true
-  }, function(err, result) {
-    assert.ifError(err);
+TEST(async function test_resolve6_ttl(done) {
+  function validateResult(result) {
     assert.ok(result.length > 0);
 
     for (let i = 0; i < result.length; i++) {
@@ -113,29 +122,42 @@ TEST(function test_resolve6_ttl(done) {
       assert.ok(item.ttl > 0);
       assert.ok(isIPv6(item.address));
     }
+  }
+
+  validateResult(await dnsPromises.resolve6(addresses.INET6_HOST, {
+    ttl: true
+  }));
 
+  const req = dns.resolve6(addresses.INET6_HOST, {
+    ttl: true
+  }, function(err, result) {
+    assert.ifError(err);
+    validateResult(result);
     done();
   });
 
   checkWrap(req);
 });
 
-TEST(function test_resolveMx(done) {
-  const req = dns.resolveMx(addresses.MX_HOST, function(err, result) {
-    assert.ifError(err);
+TEST(async function test_resolveMx(done) {
+  function validateResult(result) {
     assert.ok(result.length > 0);
 
     for (let i = 0; i < result.length; i++) {
       const item = result[i];
       assert.ok(item);
       assert.strictEqual(typeof item, 'object');
-
       assert.ok(item.exchange);
       assert.strictEqual(typeof item.exchange, 'string');
-
       assert.strictEqual(typeof item.priority, 'number');
     }
+  }
 
+  validateResult(await dnsPromises.resolveMx(addresses.MX_HOST));
+
+  const req = dns.resolveMx(addresses.MX_HOST, function(err, result) {
+    assert.ifError(err);
+    validateResult(result);
     done();
   });
 
@@ -143,6 +165,10 @@ TEST(function test_resolveMx(done) {
 });
 
 TEST(function test_resolveMx_failure(done) {
+  dnsPromises.resolveMx(addresses.INVALID_HOST)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+
   const req = dns.resolveMx(addresses.INVALID_HOST, function(err, result) {
     assert.ok(err instanceof Error);
     assert.strictEqual(err.errno, 'ENOTFOUND');
@@ -155,17 +181,23 @@ TEST(function test_resolveMx_failure(done) {
   checkWrap(req);
 });
 
-TEST(function test_resolveNs(done) {
-  const req = dns.resolveNs(addresses.NS_HOST, function(err, names) {
-    assert.ifError(err);
-    assert.ok(names.length > 0);
+TEST(async function test_resolveNs(done) {
+  function validateResult(result) {
+    assert.ok(result.length > 0);
 
-    for (let i = 0; i < names.length; i++) {
-      const name = names[i];
-      assert.ok(name);
-      assert.strictEqual(typeof name, 'string');
+    for (let i = 0; i < result.length; i++) {
+      const item = result[i];
+
+      assert.ok(item);
+      assert.strictEqual(typeof item, 'string');
     }
+  }
 
+  validateResult(await dnsPromises.resolveNs(addresses.NS_HOST));
+
+  const req = dns.resolveNs(addresses.NS_HOST, function(err, names) {
+    assert.ifError(err);
+    validateResult(names);
     done();
   });
 
@@ -173,6 +205,10 @@ TEST(function test_resolveNs(done) {
 });
 
 TEST(function test_resolveNs_failure(done) {
+  dnsPromises.resolveNs(addresses.INVALID_HOST)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+
   const req = dns.resolveNs(addresses.INVALID_HOST, function(err, result) {
     assert.ok(err instanceof Error);
     assert.strictEqual(err.errno, 'ENOTFOUND');
@@ -185,9 +221,8 @@ TEST(function test_resolveNs_failure(done) {
   checkWrap(req);
 });
 
-TEST(function test_resolveSrv(done) {
-  const req = dns.resolveSrv(addresses.SRV_HOST, function(err, result) {
-    assert.ifError(err);
+TEST(async function test_resolveSrv(done) {
+  function validateResult(result) {
     assert.ok(result.length > 0);
 
     for (let i = 0; i < result.length; i++) {
@@ -202,7 +237,13 @@ TEST(function test_resolveSrv(done) {
       assert.strictEqual(typeof item.priority, 'number');
       assert.strictEqual(typeof item.weight, 'number');
     }
+  }
 
+  validateResult(await dnsPromises.resolveSrv(addresses.SRV_HOST));
+
+  const req = dns.resolveSrv(addresses.SRV_HOST, function(err, result) {
+    assert.ifError(err);
+    validateResult(result);
     done();
   });
 
@@ -210,6 +251,10 @@ TEST(function test_resolveSrv(done) {
 });
 
 TEST(function test_resolveSrv_failure(done) {
+  dnsPromises.resolveSrv(addresses.INVALID_HOST)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+
   const req = dns.resolveSrv(addresses.INVALID_HOST, function(err, result) {
     assert.ok(err instanceof Error);
     assert.strictEqual(err.errno, 'ENOTFOUND');
@@ -222,9 +267,8 @@ TEST(function test_resolveSrv_failure(done) {
   checkWrap(req);
 });
 
-TEST(function test_resolvePtr(done) {
-  const req = dns.resolvePtr(addresses.PTR_HOST, function(err, result) {
-    assert.ifError(err);
+TEST(async function test_resolvePtr(done) {
+  function validateResult(result) {
     assert.ok(result.length > 0);
 
     for (let i = 0; i < result.length; i++) {
@@ -232,7 +276,13 @@ TEST(function test_resolvePtr(done) {
       assert.ok(item);
       assert.strictEqual(typeof item, 'string');
     }
+  }
+
+  validateResult(await dnsPromises.resolvePtr(addresses.PTR_HOST));
 
+  const req = dns.resolvePtr(addresses.PTR_HOST, function(err, result) {
+    assert.ifError(err);
+    validateResult(result);
     done();
   });
 
@@ -240,6 +290,10 @@ TEST(function test_resolvePtr(done) {
 });
 
 TEST(function test_resolvePtr_failure(done) {
+  dnsPromises.resolvePtr(addresses.INVALID_HOST)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+
   const req = dns.resolvePtr(addresses.INVALID_HOST, function(err, result) {
     assert.ok(err instanceof Error);
     assert.strictEqual(err.errno, 'ENOTFOUND');
@@ -252,16 +306,14 @@ TEST(function test_resolvePtr_failure(done) {
   checkWrap(req);
 });
 
-TEST(function test_resolveNaptr(done) {
-  const req = dns.resolveNaptr(addresses.NAPTR_HOST, function(err, result) {
-    assert.ifError(err);
+TEST(async function test_resolveNaptr(done) {
+  function validateResult(result) {
     assert.ok(result.length > 0);
 
     for (let i = 0; i < result.length; i++) {
       const item = result[i];
       assert.ok(item);
       assert.strictEqual(typeof item, 'object');
-
       assert.strictEqual(typeof item.flags, 'string');
       assert.strictEqual(typeof item.service, 'string');
       assert.strictEqual(typeof item.regexp, 'string');
@@ -269,7 +321,13 @@ TEST(function test_resolveNaptr(done) {
       assert.strictEqual(typeof item.order, 'number');
       assert.strictEqual(typeof item.preference, 'number');
     }
+  }
 
+  validateResult(await dnsPromises.resolveNaptr(addresses.NAPTR_HOST));
+
+  const req = dns.resolveNaptr(addresses.NAPTR_HOST, function(err, result) {
+    assert.ifError(err);
+    validateResult(result);
     done();
   });
 
@@ -277,6 +335,10 @@ TEST(function test_resolveNaptr(done) {
 });
 
 TEST(function test_resolveNaptr_failure(done) {
+  dnsPromises.resolveNaptr(addresses.INVALID_HOST)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+
   const req = dns.resolveNaptr(addresses.INVALID_HOST, function(err, result) {
     assert.ok(err instanceof Error);
     assert.strictEqual(err.errno, 'ENOTFOUND');
@@ -289,33 +351,31 @@ TEST(function test_resolveNaptr_failure(done) {
   checkWrap(req);
 });
 
-TEST(function test_resolveSoa(done) {
-  const req = dns.resolveSoa(addresses.SOA_HOST, function(err, result) {
-    assert.ifError(err);
+TEST(async function test_resolveSoa(done) {
+  function validateResult(result) {
     assert.ok(result);
     assert.strictEqual(typeof result, 'object');
-
     assert.strictEqual(typeof result.nsname, 'string');
     assert.ok(result.nsname.length > 0);
-
     assert.strictEqual(typeof result.hostmaster, 'string');
     assert.ok(result.hostmaster.length > 0);
-
     assert.strictEqual(typeof result.serial, 'number');
     assert.ok((result.serial > 0) && (result.serial < 4294967295));
-
     assert.strictEqual(typeof result.refresh, 'number');
     assert.ok((result.refresh > 0) && (result.refresh < 2147483647));
-
     assert.strictEqual(typeof result.retry, 'number');
     assert.ok((result.retry > 0) && (result.retry < 2147483647));
-
     assert.strictEqual(typeof result.expire, 'number');
     assert.ok((result.expire > 0) && (result.expire < 2147483647));
-
     assert.strictEqual(typeof result.minttl, 'number');
     assert.ok((result.minttl >= 0) && (result.minttl < 2147483647));
+  }
 
+  validateResult(await dnsPromises.resolveSoa(addresses.SOA_HOST));
+
+  const req = dns.resolveSoa(addresses.SOA_HOST, function(err, result) {
+    assert.ifError(err);
+    validateResult(result);
     done();
   });
 
@@ -323,6 +383,10 @@ TEST(function test_resolveSoa(done) {
 });
 
 TEST(function test_resolveSoa_failure(done) {
+  dnsPromises.resolveSoa(addresses.INVALID_HOST)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+
   const req = dns.resolveSoa(addresses.INVALID_HOST, function(err, result) {
     assert.ok(err instanceof Error);
     assert.strictEqual(err.errno, 'ENOTFOUND');
@@ -335,17 +399,22 @@ TEST(function test_resolveSoa_failure(done) {
   checkWrap(req);
 });
 
-TEST(function test_resolveCname(done) {
-  const req = dns.resolveCname(addresses.CNAME_HOST, function(err, names) {
-    assert.ifError(err);
-    assert.ok(names.length > 0);
+TEST(async function test_resolveCname(done) {
+  function validateResult(result) {
+    assert.ok(result.length > 0);
 
-    for (let i = 0; i < names.length; i++) {
-      const name = names[i];
+    for (let i = 0; i < result.length; i++) {
+      const name = result[i];
       assert.ok(name);
       assert.strictEqual(typeof name, 'string');
     }
+  }
+
+  validateResult(await dnsPromises.resolveCname(addresses.CNAME_HOST));
 
+  const req = dns.resolveCname(addresses.CNAME_HOST, function(err, names) {
+    assert.ifError(err);
+    validateResult(names);
     done();
   });
 
@@ -353,6 +422,10 @@ TEST(function test_resolveCname(done) {
 });
 
 TEST(function test_resolveCname_failure(done) {
+  dnsPromises.resolveCname(addresses.INVALID_HOST)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+
   const req = dns.resolveCname(addresses.INVALID_HOST, function(err, result) {
     assert.ok(err instanceof Error);
     assert.strictEqual(err.errno, 'ENOTFOUND');
@@ -366,12 +439,18 @@ TEST(function test_resolveCname_failure(done) {
 });
 
 
-TEST(function test_resolveTxt(done) {
+TEST(async function test_resolveTxt(done) {
+  function validateResult(result) {
+    assert.ok(Array.isArray(result[0]));
+    assert.strictEqual(result.length, 1);
+    assert(result[0][0].startsWith('v=spf1'));
+  }
+
+  validateResult(await dnsPromises.resolveTxt(addresses.TXT_HOST));
+
   const req = dns.resolveTxt(addresses.TXT_HOST, function(err, records) {
     assert.ifError(err);
-    assert.strictEqual(records.length, 1);
-    assert.ok(util.isArray(records[0]));
-    assert(records[0][0].startsWith('v=spf1'));
+    validateResult(records);
     done();
   });
 
@@ -379,6 +458,10 @@ TEST(function test_resolveTxt(done) {
 });
 
 TEST(function test_resolveTxt_failure(done) {
+  dnsPromises.resolveTxt(addresses.INVALID_HOST)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ errno: 'ENOTFOUND' }));
+
   const req = dns.resolveTxt(addresses.INVALID_HOST, function(err, result) {
     assert.ok(err instanceof Error);
     assert.strictEqual(err.errno, 'ENOTFOUND');
@@ -393,6 +476,10 @@ TEST(function test_resolveTxt_failure(done) {
 
 
 TEST(function test_lookup_failure(done) {
+  dnsPromises.lookup(addresses.INVALID_HOST, 4)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ errno: dns.NOTFOUND }));
+
   const req = dns.lookup(addresses.INVALID_HOST, 4, (err, ip, family) => {
     assert.ok(err instanceof Error);
     assert.strictEqual(err.errno, dns.NOTFOUND);
@@ -407,17 +494,23 @@ TEST(function test_lookup_failure(done) {
 });
 
 
-TEST(function test_lookup_ip_all(done) {
+TEST(async function test_lookup_ip_all(done) {
+  function validateResult(result) {
+    assert.ok(Array.isArray(result));
+    assert.ok(result.length > 0);
+    assert.strictEqual(result[0].address, '127.0.0.1');
+    assert.strictEqual(result[0].family, 4);
+  }
+
+  validateResult(await dnsPromises.lookup('127.0.0.1', { all: true }));
+
   const req = dns.lookup(
     '127.0.0.1',
     { all: true },
     function(err, ips, family) {
       assert.ifError(err);
-      assert.ok(Array.isArray(ips));
-      assert.ok(ips.length > 0);
-      assert.strictEqual(ips[0].address, '127.0.0.1');
-      assert.strictEqual(ips[0].family, 4);
-
+      assert.strictEqual(family, undefined);
+      validateResult(ips);
       done();
     }
   );
@@ -452,7 +545,9 @@ TEST(function test_lookup_ip_promise(done) {
 });
 
 
-TEST(function test_lookup_null_all(done) {
+TEST(async function test_lookup_null_all(done) {
+  assert.deepStrictEqual(await dnsPromises.lookup(null, { all: true }), []);
+
   const req = dns.lookup(null, { all: true }, function(err, ips, family) {
     assert.ifError(err);
     assert.ok(Array.isArray(ips));
@@ -465,15 +560,12 @@ TEST(function test_lookup_null_all(done) {
 });
 
 
-TEST(function test_lookup_all_mixed(done) {
-  const req = dns.lookup(addresses.INET_HOST, {
-    all: true
-  }, function(err, ips) {
-    assert.ifError(err);
-    assert.ok(Array.isArray(ips));
-    assert.ok(ips.length > 0);
+TEST(async function test_lookup_all_mixed(done) {
+  function validateResult(result) {
+    assert.ok(Array.isArray(result));
+    assert.ok(result.length > 0);
 
-    ips.forEach(function(ip) {
+    result.forEach(function(ip) {
       if (isIPv4(ip.address))
         assert.strictEqual(ip.family, 4);
       else if (isIPv6(ip.address))
@@ -481,7 +573,15 @@ TEST(function test_lookup_all_mixed(done) {
       else
         assert.fail('unexpected IP address');
     });
+  }
+
+  validateResult(await dnsPromises.lookup(addresses.INET_HOST, { all: true }));
 
+  const req = dns.lookup(addresses.INET_HOST, {
+    all: true
+  }, function(err, ips) {
+    assert.ifError(err);
+    validateResult(ips);
     done();
   });
 
@@ -490,6 +590,10 @@ TEST(function test_lookup_all_mixed(done) {
 
 
 TEST(function test_lookupservice_invalid(done) {
+  dnsPromises.lookupService('1.2.3.4', 80)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({ code: 'ENOTFOUND' }));
+
   const req = dns.lookupService('1.2.3.4', 80, function(err, host, service) {
     assert(err instanceof Error);
     assert.strictEqual(err.code, 'ENOTFOUND');
@@ -503,6 +607,13 @@ TEST(function test_lookupservice_invalid(done) {
 
 
 TEST(function test_reverse_failure(done) {
+  dnsPromises.reverse('203.0.113.0')
+    .then(common.mustNotCall())
+    .catch(common.expectsError({
+      code: 'ENOTFOUND',
+      hostname: '203.0.113.0'
+    }));
+
   // 203.0.113.0/24 are addresses reserved for (RFC) documentation use only
   const req = dns.reverse('203.0.113.0', function(err) {
     assert(err instanceof Error);
@@ -518,6 +629,13 @@ TEST(function test_reverse_failure(done) {
 
 
 TEST(function test_lookup_failure(done) {
+  dnsPromises.lookup(addresses.INVALID_HOST)
+    .then(common.mustNotCall())
+    .catch(common.expectsError({
+      code: 'ENOTFOUND',
+      hostname: addresses.INVALID_HOST
+    }));
+
   const req = dns.lookup(addresses.INVALID_HOST, (err) => {
     assert(err instanceof Error);
     assert.strictEqual(err.code, 'ENOTFOUND');  // Silly error code...
@@ -584,3 +702,7 @@ dns.lookup(addresses.INET6_HOST, 6, common.mustCall());
 dns.lookup(addresses.INET_HOST, {}, common.mustCall());
 dns.lookupService('0.0.0.0', '0', common.mustCall());
 dns.lookupService('0.0.0.0', 0, common.mustCall());
+(async function() {
+  await dnsPromises.lookup(addresses.INET6_HOST, 6);
+  await dnsPromises.lookup(addresses.INET_HOST, {});
+})();
diff --git a/test/parallel/test-c-ares.js b/test/parallel/test-c-ares.js
index 8ba221ca99..59ae40b2b8 100644
--- a/test/parallel/test-c-ares.js
+++ b/test/parallel/test-c-ares.js
@@ -23,8 +23,26 @@
 const common = require('../common');
 const assert = require('assert');
 
+common.crashOnUnhandledRejection();
+
 const dns = require('dns');
+const dnsPromises = dns.promises;
+
+(async function() {
+  let res;
+
+  res = await dnsPromises.lookup(null);
+  assert.strictEqual(res.address, null);
+  assert.strictEqual(res.family, 4);
+
+  res = await dnsPromises.lookup('127.0.0.1');
+  assert.strictEqual(res.address, '127.0.0.1');
+  assert.strictEqual(res.family, 4);
 
+  res = await dnsPromises.lookup('::1');
+  assert.strictEqual(res.address, '::1');
+  assert.strictEqual(res.family, 6);
+})();
 
 // Try resolution without callback
 
@@ -52,14 +70,18 @@ dns.lookup('::1', common.mustCall((error, result, addressType) => {
   // Try calling resolve with an unsupported type that's an object key
   'toString'
 ].forEach((val) => {
+  const err = {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: TypeError,
+    message: `The value "${val}" is invalid for option "rrtype"`
+  };
+
   common.expectsError(
     () => dns.resolve('www.google.com', val),
-    {
-      code: 'ERR_INVALID_OPT_VALUE',
-      type: TypeError,
-      message: `The value "${val}" is invalid for option "rrtype"`
-    }
+    err
   );
+
+  common.expectsError(() => dnsPromises.resolve('www.google.com', val), err);
 });
 
 // Windows doesn't usually have an entry for localhost 127.0.0.1 in
@@ -70,4 +92,8 @@ if (!common.isWindows) {
     assert.ifError(error);
     assert.ok(Array.isArray(domains));
   }));
+
+  (async function() {
+    assert.ok(Array.isArray(await dnsPromises.reverse('127.0.0.1')));
+  })();
 }
diff --git a/test/parallel/test-dns-lookup.js b/test/parallel/test-dns-lookup.js
index b9c0dfc6df..5ee3bc7051 100644
--- a/test/parallel/test-dns-lookup.js
+++ b/test/parallel/test-dns-lookup.js
@@ -3,17 +3,23 @@ const common = require('../common');
 const assert = require('assert');
 const cares = process.binding('cares_wrap');
 const dns = require('dns');
+const dnsPromises = dns.promises;
+
+common.crashOnUnhandledRejection();
 
 // Stub `getaddrinfo` to *always* error.
 cares.getaddrinfo = () => process.binding('uv').UV_ENOENT;
 
-common.expectsError(() => {
-  dns.lookup(1, {});
-}, {
-  code: 'ERR_INVALID_ARG_TYPE',
-  type: TypeError,
-  message: /^The "hostname" argument must be one of type string or falsy/
-});
+{
+  const err = {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message: /^The "hostname" argument must be one of type string or falsy/
+  };
+
+  common.expectsError(() => dns.lookup(1, {}), err);
+  common.expectsError(() => dnsPromises.lookup(1, {}), err);
+}
 
 common.expectsError(() => {
   dns.lookup(false, 'cb');
@@ -29,29 +35,66 @@ common.expectsError(() => {
   type: TypeError
 });
 
-common.expectsError(() => {
-  dns.lookup(false, {
+{
+  const err = {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: TypeError,
+    message: 'The value "100" is invalid for option "hints"'
+  };
+  const options = {
     hints: 100,
     family: 0,
     all: false
-  }, common.mustNotCall());
-}, {
-  code: 'ERR_INVALID_OPT_VALUE',
-  type: TypeError,
-  message: 'The value "100" is invalid for option "hints"'
-});
+  };
 
-common.expectsError(() => {
-  dns.lookup(false, {
+  common.expectsError(() => { dnsPromises.lookup(false, options); }, err);
+  common.expectsError(() => {
+    dns.lookup(false, options, common.mustNotCall());
+  }, err);
+}
+
+{
+  const err = {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: TypeError,
+    message: 'The value "20" is invalid for option "family"'
+  };
+  const options = {
     hints: 0,
     family: 20,
     all: false
-  }, common.mustNotCall());
-}, {
-  code: 'ERR_INVALID_OPT_VALUE',
-  type: TypeError,
-  message: 'The value "20" is invalid for option "family"'
-});
+  };
+
+  common.expectsError(() => { dnsPromises.lookup(false, options); }, err);
+  common.expectsError(() => {
+    dns.lookup(false, options, common.mustNotCall());
+  }, err);
+}
+
+(async function() {
+  let res;
+
+  res = await dnsPromises.lookup(false, {
+    hints: 0,
+    family: 0,
+    all: true
+  });
+  assert.deepStrictEqual(res, []);
+
+  res = await dnsPromises.lookup('127.0.0.1', {
+    hints: 0,
+    family: 4,
+    all: true
+  });
+  assert.deepStrictEqual(res, [{ address: '127.0.0.1', family: 4 }]);
+
+  res = await dnsPromises.lookup('127.0.0.1', {
+    hints: 0,
+    family: 4,
+    all: false
+  });
+  assert.deepStrictEqual(res, { address: '127.0.0.1', family: 4 });
+})();
 
 dns.lookup(false, {
   hints: 0,
diff --git a/test/parallel/test-dns-resolveany-bad-ancount.js b/test/parallel/test-dns-resolveany-bad-ancount.js
index 63ed1774b1..d48d9385b8 100644
--- a/test/parallel/test-dns-resolveany-bad-ancount.js
+++ b/test/parallel/test-dns-resolveany-bad-ancount.js
@@ -4,6 +4,9 @@ const dnstools = require('../common/dns');
 const dns = require('dns');
 const assert = require('assert');
 const dgram = require('dgram');
+const dnsPromises = dns.promises;
+
+common.crashOnUnhandledRejection();
 
 const server = dgram.createSocket('udp4');
 
@@ -20,12 +23,20 @@ server.on('message', common.mustCall((msg, { address, port }) => {
   // Overwrite the # of answers with 2, which is incorrect.
   buf.writeUInt16LE(2, 6);
   server.send(buf, port, address);
-}));
+}, 2));
 
-server.bind(0, common.mustCall(() => {
+server.bind(0, common.mustCall(async () => {
   const address = server.address();
   dns.setServers([`127.0.0.1:${address.port}`]);
 
+  dnsPromises.resolveAny('example.org')
+    .then(common.mustNotCall())
+    .catch(common.expectsError({
+      code: 'EBADRESP',
+      syscall: 'queryAny',
+      hostname: 'example.org'
+    }));
+
   dns.resolveAny('example.org', common.mustCall((err) => {
     assert.strictEqual(err.code, 'EBADRESP');
     assert.strictEqual(err.syscall, 'queryAny');
diff --git a/test/parallel/test-dns-resolveany.js b/test/parallel/test-dns-resolveany.js
index 82f589147f..f9a6399cef 100644
--- a/test/parallel/test-dns-resolveany.js
+++ b/test/parallel/test-dns-resolveany.js
@@ -4,6 +4,9 @@ const dnstools = require('../common/dns');
 const dns = require('dns');
 const assert = require('assert');
 const dgram = require('dgram');
+const dnsPromises = dns.promises;
+
+common.crashOnUnhandledRejection();
 
 const answers = [
   { type: 'A', address: '1.2.3.4', ttl: 123 },
@@ -36,18 +39,24 @@ server.on('message', common.mustCall((msg, { address, port }) => {
     questions: parsed.questions,
     answers: answers.map((answer) => Object.assign({ domain }, answer)),
   }), port, address);
-}));
+}, 2));
 
-server.bind(0, common.mustCall(() => {
+server.bind(0, common.mustCall(async () => {
   const address = server.address();
   dns.setServers([`127.0.0.1:${address.port}`]);
 
+  validateResults(await dnsPromises.resolveAny('example.org'));
+
   dns.resolveAny('example.org', common.mustCall((err, res) => {
     assert.ifError(err);
-    // Compare copies with ttl removed, c-ares fiddles with that value.
-    assert.deepStrictEqual(
-      res.map((r) => Object.assign({}, r, { ttl: null })),
-      answers.map((r) => Object.assign({}, r, { ttl: null })));
+    validateResults(res);
     server.close();
   }));
 }));
+
+function validateResults(res) {
+  // Compare copies with ttl removed, c-ares fiddles with that value.
+  assert.deepStrictEqual(
+    res.map((r) => Object.assign({}, r, { ttl: null })),
+    answers.map((r) => Object.assign({}, r, { ttl: null })));
+}
diff --git a/test/parallel/test-dns-resolvens-typeerror.js b/test/parallel/test-dns-resolvens-typeerror.js
index 8da7d3a489..ec57bba614 100644
--- a/test/parallel/test-dns-resolvens-typeerror.js
+++ b/test/parallel/test-dns-resolvens-typeerror.js
@@ -27,7 +27,18 @@ const common = require('../common');
 // Issue https://github.com/nodejs/node-v0.x-archive/issues/7070
 
 const dns = require('dns');
+const dnsPromises = dns.promises;
 
+common.crashOnUnhandledRejection();
+
+common.expectsError(
+  () => dnsPromises.resolveNs([]), // bad name
+  {
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError,
+    message: /^The "name" argument must be of type string/
+  }
+);
 common.expectsError(
   () => dns.resolveNs([]), // bad name
   {
diff --git a/test/parallel/test-dns.js b/test/parallel/test-dns.js
index f50b9464f1..9acf18994e 100644
--- a/test/parallel/test-dns.js
+++ b/test/parallel/test-dns.js
@@ -24,6 +24,9 @@ const common = require('../common');
 const assert = require('assert');
 
 const dns = require('dns');
+const dnsPromises = dns.promises;
+
+common.crashOnUnhandledRejection();
 
 const existing = dns.getServers();
 assert(existing.length > 0);
@@ -149,7 +152,7 @@ common.expectsError(() => {
     code: 'ERR_INVALID_ARG_TYPE',
     type: TypeError,
     message: /^The "hostname" argument must be one of type string or falsy/
-  }, 5);
+  }, 10);
 
   assert.throws(() => dns.lookup({}, common.mustNotCall()), errorReg);
 
@@ -161,6 +164,12 @@ common.expectsError(() => {
 
   assert.throws(() => dns.lookup(common.mustNotCall(), common.mustNotCall()),
                 errorReg);
+
+  assert.throws(() => dnsPromises.lookup({}), errorReg);
+  assert.throws(() => dnsPromises.lookup([]), errorReg);
+  assert.throws(() => dnsPromises.lookup(true), errorReg);
+  assert.throws(() => dnsPromises.lookup(1), errorReg);
+  assert.throws(() => dnsPromises.lookup(common.mustNotCall()), errorReg);
 }
 
 // dns.lookup should accept falsey values
@@ -171,30 +180,37 @@ common.expectsError(() => {
     assert.strictEqual(family, 4);
   };
 
-  dns.lookup('', common.mustCall(checkCallback));
-  dns.lookup(null, common.mustCall(checkCallback));
-  dns.lookup(undefined, common.mustCall(checkCallback));
-  dns.lookup(0, common.mustCall(checkCallback));
-  dns.lookup(NaN, common.mustCall(checkCallback));
+  ['', null, undefined, 0, NaN].forEach(async (value) => {
+    const res = await dnsPromises.lookup(value);
+    assert.deepStrictEqual(res, { address: null, family: 4 });
+    dns.lookup(value, common.mustCall(checkCallback));
+  });
 }
 
-/*
- * Make sure that dns.lookup throws if hints does not represent a valid flag.
- * (dns.V4MAPPED | dns.ADDRCONFIG) + 1 is invalid because:
- * - it's different from dns.V4MAPPED and dns.ADDRCONFIG.
- * - it's different from them bitwise ored.
- * - it's different from 0.
- * - it's an odd number different than 1, and thus is invalid, because
- * flags are either === 1 or even.
- */
-common.expectsError(() => {
-  dns.lookup('nodejs.org', { hints: (dns.V4MAPPED | dns.ADDRCONFIG) + 1 },
-             common.mustNotCall());
-}, {
-  code: 'ERR_INVALID_OPT_VALUE',
-  type: TypeError,
-  message: /The value "\d+" is invalid for option "hints"/
-});
+{
+  /*
+  * Make sure that dns.lookup throws if hints does not represent a valid flag.
+  * (dns.V4MAPPED | dns.ADDRCONFIG) + 1 is invalid because:
+  * - it's different from dns.V4MAPPED and dns.ADDRCONFIG.
+  * - it's different from them bitwise ored.
+  * - it's different from 0.
+  * - it's an odd number different than 1, and thus is invalid, because
+  * flags are either === 1 or even.
+  */
+  const hints = (dns.V4MAPPED | dns.ADDRCONFIG) + 1;
+  const err = {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: TypeError,
+    message: /The value "\d+" is invalid for option "hints"/
+  };
+
+  common.expectsError(() => {
+    dnsPromises.lookup('nodejs.org', { hints });
+  }, err);
+  common.expectsError(() => {
+    dns.lookup('nodejs.org', { hints }, common.mustNotCall());
+  }, err);
+}
 
 common.expectsError(() => dns.lookup('nodejs.org'), {
   code: 'ERR_INVALID_CALLBACK',
@@ -219,33 +235,57 @@ dns.lookup('', {
   hints: dns.ADDRCONFIG | dns.V4MAPPED
 }, common.mustCall());
 
-common.expectsError(() => dns.lookupService('0.0.0.0'), {
-  code: 'ERR_MISSING_ARGS',
-  type: TypeError,
-  message: 'The "host", "port", and "callback" arguments must be specified'
-});
+(async function() {
+  await dnsPromises.lookup('', { family: 4, hints: 0 });
+  await dnsPromises.lookup('', { family: 6, hints: dns.ADDRCONFIG });
+  await dnsPromises.lookup('', { hints: dns.V4MAPPED });
+  await dnsPromises.lookup('', { hints: dns.ADDRCONFIG | dns.V4MAPPED });
+})();
 
-const invalidHost = 'fasdfdsaf';
-common.expectsError(() => {
-  dns.lookupService(invalidHost, 0, common.mustNotCall());
-}, {
-  code: 'ERR_INVALID_OPT_VALUE',
-  type: TypeError,
-  message: `The value "${invalidHost}" is invalid for option "host"`
-});
+{
+  const err = {
+    code: 'ERR_MISSING_ARGS',
+    type: TypeError,
+    message: 'The "host", "port", and "callback" arguments must be specified'
+  };
+
+  common.expectsError(() => dns.lookupService('0.0.0.0'), err);
+  err.message = 'The "host" and "port" arguments must be specified';
+  common.expectsError(() => dnsPromises.lookupService('0.0.0.0'), err);
+}
+
+{
+  const invalidHost = 'fasdfdsaf';
+  const err = {
+    code: 'ERR_INVALID_OPT_VALUE',
+    type: TypeError,
+    message: `The value "${invalidHost}" is invalid for option "host"`
+  };
+
+  common.expectsError(() => {
+    dnsPromises.lookupService(invalidHost, 0);
+  }, err);
+
+  common.expectsError(() => {
+    dns.lookupService(invalidHost, 0, common.mustNotCall());
+  }, err);
+}
 
 const portErr = (port) => {
-  common.expectsError(
-    () => {
-      dns.lookupService('0.0.0.0', port, common.mustNotCall());
-    },
-    {
-      code: 'ERR_SOCKET_BAD_PORT',
-      message:
-        `Port should be > 0 and < 65536. Received ${port}.`,
-      type: RangeError
-    }
-  );
+  const err = {
+    code: 'ERR_SOCKET_BAD_PORT',
+    message:
+      `Port should be > 0 and < 65536. Received ${port}.`,
+    type: RangeError
+  };
+
+  common.expectsError(() => {
+    dnsPromises.lookupService('0.0.0.0', port);
+  }, err);
+
+  common.expectsError(() => {
+    dns.lookupService('0.0.0.0', port, common.mustNotCall());
+  }, err);
 };
 portErr(null);
 portErr(undefined);