testeranto 0.189.0 → 0.198.0

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

@@ -1,138 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ITestImplementation } from "../../CoreTypes";
-import { MockBaseBuilder } from "./baseBuilder.test.mock";
-
-import { I, O } from "./baseBuilder.test.types";
-import { ITestJob, ITTestResourceRequest } from "..";
-import { BaseBuilder } from "../basebuilder";
-
-// Define our test subject type
-type TestSubject = MockBaseBuilder<any, any, any, any, any, any>;
-
-export const implementation: ITestImplementation<I, O, {}> = {
-  suites: {
-    Default: "BaseBuilder test suite",
-  },
-
-  givens: {
-    "the default BaseBuilder": () => {
-      return new MockBaseBuilder(
-        {}, // input
-        {}, // suitesOverrides
-        {}, // givenOverrides
-        {}, // whenOverrides
-        {}, // thenOverrides
-        { ports: 0 }, // testResourceRequirement
-        () => [] // testSpecification
-      );
-    },
-    "a BaseBuilder with TestInput": (input: any) => {
-      return new MockBaseBuilder(
-        input,
-        {},
-        {},
-        {},
-        {},
-        { ports: [] },
-        () => []
-      );
-    },
-    "a BaseBuilder with Test Resource Requirements": (
-      requirements: ITTestResourceRequest
-    ) => {
-      return new MockBaseBuilder({}, {}, {}, {}, {}, requirements, () => []);
-    },
-  },
-
-  whens: {
-    addArtifact: (artifact: Promise<any>) => (builder: TestSubject) => {
-      builder.artifacts.push(artifact);
-      return builder;
-    },
-    setTestJobs: (jobs: ITestJob[]) => (builder: TestSubject) => {
-      builder.testJobs = jobs;
-      return builder;
-    },
-  },
-
-  thens: {
-    "it is initialized": () => (builder, utils) => {
-      utils.writeFileSync("hello.txt", "world");
-
-      if (!(builder instanceof BaseBuilder)) {
-        console.error("Builder instance:", builder);
-        throw new Error(
-          `Builder was not properly initialized - expected BaseBuilder instance but got ${builder?.constructor?.name}`
-        );
-      }
-
-      // Verify required properties exist
-      [
-        "artifacts",
-        "testJobs",
-        "specs",
-        "suitesOverrides",
-        "givenOverides",
-        "whenOverides",
-        "thenOverides",
-      ].forEach((prop) => {
-        if (!(prop in builder)) {
-          throw new Error(`Builder missing required property: ${prop}`);
-        }
-      });
-
-      return builder;
-    },
-    "it generates TestSpecifications": () => (builder: TestSubject) => {
-      if (!Array.isArray(builder.specs)) {
-        throw new Error("Specs were not generated");
-      }
-      return builder;
-    },
-    "it creates jobs": () => (builder: TestSubject) => {
-      if (!Array.isArray(builder.testJobs)) {
-        throw new Error("Test jobs were not created");
-      }
-      return builder;
-    },
-    "it tracks artifacts": () => (builder: TestSubject, utils) => {
-      if (!Array.isArray(builder.artifacts)) {
-        throw new Error("Artifacts array not initialized");
-      }
-      // Verify we can write artifacts
-      utils.writeFileSync("artifact_test.txt", "test");
-      return builder;
-    },
-    resourceRequirementsSet: () => (builder: TestSubject) => {
-      if (!builder.testResourceRequirement) {
-        throw new Error("Resource requirements not set");
-      }
-      return builder;
-    },
-    suitesOverridesConfigured: () => (builder: TestSubject) => {
-      if (!builder.suitesOverrides) {
-        throw new Error("Suites overrides not configured");
-      }
-      return builder;
-    },
-    givensOverridesConfigured: () => (builder: TestSubject) => {
-      if (!builder.givenOverides) {
-        throw new Error("Givens overrides not configured");
-      }
-      return builder;
-    },
-    whensOverridesConfigured: () => (builder: TestSubject) => {
-      if (!builder.whenOverides) {
-        throw new Error("Whens overrides not configured");
-      }
-      return builder;
-    },
-    thensOverridesConfigured: () => (builder: TestSubject) => {
-      if (!builder.thenOverides) {
-        throw new Error("Thens overrides not configured");
-      }
-      return builder;
-    },
-  },
-};

package/src/lib/baseBuilder.test/baseBuilder.test.mock.ts

@@ -1,90 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Ibdd_in_any, Ibdd_out_any, ITestSpecification } from "../../CoreTypes";
-
-import { BaseBuilder } from "../basebuilder";
-
-import {
-  ISuiteKlasser,
-  IGivenKlasser,
-  IWhenKlasser,
-  IThenKlasser,
-} from "../types";
-import { ITTestResourceRequest } from "..";
-
-/**
- * Concrete implementation of BaseBuilder for testing purposes only
- */
-export class MockBaseBuilder<
-  I extends Ibdd_in_any,
-  O extends Ibdd_out_any,
-  SuiteExtensions = {},
-  GivenExtensions = {},
-  WhenExtensions = {},
-  ThenExtensions = {}
-> extends BaseBuilder<
-  I,
-  O,
-  SuiteExtensions,
-  GivenExtensions,
-  WhenExtensions,
-  ThenExtensions
-> {
-  public summary: Record<string, any> = {};
-
-  constructor(
-    input: I["iinput"],
-    suitesOverrides: Record<
-      keyof SuiteExtensions,
-      ISuiteKlasser<I, O>
-    > = {} as any,
-    givenOverrides: Record<keyof GivenExtensions, IGivenKlasser<I>> = {} as any,
-    whenOverrides: Record<keyof WhenExtensions, IWhenKlasser<I>> = {} as any,
-    thenOverrides: Record<keyof ThenExtensions, IThenKlasser<I>> = {} as any,
-    testResourceRequirement: ITTestResourceRequest = { ports: 0 },
-    testSpecification: ITestSpecification<I, O> = () => []
-  ) {
-    super(
-      input,
-      suitesOverrides,
-      givenOverrides,
-      whenOverrides,
-      thenOverrides,
-      testResourceRequirement,
-      testSpecification
-    );
-  }
-
-  /**
-   * Simplified version for testing that doesn't actually run tests
-   */
-  public async testRun(puppetMaster: any): Promise<any> {
-    try {
-      this.summary = {
-        [puppetMaster.testResourceConfiguration.name]: {
-          typeErrors: 0,
-          staticErrors: 0,
-          runTimeError: "",
-          prompt: "",
-          failingFeatures: {},
-        },
-      };
-
-      return {
-        failed: false,
-        fails: 0,
-        artifacts: this.artifacts,
-        features: [],
-      };
-    } catch (error) {
-      console.error("Test run failed:", error);
-      return {
-        failed: true,
-        fails: 1,
-        artifacts: this.artifacts,
-        features: [],
-        error: error.message
-      };
-    }
-  }
-}

package/src/lib/baseBuilder.test/baseBuilder.test.node.ts

@@ -1,16 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Node";
-
-import { specification } from "./baseBuilder.test.specification";
-import { implementation } from "./baseBuilder.test.implementation";
-import { testAdapter } from "./baseBuilder.test.adapter";
-import { I, O } from "./baseBuilder.test.types";
-
-import { MockBaseBuilder } from "./baseBuilder.test.mock";
-
-export default Testeranto<I, O, {}>(
-  MockBaseBuilder.prototype,
-  specification,
-  implementation,
-  testAdapter
-);

package/src/lib/baseBuilder.test/baseBuilder.test.pure.ts

@@ -1,16 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Pure";
-
-import { specification } from "./baseBuilder.test.specification";
-import { implementation } from "./baseBuilder.test.implementation";
-import { testAdapter } from "./baseBuilder.test.adapter";
-import { I, O } from "./baseBuilder.test.types";
-
-import { MockBaseBuilder } from "./baseBuilder.test.mock";
-
-export default Testeranto<I, O, {}>(
-  MockBaseBuilder.prototype,
-  specification,
-  implementation,
-  testAdapter
-);

package/src/lib/baseBuilder.test/baseBuilder.test.specification.ts

@@ -1,35 +0,0 @@
-import { ITestSpecification } from "../../CoreTypes";
-
-import { I, O } from "./baseBuilder.test.types";
-
-export const specification: ITestSpecification<I, O> = (
-  Suite,
-  Given,
-  When,
-  Then
-) => {
-  return [
-    Suite.Default("Testing BaseBuilder functionality", {
-      testInitialization: Given["the default BaseBuilder"](
-        ["BaseBuilder should initialize correctly"],
-        [],
-        [
-          Then["it is initialized"](),
-          Then["it tracks artifacts"](),
-          // Then["it creates jobs"](),
-          // Then["it generates TestSpecifications"](),
-        ]
-      ),
-      testSpecsGeneration: Given["the default BaseBuilder"](
-        ["BaseBuilder should generate specs from test specification"],
-        [],
-        [Then["it generates TestSpecifications"]()]
-      ),
-      testJobsCreation: Given["the default BaseBuilder"](
-        ["BaseBuilder should create test jobs"],
-        [],
-        [Then["it creates jobs"]()]
-      ),
-    }),
-  ];
-};

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

@@ -1,36 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
-import { BaseBuilder } from "../basebuilder";
-
-export type I = Ibdd_in<
-  {}, // iinput
-  BaseBuilder<any, any, any, any, any, any>, // isubject
-  BaseBuilder<any, any, any, any, any, any>, // istore
-  BaseBuilder<any, any, any, any, any, any>, // iselection
-  () => BaseBuilder<any, any, any, any, any, any>, // given
-  (store: any) => any, // when
-  (store: any) => any // then
->;
-
-export type O = Ibdd_out<
-  // Suites
-  {
-    Default: [string];
-  },
-  // Givens
-  {
-    "the default BaseBuilder": [];
-    "a BaseBuilder with TestInput": [];
-    "a BaseBuilder with Test Resource Requirements": [];
-  },
-  // Whens
-  {}, // No whens in these tests
-  // Thens
-  {
-    "it is initialized": [];
-    "it generates TestSpecifications": [];
-    "it creates jobs": [];
-    "it tracks artifacts": [];
-  }
->;

package/src/lib/baseBuilder.test/baseBuilder.test.web.ts

@@ -1,16 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Web";
-
-import { specification } from "./baseBuilder.test.specification";
-import { implementation } from "./baseBuilder.test.implementation";
-import { testAdapter } from "./baseBuilder.test.adapter";
-import { I, O } from "./baseBuilder.test.types";
-
-import { MockBaseBuilder } from "./baseBuilder.test.mock";
-
-export default Testeranto<I, O, {}>(
-  MockBaseBuilder.prototype,
-  specification,
-  implementation,
-  testAdapter
-);

package/src/lib/basebuilder.ts

@@ -1,192 +0,0 @@
-/* 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 type {
-  Ibdd_in_any,
-  Ibdd_out_any,
-  ITestSpecification,
-} from "../CoreTypes";
-
-import { ITestJob, ITLog, IFinalResults, ITTestResourceRequest } from ".";
-import {
-  ISuiteKlasser,
-  IGivenKlasser,
-  IWhenKlasser,
-  IThenKlasser,
-  IPM,
-} from "./types.js";
-import { BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
-import { BaseSuite } from "./BaseSuite";
-
-export abstract class BaseBuilder<
-  I extends Ibdd_in_any,
-  O extends Ibdd_out_any,
-  SuiteExtensions,
-  GivenExtensions,
-  WhenExtensions,
-  ThenExtensions
-> {
-  specs: any;
-
-  assertThis: (t: I["then"]) => {};
-
-  testResourceRequirement: ITTestResourceRequest;
-  artifacts: Promise<unknown>[] = [];
-  testJobs: ITestJob[];
-  testSpecification: ITestSpecification<I, O>;
-  suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>;
-  givenOverides: Record<keyof GivenExtensions, IGivenKlasser<I>>;
-  whenOverides: Record<keyof WhenExtensions, IWhenKlasser<I>>;
-  thenOverides: Record<keyof ThenExtensions, IThenKlasser<I>>;
-  puppetMaster: IPM;
-
-  constructor(
-    input: I["iinput"],
-    suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>,
-    givenOverides: Record<keyof GivenExtensions, IGivenKlasser<I>>,
-    whenOverides: Record<keyof WhenExtensions, IWhenKlasser<I>>,
-    thenOverides: Record<keyof ThenExtensions, IThenKlasser<I>>,
-    testResourceRequirement: ITTestResourceRequest,
-    testSpecification: any
-  ) {
-    this.artifacts = [];
-    this.testResourceRequirement = testResourceRequirement;
-    this.suitesOverrides = suitesOverrides;
-    this.givenOverides = givenOverides;
-    this.whenOverides = whenOverides;
-    this.thenOverides = thenOverides;
-    this.testSpecification = testSpecification;
-
-    this.specs = testSpecification(
-      this.Suites(),
-      this.Given(),
-      this.When(),
-      this.Then()
-    );
-
-    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);
-          }
-        };
-
-      const runner = suiteRunner(suite);
-
-      return {
-        test: suite,
-
-        toObj: () => {
-          return suite.toObj();
-        },
-
-        runner,
-
-        receiveTestResourceConfig: async function (
-          puppetMaster: IPM
-        ): Promise<IFinalResults> {
-          // deprecated?
-          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),
-            ]);
-
-            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: [],
-            };
-          }
-
-          // const logPromise = new Promise(async (res) => {
-          //   await puppetMaster.end(access);
-          //   res(true);
-          // });
-        },
-      };
-    });
-  }
-
-  // testsJson() {
-  //   puppetMaster.writeFileSync(
-  //     `tests.json`,
-  //     JSON.stringify({ features: suiteDone.features() }, null, 2)
-  //   );
-  // }
-
-  Specs() {
-    return this.specs;
-  }
-  Suites() {
-    return this.suitesOverrides;
-  }
-
-  Given(): Record<
-    keyof GivenExtensions,
-    (
-      name: string,
-      features: string[],
-      whens: BaseWhen<I>[],
-      thens: BaseThen<I>[],
-      gcb
-    ) => BaseGiven<I>
-  > {
-    return this.givenOverides;
-  }
-
-  When(): Record<
-    keyof WhenExtensions,
-    (arg0: I["istore"], ...arg1: any) => BaseWhen<I>
-  > {
-    return this.whenOverides;
-  }
-
-  Then(): Record<
-    keyof ThenExtensions,
-    (selection: I["iselection"], expectation: any) => BaseThen<I>
-  > {
-    return this.thenOverides;
-  }
-}

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

@@ -1,25 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { ITestAdapter } from "../../CoreTypes";
-
-import { I } from "../baseBuilder.test/baseBuilder.test.types";
-
-export const testAdapter: ITestAdapter<I> = {
-  beforeAll: async () => {},
-  beforeEach: async (subject, initializer) => {
-    console.log("Running beforeEach with initializer:", initializer);
-    const result = await initializer();
-    console.log("Initializer returned:", result);
-    return result;
-  },
-  andWhen: async (store, whenCB, testResource, utils) => {
-    return whenCB(store, utils);
-  },
-  butThen: async (store, thenCB, testResource, pm) => {
-    return thenCB(store, pm);
-  },
-  afterEach: (store) => store,
-  afterAll: () => {},
-  assertThis: (x: any) => {},
-};

package/src/lib/classBuilder.test/classBuilder.test.specification.ts

@@ -1,104 +0,0 @@
-import { ITestSpecification } from "../../CoreTypes";
-import { I, O } from "./classBuilder.test.types";
-import { implementation } from "./classBuilder.test.implementation";
-
-export const specification: ITestSpecification<I, O> = (
-  Suite,
-  Given,
-  When,
-  Then
-) => {
-  return [
-    Suite.Default("Basic ClassBuilder Functionality", {
-      // Basic initialization tests
-      initialization: Given.Default(
-        ["ClassBuilder should initialize with default values"],
-        [],
-        [Then.initializedProperly()]
-      ),
-      customInput: Given.WithCustomInput(
-        { custom: "input" },
-        [],
-        [Then.initializedProperly()]
-      ),
-      resourceRequirements: Given.WithResourceRequirements(
-        { ports: [3000, 3001] },
-        [],
-        [Then.resourceRequirementsSet()]
-      ),
-
-      // Core functionality tests
-      specGeneration: Given.Default(
-        ["Should generate specs from test specification"],
-        [],
-        [Then.specsGenerated()]
-      ),
-      jobCreation: Given.Default(
-        ["Should create test jobs from specs"],
-        [],
-        [Then.jobsCreated()]
-      ),
-      artifactTracking: Given.Default(
-        ["Should track artifacts"],
-        [When.addArtifact(Promise.resolve("test"))],
-        [Then.artifactsTracked()]
-      ),
-
-      // Configuration tests
-      overridesConfiguration: Given.Default(
-        ["Should properly configure all overrides"],
-        [],
-        [
-          Then.suitesOverridesConfigured(),
-          Then.givensOverridesConfigured(),
-          Then.whensOverridesConfigured(),
-          Then.thensOverridesConfigured(),
-        ]
-      ),
-    }),
-
-    Suite.ExtendedSuite(
-      "Advanced ClassBuilder Functionality",
-      {
-        // Custom implementations
-        customImplementation: Given.WithCustomImplementation(
-          implementation,
-          [],
-          [Then.specsGenerated(), Then.jobsCreated()]
-        ),
-        customSpecification: Given.WithCustomSpecification(
-          specification,
-          [],
-          [Then.specsGenerated(), Then.jobsCreated()]
-        ),
-
-        // Dynamic modification tests
-        modifySpecs: Given.Default(
-          ["Should allow modifying specs"],
-          [When.modifySpecs((specs) => [...specs, "extra"])],
-          [Then.specsModified(1)]
-        ),
-        modifyJobs: Given.Default(
-          ["Should allow modifying jobs"],
-          [When.modifyJobs((jobs) => [...jobs, {} as ITestJob])],
-          [Then.jobsModified(1)]
-        ),
-
-        // Error handling
-        errorHandling: Given.Default(
-          ["Should properly handle errors"],
-          [When.triggerError("test error")],
-          [Then.errorThrown("test error")]
-        ),
-
-        // Full test run
-        testRun: Given.Default(
-          ["Should complete a full test run successfully"],
-          [],
-          [Then.testRunSuccessful()]
-        ),
-      },
-      []
-    ),
-  ];
-};

package/src/lib/classBuilder.test/classBuilder.test.ts

@@ -1,14 +0,0 @@
-import Testeranto from "../../Node";
-import { ClassBuilder } from "../classBuilder";
-import { specification } from "./classBuilder.test.specification"; 
-import { implementation } from "./classBuilder.test.implementation";
-import { testAdapter } from "./classBuilder.test.adapter";
-import { I, O, M } from "./classBuilder.test.types";
-
-export default Testeranto<I, O, M>(
-  ClassBuilder.prototype,
-  specification,
-  implementation,
-  testAdapter,
-  { ports: 1 } // Add resource requirements
-);