• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1'use strict';
2const common = require('../common');
3const { addresses } = require('../common/internet');
4const assert = require('assert');
5const dns = require('dns');
6const net = require('net');
7const util = require('util');
8const isIPv4 = net.isIPv4;
9
10const dnsPromises = dns.promises;
11let running = false;
12const queue = [];
13
14function TEST(f) {
15  function next() {
16    const f = queue.shift();
17    if (f) {
18      running = true;
19      console.log(f.name);
20      f(done);
21    }
22  }
23
24  function done() {
25    running = false;
26    process.nextTick(next);
27  }
28
29  queue.push(f);
30
31  if (!running) {
32    next();
33  }
34}
35
36function checkWrap(req) {
37  assert.ok(typeof req === 'object');
38}
39
40TEST(async function test_resolve4(done) {
41  function validateResult(res) {
42    assert.ok(res.length > 0);
43
44    for (let i = 0; i < res.length; i++) {
45      assert.ok(isIPv4(res[i]));
46    }
47  }
48
49  validateResult(await dnsPromises.resolve4(addresses.INET4_HOST));
50
51  const req = dns.resolve4(
52    addresses.INET4_HOST,
53    common.mustCall((err, ips) => {
54      assert.ifError(err);
55      validateResult(ips);
56      done();
57    }));
58
59  checkWrap(req);
60});
61
62TEST(async function test_reverse_ipv4(done) {
63  function validateResult(res) {
64    assert.ok(res.length > 0);
65
66    for (let i = 0; i < res.length; i++) {
67      assert.ok(res[i]);
68      assert.ok(typeof res[i] === 'string');
69    }
70  }
71
72  validateResult(await dnsPromises.reverse(addresses.INET4_IP));
73
74  const req = dns.reverse(
75    addresses.INET4_IP,
76    common.mustCall((err, domains) => {
77      assert.ifError(err);
78      validateResult(domains);
79      done();
80    }));
81
82  checkWrap(req);
83});
84
85TEST(async function test_lookup_ipv4_explicit(done) {
86  function validateResult(res) {
87    assert.ok(net.isIPv4(res.address));
88    assert.strictEqual(res.family, 4);
89  }
90
91  validateResult(await dnsPromises.lookup(addresses.INET4_HOST, 4));
92
93  const req = dns.lookup(
94    addresses.INET4_HOST, 4,
95    common.mustCall((err, ip, family) => {
96      assert.ifError(err);
97      validateResult({ address: ip, family });
98      done();
99    }));
100
101  checkWrap(req);
102});
103
104TEST(async function test_lookup_ipv4_implicit(done) {
105  function validateResult(res) {
106    assert.ok(net.isIPv4(res.address));
107    assert.strictEqual(res.family, 4);
108  }
109
110  validateResult(await dnsPromises.lookup(addresses.INET4_HOST));
111
112  const req = dns.lookup(
113    addresses.INET4_HOST,
114    common.mustCall((err, ip, family) => {
115      assert.ifError(err);
116      validateResult({ address: ip, family });
117      done();
118    }));
119
120  checkWrap(req);
121});
122
123TEST(async function test_lookup_ipv4_explicit_object(done) {
124  function validateResult(res) {
125    assert.ok(net.isIPv4(res.address));
126    assert.strictEqual(res.family, 4);
127  }
128
129  validateResult(await dnsPromises.lookup(addresses.INET4_HOST, { family: 4 }));
130
131  const req = dns.lookup(addresses.INET4_HOST, {
132    family: 4
133  }, common.mustCall((err, ip, family) => {
134    assert.ifError(err);
135    validateResult({ address: ip, family });
136    done();
137  }));
138
139  checkWrap(req);
140});
141
142TEST(async function test_lookup_ipv4_hint_addrconfig(done) {
143  function validateResult(res) {
144    assert.ok(net.isIPv4(res.address));
145    assert.strictEqual(res.family, 4);
146  }
147
148  validateResult(await dnsPromises.lookup(addresses.INET4_HOST, {
149    hints: dns.ADDRCONFIG
150  }));
151
152  const req = dns.lookup(addresses.INET4_HOST, {
153    hints: dns.ADDRCONFIG
154  }, common.mustCall((err, ip, family) => {
155    assert.ifError(err);
156    validateResult({ address: ip, family });
157    done();
158  }));
159
160  checkWrap(req);
161});
162
163TEST(async function test_lookup_ip_ipv4(done) {
164  function validateResult(res) {
165    assert.strictEqual(res.address, '127.0.0.1');
166    assert.strictEqual(res.family, 4);
167  }
168
169  validateResult(await dnsPromises.lookup('127.0.0.1'));
170
171  const req = dns.lookup('127.0.0.1',
172                         common.mustCall((err, ip, family) => {
173                           assert.ifError(err);
174                           validateResult({ address: ip, family });
175                           done();
176                         }));
177
178  checkWrap(req);
179});
180
181TEST(async function test_lookup_localhost_ipv4(done) {
182  function validateResult(res) {
183    assert.strictEqual(res.address, '127.0.0.1');
184    assert.strictEqual(res.family, 4);
185  }
186
187  validateResult(await dnsPromises.lookup('localhost', 4));
188
189  const req = dns.lookup('localhost', 4,
190                         common.mustCall((err, ip, family) => {
191                           assert.ifError(err);
192                           validateResult({ address: ip, family });
193                           done();
194                         }));
195
196  checkWrap(req);
197});
198
199TEST(async function test_lookup_all_ipv4(done) {
200  function validateResult(res) {
201    assert.ok(Array.isArray(res));
202    assert.ok(res.length > 0);
203
204    res.forEach((ip) => {
205      assert.ok(isIPv4(ip.address));
206      assert.strictEqual(ip.family, 4);
207    });
208  }
209
210  validateResult(await dnsPromises.lookup(addresses.INET4_HOST, {
211    all: true,
212    family: 4
213  }));
214
215  const req = dns.lookup(
216    addresses.INET4_HOST,
217    { all: true, family: 4 },
218    common.mustCall((err, ips) => {
219      assert.ifError(err);
220      validateResult(ips);
221      done();
222    })
223  );
224
225  checkWrap(req);
226});
227
228TEST(async function test_lookupservice_ip_ipv4(done) {
229  function validateResult(res) {
230    assert.strictEqual(typeof res.hostname, 'string');
231    assert(res.hostname);
232    assert(['http', 'www', '80'].includes(res.service));
233  }
234
235  validateResult(await dnsPromises.lookupService('127.0.0.1', 80));
236
237  const req = dns.lookupService(
238    '127.0.0.1', 80,
239    common.mustCall((err, hostname, service) => {
240      assert.ifError(err);
241      validateResult({ hostname, service });
242      done();
243    })
244  );
245
246  checkWrap(req);
247});
248
249TEST(function test_lookupservice_ip_ipv4_promise(done) {
250  util.promisify(dns.lookupService)('127.0.0.1', 80)
251    .then(common.mustCall(({ hostname, service }) => {
252      assert.strictEqual(typeof hostname, 'string');
253      assert(hostname.length > 0);
254      assert(['http', 'www', '80'].includes(service));
255      done();
256    }));
257});
258