hotstaq 0.5.3

package/src/HotTestDriver.ts

@@ -0,0 +1,171 @@
+import { HotTestElement, HotTestElementOptions } from "./HotTestElement";
+import { HotTestPage } from "./HotTestMap";
+
+/**
+ * This actually executes the tests.
+ */
+export abstract class HotTestDriver
+{
+	/**
+	 * The current page.
+	 */
+	page: HotTestPage;
+
+	constructor (page: HotTestPage = null)
+	{
+		this.page = page;
+	}
+
+	/**
+	 * Get a test object by it's name. If a * is used, it will be used as a 
+	 * wildcard for the object's name. If a > is used, then the name will 
+	 * be treated as a CSS selector.
+	 */
+	parseTestObject (name: string): string
+	{
+		let pos: number = name.indexOf ("*");
+		let wildcard: string = "";
+
+		if (pos > -1)
+		{
+			name = name.replace (/\*/, "");
+			wildcard = "*";
+		}
+
+		let selector: string = `[data-test-object-name${wildcard}='${name}']`;
+		pos = name.indexOf (">");
+
+		if (pos > -1)
+		{
+			name = name.replace (/\>/, "");
+			selector = name;
+		}
+
+		return (selector);
+	}
+
+	/**
+	 * Wait for a number of milliseconds.
+	 */
+	async wait (numMilliseconds: number): Promise<void>
+	{
+		return (await new Promise ((resolve, reject) =>
+			{
+				setTimeout (() =>
+					{
+						resolve ();
+					}, numMilliseconds);
+			}));
+	}
+
+	/**
+	 * Print a message.
+	 */
+	async print (message: string): Promise<void>
+	{
+		process.stdout.write (message);
+	}
+
+	/**
+	 * Print a message line.
+	 */
+	async println (message: string): Promise<void>
+	{
+		await this.print (`${message}\n`);
+	}
+
+	/**
+	 * Disconnect this server or destroy anything associated with this HotTestDriver.
+	 */
+	abstract destroy (): Promise<void>;
+
+	/**
+	 * Navigate to a url.
+	 */
+	abstract navigateToUrl (url: string): Promise<void>;
+	/**
+	 * Wait for a HotTestElement to load.
+	 */
+	abstract waitForTestElement (name: string | HotTestElement, options?: HotTestElementOptions): Promise<any>;
+	/**
+	 * Find a HotTestElement to utilize.
+	 */
+	abstract findTestElement (name: string | HotTestElement, options?: HotTestElementOptions): Promise<any>;
+	/**
+	 * Run a HotTestElement command.
+	 */
+	abstract runCommand (testElm: string | HotTestElement, funcName?: string, valueStr?: string): Promise<any>;
+	/**
+	 * An expression to test.
+	 */
+	abstract assertElementValue (name: string | HotTestElement, value: any, 
+		errorMessage?: string, options?: HotTestElementOptions): Promise<any>;
+	/**
+	 * An expression to test.
+	 */
+	async assert (value: any, errorMessage: string = ""): Promise<any>
+	{
+		if (! (value))
+			throw new Error (errorMessage);
+	}
+
+	/**
+	 * Run a series of test elements.
+	 */
+	async run (executions: string[] | string[][]): Promise<any[]>
+	{
+		let results: any[] = [];
+
+		for (let iIdx = 0; iIdx < executions.length; iIdx++)
+		{
+			let execution: any = executions[iIdx];
+			let testElm: HotTestElement = null;
+			let func: string = "";
+			let value: string = "";
+
+			if (typeof (execution) === "string")
+			{
+				testElm = this.page.testElements[execution];
+
+				/// @fixme This is going to wreck selecting test elements by wildcards.
+				if (testElm == null)
+					throw new Error (`HotTestDriver: Unable to find test element ${execution}`);
+
+				func = testElm.func;
+				value = testElm.value;
+			}
+
+			if (execution instanceof Array)
+			{
+				let name: string = execution[0];
+				testElm = this.page.testElements[name];
+
+				// This null catch is specifically to help find wildcard test elements.
+				if (testElm == null)
+				{
+					testElm = new HotTestElement (name);
+					func = execution[1];
+					value = execution[2];
+				}
+				else
+				{
+					func = testElm.func;
+					value = testElm.value;
+
+					if (execution.length > 1)
+						func = execution[1];
+
+					if (execution.length > 2)
+						value = execution[2];
+				}
+			}
+
+			testElm.func = func;
+			testElm.value = value;
+
+			results.push (await this.runCommand (testElm));
+		}
+
+		return (results);
+	}
+}

package/src/HotTestElement.ts

@@ -0,0 +1,97 @@
+/**
+ * Hot test element options.
+ */
+export interface IHotTestElementOptions
+{
+	/**
+	 * Indicates that the test element must be visible in 
+	 * order to select it.
+	 */
+	mustBeVisible?: boolean;
+	/**
+	 * If the test element is missing, ignore the error. This 
+	 * will cause the rest of the function to return immediately 
+	 * without any exceptions being thrown.
+	 */
+	ignoreMissingElementError?: boolean;
+}
+
+/**
+ * Hot test element options.
+ */
+export class HotTestElementOptions implements IHotTestElementOptions
+{
+	/**
+	 * Indicates that the test element must be visible in 
+	 * order to select it.
+	 */
+	mustBeVisible: boolean;
+	/**
+	 * If the test element is missing, ignore the error. This 
+	 * will cause the rest of the function to return immediately 
+	 * without any exceptions being thrown.
+	 */
+	ignoreMissingElementError: boolean;
+
+	constructor (copy: IHotTestElementOptions = {})
+	{
+		this.mustBeVisible = copy.mustBeVisible || true;
+		this.ignoreMissingElementError = copy.ignoreMissingElementError || false;
+	}
+}
+
+/**
+ * A test element.
+ */
+export interface IHotTestElement
+{
+	/**
+	 * The name of the element.
+	 */
+	name: string;
+	/**
+	 * The name of the function to execute 
+	 * while executing the test.
+	 */
+	func?: string;
+	/**
+	 * The value to use.
+	 */
+	value?: any;
+}
+
+/**
+ * A test element.
+ */
+export class HotTestElement implements IHotTestElement
+{
+	/**
+	 * The name of the element.
+	 */
+	name: string;
+	/**
+	 * The name of the function to execute 
+	 * while executing the test.
+	 */
+	func: string;
+	/**
+	 * The value to use.
+	 */
+	value: any;
+
+	constructor (name: string | IHotTestElement, func: string = "", value: any = null)
+	{
+		if (typeof (name) === "string")
+		{
+			this.name = name;
+			this.func = func;
+			this.value = value;
+		}
+		else
+		{
+			this.name = name.name;
+			this.func = name.func || func;
+			this.value = name.value || value;
+		}
+	}
+}

package/src/HotTestMap.ts

@@ -0,0 +1,130 @@
+import { HotTestElement } from "./HotTestElement";
+import { HotTestDriver } from "./HotTestDriver";
+import { HotSiteMapPath } from "./HotStaq";
+
+/**
+ * Create a test path for later execution.
+ */
+export type HotTestPath = (driver: HotTestDriver, ...args: any) => Promise<any>;
+
+/**
+ * The destination to take in a map.
+ */
+export class HotTestDestination
+{
+	/**
+	 * The destination to take.
+	 */
+	destination: string;
+	/**
+	 * If set to true, this will automatically start executing it's 
+	 * tests when it's time.
+	 */
+	autoStart: boolean;
+
+	constructor (destination: string | HotTestDestination | HotSiteMapPath = "", autoStart: boolean = true)
+	{
+		if (typeof (destination) === "string")
+		{
+			this.destination = destination;
+			this.autoStart = autoStart;
+		}
+		else
+		{
+			if (destination instanceof HotTestDestination)
+			{
+				this.destination = destination.destination;
+				this.autoStart = destination.autoStart;
+			}
+			else
+			{
+				this.destination = destination.path;
+				this.autoStart = destination.autoStart;
+			}
+		}
+	}
+}
+
+/**
+ * A page containing only test related info.
+ */
+export interface HotTestPage
+{
+	/**
+	 * The elements to test on this map.
+	 */
+	testElements: { [name: string]: HotTestElement; };
+	/**
+	 * The test paths to test on this map.
+	 */
+	testPaths: { [name: string]: HotTestPath; };
+}
+
+/**
+ * Maps the paths that are taken to complete a test.
+ */
+export class HotTestMap
+{
+	/**
+	 * The order in which paths are to be taken. Each destination is a string 
+	 * in a type -> path order. The type could be either a page or api route. 
+	 * For example:
+	 * ```
+	 * [
+	 *      "page:signin_page -> signin_path",
+	 *      "page:account_page -> change_username_path",
+	 *      "page:account_page -> change_password_path",
+	 *      "page:account_page -> change_name_path -> change_address_path",
+	 * 		"page:account_page -> signout_path",
+	 * 		"api:account_api_route -> signout_route_method -> signout_test_path"
+	 * ]
+	 * ```
+	 * 
+	 * The first string to the left of the -> will always be the type, such as a 
+	 * page or an api route. Any strings to the right of the -> will be a path, even 
+	 * when chaining addtional ->'s.
+	 */
+	destinations: HotTestDestination[] | { [name: string]: HotTestDestination; };
+	/**
+	 * The order in which destinations are supposed to execute. This is 
+	 * ignored if the destinations are an array.
+	 */
+	destinationOrder: string[];
+	/**
+	 * The test pages to execute.
+	 */
+	pages: {
+			[name: string]: HotTestPage
+		};
+
+	constructor (destinations: string[] | HotTestDestination[] | { [name: string]: string | HotTestDestination; } = [], 
+		pages: { [name: string]: HotTestPage } = {}, destinationOrder: string[] = [])
+	{
+		// Go through and convert any strings into HotTestDestinations.
+		if (destinations instanceof Array)
+		{
+			this.destinations = [];
+
+			for (let iIdx = 0; iIdx < destinations.length; iIdx++)
+			{
+				let dest = destinations[iIdx];
+
+				this.destinations.push (new HotTestDestination (dest));
+			}
+		}
+		else
+		{
+			this.destinations = {};
+
+			for (let key in destinations)
+			{
+				let dest = destinations[key];
+
+				this.destinations[key] = new HotTestDestination (dest);
+			}
+		}
+
+		this.destinationOrder = destinationOrder;
+		this.pages = pages;
+	}
+}