zation-assured 0.6.3 → 3.0.0-dev.1

package/dist/lib/helper/asserter/abstractActionAsserter.d.ts

@@ -0,0 +1,68 @@
+import { Channel, Databox, Client } from "zation-client";
+import { Test } from "../test/test";
+import { WhenBuilder } from "../../api/when";
+import { ClientAsserter } from "./client/clientAsserter";
+import { DataboxAsserter } from "./databox/databoxAsserter";
+import { ChannelAsserter } from "./channel/channelAsserter";
+export declare abstract class AbstractActionAsserter<T, C extends Client<any, any>> {
+    protected readonly _test: Test;
+    protected readonly _client: C;
+    private _shouldThrowTimeoutError;
+    protected constructor(test: Test, client: C);
+    protected abstract _executeAction(): Promise<void>;
+    private _createTest;
+    /**
+     * @description
+     * Asserts that the when action should not throw or throw a TimeoutError.
+     * @param assertion
+     */
+    throwsTimeoutError(assertion?: boolean): T;
+    /**
+     * @description
+     * Runs a extra test action and asserts that no error will be thrown.
+     * AssertionErrors will be rethrown, and all other errors will fail
+     * the test with the provided message or the concrete error.
+     * @param action
+     * @param failMsg If not provided, the concrete error is used.
+     */
+    action(action: (client: C) => void | Promise<void>, failMsg?: string): T;
+    /**
+     * @description
+     * Start with a new when and link them to one test.
+     */
+    get and(): WhenBuilder<C>;
+    /**
+     * @description
+     * Create assertions on the client.
+     */
+    client(): ClientAsserter<T, C>;
+    /**
+     * @description
+     * Create assertions on other clients.
+     * Notice that this method will not automatically connect the clients.
+     */
+    otherClients<C extends Client<any, any>>(...clients: C[]): ClientAsserter<T, C>;
+    /**
+     * @description
+     * Create assertions on other databoxes.
+     * Notice that this method will not automatically connect the databoxes.
+     */
+    otherDataboxes<D extends Databox<any, any, any, any>>(...databoxes: D[]): DataboxAsserter<T, D>;
+    /**
+     * @description
+     * Create assertions on other channels.
+     * Notice that this method will not automatically subscribe to the channels.
+     */
+    otherChannels<C extends Channel<any, any>>(...channels: C[]): ChannelAsserter<T, C>;
+    /**
+     * @description
+     * Runs the test.
+     */
+    test(): Promise<void>;
+    /**
+     * @description
+     * Returns self.
+     * For fluent programing with inheritance.
+     */
+    protected abstract self(): T;
+}

package/dist/lib/helper/asserter/{rootSendAsserter.js → abstractActionAsserter.js}

@@ -1,8 +1,8 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -14,7 +14,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RootSendAsserter = void 0;
+exports.AbstractActionAsserter = void 0;
 const zation_client_1 = require("zation-client");
 const when_1 = require("../../api/when");
 const clientAsserter_1 = require("./client/clientAsserter");
@@ -22,39 +22,24 @@ const actionUtils_1 = require("../utils/actionUtils");
 const databoxAsserter_1 = require("./databox/databoxAsserter");
 const channelAsserter_1 = require("./channel/channelAsserter");
 const assert = require('assert');
-class RootSendAsserter {
+class AbstractActionAsserter {
     constructor(test, client) {
-        this.autoConnectedClient = false;
         this._shouldThrowTimeoutError = false;
-        this._shouldThrowConnectionRequiredError = false;
         this._test = test;
         this._client = client;
         this._createTest();
     }
     _createTest() {
         this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            if (!this._client.isConnected() && this.autoConnectedClient) {
-                yield this._client.connect();
-            }
             try {
                 yield this._executeAction();
-                if (this._shouldThrowTimeoutError) {
+                if (this._shouldThrowTimeoutError)
                     assert.fail('Send should throw a timeout error.');
-                }
-                if (this._shouldThrowConnectionRequiredError) {
-                    assert.fail('Send should throw a connection required error.');
-                }
             }
             catch (e) {
                 if (e instanceof zation_client_1.TimeoutError) {
-                    if (!this._shouldThrowTimeoutError) {
+                    if (!this._shouldThrowTimeoutError)
                         assert.fail('Send should not throw a timeout error.');
-                    }
-                }
-                else if (e instanceof zation_client_1.ConnectionRequiredError) {
-                    if (!this._shouldThrowConnectionRequiredError) {
-                        assert.fail('Send should not throw a connection required error.');
-                    }
                 }
                 else
                     throw e;
@@ -65,49 +50,24 @@ class RootSendAsserter {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Asserts that send should throw a timeout error.
-     * @param value
-     */
-    throwsTimeoutError(value = true) {
-        this._shouldThrowTimeoutError = value;
-        return this.self();
-    }
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * @description
-     * Asserts that send should throw a connection required error.
-     * @param value
+     * Asserts that the when action should not throw or throw a TimeoutError.
+     * @param assertion
      */
-    throwsConnectionRequiredError(value = true) {
-        this._shouldThrowConnectionRequiredError = value;
-        return this.self();
-    }
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * @description
-     * This function lets you do an extra action on the client and asserts that no error is thrown.
-     * When an error throws, it lets the test fail with the provided message or the concrete error.
-     * @param action
-     * @param message if not provided it throws the specific error.
-     */
-    action(action, message) {
-        actionUtils_1.default.action(this._test, () => action(this._client), message);
-        this._test.pushSyncWait();
+    throwsTimeoutError(assertion = true) {
+        this._shouldThrowTimeoutError = assertion;
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * This function lets you do an extra action on the client and
-     * asserts that an error or an error instance of a specific class is thrown.
-     * When no error is thrown, or the error does not match with the given classes
-     * (only if at least one class is given), it lets the test fail with the provided message.
+     * Runs a extra test action and asserts that no error will be thrown.
+     * AssertionErrors will be rethrown, and all other errors will fail
+     * the test with the provided message or the concrete error.
      * @param action
-     * @param message
-     * @param validErrorClasses
+     * @param failMsg If not provided, the concrete error is used.
      */
-    actionShouldThrow(action, message, ...validErrorClasses) {
-        actionUtils_1.default.actionShouldThrow(this._test, () => action(this._client), message, ...validErrorClasses);
+    action(action, failMsg) {
+        this._test.test(() => actionUtils_1.default.runAction(() => action(this._client), failMsg));
         this._test.pushSyncWait();
         return this.self();
     }
@@ -116,14 +76,14 @@ class RootSendAsserter {
      * @description
      * Start with a new when and link them to one test.
      */
-    and() {
+    get and() {
         this._test.newSubTest();
         return new when_1.WhenBuilder(this._client, this._test);
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert client.
+     * Create assertions on the client.
      */
     client() {
         return new clientAsserter_1.ClientAsserter([this._client], this._test, this.self());
@@ -131,7 +91,7 @@ class RootSendAsserter {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert other clients.
+     * Create assertions on other clients.
      * Notice that this method will not automatically connect the clients.
      */
     otherClients(...clients) {
@@ -140,7 +100,7 @@ class RootSendAsserter {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert other databoxes.
+     * Create assertions on other databoxes.
      * Notice that this method will not automatically connect the databoxes.
      */
     otherDataboxes(...databoxes) {
@@ -149,7 +109,7 @@ class RootSendAsserter {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert other channels.
+     * Create assertions on other channels.
      * Notice that this method will not automatically subscribe to the channels.
      */
     otherChannels(...channels) {
@@ -159,15 +119,11 @@ class RootSendAsserter {
     /**
      * @description
      * Runs the test.
-     * @param autoConnect
-     * Will auto connect the client
-     * if the client is not connected to the server.
      */
-    test(autoConnect = false) {
+    test() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.autoConnectedClient = autoConnect;
             return this._test.execute();
         });
     }
 }
-exports.RootSendAsserter = RootSendAsserter;
+exports.AbstractActionAsserter = AbstractActionAsserter;

package/dist/lib/helper/asserter/assertStarter.d.ts

@@ -0,0 +1,5 @@
+export default class AssertStarter<T> {
+    private readonly asserter;
+    constructor(asserter: T);
+    get assertThat(): T;
+}

package/dist/lib/helper/asserter/assertStarter.js

@@ -0,0 +1,16 @@
+"use strict";
+/*
+Author: Ing. Luca Gian Scaringella
+GitHub: LucaCode
+Copyright(c) Ing. Luca Gian Scaringella
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+class AssertStarter {
+    constructor(asserter) {
+        this.asserter = asserter;
+    }
+    get assertThat() {
+        return this.asserter;
+    }
+}
+exports.default = AssertStarter;

package/dist/lib/helper/asserter/channel/abstractChannelAsserter.d.ts

@@ -1,64 +1,55 @@
 import { Test } from "../../test/test";
-import { Channel } from 'zation-client';
+import { Channel, DataType } from 'zation-client';
 import { DataEventAsserter } from "../event/dataEventAsserter";
 import { ValueAsserter } from "../value/valueAsserter";
-import { CodeDataEventAsserter } from "../event/codeDataEventAsserter";
-export declare abstract class AbstractChannelAsserter<T> {
+import { CodeMetadataEventAsserter } from "../event/codeMetadataEventAsserter";
+import { ChannelEvents, ChannelMember } from "../../utils/types";
+export declare abstract class AbstractChannelAsserter<T, C extends Channel<any, any>> {
     protected _test: Test;
-    protected channels: Channel[];
+    protected channels: C[];
     protected abstract self(): T;
-    protected constructor(channels: Channel[], test: Test);
-    protected _forEachChannel(func: (channel: Channel, i: number) => Promise<void>): Promise<void>;
+    protected constructor(channels: C[], test: Test);
+    protected _forEachChannel(func: (channel: C, i: number) => Promise<void>): Promise<void>;
     /**
      * @description
      * Asserts that the channel is subscribed.
      * @param timeout
-     * With this parameter, you can set a time limit in that the assertion must be successful.
+     * Sets a time limit in that the assertion must be successful.
      */
     isSubscribed(timeout?: number): T;
     /**
      * @description
      * Asserts that the channel is unsubscribed.
      * @param timeout
-     * With this parameter, you can set a time limit in that the assertion must be successful.
+     * Sets a time limit in that the assertion must be successful.
      */
     isUnsubscribed(timeout?: number): T;
     /**
      * Asserts the current member of the channel.
      */
-    member(): ValueAsserter<T>;
+    member(): ValueAsserter<ChannelMember<C>, T>;
     /**
      * @description
-     * This function lets you do extra actions on each channel and asserts that no error is thrown.
-     * When an error throws, it lets the test fail with the provided message or the concrete error.
+     * Runs a extra test action and asserts that no error will be thrown.
+     * AssertionErrors will be rethrown, and all other errors will fail
+     * the test with the provided message or the concrete error.
      * @param action
-     * @param message if not provided it throws the specific error.
+     * @param failMsg If not provided, the concrete error is used.
      */
-    action(action: (channel: Channel, index: number) => void | Promise<void>, message?: string): T;
-    /**
-     * @description
-     * This function lets you do extra actions on each channel and
-     * asserts that an error or an error instance of a specific class is thrown.
-     * When no error is thrown, or the error does not match with the given classes
-     * (only if at least one class is given), it lets the test fail with the provided message.
-     * @param action
-     * @param message
-     * @param validErrorClasses
-     */
-    actionShouldThrow(action: (channel: Channel, index: number) => void | Promise<void>, message: string, ...validErrorClasses: any[]): T;
+    action(action: (channel: C, index: number) => void | Promise<void>, failMsg?: string): T;
     /**
      * @description
      * Asserts that the channel should get a publish.
      */
-    getsPublish(event: string): DataEventAsserter<T>;
+    getsPublish<E extends keyof ChannelEvents<C>>(event: E): DataEventAsserter<T, [ChannelEvents<C>[E], DataType], 0>;
     /**
      * @description
-     * Asserts that the channel should trigger an Close event.
+     * Asserts that the channel should trigger an close event.
      */
-    closeTriggers(): CodeDataEventAsserter<T>;
+    closeTriggers(): CodeMetadataEventAsserter<T, [number | string | undefined, any], 0, 1>;
     /**
      * @description
-     * Asserts that the channel should trigger an KickOut event.
+     * Asserts that the channel should trigger an kick out event.
      */
-    kickOutTriggers(): CodeDataEventAsserter<T>;
+    kickOutTriggers(): CodeMetadataEventAsserter<T, [number | string | undefined, any], 0, 1>;
 }

package/dist/lib/helper/asserter/channel/abstractChannelAsserter.js

@@ -1,8 +1,8 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -19,7 +19,7 @@ const timeoutAssert_1 = require("../../timeout/timeoutAssert");
 const actionUtils_1 = require("../../utils/actionUtils");
 const dataEventAsserter_1 = require("../event/dataEventAsserter");
 const valueAsserter_1 = require("../value/valueAsserter");
-const codeDataEventAsserter_1 = require("../event/codeDataEventAsserter");
+const codeMetadataEventAsserter_1 = require("../event/codeMetadataEventAsserter");
 class AbstractChannelAsserter {
     constructor(channels, test) {
         this._test = test;
@@ -27,11 +27,7 @@ class AbstractChannelAsserter {
     }
     _forEachChannel(func) {
         return __awaiter(this, void 0, void 0, function* () {
-            let promises = [];
-            this.channels.forEach((c, i) => {
-                promises.push(func(c, i));
-            });
-            yield Promise.all(promises);
+            yield Promise.all(this.channels.map((ch, i) => func(ch, i)));
         });
     }
     // noinspection JSUnusedGlobalSymbols
@@ -39,20 +35,18 @@ class AbstractChannelAsserter {
      * @description
      * Asserts that the channel is subscribed.
      * @param timeout
-     * With this parameter, you can set a time limit in that the assertion must be successful.
+     * Sets a time limit in that the assertion must be successful.
      */
     isSubscribed(timeout = 0) {
-        this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            yield this._forEachChannel((ch, i) => __awaiter(this, void 0, void 0, function* () {
-                if (ch.isSubscribed(false))
-                    return;
-                const toa = new timeoutAssert_1.TimeoutAssert(`Channel: ${i} should be subscribed.`, timeout);
-                ch.onceSubscribe(() => {
-                    toa.resolve();
-                });
-                yield toa.set();
-            }));
-        }));
+        this._test.test(() => this._forEachChannel((ch, i) => __awaiter(this, void 0, void 0, function* () {
+            if (ch.isSubscribed(false))
+                return;
+            const toa = new timeoutAssert_1.TimeoutAssert(`Channel: ${i} should be subscribed.`, timeout);
+            ch.onceSubscribe(() => {
+                toa.resolve();
+            });
+            yield toa.set();
+        })));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
@@ -60,20 +54,18 @@ class AbstractChannelAsserter {
      * @description
      * Asserts that the channel is unsubscribed.
      * @param timeout
-     * With this parameter, you can set a time limit in that the assertion must be successful.
+     * Sets a time limit in that the assertion must be successful.
      */
     isUnsubscribed(timeout = 0) {
-        this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            yield this._forEachChannel((ch, i) => __awaiter(this, void 0, void 0, function* () {
-                if (!ch.isSubscribed(false))
-                    return;
-                const toa = new timeoutAssert_1.TimeoutAssert(`Channel: ${i} should be unsubscribed.`, timeout);
-                ch.onceUnsubscribe(() => {
-                    toa.resolve();
-                });
-                yield toa.set();
-            }));
-        }));
+        this._test.test(() => this._forEachChannel((ch, i) => __awaiter(this, void 0, void 0, function* () {
+            if (!ch.isSubscribed(false))
+                return;
+            const toa = new timeoutAssert_1.TimeoutAssert(`Channel: ${i} should be unsubscribed.`, timeout);
+            ch.onceUnsubscribe(() => {
+                toa.resolve();
+            });
+            yield toa.set();
+        })));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
@@ -81,44 +73,23 @@ class AbstractChannelAsserter {
      * Asserts the current member of the channel.
      */
     member() {
-        return new valueAsserter_1.ValueAsserter(this.self(), 'Channel', (test) => {
-            this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-                yield this._forEachChannel((ch, i) => __awaiter(this, void 0, void 0, function* () {
-                    test(ch.member, ` ${i} channel:`);
-                }));
-            }));
+        return new valueAsserter_1.ValueAsserter(this.self(), (test) => {
+            this._test.test(() => this._forEachChannel((ch, i) => __awaiter(this, void 0, void 0, function* () {
+                test(ch.member, `Channel: ${i} member:`);
+            })));
         });
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * This function lets you do extra actions on each channel and asserts that no error is thrown.
-     * When an error throws, it lets the test fail with the provided message or the concrete error.
+     * Runs a extra test action and asserts that no error will be thrown.
+     * AssertionErrors will be rethrown, and all other errors will fail
+     * the test with the provided message or the concrete error.
      * @param action
-     * @param message if not provided it throws the specific error.
+     * @param failMsg If not provided, the concrete error is used.
      */
-    action(action, message) {
-        this.channels.forEach((channel, index) => {
-            actionUtils_1.default.action(this._test, () => action(channel, index), message);
-        });
-        this._test.pushSyncWait();
-        return this.self();
-    }
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * @description
-     * This function lets you do extra actions on each channel and
-     * asserts that an error or an error instance of a specific class is thrown.
-     * When no error is thrown, or the error does not match with the given classes
-     * (only if at least one class is given), it lets the test fail with the provided message.
-     * @param action
-     * @param message
-     * @param validErrorClasses
-     */
-    actionShouldThrow(action, message, ...validErrorClasses) {
-        this.channels.forEach((channel, index) => {
-            actionUtils_1.default.actionShouldThrow(this._test, () => action(channel, index), message, ...validErrorClasses);
-        });
+    action(action, failMsg) {
+        this._test.test(() => this._forEachChannel((channel, index) => actionUtils_1.default.runAction(() => action(channel, index), failMsg)));
         this._test.pushSyncWait();
         return this.self();
     }
@@ -129,40 +100,28 @@ class AbstractChannelAsserter {
      */
     getsPublish(event) {
         return new dataEventAsserter_1.DataEventAsserter(this.channels.map(ch => {
-            return (listener) => {
-                ch.oncePublish(event, (data) => {
-                    listener(data);
-                });
-            };
-        }), "Channel", `Publish - ${event}`, this._test, this.self());
+            return (listener) => ch.oncePublish(event, listener);
+        }), "channel", `publish - ${event}`, this._test, this.self(), 0);
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Asserts that the channel should trigger an Close event.
+     * Asserts that the channel should trigger an close event.
      */
     closeTriggers() {
-        return new codeDataEventAsserter_1.CodeDataEventAsserter(this.channels.map(ch => {
-            return (listener) => {
-                ch.onceClose((code, data) => {
-                    listener(data, code);
-                });
-            };
-        }), "Channel", "Close", this._test, this.self());
+        return new codeMetadataEventAsserter_1.CodeMetadataEventAsserter(this.channels.map(ch => {
+            return (listener) => ch.onceClose(listener);
+        }), "Channel", "close", this._test, this.self(), 0, 1);
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Asserts that the channel should trigger an KickOut event.
+     * Asserts that the channel should trigger an kick out event.
      */
     kickOutTriggers() {
-        return new codeDataEventAsserter_1.CodeDataEventAsserter(this.channels.map(ch => {
-            return (listener) => {
-                ch.onceKickOut((code, data) => {
-                    listener(data, code);
-                });
-            };
-        }), "Channel", "KickOut", this._test, this.self());
+        return new codeMetadataEventAsserter_1.CodeMetadataEventAsserter(this.channels.map(ch => {
+            return (listener) => ch.onceKickOut(listener);
+        }), "Channel", "kick out", this._test, this.self(), 0, 1);
     }
 }
 exports.AbstractChannelAsserter = AbstractChannelAsserter;

package/dist/lib/helper/asserter/channel/channelAsserter.d.ts

@@ -1,13 +1,13 @@
 import { Channel } from 'zation-client';
 import { Test } from "../../test/test";
 import { AbstractChannelAsserter } from "./abstractChannelAsserter";
-export declare class ChannelAsserter<T> extends AbstractChannelAsserter<ChannelAsserter<T>> {
+export declare class ChannelAsserter<T, C extends Channel<any, any>> extends AbstractChannelAsserter<ChannelAsserter<T, C>, C> {
     private readonly _source;
-    constructor(channels: Channel[], test: Test, source: T);
+    constructor(channels: C[], test: Test, source: T);
     /**
      * @description
      * End the channel asserter.
      */
     end(): T;
-    protected self(): ChannelAsserter<T>;
+    protected self(): ChannelAsserter<T, C>;
 }

package/dist/lib/helper/asserter/channel/channelAsserter.js

@@ -1,8 +1,8 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelAsserter = void 0;

package/dist/lib/helper/asserter/channel/standaloneChannelAsserter.d.ts

@@ -1,16 +1,16 @@
 import { Channel } from 'zation-client';
 import { AbstractChannelAsserter } from "./abstractChannelAsserter";
-export declare class StandaloneChannelAsserter extends AbstractChannelAsserter<StandaloneChannelAsserter> {
-    constructor(channel: Channel | Channel[], itTestDescription?: string);
+export declare class StandaloneChannelAsserter<C extends Channel<any, any>> extends AbstractChannelAsserter<StandaloneChannelAsserter<C>, C> {
+    constructor(channel: C | C[], description?: string);
     /**
      * @description
-     * Will subscribe all channels (before the test).
+     * Subscribes all channels (before the test).
      */
-    subscribe(member?: any): StandaloneChannelAsserter;
+    subscribe(member?: any): StandaloneChannelAsserter<C>;
     /**
      * @description
      * Run the test.
      */
     test(): Promise<void>;
-    protected self(): StandaloneChannelAsserter;
+    protected self(): StandaloneChannelAsserter<C>;
 }

package/dist/lib/helper/asserter/channel/standaloneChannelAsserter.js

@@ -1,8 +1,8 @@
 "use strict";
 /*
-Author: Luca Scaringella
+Author: Ing. Luca Gian Scaringella
 GitHub: LucaCode
-©Copyright by Luca Scaringella
+Copyright(c) Ing. Luca Gian Scaringella
  */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -19,13 +19,13 @@ const test_1 = require("../../test/test");
 const abstractChannelAsserter_1 = require("./abstractChannelAsserter");
 const chai_1 = require("chai");
 class StandaloneChannelAsserter extends abstractChannelAsserter_1.AbstractChannelAsserter {
-    constructor(channel, itTestDescription) {
-        super(Array.isArray(channel) ? channel : [channel], new test_1.Test(itTestDescription));
+    constructor(channel, description) {
+        super(Array.isArray(channel) ? channel : [channel], new test_1.Test(description));
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Will subscribe all channels (before the test).
+     * Subscribes all channels (before the test).
      */
     subscribe(member) {
         this._test.beforeTest(() => __awaiter(this, void 0, void 0, function* () {
@@ -34,7 +34,7 @@ class StandaloneChannelAsserter extends abstractChannelAsserter_1.AbstractChanne
                     yield channel.subscribe(member);
                 }
                 catch (err) {
-                    chai_1.assert.fail(`Cannot subscribe to the channel ${index}. Error -> ` + err.stack);
+                    chai_1.assert.fail(`Cannot subscribe to the channel ${index}. Error -> ` + err);
                 }
             })));
         }));