testeranto 0.189.0 → 0.198.0

package/src/lib/{classBuilder.test/classBuilder.test.types.ts → Tiposkripto.test/Tiposkripto.types.ts}

@@ -5,18 +5,19 @@ import {
   Ibdd_out,
   ITestImplementation,
   ITestSpecification,
+  ITestAdapter,
 } from "../../CoreTypes";
 
-import { ClassBuilder } from "../classBuilder";
-
 import { ITestJob, ITTestResourceRequest } from "..";
 
+import Tiposkripto from "../Tiposkripto";
+
 export type I = Ibdd_in<
   {}, // iinput
-  ClassBuilder<any, any, any>, // isubject
-  ClassBuilder<any, any, any>, // istore
-  ClassBuilder<any, any, any>, // iselection
-  () => ClassBuilder<any, any, any>, // given
+  Tiposkripto<any, any, any>, // isubject
+  Tiposkripto<any, any, any>, // istore
+  Tiposkripto<any, any, any>, // iselection
+  () => Tiposkripto<any, any, any>, // given
   (store: any) => any, // when
   (store: any) => any // then
 >;
@@ -34,6 +35,7 @@ export type O = Ibdd_out<
     WithResourceRequirements: [requirements: ITTestResourceRequest];
     WithCustomImplementation: [impl: ITestImplementation<any, any>];
     WithCustomSpecification: [spec: ITestSpecification<any, any>];
+    WithCustomAdapter: [adapter: Partial<ITestAdapter<any>>];
   },
   // Whens
   {
@@ -54,6 +56,7 @@ export type O = Ibdd_out<
     givensOverridesConfigured: [];
     whensOverridesConfigured: [];
     thensOverridesConfigured: [];
+    interfaceConfigured: [];
     specsModified: [expectedCount: number];
     jobsModified: [expectedCount: number];
     errorThrown: [expectedMessage: string];
@@ -65,16 +68,16 @@ export type M = {
   givens: {
     [K in keyof O["givens"]]: (
       ...args: O["givens"][K]
-    ) => ClassBuilder<any, any, any>;
+    ) => Tiposkripto<any, any, any>;
   };
   whens: {
     [K in keyof O["whens"]]: (
       ...args: O["whens"][K]
-    ) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
+    ) => (builder: Tiposkripto<any, any, any>) => Tiposkripto<any, any, any>;
   };
   thens: {
     [K in keyof O["thens"]]: (
       ...args: O["thens"][K]
-    ) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
+    ) => (builder: Tiposkripto<any, any, any>) => Tiposkripto<any, any, any>;
   };
 };

package/src/lib/Tiposkripto.ts

@@ -0,0 +1,325 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// Do not add logging to this file as it is used by the pure runtime.
+
+import { PassThrough } from "stream";
+import { NonEmptyObject } from "type-fest";
+
+import type {
+  Ibdd_in_any,
+  Ibdd_out_any,
+  ITestImplementation,
+  ITestSpecification,
+  ITestAdapter,
+} from "../CoreTypes";
+
+import {
+  ITestJob,
+  ITLog,
+  IFinalResults,
+  ITTestResourceConfiguration,
+  ITTestResourceRequest,
+  ITestArtifactory,
+  defaultTestResourceRequirement,
+  DefaultAdapter,
+} from "./index.js";
+import { BaseGiven, IGivens } from "./BaseGiven";
+import { BaseWhen } from "./BaseWhen.js";
+import { BaseThen } from "./BaseThen.js";
+import { IPM } from "./types.js";
+import { BaseSuite } from "./BaseSuite";
+
+type IExtenstions = Record<string, unknown>;
+
+export default abstract class Tiposkripto<
+  I extends Ibdd_in_any = Ibdd_in_any,
+  O extends Ibdd_out_any = Ibdd_out_any,
+  M = unknown
+> {
+  // Add the receiveTestResourceConfig method from TesterantoCore
+  abstract receiveTestResourceConfig(
+    partialTestResource: string
+  ): Promise<IFinalResults>;
+  specs: any;
+
+  assertThis: (t: I["then"]) => any;
+
+  testResourceRequirement: ITTestResourceRequest;
+  artifacts: Promise<unknown>[] = [];
+  testJobs: ITestJob[];
+  testSpecification: ITestSpecification<I, O>;
+  suitesOverrides: Record<keyof IExtenstions, any>;
+  givenOverides: Record<keyof IExtenstions, any>;
+  whenOverides: Record<keyof IExtenstions, any>;
+  thenOverides: Record<keyof IExtenstions, any>;
+  puppetMaster: IPM;
+
+  constructor(
+    input: I["iinput"],
+    testSpecification: ITestSpecification<I, O>,
+    testImplementation: ITestImplementation<I, O, M> & {
+      suites: Record<string, NonEmptyObject<object>>;
+      givens: Record<string, any>;
+      whens: Record<string, any>;
+      thens: Record<string, any>;
+    },
+    testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
+    testAdapter: Partial<ITestAdapter<I>> = {},
+    uberCatcher: (cb: () => void) => void = (cb) => cb()
+  ) {
+    const fullAdapter = DefaultAdapter<I>(testAdapter);
+
+    // Create classy implementations
+    const classySuites = Object.entries(testImplementation.suites).reduce(
+      (a, [key], index) => {
+        a[key] = (somestring: string, givens: IGivens<I>) => {
+          return new (class extends BaseSuite<I, O> {
+            afterAll(
+              store: I["istore"],
+              artifactory: ITestArtifactory,
+              pm: IPM
+            ) {
+              return fullAdapter.afterAll(store, pm);
+            }
+
+            assertThat(t: Awaited<I["then"]>): boolean {
+              return fullAdapter.assertThis(t);
+            }
+
+            async setup(
+              s: I["iinput"],
+              artifactory: ITestArtifactory,
+              tr: ITTestResourceConfiguration,
+              pm: IPM
+            ): Promise<I["isubject"]> {
+              return (
+                fullAdapter.beforeAll?.(s, tr, pm) ??
+                (s as unknown as Promise<I["isubject"]>)
+              );
+            }
+          })(somestring, index, givens);
+        };
+        return a;
+      },
+      {}
+    );
+
+    const classyGivens = Object.entries(testImplementation.givens).reduce(
+      (a, [key, g]) => {
+        a[key] = (
+          name: string,
+          features: string[],
+          whens: BaseWhen<I>[],
+          thens: BaseThen<I>[],
+          gcb: I["given"],
+          initialValues: any
+        ) => {
+          return new (class extends BaseGiven<I> {
+            uberCatcher = uberCatcher;
+
+            async givenThat(
+              subject,
+              testResource,
+              artifactory,
+              initializer,
+              initialValues,
+              pm
+            ) {
+              return fullAdapter.beforeEach(
+                subject,
+                initializer,
+                testResource,
+                initialValues,
+                pm
+              );
+            }
+
+            afterEach(
+              store: I["istore"],
+              key: string,
+              artifactory,
+              pm
+            ): Promise<unknown> {
+              return Promise.resolve(fullAdapter.afterEach(store, key, pm));
+            }
+          })(
+            name,
+            features,
+            whens,
+            thens,
+            testImplementation.givens[key],
+            initialValues
+          );
+        };
+        return a;
+      },
+      {}
+    );
+
+    const classyWhens = Object.entries(testImplementation.whens).reduce(
+      (a, [key, whEn]: [string, (...x: any[]) => any]) => {
+        a[key] = (...payload: any[]) => {
+          return new (class extends BaseWhen<I> {
+            async andWhen(store, whenCB, testResource, pm) {
+              return await fullAdapter.andWhen(store, whenCB, testResource, pm);
+            }
+          })(`${key}: ${payload && payload.toString()}`, whEn(...payload));
+        };
+        return a;
+      },
+      {}
+    );
+
+    const classyThens = Object.entries(testImplementation.thens).reduce(
+      (a, [key, thEn]: [string, (...x: any[]) => any]) => {
+        a[key] = (...args: any[]) => {
+          return new (class extends BaseThen<I> {
+            async butThen(
+              store: any,
+              thenCB,
+              testResource: any,
+              pm: IPM
+            ): Promise<I["iselection"]> {
+              return await fullAdapter.butThen(store, thenCB, testResource, pm);
+            }
+          })(`${key}: ${args && args.toString()}`, thEn(...args));
+        };
+        return a;
+      },
+      {}
+    );
+
+    // Set up the overrides
+    this.suitesOverrides = classySuites;
+    this.givenOverides = classyGivens;
+    this.whenOverides = classyWhens;
+    this.thenOverides = classyThens;
+    this.testResourceRequirement = testResourceRequirement;
+    this.testSpecification = testSpecification;
+
+    // Generate specs
+    this.specs = testSpecification(
+      this.Suites(),
+      this.Given(),
+      this.When(),
+      this.Then()
+    );
+
+    // Create test jobs
+    this.testJobs = this.specs.map((suite: BaseSuite<I, O>) => {
+      const suiteRunner =
+        (suite: BaseSuite<I, O>) =>
+        async (puppetMaster: IPM, tLog: ITLog): Promise<BaseSuite<I, O>> => {
+          try {
+            const x = await suite.run(
+              input,
+              puppetMaster.testResourceConfiguration,
+              (fPath: string, value: string | Buffer | PassThrough) =>
+                puppetMaster.testArtiFactoryfileWriter(
+                  tLog,
+                  (p: Promise<void>) => {
+                    this.artifacts.push(p);
+                  }
+                )(
+                  puppetMaster.testResourceConfiguration.fs + "/" + fPath,
+                  value
+                ),
+              tLog,
+              puppetMaster
+            );
+            return x;
+          } catch (e) {
+            console.error(e.stack);
+            throw e;
+          }
+        };
+
+      const runner = suiteRunner(suite);
+
+      return {
+        test: suite,
+
+        toObj: () => {
+          return suite.toObj();
+        },
+
+        runner,
+
+        receiveTestResourceConfig: async function (
+          puppetMaster: IPM
+        ): Promise<IFinalResults> {
+          const tLog = async (...l: string[]) => {
+            //
+          };
+
+          try {
+            const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);
+            const fails = suiteDone.fails;
+            await puppetMaster.writeFileSync(
+              `tests.json`,
+              JSON.stringify(this.toObj(), null, 2),
+              "test"
+            );
+
+            return {
+              failed: fails > 0,
+              fails,
+              artifacts: this.artifacts || [],
+              features: suiteDone.features(),
+            };
+          } catch (e) {
+            console.error(e.stack);
+            return {
+              failed: true,
+              fails: -1,
+              artifacts: this.artifacts || [],
+              features: [],
+            };
+          }
+        },
+      };
+    });
+  }
+
+  Specs() {
+    return this.specs;
+  }
+  Suites() {
+    return this.suitesOverrides;
+  }
+
+  Given(): Record<
+    keyof IExtenstions,
+    (
+      name: string,
+      features: string[],
+      whens: BaseWhen<I>[],
+      thens: BaseThen<I>[],
+      gcb: I["given"]
+    ) => BaseGiven<I>
+  > {
+    return this.givenOverides;
+  }
+
+  When(): Record<
+    keyof IExtenstions,
+    (arg0: I["istore"], ...arg1: any) => BaseWhen<I>
+  > {
+    return this.whenOverides;
+  }
+
+  Then(): Record<
+    keyof IExtenstions,
+    (selection: I["iselection"], expectation: any) => BaseThen<I>
+  > {
+    return this.thenOverides;
+  }
+
+  // Add a method to access test jobs which can be used by receiveTestResourceConfig
+  getTestJobs(): ITestJob[] {
+    return this.testJobs;
+  }
+}

package/src/lib/abstractBase.test/MockGiven.ts

@@ -1,5 +1,10 @@
-import { BaseGiven, BaseThen, BaseWhen } from "../abstractBase";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import { Ibdd_in_any } from "../../CoreTypes";
+import { BaseGiven } from "../BaseGiven";
+import { BaseThen } from "../BaseThen";
+import { BaseWhen } from "../BaseWhen";
 
 export class MockGiven<I extends Ibdd_in_any> extends BaseGiven<I> {
   constructor(
@@ -21,7 +26,12 @@ export class MockGiven<I extends Ibdd_in_any> extends BaseGiven<I> {
     initialValues: any,
     pm: any
   ): Promise<I["istore"]> {
-    return givenCB();
+    // Call the givenCB which is a function that returns the store
+    const result = givenCB();
+    if (typeof result === 'function') {
+      return result();
+    }
+    return result;
   }
 
   uberCatcher(e: Error): void {

package/src/lib/abstractBase.test/MockThen.ts

@@ -1,5 +1,7 @@
-import { BaseThen } from "../abstractBase";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Ibdd_in_any } from "../../CoreTypes";
+import { BaseThen } from "../BaseThen";
 
 export class MockThen<I extends Ibdd_in_any> extends BaseThen<I> {
   constructor(
@@ -15,6 +17,9 @@ export class MockThen<I extends Ibdd_in_any> extends BaseThen<I> {
     testResourceConfiguration: any,
     pm: any
   ): Promise<I["iselection"]> {
-    return thenCB(store);
+    // The thenCB expects a selection, not the store directly
+    // We need to extract the selection from the store
+    const selection = { testSelection: (store as any).testSelection };
+    return thenCB(selection as any);
   }
 }

package/src/lib/abstractBase.test/MockWhen.ts

@@ -1,5 +1,8 @@
-import { BaseWhen } from "../abstractBase";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import { Ibdd_in_any } from "../../CoreTypes";
+import { BaseWhen } from "../BaseWhen";
 
 export class MockWhen<I extends Ibdd_in_any> extends BaseWhen<I> {
   constructor(name: string, whenCB: (x: I["iselection"]) => I["then"]) {
@@ -12,6 +15,11 @@ export class MockWhen<I extends Ibdd_in_any> extends BaseWhen<I> {
     testResource: any,
     pm: any
   ): Promise<I["istore"]> {
-    return whenCB(store);
+    // The whenCB returns a function that takes the store
+    const result = whenCB(store as any);
+    if (typeof result === 'function') {
+      return result(store);
+    }
+    return result;
   }
 }

package/src/lib/abstractBase.test/adapter.ts

@@ -1,12 +1,26 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { ITestAdapter } from "../../CoreTypes";
 import { I } from "./types";
 
 export const testAdapter: ITestAdapter<I> = {
-  beforeEach: async (subject, initializer) => initializer(),
-  andWhen: async (store, whenCB) => whenCB(store),
-  butThen: async (store, thenCB) => thenCB(store),
-  afterEach: (store) => store,
-  afterAll: () => {},
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    const result = await initializer();
+    // Ensure the result matches the expected type
+    if (typeof result === "function") {
+      // If it's a function, call it to get the actual store
+      return result();
+    }
+    return result;
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    return whenCB(store);
+  },
+  butThen: async (store, thenCB, testResource, pm) => {
+    return thenCB(store);
+  },
+  afterEach: async (store, key, pm) => Promise.resolve(store),
+  afterAll: async (store, pm) => {},
   assertThis: (result) => !!result,
-  beforeAll: async (input) => input as any,
+  beforeAll: async (input, testResource, pm) => input as any,
 };

package/src/lib/abstractBase.test/implementation.ts

@@ -8,34 +8,34 @@ export const implementation: ITestImplementation<I, O> = {
   },
 
   givens: {
-    Default: () => ({
+    Default: () => () => ({
       testStore: { value: "initial" },
       testSelection: { selected: true },
     }),
-    WithError: () => ({
+    WithError: () => () => ({
       testStore: { value: "error" },
       testSelection: { selected: false },
     }),
   },
 
   whens: {
-    modifyStore: (newValue: string) => (store) => ({
+    modifyStore: (newValue: string) => (store: any) => ({
       ...store,
       testStore: { value: newValue },
     }),
-    throwError: () => () => {
+    throwError: () => (store: any) => {
       throw new Error("Test error");
     },
   },
 
   thens: {
-    verifyStore: (expected: string) => (store) => {
+    verifyStore: (expected: string) => (store: any) => {
       if (store.testStore.value !== expected) {
         throw new Error(`Expected ${expected}, got ${store.testStore.value}`);
       }
       return store;
     },
-    verifyError: (expected: string) => (store) => {
+    verifyError: (expected: string) => (store: any) => {
       if (!store.error || !store.error.message.includes(expected)) {
         throw new Error(`Expected error "${expected}" not found`);
       }

package/src/lib/abstractBase.test/types.ts

@@ -5,9 +5,9 @@ export type I = Ibdd_in<
   {}, // isubject
   { testStore: { value: string }; error?: Error }, // istore
   { testSelection: { selected: boolean } }, // iselection
-  () => { testStore: { value: string } }, // given
-  (store: any) => any, // when
-  (store: any) => any // then
+  () => () => { testStore: { value: string } }, // given
+  (store: any) => (store: any) => any, // when
+  (store: any) => (store: any) => any // then
 >;
 
 export type O = Ibdd_out<

package/src/lib/index.ts

@@ -8,28 +8,38 @@ import { PM_Node } from "../PM/node";
 import { PM_Pure } from "../PM/pure";
 import { PM_Web } from "../PM/web";
 import { ITestconfig, IBuiltConfig, IRunTime, ITestTypes } from "../Types";
-import { IGivens } from "./abstractBase";
+import { IGivens } from "./BaseGiven";
+
 import { BaseSuite } from "./BaseSuite";
 import { IPM } from "./types";
 
 export const BaseAdapter = <T extends Ibdd_in_any>(): ITestAdapter<T> => ({
-  beforeAll: async (s: T["istore"]) => s,
+  beforeAll: async (
+    input: T["iinput"],
+    testResource: ITTestResourceConfiguration,
+    pm: IPM
+  ) => {
+    return input as unknown as T["isubject"];
+  },
   beforeEach: async function (
     subject: T["isubject"],
-    initialValues: T["iinitialValues"],
-    x: unknown,
+    initializer: (c?: any) => T["given"],
     testResource: ITTestResourceConfiguration,
+    initialValues: any,
     pm: IPM
-  ): Promise<T["isubject"]> {
-    return subject;
+  ): Promise<T["istore"]> {
+    return subject as unknown as T["istore"];
   },
-  afterEach: async (s: T["istore"]) => s,
-  afterAll: (store: T["istore"]) => undefined,
+  afterEach: async (store: T["istore"], key: string, pm: IPM) =>
+    Promise.resolve(store),
+  afterAll: (store: T["istore"], pm: IPM) => undefined,
   butThen: async (
     store: T["istore"],
-    thenCb: (s: T["iselection"]) => Promise<T["isubject"]>
+    thenCb: T["then"],
+    testResource: ITTestResourceConfiguration,
+    pm: IPM
   ) => {
-    return thenCb(store);
+    return thenCb(store, pm);
   },
   andWhen: async (
     store: T["istore"],
@@ -37,23 +47,19 @@ export const BaseAdapter = <T extends Ibdd_in_any>(): ITestAdapter<T> => ({
     testResource: ITTestResourceConfiguration,
     pm: IPM
   ) => {
-    try {
-      await whenCB(store, testResource, pm);
-    } catch (error) {
-      console.error("Error in andWhen:", error);
-      throw error; // Re-throw to maintain test failure
-    }
+    return whenCB(store, pm);
   },
-  assertThis: (x: any) => x,
+  assertThis: (x: T["then"]) => x,
 });
 
 export const DefaultAdapter = <T extends Ibdd_in_any>(
   p: Partial<ITestAdapter<T>>
 ): ITestAdapter<T> => {
+  const base = BaseAdapter<T>();
   return {
-    ...BaseAdapter,
+    ...base,
     ...p,
-  };
+  } as ITestAdapter<T>;
 };
 
 export type ITTestResourceConfiguration = {
@@ -84,7 +90,7 @@ export type ILogWriter = {
   mkdirSync: () => any;
   testArtiFactoryfileWriter: (
     tLog: ITLog,
-    n: (Promise) => void
+    n: (promise: Promise<any>) => void
   ) => (fPath: string, value: unknown) => void;
 };
 

package/src/lib/mocks.test.ts

@@ -1,10 +1,11 @@
-import { Ibdd_in_any, Ibdd_out_any, ITestSpecification } from "../CoreTypes";
+// import { Ibdd_in_any, Ibdd_out_any, ITestSpecification } from "../CoreTypes";
+// import { BaseSuite } from "./BaseSuite";
 
-export const mockTestSpecification = (): ITestSpecification<
-  Ibdd_in_any,
-  Ibdd_out_any
-> => {
-  return () => {
-    return new BaseSuite();
-  };
-};
+// export const mockTestSpecification = (): ITestSpecification<
+//   Ibdd_in_any,
+//   Ibdd_out_any
+// > => {
+//   return () => {
+//     return new BaseSuite();
+//   };
+// };

package/src/lib/pmProxy.test/adapter.ts

@@ -48,7 +48,15 @@ export const testAdapter: ITestAdapter<I> = {
     };
   },
 
-  assertThis: (returnedFilePath, expectation) => {
-    assert.equal(returnedFilePath, expectation);
+  assertThis: (actualResult, expectedResult) => {
+    // Handle both path assertions and our new test result
+    if (typeof actualResult === 'string' && actualResult.startsWith('PASS')) {
+      assert.equal(actualResult, 'PASS', 'tests.json should be written with correct path and content');
+    } else if (typeof actualResult === 'string' && actualResult.startsWith('FAIL')) {
+      // For the tests.json write test, we want to see what's actually happening
+      assert.fail(`Test failed: ${actualResult}`);
+    } else {
+      assert.equal(actualResult, expectedResult);
+    }
   },
 };