zation-assured 0.6.3 → 3.0.0-dev.1

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;

package/dist/lib/helper/asserter/value/abstractValueAsserter.d.ts

@@ -1,10 +1,9 @@
 import { ForintQuery } from "forint";
-declare type AddTest = (test: (value: any, eStr?: string) => void) => void;
-export declare abstract class AbstractValueAsserter<T> {
+declare type AddTest = (test: (value: any, target: string) => void) => void;
+export declare abstract class AbstractValueAsserter<V, T> {
     protected abstract self(): T;
     private readonly addTest;
-    private readonly name;
-    protected constructor(name: string, addTest: AddTest);
+    protected constructor(addTest: AddTest);
     /**
      * @description
      * Asserts that the value is undefined.
@@ -66,29 +65,29 @@ export declare abstract class AbstractValueAsserter<T> {
     /**
      * Asserts that the value matches with a forint query.
      */
-    matches(query: ForintQuery): T;
+    matches(query: ForintQuery<V> | ForintQuery<Record<any, any>>): T;
     /**
      * Asserts that the value not matches with a forint query.
      */
-    notMatches(query: ForintQuery): T;
+    notMatches(query: ForintQuery<V> | ForintQuery<Record<any, any>>): T;
     /**
      * @description
      * Asserts that the value has all specific keys.
      * @param keys
      */
-    containsAllKeys(...keys: string[]): T;
+    containsAllKeys(...keys: (keyof V | string)[]): T;
     /**
      * @description
      * Asserts that the value has at least one specific keys.
      * @param keys
      */
-    hasAnyKeys(...keys: string[]): T;
+    hasAnyKeys(...keys: (keyof V | string)[]): T;
     /**
      * @description
      * Asserts that the value does not have any of the specific keys.
      * @param keys
      */
-    doesNotHaveAnyKeys(...keys: string[]): T;
+    doesNotHaveAnyKeys(...keys: (keyof V | string)[]): T;
     /**
      * @description
      * Asserts that the value should own include a subset.
@@ -131,10 +130,9 @@ export declare abstract class AbstractValueAsserter<T> {
     lengthOf(length: number): T;
     /**
      * @description
-     * Lets you do a custom assertion with the value.
+     * Creates a custom assertion.
      * @param assert
-     * @param message
      */
-    assert(assert: (value: any) => boolean | Promise<boolean>, message?: string): T;
+    assert(assert: (value: any, target: string) => void | Promise<void>): T;
 }
 export {};