test: add more node.js tests

Author: anonrig

test/node.ts

@@ -1,5 +1,8 @@
 import vm from "node:vm";
 
+function extendedFunction() {}
+extendedFunction.prototype = { a: "b" };
+
 function createWithNoPrototype(properties) {
   const noProto = Object.create(null);
   properties.forEach((property) => {
@@ -112,3 +115,20 @@ export const qsTestCases = [
   [null, "", {}],
   [undefined, "", {}],
 ];
+export const qsWeirdObjects = [
+  [{ regexp: /./g }, "regexp=", { regexp: "" }],
+  [{ regexp: new RegExp(".", "g") }, "regexp=", { regexp: "" }],
+  [{ fn: () => {} }, "fn=", { fn: "" }],
+  [{ fn: new Function("") }, "fn=", { fn: "" }],
+  [{ math: Math }, "math=", { math: "" }],
+  [{ e: extendedFunction }, "e=", { e: "" }],
+  [{ d: new Date() }, "d=", { d: "" }],
+  [{ d: Date }, "d=", { d: "" }],
+  [{ f: new Boolean(false), t: new Boolean(true) }, "f=&t=", { f: "", t: "" }],
+  [{ f: false, t: true }, "f=false&t=true", { f: "false", t: "true" }],
+  [{ n: null }, "n=", { n: "" }],
+  [{ nan: NaN }, "nan=", { nan: "" }],
+  [{ inf: Infinity }, "inf=", { inf: "" }],
+  [{ a: [], b: [] }, "", {}],
+  [{ a: 1, b: [] }, "a=1", { a: "1" }],
+];

test/parse.test.ts

@@ -1,9 +1,13 @@
 import qs from "../lib";
 import { test, assert } from "vitest";
-import { qsNoMungeTestCases, qsTestCases } from "./node";
+import { qsNoMungeTestCases, qsTestCases, qsWeirdObjects } from "./node";
 import querystring from "querystring";
 
 test("should succeed on node.js tests", () => {
+  qsWeirdObjects.forEach(
+    (t) =>
+      assert.deepEqual(qs.parse(t[1] as string), t[2] as Record<string, any>),
+  );
   qsNoMungeTestCases.forEach((t) => assert.deepEqual(qs.parse(t[0]), t[1]));
   qsTestCases.forEach((t) => assert.deepEqual(qs.parse(t[0]), t[2]));
 });
@@ -39,3 +43,13 @@ test("should accept pairs with missing values", () => {
 test("should decode key", () => {
   assert.deepEqual(qs.parse("full%20name=Yagiz"), { "full name": "Yagiz" });
 });
+
+test("should handle really large object", () => {
+  const query = {};
+
+  for (let i = 0; i < 2000; i++) query[i] = i;
+
+  const url = qs.stringify(query);
+
+  assert.strictEqual(Object.keys(qs.parse(url)).length, 2000);
+});

test/stringify.test.ts

@@ -1,9 +1,16 @@
-import { qsNoMungeTestCases, qsTestCases } from "./node";
+import { qsNoMungeTestCases, qsTestCases, qsWeirdObjects } from "./node";
 import qs from "../lib";
 import { test, assert } from "vitest";
 import querystring from "querystring";
 
 test("should succeed on node.js tests", () => {
+  qsWeirdObjects.forEach(
+    (t) =>
+      assert.deepEqual(
+        qs.stringify(t[2] as Record<string, any>),
+        t[1] as string,
+      ),
+  );
   qsNoMungeTestCases.forEach((t) => assert.deepEqual(qs.stringify(t[1]), t[0]));
   qsTestCases.forEach((t) => assert.deepEqual(qs.stringify(t[2]), t[1]));
 });
@@ -29,6 +36,8 @@ test("should handle BigInt", () => {
     qs.stringify({ age: BigInt(55), name: "John" }),
     "age=55&name=John",
   );
+  assert.strictEqual(qs.stringify({ foo: 2n ** 1023n }), "foo=" + 2n ** 1023n);
+  assert.strictEqual(qs.stringify([0n, 1n, 2n]), "0=0&1=1&2=2");
 });
 
 test("should handle boolean values", () => {
@@ -52,3 +61,36 @@ test("should omit non-object inputs", () => {
 test("should handle multi-byte characters", () => {
   assert.deepEqual(qs.stringify({ multiByte: "𝌆" }), "multiByte=%F0%9D%8C%86");
 });
+
+test("invalid surrogate pair should throw", () => {
+  assert.throws(() => qs.stringify({ foo: "\udc00" }), "URI malformed");
+});
+
+test("should omit nested values", () => {
+  const f = qs.stringify({
+    a: "b",
+    q: qs.stringify({
+      x: "y",
+      y: "z",
+    }),
+  });
+  assert.strictEqual(f, "a=b&q=x%3Dy%26y%3Dz");
+});
+
+test("should coerce numbers to string", () => {
+  assert.strictEqual(qs.stringify({ foo: 0 }), "foo=0");
+  assert.strictEqual(qs.stringify({ foo: -0 }), "foo=0");
+  assert.strictEqual(qs.stringify({ foo: 3 }), "foo=3");
+  assert.strictEqual(qs.stringify({ foo: -72.42 }), "foo=-72.42");
+  assert.strictEqual(qs.stringify({ foo: NaN }), "foo=");
+  assert.strictEqual(qs.stringify({ foo: 1e21 }), "foo=1e%2B21");
+  assert.strictEqual(qs.stringify({ foo: Infinity }), "foo=");
+});
+
+test("should return empty string on certain inputs", () => {
+  assert.strictEqual(qs.stringify(), "");
+  assert.strictEqual(qs.stringify(0), "");
+  assert.strictEqual(qs.stringify([]), "");
+  assert.strictEqual(qs.stringify(null), "");
+  assert.strictEqual(qs.stringify(true), "");
+});