zation-assured 0.5.1 → 3.0.0-dev.1

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);
                 }
             })));
         }));

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
+     * Forint 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>;
+}

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

@@ -0,0 +1,112 @@
+"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 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* () {
+            const resp = yield this.sendRequest();
+            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,49 @@
+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
+     * Forint 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>;
+}

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

@@ -0,0 +1,108 @@
+"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;
+    }
+}
+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 { ForintQuery } from "forint";
+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
-     * 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?: number): T;
     /**
      * @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?: number): T;
     /**
-     * Assert the current data of the databox.
+     * Asserts the current data of the databox.
      */
-    data(): ValueAsserter<T>;
+    data(): ValueAsserter<DeepReadonly<DataboxData<D>>, T>;
     /**
-     * Assert the current member of the databox.
+     * 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
-     * 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: DataEventReason[]): DataEventAsserter<T>;
+    dataChangeTriggers(reasonFilter?: ForintQuery<DataEventReason>): DataEventAsserter<T, [DeepReadonly<DataboxData<D>>, DataEventReason, DbStorage<DataboxData<D>>], 0>;
     /**
      * @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: DataEventReason[]): DataEventAsserter<T>;
+    dataTouchTriggers(reasonFilter?: ForintQuery<DataEventReason>): DataEventAsserter<T, [DeepReadonly<DataboxData<D>>, DataEventReason, DbStorage<DataboxData<D>>], 0>;
     /**
      * @description
-     * Assert 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
-     * Assert 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>;
 }