testeranto 0.197.0 → 0.198.0

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,12 +8,17 @@ 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 (input: T["iinput"], testResource: ITTestResourceConfiguration, pm: IPM) => {
+  beforeAll: async (
+    input: T["iinput"],
+    testResource: ITTestResourceConfiguration,
+    pm: IPM
+  ) => {
     return input as unknown as T["isubject"];
   },
   beforeEach: async function (
@@ -25,7 +30,8 @@ export const BaseAdapter = <T extends Ibdd_in_any>(): ITestAdapter<T> => ({
   ): Promise<T["istore"]> {
     return subject as unknown as T["istore"];
   },
-  afterEach: async (store: T["istore"], key: string, pm: IPM) => Promise.resolve(store),
+  afterEach: async (store: T["istore"], key: string, pm: IPM) =>
+    Promise.resolve(store),
   afterAll: (store: T["istore"], pm: IPM) => undefined,
   butThen: async (
     store: T["istore"],

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/types.ts

@@ -6,9 +6,11 @@ import type { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
 import { PM_Node } from "../PM/node";
 import { PM_Pure } from "../PM/pure";
 import { PM_Web } from "../PM/web";
+import { IGivens, BaseGiven } from "./BaseGiven";
 
-import { IGivens, BaseGiven, BaseWhen, BaseThen } from "./abstractBase";
 import { BaseSuite } from "./BaseSuite";
+import { BaseThen } from "./BaseThen";
+import { BaseWhen } from "./BaseWhen";
 
 export type IPM = PM_Node | PM_Web | PM_Pure;
 

package/src/run.ts

@@ -25,18 +25,33 @@ if (mode !== "once" && mode !== "dev") {
   process.exit(-1);
 }
 
-import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
-  const bigConfig: IProject = module.default;
+const f = process.cwd() + "/" + "testeranto.config.ts";
+
+console.log("config file:", f);
+
+import(f).then(async (module) => {
+  const bigConfig: IProject = module.default || module;
 
   const rawConfig: ITestconfig = bigConfig.projects[projectName];
 
+  if (!rawConfig) {
+    console.error(`Project "${projectName}" does not exist in the configuration.`);
+    console.error("Available projects:", Object.keys(bigConfig.projects));
+    process.exit(-1);
+  }
+
+  if (!rawConfig.tests) {
+    console.error(projectName, "appears to have no tests: ", f);
+    console.error(`here is the config:`);
+    console.log(JSON.stringify(rawConfig));
+    process.exit(-1);
+  }
+
   const config: IBuiltConfig = {
     ...rawConfig,
     buildDir: process.cwd() + "/" + `testeranto/${projectName}.json`,
   };
 
-  if (!config.tests) throw "config has no tests?";
-
   const pm = new PM_Main(config, projectName, mode);
   pm.start();