chore: move cli/tests/ -> tests/ (#22369)

This looks like a massive PR, but it's only a move from cli/tests ->
tests, and updates of relative paths for files.

This is the first step towards aggregate all of the integration test
files under tests/, which will lead to a set of integration tests that
can run without the CLI binary being built.

While we could leave these tests under `cli`, it would require us to
keep a more complex directory structure for the various test runners. In
addition, we have a lot of complexity to ignore various test files in
the `cli` project itself (cargo publish exclusion rules, autotests =
false, etc).

And finally, the `tests/` folder will eventually house the `test_ffi`,
`test_napi` and other testing code, reducing the size of the root repo
directory.

For easier review, the extremely large and noisy "move" is in the first
commit (with no changes -- just a move), while the remainder of the
changes to actual files is in the second commit.

1 files changed, 250 insertions, 0 deletions

diff --git a/tests/node_compat/test/internet/test-dns-ipv6.js b/tests/node_compat/test/internet/test-dns-ipv6.js
new file mode 100644
index 000000000..4b94d6041
--- /dev/null
+++ b/tests/node_compat/test/internet/test-dns-ipv6.js
@@ -0,0 +1,250 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+
+// Copyright Joyent and Node contributors. All rights reserved. MIT license.
+// Taken from Node 16.13.0
+// This file is automatically generated by "node/_tools/setup.ts". Do not modify this file manually
+
+'use strict';
+
+// TODO: enable remaining tests once functionality is implemented.
+
+const common = require('../common');
+const { addresses } = require('../common/internet');
+if (!common.hasIPv6)
+  common.skip('this test, no IPv6 support');
+
+const assert = require('assert');
+const dns = require('dns');
+const net = require('net');
+const dnsPromises = dns.promises;
+const isIPv6 = net.isIPv6;
+
+let running = false;
+const queue = [];
+
+function TEST(f) {
+  function next() {
+    const f = queue.shift();
+    if (f) {
+      running = true;
+      console.log(f.name);
+      f(done);
+    }
+  }
+
+  function done() {
+    running = false;
+    process.nextTick(next);
+  }
+
+  queue.push(f);
+
+  if (!running) {
+    next();
+  }
+}
+
+function checkWrap(req) {
+  assert.ok(typeof req === 'object');
+}
+
+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.mustSucceed((ips) => {
+      validateResult(ips);
+      done();
+    }));
+
+  checkWrap(req);
+});
+
+// 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.mustSucceed((domains) => {
+//       validateResult(domains);
+//       done();
+//     }));
+
+//   checkWrap(req);
+// });
+
+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.mustSucceed((ip, family) => {
+      validateResult({ address: ip, family });
+      done();
+    }));
+
+  checkWrap(req);
+});
+
+// This ends up just being too problematic to test
+// TEST(function test_lookup_ipv6_implicit(done) {
+//   var req = dns.lookup(addresses.INET6_HOST, function(err, ip, family) {
+//     assert.ifError(err);
+//     assert.ok(net.isIPv6(ip));
+//     assert.strictEqual(family, 6);
+
+//     done();
+//   });
+
+//   checkWrap(req);
+// });
+
+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.mustSucceed((ip, family) => {
+    validateResult({ address: ip, family });
+    done();
+  }));
+
+  checkWrap(req);
+});
+
+TEST(function test_lookup_ipv6_hint(done) {
+  const req = dns.lookup(addresses.INET6_HOST, {
+    family: 6,
+    hints: dns.V4MAPPED
+  }, common.mustCall((err, ip, family) => {
+    if (err) {
+      // FreeBSD does not support V4MAPPED
+      if (common.isFreeBSD) {
+        assert(err instanceof Error);
+        assert.strictEqual(err.code, 'EAI_BADFLAGS');
+        assert.strictEqual(err.hostname, addresses.INET_HOST);
+        assert.match(err.message, /getaddrinfo EAI_BADFLAGS/);
+        done();
+        return;
+      }
+
+      assert.ifError(err);
+    }
+
+    assert.ok(isIPv6(ip));
+    assert.strictEqual(family, 6);
+
+    done();
+  }));
+
+  checkWrap(req);
+});
+
+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.mustSucceed((ip, family) => {
+      validateResult({ address: ip, family });
+      done();
+    }));
+
+  checkWrap(req);
+});
+
+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.mustSucceed((ips) => {
+      validateResult(ips);
+      done();
+    })
+  );
+
+  checkWrap(req);
+});
+
+// TEST(function test_lookupservice_ip_ipv6(done) {
+//   const req = dns.lookupService(
+//     '::1', 80,
+//     common.mustCall((err, host, service) => {
+//       if (err) {
+//         // Not skipping the test, rather checking an alternative result,
+//         // i.e. that ::1 may not be configured (e.g. in /etc/hosts)
+//         assert.strictEqual(err.code, 'ENOTFOUND');
+//         return done();
+//       }
+//       assert.strictEqual(typeof host, 'string');
+//       assert(host);
+//       assert(['http', 'www', '80'].includes(service));
+//       done();
+//     })
+//   );
+
+//   checkWrap(req);
+// });
+
+// Disabled because it appears to be not working on Linux.
+// TEST(function test_lookup_localhost_ipv6(done) {
+//   var req = dns.lookup('localhost', 6, function(err, ip, family) {
+//     assert.ifError(err);
+//     assert.ok(net.isIPv6(ip));
+//     assert.strictEqual(family, 6);
+//
+//     done();
+//   });
+//
+//   checkWrap(req);
+// });