@opentap/runner-client 2.4.6-alpha.1.1 → 2.5.0-alpha.1

package/lib/DTOs.d.ts

@@ -1168,3 +1168,88 @@ export declare class TestPlanSettingsChangedEventArgs extends SessionEvent imple
     toJSON(data?: any): any;
 }
 export declare type ITestPlanSettingsChangedEventArgs = ISessionEvent;
+export interface ITestStepRunEvent {
+    parent?: string;
+    testStepId?: string;
+    testStepName?: string;
+    testStepTypeName?: string;
+    id?: string;
+    verdict?: number;
+    startTime?: string;
+    parameters?: Parameter[];
+}
+export declare class TestStepRunEvent implements ITestStepRunEvent {
+    parent?: string;
+    testStepId?: string;
+    testStepName?: string;
+    testStepTypeName?: string;
+    id?: string;
+    verdict?: number;
+    startTime?: string;
+    parameters?: Parameter[];
+    protected _discriminator: string;
+    constructor(data?: ITestStepRunEvent);
+    init(_data?: any): void;
+    static fromJS(data: any): TestStepRunEvent;
+    toJSON(data?: any): any;
+}
+export declare type ITestStepRunStartEventArgs = ITestStepRunEvent;
+export declare class TestStepRunStartEventArgs extends TestStepRunEvent implements ITestStepRunStartEventArgs {
+    constructor(data?: ITestStepRunStartEventArgs);
+    init(_data?: any): void;
+    static fromJS(data: any): TestStepRunStartEventArgs;
+    toJSON(data?: any): any;
+}
+export declare type ITestStepRunCompletedEventArgs = ITestStepRunEvent;
+export declare class TestStepRunCompletedEventArgs extends TestStepRunEvent implements ITestStepRunCompletedEventArgs {
+    constructor(data?: ITestStepRunCompletedEventArgs);
+    init(_data?: any): void;
+    static fromJS(data: any): TestStepRunCompletedEventArgs;
+    toJSON(data?: any): any;
+}
+export interface ITestPlanRunEvent {
+    testPlanRunId?: number;
+    testPlanRunGuid?: string;
+    path?: string;
+    name?: string;
+    verdict?: string;
+    startTime?: string;
+    runner?: string;
+    status?: string;
+    isCampaign?: boolean;
+    operator?: string;
+}
+export declare class TestPlanRunEvent implements ITestPlanRunEvent {
+    testPlanRunId?: number;
+    testPlanRunGuid?: string;
+    path?: string;
+    name?: string;
+    verdict?: string;
+    startTime?: string;
+    runner?: string;
+    status?: string;
+    isCampaign?: boolean;
+    operator?: string;
+    protected _discriminator: string;
+    constructor(data?: ITestPlanRunEvent);
+    init(_data?: any): void;
+    static fromJS(data: any): TestPlanRunEvent;
+    toJSON(data?: any): any;
+}
+export declare type ITestPlanRunStartEventArgs = ITestPlanRunEvent;
+export declare class TestPlanRunStartEventArgs extends TestPlanRunEvent implements ITestPlanRunStartEventArgs {
+    constructor(data?: ITestPlanRunStartEventArgs);
+    init(_data?: any): void;
+    static fromJS(data: any): TestPlanRunStartEventArgs;
+    toJSON(data?: any): any;
+}
+export interface ITestPlanRunCompletedEventArgs extends ITestPlanRunEvent {
+    durationInSeconds?: number;
+}
+export declare class TestPlanRunCompletedEventArgs extends TestPlanRunEvent implements ITestPlanRunCompletedEventArgs {
+    durationInSeconds?: number;
+    constructor(data?: ITestPlanRunCompletedEventArgs);
+    init(_data?: any): void;
+    static fromJS(data: any): TestPlanRunCompletedEventArgs;
+    toJSON(data?: any): any;
+}

package/lib/DTOs.js

@@ -3392,3 +3392,224 @@ var TestPlanSettingsChangedEventArgs = /** @class */ (function (_super) {
     return TestPlanSettingsChangedEventArgs;
 }(SessionEvent));
 export { TestPlanSettingsChangedEventArgs };
+var TestStepRunEvent = /** @class */ (function () {
+    function TestStepRunEvent(data) {
+        if (data) {
+            for (var property in data) {
+                if (Object.prototype.hasOwnProperty.call(data, property))
+                    this[property] = data[property];
+            }
+        }
+        this._discriminator = 'TestStepRunEvent';
+    }
+    TestStepRunEvent.prototype.init = function (_data) {
+        if (_data) {
+            this.parent = _data['Parent'];
+            this.testStepId = _data['TestStepId'];
+            this.testStepName = _data['TestStepName'];
+            this.testStepTypeName = _data['TestStepTypeName'];
+            this.id = _data['Id'];
+            this.verdict = _data['Verdict'];
+            this.startTime = _data['StartTime'];
+            if (Array.isArray(_data['Parameters'])) {
+                this.parameters = [];
+                for (var _i = 0, _a = _data['Parameters']; _i < _a.length; _i++) {
+                    var item = _a[_i];
+                    this.parameters.push(Parameter.fromJS(item));
+                }
+            }
+        }
+    };
+    TestStepRunEvent.fromJS = function (data) {
+        data = typeof data === 'object' ? data : {};
+        if (data['discriminator'] === 'TestStepRunStartEventArgs') {
+            var result_39 = new TestStepRunStartEventArgs();
+            result_39.init(data);
+            return result_39;
+        }
+        if (data['discriminator'] === 'TestStepRunCompletedEventArgs') {
+            var result_40 = new TestStepRunCompletedEventArgs();
+            result_40.init(data);
+            return result_40;
+        }
+        var result = new TestStepRunEvent();
+        result.init(data);
+        return result;
+    };
+    TestStepRunEvent.prototype.toJSON = function (data) {
+        data['Parent'] = this.parent;
+        data['TestStepId'] = this.testStepId;
+        data['TestStepName'] = this.testStepName;
+        data['TestStepTypeName'] = this.testStepTypeName;
+        data['Id'] = this.id;
+        data['Verdict'] = this.verdict;
+        data['StartTime'] = this.startTime;
+        if (Array.isArray(this.parameters)) {
+            data['Parameters'] = [];
+            for (var _i = 0, _a = this.parameters; _i < _a.length; _i++) {
+                var item = _a[_i];
+                data['Parameters'].push(item.toJSON());
+            }
+        }
+        return data;
+    };
+    return TestStepRunEvent;
+}());
+export { TestStepRunEvent };
+var TestStepRunStartEventArgs = /** @class */ (function (_super) {
+    __extends(TestStepRunStartEventArgs, _super);
+    function TestStepRunStartEventArgs(data) {
+        var _this = _super.call(this, data) || this;
+        _this._discriminator = 'TestStepRunStartEventArgs';
+        return _this;
+    }
+    TestStepRunStartEventArgs.prototype.init = function (_data) {
+        _super.prototype.init.call(this, _data);
+    };
+    TestStepRunStartEventArgs.fromJS = function (data) {
+        data = typeof data === 'object' ? data : {};
+        var result = new TestStepRunStartEventArgs();
+        result.init(data);
+        return result;
+    };
+    TestStepRunStartEventArgs.prototype.toJSON = function (data) {
+        data = typeof data === 'object' ? data : {};
+        _super.prototype.toJSON.call(this, data);
+        return data;
+    };
+    return TestStepRunStartEventArgs;
+}(TestStepRunEvent));
+export { TestStepRunStartEventArgs };
+var TestStepRunCompletedEventArgs = /** @class */ (function (_super) {
+    __extends(TestStepRunCompletedEventArgs, _super);
+    function TestStepRunCompletedEventArgs(data) {
+        var _this = _super.call(this, data) || this;
+        _this._discriminator = 'TestStepRunCompletedEventArgs';
+        return _this;
+    }
+    TestStepRunCompletedEventArgs.prototype.init = function (_data) {
+        _super.prototype.init.call(this, _data);
+    };
+    TestStepRunCompletedEventArgs.fromJS = function (data) {
+        data = typeof data === 'object' ? data : {};
+        var result = new TestStepRunCompletedEventArgs();
+        result.init(data);
+        return result;
+    };
+    TestStepRunCompletedEventArgs.prototype.toJSON = function (data) {
+        data = typeof data === 'object' ? data : {};
+        _super.prototype.toJSON.call(this, data);
+        return data;
+    };
+    return TestStepRunCompletedEventArgs;
+}(TestStepRunEvent));
+export { TestStepRunCompletedEventArgs };
+var TestPlanRunEvent = /** @class */ (function () {
+    function TestPlanRunEvent(data) {
+        if (data) {
+            for (var property in data) {
+                if (Object.prototype.hasOwnProperty.call(data, property))
+                    this[property] = data[property];
+            }
+        }
+        this._discriminator = 'TestPlanRunEvent';
+    }
+    TestPlanRunEvent.prototype.init = function (_data) {
+        if (_data) {
+            this.testPlanRunId = _data['Run/TestPlanRunId'];
+            this.testPlanRunGuid = _data['Run/TestPlanRunGuid'];
+            this.path = _data['Run/Path'];
+            this.name = _data['Run/Name'];
+            this.verdict = _data['Run/Verdict'];
+            this.startTime = _data['Run/StartTime'];
+            this.runner = _data['Run/Runner'];
+            this.status = _data['Run/Status'];
+            this.isCampaign = _data['Run/IsCampaign'];
+            this.operator = _data['Run/Operator'];
+        }
+    };
+    TestPlanRunEvent.fromJS = function (data) {
+        data = typeof data === 'object' ? data : {};
+        if (data['discriminator'] === 'TestPlanRunStartEventArgs') {
+            var result_41 = new TestPlanRunStartEventArgs();
+            result_41.init(data);
+            return result_41;
+        }
+        if (data['discriminator'] === 'TestPlanRunCompletedEventArgs') {
+            var result_42 = new TestPlanRunCompletedEventArgs();
+            result_42.init(data);
+            return result_42;
+        }
+        var result = new TestPlanRunEvent();
+        result.init(data);
+        return result;
+    };
+    TestPlanRunEvent.prototype.toJSON = function (data) {
+        data = typeof data === 'object' ? data : {};
+        data['Run/TestPlanRunId'] = this.testPlanRunId;
+        data['Run/TestPlanRunGuid'] = this.testPlanRunGuid;
+        data['Run/Path'] = this.path;
+        data['Run/Name'] = this.name;
+        data['Run/Verdict'] = this.verdict;
+        data['Run/StartTime'] = this.startTime;
+        data['Run/Runner'] = this.runner;
+        data['Run/Status'] = this.status;
+        data['Run/IsCampaign'] = this.isCampaign;
+        data['Run/Operator'] = this.operator;
+        return data;
+    };
+    return TestPlanRunEvent;
+}());
+export { TestPlanRunEvent };
+var TestPlanRunStartEventArgs = /** @class */ (function (_super) {
+    __extends(TestPlanRunStartEventArgs, _super);
+    function TestPlanRunStartEventArgs(data) {
+        var _this = _super.call(this, data) || this;
+        _this._discriminator = 'TestPlanRunStartEventArgs';
+        return _this;
+    }
+    TestPlanRunStartEventArgs.prototype.init = function (_data) {
+        _super.prototype.init.call(this, _data);
+    };
+    TestPlanRunStartEventArgs.fromJS = function (data) {
+        data = typeof data === 'object' ? data : {};
+        var result = new TestPlanRunStartEventArgs();
+        result.init(data);
+        return result;
+    };
+    TestPlanRunStartEventArgs.prototype.toJSON = function (data) {
+        data = typeof data === 'object' ? data : {};
+        _super.prototype.toJSON.call(this, data);
+        return data;
+    };
+    return TestPlanRunStartEventArgs;
+}(TestPlanRunEvent));
+export { TestPlanRunStartEventArgs };
+var TestPlanRunCompletedEventArgs = /** @class */ (function (_super) {
+    __extends(TestPlanRunCompletedEventArgs, _super);
+    function TestPlanRunCompletedEventArgs(data) {
+        var _this = _super.call(this, data) || this;
+        _this._discriminator = 'TestPlanRunCompletedEventArgs';
+        return _this;
+    }
+    TestPlanRunCompletedEventArgs.prototype.init = function (_data) {
+        _super.prototype.init.call(this, _data);
+        if (_data) {
+            this.durationInSeconds = _data['Run/DurationInSeconds'];
+        }
+    };
+    TestPlanRunCompletedEventArgs.fromJS = function (data) {
+        data = typeof data === 'object' ? data : {};
+        var result = new TestPlanRunCompletedEventArgs();
+        result.init(data);
+        return result;
+    };
+    TestPlanRunCompletedEventArgs.prototype.toJSON = function (data) {
+        data = typeof data === 'object' ? data : {};
+        data['Run/DurationInSeconds'] = this.durationInSeconds;
+        _super.prototype.toJSON.call(this, data);
+        return data;
+    };
+    return TestPlanRunCompletedEventArgs;
+}(TestPlanRunEvent));
+export { TestPlanRunCompletedEventArgs };

package/lib/SystemClient.d.ts

@@ -1,5 +1,11 @@
 import { BaseClient } from './BaseClient';
 import { ConnectionOptions, Subscription, SubscriptionOptions } from 'nats.ws';
+import { ErrorResponse, TestPlanRunCompletedEventArgs, TestPlanRunStartEventArgs, TestStepRunCompletedEventArgs, TestStepRunStartEventArgs } from './DTOs';
+export interface RunnerLifetimeEvent {
+    RunnerId: string;
+    Subject: string;
+    Discriminator: string;
+}
 export declare class SystemClient extends BaseClient {
     constructor(baseSubject: string, options: ConnectionOptions);
     /**
@@ -8,5 +14,41 @@ export declare class SystemClient extends BaseClient {
      * @param {SubscriptionOptions} options
      * @returns {Subscription}
      */
-    subscribeLifetimeEventListener(listener: (...args: any[]) => void, options?: SubscriptionOptions): Subscription;
+    subscribeLifetimeEventListener(listener: (error: ErrorResponse | null, message: RunnerLifetimeEvent | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Subscribe to the test step run start events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test step run start events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    subscribeTestStepRunStartEventListener(runnerId: string, runId: string, listener: (error: ErrorResponse | null, message: TestStepRunStartEventArgs | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Subscribe to the test step run completed events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test step run completed events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    subscribeTestStepRunCompletedEventListener(runnerId: string, runId: string, listener: (error: ErrorResponse | null, message: TestStepRunCompletedEventArgs | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Subscribe to the test plan run start events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test plan run start events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    subscribeTestPlanRunStartEventListener(runnerId: string, runId: string, listener: (error: ErrorResponse | null, message: TestPlanRunStartEventArgs | null) => void, options?: SubscriptionOptions): Subscription;
+    /**
+     * Subscribe to the test plan run completed events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test plan run completed events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    subscribeTestPlanRunCompletedEventListener(runnerId: string, runId: string, listener: (error: ErrorResponse | null, message: TestPlanRunCompletedEventArgs | null) => void, options?: SubscriptionOptions): Subscription;
 }

package/lib/SystemClient.js

@@ -26,6 +26,7 @@ var __assign = (this && this.__assign) || function () {
 };
 import { BaseClient } from './BaseClient';
 import { JSONCodec } from 'nats.ws';
+import { TestPlanRunCompletedEventArgs, TestPlanRunStartEventArgs, TestStepRunCompletedEventArgs, TestStepRunStartEventArgs, } from './DTOs';
 var SystemClient = /** @class */ (function (_super) {
     __extends(SystemClient, _super);
     function SystemClient(baseSubject, options) {
@@ -39,18 +40,127 @@ var SystemClient = /** @class */ (function (_super) {
      */
     SystemClient.prototype.subscribeLifetimeEventListener = function (listener, options) {
         var _this = this;
-        return this.subscribe('*.Events.Lifetime', __assign(__assign({}, options), { callback: function (error, message) {
+        var subject = '*.Events.Lifetime';
+        return this.subscribe(subject, __assign(__assign({}, options), { callback: function (error, message) {
                 if (error) {
-                    listener(_this.natsErrorHandler(error, '*.Events.Lifetime'));
+                    listener(_this.natsErrorHandler(error, subject), null);
                     return;
                 }
                 try {
                     var jsonCodec = JSONCodec();
                     var data = jsonCodec.decode(message === null || message === void 0 ? void 0 : message.data);
-                    listener(data);
+                    listener(null, data);
                 }
                 catch (error) {
-                    listener(_this.natsErrorHandler(error, '*.Events.Lifetime'));
+                    listener(_this.natsErrorHandler(error, subject), null);
+                }
+            } }));
+    };
+    /**
+     * Subscribe to the test step run start events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test step run start events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    SystemClient.prototype.subscribeTestStepRunStartEventListener = function (runnerId, runId, listener, options) {
+        var _this = this;
+        var subject = "".concat(runnerId, ".Runs.").concat(runId, ".Events.TestStepRunStart");
+        return this.subscribe(subject, __assign(__assign({}, options), { callback: function (error, message) {
+                if (error) {
+                    listener(_this.natsErrorHandler(error, subject), null);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var testStepRunStartEventArgsJs = jsonCodec.decode(message === null || message === void 0 ? void 0 : message.data);
+                    var testStepRunStartEventArgs = TestStepRunStartEventArgs.fromJS(testStepRunStartEventArgsJs);
+                    listener(null, testStepRunStartEventArgs);
+                }
+                catch (error) {
+                    listener(_this.natsErrorHandler(error, subject), null);
+                }
+            } }));
+    };
+    /**
+     * Subscribe to the test step run completed events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test step run completed events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    SystemClient.prototype.subscribeTestStepRunCompletedEventListener = function (runnerId, runId, listener, options) {
+        var _this = this;
+        var subject = "".concat(runnerId, ".Runs.").concat(runId, ".Events.TestStepRunCompleted");
+        return this.subscribe(subject, __assign(__assign({}, options), { callback: function (error, message) {
+                if (error) {
+                    listener(_this.natsErrorHandler(error, subject), null);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var testStepRunCompletedEventArgsJs = jsonCodec.decode(message === null || message === void 0 ? void 0 : message.data);
+                    var testStepRunCompletedEventArgs = TestStepRunCompletedEventArgs.fromJS(testStepRunCompletedEventArgsJs);
+                    listener(null, testStepRunCompletedEventArgs);
+                }
+                catch (error) {
+                    listener(_this.natsErrorHandler(error, subject), null);
+                }
+            } }));
+    };
+    /**
+     * Subscribe to the test plan run start events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test plan run start events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    SystemClient.prototype.subscribeTestPlanRunStartEventListener = function (runnerId, runId, listener, options) {
+        var _this = this;
+        var subject = "".concat(runnerId, ".Runs.").concat(runId, ".Events.TestPlanRunStart");
+        return this.subscribe(subject, __assign(__assign({}, options), { callback: function (error, message) {
+                if (error) {
+                    listener(_this.natsErrorHandler(error, subject), null);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var testPlanRunStartEventArgsJs = jsonCodec.decode(message === null || message === void 0 ? void 0 : message.data);
+                    var testPlanRunStartEventArgs = TestPlanRunStartEventArgs.fromJS(testPlanRunStartEventArgsJs);
+                    listener(null, testPlanRunStartEventArgs);
+                }
+                catch (error) {
+                    listener(_this.natsErrorHandler(error, subject), null);
+                }
+            } }));
+    };
+    /**
+     * Subscribe to the test plan run completed events for the given Runner and Run ID.
+     * Wildcard can be used for the Runner or Run ID to receive all test plan run completed events.
+     * @param  {string} runnerId
+     * @param  {string} runId
+     * @param  {(error:ErrorResponse|null,message:TestStepRunStartEventArgs|null)=>void} listener
+     * @param  {SubscriptionOptions} options?
+     */
+    SystemClient.prototype.subscribeTestPlanRunCompletedEventListener = function (runnerId, runId, listener, options) {
+        var _this = this;
+        var subject = "".concat(runnerId, ".Runs.").concat(runId, ".Events.TestPlanRunCompleted");
+        return this.subscribe(subject, __assign(__assign({}, options), { callback: function (error, message) {
+                if (error) {
+                    listener(_this.natsErrorHandler(error, subject), null);
+                    return;
+                }
+                try {
+                    var jsonCodec = JSONCodec();
+                    var testPlanRunCompletedEventArgsJs = jsonCodec.decode(message === null || message === void 0 ? void 0 : message.data);
+                    var testPlanRunCompletedEventArgs = TestPlanRunCompletedEventArgs.fromJS(testPlanRunCompletedEventArgsJs);
+                    listener(null, testPlanRunCompletedEventArgs);
+                }
+                catch (error) {
+                    listener(_this.natsErrorHandler(error, subject), null);
                 }
             } }));
     };

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export { RunnerClient } from './RunnerClient';
 export { SessionClient } from './SessionClient';
-export { SystemClient } from './SystemClient';
+export { SystemClient, RunnerLifetimeEvent } from './SystemClient';
 export * from './DTOs';
 export * from 'nats.ws';

package/package.json

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