testeranto 0.140.2 → 0.146.0

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
@@ -120,16 +120,6 @@ export default abstract class Testeranto<
             testResource,
             pm
           );
-          // try {
-          //   return await fullTestInterface.andWhen(
-          //     store,
-          //     whenCB,
-          //     testResource,
-          //     pm
-          //   );
-          // } catch (e) {
-          //   console.log("mark22", e);
-          // }
         }
       } as any,
 

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,46 @@
+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) => {
+    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");
+  }
+}

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

@@ -0,0 +1,136 @@
+import { Browser } from "puppeteer-core";
+
+import { IBuiltConfig, ITLog } from "../index";
+import { PM_Base } from "../../PM/base";
+
+export class MockPMBase implements PM_Base {
+  browser: Browser;
+  configs: IBuiltConfig;
+  calls: Record<string, any[]> = {};
+  testResourceConfiguration: any = {};
+
+  constructor(configs?: IBuiltConfig) {
+    this.configs = configs || ({} as IBuiltConfig);
+  }
+
+  // Common tracking functionality
+  protected trackCall(method: string, args: any) {
+    if (!this.calls[method]) {
+      this.calls[method] = [];
+    }
+    this.calls[method].push(args);
+  }
+
+  getCallCount(method: string): number {
+    return this.calls[method]?.length || 0;
+  }
+
+  getLastCall(method: string): any {
+    const calls = this.calls[method];
+    return calls ? calls[calls.length - 1] : null;
+  }
+
+  // Minimal implementations of required methods
+  launchSideCar(n: number, testName: string, projectName: string) {
+    this.trackCall("launchSideCar", { n, testName, projectName });
+    return Promise.resolve();
+  }
+
+  end(uid: number): Promise<boolean> {
+    this.trackCall("end", { uid });
+    return Promise.resolve(true);
+  }
+
+  writeFileSync(
+    path: string,
+    content: string,
+    testName?: string
+  ): Promise<boolean> {
+    this.trackCall("writeFileSync", { path, content, testName });
+    return Promise.resolve(true);
+  }
+
+  createWriteStream(path: string, testName?: string): Promise<number> {
+    this.trackCall("createWriteStream", { path, testName });
+    return Promise.resolve(0);
+  }
+
+  screencast(opts: any, testName: string, page?: any): Promise<any> {
+    this.trackCall("screencast", { opts, testName, page });
+    return Promise.resolve({});
+  }
+
+  customScreenShot(opts: any, testName: string, pageUid?: any): Promise<any> {
+    this.trackCall("customScreenShot", { opts, testName, pageUid });
+    return Promise.resolve({});
+  }
+
+  testArtiFactoryfileWriter(
+    tLog: ITLog,
+    callback: (Promise: any) => void
+  ): any {
+    return (fPath: string, value: string | Buffer | any) => {
+      this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+      callback(Promise.resolve());
+    };
+  }
+
+  // Other required PM_Base methods with minimal implementations
+  closePage(p: any): any {
+    return Promise.resolve();
+  }
+  $(selector: string, p: string): Promise<any> {
+    return Promise.resolve();
+  }
+  click(selector: string, page: any): any {
+    return Promise.resolve();
+  }
+  goto(p: string, url: string): any {
+    return Promise.resolve();
+  }
+  newPage(): Promise<string> {
+    return Promise.resolve("mock-page");
+  }
+  pages(): Promise<string[]> {
+    return Promise.resolve(["mock-page"]);
+  }
+  waitForSelector(p: string, s: string): any {
+    return Promise.resolve(true);
+  }
+  focusOn(selector: string, p: string): any {
+    return Promise.resolve();
+  }
+  typeInto(value: string, p: string): any {
+    return Promise.resolve();
+  }
+  getAttribute(selector: string, attribute: string, p: string): any {
+    return Promise.resolve();
+  }
+  getInnerHtml(selector: string, p: string): Promise<any> {
+    return Promise.resolve();
+  }
+  isDisabled(selector: string, p: string): any {
+    return Promise.resolve(false);
+  }
+  screencastStop(s: string): any {
+    return Promise.resolve();
+  }
+  existsSync(destFolder: string): boolean {
+    return false;
+  }
+  mkdirSync(fp: string): any {
+    return Promise.resolve();
+  }
+  write(uid: number, contents: string): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+  page(p: any): string | undefined {
+    return "mock-page";
+  }
+  doInPage(p: string, cb: (p: any) => unknown): any {
+    return Promise.resolve();
+  }
+  customclose(): any {
+    return Promise.resolve();
+  }
+}

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

@@ -0,0 +1,123 @@
+import { I, O } from "./types";
+import { ITestSpecification } from "../../CoreTypes";
+
+export const specification: ITestSpecification<I, O> = (
+  Suite,
+  Given,
+  When,
+  Then,
+  Check
+) => [
+  Suite.Default("PM Proxy Functionality", {
+    // Basic path rewriting tests
+    writeFileProxyTest: Given.SomeBaseString(
+      ["butThenProxy should rewrite writeFileSync paths"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt")],
+      "writeFileSync test"
+    ),
+    createWriteStreamProxyTest: Given.SomeBaseString(
+      ["butThenProxy should rewrite createWriteStream paths"],
+      [],
+      [Then.theButTheProxyReturns("createWriteStream", "test/path/butThen/stream.txt")],
+      "createWriteStream test"
+    ),
+    screencastProxyTest: Given.SomeBaseString(
+      ["butThenProxy should rewrite screencast paths"],
+      [],
+      [Then.theButTheProxyReturns("screencast", "test/path/butThen/screen.png")],
+      "screencast test"
+    ),
+    customScreenShotProxyTest: Given.SomeBaseString(
+      ["butThenProxy should rewrite customScreenShot paths"],
+      [],
+      [Then.theButTheProxyReturns("customScreenShot", "test/path/butThen/shot.png")],
+      "customScreenShot test"
+    ),
+
+    // Edge cases
+    emptyPathTest: Given.SomeBaseString(
+      ["butThenProxy should handle empty paths"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/")],
+      "empty path test"
+    ),
+    nestedPathTest: Given.SomeBaseString(
+      ["butThenProxy should handle nested paths"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/nested/folder/test.txt")],
+      "nested path test"
+    ),
+    specialCharsTest: Given.SomeBaseString(
+      ["butThenProxy should handle special characters in paths"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/file with spaces.txt")],
+      "special chars test"
+    ),
+  }),
+
+  Suite.Default("Proxy Type Coverage", {
+    // Test all proxy types
+    butThenProxyTest: Given.SomeBaseString(
+      ["butThenProxy should work correctly"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt")],
+      "butThenProxy test"
+    ),
+    andWhenProxyTest: Given.SomeBaseString(
+      ["andWhenProxy should work correctly"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/andWhen/test.txt")],
+      "andWhenProxy test"
+    ),
+    beforeEachProxyTest: Given.SomeBaseString(
+      ["beforeEachProxy should work correctly"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "suite-1/beforeEach/test.txt")],
+      "beforeEachProxy test"
+    ),
+    afterEachProxyTest: Given.SomeBaseString(
+      ["afterEachProxy should work correctly"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "suite-1/given-1/afterEach/test.txt")],
+      "afterEachProxy test"
+    ),
+  }),
+
+  Suite.Default("Content Preservation", {
+    // Verify content is preserved
+    contentPreservationTest: Given.SomeBaseString(
+      ["Proxies should preserve file content"],
+      [],
+      [
+        Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt"),
+        Then.verifyContent("test content")
+      ],
+      "content preservation test"
+    ),
+    objectContentTest: Given.SomeBaseString(
+      ["Proxies should preserve object content"],
+      [],
+      [
+        Then.theButTheProxyReturns("screencast", "test/path/butThen/screen.png"),
+        Then.verifyContent({quality: 80, fullPage: true})
+      ],
+      "object content test"
+    ),
+  }),
+
+  Suite.Default("Error Cases", {
+    invalidPathTest: Given.SomeBaseString(
+      ["Proxies should handle invalid paths"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/../invalid.txt")],
+      "invalid path test"
+    ),
+    undefinedInputTest: Given.SomeBaseString(
+      ["Proxies should handle undefined inputs"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", undefined)],
+      "undefined input test"
+    ),
+  }),
+];