testeranto 0.140.2 → 0.146.0

package/src/lib/BaseSuite.ts

@@ -95,21 +95,23 @@ export abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
 
     for (const [gKey, g] of Object.entries(this.givens)) {
       const giver = this.givens[gKey];
-      this.store = await giver.give(
-        subject,
-        gKey,
-        testResourceConfiguration,
-        this.assertThat,
-        suiteArtifactory,
-        tLog,
-        pm,
-        sNdx
-      ).catch((e) => {
-        this.failed = true;
-        this.fails = this.fails + 1;
-        console.error("Given error:", e);
-        throw e;
-      });
+      this.store = await giver
+        .give(
+          subject,
+          gKey,
+          testResourceConfiguration,
+          this.assertThat,
+          suiteArtifactory,
+          tLog,
+          pm,
+          sNdx
+        )
+        .catch((e) => {
+          this.failed = true;
+          this.fails = this.fails + 1;
+          console.error("Given error 1:", e);
+          throw e;
+        });
     }
 
     for (const [ndx, thater] of this.checks.entries()) {

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

@@ -0,0 +1,31 @@
+import { BaseGiven } from "../abstractBase";
+import { Ibdd_in_any } from "../../CoreTypes";
+
+export class MockGiven<I extends Ibdd_in_any> extends BaseGiven<I> {
+  constructor(
+    name: string,
+    features: string[],
+    whens: BaseWhen<I>[],
+    thens: BaseThen<I>[],
+    givenCB: I["given"],
+    initialValues: any
+  ) {
+    super(name, features, whens, thens, givenCB, initialValues);
+  }
+
+  async givenThat(
+    subject: I["isubject"],
+    testResourceConfiguration: any,
+    artifactory: any,
+    givenCB: I["given"],
+    initialValues: any,
+    pm: any
+  ): Promise<I["istore"]> {
+    return givenCB();
+  }
+
+  uberCatcher(e: Error): void {
+    console.error("MockGiven error:", e);
+    this.error = e;
+  }
+}

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

@@ -0,0 +1,20 @@
+import { BaseThen } from "../abstractBase";
+import { Ibdd_in_any } from "../../CoreTypes";
+
+export class MockThen<I extends Ibdd_in_any> extends BaseThen<I> {
+  constructor(
+    name: string,
+    thenCB: (val: I["iselection"]) => Promise<I["then"]>
+  ) {
+    super(name, thenCB);
+  }
+
+  async butThen(
+    store: I["istore"],
+    thenCB: (s: I["iselection"]) => Promise<I["isubject"]>,
+    testResourceConfiguration: any,
+    pm: any
+  ): Promise<I["iselection"]> {
+    return thenCB(store);
+  }
+}

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

@@ -0,0 +1,17 @@
+import { BaseWhen } from "../abstractBase";
+import { Ibdd_in_any } from "../../CoreTypes";
+
+export class MockWhen<I extends Ibdd_in_any> extends BaseWhen<I> {
+  constructor(name: string, whenCB: (x: I["iselection"]) => I["then"]) {
+    super(name, whenCB);
+  }
+
+  async andWhen(
+    store: I["istore"],
+    whenCB: (x: I["iselection"]) => I["then"],
+    testResource: any,
+    pm: any
+  ): Promise<I["istore"]> {
+    return whenCB(store);
+  }
+}

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

@@ -0,0 +1,51 @@
+import { PassThrough } from "stream";
+
+import { ITestImplementation } from "../../CoreTypes";
+
+import { I, O } from "./types";
+
+export const implementation: ITestImplementation<I, O> = {
+  suites: {
+    Default: "Abstract Base Test Suite",
+  },
+
+  givens: {
+    Default: () => ({
+      testStore: { value: "initial" },
+      testSelection: { selected: true },
+    }),
+    WithError: () => ({
+      testStore: { value: "error" },
+      testSelection: { selected: false },
+    }),
+  },
+
+  whens: {
+    modifyStore: (newValue: string) => (store) => ({
+      ...store,
+      testStore: { value: newValue },
+    }),
+    throwError: () => () => {
+      throw new Error("Test error");
+    },
+  },
+
+  thens: {
+    verifyStore: (expected: string) => (store) => {
+      if (store.testStore.value !== expected) {
+        throw new Error(`Expected ${expected}, got ${store.testStore.value}`);
+      }
+      return store;
+    },
+    verifyError: (expected: string) => (store) => {
+      if (!store.error || !store.error.message.includes(expected)) {
+        throw new Error(`Expected error "${expected}" not found`);
+      }
+      return store;
+    },
+  },
+
+  checks: {
+    Default: () => new PassThrough(),
+  },
+};

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

@@ -0,0 +1,19 @@
+import Testeranto from "../../Node";
+import { specification } from "./specification";
+import { implementation } from "./implementation";
+import { testInterface } from "./interface";
+import { I, O } from "./types";
+import { MockGiven } from "./MockGiven";
+import { MockThen } from "./MockThen";
+import { MockWhen } from "./MockWhen";
+
+export default Testeranto<I, O, {}>(
+  {
+    MockGiven,
+    MockWhen,
+    MockThen,
+  },
+  specification,
+  implementation,
+  testInterface
+);

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

@@ -0,0 +1,12 @@
+import { ITestInterface } from "../../CoreTypes";
+import { I } from "./types";
+
+export const testInterface: ITestInterface<I> = {
+  beforeEach: async (subject, initializer) => initializer(),
+  andWhen: async (store, whenCB) => whenCB(store),
+  butThen: async (store, thenCB) => thenCB(store),
+  afterEach: (store) => store,
+  afterAll: () => {},
+  assertThis: (result) => !!result,
+  beforeAll: async (input) => input as any
+};

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

@@ -0,0 +1,49 @@
+import { ITestSpecification } from "../../CoreTypes";
+import { I, O } from "./types";
+
+export const specification: ITestSpecification<I, O> = (
+  Suite,
+  Given,
+  When,
+  Then,
+  Check
+) => [
+  Suite.Default("BaseGiven Tests", {
+    initialization: Given.Default(
+      ["Should initialize with default values"],
+      [],
+      [Then.verifyStore("initial")]
+    ),
+    errorHandling: Given.WithError(
+      ["Should handle errors properly"],
+      [When.throwError()],
+      [Then.verifyError("Test error")]
+    )
+  }),
+
+  Suite.Default("BaseWhen Tests", {
+    stateModification: Given.Default(
+      ["Should modify state correctly"],
+      [When.modifyStore("modified")],
+      [Then.verifyStore("modified")]
+    ),
+    errorPropagation: Given.Default(
+      ["Should propagate errors"],
+      [When.throwError()],
+      [Then.verifyError("Test error")]
+    )
+  }),
+
+  Suite.Default("BaseThen Tests", {
+    assertionPassing: Given.Default(
+      ["Should pass valid assertions"],
+      [When.modifyStore("asserted")],
+      [Then.verifyStore("asserted")]
+    ),
+    assertionFailing: Given.Default(
+      ["Should fail invalid assertions"],
+      [When.modifyStore("wrong")],
+      [Then.verifyStore("right")] // This should fail
+    )
+  })
+];

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

@@ -0,0 +1,19 @@
+import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
+
+export type I = Ibdd_in<
+  {}, // iinput
+  {}, // isubject
+  { testStore: { value: string }; error?: Error }, // istore
+  { testSelection: { selected: boolean } }, // iselection
+  () => { testStore: { value: string } }, // given
+  (store: any) => any, // when
+  (store: any) => any // then
+>;
+
+export type O = Ibdd_out<
+  { Default: [string] }, // Suites
+  { Default: []; WithError: [] }, // Givens
+  { modifyStore: [string]; throwError: [] }, // Whens
+  { verifyStore: [string]; verifyError: [string] }, // Thens
+  { Default: [] } // Checks
+>;

package/src/lib/abstractBase.ts

@@ -214,7 +214,6 @@ export abstract class BaseWhen<I extends Ibdd_in_any> {
       testResourceConfiguration,
       andWhenProxy(pm, filepath)
     ).catch((e: Error) => {
-      console.log("MARK9", e);
       this.error = e;
       throw e;
     });
@@ -271,7 +270,6 @@ export abstract class BaseThen<I extends Ibdd_in_any> {
       testResourceConfiguration,
       butThenProxy(pm, filepath)
     ).catch((e) => {
-      console.log("test failed 3", e);
       this.error = e;
       throw e;
     });

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

@@ -0,0 +1,83 @@
+import { BaseBuilder } from "../basebuilder";
+import { Ibdd_in_any, Ibdd_out_any, ITestSpecification } from "../../CoreTypes";
+import {
+  ISuiteKlasser,
+  IGivenKlasser,
+  IWhenKlasser,
+  IThenKlasser,
+  ICheckKlasser,
+} from "../types";
+import { ITTestResourceRequest } from "..";
+
+/**
+ * Concrete implementation of BaseBuilder for testing purposes only
+ */
+export class TestBaseBuilder<
+  I extends Ibdd_in_any,
+  O extends Ibdd_out_any,
+  SuiteExtensions = {},
+  GivenExtensions = {},
+  WhenExtensions = {},
+  ThenExtensions = {},
+  CheckExtensions = {}
+> extends BaseBuilder<
+  I,
+  O,
+  SuiteExtensions,
+  GivenExtensions,
+  WhenExtensions,
+  ThenExtensions,
+  CheckExtensions
+> {
+  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,
+    checkOverrides: Record<keyof CheckExtensions, ICheckKlasser<I>> = {} as any,
+    testResourceRequirement: ITTestResourceRequest = { ports: [] },
+    testSpecification: ITestSpecification<I, O> = () => []
+  ) {
+    super(
+      input,
+      suitesOverrides,
+      givenOverrides,
+      whenOverrides,
+      thenOverrides,
+      checkOverrides,
+      testResourceRequirement,
+      testSpecification
+    );
+
+    this.summary = {};
+  }
+
+  /**
+   * Simplified version for testing that doesn't actually run tests
+   */
+  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/baseBuilder.test/baseBuilder.test.implementation.ts

@@ -0,0 +1,134 @@
+import { PassThrough } from "stream";
+
+import { ITestImplementation } from "../../CoreTypes";
+import { TestBaseBuilder } from "./TestBaseBuilder";
+
+import { I, O } from "./baseBuilder.test.types";
+import { ITTestResourceRequest } from "..";
+import { BaseBuilder } from "../basebuilder";
+
+// Define our test subject type
+type TestSubject = TestBaseBuilder<any, any, any, any, any, any>;
+
+export const implementation: ITestImplementation<I, O, {}> = {
+  suites: {
+    Default: "BaseBuilder test suite",
+  },
+
+  givens: {
+    Default: () => {
+      return new TestBaseBuilder(
+        {},
+        {},
+        {},
+        {},
+        {},
+        {},
+        { ports: [] },
+        () => []
+      );
+    },
+    WithCustomInput: (input: any) => {
+      return new TestBaseBuilder(
+        input,
+        {},
+        {},
+        {},
+        {},
+        {},
+        { ports: [] },
+        () => []
+      );
+    },
+    WithResourceRequirements: (requirements: ITTestResourceRequest) => {
+      return new TestBaseBuilder(
+        {},
+        {},
+        {},
+        {},
+        {},
+        {},
+        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: {
+    initializedProperly: () => (builder: TestSubject) => {
+      if (!(builder instanceof BaseBuilder)) {
+        throw new Error("Builder was not properly initialized");
+      }
+      return builder;
+    },
+    specsGenerated: () => (builder: TestSubject) => {
+      if (!Array.isArray(builder.specs)) {
+        throw new Error("Specs were not generated");
+      }
+      return builder;
+    },
+    jobsCreated: () => (builder: TestSubject) => {
+      if (!Array.isArray(builder.testJobs)) {
+        throw new Error("Test jobs were not created");
+      }
+      return builder;
+    },
+    artifactsTracked: () => (builder: TestSubject) => {
+      if (!Array.isArray(builder.artifacts)) {
+        throw new Error("Artifacts array not initialized");
+      }
+      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;
+    },
+    checksOverridesConfigured: () => (builder: TestSubject) => {
+      if (!builder.checkOverides) {
+        throw new Error("Checks overrides not configured");
+      }
+      return builder;
+    },
+  },
+
+  checks: {
+    Default: () => new PassThrough(), // Not used in these tests
+  },
+};

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

@@ -0,0 +1,18 @@
+import { ITestInterface } from "../../CoreTypes";
+
+import { I } from "./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/baseBuilder.test/baseBuilder.test.node.ts

@@ -0,0 +1,14 @@
+import Testeranto from "../../Pure";
+
+import { specification } from "./baseBuilder.test.specification";
+import { implementation } from "./baseBuilder.test.implementation";
+import { testInterface } from "./baseBuilder.test.interface";
+import { I, O } from "./baseBuilder.test.types";
+import { BaseBuilder } from "../basebuilder";
+
+export default Testeranto<I, O, {}>(
+  BaseBuilder.prototype,
+  specification,
+  implementation,
+  testInterface
+);

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

@@ -0,0 +1,14 @@
+import Testeranto from "../../Pure";
+
+import { specification } from "./baseBuilder.test.specification";
+import { implementation } from "./baseBuilder.test.implementation";
+import { testInterface } from "./baseBuilder.test.interface";
+import { I, O } from "./baseBuilder.test.types";
+import { BaseBuilder } from "../basebuilder";
+
+export default Testeranto<I, O, {}>(
+  BaseBuilder.prototype,
+  specification,
+  implementation,
+  testInterface
+);

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

@@ -0,0 +1,35 @@
+import { ITestSpecification } from "../../CoreTypes";
+
+import { I, O } from "./baseBuilder.test.types";
+
+export const specification: ITestSpecification<I, O> = (
+  Suite,
+  Given,
+  When,
+  Then,
+  Check
+) => {
+  return [
+    Suite.Default(
+      "Testing BaseBuilder functionality",
+      {
+        testInitialization: Given.Default(
+          ["BaseBuilder should initialize correctly"],
+          [],
+          [Then.initializedProperly()]
+        ),
+        testSpecsGeneration: Given.Default(
+          ["BaseBuilder should generate specs from test specification"],
+          [],
+          [Then.specsGenerated()]
+        ),
+        testJobsCreation: Given.Default(
+          ["BaseBuilder should create test jobs"],
+          [],
+          [Then.jobsCreated()]
+        ),
+      },
+      []
+    ),
+  ];
+};

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

@@ -0,0 +1,36 @@
+import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
+
+import { TestBaseBuilder } from "./TestBaseBuilder";
+
+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
+  {
+    Default: [];
+  },
+  // Whens
+  {}, // No whens in these tests
+  // Thens
+  {
+    initializedProperly: [];
+    specsGenerated: [];
+    jobsCreated: [];
+  },
+  // Checks
+  {
+    Default: [];
+  }
+>;

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

@@ -0,0 +1,14 @@
+import Testeranto from "../../Web";
+
+import { specification } from "./baseBuilder.test.specification";
+import { implementation } from "./baseBuilder.test.implementation";
+import { testInterface } from "./baseBuilder.test.interface";
+import { I, O } from "./baseBuilder.test.types";
+import { BaseBuilder } from "../basebuilder";
+
+export default Testeranto<I, O, {}>(
+  BaseBuilder.prototype,
+  specification,
+  implementation,
+  testInterface
+);

package/src/lib/basebuilder.ts

@@ -114,8 +114,9 @@ export abstract class BaseBuilder<
             logFilePath
           );
 
+          // deprecated?
           const tLog = async (...l: string[]) => {
-            // console.log("x", x);
+            //
           };
 
           const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);