@nivinjoseph/n-sec 5.0.5 → 6.0.2

package/test/hmac.test.ts

@@ -1,79 +1,80 @@
-import * as Assert from "assert";
-import { Hmac, SymmetricEncryption } from "./../src/index";
+import { describe, test } from "node:test";
+import assert from "node:assert";
+import { Hmac, SymmetricEncryption } from "./../src/index.js";
 // import { CryptoException } from "./../src/crypto-exception";
 import "@nivinjoseph/n-ext";
 
-suite("Hmac", () =>
+await describe("Hmac", async () =>
 {
-    suite("create", () =>
+    await describe("create", async () =>
     {
-        test("should return string value that is not null, empty, whitespace or same as the key or input", async () =>
+        await test("should return string value that is not null, empty, whitespace or same as the key or input", async () =>
         {
             const key = await SymmetricEncryption.generateKey();
             const value = "hello world";
             const hmac = Hmac.create(key, value);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(hmac !== null && !hmac.isEmptyOrWhiteSpace());
-            Assert.notStrictEqual(hmac, key);
-            Assert.notStrictEqual(hmac, value);
+            assert.ok(hmac !== null && !hmac.isEmptyOrWhiteSpace());
+            assert.notStrictEqual(hmac, key);
+            assert.notStrictEqual(hmac, value);
         });
-        
-        test("multiple invocations with the same key and value must return the same output", async () =>
+
+        await test("multiple invocations with the same key and value must return the same output", async () =>
         {
             const key = await SymmetricEncryption.generateKey();
             const value = "hello world";
             const hmac1 = Hmac.create(key, value);
             const hmac2 = Hmac.create(key, value);
-            Assert.strictEqual(hmac1, hmac2);
+            assert.strictEqual(hmac1, hmac2);
         });
-        
-        test("multiple invocations with different keys and different values must return different outputs", async () =>
+
+        await test("multiple invocations with different keys and different values must return different outputs", async () =>
         {
             const key1 = await SymmetricEncryption.generateKey();
             const value1 = "hello world";
             const hmac1 = Hmac.create(key1, value1);
-            
+
             const key2 = await SymmetricEncryption.generateKey();
             const value2 = "goodbye world";
             const hmac2 = Hmac.create(key2, value2);
-            Assert.notStrictEqual(hmac1, hmac2);
+            assert.notStrictEqual(hmac1, hmac2);
         });
-        
-        test("multiple invocations with the same key and different values must return different outputs", async () =>
+
+        await test("multiple invocations with the same key and different values must return different outputs", async () =>
         {
             const key = await SymmetricEncryption.generateKey();
             const value1 = "hello world";
             const value2 = "goodbye world";
             const hmac1 = Hmac.create(key, value1);
             const hmac2 = Hmac.create(key, value2);
-            Assert.notStrictEqual(hmac1, hmac2);
+            assert.notStrictEqual(hmac1, hmac2);
         });
-        
-        test("multiple invocations with different keys and the same value must return different outputs", async () =>
+
+        await test("multiple invocations with different keys and the same value must return different outputs", async () =>
         {
             const key1 = await SymmetricEncryption.generateKey();
             const key2 = await SymmetricEncryption.generateKey();
             const value = "hello world";
             const hmac1 = Hmac.create(key1, value);
             const hmac2 = Hmac.create(key2, value);
-            Assert.notStrictEqual(hmac1, hmac2);
+            assert.notStrictEqual(hmac1, hmac2);
         });
-        
-        
-        
-        // test("should create same Hmacs for a given value and key", async () =>
+
+
+
+        // await test("should create same Hmacs for a given value and key", async () =>
         // {
         //     let key = await SymmetricEncryption.generateKey();
         //     let hmac1 = await Hmac.create(key, "some-string");
         //     let hmac2 = await Hmac.create(key, "some-string");
-        //     Assert.ok(hmac1 !== null && !hmac1.isEmptyOrWhiteSpace());
-        //     Assert.ok(hmac2 !== null && !hmac2.isEmptyOrWhiteSpace());
-        //     Assert.notStrictEqual(hmac1, "some-string");
-        //     Assert.notStrictEqual(hmac2, "some-string");
-        //     Assert.strictEqual(hmac1, hmac2);
+        //     assert.ok(hmac1 !== null && !hmac1.isEmptyOrWhiteSpace());
+        //     assert.ok(hmac2 !== null && !hmac2.isEmptyOrWhiteSpace());
+        //     assert.notStrictEqual(hmac1, "some-string");
+        //     assert.notStrictEqual(hmac2, "some-string");
+        //     assert.strictEqual(hmac1, hmac2);
         // });
-        
-        // test("should throw CryptoException when key is null", async () =>
+
+        // await test("should throw CryptoException when key is null", async () =>
         // {
         //     try
         //     {
@@ -81,14 +82,14 @@ suite("Hmac", () =>
         //     }
         //     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 null", async () =>
+
+        // await test("should throw CryptoException when value is null", async () =>
         // {
         //     try
         //     {
@@ -97,14 +98,14 @@ suite("Hmac", () =>
         //     }
         //     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 key is undefined", async () =>
+
+        // await test("should throw CryptoException when key is undefined", async () =>
         // {
         //     try
         //     {
@@ -112,14 +113,14 @@ suite("Hmac", () =>
         //     }
         //     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
         //     {
@@ -128,14 +129,14 @@ suite("Hmac", () =>
         //     }
         //     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 invalid key", async () =>
+
+        // await test("should throw CryptoException when invalid key", async () =>
         // {
         //     try
         //     {
@@ -143,12 +144,12 @@ suite("Hmac", () =>
         //     }
         //     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);
         // });
     });
-    
+
 });

package/test/json-web-token.test.ts

@@ -1,18 +1,18 @@
-import * as Assert from "assert";
-import { JsonWebToken } from "./../src/api-security/json-web-token";
-import { Claim } from "../src/api-security/claim";
-import { SymmetricEncryption } from "../src/index";
-import { InvalidTokenException } from "../src/api-security/invalid-token-exception";
-import { ExpiredTokenException } from "../src/api-security/expired-token-exception";
-// import { AsymmetricEncryption } from "../src/index";
+import { describe, test } from "node:test";
+import assert from "node:assert";
+import { JsonWebToken } from "./../src/api-security/json-web-token.js";
+import { Claim } from "../src/api-security/claim.js";
+import { SymmetricEncryption } from "../src/index.js";
+import { InvalidTokenException } from "../src/api-security/invalid-token-exception.js";
+import { ExpiredTokenException } from "../src/api-security/expired-token-exception.js";
 
 
-suite("Json Web Token ", () =>
+await describe("Json Web Token ", async () =>
 {
-    suite("Hmac", () =>
+    await describe("Hmac", async () =>
     {
-    
-        test("should successfully create a token using hmac with one claim", async () =>
+
+        await test("should successfully create a token using hmac with one claim", async () =>
         {
             const claim = new Claim("this_claim", "ThisValue");
             const key = await SymmetricEncryption.generateKey();
@@ -20,14 +20,14 @@ suite("Json Web Token ", () =>
             const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim]).generateToken();
             const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(jwt !== null || jwt !== undefined);
-            Assert.strictEqual(jwt.issuer, "issuer1");
-            Assert.strictEqual(jwt.algType, 1);
-            Assert.strictEqual(jwt.expiry, time + 10000000);
-            Assert.deepStrictEqual(jwt.claims, [claim]);
+            assert.ok(jwt !== null || jwt !== undefined);
+            assert.strictEqual(jwt.issuer, "issuer1");
+            assert.strictEqual(jwt.algType, 1);
+            assert.strictEqual(jwt.expiry, time + 10000000);
+            assert.deepStrictEqual(jwt.claims, [claim]);
         });
 
-        test("should successfully create a token using hmac with 2 claims", async () =>
+        await test("should successfully create a token using hmac with 2 claims", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -36,14 +36,14 @@ suite("Json Web Token ", () =>
             const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
             const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(jwt !== null || jwt !== undefined);
-            Assert.strictEqual(jwt.issuer, "issuer1");
-            Assert.strictEqual(jwt.algType, 1);
-            Assert.strictEqual(jwt.expiry, time + 10000000);
-            Assert.deepStrictEqual(jwt.claims, [claim1, claim2]);
+            assert.ok(jwt !== null || jwt !== undefined);
+            assert.strictEqual(jwt.issuer, "issuer1");
+            assert.strictEqual(jwt.algType, 1);
+            assert.strictEqual(jwt.expiry, time + 10000000);
+            assert.deepStrictEqual(jwt.claims, [claim1, claim2]);
         });
 
-        test("should successfully create a token using hmac with 2 claims", async () =>
+        await test("should successfully create a token using hmac with 2 claims", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -52,14 +52,14 @@ suite("Json Web Token ", () =>
             const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
             const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(jwt !== null || jwt !== undefined);
-            Assert.strictEqual(jwt.issuer, "issuer1");
-            Assert.strictEqual(jwt.algType, 1);
-            Assert.strictEqual(jwt.expiry, time + 10000000);
-            Assert.deepStrictEqual(jwt.claims, [claim1, claim2]);
+            assert.ok(jwt !== null || jwt !== undefined);
+            assert.strictEqual(jwt.issuer, "issuer1");
+            assert.strictEqual(jwt.algType, 1);
+            assert.strictEqual(jwt.expiry, time + 10000000);
+            assert.deepStrictEqual(jwt.claims, [claim1, claim2]);
         });
 
-        test("should throw an exception when getting JWT with a different issuer that what was user to generate token", async () =>
+        await test("should throw an exception when getting JWT with a different issuer that what was user to generate token", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -72,14 +72,14 @@ suite("Json Web Token ", () =>
             }
             catch (exp)
             {
-                Assert.ok(exp instanceof InvalidTokenException);
-                Assert.equal(exp.message, `Token '${token}' is invalid because iss was expected to be 'notTheIssuer' but instead was 'issuer1'.`);
+                assert.ok(exp instanceof InvalidTokenException);
+                assert.equal(exp.message, `Token '${token}' is invalid because iss was expected to be 'notTheIssuer' but instead was 'issuer1'.`);
                 return;
             }
-            Assert.ok(false);
+            assert.ok(false);
         });
-        
-        test("should throw an exception when getting JWT when the token is expired", async () =>
+
+        await test("should throw an exception when getting JWT when the token is expired", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -92,15 +92,15 @@ suite("Json Web Token ", () =>
             }
             catch (exp)
             {
-                Assert.ok(exp instanceof ExpiredTokenException);
-                Assert.equal(exp.message, `Token '${token}' is expired.`);
+                assert.ok(exp instanceof ExpiredTokenException);
+                assert.equal(exp.message, `Token '${token}' is expired.`);
                 return;
             }
-            Assert.ok(false);
+            assert.ok(false);
         });
-        
+
         // TODO: right now we only support one alg type. When we support others, we should uncomment this test
-        // test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
+        // await test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
         // {
         //     let claim1 = new Claim("this_claim", "ThisValue");
         //     let claim2 = new Claim("that_claim", "ThatValue");
@@ -114,14 +114,14 @@ suite("Json Web Token ", () =>
         //     catch (exp)
         //     {
         //         console.log(exp);
-        //         Assert.ok(exp instanceof InvalidTokenException);
-        //         Assert.equal(exp.message, `Token '${token}' is invalid because alg was expected to be '${2}' but instead was '${1}'.`);
+        //         assert.ok(exp instanceof InvalidTokenException);
+        //         assert.equal(exp.message, `Token '${token}' is invalid because alg was expected to be '${2}' but instead was '${1}'.`);
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
-        
-        test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
+
+        await test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -135,14 +135,14 @@ suite("Json Web Token ", () =>
             }
             catch (exp)
             {
-                Assert.ok(exp instanceof InvalidTokenException);
-                Assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
+                assert.ok(exp instanceof InvalidTokenException);
+                assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
                 return;
             }
-            Assert.ok(false);
+            assert.ok(false);
         });
-        
-        test("should throw an exception when getting JWT when the token is tampered with", async () =>
+
+        await test("should throw an exception when getting JWT when the token is tampered with", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -156,31 +156,31 @@ suite("Json Web Token ", () =>
             }
             catch (exp)
             {
-                Assert.ok(exp instanceof InvalidTokenException);
-                Assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
+                assert.ok(exp instanceof InvalidTokenException);
+                assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
                 return;
             }
-            Assert.ok(false);
+            assert.ok(false);
         });
-    }); 
-    
-    // suite("digital Signature", () =>
+    });
+
+    // await describe("digital Signature", () =>
     // {
-    //     test("should successfully create a token using keyPair using digital Signature with one claim and get jwt using keyPair", async () =>
+    //     await test("should successfully create a token using keyPair using digital Signature with one claim and get jwt using keyPair", async () =>
     //     {
     //         let keyPair = await AsymmetricEncryption.generateKeyPair();
     //         let claim = new Claim("this_claim", "ThisValue");
     //         let time = Date.now();
     //         let token = await JsonWebToken.fromClaims("issuer1", 2, keyPair, time + 10000000, [claim]).generateToken();
     //         let jwt = await JsonWebToken.fromToken("issuer1", 2, keyPair, token);
-    //         Assert.ok(jwt !== null || jwt !== undefined);
-    //         Assert.strictEqual(jwt.issuer, "issuer1");
-    //         Assert.strictEqual(jwt.algType, 2);
-    //         Assert.strictEqual(jwt.expiry, time + 10000000);
-    //         Assert.deepStrictEqual(jwt.claims, [claim]);
+    //         assert.ok(jwt !== null || jwt !== undefined);
+    //         assert.strictEqual(jwt.issuer, "issuer1");
+    //         assert.strictEqual(jwt.algType, 2);
+    //         assert.strictEqual(jwt.expiry, time + 10000000);
+    //         assert.deepStrictEqual(jwt.claims, [claim]);
     //     });
-        
-    //     test("should successfully create a token using keyPair using digital Signature with one claim and get jwt using public key", async () =>
+
+    //     await test("should successfully create a token using keyPair using digital Signature with one claim and get jwt using public key", async () =>
     //     {
     //         let keyPair = await AsymmetricEncryption.generateKeyPair();
     //         let pubKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -188,14 +188,14 @@ suite("Json Web Token ", () =>
     //         let time = Date.now();
     //         let token = await JsonWebToken.fromClaims("issuer1", 2, keyPair, time + 10000000, [claim]).generateToken();
     //         let jwt = await JsonWebToken.fromToken("issuer1", 2, pubKey, token);
-    //         Assert.ok(jwt !== null || jwt !== undefined);
-    //         Assert.strictEqual(jwt.issuer, "issuer1");
-    //         Assert.strictEqual(jwt.algType, 2);
-    //         Assert.strictEqual(jwt.expiry, time + 10000000);
-    //         Assert.deepStrictEqual(jwt.claims, [claim]);
+    //         assert.ok(jwt !== null || jwt !== undefined);
+    //         assert.strictEqual(jwt.issuer, "issuer1");
+    //         assert.strictEqual(jwt.algType, 2);
+    //         assert.strictEqual(jwt.expiry, time + 10000000);
+    //         assert.deepStrictEqual(jwt.claims, [claim]);
     //     });
-        
-    //     test("should throw an exception when getting JWT with a different issuer that what was user to generate token", async () =>
+
+    //     await test("should throw an exception when getting JWT with a different issuer that what was user to generate token", async () =>
     //     {
     //         let keyPair = await AsymmetricEncryption.generateKeyPair();
     //         let pubKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -208,14 +208,14 @@ suite("Json Web Token ", () =>
     //         }
     //         catch (exp)
     //         {
-    //             Assert.ok(exp instanceof InvalidTokenException);
-    //             Assert.equal(exp.message, `Token '${token}' is invalid because iss was expected to be 'notTheIssuer' but instead was 'issuer1'.`);
+    //             assert.ok(exp instanceof InvalidTokenException);
+    //             assert.equal(exp.message, `Token '${token}' is invalid because iss was expected to be 'notTheIssuer' but instead was 'issuer1'.`);
     //             return;
     //         }
-    //         Assert.ok(false);
+    //         assert.ok(false);
     //     });
-        
-    //     test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
+
+    //     await test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
     //     {
     //         let claim1 = new Claim("this_claim", "ThisValue");
     //         let claim2 = new Claim("that_claim", "ThatValue");
@@ -229,14 +229,14 @@ suite("Json Web Token ", () =>
     //         }
     //         catch (exp)
     //         {
-    //             Assert.ok(exp instanceof InvalidTokenException);
-    //             Assert.equal(exp.message, `Token '${token}' is invalid because alg was expected to be '${1}' but instead was '${2}'.`);
+    //             assert.ok(exp instanceof InvalidTokenException);
+    //             assert.equal(exp.message, `Token '${token}' is invalid because alg was expected to be '${1}' but instead was '${2}'.`);
     //             return;
     //         }
-    //         Assert.ok(false);
+    //         assert.ok(false);
     //     });
-        
-    //     test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
+
+    //     await test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
     //     {
     //         let claim1 = new Claim("this_claim", "ThisValue");
     //         let claim2 = new Claim("that_claim", "ThatValue");
@@ -250,14 +250,14 @@ suite("Json Web Token ", () =>
     //         }
     //         catch (exp)
     //         {
-    //             Assert.ok(exp instanceof ExpiredTokenException);
-    //             Assert.equal(exp.message, `Token '${token}' is expired.`);
+    //             assert.ok(exp instanceof ExpiredTokenException);
+    //             assert.equal(exp.message, `Token '${token}' is expired.`);
     //             return;
     //         }
-    //         Assert.ok(false);
+    //         assert.ok(false);
     //     });
-        
-    //     test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
+
+    //     await test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
     //     {
     //         let claim1 = new Claim("this_claim", "ThisValue");
     //         let claim2 = new Claim("that_claim", "ThatValue");
@@ -271,15 +271,15 @@ suite("Json Web Token ", () =>
     //         }
     //         catch (exp)
     //         {
-    //             Assert.ok(exp instanceof InvalidTokenException);
-    //             Assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
+    //             assert.ok(exp instanceof InvalidTokenException);
+    //             assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
     //             return;
     //         }
-    //         Assert.ok(false);
+    //         assert.ok(false);
     //     });
-        
-        
-    //     test("should throw an exception when getting JWT when the token is tampered with", async () =>
+
+
+    //     await test("should throw an exception when getting JWT when the token is tampered with", async () =>
     //     {
     //         let claim1 = new Claim("this_claim", "ThisValue");
     //         let claim2 = new Claim("that_claim", "ThatValue");
@@ -293,12 +293,12 @@ suite("Json Web Token ", () =>
     //         }
     //         catch (exp)
     //         {
-    //             Assert.ok(exp instanceof InvalidTokenException);
-    //             Assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
+    //             assert.ok(exp instanceof InvalidTokenException);
+    //             assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
     //             return;
     //         }
-    //         Assert.ok(false);
+    //         assert.ok(false);
     //     });
     // });
-    
+
 });

package/test/other.test.ts

@@ -1,15 +1,16 @@
-import * as Assert from "assert";
+import assert from "node:assert";
+import { describe, test } from "node:test";
 
-suite("Other", () =>
+await describe("Other", async () =>
 {
-    test("encoding decoding", () =>
+    await test("encoding decoding", () =>
     {
         const text = "moonlight43iuj90/;msdnnksdkdkdk[[[][][";
         const encodedText = Buffer.from(text, "utf8").toString("base64");
-        Assert.notStrictEqual(encodedText, text);
-        
+        assert.notStrictEqual(encodedText, text);
+
         const decodedText = Buffer.from(encodedText, "base64").toString("utf8");
-        Assert.notStrictEqual(decodedText, encodedText);
-        Assert.strictEqual(decodedText, text);
+        assert.notStrictEqual(decodedText, encodedText);
+        assert.strictEqual(decodedText, text);
     });
 });