Enhancement/#311 page iterator request options

spec/development/workload/PageIterator.ts

@@ -1,61 +1,123 @@
+/**
+ * -------------------------------------------------------------------------------------------
+ * 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 { Event } from "microsoft-graph";
 
-import { PageIterator, PageIteratorCallback, GraphRequestOptions } from "../../../src/tasks/PageIterator";
+import { PageIterator, PageIteratorCallback, GraphRequestOptions, PageCollection } from "../../../src/tasks/PageIterator";
 import { getClient } from "../test-helper";
+import { ChaosHandler } from "../../../src/middleware/ChaosHandler";
+import { ChaosHandlerOptions } from "../../../src/middleware/options/ChaosHandlerOptions";
+import { ChaosStrategy } from "../../../src/middleware/options/ChaosStrategy";
+import { Client, ClientOptions } from "../../../src";
 
 const client = getClient();
 describe("PageIterator", function() {
-	describe("sameHeadersPassedWithPageIterator", () => {
-		const pstHeader = { Prefer: 'outlook.timezone= "pacific standard time"' };
-		const utc = "UTC";
-		const pst = "Pacific Standard Time";
-
-		it("verify same headers", async () => {
-			const response = await client
-				.api(`/me/events?$top=2`)
-				.headers(pstHeader)
-				.select("id,start,end")
-				.get();
-
-			const callback: PageIteratorCallback = (eventResponse) => {
-				const event = eventResponse as Event;
+	const pstHeader = { Prefer: 'outlook.timezone= "pacific standard time"' };
+	const utc = "UTC";
+	const pst = "Pacific Standard Time";
+	const testURL = "/me/events";
+
+	before(async function() {
+		this.timeout(20000);
+
+		const response = await client.api(testURL).get();
+		const numberOfEvents = 4;
+		const existingEventsCount = response.value.length;
+
+		if (existingEventsCount >= numberOfEvents) {
+			return;
+		}
+		const eventSubject = '"subject": "Test event ';
+		const eventTimeZone = '"timeZone": "UTC"';
+		const eventStartDateTime = '"start": { "dateTime":"' + new Date().toISOString() + '",' + eventTimeZone + "}";
+		const eventEndDateTime = '"end": { "dateTime":"' + new Date().toISOString() + '",' + eventTimeZone + "}";
+
+		for (let i = 1; i <= numberOfEvents - existingEventsCount; i++) {
+			const eventBody = "{" + eventSubject + "" + 1 + '",' + eventStartDateTime + "," + eventEndDateTime + "}";
+			const response = await client.api(testURL).post(eventBody);
+			if (response.error) {
+				throw response.error;
+			}
+		}
+	});
+
+	it("same headers passed with pageIterator", async () => {
+		const response = await client
+			.api(`${testURL}?$top=2`)
+			.headers(pstHeader)
+			.select("id,start,end")
+			.get();
+
+		const callback: PageIteratorCallback = (eventResponse) => {
+			const event = eventResponse as Event;
+			assert.equal(event.start.timeZone, pst);
+			return true;
+		};
+		var requestOptions: GraphRequestOptions = { options: { headers: pstHeader } };
+		if (response["@odata.nextLink"]) {
+			const pageIterator = new PageIterator(client, response, callback, requestOptions);
+			await pageIterator.iterate();
+			assert.isTrue(pageIterator.isComplete());
+		}
+	}).timeout(30 * 1000);
+
+	it("different headers passed with pageIterator", async () => {
+		const response = await client
+			.api(`${testURL}?$top=2`)
+			.headers({ Prefer: `outlook.timezone= "${utc}"` })
+			.select("id,start,end")
+			.get();
+
+		let counter = 0;
+		const callback: PageIteratorCallback = (eventResponse) => {
+			const event = eventResponse as Event;
+			if (counter < 2) {
+				assert.equal(event.start.timeZone, utc);
+				counter++;
+			} else {
 				assert.equal(event.start.timeZone, pst);
-				return true;
-			};
-			var requestOptions: GraphRequestOptions = { options: { headers: pstHeader } };
-			if (response["@odata.nextLink"]) {
-				const pageIterator = new PageIterator(client, response, callback, requestOptions);
-				await pageIterator.iterate();
-				assert.isTrue(pageIterator.isComplete());
 			}
-		}).timeout(20 * 1000);
-
-		it("differentHeadersPassedWithPageIterator", async () => {
-			const response = await client
-				.api(`/me/events?$top=4`)
-				.headers({ Prefer: `outlook.timezone= "${utc}"` })
-				.select("id,start,end")
-				.get();
-
-			let counter = 0;
-			const callback: PageIteratorCallback = (eventResponse) => {
-				const event = eventResponse as Event;
-				if (counter < 4) {
-					assert.equal(event.start.timeZone, utc);
-					counter++;
-				} else {
-					assert.equal(event.start.timeZone, pst);
-				}
-				return true;
+			return true;
+		};
+
+		var requestOptions = { headers: pstHeader };
+		if (response["@odata.nextLink"]) {
+			const pageIterator = new PageIterator(client, response, callback, requestOptions);
+			await pageIterator.iterate();
+			assert.isTrue(pageIterator.isComplete());
+		}
+	}).timeout(30 * 1000);
+
+	it("setting middleware with pageIterator", async () => {
+		const middleware = new ChaosHandler();
+		const getPageCollection = () => {
+			return {
+				value: [],
+				"@odata.nextLink": "nextURL",
+				additionalContent: "additional content",
 			};
+		};
+		const clientOptions: ClientOptions = {
+			middleware,
+		};
+		const responseBody = { value: [{ event1: "value1" }, { event2: "value2" }] };
+		let counter = 1;
+		const callback: PageIteratorCallback = (data) => {
+			assert.equal(data["event" + counter], "value" + counter);
+			counter++;
+			return true;
+		};
 
-			var requestOptions = { headers: pstHeader };
-			if (response["@odata.nextLink"]) {
-				const pageIterator = new PageIterator(client, response, callback, requestOptions);
-				await pageIterator.iterate();
-				assert.isTrue(pageIterator.isComplete());
-			}
-		});
+		const middlewareOptions = [new ChaosHandlerOptions(ChaosStrategy.MANUAL, 200, "middleware options for pageIterator", 0, responseBody)];
+		const requestOptions = { middlewareOptions };
+
+		const client = Client.initWithMiddleware(clientOptions);
+		const pageIterator = new PageIterator(client, getPageCollection(), callback, requestOptions);
+		await pageIterator.iterate();
 	});
 });

src/middleware/ChaosHandler.ts

@@ -91,15 +91,19 @@ export class ChaosHandler implements Middleware {
 	 * @param {string} statusMessage - the status message to be returned for the request
 	 * @param {string} requestID - request id
 	 * @param {string} requestDate - date of the request
+	 * @param {string} requestBody - the request body to be returned for the request
 	 * @returns response body
 	 */
-	private createResponseBody(statusCode: number, statusMessage: string, requestID: string, requestDate: string) {
-		let responseBody: any;
+	private createResponseBody(statusCode: number, statusMessage: string, requestID: string, requestDate: string, responseBody?: any) {
+		if (responseBody) {
+			return responseBody;
+		}
+		let body: any;
 		if (statusCode >= 400) {
 			const codeMessage: string = httpStatusCode[statusCode];
 			const errMessage: string = statusMessage;
 
-			responseBody = {
+			body = {
 				error: {
 					code: codeMessage,
 					message: errMessage,
@@ -110,9 +114,9 @@ export class ChaosHandler implements Middleware {
 				},
 			};
 		} else {
-			responseBody = {};
+			body = {};
 		}
-		return responseBody;
+		return body;
 	}
 
 	/**
@@ -132,7 +136,7 @@ export class ChaosHandler implements Middleware {
 			requestID = generateUUID();
 			requestDate = new Date();
 			responseHeader = this.createResponseHeaders(chaosHandlerOptions.statusCode, requestID, requestDate.toString());
-			responseBody = this.createResponseBody(chaosHandlerOptions.statusCode, chaosHandlerOptions.statusMessage, requestID, requestDate.toString());
+			responseBody = this.createResponseBody(chaosHandlerOptions.statusCode, chaosHandlerOptions.statusMessage, requestID, requestDate.toString(), chaosHandlerOptions.responseBody);
 			const init: any = { url: requestURL, status: chaosHandlerOptions.statusCode, statusText: chaosHandlerOptions.statusMessage, headers: responseHeader };
 			context.response = new Response(responseBody, init);
 		} catch (error) {

src/middleware/options/ChaosHandlerOptions.ts

@@ -48,20 +48,30 @@ export class ChaosHandlerOptions implements MiddlewareOptions {
 	 */
 	public chaosPercentage: number;
 
+	/**
+	 * The response body to be returned in the response
+	 *
+	 * @public
+	 */
+	public responseBody: any;
+
 	/**
 	 * @public
 	 * @constructor
 	 * To create an instance of Testing Handler Options
 	 * @param {ChaosStrategy} ChaosStrategy - Specifies the startegy used for the Testing Handler -> RAMDOM/MANUAL
-	 * @param {number?} statusCode - The Message to be returned in the response
-	 * @param {string} - The Message to be returned in the response
+	 * @param {number?} statusCode - The statusCode to be returned in the response
+	 * @param {string} statusMessage - The Message to be returned in the response
+	 * @param {number?} chaosPercentage - The percentage of randomness/chaos in the handler
+	 * @param {any} responseBody - The response body to be returned in the response
 	 * @returns An instance of ChaosHandlerOptions
 	 */
-	public constructor(chaosStrategy: ChaosStrategy = ChaosStrategy.RANDOM, statusCode?: number, statusMessage: string = "Some error Happened", chaosPercentage?: number) {
+	public constructor(chaosStrategy: ChaosStrategy = ChaosStrategy.RANDOM, statusCode?: number, statusMessage: string = "Some error Happened", chaosPercentage?: number, responseBody?: any) {
 		this.chaosStrategy = chaosStrategy;
 		this.statusCode = statusCode;
 		this.statusMessage = statusMessage;
 		this.chaosPercentage = chaosPercentage !== undefined ? chaosPercentage : 10;
+		this.responseBody = responseBody;
 		if (this.chaosPercentage > 100) {
 			throw new Error("Error Pecentage can not be more than 100");
 		}