testeranto 0.140.1 → 0.143.0

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

@@ -0,0 +1,72 @@
+import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
+import { ClassBuilder } from "../classBuilder";
+import { 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(),
+  },
+};

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

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

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

@@ -0,0 +1,99 @@
+import { ITestSpecification } from "../../CoreTypes";
+import { I, O } from "./core.test.types";
+
+export const specification: ITestSpecification<I, O> = (
+  Suite,
+  Given,
+  When,
+  Then,
+  Check
+) => {
+  return [
+    Suite.Default(
+      "Testeranto Core Functionality",
+      {
+        // Initialization tests
+        defaultInitialization: Given.Default(
+          ["Should initialize with default values"],
+          [],
+          [Then.initializedProperly()]
+        ),
+        customInputInitialization: Given.WithCustomInput(
+          { test: "input" },
+          [],
+          [Then.initializedProperly()]
+        ),
+        
+        // Configuration tests  
+        resourceConfig: Given.WithResourceRequirements(
+          { ports: [3000, 3001] },
+          [],
+          [Then.resourceRequirementsSet()]
+        ),
+        interfaceConfig: Given.WithCustomInterface(
+          { 
+            assertThis: (x) => !!x,
+            beforeEach: async (s, i) => i()
+          },
+          [],
+          [Then.interfaceConfigured()]
+        ),
+
+        // Core operations
+        specGeneration: Given.Default(
+          ["Should generate test specs"],
+          [],
+          [Then.specsGenerated()]
+        ),
+        jobCreation: Given.Default(
+          ["Should create test jobs"],
+          [],
+          [Then.jobsCreated()]
+        ),
+        artifactHandling: Given.Default(
+          ["Should track artifacts"],
+          [When.addArtifact(Promise.resolve("test"))],
+          [Then.artifactsTracked()]
+        )
+      },
+      []
+    ),
+
+    Suite.ExtendedSuite(
+      "Testeranto Advanced Features",
+      {
+        // Error handling
+        errorPropagation: Given.Default(
+          ["Should propagate errors properly"],
+          [When.triggerError("test error")],
+          [Then.errorThrown("test error")]
+        ),
+
+        // Dynamic behavior
+        specModification: Given.Default(
+          ["Should allow spec modification"],
+          [When.modifySpecs((specs) => [...specs, {name: "extra"}])],
+          [Then.specsModified(1)]
+        ),
+
+        // Full lifecycle
+        testExecution: Given.Default(
+          ["Should execute full test lifecycle"],
+          [],
+          [Then.testRunSuccessful()]
+        ),
+
+        // Custom implementations
+        customImpl: Given.WithCustomImplementation(
+          {
+            ...implementation,
+            suites: {Default: "Custom suite"}
+          },
+          [],
+          [Then.specsGenerated()]
+        )
+      },
+      []
+    )
+  ];
+};

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

@@ -0,0 +1,15 @@
+import Testeranto from "../../Pure";
+import { specification } from "./core.test.specification";
+import { implementation } from "./core.test.implementation";
+import { testInterface } from "./core.test.interface";
+import { I, O, M } from "./core.test.types";
+import { MockCore } from "./MockCore";
+
+export default Testeranto<I, O, M>(
+  MockCore.prototype, // test subject
+  specification, // test scenarios
+  implementation, // test operations
+  testInterface, // test lifecycle hooks
+  { ports: [] }, // resource requirements
+  (cb) => cb() // error handler
+);

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

@@ -0,0 +1,68 @@
+import { Ibdd_in, Ibdd_out, ITestInterface } from "../../CoreTypes";
+import { MockCore } from "./MockCore";
+import { ITTestResourceRequest } from "..";
+
+export type I = Ibdd_in<
+  {}, // iinput
+  MockCore<any, any, any>, // isubject
+  MockCore<any, any, any>, // istore
+  MockCore<any, any, any>, // iselection
+  () => MockCore<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];
+    WithCustomInterface: [interface: Partial<ITestInterface<any>>];
+  },
+  // Whens
+  {
+    addArtifact: [artifact: Promise<any>];
+    setTestJobs: [jobs: any[]];
+    modifySpecs: [modifier: (specs: any[]) => any[]];
+    triggerError: [message: string];
+  },
+  // Thens
+  {
+    initializedProperly: [];
+    specsGenerated: [];
+    jobsCreated: [];
+    artifactsTracked: [];
+    resourceRequirementsSet: [];
+    interfaceConfigured: [];
+    errorThrown: [expectedMessage: string];
+    testRunSuccessful: [];
+  },
+  // Checks
+  {
+    Default: [];
+  }
+>;
+
+export type M = {
+  givens: {
+    [K in keyof O["givens"]]: (
+      ...args: O["givens"][K]
+    ) => MockCore<any, any, any>;
+  };
+  whens: {
+    [K in keyof O["whens"]]: (
+      ...args: O["whens"][K]
+    ) => (builder: MockCore<any, any, any>) => MockCore<any, any, any>;
+  };
+  thens: {
+    [K in keyof O["thens"]]: (
+      ...args: O["thens"][K]
+    ) => (builder: MockCore<any, any, any>) => MockCore<any, any, any>;
+  };
+};

package/src/lib/core.ts

@@ -21,7 +21,7 @@ import type {
 } from "../CoreTypes";
 import { BaseSuite } from "./BaseSuite.js";
 
-export default abstract class Testeranto<
+export default abstract class TesterantoCore<
   I extends Ibdd_in_any,
   O extends Ibdd_out_any,
   M

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

@@ -0,0 +1,104 @@
+import { I, M, O } from "./types";
+import { ITestImplementation } from "../../CoreTypes";
+// import { ITestProxies } from ".";
+import { IPM } from "../types";
+import { IProxiedFunctions, IProxy } from "../pmProxy";
+import { MockPMBase } from "./mockPMBase";
+
+export const implementation: ITestImplementation<I, O, M> = {
+  suites: {
+    Default: "PM Proxy Tests",
+  },
+
+  givens: {
+    SomeBaseString: (s: string) => s,
+  },
+
+  whens: {
+    // functions have no mutations
+  },
+  thens: {
+    theButTheProxyReturns:
+      (method: IProxiedFunctions, expectedPath: string) =>
+      (store: { butThenProxy: IProxy }) => {
+        const mockPm = new MockPMBase() as unknown as IPM;
+        const filepath = "test/path";
+        const proxiedPm = store.butThenProxy(mockPm, filepath);
+
+        let actualPath: string;
+        let actualContent: any;
+        
+        try {
+          switch (method) {
+            case "writeFileSync":
+              const content = expectedPath.includes('content') ? 
+                "test content" : "default content";
+              proxiedPm.writeFileSync(
+                expectedPath.includes('empty') ? "" : 
+                expectedPath.includes('nested') ? "nested/folder/test.txt" :
+                expectedPath.includes('spaces') ? "file with spaces.txt" :
+                expectedPath.includes('invalid') ? "../invalid.txt" :
+                "test.txt", 
+                content
+              );
+              actualPath = mockPm.getLastCall("writeFileSync")?.path;
+              actualContent = mockPm.getLastCall("writeFileSync")?.content;
+              break;
+
+            case "createWriteStream":
+              proxiedPm.createWriteStream(
+                expectedPath.includes('empty') ? "" : "stream.txt"
+              );
+              actualPath = mockPm.getLastCall("createWriteStream")?.path;
+              break;
+
+            case "screencast":
+              proxiedPm.screencast(
+                { 
+                  path: "screen.png",
+                  quality: 80,
+                  fullPage: true 
+                }, 
+                "test"
+              );
+              actualPath = mockPm.getLastCall("screencast")?.opts?.path;
+              actualContent = mockPm.getLastCall("screencast")?.opts;
+              break;
+
+            case "customScreenShot":
+              proxiedPm.customScreenShot(
+                { path: "shot.png" }, 
+                "test"
+              );
+              actualPath = mockPm.getLastCall("customScreenShot")?.opts?.path;
+              break;
+
+            default:
+              throw new Error(`Unknown method: ${method}`);
+          }
+
+          if (expectedPath === undefined) {
+            return [undefined, undefined];
+          }
+
+          return [actualPath, expectedPath, actualContent];
+        } catch (error) {
+          return [error.message, expectedPath];
+        }
+      },
+
+    verifyContent: (expectedContent: any) => (result: any[]) => {
+      const actualContent = result[2];
+      if (JSON.stringify(actualContent) !== JSON.stringify(expectedContent)) {
+        throw new Error(
+          `Content mismatch. Expected: ${JSON.stringify(expectedContent)}, Got: ${JSON.stringify(actualContent)}`
+        );
+      }
+      return result;
+    },
+  },
+
+  checks: {
+    Default: (s: string) => s,
+  },
+};

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

@@ -0,0 +1,19 @@
+import Testeranto from "../../Node";
+import { implementation } from "./implementation";
+import { specification } from "./specification";
+import { testInterface } from "./interface";
+import { I, O } from "./types";
+
+import { butThenProxy, IProxy } from "../pmProxy";
+
+export type ITestProxies = { butThenProxy: IProxy };
+
+export default Testeranto<I, O, {}>(
+  // because of the nature of testeranto, we must add all the testable items here
+  {
+    butThenProxy,
+  },
+  specification,
+  implementation,
+  testInterface
+);

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

@@ -0,0 +1,47 @@
+import { assert } from "chai";
+
+import { I } from "./types";
+import { ITestInterface } from "../../CoreTypes";
+import { andWhenProxy, butThenProxy } from "../pmProxy";
+import { IPM } from "../types";
+import { MockPMBase } from "./mockPMBase";
+// import { butThenProxy, andWhenProxy, beforeEachProxy } from "../pmProxy";
+
+export const testInterface: ITestInterface<I> = {
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    return subject;
+    // const mockPM = MockPMBase();
+    // return {
+    //   beforeEachProxy: subject.butThenProxy(
+    //     new MockPMBase() as unknown as IPM,
+    //     initializer
+    //   ),
+    // };
+  },
+
+  andWhen: async (store, whenCB, testResource, pm) => {
+    const proxiedPM = andWhenProxy(pm, "some/path");
+    return whenCB(store, proxiedPM);
+  },
+
+  butThen: async (store, thenCB, testResource, pm) => {
+    console.log("mark2 butThen", store, thenCB.toString());
+    const proxiedPM = butThenProxy(pm, "some/path");
+    return thenCB(store, proxiedPM);
+  },
+
+  afterEach: async (store, key, pm) => store,
+  afterAll: async (store, pm) => {},
+  beforeAll: async (input, testResource, pm, theGivenString) => {
+    return {
+      beforeEachProxy: input.butThenProxy(
+        new MockPMBase() as unknown as IPM,
+        theGivenString
+      ),
+    };
+  },
+
+  assertThis: (returnedFilePath, expectation) => {
+    assert.equal(returnedFilePath, expectation);
+  },
+};

package/src/lib/pmProxy.test/mockPM.ts

@@ -0,0 +1,38 @@
+import { MockPMBase } from "./mockPMBase";
+
+export class MockPM extends MockPMBase {
+  server: any;
+
+  constructor(configs?: any) {
+    super(configs);
+    this.server = {};
+    this.testResourceConfiguration = {};
+  }
+
+  // PM-specific methods
+  start(): Promise<void> {
+    this.trackCall("start", {});
+    return Promise.resolve();
+  }
+
+  stop(): Promise<void> {
+    this.trackCall("stop", {});
+    return Promise.resolve();
+  }
+
+  launchSideCar(n: number): Promise<[number, any]> {
+    this.trackCall("launchSideCar", { n });
+    return Promise.resolve([n, this.testResourceConfiguration]);
+  }
+
+  stopSideCar(n: number): Promise<any> {
+    this.trackCall("stopSideCar", { n });
+    return Promise.resolve();
+  }
+
+  // Override any methods that need different behavior from MockPMBase
+  // For example:
+  writeFileSync(path: string, content: string): Promise<boolean> {
+    return super.writeFileSync(path, content, "default-test-name");
+  }
+}