testeranto.tiposkripto 0.3.2 → 0.4.0

package/dist/types/lib/tiposkripto/src/verbs/bdd/BaseGiven.d.ts

@@ -0,0 +1,48 @@
+import type { TestTypeParams_any } from "../../CoreTypes.js";
+import type { ITestArtifactory, ITestResourceConfiguration } from "../../types.js";
+/**
+ * Represents a collection of Given conditions keyed by their names.
+ * Givens are typically organized as named collections because:
+ * - They set up different initial states for tests
+ * - Tests often need to reference specific Given conditions by name
+ * - This allows for better organization and reuse of setup logic
+ * - The BDD pattern often involves multiple named Given scenarios
+ */
+/**
+ * BaseGiven for BDD pattern - independent implementation
+ */
+export declare abstract class BaseGiven<I extends TestTypeParams_any> {
+    features: string[];
+    whens: any[];
+    thens: any[];
+    error: Error | null;
+    store: I["istore"];
+    givenCB: I["given"];
+    initialValues: any;
+    key: string;
+    failed: boolean;
+    artifacts: string[];
+    fails: number;
+    status: boolean | undefined;
+    testResourceConfiguration: ITestResourceConfiguration | null;
+    constructor(features: string[], whens: any[], thens: any[], givenCB: I["given"], initialValues: any);
+    addArtifact(path: string): void;
+    setParent(parent: any): void;
+    toObj(): any;
+    /**
+     * Abstract method to be implemented by concrete Given classes.
+     * Sets up the initial state for the BDD Given phase.
+     *
+     * @param subject The test subject
+     * @param testResourceConfiguration Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @param givenCB Given callback function
+     * @param initialValues Initial values for setup
+     * @returns Promise resolving to the test store
+     */
+    abstract givenThat(subject: I["isubject"], testResourceConfiguration: ITestResourceConfiguration, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any): Promise<I["istore"]>;
+    afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory): Promise<I["istore"]>;
+    give(subject: I["isubject"], key: string, testResourceConfiguration: ITestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory?: any, suiteNdx?: number): Promise<I["istore"]>;
+    private createArtifactoryForWhen;
+    private createArtifactoryForThen;
+}

package/dist/types/lib/tiposkripto/src/verbs/bdd/BaseThen.d.ts

@@ -0,0 +1,38 @@
+import type { TestTypeParams_any } from "../../CoreTypes.js";
+import type { ITestResourceConfiguration } from "../../types.js";
+/**
+ * BaseThen for BDD pattern - independent implementation
+ */
+export declare abstract class BaseThen<I extends TestTypeParams_any> {
+    name: string;
+    thenCB: (storeState: I["iselection"]) => Promise<I["then"]>;
+    error: Error | null;
+    status: boolean | undefined;
+    constructor(name: string, thenCB: (val: I["iselection"]) => Promise<I["then"]>);
+    /**
+     * Abstract method to be implemented by concrete Then classes.
+     * Performs the verification for the BDD Then phase.
+     *
+     * @param store The test store
+     * @param thenCB Then callback function
+     * @param testResourceConfiguration Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @returns Promise resolving to the selection for verification
+     */
+    abstract butThen(store: I["istore"], thenCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: ITestResourceConfiguration, artifactory?: any): Promise<I["iselection"]>;
+    test(store: I["istore"], testResourceConfiguration: ITestResourceConfiguration, filepath: string, artifactory?: any): Promise<I["then"] | undefined>;
+    toObj(): {
+        name: string;
+        status: boolean | undefined;
+        error: string | null;
+    };
+}
+/**
+ * Represents a collection of Then assertions keyed by their names.
+ * Thens are typically part of Given definitions rather than standalone collections,
+ * but this type exists for consistency and potential future use cases where:
+ * - Assertions might need to be reused or composed dynamically
+ * - Custom assertion libraries could benefit from named assertion collections
+ * - Advanced validation patterns require named Then conditions
+ */
+export type IThens<I extends TestTypeParams_any> = Record<string, BaseThen<I>>;

package/dist/types/lib/tiposkripto/src/verbs/bdd/BaseWhen.d.ts

@@ -0,0 +1,37 @@
+import { TestTypeParams_any } from "../../CoreTypes.js";
+/**
+ * BaseWhen for BDD pattern - independent implementation
+ */
+export declare abstract class BaseWhen<I extends TestTypeParams_any> {
+    name: string;
+    whenCB: (x: I["iselection"]) => I["then"];
+    error: Error | null;
+    status: boolean | undefined;
+    constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]);
+    /**
+     * Abstract method to be implemented by concrete When classes.
+     * Performs the action for the BDD When phase.
+     *
+     * @param store The test store
+     * @param whenCB When callback function
+     * @param testResource Test resource configuration
+     * @param artifactory Context-aware artifactory for file operations
+     * @returns Promise resolving to the result of the action
+     */
+    abstract andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, artifactory?: any): Promise<any>;
+    test(store: I["istore"], testResourceConfiguration: any, artifactory?: any): Promise<any>;
+    toObj(): {
+        name: string;
+        status: boolean | undefined;
+        error: string | null;
+    };
+}
+/**
+ * Represents a collection of When actions keyed by their names.
+ * Whens are typically part of Given definitions rather than standalone collections,
+ * but this type exists for consistency and potential future use cases where:
+ * - When actions might need to be reused across multiple Given conditions
+ * - Dynamic composition of test steps is required
+ * - Advanced test patterns need to reference When actions by name
+ */
+export type IWhens<I extends TestTypeParams_any> = Record<string, BaseWhen<I>>;

package/dist/types/lib/tiposkripto/src/verbs/internal/CommonUtils.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Common utilities shared across all testing patterns
+ */
+export declare class CommonUtils {
+    /**
+     * Normalize a path string for consistent artifact storage
+     */
+    static normalizePath(path: string): string;
+    /**
+     * Add an artifact with path normalization
+     */
+    static addArtifact(artifacts: string[], path: string): void;
+    /**
+     * Create a fallback artifactory for logging
+     */
+    static createFallbackArtifactory(context: {
+        suiteIndex?: number;
+        givenKey?: string;
+        whenIndex?: number;
+        thenIndex?: number;
+        valueKey?: string;
+        rowIndex?: number;
+    }, basePath?: string): any;
+    /**
+     * Standard error handling for test operations
+     */
+    static handleTestError(error: any, target: {
+        failed: boolean;
+        fails: number;
+        error: Error | null;
+    }): void;
+    /**
+     * Standard method to create an object representation
+     */
+    static toObj(target: {
+        key?: string;
+        name?: string;
+        failed: boolean;
+        fails?: number;
+        error: Error | null;
+        features?: string[];
+        artifacts: string[];
+        status?: boolean | undefined;
+    }, additionalProps?: Record<string, any>): any;
+}

package/dist/types/lib/tiposkripto/src/verbs/tdt/BaseConfirm.d.ts

@@ -0,0 +1,26 @@
+import type { TestTypeParams_any } from "../../CoreTypes.js";
+import type { ITestArtifactory, ITestResourceConfiguration } from "../../types.js";
+/**
+ * BaseConfirm for TDT (Table-Driven Testing) pattern.
+ * Standalone class similar to BaseGiven but for table-driven testing.
+ */
+export declare class BaseConfirm<I extends TestTypeParams_any> {
+    features: string[];
+    testCases: any[][];
+    confirmCB: I["given"];
+    initialValues: any;
+    key: string;
+    failed: boolean;
+    artifacts: string[];
+    fails: number;
+    status: boolean | undefined;
+    error: Error | null;
+    store: I["istore"];
+    constructor(features: string[], testCases: any[][], confirmCB: I["given"], initialValues: any);
+    addArtifact(path: string): void;
+    setParent(parent: any): void;
+    toObj(): any;
+    confirm(subject: I["isubject"], key: string, testResourceConfiguration: ITestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory?: any, suiteNdx?: number): Promise<I["istore"]>;
+    run(subject: I["isubject"], testResourceConfiguration: ITestResourceConfiguration, artifactory?: ITestArtifactory): Promise<I["istore"]>;
+}
+export type IConfirms<I extends TestTypeParams_any> = Record<string, BaseConfirm<I>>;

package/dist/types/lib/tiposkripto/src/verbs/tdt/BaseExpected.d.ts

@@ -0,0 +1,27 @@
+import type { TestTypeParams_any } from "../../CoreTypes.js";
+import type { ITestResourceConfiguration } from "../../types.js";
+/**
+ * BaseExpected for TDT pattern - independent implementation
+ * Validates each row in table-driven testing.
+ */
+export declare abstract class BaseExpected<I extends TestTypeParams_any> {
+    name: string;
+    expectedCB: (val: I["iselection"]) => Promise<I["action"]>;
+    expectedValue: any;
+    error: Error | null;
+    status: boolean | undefined;
+    constructor(name: string, expectedCB: (val: I["iselection"]) => Promise<I["action"]>);
+    setExpectedValue(expected: any): void;
+    /**
+     * Abstract method to validate a row
+     */
+    abstract validateRow(store: I["istore"], testResourceConfiguration: any, filepath: string, expectedValue: any, artifactory?: any): Promise<any>;
+    test(store: I["istore"], testResourceConfiguration: ITestResourceConfiguration, filepath: string, artifactory?: any): Promise<any>;
+    toObj(): {
+        name: string;
+        status: boolean | undefined;
+        error: string | null;
+        expectedValue: any;
+    };
+}
+export type IExpecteds<I extends TestTypeParams_any> = Record<string, BaseExpected<I>>;

package/dist/types/lib/tiposkripto/src/verbs/tdt/BaseShould.d.ts

@@ -0,0 +1,24 @@
+import { TestTypeParams_any } from "../../CoreTypes.js";
+/**
+ * BaseShould for TDT pattern - independent implementation
+ * Processes each row in table-driven testing.
+ */
+export declare class BaseShould<I extends TestTypeParams_any> {
+    name: string;
+    shouldCB: (xyz: I["iselection"]) => I["action"];
+    currentRow: any[];
+    rowIndex: number;
+    error: Error | null;
+    status: boolean | undefined;
+    constructor(name: string, shouldCB: (xyz: I["iselection"]) => I["action"]);
+    setRowData(rowIndex: number, rowData: any[]): void;
+    processRow(actualResult: any, testResourceConfiguration: any, artifactory?: any): Promise<boolean>;
+    toObj(): {
+        name: string;
+        status: boolean | undefined;
+        error: string | null;
+        rowIndex: number;
+        currentRow: any[];
+    };
+}
+export type IShoulds<I extends TestTypeParams_any> = Record<string, BaseShould<I>>;

package/dist/types/lib/tiposkripto/src/verbs/tdt/BaseValue.d.ts

@@ -0,0 +1,38 @@
+import type { TestTypeParams_any } from "../../CoreTypes.js";
+import { ITestResourceConfiguration } from "../../types.js";
+/**
+ * BaseValue for TDT pattern - independent implementation
+ * Sets up table data for table-driven testing.
+ */
+export declare class BaseValue<I extends TestTypeParams_any> {
+    features: string[];
+    tableRows: any[][];
+    confirmCB: I["setup"];
+    initialValues: any;
+    key: string;
+    failed: boolean;
+    artifacts: string[];
+    fails: number;
+    status: boolean | undefined;
+    error: Error | null;
+    store: I["istore"];
+    testResourceConfiguration: ITestResourceConfiguration | null;
+    constructor(features: string[], tableRows: any[][], confirmCB: I["setup"], initialValues: any);
+    setParent(parent: any): void;
+    addArtifact(path: string): void;
+    value(subject: I["isubject"], key: string, testResourceConfiguration: ITestResourceConfiguration, tester: (t: Awaited<I["check"]> | undefined) => boolean, artifactory?: any, suiteNdx?: number): Promise<I["istore"]>;
+    private processRow;
+    private createArtifactoryForRow;
+    afterEach(store: I["istore"], key: string, artifactory: any): Promise<I["istore"]>;
+    toObj(): {
+        key: string;
+        values: any[][];
+        tableRows: any[][];
+        error: (string | Error | undefined)[] | null;
+        failed: boolean;
+        features: string[];
+        artifacts: string[];
+        status: boolean | undefined;
+    };
+}
+export type IValues<I extends TestTypeParams_any> = Record<string, BaseValue<I>>;