testeranto 0.140.1 → 0.143.0

package/src/Pure.test.ts

@@ -0,0 +1,299 @@
+import { Ibdd_in, Ibdd_out } from "./CoreTypes";
+import PureTesteranto from "./Pure";
+import { MockPMBase } from "./lib/pmProxy.test/mockPMBase";
+import { IPM } from "./lib/types";
+
+// Test types specific to PureTesteranto testing
+type PureI = Ibdd_in<
+  null, // No initial input needed
+  IPM, // Test subject is IPM
+  { pm: IPM }, // Store contains PM instance
+  { pm: IPM }, // Selection is same as store
+  () => IPM, // Given returns IPM
+  (store: { pm: IPM }) => { pm: IPM }, // When modifies store
+  (store: { pm: IPM }) => { pm: IPM } // Then verifies store
+>;
+
+type PureO = Ibdd_out<
+  { Default: [string] },
+  { Default: [] },
+  {
+    applyProxy: [string]; // When to apply a proxy
+    verifyCall: [string, any]; // Then to verify calls
+  },
+  {
+    verifyProxy: [string]; // Then to verify proxy behavior
+    verifyNoProxy: []; // Then to verify no proxy
+  },
+  { Default: [] }
+>;
+
+// Implementation for PureTesteranto tests
+const implementation = {
+  suites: {
+    Default: "PureTesteranto Test Suite",
+  },
+
+  givens: {
+    Default: () => ({
+      pm: new MockPMBase() as unknown as IPM,
+      config: {},
+      proxies: {
+        butThenProxy: (pm: IPM, path: string) => ({
+          ...pm,
+          writeFileSync: (p: string, c: string) => 
+            pm.writeFileSync(`${path}/butThen/${p}`, c)
+        }),
+        andWhenProxy: (pm: IPM, path: string) => ({
+          ...pm,
+          writeFileSync: (p: string, c: string) => 
+            pm.writeFileSync(`${path}/andWhen/${p}`, c)
+        }),
+        beforeEachProxy: (pm: IPM, suite: string) => ({
+          ...pm,
+          writeFileSync: (p: string, c: string) => 
+            pm.writeFileSync(`suite-${suite}/beforeEach/${p}`, c)
+        })
+      }
+    }),
+  },
+
+  whens: {
+    applyProxy: (proxyType: string) => (store) => {
+      switch (proxyType) {
+        case "invalidConfig":
+          throw new Error("Invalid configuration");
+        case "missingProxy":
+          return { ...store, pm: {} }; // Break proxy chain
+        case "largePayload":
+          return { 
+            ...store, 
+            largePayload: true,
+            pm: {
+              ...store.pm,
+              writeFileSync: (p: string, c: string) => {
+                if (c.length > 1e6) {
+                  return true;
+                }
+                throw new Error("Payload too small");
+              }
+            }
+          };
+        default:
+          return store;
+      }
+    },
+  },
+
+  thens: {
+    verifyProxy: (expectedPath: string) => (store) => {
+      const testPath = "expected";
+      const result = store.pm.writeFileSync(testPath, "content");
+      const actualPath = store.pm.getLastCall("writeFileSync")?.path;
+      if (actualPath !== expectedPath) {
+        throw new Error(`Expected path ${expectedPath}, got ${actualPath}`);
+      }
+      return store;
+    },
+    verifyNoProxy: () => (store) => {
+      if (store.pm.getCallCount("writeFileSync") > 0) {
+        throw new Error("Proxy was unexpectedly applied");
+      }
+      return store;
+    },
+    verifyError: (expectedError: string) => (store) => {
+      try {
+        store.pm.writeFileSync("test", "content");
+        throw new Error("Expected error but none was thrown");
+      } catch (error) {
+        if (!error.message.includes(expectedError)) {
+          throw new Error(`Expected error "${expectedError}", got "${error.message}"`);
+        }
+      }
+      return store;
+    },
+    verifyResourceConfig: () => (store) => {
+      if (!store.pm.testResourceConfiguration) {
+        throw new Error("Missing test resource configuration");
+      }
+      return store;
+    },
+    verifyLargePayload: () => (store) => {
+      const largeContent = "x".repeat(2e6); // 2MB payload
+      const result = store.pm.writeFileSync("large.txt", largeContent);
+      if (!result) {
+        throw new Error("Failed to handle large payload");
+      }
+      return store;
+    },
+    verifyTypeSafety: () => (store) => {
+      // TypeScript will catch these at compile time
+      return store;
+    },
+  },
+
+  checks: {
+    Default: () => ({} as IPM),
+  },
+};
+
+// Specification for PureTesteranto tests
+const specification = (Suite, Given, When, Then, Check) => [
+  Suite.Default("Core Functionality", {
+    initializationTest: Given.Default(
+      ["Should initialize with default configuration"],
+      [],
+      [Then.verifyNoProxy()]
+    ),
+    resourceConfigTest: Given.Default(
+      ["Should handle test resource configuration"],
+      [When.applyProxy("resourceConfig")],
+      [Then.verifyResourceConfig()]
+    ),
+  }),
+
+  Suite.Default("Proxy Integration", {
+    butThenProxyTest: Given.Default(
+      ["Should integrate with butThenProxy"],
+      [When.applyProxy("butThenProxy")],
+      [Then.verifyProxy("test/path/butThen/expected")]
+    ),
+    andWhenProxyTest: Given.Default(
+      ["Should integrate with andWhenProxy"],
+      [When.applyProxy("andWhenProxy")],
+      [Then.verifyProxy("test/path/andWhen/expected")]
+    ),
+    beforeEachProxyTest: Given.Default(
+      ["Should integrate with beforeEachProxy"],
+      [When.applyProxy("beforeEachProxy")],
+      [Then.verifyProxy("suite-1/beforeEach/expected")]
+    ),
+  }),
+
+  Suite.Default("Error Handling", {
+    invalidConfigTest: Given.Default(
+      ["Should handle invalid configuration"],
+      [When.applyProxy("invalidConfig")],
+      [Then.verifyError("Invalid configuration")]
+    ),
+    missingProxyTest: Given.Default(
+      ["Should handle missing proxy"],
+      [When.applyProxy("missingProxy")],
+      [Then.verifyError("Proxy not found")]
+    ),
+  }),
+
+  Suite.Default("Performance", {
+    multipleProxiesTest: Given.Default(
+      ["Should handle multiple proxies efficiently"],
+      [
+        When.applyProxy("butThenProxy"),
+        When.applyProxy("andWhenProxy"),
+        When.applyProxy("beforeEachProxy")
+      ],
+      [
+        Then.verifyProxy("test/path/butThen/expected"),
+        Then.verifyProxy("test/path/andWhen/expected"),
+        Then.verifyProxy("suite-1/beforeEach/expected")
+      ]
+    ),
+    largePayloadTest: Given.Default(
+      ["Should handle large payloads"],
+      [When.applyProxy("largePayload")],
+      [Then.verifyLargePayload()]
+    ),
+  }),
+
+  Suite.Default("Cross-Component Verification", {
+    proxyChainTest: Given.Default(
+      ["Proxies should chain correctly"],
+      [
+        When.applyProxy("butThenProxy"),
+        When.applyProxy("andWhenProxy")
+      ],
+      [
+        Then.verifyProxy("test/path/andWhen/butThen/expected")
+      ]
+    ),
+    errorPropagationTest: Given.Default(
+      ["Errors should propagate across components"],
+      [When.applyProxy("invalidConfig")],
+      [Then.verifyError("Invalid configuration")]
+    ),
+    resourceSharingTest: Given.Default(
+      ["Resources should be shared correctly"],
+      [When.applyProxy("resourceConfig")],
+      [Then.verifyResourceConfig()]
+    )
+  }),
+
+  Suite.Default("Type Safety", {
+    strictTypeTest: Given.Default(
+      ["Should enforce type safety"],
+      [When.applyProxy("typeSafe")],
+      [Then.verifyTypeSafety()]
+    ),
+    invalidTypeTest: Given.Default(
+      ["Should reject invalid types"],
+      [When.applyProxy("invalidType")],
+      [Then.verifyError("Type mismatch")]
+    ),
+  }),
+
+  Suite.Default("Integration Tests", {
+    // Verify builders work together
+    builderIntegration: Given.Default(
+      ["BaseBuilder and ClassBuilder should integrate properly"],
+      [],
+      [
+        Then.initializedProperly(),
+        Then.specsGenerated(),
+        Then.jobsCreated(),
+        Then.artifactsTracked()
+      ]
+    ),
+
+    // Verify PM proxy integration  
+    pmProxyIntegration: Given.Default(
+      ["PM proxies should work with test runners"],
+      [When.applyProxy("butThenProxy")],
+      [Then.verifyProxy("test/path/butThen/expected")]
+    ),
+
+    // Verify full test lifecycle
+    fullLifecycle: Given.Default(
+      ["Should complete full test lifecycle"],
+      [
+        When.addArtifact(Promise.resolve("test")),
+        When.setTestJobs([]),
+        When.modifySpecs((specs) => [...specs])
+      ],
+      [
+        Then.testRunSuccessful(),
+        Then.artifactsTracked(),
+        Then.specsModified(0)
+      ]
+    )
+  })
+];
+
+// Test interface for PureTesteranto
+const testInterface = {
+  beforeEach: async (subject, initializer) => {
+    return { pm: initializer() };
+  },
+  andWhen: async (store, whenCB) => whenCB(store),
+  butThen: async (store, thenCB) => thenCB(store),
+  afterEach: async (store) => store,
+  afterAll: async () => {},
+  beforeAll: async (input, testResource) => ({} as IPM),
+  assertThis: (x) => x,
+};
+
+// Export the test suite
+export default PureTesteranto<PureI, PureO, {}>(
+  null, // No initial input
+  specification,
+  implementation,
+  testInterface
+);

package/src/lib/BaseSuite.test.ts

@@ -1,7 +1,9 @@
+import Testeranto from "../Node";
+
 import { BaseSuite } from "./BaseSuite";
 import { BaseGiven, BaseWhen, BaseThen, BaseCheck } from "./abstractBase";
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
-import { IPM } from "./types";
+import { IPM, ITestCheckCallback } from "./types";
 import {
   Ibdd_in,
   Ibdd_out,
@@ -9,7 +11,7 @@ import {
   ITestImplementation,
   ITestInterface,
 } from "../CoreTypes";
-import Testeranto from "../Node";
+import { WhenSpecification } from "../Types";
 
 // 1. Define our test types with full type safety
 type TestStore = {
@@ -159,10 +161,10 @@ class TestableSuite extends BaseSuite<I, O> {
 
 // 3. Enhanced Test Specification with more test cases
 const specification: ITestSpecification<I, O> = (
-  Suite: SuiteSpecification<I, O>,
-  Given: GivenSpecification<I, O>,
+  Suite: ITestSpecification<I, O>,
+  Given: WhenSpecification<I, O>,
   When: WhenSpecification<I, O>,
-  Then: ThenSpecification<I, O>,
+  Then: WhenSpecification<I, O>,
   Check: ITestCheckCallback<I, O>
 ) => [
   Suite.Default(
@@ -219,6 +221,23 @@ const specification: ITestSpecification<I, O> = (
       // )
     ]
   ),
+
+  Suite.Default("Comprehensive Integration", {
+    fullStackTest: Given.Default(
+      ["All components should work together"],
+      [
+        When.addArtifact(Promise.resolve("test")),
+        When.modifySpecs((specs) => [...specs, "extra"]),
+        When.modifyJobs((jobs) => [...jobs, {}])
+      ],
+      [
+        Then.specsModified(1),
+        Then.jobsModified(1),
+        Then.artifactsTracked(),
+        Then.testRunSuccessful()
+      ]
+    )
+  })
 ];
 
 // 4. Enhanced Test Implementation with more operations

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/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: [],
+    });
+  }
+}