Adding unit tests for graph client error class

Author: nikithauc

spec/core/Client.ts

@@ -10,6 +10,7 @@ import "isomorphic-fetch";
 
 import { CustomAuthenticationProvider, TelemetryHandler } from "../../src";
 import { Client } from "../../src/Client";
+import { GraphClientError } from "../../src/GraphClientError";
 import { AuthProvider } from "../../src/IAuthProvider";
 import { ClientOptions } from "../../src/IClientOptions";
 import { Options } from "../../src/IOptions";
@@ -118,17 +119,19 @@ describe("Client.ts", () => {
 				const client = Client.init(options);
 				const res = await client.api("/test").get();
 			} catch (error) {
-				assert.isDefined(error.body);
+				assert.isTrue(error instanceof GraphClientError);
+				assert.isDefined(error.message);
 			}
 		});
 
 		it("Should throw error in case the access token is empty", async () => {
+			const customError = { message: "Token is empty" };
 			try {
 				const options = {
 					defaultVersion: "v1.0",
 					debugLogging: true,
 					authProvider: (done) => {
-						done(null, getTokenFunction());
+						done(customError, getTokenFunction());
 					},
 				};
 				const getTokenFunction = (): string => {
@@ -137,7 +140,8 @@ describe("Client.ts", () => {
 				const client = Client.init(options);
 				const res = await client.api("/test").get();
 			} catch (error) {
-				assert.isDefined(error.body);
+				assert.isTrue(error instanceof GraphClientError);
+				assert.equal(error.customError, customError);
 			}
 		});
 	});

spec/core/GraphClientError.ts

@@ -0,0 +1,34 @@
+/**
+ * -------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.
+ * See License in the project root for license information.
+ * -------------------------------------------------------------------------------------------
+ */
+
+import { assert } from "chai";
+
+import { GraphClientError } from "../../src/GraphClientError";
+
+describe("GraphErrorHandler.ts", () => {
+	const message = "test";
+	const name = "test_name";
+	it("Should return GraphClientError error with message set", () => {
+		const gError = new GraphClientError(message);
+		assert.equal(gError.message, message);
+	});
+
+	it("Should return GraphClientError when Error object is passed", () => {
+		const errorParameter = new Error(message);
+		errorParameter.name = name;
+		const gError = GraphClientError.setGraphClientError(errorParameter);
+		assert.equal(gError.message, message);
+		assert.equal(gError.name, name);
+	});
+
+	it("Should return GraphClientError when custom error object is passed", () => {
+		const customErrorParameter = { errorName: name, errorMessage: message };
+		const gError = GraphClientError.setGraphClientError(customErrorParameter);
+		assert.isDefined(gError.customError);
+		assert.equal(gError.customError, customErrorParameter);
+	});
+});

src/CustomAuthenticationProvider.ts

@@ -49,9 +49,12 @@ export class CustomAuthenticationProvider implements AuthenticationProvider {
 					resolve(accessToken);
 				} else {
 					if (!error) {
-						error = new GraphClientError("Access token cannot be undefined or empty.");
+						const invalidTokenMessage = "Access token is undefined or empty.\
+						Please provide a valid token.\
+						For more help - https://github.com/microsoftgraph/msgraph-sdk-javascript/blob/dev/docs/CustomAuthenticationProvider.md";
+						error = new GraphClientError(invalidTokenMessage);
 					}
-					const err = await GraphClientError.getError(error);
+					const err = await GraphClientError.setGraphClientError(error);
 					reject(err);
 				}
 			});

src/GraphClientError.ts

@@ -11,39 +11,51 @@
 
 /**
  * @class
- * This class is to handle errors that within the JavaScript Client SDK
- * unlike GraphError Class which handles errors in response from the Graph API.
+ * Create GraphClientError object to handle client-side errors
+ * encountered within the JavaScript Client SDK.
+ * Whereas GraphError Class should be used to handle errors in the response from the Graph API.
  */
 
 export class GraphClientError extends Error {
 	/**
 	 * @public
-	 * A member holding response by the graph service
+	 * A custom error. This property should set be when the error is not of instanceOf Error/GraphClientError.
+	 * Example =
+	 * const client = MicrosoftGraph.Client.init({
+	 * 		defaultVersion: "v1.0",
+	 *  	authProvider: (done) => { done({TokenError:"AccessToken cannot be null"}, "<ACCESS_TOKEN>");
+	 * });
 	 */
-	public body?: any;
+	public customError?: any;
 
 	/**
 	 * @public
 	 * @static
 	 * @async
-	 * To get the GraphError object
-	 * @param {any} [error = null] - The error returned encountered by the Graph JavaScript Client
-	 * SDK while processing request
-	 * @returns A promise that resolves to GraphError instance
+	 * To set the GraphClientError object
+	 * @param {any} - The error returned encountered by the Graph JavaScript Client SDK while processing request
+	 * @returns GraphClientError object set to the error passed
 	 */
-	public static async getError(error: any = null): Promise<GraphClientError> {
+	public static setGraphClientError(error: any): GraphClientError {
 		let graphClientError: GraphClientError;
-		if (typeof Error !== "undefined" && error instanceof Error) {
+		if (error instanceof Error) {
 			graphClientError = error;
-		} else if (error) {
+		} else {
 			graphClientError = new GraphClientError();
-			graphClientError.body = error;
+			graphClientError.customError = error;
 		}
 		return graphClientError;
 	}
 
-	public constructor(message?: string, baseError?: Error) {
-		super(message || (baseError && baseError.message));
-		this.stack = baseError ? baseError.stack : this.stack;
+	/**
+	 * @public
+	 * @constructor
+	 * Creates an instance of GraphClientError
+	 * @param {string} message? - Error message
+	 * @returns An instance of GraphClientError
+	 */
+	public constructor(message?: string) {
+		super(message);
+		Object.setPrototypeOf(this, GraphClientError.prototype);
 	}
 }

src/GraphErrorHandler.ts

@@ -41,7 +41,7 @@ export class GraphErrorHandler {
 	 * @static
 	 * @async
 	 * Populates the GraphError instance from the Error returned by graph service
-	 * @param {any} error - The error returned by graph service or some native error
+	 * @param {any} graphError - The error possibly returned by graph service or some native error
 	 * @param {number} statusCode - The status code of the response
 	 * @returns A promise that resolves to GraphError instance
 	 *
@@ -57,25 +57,17 @@ export class GraphErrorHandler {
 	 *      }
 	 *  }
 	 */
-	private static constructErrorFromResponse(error: any, statusCode: number): GraphError {
-		if (!error.error) {
-			// example - Consider error specified is a string when using type AuthProviderCallback = (error: any, accessToken: string | null) => void;
-			const graphError = new GraphError(statusCode, "Microsoft Graph JavaScript Client SDK came across an error while processing the request");
-			graphError.body = error;
-			return graphError;
-		}
-		error = error.error;
+	private static constructErrorFromResponse(graphError: any, statusCode: number): GraphError {
+		const error = graphError.error;
 		const gError = new GraphError(statusCode, error.message);
 		gError.code = error.code;
 		if (error.innerError !== undefined) {
 			gError.requestId = error.innerError["request-id"];
 			gError.date = new Date(error.innerError.date);
 		}
-		try {
-			gError.body = JSON.stringify(error);
-		} catch (error) {
-			// tslint:disable-line: no-empty
-		}
+
+		gError.body = JSON.stringify(error);
+
 		return gError;
 	}
 
@@ -84,19 +76,21 @@ export class GraphErrorHandler {
 	 * @static
 	 * @async
 	 * To get the GraphError object
+	 * Reference - https://docs.microsoft.com/en-us/graph/errors
 	 * @param {any} [error = null] - The error returned by graph service or some native error
 	 * @param {number} [statusCode = -1] - The status code of the response
 	 * @param {GraphRequestCallback} [callback] - The graph request callback function
 	 * @returns A promise that resolves to GraphError instance
 	 */
 	public static async getError(error: any = null, statusCode: number = -1, callback?: GraphRequestCallback): Promise<GraphError> {
 		let gError: GraphError;
-		if (typeof Error !== "undefined" && error instanceof Error) {
-			gError = GraphErrorHandler.constructError(error, statusCode);
-		} else if (error) {
+		if (error && error.error) {
 			gError = GraphErrorHandler.constructErrorFromResponse(error, statusCode);
+		} else if (error instanceof Error) {
+			gError = GraphErrorHandler.constructError(error, statusCode);
 		} else {
 			gError = new GraphError(statusCode);
+			gError.body = error; // if a custom error is passed which is not instance of Error object or a graph API response
 		}
 		if (typeof callback === "function") {
 			callback(gError, null);