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, 287 insertions, 0 deletions

diff --git a/tests/node_compat/test/parallel/test-stream-construct.js b/tests/node_compat/test/parallel/test-stream-construct.js
new file mode 100644
index 000000000..0cd93c9e9
--- /dev/null
+++ b/tests/node_compat/test/parallel/test-stream-construct.js
@@ -0,0 +1,287 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+
+// Copyright Joyent and Node contributors. All rights reserved. MIT license.
+// Taken from Node 18.12.1
+// This file is automatically generated by `tools/node_compat/setup.ts`. Do not modify this file manually.
+
+'use strict';
+
+const common = require('../common');
+const { Writable, Readable, Duplex } = require('stream');
+const assert = require('assert');
+
+{
+  // Multiple callback.
+  new Writable({
+    construct: common.mustCall((callback) => {
+      callback();
+      callback();
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    code: 'ERR_MULTIPLE_CALLBACK'
+  }));
+}
+
+{
+  // Multiple callback.
+  new Readable({
+    construct: common.mustCall((callback) => {
+      callback();
+      callback();
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    code: 'ERR_MULTIPLE_CALLBACK'
+  }));
+}
+
+{
+  // Synchronous error.
+
+  new Writable({
+    construct: common.mustCall((callback) => {
+      callback(new Error('test'));
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    message: 'test'
+  }));
+}
+
+{
+  // Synchronous error.
+
+  new Readable({
+    construct: common.mustCall((callback) => {
+      callback(new Error('test'));
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    message: 'test'
+  }));
+}
+
+{
+  // Asynchronous error.
+
+  new Writable({
+    construct: common.mustCall((callback) => {
+      process.nextTick(callback, new Error('test'));
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    message: 'test'
+  }));
+}
+
+{
+  // Asynchronous error.
+
+  new Readable({
+    construct: common.mustCall((callback) => {
+      process.nextTick(callback, new Error('test'));
+    })
+  }).on('error', common.expectsError({
+    name: 'Error',
+    message: 'test'
+  }));
+}
+
+function testDestroy(factory) {
+  {
+    let constructed = false;
+    const s = factory({
+      construct: common.mustCall((cb) => {
+        constructed = true;
+        process.nextTick(cb);
+      })
+    });
+    s.on('close', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.destroy();
+  }
+
+  {
+    let constructed = false;
+    const s = factory({
+      construct: common.mustCall((cb) => {
+        constructed = true;
+        process.nextTick(cb);
+      })
+    });
+    s.on('close', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.destroy(null, () => {
+      assert.strictEqual(constructed, true);
+    });
+  }
+
+  {
+    let constructed = false;
+    const s = factory({
+      construct: common.mustCall((cb) => {
+        constructed = true;
+        process.nextTick(cb);
+      })
+    });
+    s.on('close', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.destroy();
+  }
+
+
+  {
+    let constructed = false;
+    const s = factory({
+      construct: common.mustCall((cb) => {
+        constructed = true;
+        process.nextTick(cb);
+      })
+    });
+    s.on('close', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.on('error', common.mustCall((err) => {
+      assert.strictEqual(err.message, 'kaboom');
+    }));
+    s.destroy(new Error('kaboom'), (err) => {
+      assert.strictEqual(err.message, 'kaboom');
+      assert.strictEqual(constructed, true);
+    });
+  }
+
+  {
+    let constructed = false;
+    const s = factory({
+      construct: common.mustCall((cb) => {
+        constructed = true;
+        process.nextTick(cb);
+      })
+    });
+    s.on('error', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.on('close', common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+    }));
+    s.destroy(new Error());
+  }
+}
+testDestroy((opts) => new Readable({
+  read: common.mustNotCall(),
+  ...opts
+}));
+testDestroy((opts) => new Writable({
+  write: common.mustNotCall(),
+  final: common.mustNotCall(),
+  ...opts
+}));
+
+{
+  let constructed = false;
+  const r = new Readable({
+    autoDestroy: true,
+    construct: common.mustCall((cb) => {
+      constructed = true;
+      process.nextTick(cb);
+    }),
+    read: common.mustCall(() => {
+      assert.strictEqual(constructed, true);
+      r.push(null);
+    })
+  });
+  r.on('close', common.mustCall(() => {
+    assert.strictEqual(constructed, true);
+  }));
+  r.on('data', common.mustNotCall());
+}
+
+{
+  let constructed = false;
+  const w = new Writable({
+    autoDestroy: true,
+    construct: common.mustCall((cb) => {
+      constructed = true;
+      process.nextTick(cb);
+    }),
+    write: common.mustCall((chunk, encoding, cb) => {
+      assert.strictEqual(constructed, true);
+      process.nextTick(cb);
+    }),
+    final: common.mustCall((cb) => {
+      assert.strictEqual(constructed, true);
+      process.nextTick(cb);
+    })
+  });
+  w.on('close', common.mustCall(() => {
+    assert.strictEqual(constructed, true);
+  }));
+  w.end('data');
+}
+
+{
+  let constructed = false;
+  const w = new Writable({
+    autoDestroy: true,
+    construct: common.mustCall((cb) => {
+      constructed = true;
+      process.nextTick(cb);
+    }),
+    write: common.mustNotCall(),
+    final: common.mustCall((cb) => {
+      assert.strictEqual(constructed, true);
+      process.nextTick(cb);
+    })
+  });
+  w.on('close', common.mustCall(() => {
+    assert.strictEqual(constructed, true);
+  }));
+  w.end();
+}
+
+{
+  new Duplex({
+    construct: common.mustCall()
+  });
+}
+
+{
+  // https://github.com/nodejs/node/issues/34448
+
+  let constructed = false;
+  const d = new Duplex({
+    readable: false,
+    construct: common.mustCall((callback) => {
+      setImmediate(common.mustCall(() => {
+        constructed = true;
+        callback();
+      }));
+    }),
+    write(chunk, encoding, callback) {
+      callback();
+    },
+    read() {
+      this.push(null);
+    }
+  });
+  d.resume();
+  d.end('foo');
+  d.on('close', common.mustCall(() => {
+    assert.strictEqual(constructed, true);
+  }));
+}
+
+{
+  // Construct should not cause stream to read.
+  new Readable({
+    construct: common.mustCall((callback) => {
+      callback();
+    }),
+    read: common.mustNotCall()
+  });
+}