testeranto 0.140.2 → 0.146.0

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

@@ -0,0 +1,88 @@
+import { BaseBuilder } from "../basebuilder";
+import {
+  Ibdd_in_any,
+  Ibdd_out_any,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../CoreTypes";
+import {
+  ISuiteKlasser,
+  IGivenKlasser,
+  IWhenKlasser,
+  IThenKlasser,
+  ICheckKlasser,
+} from "../types";
+import { ITTestResourceRequest } from "..";
+
+/**
+ * Concrete implementation of BaseBuilder for testing ClassBuilder
+ */
+export class TestClassBuilder<
+  I extends Ibdd_in_any,
+  O extends Ibdd_out_any,
+  M = unknown
+> extends BaseBuilder<
+  I,
+  O,
+  Record<string, unknown>,
+  Record<string, unknown>,
+  Record<string, unknown>,
+  Record<string, unknown>,
+  Record<string, unknown>
+> {
+  public summary: Record<string, any> = {};
+
+  constructor(
+    testImplementation: ITestImplementation<I, O, M> & {
+      suites: Record<string, any>;
+      givens: Record<string, any>;
+      whens: Record<string, any>;
+      thens: Record<string, any>;
+      checks: Record<string, any>;
+    },
+    testSpecification: ITestSpecification<I, O>,
+    input: I["iinput"],
+    suiteKlasser: ISuiteKlasser<I, O>,
+    givenKlasser: IGivenKlasser<I>,
+    whenKlasser: IWhenKlasser<I>,
+    thenKlasser: IThenKlasser<I>,
+    checkKlasser: ICheckKlasser<I>,
+    testResourceRequirement: ITTestResourceRequest
+  ) {
+    super(
+      input,
+      {}, // suitesOverrides
+      {}, // givenOverides
+      {}, // whenOverides
+      {}, // thenOverides
+      {}, // checkOverides
+      testResourceRequirement,
+      testSpecification
+    );
+
+    this.summary = {};
+  }
+
+  /**
+   * Simplified test run for verification
+   */
+  public testRun(puppetMaster: any): Promise<any> {
+    this.summary = {
+      [puppetMaster.testResourceConfiguration.name]: {
+        typeErrors: 0,
+        staticErrors: 0,
+        runTimeError: "",
+        prompt: "",
+        failingFeatures: {},
+      },
+    };
+
+    return Promise.resolve({
+      failed: false,
+      fails: 0,
+      artifacts: [],
+      logPromise: Promise.resolve(),
+      features: [],
+    });
+  }
+}

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

@@ -0,0 +1,204 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { PassThrough } from "stream";
+
+import { ITestImplementation, ITestSpecification } from "../../CoreTypes";
+import { TestClassBuilder } from "./TestClassBuilder";
+import { I, O, M } from "./classBuilder.test.types";
+
+import { ITTestResourceRequest } from "..";
+import { specification } from "./classBuilder.test.specification";
+
+export const implementation: ITestImplementation<I, O, M> = {
+  suites: {
+    Default: "ClassBuilder test suite",
+  },
+
+  givens: {
+    Default: () => {
+      return new TestClassBuilder(
+        implementation, // Use the current implementation
+        specification, // Use the current specification
+        {}, // Default input
+        class {}, // suiteKlasser
+        class {}, // givenKlasser
+        class {}, // whenKlasser
+        class {}, // thenKlasser
+        class {}, // checkKlasser
+        { ports: [] } // Default resource requirements
+      );
+    },
+    WithCustomInput: (input: any) => {
+      return new TestClassBuilder(
+        implementation,
+        specification,
+        input,
+        class {},
+        class {},
+        class {},
+        class {},
+        class {},
+        { ports: [] }
+      );
+    },
+    WithResourceRequirements: (requirements: ITTestResourceRequest) => {
+      return new TestClassBuilder(
+        implementation,
+        specification,
+        {},
+        class {},
+        class {},
+        class {},
+        class {},
+        class {},
+        requirements
+      );
+    },
+    WithCustomImplementation: (impl: ITestImplementation<any, any>) => {
+      return new TestClassBuilder(
+        impl,
+        specification,
+        {},
+        class {},
+        class {},
+        class {},
+        class {},
+        class {},
+        { ports: [] }
+      );
+    },
+    WithCustomSpecification: (spec: ITestSpecification<any, any>) => {
+      return new TestClassBuilder(
+        implementation,
+        spec,
+        {},
+        class {},
+        class {},
+        class {},
+        class {},
+        class {},
+        { ports: [] }
+      );
+    },
+  },
+
+  whens: {
+    addArtifact: (artifact: Promise<any>) => (builder) => {
+      builder.artifacts.push(artifact);
+      return builder;
+    },
+    setTestJobs: (jobs: any[]) => (builder) => {
+      builder.testJobs = jobs;
+      return builder;
+    },
+    modifySpecs: (modifier: (specs: any[]) => any[]) => (builder) => {
+      builder.specs = modifier(builder.specs || []);
+      return builder;
+    },
+    modifyJobs: (modifier: (jobs: any[]) => any[]) => (builder) => {
+      builder.testJobs = modifier(builder.testJobs || []);
+      return builder;
+    },
+    triggerError: (message: string) => (builder) => {
+      throw new Error(message);
+    },
+  },
+
+  thens: {
+    initializedProperly: () => (builder) => {
+      if (!(builder instanceof TestClassBuilder)) {
+        throw new Error("Builder was not properly initialized");
+      }
+      return builder;
+    },
+    specsGenerated: () => (builder) => {
+      if (!Array.isArray(builder.specs)) {
+        throw new Error("Specs were not generated");
+      }
+      return builder;
+    },
+    jobsCreated: () => (builder) => {
+      if (!Array.isArray(builder.testJobs)) {
+        throw new Error("Test jobs were not created");
+      }
+      return builder;
+    },
+    artifactsTracked: () => (builder) => {
+      if (!Array.isArray(builder.artifacts)) {
+        throw new Error("Artifacts array not initialized");
+      }
+      return builder;
+    },
+    resourceRequirementsSet: () => (builder) => {
+      if (!builder.testResourceRequirement) {
+        throw new Error("Resource requirements not set");
+      }
+      return builder;
+    },
+    suitesOverridesConfigured: () => (builder) => {
+      if (!builder.suitesOverrides) {
+        throw new Error("Suites overrides not configured");
+      }
+      return builder;
+    },
+    givensOverridesConfigured: () => (builder) => {
+      if (!builder.givenOverides) {
+        throw new Error("Givens overrides not configured");
+      }
+      return builder;
+    },
+    whensOverridesConfigured: () => (builder) => {
+      if (!builder.whenOverides) {
+        throw new Error("Whens overrides not configured");
+      }
+      return builder;
+    },
+    thensOverridesConfigured: () => (builder) => {
+      if (!builder.thenOverides) {
+        throw new Error("Thens overrides not configured");
+      }
+      return builder;
+    },
+    checksOverridesConfigured: () => (builder) => {
+      if (!builder.checkOverides) {
+        throw new Error("Checks overrides not configured");
+      }
+      return builder;
+    },
+    specsModified: (expectedCount: number) => (builder) => {
+      if (builder.specs.length <= expectedCount) {
+        throw new Error(`Expected at least ${expectedCount} modified specs`);
+      }
+      return builder;
+    },
+    jobsModified: (expectedCount: number) => (builder) => {
+      if (builder.testJobs.length <= expectedCount) {
+        throw new Error(`Expected at least ${expectedCount} modified jobs`);
+      }
+      return builder;
+    },
+    errorThrown: (expectedMessage: string) => (builder) => {
+      // This is handled by the test runner
+      return builder;
+    },
+    testRunSuccessful: () => async (builder) => {
+      try {
+        await builder.testRun({
+          testResourceConfiguration: {
+            name: "test",
+            fs: "/tmp",
+            ports: [],
+          },
+        });
+        return builder;
+      } catch (e) {
+        throw new Error(`Test run failed: ${e.message}`);
+      }
+    },
+  },
+
+  checks: {
+    Default: () => new PassThrough(),
+    ImplementationCheck: (validator) => validator(implementation),
+    SpecificationCheck: (validator) => validator(specification),
+  },
+};

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

@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ITestInterface } from "../../CoreTypes";
+import { I } from "../baseBuilder.test/baseBuilder.test.types";
+
+export const testInterface: ITestInterface<I> = {
+  beforeEach: async (subject, initializer) => {
+    return initializer();
+  },
+  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

@@ -0,0 +1,113 @@
+import { ITestJob } from "..";
+import { ITestSpecification } from "../../CoreTypes";
+import { I, O } from "./classBuilder.test.types";
+
+export const specification: ITestSpecification<I, O> = (
+  Suite,
+  Given,
+  When,
+  Then,
+  Check
+) => {
+  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(),
+            Then.checksOverridesConfigured(),
+          ]
+        ),
+      },
+      []
+    ),
+
+    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()]
+        ),
+      },
+      [
+        Check.ImplementationCheck((impl) => impl !== null),
+        Check.SpecificationCheck((spec) => spec !== null),
+      ]
+    ),
+  ];
+};

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

@@ -0,0 +1,14 @@
+import Testeranto from "../../Node";
+
+import { ClassBuilder } from "../classBuilder";
+import { specification } from "./classBuilder.test.specification";
+import { implementation } from "./classBuilder.test.implementation";
+import { testInterface } from "./classBuilder.test.interface";
+import { I, O, M } from "./classBuilder.test.types";
+
+export default Testeranto<I, O, M>(
+  ClassBuilder.prototype,
+  specification,
+  implementation,
+  testInterface
+);

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

@@ -0,0 +1,84 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+  Ibdd_in,
+  Ibdd_out,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../CoreTypes";
+import { ClassBuilder } from "../classBuilder";
+import { ITestJob, ITTestResourceRequest } from "..";
+
+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
+  (store: any) => any, // when
+  (store: any) => any // then
+>;
+
+export type O = Ibdd_out<
+  // Suites
+  {
+    Default: [string];
+    ExtendedSuite: [description: string];
+  },
+  // Givens
+  {
+    Default: [];
+    WithCustomInput: [input: any];
+    WithResourceRequirements: [requirements: ITTestResourceRequest];
+    WithCustomImplementation: [impl: ITestImplementation<any, any>];
+    WithCustomSpecification: [spec: ITestSpecification<any, any>];
+  },
+  // Whens
+  {
+    addArtifact: [artifact: Promise<any>];
+    setTestJobs: [jobs: ITestJob[]];
+    modifySpecs: [modifier: (specs: any[]) => any[]];
+    modifyJobs: [modifier: (jobs: ITestJob[]) => ITestJob[]];
+    triggerError: [message: string];
+  },
+  // Thens
+  {
+    initializedProperly: [];
+    specsGenerated: [];
+    jobsCreated: [];
+    artifactsTracked: [];
+    resourceRequirementsSet: [];
+    suitesOverridesConfigured: [];
+    givensOverridesConfigured: [];
+    whensOverridesConfigured: [];
+    thensOverridesConfigured: [];
+    checksOverridesConfigured: [];
+    specsModified: [expectedCount: number];
+    jobsModified: [expectedCount: number];
+    errorThrown: [expectedMessage: string];
+    testRunSuccessful: [];
+  },
+  // Checks
+  {
+    Default: [];
+    ImplementationCheck: [validator: (impl: any) => boolean];
+    SpecificationCheck: [validator: (spec: any) => boolean];
+  }
+>;
+
+export type M = {
+  givens: {
+    [K in keyof O["givens"]]: (
+      ...args: O["givens"][K]
+    ) => ClassBuilder<any, any, any>;
+  };
+  whens: {
+    [K in keyof O["whens"]]: (
+      ...args: O["whens"][K]
+    ) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
+  };
+  thens: {
+    [K in keyof O["thens"]]: (
+      ...args: O["thens"][K]
+    ) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
+  };
+};

package/src/lib/core.test/MockCore.ts

@@ -0,0 +1,49 @@
+import TesterantoCore from "../core";
+
+import {
+  Ibdd_in_any,
+  Ibdd_out_any,
+  ITestImplementation,
+  ITestSpecification,
+  ITestInterface,
+} from "../../CoreTypes";
+import { ITTestResourceRequest, IFinalResults } from "..";
+
+/**
+ * Concrete implementation of Testeranto for testing purposes
+ */
+export class MockCore<
+  I extends Ibdd_in_any,
+  O extends Ibdd_out_any,
+  M = unknown
+> extends TesterantoCore<I, O, M> {
+  constructor(
+    input: I["iinput"],
+    testSpecification: ITestSpecification<I, O>,
+    testImplementation: ITestImplementation<I, O, M>,
+    testResourceRequirement: ITTestResourceRequest = { ports: [] },
+    testInterface: Partial<ITestInterface<I>> = {},
+    uberCatcher: (cb: () => void) => void = (cb) => cb()
+  ) {
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testInterface,
+      uberCatcher
+    );
+  }
+
+  async receiveTestResourceConfig(
+    partialTestResource: string
+  ): Promise<IFinalResults> {
+    return {
+      failed: false,
+      fails: 0,
+      artifacts: [],
+      logPromise: Promise.resolve(),
+      features: [],
+    };
+  }
+}

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

@@ -0,0 +1,129 @@
+import { ITestImplementation } from "../../CoreTypes";
+import { MockCore } from "./MockCore";
+import { I, O, M } from "./core.test.types";
+import { PassThrough } from "stream";
+import { ITTestResourceRequest } from "..";
+import { ITestInterface } from "../../CoreTypes";
+
+export const implementation: ITestImplementation<I, O, M> = {
+  suites: {
+    Default: "Testeranto test suite",
+    ExtendedSuite: "Extended Testeranto test suite",
+  },
+
+  givens: {
+    Default: () => {
+      return new MockCore(
+        {}, // input
+        specification, // testSpecification 
+        implementation, // testImplementation
+        { ports: [] }, // testResourceRequirement
+        testInterface, // testInterface
+        (cb) => cb() // uberCatcher
+      );
+    },
+    WithCustomInput: (input: any) => {
+      return new MockCore(
+        input,
+        specification,
+        implementation,
+        { ports: [] },
+        testInterface,
+        (cb) => cb()
+      );
+    },
+    WithResourceRequirements: (requirements: ITTestResourceRequest) => {
+      return new MockCore(
+        {},
+        specification,
+        implementation,
+        requirements,
+        testInterface,
+        (cb) => cb()
+      );
+    },
+    WithCustomInterface: (customInterface: Partial<ITestInterface<any>>) => {
+      return new MockCore(
+        {},
+        specification,
+        implementation,
+        { ports: [] },
+        {...testInterface, ...customInterface},
+        (cb) => cb()
+      );
+    }
+  },
+
+  whens: {
+    addArtifact: (artifact: Promise<any>) => (builder) => {
+      builder.artifacts.push(artifact);
+      return builder;
+    },
+    setTestJobs: (jobs: any[]) => (builder) => {
+      builder.testJobs = jobs;
+      return builder;
+    },
+    modifySpecs: (modifier: (specs: any[]) => any[]) => (builder) => {
+      builder.specs = modifier(builder.specs || []);
+      return builder;
+    },
+    triggerError: (message: string) => (builder) => {
+      throw new Error(message);
+    },
+  },
+
+  thens: {
+    initializedProperly: () => (builder) => {
+      if (!(builder instanceof MockCore)) {
+        throw new Error("Builder was not properly initialized");
+      }
+      return builder;
+    },
+    specsGenerated: () => (builder) => {
+      if (!Array.isArray(builder.specs)) {
+        throw new Error("Specs were not generated");
+      }
+      return builder;
+    },
+    jobsCreated: () => (builder) => {
+      if (!Array.isArray(builder.testJobs)) {
+        throw new Error("Test jobs were not created");
+      }
+      return builder;
+    },
+    artifactsTracked: () => (builder) => {
+      if (!Array.isArray(builder.artifacts)) {
+        throw new Error("Artifacts array not initialized");
+      }
+      return builder;
+    },
+    resourceRequirementsSet: () => (builder) => {
+      if (!builder.testResourceRequirement) {
+        throw new Error("Resource requirements not set");
+      }
+      return builder;
+    },
+    interfaceConfigured: () => (builder) => {
+      if (!builder.testInterface) {
+        throw new Error("Test interface not configured");
+      }
+      return builder;
+    },
+    errorThrown: (expectedMessage: string) => (builder) => {
+      // Handled by test runner
+      return builder;
+    },
+    testRunSuccessful: () => async (builder) => {
+      try {
+        await builder.receiveTestResourceConfig("");
+        return builder;
+      } catch (e) {
+        throw new Error(`Test run failed: ${e.message}`);
+      }
+    },
+  },
+
+  checks: {
+    Default: () => new PassThrough(),
+  },
+};