zation-assured 0.6.2 → 3.0.0-dev.3

package/dist/lib/helper/asserter/client/abstractClientAsserter.d.ts

@@ -1,42 +1,41 @@
 import { Test } from "../../test/test";
-import { DataboxOptions, Client } from 'zation-client';
-import { DataEventAsserter } from "../event/dataEventAsserter";
+import { DataboxOptions, Client, Databox, Channel } from 'zation-client';
 import { DataboxAsserter } from "../databox/databoxAsserter";
 import { ChannelAsserter } from "../channel/channelAsserter";
 import { ValueAsserter } from "../value/valueAsserter";
-export declare type Responder = (resp: (err?: (any | number), responseData?: any) => void, data: any) => void;
-export declare abstract class AbstractClientAsserter<T> {
+import { ClientAPI, ClientTokenPayload, Default } from "../../utils/types";
+export declare abstract class AbstractClientAsserter<T, C extends Client<any, any>> {
     protected _test: Test;
-    protected clients: Client[];
+    protected clients: C[];
     protected abstract self(): T;
-    protected constructor(clients: Client[], test: Test);
-    protected _forEachClient(func: (client: Client, i: number) => Promise<void>): Promise<void>;
+    protected constructor(clients: C[], test: Test);
+    protected _forEachClient(func: (client: C, i: number) => Promise<void>): Promise<void>;
     /**
      * @description
      * Asserts that the client is connected.
      * @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.
      */
     isConnected(timeout?: number): T;
     /**
      * @description
      * Asserts that the client is disconnected.
      * @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.
      */
     isDisconnected(timeout?: number): T;
     /**
      * @description
      * Asserts that the client is authenticated.
      * @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.
      */
     isAuthenticated(timeout?: number): T;
     /**
      * @description
      * Asserts that the client is deauthenticated.
      * @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.
      */
     isDeauthenticated(timeout?: number): T;
     /**
@@ -67,43 +66,26 @@ export declare abstract class AbstractClientAsserter<T> {
      * @description
      * Asserts the token payload of the client.
      */
-    tokenPayload(): ValueAsserter<T>;
+    tokenPayload(): ValueAsserter<ClientTokenPayload<C>, T>;
     /**
      * @description
-     * Assert databox.
+     * Create assertions on a databox of the client.
      * Will automatically connect (before the test) and disconnect (after the test) the databox.
      */
-    databox(identifier: string, member?: any, options?: DataboxOptions): DataboxAsserter<T>;
+    databox<DN extends keyof ClientAPI<C>['databoxes']>(identifier: DN, member?: Default<ClientAPI<C>['databoxes'][DN]['member'], string>, options?: DataboxOptions<ClientAPI<C>['databoxes'][DN]['options'], ClientAPI<C>['databoxes'][DN]['fetchInput']>): DataboxAsserter<T, Databox<ClientAPI<C>['databoxes'][DN]['content'], Default<ClientAPI<C>['databoxes'][DN]['member'], string>, ClientAPI<C>['databoxes'][DN]['options'], ClientAPI<C>['databoxes'][DN]['fetchInput']>>;
     /**
      * @description
-     * Assert channel.
+     * Create assertions on a channel of the client.
      * Will automatically subscribe (before the test) and unsubscribe (after the test) the channel.
      */
-    channel(identifier: string, member?: any): ChannelAsserter<T>;
+    channel<CN extends keyof ClientAPI<C>['channels']>(identifier: CN, member?: Default<ClientAPI<C>['channels'][CN]['member'], string>): ChannelAsserter<T, Channel<Default<ClientAPI<C>['channels'][CN]['member'], string>, Default<ClientAPI<C>['channels'][CN]['publishes'], Record<string, any>>>>;
     /**
      * @description
-     * This function lets you do extra actions on each 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.
+     * 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: (client: Client, index: number) => void | Promise<void>, message?: string): T;
-    /**
-     * @description
-     * This function lets you do extra actions on each 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.
-     * @param action
-     * @param message
-     * @param validErrorClasses
-     */
-    actionShouldThrow(action: (client: Client, index: number) => void | Promise<void>, message: string, ...validErrorClasses: any[]): T;
-    /**
-     * @description
-     * Asserts that the client should receive an emit-event from the server.
-     * It uses the custom zation event namespace
-     * (so you cannot have name conflicts with internal event names).
-     */
-    receiveEvent(event: string, responder?: Responder): DataEventAsserter<T>;
+    action(action: (client: C, index: number) => void | Promise<void>, failMsg?: string): T;
 }

package/dist/lib/helper/asserter/client/abstractClientAsserter.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); }); }
@@ -16,10 +16,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractClientAsserter = void 0;
 const assert = require('assert');
-const zation_client_1 = require("zation-client");
 const timeoutAssert_1 = require("../../timeout/timeoutAssert");
 const actionUtils_1 = require("../../utils/actionUtils");
-const dataEventAsserter_1 = require("../event/dataEventAsserter");
 const databoxAsserter_1 = require("../databox/databoxAsserter");
 const channelAsserter_1 = require("../channel/channelAsserter");
 const valueAsserter_1 = require("../value/valueAsserter");
@@ -30,11 +28,7 @@ class AbstractClientAsserter {
     }
     _forEachClient(func) {
         return __awaiter(this, void 0, void 0, function* () {
-            let promises = [];
-            this.clients.forEach((c, i) => {
-                promises.push(func(c, i));
-            });
-            yield Promise.all(promises);
+            yield Promise.all(this.clients.map((client, index) => func(client, index)));
         });
     }
     // noinspection JSUnusedGlobalSymbols
@@ -42,21 +36,18 @@ class AbstractClientAsserter {
      * @description
      * Asserts that the client is connected.
      * @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.
      */
     isConnected(timeout = 0) {
-        this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            yield this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
-                if (c.isConnected()) {
-                    return;
-                }
-                const toa = new timeoutAssert_1.TimeoutAssert(`Client: ${i} should be connected.`, timeout);
-                c.eventReact().onceConnect(() => {
-                    toa.resolve();
-                });
-                yield toa.set();
-            }));
-        }));
+        this._test.test(() => this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
+            if (c.connected)
+                return;
+            const toa = new timeoutAssert_1.TimeoutAssert(`Client: ${i} should be connected.`, timeout);
+            c.onceConnect(() => {
+                toa.resolve();
+            });
+            yield toa.set();
+        })));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
@@ -64,21 +55,18 @@ class AbstractClientAsserter {
      * @description
      * Asserts that the client is disconnected.
      * @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.
      */
     isDisconnected(timeout = 0) {
-        this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            yield this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
-                if (!c.isConnected()) {
-                    return;
-                }
-                const toa = new timeoutAssert_1.TimeoutAssert(`Client: ${i} should be disconnected.`, timeout);
-                c.eventReact().onceDisconnect(() => {
-                    toa.resolve();
-                });
-                yield toa.set();
-            }));
-        }));
+        this._test.test(() => this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
+            if (!c.connected)
+                return;
+            const toa = new timeoutAssert_1.TimeoutAssert(`Client: ${i} should be disconnected.`, timeout);
+            c.onceDisconnect(() => {
+                toa.resolve();
+            });
+            yield toa.set();
+        })));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
@@ -86,21 +74,18 @@ class AbstractClientAsserter {
      * @description
      * Asserts that the client is authenticated.
      * @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.
      */
     isAuthenticated(timeout = 0) {
-        this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            yield this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
-                if (c.isAuthenticated()) {
-                    return;
-                }
-                const toa = new timeoutAssert_1.TimeoutAssert(`Client: ${i} should be authenticated.`, timeout);
-                c.eventReact().onceAuthenticate(() => {
-                    toa.resolve();
-                });
-                yield toa.set();
-            }));
-        }));
+        this._test.test(() => this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
+            if (c.authenticated)
+                return;
+            const toa = new timeoutAssert_1.TimeoutAssert(`Client: ${i} should be authenticated.`, timeout);
+            c.onceAuthenticate(() => {
+                toa.resolve();
+            });
+            yield toa.set();
+        })));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
@@ -108,21 +93,18 @@ class AbstractClientAsserter {
      * @description
      * Asserts that the client is deauthenticated.
      * @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.
      */
     isDeauthenticated(timeout = 0) {
-        this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            yield this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
-                if (!c.isAuthenticated()) {
-                    return;
-                }
-                const toa = new timeoutAssert_1.TimeoutAssert(`Client: ${i} should be deauthenticated.`, timeout);
-                c.eventReact().onceDeauthenticate(() => {
-                    toa.resolve();
-                });
-                yield toa.set();
-            }));
-        }));
+        this._test.test(() => this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
+            if (!c.authenticated)
+                return;
+            const toa = new timeoutAssert_1.TimeoutAssert(`Client: ${i} should be deauthenticated.`, timeout);
+            c.onceDeauthenticate(() => {
+                toa.resolve();
+            });
+            yield toa.set();
+        })));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
@@ -133,17 +115,13 @@ class AbstractClientAsserter {
      * If it is not given it will assert that the client has any user id.
      */
     hasUserId(userId) {
-        this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            yield this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
-                const currentId = c.userId;
-                if (userId !== undefined) {
-                    assert.equal(currentId, userId, `Client: ${i} should have the userId: ${userId}`);
-                }
-                else if (currentId === undefined) {
-                    assert.fail(`Client: ${i} should have any user id.`);
-                }
-            }));
-        }));
+        this._test.test(() => this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
+            const currentId = c.userId;
+            if (userId != null)
+                assert.equal(currentId, userId, `Client: ${i} should have the userId: ${userId}`);
+            else if (currentId == null)
+                assert.fail(`Client: ${i} should have any user id.`);
+        })));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
@@ -154,17 +132,14 @@ class AbstractClientAsserter {
      * If it is not given it will assert that the client has any authUserGroup.
      */
     hasAuthUserGroup(authUserGroup) {
-        this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            yield this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
-                const currentGroup = c.authUserGroup;
-                if (authUserGroup !== undefined) {
-                    assert.equal(currentGroup, authUserGroup, `Client: ${i} should have the authUserGroup: ${authUserGroup}`);
-                }
-                else if (currentGroup === undefined) {
-                    assert.fail(`Client: ${i} should have any authUserGroup.`);
-                }
-            }));
-        }));
+        this._test.test(() => this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
+            const currentGroup = c.authUserGroup;
+            if (authUserGroup != null) {
+                assert.equal(currentGroup, authUserGroup, `Client: ${i} should have the authUserGroup: ${authUserGroup}`);
+            }
+            else if (currentGroup == null)
+                assert.fail(`Client: ${i} should have any authUserGroup.`);
+        })));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
@@ -173,22 +148,10 @@ class AbstractClientAsserter {
      * Asserts that the client has a specific token id.
      */
     hasTokenId(tokenId) {
-        this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            yield this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const currentTokenId = c.tokenId;
-                    assert.equal(currentTokenId, tokenId, `Client: ${i} should have the tokenId: ${tokenId}`);
-                }
-                catch (e) {
-                    if (e instanceof zation_client_1.AuthenticationRequiredError) {
-                        assert.fail(`Client: ${i} can not access the token for assert token id.`);
-                    }
-                    else {
-                        throw e;
-                    }
-                }
-            }));
-        }));
+        this._test.test(() => this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            assert.equal((_a = c.authToken) === null || _a === void 0 ? void 0 : _a.tid, tokenId, `Client: ${i} should have the tokenId: ${tokenId}`);
+        })));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
@@ -197,22 +160,10 @@ class AbstractClientAsserter {
      * Asserts that the client has panel access.
      */
     hasPanelAccess(access = true) {
-        this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-            yield this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const currentAccess = c.hasPanelAccess();
-                    assert.equal(currentAccess, access, `Client: ${i} should ${access ? '' : 'not'} have panel access`);
-                }
-                catch (e) {
-                    if (e instanceof zation_client_1.AuthenticationRequiredError) {
-                        assert.fail(`Client: ${i} can not access the token for assert panel access.`);
-                    }
-                    else {
-                        throw e;
-                    }
-                }
-            }));
-        }));
+        this._test.test(() => this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            assert.equal((_a = c.authToken) === null || _a === void 0 ? void 0 : _a.panelAccess, access, `Client: ${i} should ${access ? '' : 'not'} have panel access`);
+        })));
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
@@ -221,27 +172,16 @@ class AbstractClientAsserter {
      * Asserts the token payload of the client.
      */
     tokenPayload() {
-        return new valueAsserter_1.ValueAsserter(this.self(), 'Client:', (test) => {
-            this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-                yield this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        test(c.getTokenPayload(), ` ${i} Token:`);
-                    }
-                    catch (e) {
-                        if (e instanceof zation_client_1.AuthenticationRequiredError) {
-                            assert.fail(`Client: ${i} token payload can not be asserted because the client is not authenticated.`);
-                        }
-                        else
-                            throw e;
-                    }
-                }));
-            }));
+        return new valueAsserter_1.ValueAsserter(this.self(), (test) => {
+            this._test.test(() => this._forEachClient((c, i) => __awaiter(this, void 0, void 0, function* () {
+                test(c.authTokenPayload, `Client: ${i} token payload:`);
+            })));
         });
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert databox.
+     * Create assertions on a databox of the client.
      * Will automatically connect (before the test) and disconnect (after the test) the databox.
      */
     databox(identifier, member, options = {}) {
@@ -252,12 +192,10 @@ class AbstractClientAsserter {
                     yield db.connect(member);
                 }
                 catch (err) {
-                    assert.fail("Cannot connect the databox. Error -> " + err.stack);
+                    assert.fail("Cannot connect the databox. Error -> " + err);
                 }
             }));
-            this._test.afterTest(() => __awaiter(this, void 0, void 0, function* () {
-                yield db.disconnect();
-            }));
+            this._test.afterTest(() => db.disconnect());
             return db;
         });
         return new databoxAsserter_1.DataboxAsserter(databoxes, this._test, this.self());
@@ -265,7 +203,7 @@ class AbstractClientAsserter {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert channel.
+     * Create assertions on a channel of the client.
      * Will automatically subscribe (before the test) and unsubscribe (after the test) the channel.
      */
     channel(identifier, member) {
@@ -276,12 +214,10 @@ class AbstractClientAsserter {
                     yield channel.subscribe(member);
                 }
                 catch (err) {
-                    assert.fail("Cannot subscribe to the channel. Error -> " + err.stack);
+                    assert.fail("Cannot subscribe to the channel. Error -> " + err);
                 }
             }));
-            this._test.afterTest(() => {
-                channel.unsubscribe();
-            });
+            this._test.afterTest(() => channel.unsubscribe());
             return channel;
         });
         return new channelAsserter_1.ChannelAsserter(channels, this._test, this.self());
@@ -289,54 +225,16 @@ class AbstractClientAsserter {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * This function lets you do extra actions on each 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) {
-        this.clients.forEach((client, index) => {
-            actionUtils_1.default.action(this._test, () => action(client, index), message);
-        });
-        this._test.pushSyncWait();
-        return this.self();
-    }
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * @description
-     * This function lets you do extra actions on each 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) {
-        this.clients.forEach((client, index) => {
-            actionUtils_1.default.actionShouldThrow(this._test, () => action(client, index), message, ...validErrorClasses);
-        });
+    action(action, failMsg) {
+        this._test.test(() => this._forEachClient((client, index) => actionUtils_1.default.runAction(() => action(client, index), failMsg)));
         this._test.pushSyncWait();
         return this.self();
     }
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * @description
-     * Asserts that the client should receive an emit-event from the server.
-     * It uses the custom zation event namespace
-     * (so you cannot have name conflicts with internal event names).
-     */
-    receiveEvent(event, responder = (resp) => {
-        resp(null);
-    }) {
-        return new dataEventAsserter_1.DataEventAsserter(this.clients.map(c => {
-            return (listener) => {
-                c.once(event, (data, response) => {
-                    listener(data);
-                    responder(response, data);
-                });
-            };
-        }), "Client", event, this._test, this.self());
-    }
 }
 exports.AbstractClientAsserter = AbstractClientAsserter;

package/dist/lib/helper/asserter/client/clientAsserter.d.ts

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

package/dist/lib/helper/asserter/client/clientAsserter.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.ClientAsserter = void 0;

package/dist/lib/helper/asserter/client/standaloneClientAsserter.d.ts

@@ -1,16 +1,16 @@
 import { Client } from 'zation-client';
 import { AbstractClientAsserter } from "./abstractClientAsserter";
-export declare class StandaloneClientAsserter extends AbstractClientAsserter<StandaloneClientAsserter> {
-    constructor(client: Client | Client[], itTestDescription?: string);
+export declare class StandaloneClientAsserter<C extends Client<any, any>> extends AbstractClientAsserter<StandaloneClientAsserter<C>, C> {
+    constructor(client: C | C[], description?: string);
     /**
      * @description
-     * Will connect all clients (before the test).
+     * Connects all clients (before the test).
      */
-    connect(): StandaloneClientAsserter;
+    connect(): StandaloneClientAsserter<C>;
     /**
      * @description
-     * Run the test.
+     * Runs the test.
      */
     test(): Promise<void>;
-    protected self(): StandaloneClientAsserter;
+    protected self(): StandaloneClientAsserter<C>;
 }

package/dist/lib/helper/asserter/client/standaloneClientAsserter.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 abstractClientAsserter_1 = require("./abstractClientAsserter");
 const test_1 = require("../../test/test");
 const chai_1 = require("chai");
 class StandaloneClientAsserter extends abstractClientAsserter_1.AbstractClientAsserter {
-    constructor(client, itTestDescription) {
-        super(Array.isArray(client) ? client : [client], new test_1.Test(itTestDescription));
+    constructor(client, description) {
+        super(Array.isArray(client) ? client : [client], new test_1.Test(description));
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Will connect all clients (before the test).
+     * Connects all clients (before the test).
      */
     connect() {
         this._test.beforeTest(() => __awaiter(this, void 0, void 0, function* () {
@@ -34,7 +34,7 @@ class StandaloneClientAsserter extends abstractClientAsserter_1.AbstractClientAs
                     yield client.connect();
                 }
                 catch (err) {
-                    chai_1.assert.fail(`Cannot connect the client ${index}. Error -> ` + err.stack);
+                    chai_1.assert.fail(`Cannot connect the client ${index}. Error -> ` + err);
                 }
             })));
         }));
@@ -43,7 +43,7 @@ class StandaloneClientAsserter extends abstractClientAsserter_1.AbstractClientAs
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Run the test.
+     * Runs the test.
      */
     test() {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/lib/helper/asserter/controller/integratedResponseAsserter.d.ts

@@ -0,0 +1,52 @@
+import { Client, Response, BackErrorFilter } from "zation-client";
+import { Test } from "../../test/test";
+import { ValueAsserter } from "../value/valueAsserter";
+import { BackErrorsFilterBuilder } from "../../backError/backErrorsFilterBuilder";
+import { AbstractActionAsserter } from "../abstractActionAsserter";
+import { ResponseData } from "../../utils/types";
+export declare class IntegratedResponseAsserter<R extends Response<any>, C extends Client<any, any>> extends AbstractActionAsserter<IntegratedResponseAsserter<R, C>, C> {
+    private readonly sendRequest;
+    private readonly responseAsserters;
+    constructor(sendRequest: () => Promise<R>, test: Test, client: C);
+    protected _executeAction(): Promise<void>;
+    private _respInfo;
+    /**
+     * @description
+     * Asserts that the response is successful.
+     */
+    isSuccessful(): IntegratedResponseAsserter<R, C>;
+    /**
+     * @description
+     * Asserts that the response is not successful.
+     */
+    isNotSuccessful(): IntegratedResponseAsserter<R, C>;
+    /**
+     * @description
+     * Asserts that the response has a result.
+     */
+    hasResult(): IntegratedResponseAsserter<R, C>;
+    /**
+     * @description
+     * Asserts the result of the response.
+     */
+    result(): ValueAsserter<ResponseData<R>, IntegratedResponseAsserter<R, C>>;
+    /**
+     * @description
+     * Asserts that the response has specific errors with a BackErrorFilterBuilder.
+     */
+    hasError(): BackErrorsFilterBuilder<IntegratedResponseAsserter<R, C>>;
+    /**
+     * @description
+     * Asserts that the response has specific errors with a raw filter.
+     * @param filter
+     * Queric filter to filter for specific errors.
+     */
+    hasError(filter: BackErrorFilter): IntegratedResponseAsserter<R, C>;
+    /**
+     * @description
+     * Creates a custom assertion.
+     * @param assert
+     */
+    assert(assert: (resp: R) => void | Promise<void>): IntegratedResponseAsserter<R, C>;
+    protected self(): IntegratedResponseAsserter<R, C>;
+}