testeranto.tiposkripto 0.3.2 → 0.4.0

package/dist/types/Types.d.ts

@@ -1,22 +1,29 @@
-import { BaseGiven } from "./lib/tiposkripto/src/BaseGiven";
-import { BaseThen } from "./lib/tiposkripto/src/BaseThen";
-import { BaseWhen } from "./lib/tiposkripto/src/BaseWhen";
+import type { Plugin } from "esbuild";
 import type { Ibdd_in_any, Ibdd_out_any } from "./lib/tiposkripto/src/CoreTypes";
 import type { ITestResourceConfiguration } from "./lib/tiposkripto/src/types";
+import type { BaseGiven } from "./lib/tiposkripto/src/verbs/bdd/BaseGiven";
+import type { BaseThen } from "./lib/tiposkripto/src/verbs/bdd/BaseThen";
+import type { BaseWhen } from "./lib/tiposkripto/src/verbs/bdd/BaseWhen";
+import type { BaseDescribe } from "./lib/tiposkripto/src/verbs/aaa/BaseDescribe";
+import type { BaseIt } from "./lib/tiposkripto/src/verbs/aaa/BaseIt";
+import type { BaseConfirm } from "./lib/tiposkripto/src/verbs/tdt/BaseConfirm";
+import type { BaseValue } from "./lib/tiposkripto/src/verbs/tdt/BaseValue";
+import type { BaseShould } from "./lib/tiposkripto/src/verbs/tdt/BaseShould";
 export type ITestconfigV2 = {
+    volumes: string[];
     featureIngestor: (s: string) => Promise<string>;
     runtimes: Record<string, IBaseTestConfig>;
     documentationGlob?: string;
     stakeholderReactModule?: string;
 };
-export type ICheck = ((x: any) => string);
-export type IChecks = ICheck[];
+export type IOtherTest = (x: any) => string;
+export type IOtherTests = IOtherTest[];
 export type IBaseTestConfig = {
     runtime: string;
     tests: string[];
     dockerfile: string;
     buildOptions: string;
-    checks: IChecks;
+    checks: IOtherTests;
     outputs: string[];
     buildKitOptions?: {
         cacheMounts?: string[];
@@ -36,12 +43,12 @@ export type TestSummary = {
     failedFeatures: string[];
 };
 export type TestLifecycle<Subject, State, Selection> = {
-    beforeAll?: (input: any) => Promise<Subject>;
-    beforeEach?: (subject: Subject) => Promise<State>;
+    prepareAll?: (input: any) => Promise<Subject>;
+    prepareEach?: (subject: Subject) => Promise<State>;
     executeStep?: (state: State) => Promise<State>;
     verifyStep?: (state: State) => Promise<Selection>;
-    afterEach?: (state: State) => Promise<void>;
-    afterAll?: (state: State) => Promise<void>;
+    cleanupEach?: (state: State) => Promise<void>;
+    cleanupAll?: (state: State) => Promise<void>;
     assert?: (result: Selection) => void;
 };
 export type GivenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
@@ -53,6 +60,21 @@ export type WhenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
 export type ThenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
 };
+export type DescribeSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["describes"]]: (features: string[], its: BaseIt<I>[], ...xtras: O["describes"][K]) => BaseDescribe<I>;
+};
+export type ItSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["its"]]: (...xtras: O["its"][K]) => BaseIt<I>;
+};
+export type ConfirmSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["confirms"]]: (input: O["confirms"][K]) => (tableRows: [v: BaseValue, s: BaseShould][], features: string[]) => BaseConfirm<I>;
+};
+export type ValueSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["values"]]: () => BaseValue<I>;
+};
+export type ShouldSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["shoulds"]]: (...xtras: O["shoulds"][K]) => BaseShould<I>;
+};
 export type TestSuiteImplementation<O extends Ibdd_out_any> = {
     [K in keyof O["suites"]]: string;
 };
@@ -65,11 +87,34 @@ export type TestWhenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any
 export type TestThenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["thens"]]: (...It: O["thens"][K]) => (ssel: I["iselection"]) => I["then"];
 };
+export type TestDescribeImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["describes"]]: (...Id: O["describes"][K]) => I["given"];
+};
+export type TestItImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["its"]]: (...Ii: O["its"][K]) => (sel: I["iselection"]) => I["then"];
+};
+export type TestValueImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["values"]]: (...Iv: O["values"][K]) => I["given"];
+};
+export type TestShouldImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["shoulds"]]: (...Is: O["shoulds"][K]) => (sel: I["iselection"]) => I["then"];
+};
+export type TestExpectedImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["expecteds"]]: (...Ie: O["expecteds"][K]) => (sel: I["iselection"]) => Promise<I["then"]>;
+};
+export type TestConfirmImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
+    [K in keyof O["confirms"]]: (...Ic: O["confirms"][K]) => I["given"];
+};
 export type Modify<T, R> = Omit<T, keyof R> & R;
 export type TestSuiteShape = Record<string, any>;
 export type TestGivenShape = Record<string, any>;
 export type TestWhenShape = Record<string, any>;
 export type TestThenShape = Record<string, any>;
+export type TestDescribeShape = Record<string, any>;
+export type TestItShape = Record<string, any>;
+export type TestConfirmShape = Record<string, any>;
+export type TestValueShape = Record<string, any>;
+export type TestShouldShape = Record<string, any>;
 export type IPluginFactory = (register?: (entrypoint: string, sources: string[]) => any, entrypoints?: string[]) => Plugin;
 export type IRunTime = `node` | `web` | `golang` | `python` | `ruby` | `java` | `rust`;
 export type ITestTypes = [string, IRunTime, {

package/dist/types/lib/tiposkripto/src/Adapters.d.ts

@@ -0,0 +1,3 @@
+import { TestTypeParams_any, IUniversalTestAdapter, ITestAdapter } from "./CoreTypes";
+export declare const BaseAdapter: <T extends TestTypeParams_any>() => IUniversalTestAdapter<T>;
+export declare const DefaultAdapter: <T extends TestTypeParams_any>(p: Partial<ITestAdapter<T>>) => IUniversalTestAdapter<T>;

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

@@ -5,7 +5,7 @@ import type { ITestResourceConfiguration } from "./types.js";
  * BaseExpected extends BaseCheck for TDT pattern.
  * Validates each row in table-driven testing.
  */
-export declare class BaseExpected<I extends TestTypeParams_any> extends BaseCheck<I> {
+export declare abstract class BaseExpected<I extends TestTypeParams_any> extends BaseCheck<I> {
     /**
      * Abstract method to be implemented by concrete Expected classes.
      * Validates each row in table-driven testing (TDT pattern).

package/dist/types/lib/tiposkripto/src/BaseTiposkripto.d.ts

@@ -1,13 +1,8 @@
-import { BaseGiven } from "./BaseGiven";
-import { BaseThen } from "./BaseThen";
-import { BaseWhen } from "./BaseWhen";
-import type { Ibdd_in_any, Ibdd_out_any, ITestSpecification, ITestImplementation, ITestAdapter } from "./CoreTypes.js";
-import type { ITestJob, ITTestResourceRequest, ITestResourceConfiguration } from "./types.js";
-type IExtenstions = Record<string, unknown>;
+import { Ibdd_in_any, Ibdd_out_any, ITestSpecification, ITestImplementation, ITestAdapter } from "./CoreTypes";
+import { ITestJob, ITTestResourceRequest, ITestResourceConfiguration } from "./types";
 export default abstract class BaseTiposkripto<I extends Ibdd_in_any = Ibdd_in_any, O extends Ibdd_out_any = Ibdd_out_any, M = unknown> {
     totalTests: number;
     artifacts: Promise<unknown>[];
-    assertThis: (t: I["then"]) => any;
     givenOverrides: Record<string, any>;
     specs: any;
     suitesOverrides: Record<string, any>;
@@ -17,39 +12,48 @@ export default abstract class BaseTiposkripto<I extends Ibdd_in_any = Ibdd_in_an
     thenOverrides: Record<string, any>;
     whenOverrides: Record<string, any>;
     testResourceConfiguration: ITestResourceConfiguration;
+    describeOverrides: Record<string, any>;
+    itOverrides: Record<string, any>;
+    confirmOverrides: Record<string, any>;
+    valuesOverrides: Record<string, any>;
+    shouldsOverrides: Record<string, any>;
+    expectedsOverrides: Record<string, any>;
     abstract writeFileSync(filename: string, payload: string): void;
     createArtifactory(context?: {
         givenKey?: string;
         whenIndex?: number;
         thenIndex?: number;
         suiteIndex?: number;
+        stepIndex?: number;
+        stepType?: string;
     }): {
         writeFileSync: (filename: string, payload: string) => void;
     };
     constructor(webOrNode: "web" | "node", input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M> & {
-        suites: Record<string, object>;
         givens?: Record<string, any>;
         whens?: Record<string, any>;
         thens?: Record<string, any>;
-        values?: Record<string, any>;
-        shoulds?: Record<string, any>;
-        expecteds?: Record<string, any>;
         describes?: Record<string, any>;
         its?: Record<string, any>;
-    }, testResourceRequirement: ITTestResourceRequest | undefined, testAdapter: Partial<ITestAdapter<I>> | undefined, testResourceConfiguration: ITestResourceConfiguration, wsPort?: string, wsHost?: string);
+        confirms?: Record<string, any>;
+        values?: Record<string, any>;
+        shoulds?: Record<string, any>;
+    }, testResourceRequirement: ITTestResourceRequest | undefined, testAdapter: Partial<ITestAdapter<I>> | undefined, testResourceConfiguration: ITestResourceConfiguration);
     receiveTestResourceConfig(testResourceConfig: ITestResourceConfiguration): Promise<any>;
     Specs(): any;
-    Suites(): Record<string, any>;
-    Given(): Record<keyof IExtenstions, (name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], gcb: I["given"]) => BaseGiven<I>>;
-    When(): Record<keyof IExtenstions, (arg0: I["istore"], ...arg1: any) => BaseWhen<I>>;
-    Then(): Record<keyof IExtenstions, (selection: I["iselection"], expectation: any) => BaseThen<I>>;
+    Suites(): {};
+    Given(): Record<string, any>;
+    When(): Record<string, any>;
+    Then(): Record<string, any>;
     Describe(): Record<string, any>;
     It(): Record<string, any>;
     Confirm(): Record<string, any>;
     Value(): Record<string, any>;
     Should(): Record<string, any>;
     Expect(): Record<string, any>;
+    Expected(): Record<string, any>;
     getTestJobs(): ITestJob[];
-    private calculateTotalTests;
+    private createTestJobForStep;
+    private createErrorTestJob;
+    private calculateTotalTestsDirectly;
 }
-export {};

package/dist/types/lib/tiposkripto/src/CoreTypes.d.ts

@@ -1,30 +1,19 @@
-import type { GivenSpecification, WhenSpecification, ThenSpecification, TestWhenImplementation, Modify, TestSuiteImplementation, TestGivenImplementation, TestThenImplementation, TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape } from "../../../Types";
-import type { IGivens } from "./BaseGiven";
-import type { BaseSuite } from "./BaseSuite";
-import type { ITestResourceConfiguration } from "./types";
-export type IArtifactory = {};
-export type SuiteSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
-    [K in keyof O["suites"]]: (name: string, givens: IGivens<I>) => BaseSuite<I, O>;
+import type { ConfirmSpecification, DescribeSpecification, GivenSpecification, ItSpecification, Modify, ShouldSpecification, TestConfirmImplementation, TestConfirmShape, TestDescribeImplementation, TestDescribeShape, TestExpectedImplementation, TestGivenImplementation, TestGivenShape, TestItImplementation, TestItShape, TestShouldImplementation, TestShouldShape, TestSuiteImplementation, TestSuiteShape, TestThenImplementation, TestThenShape, TestValueImplementation, TestValueShape, TestWhenImplementation, TestWhenShape, ThenSpecification, ValueSpecification, WhenSpecification } from "./../../../Types";
+import { ITestResourceConfiguration } from "./types";
+export type IArtifactory = {
+    writeFileSync: (a: string, b: string) => any;
 };
 export type IUniversalTestAdapter<I extends TestTypeParams_any> = {
     prepareAll: (input: I["iinput"], testResource: ITestResourceConfiguration, artifactory?: IArtifactory) => Promise<I["isubject"]>;
-    prepareEach: (subject: I["isubject"], initializer: (c?: any) => I["given"], testResource: ITestResourceConfiguration, initialValues: any, artifactory?: IArtifactory) => Promise<I["istore"]>;
-    execute: (store: I["istore"], actionCB: I["when"], testResource: ITestResourceConfiguration, artifactory?: IArtifactory) => Promise<I["istore"]>;
-    verify: (store: I["istore"], checkCB: I["then"], testResource: ITestResourceConfiguration, artifactory?: IArtifactory) => Promise<I["iselection"]>;
+    prepareEach: (subject: I["isubject"], initializer: (c?: any) => I["check"], testResource: ITestResourceConfiguration, initialValues: any, artifactory?: IArtifactory) => Promise<I["istore"]>;
+    execute: (store: I["istore"], actionCB: I["check"], testResource: ITestResourceConfiguration, artifactory?: IArtifactory) => Promise<I["istore"]>;
+    verify: (store: I["istore"], checkCB: I["check"], testResource: ITestResourceConfiguration, artifactory?: IArtifactory) => Promise<I["iselection"]>;
     cleanupEach: (store: I["istore"], key: string, artifactory?: IArtifactory) => Promise<unknown>;
     cleanupAll: (store: I["istore"], artifactory: IArtifactory) => any;
-    assert: (x: I["then"]) => any;
+    assert: (x: I["check"]) => any;
 };
-export type ITestAdapter<I extends TestTypeParams_any> = IUniversalTestAdapter<I> & {
-    beforeAll?: (input: I["iinput"], testResource: ITestResourceConfiguration, artifactory?: IArtifactory) => Promise<I["isubject"]>;
-    beforeEach?: (subject: I["isubject"], initializer: (c?: any) => I["given"], testResource: ITestResourceConfiguration, initialValues: any, artifactory?: IArtifactory) => Promise<I["istore"]>;
-    afterEach?: (store: I["istore"], key: string, artifactory?: IArtifactory) => Promise<unknown>;
-    afterAll?: (store: I["istore"], artifactory: IArtifactory) => any;
-    andWhen?: (store: I["istore"], actionCB: I["when"], testResource: ITestResourceConfiguration, artifactory?: IArtifactory) => Promise<I["istore"]>;
-    butThen?: (store: I["istore"], checkCB: I["then"], testResource: ITestResourceConfiguration, artifactory?: IArtifactory) => Promise<I["iselection"]>;
-    assertThis?: (x: I["then"]) => any;
-};
-export type ITestSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = (Suite: SuiteSpecification<I, O>, Given: GivenSpecification<I, O>, When: WhenSpecification<I, O>, Then: ThenSpecification<I, O>, Describe: DescribewSpecification<I, O>, It: ItSpecification<I, O>, Confirm: ValueSpecification<I, O>, Value: ValueSpecification<I, O>, Should: ShouldSpecification<I, O>, Expected: ExpectSpecification<I, O>) => BaseSuite<I, O>[];
+export type ITestAdapter<I extends TestTypeParams_any> = IUniversalTestAdapter<I>;
+export type ITestSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = (Given: GivenSpecification<I, O>, When: WhenSpecification<I, O>, Then: ThenSpecification<I, O>, Describe: DescribeSpecification<I, O>, It: ItSpecification<I, O>, Confirm: ConfirmSpecification<I, O>, Value: ValueSpecification<I, O>, Should: ShouldSpecification<I, O>) => any[];
 export type ITestImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any, modifier = {
     whens: TestWhenImplementation<I, O>;
 }> = Modify<{
@@ -32,15 +21,25 @@ export type ITestImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any, m
     givens: TestGivenImplementation<I, O>;
     whens: TestWhenImplementation<I, O>;
     thens: TestThenImplementation<I, O>;
+    confirms: TestConfirmImplementation<I, O>;
+    values: TestValueImplementation<I, O>;
+    shoulds: TestShouldImplementation<I, O>;
+    expecteds: TestExpectedImplementation<I, O>;
+    describes: TestDescribeImplementation<I, O>;
+    its: TestItImplementation<I, O>;
 }, modifier>;
-export type TestSpecShape<ISuites extends TestSuiteShape = TestSuiteShape, ISetups extends TestGivenShape = TestGivenShape, IActions extends TestWhenShape = TestWhenShape, IChecks extends TestThenShape = TestThenShape> = {
-    suites: ISuites;
+export type TestSpecShape<ISetups extends TestGivenShape = TestGivenShape, IActions extends TestWhenShape = TestWhenShape, IChecks extends TestThenShape = TestThenShape, IDescribes extends TestGivenShape = TestGivenShape, IIts extends TestWhenShape = TestWhenShape, IConfirms extends TestGivenShape = TestGivenShape, IValues extends TestGivenShape = TestGivenShape, IShoulds extends TestWhenShape = TestWhenShape> = {
     givens: ISetups;
     whens: IActions;
     thens: IChecks;
+    describes: IDescribes;
+    its: IIts;
+    confirms: IConfirms;
+    values: IValues;
+    should?: IShoulds;
 };
 export type TestSpecShape_any = TestSpecShape<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape>;
-export type Ibdd_out<ISuites extends TestSuiteShape, IGivens extends TestGivenShape, IWhens extends TestWhenShape, IThens extends TestThenShape> = TestSpecShape<ISuites, IGivens, IWhens, IThens>;
+export type Ibdd_out<IGivens extends TestGivenShape, IWhens extends TestWhenShape, IThens extends TestThenShape, IDescribes extends TestDescribeShape, IIts extends TestItShape, IConfirms extends TestConfirmShape, IValues extends TestValueShape, IShoulds extends TestShouldShape> = TestSpecShape<IGivens, IWhens, IThens, IDescribes, IIts, IConfirms, IValues, IShoulds>;
 export type Ibdd_out_any = TestSpecShape_any;
 export type TestTypeParams<IInput, // Type of initial test input
 ISubject, // Type of object being tested
@@ -58,12 +57,12 @@ ICheck> = {
     /** Selected portion of state for assertions */
     iselection: ISelection;
     /** Function type for Setup steps (Given/Arrange/Map) */
-    given: ISetup;
+    setup: ISetup;
     /** Function type for Action steps (When/Act/Feed) */
-    when: IAction;
+    action: IAction;
     /** Function type for Check steps (Then/Assert/Validate) */
-    then: ICheck;
+    check: ICheck;
 };
 export type TestTypeParams_any = TestTypeParams<unknown, unknown, unknown, unknown, unknown, unknown, unknown>;
-export type Ibdd_in<IInput, ISubject, IStore, ISelection, IGiven, IWhen, IThen> = TestTypeParams<IInput, ISubject, IStore, ISelection, IGiven, IWhen, IThen>;
+export type Ibdd_in<IInput, ISubject, IStore, ISelection, ISetup, IAction, ICheck> = TestTypeParams<IInput, ISubject, IStore, ISelection, ISetup, IAction, ICheck>;
 export type Ibdd_in_any = TestTypeParams_any;

package/dist/types/lib/tiposkripto/src/Node.d.ts

@@ -1,8 +1,8 @@
-import type { TestTypeParams_any, TestSpecShape_any, ITestSpecification, ITestImplementation, ITestAdapter } from "./CoreTypes";
-import BaseTiposkripto from "./BaseTiposkripto";
-import type { ITTestResourceRequest } from "./types";
+import BaseTiposkripto from "./BaseTiposkripto.js";
+import { ITTestResourceRequest } from "./types.js";
+import { TestTypeParams_any, TestSpecShape_any, ITestSpecification, ITestImplementation, ITestAdapter } from "./CoreTypes.js";
 export declare class NodeTiposkripto<I extends TestTypeParams_any, O extends TestSpecShape_any, M> extends BaseTiposkripto<I, O, M> {
-    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testAdapter: Partial<ITestAdapter<I>>);
+    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testAdapter: Partial<ITestAdapter<I>>, testResourceRequirement?: ITTestResourceRequest);
     writeFileSync(filename: string, payload: string): void;
 }
 declare const tiposkripto: <I extends TestTypeParams_any, O extends TestSpecShape_any, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testAdapter: Partial<ITestAdapter<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<BaseTiposkripto<I, O, M>>;

package/dist/types/lib/tiposkripto/src/Web.d.ts

@@ -1,6 +1,6 @@
-import type { TestTypeParams_any, TestSpecShape_any, ITestAdapter, ITestImplementation, ITestSpecification } from "./CoreTypes.js";
 import BaseTiposkripto from "./BaseTiposkripto";
-import type { ITTestResourceRequest } from "./types";
+import { TestTypeParams_any, TestSpecShape_any, ITestSpecification, ITestImplementation, ITestAdapter } from "./CoreTypes";
+import { ITTestResourceRequest } from "./types";
 declare global {
     interface Window {
         testResourceConfig?: any;
@@ -15,10 +15,16 @@ export declare class WebTiposkripto<I extends TestTypeParams_any, O extends Test
     openScreencast(filename: string): Promise<void>;
     closeScreencast(filename: string): Promise<void>;
     createArtifactory(context?: {
+        suiteIndex?: number;
         givenKey?: string;
         whenIndex?: number;
         thenIndex?: number;
-        suiteIndex?: number;
+        describeIndex?: number;
+        itIndex?: number;
+        confirmKey?: string;
+        valueKey?: string;
+        shouldIndex?: number;
+        expectKey?: number;
     }): {
         screenshot: (filename: string, payload?: string) => void;
         openScreencast: (filename: string) => Promise<void>;

package/dist/types/lib/tiposkripto/src/index.d.ts

@@ -1,26 +1,18 @@
-import type { Ibdd_in_any, Ibdd_out_any, IUniversalTestAdapter, ITestAdapter, TestTypeParams_any } from "./CoreTypes";
-export declare const BaseAdapter: <T extends TestTypeParams_any>() => IUniversalTestAdapter<T>;
-export declare const DefaultAdapter: <T extends TestTypeParams_any>(p: Partial<ITestAdapter<T>>) => IUniversalTestAdapter<T>;
-export { BaseGiven } from "./BaseGiven.js";
-export { BaseWhen } from "./BaseWhen.js";
-export { BaseThen } from "./BaseThen.js";
-export { BaseValue } from "./BaseValue.js";
-export { BaseShould } from "./BaseShould.js";
-export { BaseExpected } from "./BaseExpected.js";
-export { BaseDescribe } from "./BaseDescribe.js";
-export { BaseIt } from "./BaseIt.js";
-export { BaseSetup } from "./BaseSetup.js";
-export { BaseAction } from "./BaseAction.js";
-export { BaseCheck } from "./BaseCheck.js";
+import { Ibdd_in_any, Ibdd_out_any } from "./CoreTypes.js";
+export { BaseValue } from "./verbs/tdt/BaseValue.js";
+export { BaseShould } from "./verbs/tdt/BaseShould";
+export { BaseExpected } from "./verbs/tdt/BaseExpected.js";
+export { BaseDescribe } from "./verbs/aaa/BaseDescribe.js";
+export { BaseIt } from "./verbs/aaa/BaseIt.js";
 export declare function createDescribeItSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any>(): {
     Suite: {
         Default: (Suite: any, Describe: any, It: any) => (name: string, descriptions: Record<string, any>) => any;
     };
     Describe: {
-        Default: (features: string[], its: any[], describeCB: I["given"], initialValues: any) => (Describe: any) => any;
+        Default: (features: string[], its: any[], describeCB: I["setup"], initialValues: any) => (Describe: any) => any;
     };
     It: {
-        Default: (name: string, itCB: (x: I["iselection"]) => I["then"]) => (It: any) => any;
+        Default: (name: string, itCB: (x: I["iselection"]) => I["check"]) => (It: any) => any;
     };
 };
 export declare function createTDTSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any>(): {
@@ -28,13 +20,13 @@ export declare function createTDTSpecification<I extends Ibdd_in_any, O extends
         Default: (Suite: any, Value: any, Should: any, Expected: any) => (name: string, confirms: Record<string, any>) => any;
     };
     Value: {
-        Default: (features: string[], tableRows: any[][], confirmCB: I["given"], initialValues: any) => (Value: any) => any;
+        Default: (features: string[], tableRows: any[][], confirmCB: I["setup"], initialValues: any) => (Value: any) => any;
     };
     Should: {
-        Default: (name: string, shouldCB: (x: I["iselection"]) => I["then"]) => (Should: any) => any;
+        Default: (name: string, shouldCB: (x: I["iselection"]) => I["check"]) => (Should: any) => any;
     };
     Expected: {
-        Default: (name: string, expectedCB: (val: I["iselection"]) => Promise<I["then"]>) => (Expected: any) => any;
+        Default: (name: string, expectedCB: (val: I["iselection"]) => Promise<I["check"]>) => (Expected: any) => any;
     };
 };
 export declare function DescribeIt<I extends Ibdd_in_any, O extends Ibdd_out_any>(): {
@@ -45,17 +37,17 @@ export declare function DescribeIt<I extends Ibdd_in_any, O extends Ibdd_out_any
         };
     };
     Describe: {
-        Default: (features: string[], its: any[], describeCB: I["given"], initialValues: any) => {
+        Default: (features: string[], its: any[], describeCB: I["setup"], initialValues: any) => {
             features: string[];
             its: any[];
-            describeCB: I["given"];
+            describeCB: I["setup"];
             initialValues: any;
         };
     };
     It: {
-        Default: (name: string, itCB: (x: I["iselection"]) => I["then"]) => {
+        Default: (name: string, itCB: (x: I["iselection"]) => I["check"]) => {
             name: string;
-            itCB: (x: I["iselection"]) => I["then"];
+            itCB: (x: I["iselection"]) => I["check"];
         };
     };
 };
@@ -67,23 +59,23 @@ export declare function Confirm<I extends Ibdd_in_any, O extends Ibdd_out_any>()
         };
     };
     Value: {
-        Default: (features: string[], tableRows: any[][], confirmCB: I["given"], initialValues: any) => {
+        Default: (features: string[], tableRows: any[][], confirmCB: I["setup"], initialValues: any) => {
             features: string[];
             tableRows: any[][];
-            confirmCB: I["given"];
+            confirmCB: I["setup"];
             initialValues: any;
         };
     };
     Should: {
-        Default: (name: string, shouldCB: (x: I["iselection"]) => I["then"]) => {
+        Default: (name: string, shouldCB: (x: I["iselection"]) => I["check"]) => {
             name: string;
-            shouldCB: (x: I["iselection"]) => I["then"];
+            shouldCB: (x: I["iselection"]) => I["check"];
         };
     };
     Expected: {
-        Default: (name: string, expectedCB: (val: I["iselection"]) => Promise<I["then"]>) => {
+        Default: (name: string, expectedCB: (val: I["iselection"]) => Promise<I["check"]>) => {
             name: string;
-            expectedCB: (val: I["iselection"]) => Promise<I["then"]>;
+            expectedCB: (val: I["iselection"]) => Promise<I["check"]>;
         };
     };
 };

package/dist/types/lib/tiposkripto/src/types.d.ts

@@ -1,10 +1,11 @@
-import type { BaseGiven } from "./BaseGiven";
-import type { BaseSuite } from "./BaseSuite";
-import type { BaseThen } from "./BaseThen";
-import type { BaseWhen } from "./BaseWhen";
-import type { Ibdd_in_any, Ibdd_out_any, TestTypeParams_any } from "./CoreTypes";
-export type ISuiteKlasser<I extends Ibdd_in_any, O extends Ibdd_out_any> = (name: string, index: number, givens: IGivens<I>) => BaseSuite<I, O>;
-export type IGivenKlasser<I extends Ibdd_in_any> = (name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], givenCB: I["given"]) => BaseGiven<I>;
+import { Ibdd_in_any, Ibdd_out_any } from "./CoreTypes";
+import { BaseDescribe } from "./verbs/aaa/BaseDescribe";
+import { BaseSuite } from "./verbs/BaseSuite";
+import { BaseGiven } from "./verbs/bdd/BaseGiven";
+import { BaseThen } from "./verbs/bdd/BaseThen";
+import { BaseWhen } from "./verbs/bdd/BaseWhen";
+import { BaseConfirm } from "./verbs/tdt/BaseConfirm";
+export type IGivenKlasser<I extends Ibdd_in_any> = (name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], givenCB: I["setup"]) => BaseGiven<I>;
 export type IWhenKlasser<I extends Ibdd_in_any> = (s: I["istore"], o: any) => BaseWhen<I>;
 export type IThenKlasser<I extends Ibdd_in_any> = (s: I["iselection"], o: any) => BaseThen<I>;
 export type ITestResourceConfiguration = {
@@ -21,24 +22,13 @@ export type ITTestResourceRequirement = {
     ports: number;
     fs: string;
 };
-export type ISetups<I extends TestTypeParams_any> = Record<string, import("./BaseSetup").BaseSetup<I>>;
-export type IActions<I extends TestTypeParams_any> = Record<string, import("./BaseAction").BaseAction<I>>;
-export type IChecks<I extends TestTypeParams_any> = Record<string, import("./BaseCheck").BaseCheck<I>>;
-export type IValues<I extends TestTypeParams_any> = Record<string, import("./BaseValue").BaseValue<I>>;
-export type IShoulds<I extends TestTypeParams_any> = Record<string, import("./BaseShould").BaseShould<I>>;
-export type IExpecteds<I extends TestTypeParams_any> = Record<string, import("./BaseExpected").BaseExpected<I>>;
-export type IDescribes<I extends TestTypeParams_any> = Record<string, import("./BaseDescribe").BaseDescribe<I>>;
-export type IIts<I extends TestTypeParams_any> = Record<string, import("./BaseIt").BaseIt<I>>;
-export type IGivens<I extends TestTypeParams_any> = Record<string, import("./BaseGiven").BaseGiven<I>>;
-export type IWhens<I extends TestTypeParams_any> = Record<string, import("./BaseWhen").BaseWhen<I>>;
-export type IThens<I extends TestTypeParams_any> = Record<string, import("./BaseThen").BaseThen<I>>;
 export type ITTestResourceRequest = {
     ports: number;
 };
 type ITest = {
     toObj(): object;
     name: string;
-    givens: IGivens<Ibdd_in_any>;
+    steps: (BaseGiven<Ibdd_in_any> | BaseDescribe<Ibdd_in_any> | BaseConfirm<Ibdd_in_any>)[];
     testResourceConfiguration: ITestResourceConfiguration;
 };
 export type ITestJob = {
@@ -53,19 +43,21 @@ export type ITestResults = Promise<{
 }>[];
 export declare const defaultTestResourceRequirement: ITTestResourceRequest;
 export type ITestArtifactory = (key: string, value: unknown) => unknown;
-export type IRunnables = {
-    golangEntryPoints: Record<string, string>;
-    nodeEntryPoints: Record<string, string>;
-    pythonEntryPoints: Record<string, string>;
-    webEntryPoints: Record<string, string>;
-};
 export type IFinalResults = {
     features: string[];
     failed: boolean;
     fails: number;
-    artifacts: Promise<unknown>[];
+    artifacts: any[];
     tests: number;
     runTimeTests: number;
     testJob: object;
+    error?: {
+        message: string;
+        stack?: string;
+        name: string;
+    };
+    stepName?: string;
+    stepType?: string;
+    [key: string]: any;
 };
 export {};

package/dist/types/lib/tiposkripto/src/verbs/aaa/BaseDescribe.d.ts

@@ -0,0 +1,39 @@
+import type { TestTypeParams_any } from "../../CoreTypes.js";
+import { BaseIt } from "./BaseIt.js";
+import { ITestResourceConfiguration, ITestArtifactory } from "../../types.js";
+/**
+ * BaseDescribe for AAA (Describe-It) pattern.
+ * Handles the Arrange/Setup phase.
+ */
+export declare class BaseDescribe<I extends TestTypeParams_any> {
+    features: string[];
+    its: BaseIt<I>[];
+    describeCB: I["given"];
+    initialValues: any;
+    error: Error | null;
+    store: I["istore"];
+    key: string;
+    failed: boolean;
+    artifacts: string[];
+    fails: number;
+    status: boolean | undefined;
+    constructor(features: string[], its: BaseIt<I>[], describeCB: I["given"], initialValues: any);
+    addArtifact(path: string): void;
+    describe(subject: I["isubject"], key: string, testResourceConfiguration: ITestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory?: ITestArtifactory, suiteNdx?: number): Promise<I["istore"]>;
+    toObj(): {
+        key: string;
+        its: {
+            name: string;
+            status: boolean | undefined;
+            error: string | null;
+            artifacts: string[];
+        }[];
+        error: (string | undefined)[] | null;
+        failed: boolean;
+        features: string[];
+        artifacts: string[];
+        status: boolean | undefined;
+        fails: number;
+    };
+}
+export type IDescribes<I extends TestTypeParams_any> = Record<string, BaseDescribe<I>>;

package/dist/types/lib/tiposkripto/src/verbs/aaa/BaseIt.d.ts

@@ -0,0 +1,22 @@
+import type { TestTypeParams_any } from "../../CoreTypes.js";
+/**
+ * BaseIt for AAA (Describe-It) pattern.
+ * It combines both Action and Check phases (Act + Assert).
+ */
+export declare class BaseIt<I extends TestTypeParams_any> {
+    name: string;
+    itCB: (xyz: I["iselection"]) => I["check"];
+    error: Error | null;
+    artifacts: string[];
+    status: boolean | undefined;
+    constructor(name: string, itCB: (xyz: I["iselection"]) => I["check"]);
+    addArtifact(path: string): void;
+    test(store: I["istore"], testResourceConfiguration: any, artifactory?: any): Promise<I["check"]>;
+    toObj(): {
+        name: string;
+        status: boolean | undefined;
+        error: string | null;
+        artifacts: string[];
+    };
+}
+export type IIts<I extends TestTypeParams_any> = Record<string, BaseIt<I>>;