zation-assured 0.5.1 → 3.0.0-dev.1

package/dist/lib/helper/asserter/databox/abstractDataboxAsserter.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,8 +19,9 @@ 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");
 const chai_1 = require("chai");
+const forint_1 = require("forint");
 class AbstractDataboxAsserter {
     constructor(databoxes, test) {
         this._test = test;
@@ -28,23 +29,19 @@ class AbstractDataboxAsserter {
     }
     _forEachDatabox(func) {
         return __awaiter(this, void 0, void 0, function* () {
-            let promises = [];
-            this.databoxes.forEach((c, i) => {
-                promises.push(func(c, i));
-            });
-            yield Promise.all(promises);
+            yield Promise.all(this.databoxes.map((db, i) => func(db, i)));
         });
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert that the databox is connected.
+     * Asserts that the databox 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._forEachDatabox((d, i) => __awaiter(this, void 0, void 0, function* () {
+            return this._forEachDatabox((d, i) => __awaiter(this, void 0, void 0, function* () {
                 if (d.isConnected())
                     return;
                 const toa = new timeoutAssert_1.TimeoutAssert(`Databox: ${i} should be connected.`, timeout);
@@ -59,13 +56,13 @@ class AbstractDataboxAsserter {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert that the databox is disconnected.
+     * Asserts that the databox 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._forEachDatabox((d, i) => __awaiter(this, void 0, void 0, function* () {
+            return this._forEachDatabox((d, i) => __awaiter(this, void 0, void 0, function* () {
                 if (!d.isConnected())
                     return;
                 const toa = new timeoutAssert_1.TimeoutAssert(`Databox: ${i} should be disconnected.`, timeout);
@@ -79,28 +76,20 @@ class AbstractDataboxAsserter {
     }
     // noinspection JSUnusedGlobalSymbols
     /**
-     * Assert the current data of the databox.
+     * Asserts the current data of the databox.
      */
     data() {
-        return new valueAsserter_1.ValueAsserter(this.self(), 'Databox', (test) => {
-            this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-                yield this._forEachDatabox((d, i) => __awaiter(this, void 0, void 0, function* () {
-                    test(d.data, ` ${i} data:`);
-                }));
-            }));
+        return new valueAsserter_1.ValueAsserter(this.self(), (test) => {
+            this._test.test(() => this._forEachDatabox((d, i) => test(d.data, `Databox: ${i} data:`)));
         });
     }
     // noinspection JSUnusedGlobalSymbols
     /**
-     * Assert the current member of the databox.
+     * Asserts the current member of the databox.
      */
     member() {
-        return new valueAsserter_1.ValueAsserter(this.self(), 'Databox', (test) => {
-            this._test.test(() => __awaiter(this, void 0, void 0, function* () {
-                yield this._forEachDatabox((d, i) => __awaiter(this, void 0, void 0, function* () {
-                    test(d.member, ` ${i} member:`);
-                }));
-            }));
+        return new valueAsserter_1.ValueAsserter(this.self(), (test) => {
+            this._test.test(() => this._forEachDatabox((d, i) => test(d.member, `Databox: ${i} member:`)));
         });
     }
     // noinspection JSUnusedGlobalSymbols
@@ -117,7 +106,7 @@ class AbstractDataboxAsserter {
                             yield databox.fetch(fetchData);
                         }
                         catch (err) {
-                            chai_1.assert.fail(`Databox ${number} fetch ${i} failed. Error -> ` + err.stack);
+                            chai_1.assert.fail(`Databox: ${number} fetch ${i} failed. Error -> ` + err);
                         }
                     }))());
                 }
@@ -130,101 +119,76 @@ class AbstractDataboxAsserter {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * This function lets you do extra actions on each databox 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.databoxes.forEach((databox, index) => {
-            actionUtils_1.default.action(this._test, () => action(databox, index), message);
-        });
-        this._test.pushSyncWait();
-        return this.self();
-    }
-    // noinspection JSUnusedGlobalSymbols
-    /**
-     * @description
-     * This function lets you do extra actions on each databox 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.databoxes.forEach((databox, index) => {
-            actionUtils_1.default.actionShouldThrow(this._test, () => action(databox, index), message, ...validErrorClasses);
-        });
+    action(action, failMsg) {
+        this._test.test(() => this._forEachDatabox((databox, index) => actionUtils_1.default.runAction(() => action(databox, index), failMsg)));
         this._test.pushSyncWait();
         return this.self();
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert that the databox should trigger an DataChange event.
-     * It is also possible to assert only in case of specific data event reasons.
+     * Asserts that the databox should trigger an data change event.
+     * It is also possible to filter for specific data event reasons with a forint query.
      */
-    dataChangeTriggers(...reasons) {
+    dataChangeTriggers(reasonFilter) {
+        const filter = reasonFilter ? (0, forint_1.default)(reasonFilter) : () => true;
         return new dataEventAsserter_1.DataEventAsserter(this.databoxes.map(d => {
             return (listener) => {
                 let handler;
-                d.onDataChange(handler = (data, triggerReasons) => {
-                    if (reasons.length === 0 || (triggerReasons.findIndex(r => reasons.indexOf(r) !== -1) !== -1)) {
+                d.onDataChange(handler = (data, reason, storage) => {
+                    if (filter(reason)) {
                         d.offDataChange(handler);
-                        listener(data);
+                        listener(data, reason, storage);
                     }
                 });
             };
-        }), "Databox", "DataChange", this._test, this.self(), ((reasons.length > 0) ? ` with any of these reasons: [${reasons}]` : ''));
+        }), "Databox", "data change", this._test, this.self(), 0, ((reasonFilter) ? ` with reasons that match the filter: ${reasonFilter}` : ''));
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert that the databox should trigger an DataTouch event.
-     * It is also possible to assert only in case of specific data event reasons.
+     * Asserts that the databox should trigger an data touch event.
+     * It is also possible to filter for specific data event reasons with a forint query.
      */
-    dataTouchTriggers(...reasons) {
+    dataTouchTriggers(reasonFilter) {
+        const filter = reasonFilter ? (0, forint_1.default)(reasonFilter) : () => true;
         return new dataEventAsserter_1.DataEventAsserter(this.databoxes.map(d => {
             return (listener) => {
                 let handler;
-                d.onDataTouch(handler = (data, triggerReasons) => {
-                    if (reasons.length === 0 || (triggerReasons.findIndex(r => reasons.indexOf(r) !== -1) !== -1)) {
+                d.onDataTouch(handler = (data, reason, storage) => {
+                    if (filter(reason)) {
                         d.offDataTouch(handler);
-                        listener(data);
+                        listener(data, reason, storage);
                     }
                 });
             };
-        }), "Databox", "DataTouch", this._test, this.self(), ((reasons.length > 0) ? ` with any of these reasons: [${reasons}]` : ''));
+        }), "Databox", "data touch", this._test, this.self(), 0, ((reasonFilter) ? ` with reasons that match the filter: ${reasonFilter}` : ''));
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert that the databox should trigger an Close event.
+     * Asserts that the databox should trigger an close event.
      */
     closeTriggers() {
-        return new codeDataEventAsserter_1.CodeDataEventAsserter(this.databoxes.map(d => {
-            return (listener) => {
-                d.onceClose((code, data) => {
-                    listener(data, code);
-                });
-            };
-        }), "Databox", "Close", this._test, this.self());
+        return new codeMetadataEventAsserter_1.CodeMetadataEventAsserter(this.databoxes.map(d => {
+            return (listener) => d.onceClose(listener);
+        }), "Databox", "close", this._test, this.self(), 0, 1);
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Assert that the databox should trigger an KickOut event.
+     * Asserts that the databox should trigger an kick out event.
      */
     kickOutTriggers() {
-        return new codeDataEventAsserter_1.CodeDataEventAsserter(this.databoxes.map(d => {
-            return (listener) => {
-                d.onceKickOut((code, data) => {
-                    listener(data, code);
-                });
-            };
-        }), "Databox", "KickOut", this._test, this.self());
+        return new codeMetadataEventAsserter_1.CodeMetadataEventAsserter(this.databoxes.map(d => {
+            return (listener) => d.onceKickOut(listener);
+        }), "Databox", "kick out", this._test, this.self(), 0, 1);
     }
 }
 exports.AbstractDataboxAsserter = AbstractDataboxAsserter;

package/dist/lib/helper/asserter/databox/databoxAsserter.d.ts

@@ -1,13 +1,13 @@
 import { Databox } from 'zation-client';
 import { Test } from "../../test/test";
 import { AbstractDataboxAsserter } from "./abstractDataboxAsserter";
-export declare class DataboxAsserter<T> extends AbstractDataboxAsserter<DataboxAsserter<T>> {
+export declare class DataboxAsserter<T, D extends Databox<any, any, any, any>> extends AbstractDataboxAsserter<DataboxAsserter<T, D>, D> {
     private readonly _source;
-    constructor(databoxes: Databox[], test: Test, source: T);
+    constructor(databoxes: D[], test: Test, source: T);
     /**
      * @description
      * End the databox asserter.
      */
     end(): T;
-    protected self(): DataboxAsserter<T>;
+    protected self(): DataboxAsserter<T, D>;
 }

package/dist/lib/helper/asserter/databox/databoxAsserter.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.DataboxAsserter = void 0;

package/dist/lib/helper/asserter/databox/standaloneDataboxAsserter.d.ts

@@ -1,16 +1,17 @@
 import { Databox } from 'zation-client';
 import { AbstractDataboxAsserter } from "./abstractDataboxAsserter";
-export declare class StandaloneDataboxAsserter extends AbstractDataboxAsserter<StandaloneDataboxAsserter> {
-    constructor(databox: Databox | Databox[], itTestDescription?: string);
+import { DataboxMember } from "../../utils/types";
+export declare class StandaloneDataboxAsserter<D extends Databox<any, any, any, any>> extends AbstractDataboxAsserter<StandaloneDataboxAsserter<D>, D> {
+    constructor(databox: D | D[], description?: string);
     /**
      * @description
-     * Will connect all databoxes (before the test).
+     * Connects all databoxes (before the test).
      */
-    connect(member?: any): StandaloneDataboxAsserter;
+    connect(member?: DataboxMember<D>): StandaloneDataboxAsserter<D>;
     /**
      * @description
      * Run the test.
      */
     test(): Promise<void>;
-    protected self(): StandaloneDataboxAsserter;
+    protected self(): StandaloneDataboxAsserter<D>;
 }

package/dist/lib/helper/asserter/databox/standaloneDataboxAsserter.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 abstractDataboxAsserter_1 = require("./abstractDataboxAsserter");
 const chai_1 = require("chai");
 class StandaloneDataboxAsserter extends abstractDataboxAsserter_1.AbstractDataboxAsserter {
-    constructor(databox, itTestDescription) {
-        super(Array.isArray(databox) ? databox : [databox], new test_1.Test(itTestDescription));
+    constructor(databox, description) {
+        super(Array.isArray(databox) ? databox : [databox], new test_1.Test(description));
     }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * Will connect all databoxes (before the test).
+     * Connects all databoxes (before the test).
      */
     connect(member) {
         this._test.beforeTest(() => __awaiter(this, void 0, void 0, function* () {
@@ -34,7 +34,7 @@ class StandaloneDataboxAsserter extends abstractDataboxAsserter_1.AbstractDatabo
                     yield databox.connect(member);
                 }
                 catch (err) {
-                    chai_1.assert.fail(`Cannot connect the databox ${index}. Error -> ` + err.stack);
+                    chai_1.assert.fail(`Cannot connect the databox ${index}. Error -> ` + err);
                 }
             })));
         }));

package/dist/lib/helper/asserter/event/abstractEventAsserter.d.ts

@@ -1,4 +1,5 @@
 import { Test } from "../../test/test";
+import { ValueAsserter } from "../value/valueAsserter";
 export declare type EventOnceListenerAdder<A extends any[]> = (listener: (...data: A) => void) => void;
 export declare abstract class AbstractEventAsserter<T, S, A extends any[] = [any]> {
     private messagePostfix;
@@ -10,22 +11,29 @@ export declare abstract class AbstractEventAsserter<T, S, A extends any[] = [any
     protected readonly _event: string;
     private _timeout;
     private _not;
-    constructor(eventOnceListenerAdder: EventOnceListenerAdder<A>[], target: string, event: string, test: Test, source: S, messagePostfix?: string);
+    protected readonly _argsAsserter: ((args: A, target: string) => void)[];
+    protected constructor(eventOnceListenerAdder: EventOnceListenerAdder<A>[], target: string, event: string, test: Test, source: S, messagePostfix?: string);
     /**
      * @description
-     * With this function, you can set a time limit in milliseconds in that the event should occur.
+     * Sets a time limit in milliseconds in that the event should occur.
      * @default
      * The default value is 200ms.
      */
     timeout(timeout: number): T;
     /**
      * @description
-     * With this function, you set that the event should not occur.
+     * Sets that the event should not occur.
      * @default
      * The default value is false.
      */
     not(): T;
-    protected _onEventArgs(args: A, index: number): void;
+    /**
+     * @description
+     * Asserts an argument value of the event.
+     * Notice that the argument will not be checked in (get not) mode.
+     */
+    withArgument<AI extends number>(argIndex: AI): ValueAsserter<A[AI], T>;
+    private _assertEventArgs;
     /**
      * @description
      * End the event asserter.

package/dist/lib/helper/asserter/event/abstractEventAsserter.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,12 +16,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractEventAsserter = void 0;
 const timeoutAssert_1 = require("../../timeout/timeoutAssert");
+const valueAsserter_1 = require("../value/valueAsserter");
 const assert = require('assert');
 class AbstractEventAsserter {
     constructor(eventOnceListenerAdder, target, event, test, source, messagePostfix = '') {
         this.messagePostfix = messagePostfix;
         this._timeout = 200;
         this._not = false;
+        this._argsAsserter = [];
         this._eventOnceListenerAdder = eventOnceListenerAdder;
         this._target = target;
         this._event = event;
@@ -31,7 +33,7 @@ class AbstractEventAsserter {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * With this function, you can set a time limit in milliseconds in that the event should occur.
+     * Sets a time limit in milliseconds in that the event should occur.
      * @default
      * The default value is 200ms.
      */
@@ -42,7 +44,7 @@ class AbstractEventAsserter {
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
-     * With this function, you set that the event should not occur.
+     * Sets that the event should not occur.
      * @default
      * The default value is false.
      */
@@ -50,7 +52,22 @@ class AbstractEventAsserter {
         this._not = true;
         return this.self();
     }
-    _onEventArgs(args, index) { }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts an argument value of the event.
+     * Notice that the argument will not be checked in (get not) mode.
+     */
+    withArgument(argIndex) {
+        return new valueAsserter_1.ValueAsserter(this.self(), (test) => {
+            this._argsAsserter.push((args, target) => {
+                test(args[argIndex], target + `argument: ${argIndex}`);
+            });
+        });
+    }
+    _assertEventArgs(args, index) {
+        this._argsAsserter.forEach(asserter => asserter(args, `${this._target}: ${index} event: ${this._event} -> `));
+    }
     // noinspection JSUnusedGlobalSymbols
     /**
      * @description
@@ -58,9 +75,7 @@ class AbstractEventAsserter {
      */
     end() {
         this._eventOnceListenerAdder.forEach((addListener, i) => {
-            let receivedEmit = false;
-            let listenerArgs;
-            let resolve;
+            let receivedEmit = false, listenerArgs, resolve;
             this._test.beforeTest(() => {
                 addListener((...args) => {
                     listenerArgs = args;
@@ -76,13 +91,13 @@ class AbstractEventAsserter {
                     resolve = () => toa.resolve();
                     yield toa.set();
                     if (!this._not)
-                        this._onEventArgs(listenerArgs, i);
+                        this._assertEventArgs(listenerArgs, i);
                 }
                 else {
                     if (this._not)
                         assert.fail(failMsg);
                     else
-                        this._onEventArgs(listenerArgs, i);
+                        this._assertEventArgs(listenerArgs, i);
                 }
             }));
         });

package/dist/lib/helper/asserter/event/codeMetadataEventAsserter.d.ts

@@ -0,0 +1,21 @@
+import { ValueAsserter } from "../value/valueAsserter";
+import { AbstractEventAsserter, EventOnceListenerAdder } from "./abstractEventAsserter";
+import { Test } from "../../test/test";
+export declare class CodeMetadataEventAsserter<S, A extends any[], CI extends keyof A, MDI extends keyof A> extends AbstractEventAsserter<CodeMetadataEventAsserter<S, A, CI, MDI>, S, A> {
+    private readonly codeIndex;
+    private readonly metadataIndex;
+    constructor(eventOnceListenerAdder: EventOnceListenerAdder<A>[], target: string, event: string, test: Test, source: S, codeIndex: CI, metadataIndex: MDI, messagePostfix?: string);
+    /**
+     * @description
+     * Asserts the code of the event.
+     * Notice that the code will not be checked in (get not) mode.
+     */
+    withCode(): ValueAsserter<A[CI], CodeMetadataEventAsserter<S, A, CI, MDI>>;
+    /**
+     * @description
+     * Asserts the metadata of the event.
+     * Notice that the metadata will not be checked in (get not) mode.
+     */
+    withMetadata(): ValueAsserter<A[MDI], CodeMetadataEventAsserter<S, A, CI, MDI>>;
+    protected self(): CodeMetadataEventAsserter<S, A, CI, MDI>;
+}

package/dist/lib/helper/asserter/event/codeMetadataEventAsserter.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+Author: Ing. Luca Gian Scaringella
+GitHub: LucaCode
+Copyright(c) Ing. Luca Gian Scaringella
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeMetadataEventAsserter = void 0;
+const valueAsserter_1 = require("../value/valueAsserter");
+const abstractEventAsserter_1 = require("./abstractEventAsserter");
+class CodeMetadataEventAsserter extends abstractEventAsserter_1.AbstractEventAsserter {
+    constructor(eventOnceListenerAdder, target, event, test, source, codeIndex, metadataIndex, messagePostfix = "") {
+        super(eventOnceListenerAdder, target, event, test, source, messagePostfix);
+        this.codeIndex = codeIndex;
+        this.metadataIndex = metadataIndex;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts the code of the event.
+     * Notice that the code will not be checked in (get not) mode.
+     */
+    withCode() {
+        return new valueAsserter_1.ValueAsserter(this.self(), (test) => {
+            this._argsAsserter.push((args, target) => {
+                test(args[this.codeIndex], target + 'code');
+            });
+        });
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts the metadata of the event.
+     * Notice that the metadata will not be checked in (get not) mode.
+     */
+    withMetadata() {
+        return new valueAsserter_1.ValueAsserter(this.self(), (test) => {
+            this._argsAsserter.push((args, target) => {
+                test(args[this.metadataIndex], target + 'metadata');
+            });
+        });
+    }
+    self() {
+        return this;
+    }
+}
+exports.CodeMetadataEventAsserter = CodeMetadataEventAsserter;

package/dist/lib/helper/asserter/event/dataEventAsserter.d.ts

@@ -1,4 +1,14 @@
-import { AbstractDataEventAsserter } from "./abstractDataEventAsserter";
-export declare class DataEventAsserter<S, A extends [any] = [any]> extends AbstractDataEventAsserter<DataEventAsserter<S, A>, S, A> {
-    protected self(): DataEventAsserter<S, A>;
+import { AbstractEventAsserter, EventOnceListenerAdder } from "./abstractEventAsserter";
+import { Test } from "../../test/test";
+import { ValueAsserter } from "../value/valueAsserter";
+export declare class DataEventAsserter<S, A extends any[], DI extends keyof A> extends AbstractEventAsserter<DataEventAsserter<S, A, DI>, S, A> {
+    private readonly dataIndex;
+    constructor(eventOnceListenerAdder: EventOnceListenerAdder<A>[], target: string, event: string, test: Test, source: S, dataIndex: DI, messagePostfix?: string);
+    /**
+     * @description
+     * Asserts the data of the event.
+     * Notice that the data will not be checked in (get not) mode.
+     */
+    withData(): ValueAsserter<A[DI], DataEventAsserter<S, A, DI>>;
+    protected self(): DataEventAsserter<S, A, DI>;
 }

package/dist/lib/helper/asserter/event/dataEventAsserter.js

@@ -1,13 +1,31 @@
 "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.DataEventAsserter = void 0;
-const abstractDataEventAsserter_1 = require("./abstractDataEventAsserter");
-class DataEventAsserter extends abstractDataEventAsserter_1.AbstractDataEventAsserter {
+const abstractEventAsserter_1 = require("./abstractEventAsserter");
+const valueAsserter_1 = require("../value/valueAsserter");
+class DataEventAsserter extends abstractEventAsserter_1.AbstractEventAsserter {
+    constructor(eventOnceListenerAdder, target, event, test, source, dataIndex, messagePostfix = "") {
+        super(eventOnceListenerAdder, target, event, test, source, messagePostfix);
+        this.dataIndex = dataIndex;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts the data of the event.
+     * Notice that the data will not be checked in (get not) mode.
+     */
+    withData() {
+        return new valueAsserter_1.ValueAsserter(this.self(), (test) => {
+            this._argsAsserter.push((args, target) => {
+                test(args[this.dataIndex], target + 'data');
+            });
+        });
+    }
     self() {
         return this;
     }

package/dist/lib/helper/asserter/receiver/integratedTransmitAsserter.d.ts

@@ -0,0 +1,9 @@
+import { Client } from "zation-client";
+import { Test } from "../../test/test";
+import { AbstractActionAsserter } from "../abstractActionAsserter";
+export declare class IntegratedTransmitAsserter<C extends Client<any, any>> extends AbstractActionAsserter<IntegratedTransmitAsserter<C>, C> {
+    private readonly transmit;
+    constructor(transmit: () => Promise<void>, test: Test, client: C);
+    protected _executeAction(): Promise<void>;
+    protected self(): IntegratedTransmitAsserter<C>;
+}

package/dist/lib/helper/asserter/receiver/{transmitAsserter.js → integratedTransmitAsserter.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,20 +14,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransmitAsserter = void 0;
-const rootSendAsserter_1 = require("../rootSendAsserter");
-class TransmitAsserter extends rootSendAsserter_1.RootSendAsserter {
-    constructor(nativeBuilder, test, client) {
+exports.IntegratedTransmitAsserter = void 0;
+const abstractActionAsserter_1 = require("../abstractActionAsserter");
+class IntegratedTransmitAsserter extends abstractActionAsserter_1.AbstractActionAsserter {
+    constructor(transmit, test, client) {
         super(test, client);
-        this.nativeBuilder = nativeBuilder;
+        this.transmit = transmit;
     }
     _executeAction() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.nativeBuilder.send();
+            yield this.transmit();
         });
     }
     self() {
         return this;
     }
 }
-exports.TransmitAsserter = TransmitAsserter;
+exports.IntegratedTransmitAsserter = IntegratedTransmitAsserter;