@nivinjoseph/n-sec 5.0.5 → 6.0.2

package/test/digital-signature.test.ts

@@ -4,11 +4,11 @@
 // import "@nivinjoseph/n-ext";
 
 
-// suite("digitalSignature", () =>
+// await describe("digitalSignature", () =>
 // {
-//     suite("sign", () =>
+//     await describe("sign", () =>
 //     {   
-//         test("should return string value thats is not null, empty, whitespace, same as value or key pair when invoked with key pair and value", async () =>
+//         await test("should return string value thats is not null, empty, whitespace, same as value or key pair when invoked with key pair and value", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let value = "some value";
@@ -19,7 +19,7 @@
 //         });
         
         
-//         // test("should throw CryptoException when KeyPair is null", async () =>
+//         // await test("should throw CryptoException when KeyPair is null", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -34,7 +34,7 @@
 //         //     assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when KeyPair is undefined", async () =>
+//         // await test("should throw CryptoException when KeyPair is undefined", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -49,7 +49,7 @@
 //         //     assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value is null", async () =>
+//         // await test("should throw CryptoException when value is null", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     try
@@ -65,7 +65,7 @@
 //         //     assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value is undefined", async () =>
+//         // await test("should throw CryptoException when value is undefined", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     try
@@ -81,7 +81,7 @@
 //         //     assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value is empty string", async () =>
+//         // await test("should throw CryptoException when value is empty string", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     try
@@ -97,7 +97,7 @@
 //         //     assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when keyPair is empty string", async () =>
+//         // await test("should throw CryptoException when keyPair is empty string", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -113,9 +113,9 @@
 //         // });
 //     });
     
-//     suite("verify", () =>
+//     await describe("verify", () =>
 //     {
-//         test("should return true when called with public key of key pair, value and signature of value generated using key pair", async () =>
+//         await test("should return true when called with public key of key pair, value and signature of value generated using key pair", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -125,7 +125,7 @@
 //             Assert.strictEqual(verification, true);
 //         });
         
-//         test("should return false when called with unrelated public key, value and signature", async () =>
+//         await test("should return false when called with unrelated public key, value and signature", async () =>
 //         {
 //             let keyPair1 = await AsymmetricEncryption.generateKeyPair();
 //             let keyPair2 = await AsymmetricEncryption.generateKeyPair();
@@ -136,7 +136,7 @@
 //             Assert.strictEqual(verification, false);
 //         });
         
-//         test("should return false when called with tampered value", async () =>
+//         await test("should return false when called with tampered value", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -147,7 +147,7 @@
 //             Assert.strictEqual(verification, false);
 //         });
         
-//         test("should return false when called with a tampered signature", async () =>
+//         await test("should return false when called with a tampered signature", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -160,7 +160,7 @@
         
         
         
-//         // test("successfully verify the signed", async () =>
+//         // await test("successfully verify the signed", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -169,7 +169,7 @@
 //         //     Assert.ok(verify);
 //         // });
         
-//         // test("un-verify modified signature", async () =>
+//         // await test("un-verify modified signature", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -179,7 +179,7 @@
 //         //     Assert.ok(!verify);
 //         // });
         
-//         // test("un-verify when wrong public key is given", async () =>
+//         // await test("un-verify when wrong public key is given", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let signature = await DigitalSignature.sign(keyPair, "some-string");
@@ -189,7 +189,7 @@
 //         //     Assert.ok(!verify);
 //         // });
         
-//         // test("should throw CryptoException when public key is null", async () =>
+//         // await test("should throw CryptoException when public key is null", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let signature = await DigitalSignature.sign(keyPair, "some-string");
@@ -206,7 +206,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value is null", async () =>
+//         // await test("should throw CryptoException when value is null", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let signature = await DigitalSignature.sign(keyPair, "some-string");
@@ -224,7 +224,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value is empty string", async () =>
+//         // await test("should throw CryptoException when value is empty string", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let signature = await DigitalSignature.sign(keyPair, "some-string");
@@ -242,7 +242,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when signature is null", async () =>
+//         // await test("should throw CryptoException when signature is null", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -259,7 +259,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value, key pair and signature are all null", async () =>
+//         // await test("should throw CryptoException when value, key pair and signature are all null", async () =>
 //         // {
 //         //     try
 //         //     {

package/test/hash.test.ts

@@ -1,49 +1,50 @@
-import * as Assert from "assert";
-import { Hash } from "./../src/index";
+import { describe, test } from "node:test";
+import assert from "node:assert";
+import { Hash } from "./../src/index.js";
 import "@nivinjoseph/n-ext";
 // import { CryptoException } from "./../src/crypto-exception";
 
-suite("Hash", () =>
+await describe("Hash", async () =>
 {
-    suite("create", () =>
+    await describe("create", async () =>
     {
-        test("must return a string value that is not null, empty, whitespace or same as input when called with a valid input", () =>
+        await test("must return a string value that is not null, empty, whitespace or same as input when called with a valid input", () =>
         {
             const input = "hello world";
             const hash = Hash.create(input);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
-            Assert.notStrictEqual(hash, input);
+            assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
+            assert.notStrictEqual(hash, input);
         });
-        
-        test("multiple invocations with the same input must return the same output", () =>
+
+        await test("multiple invocations with the same input must return the same output", () =>
         {
             const input = "hello world";
             const hash1 = Hash.create(input);
             const hash2 = Hash.create(input);
-            Assert.strictEqual(hash1, hash2);
+            assert.strictEqual(hash1, hash2);
         });
-        
-        test("multiple invocations with the different inputs must return different outputs", () =>
+
+        await test("multiple invocations with the different inputs must return different outputs", () =>
         {
             const input1 = "hello world";
             const hash1 = Hash.create(input1);
             const input2 = "goodbye world";
             const hash2 = Hash.create(input2);
-            Assert.notStrictEqual(hash1, hash2);
+            assert.notStrictEqual(hash1, hash2);
         });
-        
-        
-        // test("successfully create a hash twice with different values", async () =>
+
+
+        // await test("successfully create a hash twice with different values", async () =>
         // {
         //     let hash1 = await Hash.create("hello world");
         //     let hash2 = await Hash.create("hello world2");
-        //     Assert.ok(hash1 !== null && !hash1.isEmptyOrWhiteSpace());
-        //     Assert.ok(hash2 !== null && !hash2.isEmptyOrWhiteSpace());
-        //     Assert.notStrictEqual(hash1, hash2);
+        //     assert.ok(hash1 !== null && !hash1.isEmptyOrWhiteSpace());
+        //     assert.ok(hash2 !== null && !hash2.isEmptyOrWhiteSpace());
+        //     assert.notStrictEqual(hash1, hash2);
         // });
-        
-        // test("should throw CryptoException when value is null", async () =>
+
+        // await test("should throw CryptoException when value is null", async () =>
         // {
         //     try
         //     {
@@ -51,14 +52,14 @@ suite("Hash", () =>
         //     }
         //     catch (exception)
         //     {
-        //         Assert.ok(exception instanceof CryptoException);
-        //         Assert.strictEqual(exception.message, "Parameter count mismatch.");
+        //         assert.ok(exception instanceof CryptoException);
+        //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
-        
-        // test("should throw CryptoException when value is undefined", async () =>
+
+        // await test("should throw CryptoException when value is undefined", async () =>
         // {
         //     try
         //     {
@@ -66,14 +67,14 @@ suite("Hash", () =>
         //     }
         //     catch (exception)
         //     {
-        //         Assert.ok(exception instanceof CryptoException);
-        //         Assert.strictEqual(exception.message, "Parameter count mismatch.");
+        //         assert.ok(exception instanceof CryptoException);
+        //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
-        
-        // test("should throw CryptoException when value is empty string", async () =>
+
+        // await test("should throw CryptoException when value is empty string", async () =>
         // {
         //     try
         //     {
@@ -81,51 +82,51 @@ suite("Hash", () =>
         //     }
         //     catch (exception)
         //     {
-        //         Assert.ok(exception instanceof CryptoException);
-        //         Assert.strictEqual(exception.message, "Parameter count mismatch.");
+        //         assert.ok(exception instanceof CryptoException);
+        //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
-        
+
     });
-    
-    suite("createUsingSalt", () =>
+
+    await describe("createUsingSalt", async () =>
     {
-        test("must return a string value that is not null, empty, whitespace or same as input or salt when called with a valid input and salt", () =>
+        await test("must return a string value that is not null, empty, whitespace or same as input or salt when called with a valid input and salt", () =>
         {
             const input = "hello world";
             const salt = "salt";
             const hash = Hash.createUsingSalt(input, salt);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
-            Assert.notStrictEqual(hash, input);
-            Assert.notStrictEqual(hash, salt);
+            assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
+            assert.notStrictEqual(hash, input);
+            assert.notStrictEqual(hash, salt);
         });
 
-        test("multiple invocations with the same input and salt must return the same output", () =>
+        await test("multiple invocations with the same input and salt must return the same output", () =>
         {
             const input = "hello world";
             const salt = "salt";
             const hash1 = Hash.createUsingSalt(input, salt);
             const hash2 = Hash.createUsingSalt(input, salt);
-            Assert.strictEqual(hash1, hash2);
+            assert.strictEqual(hash1, hash2);
         });
 
-        test("multiple invocations with different inputs and different salts must return different outputs", () =>
+        await test("multiple invocations with different inputs and different salts must return different outputs", () =>
         {
             const input1 = "hello world";
             const salt1 = "salt-1";
             const hash1 = Hash.createUsingSalt(input1, salt1);
-            
+
             const input2 = "goodbye world";
             const salt2 = "salt-2";
             const hash2 = Hash.createUsingSalt(input2, salt2);
-            
-            Assert.notStrictEqual(hash1, hash2);
+
+            assert.notStrictEqual(hash1, hash2);
         });
-        
-        test("multiple invocations with different inputs and the same salt must return different outputs", () =>
+
+        await test("multiple invocations with different inputs and the same salt must return different outputs", () =>
         {
             const input1 = "hello world";
             const salt1 = "salt-1";
@@ -134,10 +135,10 @@ suite("Hash", () =>
             const input2 = "goodbye world";
             const hash2 = Hash.createUsingSalt(input2, salt1);
 
-            Assert.notStrictEqual(hash1, hash2);
+            assert.notStrictEqual(hash1, hash2);
         });
-        
-        test("multiple invocations with the same input and different salts must return different outputs", () =>
+
+        await test("multiple invocations with the same input and different salts must return different outputs", () =>
         {
             const input = "hello world";
             const salt1 = "salt-1";
@@ -146,63 +147,62 @@ suite("Hash", () =>
             const salt2 = "salt-2";
             const hash2 = Hash.createUsingSalt(input, salt2);
 
-            Assert.notStrictEqual(hash1, hash2);
+            assert.notStrictEqual(hash1, hash2);
         });
-        
-        test("regex issue", () =>
+
+        await test("regex issue", () =>
         {
             let password = "YQAt3TPI7s1YXyClbQ2$&JdHOKZJ@z4!";
             password = password.trim();
 
             const createdAt = Date.now();
             const username = "defaultUser";
-            
+
             const salt = (createdAt % 2) === 0
                 ? `${username.base64Decode()}${createdAt}`
                 : `${createdAt}${username.base64Decode()}`;
 
-            return Hash.createUsingSalt(password, salt);
+            Hash.createUsingSalt(password, salt);
         });
-        
-        
-        
-        
-        
-        // test("successfully create a hash", async () =>
+
+
+
+
+        // await test("successfully create a hash", async () =>
         // {
         //     let hash = await Hash.createUsingSalt("hello world", "some-salt");
-        //     Assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
-        //     Assert.notStrictEqual("hello world", hash);
+        //     assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
+        //     assert.notStrictEqual("hello world", hash);
         // });
 
-        // test("successfully create a hash twice with same values and same salt", async () =>
+        // await test("successfully create a hash twice with same values and same salt", async () =>
         // {
         //     let hash1 = await Hash.createUsingSalt("hello world", "some-salt");
         //     let hash2 = await Hash.createUsingSalt("hello world", "some-salt");
-        //     Assert.ok(hash1 !== null && !hash1.isEmptyOrWhiteSpace());
-        //     Assert.ok(hash2 !== null && !hash2.isEmptyOrWhiteSpace());
-        //     Assert.strictEqual(hash1, hash2);
+        //     assert.ok(hash1 !== null && !hash1.isEmptyOrWhiteSpace());
+        //     assert.ok(hash2 !== null && !hash2.isEmptyOrWhiteSpace());
+        //     assert.strictEqual(hash1, hash2);
         // });
-        
-        // test("successfully create a hash twice with same values and different salt", async () =>
+
+        // await test("successfully create a hash twice with same values and different salt", async () =>
         // {
         //     let hash1 = await Hash.createUsingSalt("hello world", "some-salt");
         //     let hash2 = await Hash.createUsingSalt("hello world", "some-other-salt");
-        //     Assert.ok(hash1 !== null && !hash1.isEmptyOrWhiteSpace());
-        //     Assert.ok(hash2 !== null && !hash2.isEmptyOrWhiteSpace());
-        //     Assert.notStrictEqual(hash1, hash2);
+        //     assert.ok(hash1 !== null && !hash1.isEmptyOrWhiteSpace());
+        //     assert.ok(hash2 !== null && !hash2.isEmptyOrWhiteSpace());
+        //     assert.notStrictEqual(hash1, hash2);
         // });
-        
-        // test("successfully create a hash twice with different values same salt", async () =>
+
+        // await test("successfully create a hash twice with different values same salt", async () =>
         // {
         //     let hash1 = await Hash.createUsingSalt("hello world", "some-salt");
         //     let hash2 = await Hash.createUsingSalt("hello world2", "some-salt");
-        //     Assert.ok(hash1 !== null && !hash1.isEmptyOrWhiteSpace());
-        //     Assert.ok(hash2 !== null && !hash2.isEmptyOrWhiteSpace());
-        //     Assert.notStrictEqual(hash1, hash2);
+        //     assert.ok(hash1 !== null && !hash1.isEmptyOrWhiteSpace());
+        //     assert.ok(hash2 !== null && !hash2.isEmptyOrWhiteSpace());
+        //     assert.notStrictEqual(hash1, hash2);
         // });
-        
-        // test("should throw CryptoException when value is null", async () =>
+
+        // await test("should throw CryptoException when value is null", async () =>
         // {
         //     try
         //     {
@@ -210,14 +210,14 @@ suite("Hash", () =>
         //     }
         //     catch (exception)
         //     {
-        //         Assert.ok(exception instanceof CryptoException);
-        //         Assert.strictEqual(exception.message, "Parameter count mismatch.");
+        //         assert.ok(exception instanceof CryptoException);
+        //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
-        
-        // test("should throw CryptoException when value is undefined", async () =>
+
+        // await test("should throw CryptoException when value is undefined", async () =>
         // {
         //     try
         //     {
@@ -225,14 +225,14 @@ suite("Hash", () =>
         //     }
         //     catch (exception)
         //     {
-        //         Assert.ok(exception instanceof CryptoException);
-        //         Assert.strictEqual(exception.message, "Parameter count mismatch.");
+        //         assert.ok(exception instanceof CryptoException);
+        //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
-        
-        // test("should throw CryptoException when salt is null", async () =>
+
+        // await test("should throw CryptoException when salt is null", async () =>
         // {
         //     try
         //     {
@@ -240,14 +240,14 @@ suite("Hash", () =>
         //     }
         //     catch (exception)
         //     {
-        //         Assert.ok(exception instanceof CryptoException);
-        //         Assert.strictEqual(exception.message, "Parameter count mismatch.");
+        //         assert.ok(exception instanceof CryptoException);
+        //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
-        
-        // test("should throw CryptoException when salt is undefined", async () =>
+
+        // await test("should throw CryptoException when salt is undefined", async () =>
         // {
         //     try
         //     {
@@ -255,14 +255,14 @@ suite("Hash", () =>
         //     }
         //     catch (exception)
         //     {
-        //         Assert.ok(exception instanceof CryptoException);
-        //         Assert.strictEqual(exception.message, "Parameter count mismatch.");
+        //         assert.ok(exception instanceof CryptoException);
+        //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
-        
-        // test("should throw CryptoException when salt is empty string", async () =>
+
+        // await test("should throw CryptoException when salt is empty string", async () =>
         // {
         //     try
         //     {
@@ -270,14 +270,14 @@ suite("Hash", () =>
         //     }
         //     catch (exception)
         //     {
-        //         Assert.ok(exception instanceof CryptoException);
-        //         Assert.strictEqual(exception.message, "Parameter count mismatch.");
+        //         assert.ok(exception instanceof CryptoException);
+        //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
-        
-        // test("should throw CryptoException when value is empty string", async () =>
+
+        // await test("should throw CryptoException when value is empty string", async () =>
         // {
         //     try
         //     {
@@ -285,11 +285,11 @@ suite("Hash", () =>
         //     }
         //     catch (exception)
         //     {
-        //         Assert.ok(exception instanceof CryptoException);
-        //         Assert.strictEqual(exception.message, "Parameter count mismatch.");
+        //         assert.ok(exception instanceof CryptoException);
+        //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
     });
 });