@nivinjoseph/n-sec 4.0.4 → 5.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nivinjoseph/n-sec",
-    "version": "4.0.4",
+    "version": "5.0.1",
     "description": "Security library",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -32,17 +32,17 @@
     },
     "homepage": "https://github.com/nivinjoseph/n-sec#readme",
     "devDependencies": {
-        "@types/mocha": "^5.2.7",
-        "@types/node": "^12.12.17",
-        "mocha": "^6.2.2",
-        "ts-node": "^8.5.4",
-        "tslint": "^5.20.1",
-        "typescript": "^3.7.3",
-        "typescript-tslint-plugin": "^0.5.5"
+        "@types/mocha": "^8.2.2",
+        "@types/node": "^14.14.43",
+        "mocha": "^8.3.2",
+        "ts-node": "^9.1.1",
+        "tslint": "^6.1.3",
+        "typescript": "^4.3.5",
+        "typescript-tslint-plugin": "^1.0.1"
     },
     "dependencies": {
-        "@nivinjoseph/n-defensive": "^1.0.28",
-        "@nivinjoseph/n-exception": "^1.0.19",
-        "@nivinjoseph/n-ext": "^1.1.10"
+        "@nivinjoseph/n-defensive": "^1.0.37",
+        "@nivinjoseph/n-exception": "^1.0.24",
+        "@nivinjoseph/n-ext": "^1.1.34"
     }
 }

package/src/api-security/claim.ts

@@ -1,5 +1,4 @@
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 
 
 // public
@@ -15,7 +14,7 @@ export class Claim
     
     public constructor(type: string, value: any)
     {
-        given(type, "type").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(type, "type").ensureHasValue();
         
         this._type = type.trim();
         this._value = value;

package/src/api-security/expired-token-exception.ts

@@ -1,6 +1,5 @@
 import { Exception } from "@nivinjoseph/n-exception";
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 
 
 // public
@@ -14,7 +13,7 @@ export class ExpiredTokenException extends Exception
     
     public constructor(token: string)
     {
-        given(token, "token").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(token, "token").ensureHasValue();
         token = token.trim();
         super(`Token '${token}' is expired.`);
         this._token = token;

package/src/api-security/invalid-token-exception.ts

@@ -1,6 +1,5 @@
 import { Exception } from "@nivinjoseph/n-exception";
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 
 
 // public
@@ -16,8 +15,8 @@ export class InvalidTokenException extends Exception
     
     public constructor(token: string, reason: string)
     {
-        given(token, "token").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(reason, "reason").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(token, "token").ensureHasValue();
+        given(reason, "reason").ensureHasValue();
         
         token = token.trim();
         super(`Token '${token}' is invalid because ${reason}.`);

package/src/api-security/json-web-token.ts

@@ -1,7 +1,6 @@
 import { Claim } from "./claim";
 import { InvalidOperationException } from "@nivinjoseph/n-exception";
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 import { InvalidTokenException } from "./invalid-token-exception";
 import { AlgType } from "./alg-type";
 import { Hmac } from "./../crypto/hmac";
@@ -32,9 +31,9 @@ export class JsonWebToken
     private constructor(issuer: string, algType: AlgType, key: string, isFullKey: boolean, expiry: number,
         claims: Array<Claim>)
     {
-        given(issuer, "issuer").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(algType, "algType").ensureHasValue().ensure(t => t === 1 || t === 2);
-        given(key, "key").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(issuer, "issuer").ensureHasValue();
+        given(algType, "algType").ensureHasValue().ensureIsEnum(AlgType);
+        given(key, "key").ensureHasValue();
         given(isFullKey, "isFullKey").ensureHasValue();
         given(expiry, "expiry").ensureHasValue();
         given(claims, "claims")
@@ -49,29 +48,29 @@ export class JsonWebToken
         this._claims = [...claims];
     }
     
-    public async generateToken(): Promise<string>
+    public generateToken(): string
     {
         if (!this._isfullKey)
             throw new InvalidOperationException("generating token using an instance created from token");    
         
-        let header: Header = {
+        const header: Header = {
             iss: this._issuer,
             alg: this._algType,
             exp: this._expiry
         };
         
-        let body: any = {};
+        const body: any = {};
         this._claims.forEach(t => body[t.type] = t.value);
         
-        let headerAndBody = this.toHex(header) + "." + this.toHex(body);
+        const headerAndBody = this.toHex(header) + "." + this.toHex(body);
         
         // let signature = this._algType === AlgType.hmac
         //     ? await Hmac.create(this._key, headerAndBody)
         //     : await DigitalSignature.sign(this._key, headerAndBody);
         
-        let signature = await Hmac.create(this._key, headerAndBody);
+        const signature = Hmac.create(this._key, headerAndBody);
         
-        let token = headerAndBody + "." + signature;
+        const token = headerAndBody + "." + signature;
         return token;
     }
     
@@ -82,27 +81,27 @@ export class JsonWebToken
         return new JsonWebToken(issuer, algType, key, true, expiry, claims);
     }
     
-    public static async fromToken(issuer: string, algType: AlgType, key: string, token: string): Promise<JsonWebToken>
+    public static fromToken(issuer: string, algType: AlgType, key: string, token: string): JsonWebToken
     {
-        given(issuer, "issuer").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(algType, "algType").ensureHasValue().ensure(t => t === 1 || t === 2);
-        given(key, "key").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(token, "token").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(issuer, "issuer").ensureHasValue();
+        given(algType, "algType").ensureHasValue().ensureIsEnum(AlgType);
+        given(key, "key").ensureHasValue();
+        given(token, "token").ensureHasValue();
         
         issuer = issuer.trim();
         key = key.trim();
         token = token.trim();
         
-        let tokenSplitted = token.split(".");
+        const tokenSplitted = token.split(".");
         if (tokenSplitted.length !== 3)
             throw new InvalidTokenException(token, "format is incorrect");
         
-        let headerString = tokenSplitted[0];
-        let bodyString = tokenSplitted[1];
-        let signature = tokenSplitted[2];
+        const headerString = tokenSplitted[0];
+        const bodyString = tokenSplitted[1];
+        const signature = tokenSplitted[2];
         
-        let header: Header = JsonWebToken.toObject(headerString) as Header;
-        let body: any = JsonWebToken.toObject(bodyString);
+        const header: Header = JsonWebToken.toObject(headerString) as Header;
+        const body: any = JsonWebToken.toObject(bodyString);
         
         if (header.iss === undefined || header.iss === null)
             throw new InvalidTokenException(token, "iss was not present");
@@ -140,11 +139,11 @@ export class JsonWebToken
         //         throw new InvalidTokenException(token, "signature could not be verified");  
         // }    
         
-        let computedSignature = await Hmac.create(key, headerString + "." + bodyString);
+        const computedSignature = Hmac.create(key, headerString + "." + bodyString);
         if (computedSignature !== signature)
             throw new InvalidTokenException(token, "signature could not be verified");    
         
-        let claims = new Array<Claim>();
+        const claims = new Array<Claim>();
         for (let item in body)
             claims.push(new Claim(item, body[item]));    
         
@@ -153,15 +152,15 @@ export class JsonWebToken
     
     private toHex(obj: object): string
     {
-        let json = JSON.stringify(obj);
-        let hex = Buffer.from(json, "utf8").toString("hex");
+        const json = JSON.stringify(obj);
+        const hex = Buffer.from(json, "utf8").toString("hex");
         return hex.toUpperCase();
     }
     
     private static toObject(hex: string): object
     {
-        let json = Buffer.from(hex.toLowerCase(), "hex").toString("utf8");
-        let obj = JSON.parse(json);
+        const json = Buffer.from(hex.toLowerCase(), "hex").toString("utf8");
+        const obj = JSON.parse(json);
         return obj;
     }
 }

package/src/crypto/hash.ts

@@ -1,5 +1,4 @@
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 import * as Crypto from "crypto";
 
 
@@ -9,21 +8,21 @@ export class Hash
     private constructor() { }
     
 
-    public static create(value: string): Promise<string>
+    public static create(value: string): string
     {
-        given(value, "value").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(value, "value").ensureHasValue().ensureIsString();
         
         value = value.trim();
         
         const hash = Crypto.createHash("sha512");
         hash.update(value, "utf8");
-        return Promise.resolve(hash.digest("hex").toUpperCase());
+        return hash.digest("hex").toUpperCase();
     }
     
-    public static createUsingSalt(value: string, salt: string): Promise<string>
+    public static createUsingSalt(value: string, salt: string): string
     {
-        given(value, "value").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(salt, "salt").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(value, "value").ensureHasValue().ensureIsString();
+        given(salt, "salt").ensureHasValue().ensureIsString();
 
         value = value.trim();
         salt = salt.trim();

package/src/crypto/hmac.ts

@@ -1,5 +1,4 @@
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 import * as Crypto from "crypto";
 
 
@@ -9,10 +8,10 @@ export class Hmac
     private constructor() { }
     
     
-    public static create(key: string, value: string): Promise<string>
+    public static create(key: string, value: string): string
     {
-        given(key, "key").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(value, "value").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(key, "key").ensureHasValue().ensureIsString();
+        given(value, "value").ensureHasValue().ensureIsString();
         
         key = key.trim();
         value = value.trim();
@@ -20,6 +19,6 @@ export class Hmac
         const hmac = Crypto.createHmac("sha256", Buffer.from(key, "hex"));
         
         hmac.update(value, "utf8");
-        return Promise.resolve(hmac.digest("hex").toUpperCase());
+        return hmac.digest("hex").toUpperCase();
     }
 }

package/src/crypto/symmetric-encryption.ts

@@ -1,7 +1,6 @@
 import * as Crypto from "crypto";
 import { CryptoException } from "./crypto-exception";
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 
 
 // public
@@ -29,14 +28,14 @@ export class SymmetricEncryption
     
     public static encrypt(key: string, value: string): Promise<string>
     {
-        given(key, "key").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(value, "value").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        
-        key = key.trim();
-        value = value.trim();
-        
         return new Promise<string>((resolve, reject) =>
         {
+            given(key, "key").ensureHasValue().ensureIsString();
+            given(value, "value").ensureHasValue().ensureIsString();
+
+            key = key.trim();
+            value = value.trim();
+            
             Crypto.randomBytes(16, (err, buf) =>
             {
                 if (err)
@@ -64,29 +63,22 @@ export class SymmetricEncryption
         
     }
     
-    public static decrypt(key: string, value: string): Promise<string>
+    public static decrypt(key: string, value: string): string
     {
-        given(key, "key").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(value, "value").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(key, "key").ensureHasValue().ensureIsString();
+        given(value, "value").ensureHasValue().ensureIsString();
 
         key = key.trim();
         value = value.trim();
         
-        try 
-        {
-            const splitted = value.split(".");
-            if (splitted.length !== 2)
-                throw new CryptoException("Invalid value.");
+        const splitted = value.split(".");
+        if (splitted.length !== 2)
+            throw new CryptoException("Invalid value.");
 
-            const iv = Buffer.from(splitted[1], "hex");
-            const deCipher = Crypto.createDecipheriv("AES-256-CBC", Buffer.from(key, "hex"), iv);
-            let decrypted = deCipher.update(splitted[0], "hex", "utf8");
-            decrypted += deCipher.final("utf8");
-            return Promise.resolve(decrypted);
-        }
-        catch (error)
-        {
-            return Promise.reject(error);
-        }
+        const iv = Buffer.from(splitted[1], "hex");
+        const deCipher = Crypto.createDecipheriv("AES-256-CBC", Buffer.from(key, "hex"), iv);
+        let decrypted = deCipher.update(splitted[0], "hex", "utf8");
+        decrypted += deCipher.final("utf8");
+        return decrypted;
     }
 }

package/test/hash.test.ts

@@ -2,34 +2,33 @@ import * as Assert from "assert";
 import { Hash } from "./../src/index";
 import "@nivinjoseph/n-ext";
 // import { CryptoException } from "./../src/crypto-exception";
-import "@nivinjoseph/n-ext";
 
 suite("Hash", () =>
 {
     suite("create", () =>
     {
-        test("must return a string value that is not null, empty, whitespace or same as input when called with a valid input", async () =>
+        test("must return a string value that is not null, empty, whitespace or same as input when called with a valid input", () =>
         {
             let input = "hello world";
-            let hash = await Hash.create(input);
+            let hash = Hash.create(input);
             Assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
             Assert.notStrictEqual(hash, input);
         });
         
-        test("multiple invocations with the same input must return the same output", async () =>
+        test("multiple invocations with the same input must return the same output", () =>
         {
             let input = "hello world";
-            let hash1 = await Hash.create(input);
-            let hash2 = await Hash.create(input);
+            let hash1 = Hash.create(input);
+            let hash2 = Hash.create(input);
             Assert.strictEqual(hash1, hash2);
         });
         
-        test("multiple invocations with the different inputs must return different outputs", async () =>
+        test("multiple invocations with the different inputs must return different outputs", () =>
         {
             let input1 = "hello world";
-            let hash1 = await Hash.create(input1);
+            let hash1 = Hash.create(input1);
             let input2 = "goodbye world";
-            let hash2 = await Hash.create(input2);
+            let hash2 = Hash.create(input2);
             Assert.notStrictEqual(hash1, hash2);
         });
         
@@ -92,58 +91,58 @@ suite("Hash", () =>
     
     suite("createUsingSalt", () =>
     {
-        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", 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", () =>
         {
             let input = "hello world";
             let salt = "salt";
-            let hash = await Hash.createUsingSalt(input, salt);
+            let hash = Hash.createUsingSalt(input, 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", async () =>
+        test("multiple invocations with the same input and salt must return the same output", () =>
         {
             let input = "hello world";
             let salt = "salt";
-            let hash1 = await Hash.createUsingSalt(input, salt);
-            let hash2 = await Hash.createUsingSalt(input, salt);
+            let hash1 = Hash.createUsingSalt(input, salt);
+            let hash2 = Hash.createUsingSalt(input, salt);
             Assert.strictEqual(hash1, hash2);
         });
 
-        test("multiple invocations with different inputs and different salts must return different outputs", async () =>
+        test("multiple invocations with different inputs and different salts must return different outputs", () =>
         {
             let input1 = "hello world";
             let salt1 = "salt-1";
-            let hash1 = await Hash.createUsingSalt(input1, salt1);
+            let hash1 = Hash.createUsingSalt(input1, salt1);
             
             let input2 = "goodbye world";
             let salt2 = "salt-2";
-            let hash2 = await Hash.createUsingSalt(input2, salt2);
+            let hash2 = Hash.createUsingSalt(input2, salt2);
             
             Assert.notStrictEqual(hash1, hash2);
         });
         
-        test("multiple invocations with different inputs and the same salt must return different outputs", async () =>
+        test("multiple invocations with different inputs and the same salt must return different outputs", () =>
         {
             let input1 = "hello world";
             let salt1 = "salt-1";
-            let hash1 = await Hash.createUsingSalt(input1, salt1);
+            let hash1 = Hash.createUsingSalt(input1, salt1);
 
             let input2 = "goodbye world";
-            let hash2 = await Hash.createUsingSalt(input2, salt1);
+            let hash2 = Hash.createUsingSalt(input2, salt1);
 
             Assert.notStrictEqual(hash1, hash2);
         });
         
-        test("multiple invocations with the same input and different salts must return different outputs", async () =>
+        test("multiple invocations with the same input and different salts must return different outputs", () =>
         {
             let input = "hello world";
             let salt1 = "salt-1";
-            let hash1 = await Hash.createUsingSalt(input, salt1);
+            let hash1 = Hash.createUsingSalt(input, salt1);
 
             let salt2 = "salt-2";
-            let hash2 = await Hash.createUsingSalt(input, salt2);
+            let hash2 = Hash.createUsingSalt(input, salt2);
 
             Assert.notStrictEqual(hash1, hash2);
         });

package/test/hmac.test.ts

@@ -11,7 +11,7 @@ suite("Hmac", () =>
         {
             let key = await SymmetricEncryption.generateKey();
             let value = "hello world";
-            let hmac = await Hmac.create(key, value);
+            let hmac = Hmac.create(key, value);
             Assert.ok(hmac !== null && !hmac.isEmptyOrWhiteSpace());
             Assert.notStrictEqual(hmac, key);
             Assert.notStrictEqual(hmac, value);
@@ -21,8 +21,8 @@ suite("Hmac", () =>
         {
             let key = await SymmetricEncryption.generateKey();
             let value = "hello world";
-            let hmac1 = await Hmac.create(key, value);
-            let hmac2 = await Hmac.create(key, value);
+            let hmac1 = Hmac.create(key, value);
+            let hmac2 = Hmac.create(key, value);
             Assert.strictEqual(hmac1, hmac2);
         });
         
@@ -30,11 +30,11 @@ suite("Hmac", () =>
         {
             let key1 = await SymmetricEncryption.generateKey();
             let value1 = "hello world";
-            let hmac1 = await Hmac.create(key1, value1);
+            let hmac1 = Hmac.create(key1, value1);
             
             let key2 = await SymmetricEncryption.generateKey();
             let value2 = "goodbye world";
-            let hmac2 = await Hmac.create(key2, value2);
+            let hmac2 = Hmac.create(key2, value2);
             Assert.notStrictEqual(hmac1, hmac2);
         });
         
@@ -43,8 +43,8 @@ suite("Hmac", () =>
             let key = await SymmetricEncryption.generateKey();
             let value1 = "hello world";
             let value2 = "goodbye world";
-            let hmac1 = await Hmac.create(key, value1);
-            let hmac2 = await Hmac.create(key, value2);
+            let hmac1 = Hmac.create(key, value1);
+            let hmac2 = Hmac.create(key, value2);
             Assert.notStrictEqual(hmac1, hmac2);
         });
         
@@ -53,8 +53,8 @@ suite("Hmac", () =>
             let key1 = await SymmetricEncryption.generateKey();
             let key2 = await SymmetricEncryption.generateKey();
             let value = "hello world";
-            let hmac1 = await Hmac.create(key1, value);
-            let hmac2 = await Hmac.create(key2, value);
+            let hmac1 = Hmac.create(key1, value);
+            let hmac2 = Hmac.create(key2, value);
             Assert.notStrictEqual(hmac1, hmac2);
         });
         

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

@@ -17,8 +17,8 @@ suite("Json Web Token ", () =>
             let claim = new Claim("this_claim", "ThisValue");
             let key = await SymmetricEncryption.generateKey();
             let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim]).generateToken();
-            let jwt = await JsonWebToken.fromToken("issuer1", 1, key, token);
+            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim]).generateToken();
+            let jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
             Assert.ok(jwt !== null || jwt !== undefined);
             Assert.strictEqual(jwt.issuer, "issuer1");
             Assert.strictEqual(jwt.algType, 1);
@@ -32,8 +32,8 @@ suite("Json Web Token ", () =>
             let claim2 = new Claim("that_claim", "ThatValue");
             let key = await SymmetricEncryption.generateKey();
             let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
-            let jwt = await JsonWebToken.fromToken("issuer1", 1, key, token);
+            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
+            let jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
             Assert.ok(jwt !== null || jwt !== undefined);
             Assert.strictEqual(jwt.issuer, "issuer1");
             Assert.strictEqual(jwt.algType, 1);
@@ -47,8 +47,8 @@ suite("Json Web Token ", () =>
             let claim2 = new Claim("that_claim", "ThatValue");
             let key = await SymmetricEncryption.generateKey();
             let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
-            let jwt = await JsonWebToken.fromToken("issuer1", 1, key, token);
+            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
+            let jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
             Assert.ok(jwt !== null || jwt !== undefined);
             Assert.strictEqual(jwt.issuer, "issuer1");
             Assert.strictEqual(jwt.algType, 1);
@@ -62,10 +62,10 @@ suite("Json Web Token ", () =>
             let claim2 = new Claim("that_claim", "ThatValue");
             let key = await SymmetricEncryption.generateKey();
             let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
+            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
             try
             {
-                await JsonWebToken.fromToken("notTheIssuer", 1, key, token);
+                JsonWebToken.fromToken("notTheIssuer", 1, key, token);
             }
             catch (exp)
             {
@@ -82,10 +82,10 @@ suite("Json Web Token ", () =>
             let claim2 = new Claim("that_claim", "ThatValue");
             let key = await SymmetricEncryption.generateKey();
             let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time, [claim1, claim2]).generateToken();
+            let token = JsonWebToken.fromClaims("issuer1", 1, key, time, [claim1, claim2]).generateToken();
             try
             {
-                await JsonWebToken.fromToken("issuer1", 1, key, token);
+                JsonWebToken.fromToken("issuer1", 1, key, token);
             }
             catch (exp)
             {
@@ -96,25 +96,27 @@ suite("Json Web Token ", () =>
             Assert.ok(false);
         });
         
-        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");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
-            try
-            {
-                await JsonWebToken.fromToken("issuer1", 2, key, token);
-            }
-            catch (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}'.`);
-                return;
-            }
-            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 () =>
+        // {
+        //     let claim1 = new Claim("this_claim", "ThisValue");
+        //     let claim2 = new Claim("that_claim", "ThatValue");
+        //     let key = await SymmetricEncryption.generateKey();
+        //     let time = Date.now();
+        //     let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
+        //     try
+        //     {
+        //         JsonWebToken.fromToken("issuer1", 2, key, 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}'.`);
+        //         return;
+        //     }
+        //     Assert.ok(false);
+        // });
         
         test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
         {
@@ -123,10 +125,10 @@ suite("Json Web Token ", () =>
             let key = await SymmetricEncryption.generateKey();
             let key2 = await SymmetricEncryption.generateKey();
             let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
+            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
             try
             {
-                await JsonWebToken.fromToken("issuer1", 1, key2, token);
+                JsonWebToken.fromToken("issuer1", 1, key2, token);
             }
             catch (exp)
             {
@@ -143,11 +145,11 @@ suite("Json Web Token ", () =>
             let claim2 = new Claim("that_claim", "ThatValue");
             let key = await SymmetricEncryption.generateKey();
             let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
+            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
             token = token + "someStuff";
             try
             {
-                await JsonWebToken.fromToken("issuer1", 1, key, token);
+                JsonWebToken.fromToken("issuer1", 1, key, token);
             }
             catch (exp)
             {