hotstaq 0.5.3

package/src/HotTesterAPI.ts

@@ -0,0 +1,126 @@
+import { EventExecutionType, HotAPI } from "./HotAPI";
+import { HotRoute } from "./HotRoute";
+import { HotClient } from "./HotClient";
+import { HotServer } from "./HotServer";
+import { HotTestDriver } from "./HotTestDriver";
+import { HotTester } from "./HotTester";
+import { HotTestMap, HotTestPath, HotTestPage } from "./HotTestMap";
+
+export class HotTesterAPI extends HotAPI
+{
+	constructor (baseUrl: string, connection: HotServer | HotClient = null, db: any = null)
+	{
+		super(baseUrl, connection, db);
+
+		this.executeEventsUsing = EventExecutionType.HotAPI;
+
+		let route: HotRoute = new HotRoute (connection, "tester");
+		route.addMethod ("pageLoaded", this.pageLoaded);
+		route.addMethod ("executeTests", this.executeTests);
+		this.addRoute (route);
+	}
+
+	/**
+	 * This is called when the page has finished loading in development mode.
+	 */
+	async pageLoaded (req: any, res: any, authorizedValue: any, jsonObj: any, queryObj: any): Promise<any>
+	{
+		let testerObj: {
+				testerName: string;
+				testerMap: string;
+				pageName: string;
+				testElements: any;
+				testPathsStrs: any;
+			} = {
+				testerName: jsonObj["testerName"],
+				testerMap: jsonObj["testerMap"],
+				pageName: jsonObj["pageName"],
+				testElements: jsonObj["testElements"],
+				testPathsStrs: jsonObj["testPaths"]
+			};
+
+		for (let key in testerObj)
+		{
+			// @ts-ignore
+			let testObj: any = testerObj[key];
+			let throwError: boolean = false;
+
+			if (testObj == null)
+				throwError = true;
+
+			if ((testerObj.testerName == "") || 
+				(testerObj.testerMap === "") || 
+				(testerObj.testElements === "") || 
+				(testerObj.testPathsStrs === ""))
+			{
+				throwError = true;
+			}
+
+			if (throwError === true)
+				throw new Error (`TesterAPI: Object ${key} was not passed.`);
+		}
+
+		testerObj.testElements = JSON.parse (testerObj.testElements);
+		testerObj.testPathsStrs = JSON.parse (testerObj.testPathsStrs);
+
+		let testPaths: { [name: string]: HotTestPath; } = {};
+
+		for (let key in testerObj.testPathsStrs)
+		{
+			let testPath: (driver: HotTestDriver, ...args: any) => Promise<any> = 
+				eval (testerObj.testPathsStrs[key]);
+
+			testPaths[key] = testPath;
+		}
+
+		let tester: HotTester = this.connection.processor.testers[testerObj.testerName];
+
+		if (tester == null)
+			throw new Error (`TesterAPI: Tester ${testerObj.testerMap} does not exist!`);
+
+		let testMap: HotTestMap = tester.testMaps[testerObj.testerMap];
+
+		if (testMap == null)
+			throw new Error (`TesterAPI: Tester map ${testerObj.testerMap} does not exist!`);
+
+		testMap.pages[testerObj.pageName] = {
+				"testElements": {},
+				"testPaths": {}
+			};
+		testMap.pages[testerObj.pageName].testElements = testerObj.testElements;
+		testMap.pages[testerObj.pageName].testPaths = testPaths;
+
+		tester.finishedLoading = true;
+
+		if (tester.onFinishedLoading != null)
+			await tester.onFinishedLoading ();
+
+		return (true);
+	}
+
+	/**
+	 * Execute the tests for a page.
+	 */
+	async executeTests (req: any, res: any, authorizedValue: any, jsonObj: any, queryObj: any): Promise<any>
+	{
+		let testerName: string = jsonObj["testerName"];
+		let testerMap: string = jsonObj["testerMap"];
+
+		if ((testerName == null) || (testerMap == null))
+			throw new Error ("TesterAPI: Not all required json objects were passed.");
+
+		if ((testerName === "") || (testerMap === ""))
+			throw new Error ("TesterAPI: Not all required json objects were passed.");
+
+		let server: HotServer = (<HotServer>this.connection);
+
+		// @ts-ignore
+		if (server.executeTests != null)
+		{
+			// @ts-ignore
+			await server.executeTests (testerName, testerMap);
+		}
+
+		return (true);
+	}
+}

package/src/HotTesterMocha.ts

@@ -0,0 +1,133 @@
+import Mocha from "mocha";
+import { Suite, Test } from "mocha";
+
+import { HotTestMap, HotTestPage, HotTestPath } from "./HotTestMap";
+import { HotDestination, HotTester, HotTestStop } from "./HotTester";
+import { HotTestDriver } from "./HotTestDriver";
+import { HotStaq } from "./HotStaq";
+
+/**
+ * The tester that uses Mocha to executes all tests.
+ */
+export class HotTesterMocha extends HotTester
+{
+	/**
+	 * The mocha instance to run.
+	 */
+	mocha: Mocha;
+	/**
+	 * The timeout for each test.
+	 */
+	timeout: number;
+	/**
+	 * The suite to execute.
+	 */
+	suite: Suite;
+    /**
+     * The Mocha beforeAll event to call before any tests are executed.
+     */
+    beforeAll: () => Promise<void>;
+    /**
+     * The Mocha afterAll event to call before any tests are executed.
+     */
+    afterAll: () => Promise<void>;
+
+	constructor (processor: HotStaq, name: string, baseUrl: string, driver: HotTestDriver, 
+		testMaps: { [name: string]: HotTestMap; } = {}, beforeAll: () => Promise<void> = null, 
+		afterAll: () => Promise<void> = null)
+	{
+		super (processor, name, baseUrl, driver, testMaps);
+
+        this.mocha = null;
+        this.timeout = 10000;
+		this.suite = null;
+        this.beforeAll = beforeAll;
+        this.afterAll = afterAll;
+	}
+
+	/**
+	 * Executed when setting up the tester.
+	 */
+	async setup (): Promise<void>
+	{
+	}
+
+	/**
+	 * Executed when destroying up the tester.
+	 */
+	async destroy (): Promise<void>
+	{
+	}
+
+	/**
+	 * Executed when tests are started.
+	 */
+	async onTestStart (destination: HotDestination, destinationKey: string = ""): Promise<boolean>
+	{
+		let destinationName: string = "";
+
+		if (destinationKey !== "")
+			destinationName = ` - ${destinationKey}`;
+
+		this.mocha = new Mocha ();
+		this.suite = Mocha.Suite.create (this.mocha.suite, `${destination.page}${destinationName} Tests`);
+		this.suite.timeout (this.timeout);
+
+        if (this.beforeAll != null)
+		    this.suite.beforeAll (this.beforeAll);
+
+		return (true);
+	}
+
+	async onTestPagePathStart (destination: HotDestination, page: HotTestPage, 
+		stop: HotTestStop, continueWhenTestIsComplete: boolean = false): Promise<boolean>
+	{
+		let testPathName: string = stop.path;
+
+		if (continueWhenTestIsComplete === true)
+		{
+			await new Promise<void> ((resolve, reject) =>
+				{
+					this.suite.addTest (new Test (testPathName, async () =>
+						{
+							// The true is a dumb hack to prevent any recursion.
+							await this.executeTestPagePath (destination, stop, true);
+							resolve ();
+						}));
+				});
+		}
+		else
+		{
+			this.suite.addTest (new Test (testPathName, async () =>
+				{
+					// The true is a dumb hack to prevent any recursion.
+					await this.executeTestPagePath (destination, stop, true);
+				}));
+		}
+
+		return (false);
+	}
+
+	async onCommand (destination: HotDestination, page: HotTestPage, stop: HotTestStop, 
+		cmd: string, args: string[], cmdFunc: ((cmdArgs: string[]) => Promise<void>)): Promise<void>
+	{
+		this.suite.addTest (new Test (cmd, async () =>
+			{
+				await cmdFunc (args);
+			}));
+	}
+
+	async onTestEnd (destination: HotDestination): Promise<void>
+	{
+		return (await new Promise ((resolve, reject) =>
+			{
+				if (this.afterAll != null)
+					this.suite.afterAll (this.afterAll);
+
+				this.mocha.run ((failures: number) =>
+					{
+						resolve ();
+					});
+			}));
+	}
+}

package/src/HotTesterMochaSelenium.ts

@@ -0,0 +1,189 @@
+import Mocha from "mocha";
+import { Suite, Test } from "mocha";
+
+import { HotTestMap, HotTestPage, HotTestPath } from "./HotTestMap";
+import { HotDestination, HotTester, HotTestStop } from "./HotTester";
+import { HotStaq } from "./HotStaq";
+import { HotTestSeleniumDriver } from "./HotTestSeleniumDriver";
+
+import { WebDriver } from "selenium-webdriver";
+
+/**
+ * The tester that uses Mocha to executes all tests.
+ */
+export class HotTesterMochaSelenium extends HotTester
+{
+	/**
+	 * The driver to use when running tests.
+	 */
+	driver: HotTestSeleniumDriver;
+	/**
+	 * The mocha instance to run.
+	 */
+	mocha: Mocha;
+	/**
+	 * The timeout for each test.
+	 */
+	timeout: number;
+	/**
+	 * The suite to execute.
+	 */
+	suite: Suite;
+    /**
+     * The Mocha beforeAll event to call before any tests are executed.
+     */
+    beforeAll: () => Promise<void>;
+    /**
+     * The Mocha afterAll event to call before any tests are executed.
+     */
+    afterAll: () => Promise<void>;
+    /**
+     * This event is executed after the Selenium driver and url have 
+	 * been loaded. If this returns true, Selenium will load the url.
+     */
+    onSetup: (driver: WebDriver, url: string) => Promise<boolean>;
+	/**
+	 * If set to true, this will wait for the tester API data. If 
+	 * onSetup is used, it will have to return true in order to 
+	 * wait for the tester data.
+	 */
+	waitForTesterData: boolean;
+
+	constructor (processor: HotStaq, name: string, baseUrl: string, 
+		testMaps: { [name: string]: HotTestMap; } = {}, 
+		onSetup: (driver: WebDriver) => Promise<boolean> = null, 
+		beforeAll: () => Promise<void> = null, 
+		afterAll: () => Promise<void> = null)
+	{
+		super (processor, name, baseUrl, null, testMaps);
+
+		this.driver = new HotTestSeleniumDriver ();
+        this.mocha = null;
+        this.timeout = 10000;
+		this.suite = null;
+		this.onSetup = onSetup;
+        this.beforeAll = beforeAll;
+        this.afterAll = afterAll;
+		this.waitForTesterData = true;
+	}
+
+	/**
+	 * Setup the Mocha/Selenium frameworks.
+	 * 
+	 * @param tester The 
+	 * @param url If this is set, this url will be used instead of the url associated with this 
+	 * tester.
+	 */
+	async setup (isWebRoute: boolean, url: string = "", destinationKey: string = ""): Promise<void>
+	{
+		// Only execute web routes using Selenium.
+		if (isWebRoute === false)
+			return;
+
+		let testDriver: HotTestSeleniumDriver = (<HotTestSeleniumDriver>this.driver);
+
+		await testDriver.loadSeleniumDriver ();
+		let driver: WebDriver = testDriver.driver;
+		let loadDriverUrl: boolean = true;
+		let tempUrl: string = this.baseUrl;
+
+		if (url !== "")
+			tempUrl = url;
+
+		if (this.onSetup != null)
+		{
+			loadDriverUrl = await this.onSetup (driver, tempUrl);
+
+			if (loadDriverUrl == null)
+				loadDriverUrl = true;
+		}
+
+		if (loadDriverUrl === true)
+		{
+			this.finishedLoading = false;
+			await driver.get (tempUrl);
+			await this.waitForData ();
+		}
+	}
+
+	/**
+	 * Executed when destroying this tester.
+	 */
+	async destroy (): Promise<void>
+	{
+		if (this.driver != null)
+			await this.driver.destroy ();
+	}
+
+	/**
+	 * Executed when tests are started.
+	 */
+	async onTestStart (destination: HotDestination, url: string, destinationKey: string = ""): Promise<boolean>
+	{
+		let destinationName: string = "";
+
+		if (destinationKey !== "")
+			destinationName = ` - ${destinationKey}`;
+
+		this.mocha = new Mocha ();
+		this.suite = Mocha.Suite.create (this.mocha.suite, `${destination.page}${destinationName} Tests`);
+		this.suite.timeout (this.timeout);
+
+        if (this.beforeAll != null)
+		    this.suite.beforeAll (this.beforeAll);
+
+		return (true);
+	}
+
+	async onTestPagePathStart (destination: HotDestination, page: HotTestPage, 
+		stop: HotTestStop, continueWhenTestIsComplete: boolean = false): Promise<boolean>
+	{
+		let testPathName: string = stop.path;
+
+		if (continueWhenTestIsComplete === true)
+		{
+			await new Promise<void> ((resolve, reject) =>
+				{
+					this.suite.addTest (new Test (testPathName, async () =>
+						{
+							// The true is a dumb hack to prevent any recursion.
+							await this.executeTestPagePath (destination, stop, true);
+							resolve ();
+						}));
+				});
+		}
+		else
+		{
+			this.suite.addTest (new Test (testPathName, async () =>
+				{
+					// The true is a dumb hack to prevent any recursion.
+					await this.executeTestPagePath (destination, stop, true);
+				}));
+		}
+
+		return (false);
+	}
+
+	async onCommand (destination: HotDestination, page: HotTestPage, stop: HotTestStop, 
+		cmd: string, args: string[], cmdFunc: ((cmdArgs: string[]) => Promise<void>)): Promise<void>
+	{
+		this.suite.addTest (new Test (cmd, async () =>
+			{
+				await cmdFunc (args);
+			}));
+	}
+
+	async onTestEnd (destination: HotDestination): Promise<void>
+	{
+		return (await new Promise ((resolve, reject) =>
+			{
+				if (this.afterAll != null)
+					this.suite.afterAll (this.afterAll);
+
+				this.mocha.run ((failures: number) =>
+					{
+						resolve ();
+					});
+			}));
+	}
+}