Introduce CustomActions feature (closes #1535)

src/api/test-controller/add-message.ts

@@ -0,0 +1,17 @@
+import addRenderedWarning from '../../notifications/add-rendered-warning';
+import TestRun from '../../test-run';
+import TestCafeErrorList from '../../errors/error-list';
+
+export function addWarnings (callsiteSet: Set<Record<string, any>>, message: string, testRun: TestRun): void {
+    callsiteSet.forEach(callsite => {
+        addRenderedWarning(testRun.warningLog, message, callsite);
+        callsiteSet.delete(callsite);
+    });
+}
+
+export function addErrors (callsiteSet: Set<Record<string, any>>, ErrorClass: any, errList: TestCafeErrorList): void {
+    callsiteSet.forEach(callsite => {
+        errList.addError(new ErrorClass(callsite));
+        callsiteSet.delete(callsite);
+    });
+}

src/api/test-controller/assertion.ts

@@ -60,7 +60,7 @@ export default class Assertion {
             message = void 0;
         }
 
-        return this._testController._enqueueCommand(command, {
+        return this._testController.enqueueCommand(command, {
             assertionType: command.methodName,
             actual:        this._actual,
             expected:      assertionArgs.expected,

src/api/test-controller/custom-actions.ts

@@ -0,0 +1,47 @@
+import { getCallsiteForMethod } from '../../errors/get-callsite';
+import { RunCustomActionCommand } from '../../test-run/commands/actions';
+import { delegateAPI } from '../../utils/delegated-api';
+import { Dictionary } from '../../configuration/interfaces';
+import TestController from './index';
+import delegatedAPI from './delegated-api';
+
+export default class CustomActions {
+    private _testController: TestController;
+    private readonly _customActions: Dictionary<Function>;
+
+    constructor (testController: TestController, customActions: Dictionary<Function>) {
+        this._testController = testController;
+        this._customActions = customActions || {};
+
+        this._registerCustomActions();
+    }
+
+    _registerCustomActions (): void {
+        Object.entries(this._customActions).forEach(([ name, fn ]) => {
+            // @ts-ignore
+            this[delegatedAPI(name)] = (...args) => {
+                const callsite = getCallsiteForMethod(name) || void 0;
+
+                return this._testController.enqueueCommand(RunCustomActionCommand, { fn, args, name }, this._validateCommand, callsite);
+            };
+        });
+
+        this._delegateAPI(this._customActions);
+    }
+
+    _validateCommand (): boolean {
+        return true;
+    }
+
+    _delegateAPI (actions: Dictionary<Function>): void {
+        const customActionsList = Object.entries(actions).map(([name]) => {
+            return {
+                srcProp:  delegatedAPI(name),
+                apiProp:  name,
+                accessor: '',
+            };
+        });
+
+        delegateAPI(this, customActionsList, { useCurrentCtxAsHandler: true });
+    }
+}

src/api/test-controller/delegated-api.ts

@@ -0,0 +1,3 @@
+export default function delegatedAPI (methodName: string, accessor = ''): string {
+    return `_${ methodName }$${ accessor }`;
+}

src/api/test-controller/index.d.ts

@@ -9,7 +9,7 @@ export default class TestController {
     public constructor (testRun: TestRun | TestRunProxy);
     public testRun: TestRun;
     public warningLog: WarningLog;
-    public _enqueueCommand (CmdCtor: unknown, cmdArgs: object, validateCommand: Function): () => Promise<unknown>;
+    public enqueueCommand (CmdCtor: unknown, cmdArgs: object, validateCommand: Function, callsite?: CallsiteRecord): () => Promise<unknown>;
     public checkForExcessiveAwaits (checkedCallsite: CallsiteRecord, { actionId }: CommandBase): void;
     public static enableDebugForNonDebugCommands (): void;
     public static disableDebugForNonDebugCommands (): void;