@opentap/runner-client 2.18.0 → 2.19.0-alpha.1.10

package/lib/DTOs.d.ts

@@ -1205,6 +1205,36 @@ export declare class TestPlanSettingsChangedEventArgs extends SessionEvent imple
     toJSON(data?: any): any;
 }
 export declare type ITestPlanSettingsChangedEventArgs = ISessionEvent;
+export interface IOnTestPlanRun {
+    status?: string;
+    userId?: string;
+}
+export declare class OnTestPlanRun implements IOnTestPlanRun {
+    status?: string;
+    userId?: string;
+    constructor(data?: IOnTestPlanRun);
+    init(_data?: any): void;
+    static fromJS(data: any): OnTestPlanRun;
+    toJSON(data?: any): any;
+}
+export interface IOnTestStepRun {
+    status?: string;
+    stepId?: string;
+    parentRunId?: string;
+    verdict?: string;
+    duration?: string;
+}
+export declare class OnTestStepRun implements IOnTestStepRun {
+    status?: string;
+    stepId?: string;
+    parentRunId?: string;
+    verdict?: string;
+    duration?: string;
+    constructor(data?: IOnTestStepRun);
+    init(_data?: any): void;
+    static fromJS(data: any): OnTestStepRun;
+    toJSON(data?: any): any;
+}
 export interface ITestStepRunEvent {
     parent?: string;
     testStepId?: string;

package/lib/DTOs.js

@@ -3507,6 +3507,72 @@ var TestPlanSettingsChangedEventArgs = /** @class */ (function (_super) {
     return TestPlanSettingsChangedEventArgs;
 }(SessionEvent));
 export { TestPlanSettingsChangedEventArgs };
+var OnTestPlanRun = /** @class */ (function () {
+    function OnTestPlanRun(data) {
+        if (data) {
+            for (var property in data) {
+                if (Object.prototype.hasOwnProperty.call(data, property))
+                    this[property] = data[property];
+            }
+        }
+    }
+    OnTestPlanRun.prototype.init = function (_data) {
+        if (_data) {
+            this.status = _data['Status'];
+            this.userId = _data['UserId'];
+        }
+    };
+    OnTestPlanRun.fromJS = function (data) {
+        data = typeof data === 'object' ? data : {};
+        var result = new OnTestPlanRun();
+        result.init(data);
+        return result;
+    };
+    OnTestPlanRun.prototype.toJSON = function (data) {
+        data = typeof data === 'object' ? data : {};
+        data['Status'] = this.status;
+        data['UserId'] = this.userId;
+        return data;
+    };
+    return OnTestPlanRun;
+}());
+export { OnTestPlanRun };
+var OnTestStepRun = /** @class */ (function () {
+    function OnTestStepRun(data) {
+        if (data) {
+            for (var property in data) {
+                if (Object.prototype.hasOwnProperty.call(data, property))
+                    this[property] = data[property];
+            }
+        }
+    }
+    OnTestStepRun.prototype.init = function (_data) {
+        if (_data) {
+            this.status = _data['Status'];
+            this.stepId = _data['StepId'];
+            this.parentRunId = _data['ParentRunId'];
+            this.verdict = _data['Verdict'];
+            this.duration = _data['Duration'];
+        }
+    };
+    OnTestStepRun.fromJS = function (data) {
+        data = typeof data === 'object' ? data : {};
+        var result = new OnTestStepRun();
+        result.init(data);
+        return result;
+    };
+    OnTestStepRun.prototype.toJSON = function (data) {
+        data = typeof data === 'object' ? data : {};
+        data['Status'] = this.status;
+        data['StepId'] = this.stepId;
+        data['ParentRunId'] = this.parentRunId;
+        data['Verdict'] = this.verdict;
+        data['Duration'] = this.duration;
+        return data;
+    };
+    return OnTestStepRun;
+}());
+export { OnTestStepRun };
 var TestStepRunEvent = /** @class */ (function () {
     function TestStepRunEvent(data) {
         if (data) {

package/lib/SessionClient.d.ts

@@ -1,4 +1,4 @@
-import { BreakPoints, CommonContext, CommonSettings, DataGridControl, Image, Interaction, ListItemType, LogList, Parameter, RepositoryPackageDefinition, RepositoryPackageReference, Result, Resource, RunStatus, SessionEvent, Setting, TestPlan, TestRun, TestStepType, TestStepValidationError, WatchDog } from './DTOs';
+import { BreakPoints, CommonContext, CommonSettings, DataGridControl, Image, Interaction, ListItemType, LogList, OnTestPlanRun, OnTestStepRun, Parameter, RepositoryPackageDefinition, RepositoryPackageReference, Resource, Result, RunStatus, SessionEvent, Setting, TestPlan, TestRun, TestStepType, TestStepValidationError, WatchDog } from './DTOs';
 import { ConnectionOptions, NatsError, Subscription, SubscriptionOptions } from 'nats.ws';
 import { BaseClient } from './BaseClient';
 export declare class SessionClient extends BaseClient {
@@ -23,6 +23,64 @@ export declare class SessionClient extends BaseClient {
      * @returns Subscription array: Result and Test Run subscriptions
      */
     connectSessionResults(resultHandler: (result: Result | undefined, err: NatsError | Error | null) => void, testRunHandler: (testRun: TestRun | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): [Subscription, Subscription];
+    /**
+     * @param testRunHandler Function to be called when test run or error is received
+     * @param options (optional) Subscription options
+     * @returns Subscription array: Result and Test Run subscriptions
+     */
+    connectTestRunEvents(testRunHandler: (testRun: TestRun | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the TestPlanRun events for the given test plan run ID.
+     * @param  {string} testPlanRunId
+     * @param  {(event:OnTestPlanRun|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestPlanRunEvents(testPlanRunId: string, handler: (event: OnTestPlanRun | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the test plan run logs for the given test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {(logList:LogList|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestPlanRunLogs(testPlanRunId: string, handler: (logList: LogList | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the test plan run parameter events for the given test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {(event:Parameter[]|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestPlanRunParameterEvents(testPlanRunId: string, handler: (event: Parameter[] | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the test step run events for the given test step and test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {string} testStepRunId
+     * @param  {(testRun:OnTestStepRun|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestStepRunEvents(testPlanRunId: string, testStepRunId: string, handler: (testStepRunId: string | undefined, testRun: OnTestStepRun | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the test step run parameters for the given test step and test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {string} testStepRunId
+     * @param  {(event:Parameter[]|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestStepRunParameterEvents(testPlanRunId: string, testStepRunId: string, handler: (event: Parameter[] | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Connect to listen to the test step run results for the given test step and test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {string} testStepRunId
+     * @param  {string} resultName
+     * @param  {(result:Result|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    connectTestStepRunResults(testPlanRunId: string, testStepRunId: string, resultName: string, handler: (result: Result | undefined, err: NatsError | Error | null) => void, options?: SubscriptionOptions): Subscription;
     /**
      * Unsubscibe from session events
      */

package/lib/SessionClient.js

@@ -24,7 +24,7 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { BreakPoints, CommonContext, CommonSettings, DataGridControl, Image, Interaction, ListItemType, LogList, Result, RunStatus, SessionEvent, Setting, TestPlan, TestRun, TestStepType, TestStepValidationError, WatchDog, } from './DTOs';
+import { BreakPoints, CommonContext, CommonSettings, DataGridControl, Image, Interaction, ListItemType, LogList, OnTestPlanRun, OnTestStepRun, Parameter, Result, RunStatus, SessionEvent, Setting, TestPlan, TestRun, TestStepType, TestStepValidationError, WatchDog, } from './DTOs';
 import { JSONCodec } from 'nats.ws';
 import { BaseClient } from './BaseClient';
 var SessionClient = /** @class */ (function (_super) {
@@ -120,6 +120,178 @@ var SessionClient = /** @class */ (function (_super) {
                 } })),
         ];
     };
+    /**
+     * @param testRunHandler Function to be called when test run or error is received
+     * @param options (optional) Subscription options
+     * @returns Subscription array: Result and Test Run subscriptions
+     */
+    SessionClient.prototype.connectTestRunEvents = function (testRunHandler, options) {
+        return this.subscribe('OnTestRun', __assign(__assign({}, options), { callback: function (error, encodedMessage) {
+                if (error) {
+                    testRunHandler(undefined, error);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var testRunJs = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
+                    var testRun = TestRun.fromJS(testRunJs);
+                    testRunHandler(testRun, error);
+                }
+                catch (error) {
+                    testRunHandler(undefined, error);
+                }
+            } }));
+    };
+    /**
+     * Connect to listen to the TestPlanRun events for the given test plan run ID.
+     * @param  {string} testPlanRunId
+     * @param  {(event:OnTestPlanRun|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    SessionClient.prototype.connectTestPlanRunEvents = function (testPlanRunId, handler, options) {
+        return this.subscribe("PlanRun.".concat(testPlanRunId), __assign(__assign({}, options), { callback: function (error, encodedMessage) {
+                if (error) {
+                    handler(undefined, error);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var onTestPlanRunJs = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
+                    var onTestPlanRun = OnTestPlanRun.fromJS(onTestPlanRunJs);
+                    handler(onTestPlanRun, error);
+                }
+                catch (error) {
+                    handler(undefined, error);
+                }
+            } }));
+    };
+    /**
+     * Connect to listen to the test plan run logs for the given test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {(logList:LogList|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    SessionClient.prototype.connectTestPlanRunLogs = function (testPlanRunId, handler, options) {
+        return this.subscribe("PlanRun.".concat(testPlanRunId, ".Logs"), __assign(__assign({}, options), { callback: function (error, encodedMessage) {
+                if (error) {
+                    handler(undefined, error);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var logListJson = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
+                    var logList = LogList.fromJS(logListJson);
+                    handler(logList, error);
+                }
+                catch (error) {
+                    handler(undefined, error);
+                }
+            } }));
+    };
+    /**
+     * Connect to listen to the test plan run parameter events for the given test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {(event:Parameter[]|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    SessionClient.prototype.connectTestPlanRunParameterEvents = function (testPlanRunId, handler, options) {
+        return this.subscribe("PlanRun.".concat(testPlanRunId, ".Parameters"), __assign(__assign({}, options), { callback: function (error, encodedMessage) {
+                if (error) {
+                    handler(undefined, error);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var parameterListJs = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
+                    var parameterList = parameterListJs.map(function (parameterJs) { return Parameter.fromJS(parameterJs); });
+                    handler(parameterList, error);
+                }
+                catch (error) {
+                    handler(undefined, error);
+                }
+            } }));
+    };
+    /**
+     * Connect to listen to the test step run events for the given test step and test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {string} testStepRunId
+     * @param  {(testRun:OnTestStepRun|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    SessionClient.prototype.connectTestStepRunEvents = function (testPlanRunId, testStepRunId, handler, options) {
+        return this.subscribe("PlanRun.".concat(testPlanRunId, ".StepRun.").concat(testStepRunId), __assign(__assign({}, options), { callback: function (error, encodedMessage) {
+                var _a;
+                if (error) {
+                    handler(undefined, undefined, error);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var onTestStepRunJs = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
+                    var onTestStepRun = OnTestStepRun.fromJS(onTestStepRunJs);
+                    var stepRunId = (_a = encodedMessage.subject.match(/\.StepRun\.(.+)$/)) === null || _a === void 0 ? void 0 : _a[1];
+                    handler(stepRunId, onTestStepRun, error);
+                }
+                catch (error) {
+                    handler(undefined, undefined, error);
+                }
+            } }));
+    };
+    /**
+     * Connect to listen to the test step run parameters for the given test step and test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {string} testStepRunId
+     * @param  {(event:Parameter[]|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    SessionClient.prototype.connectTestStepRunParameterEvents = function (testPlanRunId, testStepRunId, handler, options) {
+        return this.subscribe("PlanRun.".concat(testPlanRunId, ".StepRun.").concat(testStepRunId, ".Parameters"), __assign(__assign({}, options), { callback: function (error, encodedMessage) {
+                if (error) {
+                    handler(undefined, error);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var parameterListJs = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
+                    var parameterList = parameterListJs.map(function (parameterJs) { return Parameter.fromJS(parameterJs); });
+                    handler(parameterList, error);
+                }
+                catch (error) {
+                    handler(undefined, error);
+                }
+            } }));
+    };
+    /**
+     * Connect to listen to the test step run results for the given test step and test plan run ID
+     * @param  {string} testPlanRunId
+     * @param  {string} testStepRunId
+     * @param  {string} resultName
+     * @param  {(result:Result|undefined,err:NatsError|Error|null)=>void} handler
+     * @param  {SubscriptionOptions} options?
+     * @returns Subscription
+     */
+    SessionClient.prototype.connectTestStepRunResults = function (testPlanRunId, testStepRunId, resultName, handler, options) {
+        return this.subscribe("PlanRun.".concat(testPlanRunId, ".StepRun.").concat(testStepRunId, ".Result.").concat(resultName), __assign(__assign({}, options), { callback: function (error, encodedMessage) {
+                if (error) {
+                    handler(undefined, error);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var resultJs = jsonCodec.decode(encodedMessage === null || encodedMessage === void 0 ? void 0 : encodedMessage.data);
+                    var result = Result.fromJS(resultJs);
+                    handler(result, error);
+                }
+                catch (error) {
+                    handler(undefined, error);
+                }
+            } }));
+    };
     /**
      * Unsubscibe from session events
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentap/runner-client",
-  "version": "2.18.0",
+  "version": "2.19.0-alpha.1.10",
   "description": "This is the web client for the OpenTAP Runner.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",