chore(randomInt): update method and related tests.

Author: ElijahKotyluk

packages/cli/build.gradle.kts

@@ -1213,7 +1213,6 @@ val initializeAtRuntime: List<String> = listOfNotNull(
   "io.netty.incubator.codec.quic.BoringSSL",
   "io.netty.incubator.codec.quic.BoringSSLPrivateKeyMethod",
   $$"io.netty.util.NetUtilSubstitutions$NetUtilLocalhost6LazyHolder",
-
   // --- Netty: Native Crypto -----
 
   "io.netty.internal.tcnative.Buffer",

packages/graalvm/src/main/kotlin/elide/runtime/intrinsics/js/node/CryptoAPI.kt

@@ -57,7 +57,7 @@ import elide.vm.annotations.Polyglot
    * @param callback
    * @return A randomly generated integer between `min` (inclusive) and `max` (exclusive) or nothing if a callback was provided.
    */
-  @Polyglot public fun randomInt(min: Value?, max: Value, callback: Value?): Any
+  @Polyglot public fun randomInt(min: Value, max: Value, callback: Value?): Any
 
   /**
    * ## Crypto: randomInt

packages/graalvm/src/main/kotlin/elide/runtime/node/crypto/NodeCrypto.kt

@@ -79,30 +79,26 @@ internal class NodeCrypto private constructor () : ReadOnlyProxyObject, CryptoAP
    var error: AbstractJsException? = null
 
    if (min >= max) {
-     error = RangeError.create("The value of \"max\" is out of range. It must be greater than the value of \"min\" ($min). Received $max")
+     throw RangeError.create("The value of \"max\" is out of range. It must be greater than the value of \"min\" ($min). Received $max")
    }
 
    val randomInt = cryptoRandomGenerator.nextInt(min,   max)
 
-   if (callback != null) {
-     callback.invoke(error, randomInt)
-
-     return Unit
-   }
+   callback?.invoke(error, randomInt)
 
    return randomInt
  }
 
-  @Polyglot override fun randomInt(min: Value?, max: Value, callback: Value?): Int {
+  @Polyglot override fun randomInt(min: Value, max: Value, callback: Value?): Any {
     return randomInt(min, max, callback)
   }
 
-  @Polyglot override fun randomInt(max: Value, callback: Value?): Int {
-    return randomInt(max, callback)
+  @Polyglot override fun randomInt(max: Value, callback: Value?): Any {
+    return randomInt(0, max.asInt(), callback as? RandomIntCallback)
   }
 
-  @Polyglot override fun randomInt(max: Value): Int {
-    return randomInt(max)
+  @Polyglot override fun randomInt(max: Value): Any {
+    return randomInt(0, max = max.asInt())
   }
 
   // ProxyObject implementation
@@ -117,17 +113,17 @@ internal class NodeCrypto private constructor () : ReadOnlyProxyObject, CryptoAP
       val options = args.getOrNull(0)
       randomUUID(options)
     }
-    F_RANDOM_INT -> ProxyExecutable {
+    F_RANDOM_INT -> ProxyExecutable { args ->
       // Node.js signature: randomInt(max) OR randomInt(max, [callback]) OR randomInt(min, max) OR randomInt(min, max, [callback])
-      when (it.size) {
-        1 -> randomInt(it.first())
-        2 -> if (it[1].fitsInInt()) {
-          randomInt(min = it.first().asInt(), max = it[1].asInt())
+      when (args.size) {
+        1 -> randomInt(0, args.first().asInt())
+        2 -> if (args[1].fitsInInt()) {
+          randomInt(min = args.first().asInt(), max = args[1].asInt())
         } else {
-          randomInt(max = it.first(), callback = it[1])
+          randomInt(max = args.first(), callback = args[1])
         }
-        3 -> randomInt(it.first(), it[1], it.getOrNull(2))
-        else -> throw JsError.typeError("Invalid number of arguments for `crypto.randomInt`")
+        3 -> randomInt(args.first().asInt(), args[1].asInt(), args.getOrNull(2) as? RandomIntCallback)
+        else -> throw JsError.typeError("Invalid number of arguments for `crypto.randomInt`, ${args.size} arguments were provided.")
       }
     }
     else -> null

packages/graalvm/src/test/kotlin/elide/runtime/node/NodeCryptoTest.kt

@@ -12,6 +12,8 @@
  */
 package elide.runtime.node
 
+import org.graalvm.polyglot.Value
+import org.junit.jupiter.api.assertThrows
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertIs
@@ -20,7 +22,9 @@ import kotlin.test.assertTrue
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import elide.annotations.Inject
+import elide.runtime.intrinsics.js.err.AbstractJsException
 import elide.runtime.intrinsics.js.err.RangeError
+import elide.runtime.intrinsics.js.err.ValueError
 import elide.runtime.node.crypto.NodeCryptoModule
 import elide.testing.annotations.TestCase
 
@@ -211,76 +215,49 @@ import elide.testing.annotations.TestCase
     const crypto = require("crypto")
     const assert = require("assert")
 
-    const int = crypto.randomInt();
-    assert.equal(typeof int, "Number");
+    const int = crypto.randomInt(5, 10);
+    assert.equal(typeof int, "number");
     """
   }
 
-  @Test fun `randomInt should invoke callback with error when min is greater than or equal to max`() = conforms {
-    var callbackInvoked = false
-    crypto.provide().randomInt(10, 5) { err, value ->
-      callbackInvoked = true
-      assertNotNull(err, "Error should be provided when min >= max")
-      assertIs<RangeError>(err, "Error should be of type RangeError")
-    }
-    assertTrue(callbackInvoked, "Callback should have been invoked")
+  @Test fun `randomInt should throw a RangeError when min is greater than or equal to max`() = conforms {
+    assertThrows<RangeError> { crypto.provide().randomInt(10, 5) }
+    assertThrows<RangeError> { crypto.provide().randomInt(10, 10) }
   }.guest {
     //language=javascript
     """
     const crypto = require("crypto")
     const assert = require("assert")
 
-    let callbackInvoked = false;
-    crypto.randomInt(10, 5, (err, value) => {
-      callbackInvoked = true;
-      assert.ok(err, "Error should be provided when min >= max");
-      assert.equal(err.name, "RangeError", "Error should be of type RangeError");
+    assert.throws(() => {
+      crypto.randomInt(10, 10);
+    }, (err) => {
+      assert.ok(err instanceof RangeError);
+      return true;
     });
-
-    assert.ok(callbackInvoked, "Callback should have been invoked");
-    """
-  }
-
-  @Test fun `randomInt should return Unit when a callback is provided`() = conforms {
-    var callbackInvoked = false
-    val result = crypto.provide().randomInt(5, 10) { err, value ->
-      callbackInvoked = true
-      assertNull(err, "Error should be null for valid range")
-      assertTrue(value in 5 until 10, "Value should be within the specified range")
-    }
-    assertTrue(callbackInvoked, "Callback should have been invoked")
-    assertEquals(Unit, result, "randomInt should return Unit when a callback is provided")
-  }.guest {
-    //language=javascript
-    """
-    const crypto = require("crypto")
-    const assert = require("assert")
-
-    let callbackInvoked = false;
-    const result = crypto.randomInt(5, 10, (err, value) => {
-      callbackInvoked = true;
-      assert.ifError(err);
-      assert.ok(value >= 5 && value < 10, "Value should be within the specified range");
+    
+    assert.throws(() => {
+      crypto.randomInt(10, 5);
+    }, (err) => {
+      assert.ok(err instanceof RangeError);
+      return true;
     });
-
-    assert.ok(callbackInvoked, "Callback should have been invoked");
-    assert.equal(result, undefined, "randomInt should return undefined when a callback is provided");
     """
   }
 
   @Test fun `randomInt should default min to 0 when only max is provided`() = conforms {
-    val randomInt = crypto.provide().randomInt(max = 5)
+    val randomInt = crypto.provide().randomInt(max = 1)
     assertIs<Int>(randomInt, "randomInt should return an Int")
-    assertTrue(randomInt in 0 until 5, "randomInt should be within the range 0 to max")
+    assertEquals(0, randomInt, "randomInt should be 0 when max is 1")
   }.guest {
     //language=javascript
     """
     const crypto = require("crypto")
     const assert = require("assert")
 
-    const int = crypto.randomInt(5);
-    assert.equal(typeof int, "Number");
-    assert.ok(int >= 0 && int < 5, "randomInt should be within the range 0 to max");
+    const int = crypto.randomInt(1);
+    assert.equal(typeof int, "number");
+    assert.ok(int >= 0 && int < 1, "randomInt should be within the range 0 to max");
     """
   }
 }