testeranto 0.189.0 → 0.197.0

package/dist/types/{PM → src/PM}/main.d.ts

@@ -1,6 +1,8 @@
 import { ChildProcess } from "node:child_process";
 import { Page } from "puppeteer-core/lib/esm/puppeteer";
 import fs from "fs";
+import { WebSocketServer } from "ws";
+import http from "http";
 import { IRunnables, ITTestResourceConfiguration } from "../lib/index.js";
 import { IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
 import { Sidecar } from "../lib/Sidecar.js";
@@ -29,6 +31,20 @@ export declare class PM_Main extends PM_WithEslintAndTsc {
     webSidecars: Record<number, Page>;
     sidecars: Record<number, any>;
     launchers: Record<string, () => void>;
+    wss: WebSocketServer;
+    clients: Set<any>;
+    httpServer: http.Server;
+    runningProcesses: Map<string, ChildProcess>;
+    allProcesses: Map<string, {
+        child?: ChildProcess;
+        status: "running" | "exited" | "error";
+        exitCode?: number;
+        error?: string;
+        command: string;
+        pid?: number;
+        timestamp: string;
+    }>;
+    processLogs: Map<string, string[]>;
     constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
     stopSideCar(uid: number): Promise<any>;
     launchSideCar(n: number, name: string): Promise<[number, ITTestResourceConfiguration]>;
@@ -52,6 +68,9 @@ export declare class PM_Main extends PM_WithEslintAndTsc {
     launchPureSideCar: (sidecar: ITestTypes) => Promise<[number, ITTestResourceConfiguration]>;
     launchWeb: (src: string, dest: string) => Promise<void>;
     receiveFeaturesV2: (reportDest: string, srcTest: string, platform: IRunTime) => void;
+    requestHandler(req: http.IncomingMessage, res: http.ServerResponse): void;
+    findIndexHtml(): string | null;
+    broadcast(message: any): void;
     checkQueue(): void;
     checkForShutdown: () => void;
 }

package/dist/types/{PM → src/PM}/pure.d.ts

@@ -5,12 +5,14 @@ import { PM } from ".";
 type PuppetMasterServer = Record<string, Promise<any>>;
 export declare class PM_Pure extends PM {
     getInnerHtml(selector: string, page: string): Promise<string>;
-    stopSideCar(uid: number): Promise<boolean>;
+    stopSideCar(uid: number): Promise<any>;
     server: PuppetMasterServer;
     testResourceConfiguration: ITTestResourceConfiguration;
     constructor(t: ITTestResourceConfiguration);
+    protected trackCall(method: string, args: any): void;
     start(): Promise<void>;
     stop(): Promise<void>;
+    createWriteStream(filepath: string, testName: string): Promise<string>;
     launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
     pages(): any;
     waitForSelector(p: string, s: string): any;
@@ -27,17 +29,15 @@ export declare class PM_Pure extends PM {
     click(selector: string): string | undefined;
     screencast(opts: ScreencastOptions, page: string): any;
     screencastStop(p: string): any;
-    customScreenShot(opts: ScreencastOptions, page: string): any;
+    customScreenShot(opts: {
+        path: string;
+    }, page?: string): any;
     existsSync(destFolder: string): Promise<boolean>;
     mkdirSync(): boolean;
     write(uid: number, contents: string): Promise<boolean>;
     writeFileSync(): Promise<boolean>;
-    createWriteStream(): {
-        write: () => boolean;
-        end: () => void;
-    };
     end(uid: number): any;
     customclose(): void;
-    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): void;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (promise: Promise<any>) => void): (fPath: string, value: string | Buffer | any) => void;
 }
 export {};

package/dist/types/{Pure.test.d.ts → src/Pure.test.d.ts}

@@ -4,20 +4,32 @@ type I = Ibdd_in<null, // No initial input needed
 IPM, // Test subject is IPM
 {
     pm: IPM;
+    artifacts?: any[];
+    testJobs?: any[];
+    specs?: any[];
+    largePayload?: boolean;
 }, // Store contains PM instance
 {
     pm: IPM;
 }, // Selection is same as store
-() => IPM, // Given returns IPM
+() => {
+    pm: IPM;
+    config: {};
+    proxies: any;
+}, // Given returns initial state
 (store: {
     pm: IPM;
+    [key: string]: any;
 }) => {
     pm: IPM;
+    [key: string]: any;
 }, // When modifies store
 (store: {
     pm: IPM;
+    [key: string]: any;
 }) => {
     pm: IPM;
+    [key: string]: any;
 }>;
 type O = Ibdd_out<{
     Default: [string];

package/dist/types/src/components/DesignEditorPage.d.ts

@@ -0,0 +1 @@
+export declare const DesignEditorPage: () => JSX.Element;

package/dist/types/{components → src/components}/pure/AppFrame.d.ts

@@ -4,6 +4,8 @@ type AppFrameProps = {
     className?: string;
     style?: React.CSSProperties;
     'data-testid'?: string;
+    title?: string;
+    rightContent?: React.ReactNode;
 };
-export declare const AppFrame: ({ children }: AppFrameProps) => JSX.Element;
+export declare const AppFrame: ({ children, title, rightContent }: AppFrameProps) => JSX.Element;
 export {};

package/dist/types/{components/pure/ProjectPageView.test → src/components/pure/ModalContent.test}/index.d.ts

@@ -1,2 +1,3 @@
-declare const _default: Promise<import("../../../lib/core").default<import("testeranto-react/src/react-dom/component/dynamic").I, import("./types").O, import("./types").M>>;
+import { I, O } from "./types";
+declare const _default: Promise<import("../../../lib/core").default<import("testeranto-react/src/react-dom/component/dynamic").I, I, O>>;
 export default _default;

package/dist/types/{components → src/components}/pure/NavBar.d.ts

@@ -8,12 +8,16 @@ type NavItem = {
         variant: string;
         text: string;
     };
+    icon?: React.ReactNode;
 };
 type NavBarProps = {
     title: string;
     backLink?: string;
     navItems?: NavItem[];
     rightContent?: React.ReactNode;
+    showProcessManagerLink?: boolean;
+    onToggleCollapse?: () => void;
+    isCollapsed?: boolean;
 };
 export declare const NavBar: React.FC<NavBarProps>;
 export {};

package/dist/types/src/components/pure/ProcessManager.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface ProcessManagerProps {
+    show: boolean;
+    onHide: () => void;
+    ws: WebSocket | null;
+}
+export declare const ProcessManager: React.FC<ProcessManagerProps>;
+export {};

package/dist/types/src/components/pure/ProcessManagerView.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+export interface Process {
+    processId: string;
+    command: string;
+    pid?: number;
+    status?: "running" | "exited" | "error";
+    exitCode?: number;
+    error?: string;
+    timestamp: string;
+    logs?: string[];
+}
+interface ProcessManagerViewProps {
+    processes: Process[];
+    onRefresh: () => void;
+    onBack: () => void;
+    loading: boolean;
+    onKillProcess?: (processId: string) => void;
+}
+export declare const ProcessManagerView: React.FC<ProcessManagerViewProps>;
+export {};

package/dist/types/{components → src/components}/pure/ProjectsPageView.d.ts

@@ -25,5 +25,5 @@ type ProjectsPageViewProps = {
     error: string | null;
     navigate: (path: string) => void;
 };
-export declare const ProjectsPageView: ({ projects, summaries, configs, loading, error, navigate }: ProjectsPageViewProps) => JSX.Element;
+export declare const ProjectsPageView: ({ projects, summaries, configs, loading, error, navigate, }: ProjectsPageViewProps) => JSX.Element;
 export {};

package/dist/types/src/components/pure/SettingsButton.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const SettingsButton: React.FC;

package/dist/types/{components → src/components}/pure/TestPageView.test/implementation.d.ts

@@ -1,11 +1,12 @@
 import { ITestImplementation } from "../../../CoreTypes";
 import { IInput, ISelection, IStore, ISubject, O } from "./types";
+import { ITTestResourceConfiguration, IPM } from "../../../lib";
 export declare const implementation: ITestImplementation<{
     iinput: IInput;
     isubject: ISubject;
     istore: IStore;
     iselection: ISelection;
     given: (props: IInput) => ISelection;
-    when: (sel: ISelection) => ISelection;
-    then: (sel: ISelection) => Promise<ISelection>;
+    when: (sel: ISelection, tr: ITTestResourceConfiguration, utils: IPM) => Promise<(sel: ISelection) => ISelection>;
+    then: (sel: ISelection, tr: ITTestResourceConfiguration, utils: IPM) => Promise<(sel: ISelection) => ISelection>;
 }, O, {}>;

package/dist/types/src/components/pure/TestPageView.test/index.d.ts

@@ -0,0 +1,3 @@
+import "./../../../App.scss";
+declare const _default: any;
+export default _default;

package/dist/types/src/components/stateful/FileTree.d.ts

@@ -0,0 +1,8 @@
+import { FileType } from './TextEditorPage';
+type FileTreeProps = {
+    files: FileType[];
+    onSelect: (path: string) => void;
+    activeFile: string | null;
+};
+export declare const FileTree: ({ files, onSelect, activeFile }: FileTreeProps) => JSX.Element;
+export {};

package/dist/types/src/components/stateful/ProcessManagerPage.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const ProcessManagerPage: React.FC;

package/dist/types/src/components/stateful/SettingsPage.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const SettingsPage: React.FC;

package/dist/types/src/components/stateful/SingleProcessPage.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const SingleProcessPage: React.FC;

package/dist/types/src/components/stateful/TextEditorPage.d.ts

@@ -0,0 +1 @@
+export declare const TextEditorPage: () => JSX.Element;

package/dist/types/{lib → src/lib}/BaseSuite.test/mock.d.ts

@@ -8,11 +8,11 @@ export declare class MockGiven extends BaseGiven<I> {
     uberCatcher(e: Error): void;
 }
 export declare class MockWhen extends BaseWhen<I> {
-    andWhen(store: TestStore, whenCB: (store: TestStore) => Promise<TestStore>, testResource: any, pm: IPM): Promise<TestStore>;
-    addArtifact(name: string, content: string): this;
+    andWhen(store: TestStore, whenCB: (x: TestSelection) => (store: TestStore) => Promise<TestSelection>, testResource: any, pm: IPM): Promise<TestStore>;
+    addArtifact(path: string): void;
 }
 export declare class MockThen extends BaseThen<I> {
-    butThen(store: TestStore, thenCB: (selection: TestSelection) => Promise<TestSelection>, testResourceConfiguration: any, pm: any): Promise<TestSelection>;
+    butThen(store: TestStore, thenCB: (s: TestSelection) => Promise<BaseSuite<any, any>>, testResourceConfiguration: any, pm: IPM, ...args: any[]): Promise<TestSelection>;
 }
 export declare class MockSuite extends BaseSuite<I, O> {
     constructor(name: string, index: number);

package/dist/types/{lib → src/lib}/basebuilder.d.ts

@@ -4,7 +4,7 @@ import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, IPM } from ".
 import { BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
 export declare abstract class BaseBuilder<I extends Ibdd_in_any, O extends Ibdd_out_any, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions> {
     specs: any;
-    assertThis: (t: I["then"]) => {};
+    assertThis: (t: I["then"]) => any;
     testResourceRequirement: ITTestResourceRequest;
     artifacts: Promise<unknown>[];
     testJobs: ITestJob[];

package/dist/types/{lib → src/lib}/index.d.ts

@@ -29,7 +29,7 @@ export type ILogWriter = {
     createWriteStream: (line: string) => any | any;
     writeFileSync: (fp: string, contents: string) => any;
     mkdirSync: () => any;
-    testArtiFactoryfileWriter: (tLog: ITLog, n: (Promise: any) => void) => (fPath: string, value: unknown) => void;
+    testArtiFactoryfileWriter: (tLog: ITLog, n: (promise: Promise<any>) => void) => (fPath: string, value: unknown) => void;
 };
 export type ITestArtificer = (key: string, data: any) => void;
 type ITest = {

package/dist/types/{lib → src/lib}/pmProxy.test/mockPMBase.d.ts

@@ -17,7 +17,7 @@ export declare class MockPMBase implements PM_Base {
     createWriteStream(path: string, testName?: string): Promise<number>;
     screencast(opts: any, testName: string, page?: any): Promise<any>;
     customScreenShot(opts: any, testName: string, pageUid?: any): Promise<any>;
-    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): any;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (promise: Promise<any>) => void): any;
     closePage(p: any): any;
     $(selector: string, p: string): Promise<any>;
     click(selector: string, page: any): any;

package/dist/types/src/run.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/utils/logFiles.d.ts

@@ -0,0 +1,71 @@
+export type RuntimeName = 'node' | 'web' | 'pure';
+export declare const LOG_FILES: {
+    readonly TESTS: "tests.json";
+    readonly TYPE_ERRORS: "type_errors.txt";
+    readonly LINT_ERRORS: "lint_errors.txt";
+    readonly EXIT: "exit.log";
+    readonly MESSAGE: "message.txt";
+    readonly PROMPT: "prompt.txt";
+    readonly STDOUT: "stdout.log";
+    readonly STDERR: "stderr.log";
+    readonly INFO: "info.log";
+    readonly ERROR: "error.log";
+    readonly WARN: "warn.log";
+    readonly DEBUG: "debug.log";
+};
+export declare const STANDARD_LOGS: {
+    readonly TESTS: "tests.json";
+    readonly TYPE_ERRORS: "type_errors.txt";
+    readonly LINT_ERRORS: "lint_errors.txt";
+    readonly EXIT: "exit.log";
+    readonly MESSAGE: "message.txt";
+    readonly PROMPT: "prompt.txt";
+};
+export declare const RUNTIME_SPECIFIC_LOGS: {
+    readonly node: {
+        readonly STDOUT: "stdout.log";
+        readonly STDERR: "stderr.log";
+    };
+    readonly web: {
+        readonly INFO: "info.log";
+        readonly ERROR: "error.log";
+        readonly WARN: "warn.log";
+        readonly DEBUG: "debug.log";
+    };
+    readonly pure: {};
+};
+export declare const ALL_LOGS: {
+    readonly STDOUT: "stdout.log";
+    readonly STDERR: "stderr.log";
+    readonly TESTS: "tests.json";
+    readonly TYPE_ERRORS: "type_errors.txt";
+    readonly LINT_ERRORS: "lint_errors.txt";
+    readonly EXIT: "exit.log";
+    readonly MESSAGE: "message.txt";
+    readonly PROMPT: "prompt.txt";
+} | {
+    readonly INFO: "info.log";
+    readonly ERROR: "error.log";
+    readonly WARN: "warn.log";
+    readonly DEBUG: "debug.log";
+    readonly TESTS: "tests.json";
+    readonly TYPE_ERRORS: "type_errors.txt";
+    readonly LINT_ERRORS: "lint_errors.txt";
+    readonly EXIT: "exit.log";
+    readonly MESSAGE: "message.txt";
+    readonly PROMPT: "prompt.txt";
+} | {
+    readonly TESTS: "tests.json";
+    readonly TYPE_ERRORS: "type_errors.txt";
+    readonly LINT_ERRORS: "lint_errors.txt";
+    readonly EXIT: "exit.log";
+    readonly MESSAGE: "message.txt";
+    readonly PROMPT: "prompt.txt";
+};
+export declare const getRuntimeLogs: (runtime: RuntimeName) => {
+    standard: ("tests.json" | "type_errors.txt" | "lint_errors.txt" | "prompt.txt" | "exit.log" | "message.txt")[];
+    runtimeSpecific: ("stdout.log" | "stderr.log" | "info.log" | "error.log" | "warn.log" | "debug.log")[];
+};
+export type RuntimeLogs = typeof RUNTIME_SPECIFIC_LOGS;
+export type LogFileType<T extends RuntimeName> = keyof RuntimeLogs[T];
+export declare function getLogFilesForRuntime(runtime: RuntimeName): string[];