zation-assured 0.6.3 → 3.0.0-dev.4

package/dist/lib/helper/asserter/controller/integratedResponseAsserter.js

@@ -0,0 +1,122 @@
+"use strict";
+/*
+Author: Ing. Luca Gian Scaringella
+GitHub: LucaCode
+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); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegratedResponseAsserter = void 0;
+const zation_client_1 = require("zation-client");
+const valueAsserter_1 = require("../value/valueAsserter");
+const backErrorsFilterBuilder_1 = require("../../backError/backErrorsFilterBuilder");
+const abstractActionAsserter_1 = require("../abstractActionAsserter");
+const assert = require('assert');
+class IntegratedResponseAsserter extends abstractActionAsserter_1.AbstractActionAsserter {
+    constructor(sendRequest, test, client) {
+        super(test, client);
+        this.sendRequest = sendRequest;
+        this.responseAsserters = [];
+    }
+    _executeAction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let resp;
+            try {
+                resp = yield this.sendRequest();
+            }
+            catch (err) {
+                if (err instanceof zation_client_1.Response)
+                    resp = err;
+                else
+                    throw err;
+            }
+            for (let i = 0; i < this.responseAsserters.length; i++)
+                yield this.responseAsserters[i](resp);
+        });
+    }
+    // noinspection JSMethodCanBeStatic
+    _respInfo(res) {
+        return '\n   ' + res.toString();
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts that the response is successful.
+     */
+    isSuccessful() {
+        this.responseAsserters.push(resp => {
+            assert(resp.successful, 'Response should be successful.' + this._respInfo(resp));
+        });
+        return this;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts that the response is not successful.
+     */
+    isNotSuccessful() {
+        this.responseAsserters.push(resp => {
+            assert(!resp.successful, 'Response should be not successful.' + this._respInfo(resp));
+        });
+        return this;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts that the response has a result.
+     */
+    hasResult() {
+        this.responseAsserters.push(resp => {
+            assert(resp.result != null, `Response should have a result.`
+                + this._respInfo(resp));
+        });
+        return this;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts the result of the response.
+     */
+    result() {
+        return new valueAsserter_1.ValueAsserter(this, (test) => {
+            this.responseAsserters.push(resp => {
+                test(resp.result, 'response data');
+            });
+        });
+    }
+    hasError(filter) {
+        if (filter !== undefined) {
+            this.responseAsserters.push((resp) => {
+                assert(resp.filter(filter).length > 0, `Response should have at least one back error that matches the filter: ${JSON.stringify(filter)}.`
+                    + this._respInfo(resp));
+            });
+            return this;
+        }
+        else
+            return new backErrorsFilterBuilder_1.BackErrorsFilterBuilder(this, (filter) => {
+                this.hasError(filter);
+            });
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Creates a custom assertion.
+     * @param assert
+     */
+    assert(assert) {
+        this.responseAsserters.push(resp => assert(resp));
+        return this;
+    }
+    self() {
+        return this;
+    }
+}
+exports.IntegratedResponseAsserter = IntegratedResponseAsserter;

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

@@ -0,0 +1,54 @@
+import { BackErrorFilter, Response } from "zation-client";
+import { ValueAsserter } from "../value/valueAsserter";
+import { BackErrorsFilterBuilder } from "../../backError/backErrorsFilterBuilder";
+import { ResponseData } from "../../utils/types";
+export default class StandaloneResponseAsserter<R extends Response<any>> {
+    private readonly _test;
+    private readonly responses;
+    constructor(response: R | R[], description?: string);
+    protected _forEachResponse(func: (response: R, i: number) => Promise<void> | void): Promise<void>;
+    private _respInfo;
+    /**
+     * @description
+     * Asserts that the response is successful.
+     */
+    isSuccessful(): StandaloneResponseAsserter<R>;
+    /**
+     * @description
+     * Asserts that the response is not successful.
+     */
+    isNotSuccessful(): StandaloneResponseAsserter<R>;
+    /**
+     * @description
+     * Asserts that the response has a result.
+     */
+    hasResult(): StandaloneResponseAsserter<R>;
+    /**
+     * @description
+     * Asserts the result of the response.
+     */
+    result(): ValueAsserter<ResponseData<R>, StandaloneResponseAsserter<R>>;
+    /**
+     * @description
+     * Asserts that the response has specific errors with a BackErrorFilterBuilder.
+     */
+    hasError(): BackErrorsFilterBuilder<StandaloneResponseAsserter<R>>;
+    /**
+     * @description
+     * Asserts that the response has specific errors with a raw filter.
+     * @param filter
+     * Queric filter to filter for specific errors.
+     */
+    hasError(filter: BackErrorFilter): StandaloneResponseAsserter<R>;
+    /**
+     * @description
+     * Creates a custom assertion.
+     * @param assert
+     */
+    assert(assert: (resp: R) => void | Promise<void>): StandaloneResponseAsserter<R>;
+    /**
+     * @description
+     * Runs the test.
+     */
+    test(): Promise<void>;
+}

package/dist/lib/helper/asserter/controller/standaloneResponseAsserter.js

@@ -0,0 +1,118 @@
+"use strict";
+/*
+Author: Ing. Luca Gian Scaringella
+GitHub: LucaCode
+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); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("../../test/test");
+const valueAsserter_1 = require("../value/valueAsserter");
+const backErrorsFilterBuilder_1 = require("../../backError/backErrorsFilterBuilder");
+const assert = require('assert');
+class StandaloneResponseAsserter {
+    constructor(response, description) {
+        this._test = new test_1.Test(description);
+        this.responses = Array.isArray(response) ? response : [response];
+    }
+    _forEachResponse(func) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(this.responses
+                .map((resp, i) => func(resp, i)));
+        });
+    }
+    // noinspection JSMethodCanBeStatic
+    _respInfo(res) {
+        return '\n   ' + res.toString();
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts that the response is successful.
+     */
+    isSuccessful() {
+        this._test.test(() => this._forEachResponse((resp, i) => __awaiter(this, void 0, void 0, function* () {
+            assert(resp.successful, `Response: ${i} should be successful.` + this._respInfo(resp));
+        })));
+        return this;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts that the response is not successful.
+     */
+    isNotSuccessful() {
+        this._test.test(() => this._forEachResponse((resp, i) => __awaiter(this, void 0, void 0, function* () {
+            assert(!resp.successful, `Response: ${i} should be not successful.` + this._respInfo(resp));
+        })));
+        return this;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts that the response has a result.
+     */
+    hasResult() {
+        this._test.test(() => this._forEachResponse((resp, i) => __awaiter(this, void 0, void 0, function* () {
+            assert(resp.result != null, `Response: ${i} should have a result.`
+                + this._respInfo(resp));
+        })));
+        return this;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Asserts the result of the response.
+     */
+    result() {
+        return new valueAsserter_1.ValueAsserter(this, (test) => {
+            this._test.test(() => this._forEachResponse((resp, i) => __awaiter(this, void 0, void 0, function* () {
+                test(resp.result, `response: ${i} result`);
+            })));
+        });
+    }
+    hasError(filter) {
+        if (filter !== undefined) {
+            this._test.test(() => this._forEachResponse((resp, i) => __awaiter(this, void 0, void 0, function* () {
+                assert(resp.filter(filter).length > 0, `Response: ${i} should have at least one back error that matches the filter: ${JSON.stringify(filter)}.`
+                    + this._respInfo(resp));
+            })));
+            return this;
+        }
+        else
+            return new backErrorsFilterBuilder_1.BackErrorsFilterBuilder(this, (filter) => {
+                this.hasError(filter);
+            });
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Creates a custom assertion.
+     * @param assert
+     */
+    assert(assert) {
+        this._test.test(() => this._forEachResponse((resp) => __awaiter(this, void 0, void 0, function* () {
+            yield assert(resp);
+        })));
+        return this;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * @description
+     * Runs the test.
+     */
+    test() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._test.execute();
+        });
+    }
+}
+exports.default = StandaloneResponseAsserter;

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

@@ -1,79 +1,72 @@
 import { Test } from "../../test/test";
-import { Databox, DataEventReason } from 'zation-client';
+import { Databox, DataEventReason, DbStorage } from 'zation-client';
 import { DataEventAsserter } from "../event/dataEventAsserter";
 import { ValueAsserter } from "../value/valueAsserter";
-import { CodeDataEventAsserter } from "../event/codeDataEventAsserter";
-export declare abstract class AbstractDataboxAsserter<T> {
+import { CodeMetadataEventAsserter } from "../event/codeMetadataEventAsserter";
+import { Query } from "queric";
+import { DataboxData, DataboxFetchData, DataboxMember } from "../../utils/types";
+import { DeepReadonly } from "../../utils/types";
+export declare abstract class AbstractDataboxAsserter<T, D extends Databox<any, any, any, any>> {
     protected _test: Test;
-    protected databoxes: Databox[];
+    protected databoxes: D[];
     protected abstract self(): T;
-    protected constructor(databoxes: Databox[], test: Test);
-    protected _forEachDatabox(func: (databox: Databox, i: number) => Promise<void>): Promise<void>;
+    protected constructor(databoxes: D[], test: Test);
+    protected _forEachDatabox(func: (databox: D, i: number) => Promise<void> | void): Promise<void>;
     /**
      * @description
      * 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?: number): T;
     /**
      * @description
      * 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?: number): T;
     /**
      * Asserts the current data of the databox.
      */
-    data(): ValueAsserter<T>;
+    data(): ValueAsserter<DeepReadonly<DataboxData<D>>, T>;
     /**
      * Asserts the current member of the databox.
      */
-    member(): ValueAsserter<T>;
+    member(): ValueAsserter<DataboxMember<D>, T>;
     /**
      * Fetches data multiple times on each databox.
      */
-    fetch(times?: number, fetchData?: any): T;
+    fetch(times?: number, fetchData?: DataboxFetchData<D>): T;
     /**
      * @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.
+     * 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: (databox: Databox, index: number) => void | Promise<void>, message?: string): T;
+    action(action: (databox: D, index: number) => void | Promise<void>, failMsg?: string): T;
     /**
      * @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.
-     * @param action
-     * @param message
-     * @param validErrorClasses
-     */
-    actionShouldThrow(action: (databox: Databox, index: number) => void | Promise<void>, message: string, ...validErrorClasses: any[]): T;
-    /**
-     * @description
-     * Asserts 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 queric query.
      */
-    dataChangeTriggers(...reasons: DataEventReason[]): DataEventAsserter<T>;
+    dataChangeTriggers(reasonFilter?: Query<DataEventReason>): DataEventAsserter<T, [DeepReadonly<DataboxData<D>>, DataEventReason, DbStorage<DataboxData<D>>], 0>;
     /**
      * @description
-     * Asserts 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 queric query.
      */
-    dataTouchTriggers(...reasons: DataEventReason[]): DataEventAsserter<T>;
+    dataTouchTriggers(reasonFilter?: Query<DataEventReason>): DataEventAsserter<T, [DeepReadonly<DataboxData<D>>, DataEventReason, DbStorage<DataboxData<D>>], 0>;
     /**
      * @description
-     * Asserts that the databox should trigger an Close event.
+     * Asserts that the databox should trigger an close event.
      */
-    closeTriggers(): CodeDataEventAsserter<T>;
+    closeTriggers(): CodeMetadataEventAsserter<T, [number | string | undefined, any], 0, 1>;
     /**
      * @description
-     * Asserts that the databox should trigger an KickOut event.
+     * Asserts that the databox should trigger an kick out event.
      */
-    kickOutTriggers(): CodeDataEventAsserter<T>;
+    kickOutTriggers(): CodeMetadataEventAsserter<T, [number | string | undefined, any], 0, 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 queric_1 = require("queric");
 class AbstractDataboxAsserter {
     constructor(databoxes, test) {
         this._test = test;
@@ -28,11 +29,7 @@ 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
@@ -40,11 +37,11 @@ class AbstractDataboxAsserter {
      * @description
      * 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);
@@ -61,11 +58,11 @@ class AbstractDataboxAsserter {
      * @description
      * 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);
@@ -82,12 +79,8 @@ class AbstractDataboxAsserter {
      * 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
@@ -95,12 +88,8 @@ class AbstractDataboxAsserter {
      * 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
-     * Asserts 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 queric query.
      */
-    dataChangeTriggers(...reasons) {
+    dataChangeTriggers(reasonFilter) {
+        const filter = reasonFilter ? (0, queric_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
-     * Asserts 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 queric query.
      */
-    dataTouchTriggers(...reasons) {
+    dataTouchTriggers(reasonFilter) {
+        const filter = reasonFilter ? (0, queric_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
-     * Asserts 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
-     * Asserts 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>;
 }