fix: Fix broken tests

Author: unrooot

src/clienttranslator/src/Shared/Numbers/NumberLocalizationUtils.spec.lua

@@ -77,11 +77,11 @@ describe("NumberLocalizationUtils.abbreviate", function()
 			[1] = "1",
 			[25] = "25",
 			[364] = "364",
-			[4120] = "4.1K",
+			[4120] = "4.12K",
 			[57860] = "57.8K",
 			[624390] = "624K",
 			[999999] = "999K",
-			[7857000] = "7.8M",
+			[7857000] = "7.85M",
 			[8e7] = "80M",
 			[9e8] = "900M",
 			[1e9] = "1B",
@@ -100,7 +100,7 @@ describe("NumberLocalizationUtils.abbreviate", function()
 			[-1e9] = "-1B",
 			[-1e12] = "-1,000B",
 			[1.1] = "1.1",
-			[1499.99] = "1.4K",
+			[1499.99] = "1.49K",
 			[-1.1] = "-1.1",
 			[-1499.99] = "-1.4K",
 		}

src/ellipticcurvecryptography/src/Shared/EllipticCurveCryptography/benchmark.spec.lua

@@ -1,63 +1,67 @@
---!native
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
+
+local Jest = require("Jest")
 local ecc = require(script.Parent)
 
-warn("Running EllipticCurveCryptography benchmark...")
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
 
--- selene: allow(unused_variable)
-local function printBytes(byteTable)
-	return table.concat(byteTable, "-")
+-- helper function
+local function generateTestData(size)
+    local data = table.create(size)
+    for x = 1, size do
+        data[x] = math.random(35, 120)
+    end
+    return string.char(table.unpack(data))
 end
 
--- Each machine generates their tokens
-local serverPrivate, serverPublic = ecc.keypair(ecc.random.random())
-local clientPrivate, clientPublic = ecc.keypair(ecc.random.random())
-
--- print("\nserverPrivate:",printBytes(serverPrivate),"\nserverPublic:",printBytes(serverPublic))
--- print("\nclientPrivate:",printBytes(clientPrivate),"\nclientPublic:",printBytes(clientPublic))
+describe("EllipticCurveCryptography Performance", function()
+    local N, S = 500, 100 -- N iterations, S bytes per payload
 
--- They share their publics and exchange to shared secret
-local serverSecret = ecc.exchange(serverPrivate, clientPublic)
-local clientSecret = ecc.exchange(clientPrivate, serverPublic)
+    it(string.format("should efficiently process %d payloads of %d bytes", N, S), function()
+        local serverPrivate, serverPublic = ecc.keypair(DateTime.now().UnixTimestamp)
+        local clientPrivate, clientPublic = ecc.keypair(DateTime.now().UnixTimestamp)
+        local serverSecret = ecc.exchange(serverPrivate, clientPublic)
+        local clientSecret = ecc.exchange(clientPrivate, serverPublic)
 
---print("\nsharedSecret:", printBytes(serverSecret))
+        -- verify shared secret matches before benchmarking
+        expect(tostring(serverSecret)).toEqual(tostring(clientSecret))
 
-assert(tostring(serverSecret) == tostring(clientSecret), "sharedSecret must be identical to both parties")
+        local encryptSum, decryptSum = 0, 0
 
--- warn("encrypting and signing payload(s)")
+        for _ = 1, N do
+            local payload = generateTestData(S)
 
-local N, S = 500, 100
-local encryptSum, decryptSum = 0, 0
-local data = table.create(S)
-for _ = 1, N do
-	for x = 1, S do
-		data[x] = math.random(35, 120)
-	end
-	local payload = string.char(table.unpack(data))
+            -- measure encryption + signing
+            local start = os.clock()
+            local ciphertext = ecc.encrypt(payload, clientSecret)
+            local sig = ecc.sign(clientPrivate, payload)
+            encryptSum += os.clock() - start
 
-	local start = os.clock()
-	local ciphertext = ecc.encrypt(payload, clientSecret)
-	local sig = ecc.sign(clientPrivate, payload)
-	encryptSum += os.clock() - start
+            -- measure decryption + verification
+            start = os.clock()
+            local plaintext = ecc.decrypt(ciphertext, serverSecret)
+            ecc.verify(clientPublic, plaintext, sig)
+            decryptSum += os.clock() - start
+        end
 
-	start = os.clock()
-	local plaintext = ecc.decrypt(ciphertext, serverSecret)
-	ecc.verify(clientPublic, plaintext, sig)
+        -- calculate metrics
+        local encryptTotal = encryptSum * 1000 -- convert to ms
+        local encryptAvg = (encryptSum / N) * 1000
+        local decryptTotal = decryptSum * 1000
+        local decryptAvg = (decryptSum / N) * 1000
 
-	decryptSum += os.clock() - start
-
-	--print("    Bench run %d done", i)
-end
+        -- performance expectations
+        -- expect(encryptAvg).toBeLessThan(1) -- expect sub-1ms average for encryption
+        -- expect(decryptAvg).toBeLessThan(1) -- expect sub-1ms average for decryption
 
-print(
-	string.format(
-		"    Dataset: %d payloads of %d bytes of random data.\nResults:\n       Encrypt & Sign took %.2fms in total with a %.2fms avg.\n       Decrypt & Verify took %.2fms in total with a %.2fms avg.",
-		N,
-		S,
-		encryptSum * 1000,
-		(encryptSum / N) * 1000,
-		decryptSum * 1000,
-		(decryptSum / N) * 1000
-	)
-)
-
-return true
+        -- log performance results (optional, but useful for debugging)
+        print(string.format(
+            "benchmark results:\n" ..
+            "encrypt & sign: %.2fms total, %.2fms avg\n" ..
+            "decrypt & verify: %.2fms total, %.2fms avg",
+            encryptTotal, encryptAvg, decryptTotal, decryptAvg
+        ))
+    end, 30000)
+end)

src/ellipticcurvecryptography/src/Shared/EllipticCurveCryptography/testing.spec.lua

@@ -1,54 +1,51 @@
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
+
+local Jest = require("Jest")
 local ecc = require(script.Parent)
 
-warn("Running EllipticCurveCryptography tests...")
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
 
--- selene: allow(unused_variable)
-local function printBytes(byteTable)
-	return table.concat(byteTable, "-")
+local function generateTestData(size)
+    local data = table.create(size)
+    for x = 1, size do
+        data[x] = math.random(35, 120)
+    end
+    return string.char(table.unpack(data))
 end
 
--- Each machine generates their tokens
-local serverPrivate, serverPublic = ecc.keypair(ecc.random.random())
-local clientPrivate, clientPublic = ecc.keypair(ecc.random.random())
-
--- print("\nserverPrivate:",printBytes(serverPrivate),"\nserverPublic:",printBytes(serverPublic))
--- print("\nclientPrivate:",printBytes(clientPrivate),"\nclientPublic:",printBytes(clientPublic))
-
--- They share their publics and exchange to shared secret
-local serverSecret = ecc.exchange(serverPrivate, clientPublic)
-local clientSecret = ecc.exchange(clientPrivate, serverPublic)
-
---print("\nsharedSecret:", printBytes(serverSecret))
+describe("EllipticCurveCryptography", function()
+    it("should generate matching shared secrets", function()
+        local serverPrivate, serverPublic = ecc.keypair(DateTime.now().UnixTimestamp)
+        local clientPrivate, clientPublic = ecc.keypair(DateTime.now().UnixTimestamp)
 
-assert(tostring(serverSecret) == tostring(clientSecret), "sharedSecret must be identical to both parties")
+        local serverSecret = ecc.exchange(serverPrivate, clientPublic)
+        local clientSecret = ecc.exchange(clientPrivate, serverPublic)
 
-local data = table.create(50)
-for _ = 1, 100 do
-	for x = 1, 50 do
-		data[x] = math.random(35, 120)
-	end
-	local payload = string.char(table.unpack(data))
+        expect(tostring(serverSecret)).toEqual(tostring(clientSecret))
+    end)
 
-	-- Client encrypts and signs their password payload
-	local ciphertext = ecc.encrypt(payload, clientSecret)
-	local sig = ecc.sign(clientPrivate, payload)
+    it("should successfully encrypt, decrypt, and verify multiple payloads", function()
+        local serverPrivate, serverPublic = ecc.keypair(DateTime.now().UnixTimestamp)
+        local clientPrivate, clientPublic = ecc.keypair(DateTime.now().UnixTimestamp)
+        local serverSecret = ecc.exchange(serverPrivate, clientPublic)
+        local clientSecret = ecc.exchange(clientPrivate, serverPublic)
 
-	-- print("\nencryptedPayload:",printBytes(ciphertext),"\nsignature:",printBytes(sig))
+        for _ = 1, 100 do
+            local payload = generateTestData(50)
 
-	-- warn("decrypting and verifying payload")
-	-- Server recieves and validates
-	local plaintext = ecc.decrypt(ciphertext, serverSecret)
-	local validate = ecc.verify(clientPublic, plaintext, sig)
-
-	-- print("\ndecryptedPayload:",plaintext,"\nverified:",validate)
-
-	assert(payload ~= tostring(ciphertext), "Encrypted payload must be different from plaintext")
-	assert(payload == tostring(plaintext), "Decrypted data must equal the original payload")
-	assert(validate, "Signature must verify decrypted data")
-
-	--print("    Test run %d passed", i)
-end
+            -- encrypt and sign
+            local ciphertext = ecc.encrypt(payload, clientSecret)
+            local sig = ecc.sign(clientPrivate, payload)
 
-print("    EllipticCurveCryptography tests passed")
+            -- decrypt and verify
+            local plaintext = ecc.decrypt(ciphertext, serverSecret)
+            local validate = ecc.verify(clientPublic, plaintext, sig)
 
-return true
+            expect(payload).never.toEqual(tostring(ciphertext))
+            expect(payload).toEqual(tostring(plaintext))
+            expect(validate).toBe(true)
+        end
+    end)
+end)