test: move sqlite length validation out of the reentry test

The "non-integer callback length" suite in
test-sqlite-options-getter-reentry.js checks that function() and
aggregate() reject a callback whose length property is not an integer.
That is plain argument validation: no property getter runs, and nothing
changes mid-call, so the tests do not belong in a file about option
getters re-entering the database.

Move them into the "input validation" suites that already cover the
other argument type checks for each method. Drop "a normal function
length is still accepted", which duplicates "uses function.length when
false" in test-sqlite-custom-functions.js.

The two tests that put the getter on length itself stay where they are,
since closing the database from that getter is what they exercise.

Refs: #65595
Signed-off-by: Trevor Burnham <trevorburnham@gmail.com>
PR-URL: #65769
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: TrevorBurnham

test/parallel/test-sqlite-aggregate-function.mjs

@@ -7,6 +7,19 @@ describe('DatabaseSync.prototype.aggregate()', () => {
   describe('input validation', () => {
     const db = new DatabaseSync(':memory:');
 
+    // The length property is configurable, so any type can reach the
+    // conversion that derives the aggregate's arity from it.
+    const lengths = ['abc', {}, [], null, undefined, NaN, 1.5,
+                     Symbol.iterator, 10n, true, 2 ** 40];
+
+    function withLength(fn, length) {
+      Object.defineProperty(fn, 'length', {
+        configurable: true,
+        value: length,
+      });
+      return fn;
+    }
+
     test('throws if options.start is not provided', (t) => {
       t.assert.throws(() => {
         db.aggregate('sum', {
@@ -81,6 +94,37 @@ describe('DatabaseSync.prototype.aggregate()', () => {
         message: /The "options\.inverse" argument must be a function/,
       });
     });
+
+    test('throws if options.step.length is not an integer', (t) => {
+      for (const length of lengths) {
+        t.assert.throws(() => {
+          db.aggregate('sum', {
+            start: 0,
+            step: withLength((acc, value) => acc + value, length),
+            result: (total) => total
+          });
+        }, {
+          code: 'ERR_INVALID_ARG_TYPE',
+          message: /The "options\.step\.length" property must be an integer/,
+        }, `length=${String(length)}`);
+      }
+    });
+
+    test('throws if options.inverse.length is not an integer', (t) => {
+      for (const length of lengths) {
+        t.assert.throws(() => {
+          db.aggregate('sum', {
+            start: 0,
+            step: (acc, value) => acc + value,
+            inverse: withLength((acc, value) => acc - value, length),
+            result: (total) => total
+          });
+        }, {
+          code: 'ERR_INVALID_ARG_TYPE',
+          message: /The "options\.inverse\.length" property must be an integer/,
+        }, `length=${String(length)}`);
+      }
+    });
   });
 });
 

test/parallel/test-sqlite-custom-functions.js

@@ -71,6 +71,28 @@ suite('DatabaseSync.prototype.function()', () => {
         message: /The "options\.directOnly" argument must be a boolean/,
       });
     });
+
+    test('throws if function.length is not an integer', () => {
+      // The length property is configurable, so any type can reach the
+      // conversion that derives the function's arity from it.
+      const lengths = ['abc', {}, [], null, undefined, NaN, 1.5,
+                       Symbol.iterator, 10n, true, 2 ** 40];
+
+      for (const length of lengths) {
+        const fn = () => 1;
+        Object.defineProperty(fn, 'length', {
+          configurable: true,
+          value: length,
+        });
+
+        assert.throws(() => {
+          db.function('foo', fn);
+        }, {
+          code: 'ERR_INVALID_ARG_TYPE',
+          message: /The "function\.length" property must be an integer/,
+        }, `length=${String(length)}`);
+      }
+    });
   });
 
   suite('useBigIntArguments', () => {

test/parallel/test-sqlite-options-getter-reentry.js

@@ -242,62 +242,3 @@ suite('resizing a deserialize() buffer from an options getter', () => {
     });
   });
 });
-
-// fn.length is configurable, so it must be validated rather than cast blindly.
-suite('non-integer callback length', () => {
-  const badLengths = ['abc', {}, [], null, undefined, NaN, 1.5, Symbol.iterator,
-                      10n, true, 2 ** 40];
-
-  test('function() rejects a non-integer length', (t) => {
-    const db = new DatabaseSync(':memory:');
-    for (const value of badLengths) {
-      const fn = () => 1;
-      Object.defineProperty(fn, 'length', { configurable: true, value });
-      t.assert.throws(() => {
-        db.function('fn', fn);
-      }, {
-        code: 'ERR_INVALID_ARG_TYPE',
-        message: /The "function\.length" property must be an integer/,
-      }, `length=${String(value)}`);
-    }
-  });
-
-  test('aggregate() rejects a non-integer step length', (t) => {
-    const db = new DatabaseSync(':memory:');
-    for (const value of badLengths) {
-      const step = (acc, next) => acc;
-      Object.defineProperty(step, 'length', { configurable: true, value });
-      t.assert.throws(() => {
-        db.aggregate('agg', { start: 0, step, result: (acc) => acc });
-      }, {
-        code: 'ERR_INVALID_ARG_TYPE',
-        message: /The "options\.step\.length" property must be an integer/,
-      }, `length=${String(value)}`);
-    }
-  });
-
-  test('aggregate() rejects a non-integer inverse length', (t) => {
-    const db = new DatabaseSync(':memory:');
-    for (const value of badLengths) {
-      const inverse = (acc, next) => acc;
-      Object.defineProperty(inverse, 'length', { configurable: true, value });
-      t.assert.throws(() => {
-        db.aggregate('agg', {
-          start: 0,
-          step: (acc, next) => acc,
-          inverse,
-          result: (acc) => acc,
-        });
-      }, {
-        code: 'ERR_INVALID_ARG_TYPE',
-        message: /The "options\.inverse\.length" property must be an integer/,
-      }, `length=${String(value)}`);
-    }
-  });
-
-  test('a normal function length is still accepted', (t) => {
-    const db = new DatabaseSync(':memory:');
-    db.function('plus', (a, b) => a + b);
-    t.assert.strictEqual(db.prepare('SELECT plus(1, 2) AS v').get().v, 3);
-  });
-});