testeranto 0.203.0 → 0.206.0

package/dist/types/src/lib/index.d.ts

@@ -0,0 +1,73 @@
+import { Ibdd_in_any, ITestAdapter, Ibdd_out_any } from "../CoreTypes";
+import { PM_Node } from "../PM/node";
+import { PM_Pure } from "../PM/pure";
+import { PM_Web } from "../PM/web";
+import { ITestconfig, IBuiltConfig, IRunTime, ITestTypes } from "../Types";
+import { IGivens } from "./BaseGiven";
+import { BaseSuite } from "./BaseSuite";
+export declare const BaseAdapter: <T extends Ibdd_in_any>() => ITestAdapter<T>;
+export declare const DefaultAdapter: <T extends Ibdd_in_any>(p: Partial<ITestAdapter<T>>) => ITestAdapter<T>;
+export type ITTestResourceConfiguration = {
+    name: string;
+    fs: string;
+    ports: number[];
+    browserWSEndpoint?: string;
+    timeout?: number;
+    retries?: number;
+    environment?: Record<string, string>;
+};
+export type ITTestResourceRequirement = {
+    name: string;
+    ports: number;
+    fs: string;
+};
+export type ITTestResourceRequest = {
+    ports: number;
+};
+export type ITLog = (...string: any[]) => void;
+export type ILogWriter = {
+    createWriteStream: (line: string) => any | any;
+    writeFileSync: (fp: string, contents: string) => any;
+    mkdirSync: () => any;
+    testArtiFactoryfileWriter: (tLog: ITLog, n: (promise: Promise<any>) => void) => (fPath: string, value: unknown) => void;
+};
+export type ITestArtificer = (key: string, data: any) => void;
+type ITest = {
+    toObj(): object;
+    name: string;
+    givens: IGivens<Ibdd_in_any>;
+    testResourceConfiguration: ITTestResourceConfiguration;
+};
+export type ITestJob = {
+    toObj(): object;
+    test: ITest;
+    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<Ibdd_in_any, Ibdd_out_any>>;
+    testResourceRequirement: ITTestResourceRequirement;
+    receiveTestResourceConfig: (pm: PM_Node | PM_Web | PM_Pure) => IFinalResults;
+};
+export type ITestResults = Promise<{
+    test: ITest;
+}>[];
+export declare const defaultTestResourceRequirement: ITTestResourceRequest;
+export type ITestArtifactory = (key: string, value: unknown) => unknown;
+export type { ITestconfig, IBuiltConfig, IRunTime, ITestTypes };
+export type IRunnables = {
+    nodeEntryPoints: Record<string, string>;
+    nodeEntryPointSidecars: Record<string, string>;
+    webEntryPoints: Record<string, string>;
+    webEntryPointSidecars: Record<string, string>;
+    pureEntryPoints: Record<string, string>;
+    pureEntryPointSidecars: Record<string, string>;
+    pythonEntryPoints: Record<string, string>;
+    pythonEntryPointSidecars: Record<string, string>;
+    golangEntryPoints: Record<string, string>;
+    golangEntryPointSidecars: Record<string, string>;
+};
+export type IFinalResults = {
+    features: string[];
+    failed: boolean;
+    fails: number;
+    artifacts: Promise<unknown>[];
+    tests: number;
+    runTimeTests: number;
+};

package/dist/types/src/lib/pmProxy.d.ts

@@ -0,0 +1,12 @@
+import { IPM } from "./types";
+export type IProxyBase = (pm: IPM, mappings: [string, (...x: any) => any][]) => IPM;
+export type IProxy = (pm: IPM, filepath: string, step: any) => IPM;
+export type IProxyAfterEach = (pm: IPM, suite: string, given: string, step: any) => IPM;
+export type IProxyBeforeEach = (pm: IPM, suite: string, step: any) => IPM;
+export type IProxiedFunctions = "screencast" | "createWriteStream" | "writeFileSync" | "customScreenShot";
+export declare const butThenProxy: IProxy;
+export declare const andWhenProxy: IProxy;
+export declare const afterEachProxy: IProxyAfterEach;
+export declare const beforeEachProxy: IProxyBeforeEach;
+export declare const beforeAllProxy: IProxy;
+export declare const afterAllProxy: IProxy;

package/dist/types/src/lib/pmProxy.test/adapter.d.ts

@@ -0,0 +1,3 @@
+import { I } from "./types";
+import { ITestAdapter } from "../../CoreTypes";
+export declare const testAdapter: ITestAdapter<I>;

package/dist/types/src/lib/pmProxy.test/implementation.d.ts

@@ -0,0 +1,3 @@
+import { ITestImplementation } from "../../CoreTypes";
+import { I, M, O } from "./types";
+export declare const implementation: ITestImplementation<I, O, M>;

package/dist/types/src/lib/pmProxy.test/index.d.ts

@@ -0,0 +1,6 @@
+import { IProxy } from "../pmProxy";
+export type ITestProxies = {
+    butThenProxy: IProxy;
+};
+declare const _default: Promise<Testeranto<I, O, M>>;
+export default _default;

package/dist/types/src/lib/pmProxy.test/mockPM.d.ts

@@ -0,0 +1,10 @@
+import { MockPMBase } from "./mockPMBase";
+export declare class MockPM extends MockPMBase {
+    server: any;
+    constructor(configs?: any);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    launchSideCar(n: number): Promise<[number, any]>;
+    stopSideCar(n: number): Promise<any>;
+    writeFileSync(path: string, content: string): Promise<boolean>;
+}

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

@@ -0,0 +1,40 @@
+import { Browser } from "puppeteer-core";
+import { IBuiltConfig, ITLog } from "../index";
+import { PM_Base } from "../../app/backend/PM_0";
+export declare class MockPMBase implements PM_Base {
+    browser: Browser;
+    configs: IBuiltConfig;
+    calls: Record<string, any[]>;
+    testResourceConfiguration: any;
+    constructor(configs?: IBuiltConfig);
+    protected trackCall(method: string, args: any): void;
+    getCallCount(method: string): number;
+    getLastCall(method: string): any;
+    launchSideCar(n: number, testName: string, projectName: string): Promise<void>;
+    end(uid: number): Promise<boolean>;
+    debug(message: string): void;
+    writeFileSync(path: string, content: string, testName?: string): Promise<boolean>;
+    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: Promise<any>) => void): any;
+    closePage(p: any): any;
+    $(selector: string, p: string): Promise<any>;
+    click(selector: string, page: any): any;
+    goto(p: string, url: string): any;
+    newPage(): Promise<string>;
+    pages(): Promise<string[]>;
+    waitForSelector(p: string, s: string): any;
+    focusOn(selector: string, p: string): any;
+    typeInto(value: string, p: string): any;
+    getAttribute(selector: string, attribute: string, p: string): any;
+    getInnerHtml(selector: string, p: string): Promise<any>;
+    isDisabled(selector: string, p: string): any;
+    screencastStop(s: string): any;
+    existsSync(destFolder: string): boolean;
+    mkdirSync(fp: string): any;
+    write(uid: number, contents: string): Promise<boolean>;
+    page(p: any): string | undefined;
+    doInPage(p: string, cb: (p: any) => unknown): any;
+    customclose(): any;
+}

package/dist/types/src/lib/pmProxy.test/specification.d.ts

@@ -0,0 +1,3 @@
+import { ITestSpecification } from "../../CoreTypes";
+import { I, O } from "./types";
+export declare const specification: ITestSpecification<I, O>;

package/dist/types/src/lib/pmProxy.test/types.d.ts

@@ -0,0 +1,42 @@
+import { ITestProxies } from ".";
+import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
+import { IProxiedFunctions, IProxy } from "../pmProxy";
+import { IPM } from "../types";
+export type I = Ibdd_in<{
+    butThenProxy: IProxy;
+}, {
+    proxies: ITestProxies;
+    filepath: string;
+    mockPm: IPM;
+}, {
+    butThenProxy: IProxy;
+}, {
+    proxies: ITestProxies;
+    filepath: string;
+    mockPm: IPM;
+}, [
+    string,
+    string
+], (...args: any[]) => (proxies: {
+    butThenProxy: IProxy;
+}) => {
+    butThenProxy: IProxy;
+}, [
+    IPM,
+    "string"
+]>;
+export type O = Ibdd_out<{
+    Default: [string];
+}, {
+    SomeBaseString: [string];
+}, {}, // No Whens for pure functions
+{
+    theButTheProxyReturns: [IProxiedFunctions, string];
+}, {
+    Default: [];
+}>;
+export type M = {
+    givens: {
+        [K in keyof O["givens"]]: (...Iw: O["givens"][K]) => string;
+    };
+};

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

@@ -0,0 +1,24 @@
+import type { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
+import { PM_Node } from "../PM/node";
+import { PM_Pure } from "../PM/pure";
+import { PM_Web } from "../PM/web";
+import { IGivens, BaseGiven } from "./BaseGiven";
+import { BaseSuite } from "./BaseSuite";
+import { BaseThen } from "./BaseThen";
+import { BaseWhen } from "./BaseWhen";
+export type IPM = PM_Node | PM_Web | PM_Pure;
+export type ThemeType = "system" | "light" | "dark" | "light-vibrant" | "dark-vibrant" | "sepia" | "light-grayscale" | "dark-grayscale" | "daily" | "protanopia" | "deuteranopia" | "tritanopia";
+export type TestPhase = "beforeAll" | "beforeEach" | "test" | "afterEach" | "afterAll";
+export type TestError = {
+    phase: TestPhase;
+    error: Error;
+    testName: string;
+    timestamp: number;
+    stackTrace?: string;
+    additionalInfo?: Record<string, unknown>;
+    isRetryable?: boolean;
+};
+export type ISuiteKlasser<I extends Ibdd_in_any, O extends Ibdd_out_any> = (name: string, index: number, givens: IGivens<I>) => BaseSuite<I, O>;
+export type IGivenKlasser<I extends Ibdd_in_any> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<I>;
+export type IWhenKlasser<I extends Ibdd_in_any> = (s: any, o: any) => BaseWhen<I>;
+export type IThenKlasser<I extends Ibdd_in_any> = (s: any, o: any) => BaseThen<I>;

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

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

package/dist/types/src/mothership/test.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Promise<Testeranto<I, O, M>>;
+export default _default;

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

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

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

@@ -0,0 +1 @@
+export declare const AppHtml: () => string;

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

@@ -0,0 +1,2 @@
+import { GolingvuMetafile } from "./golingvuMetafile/types";
+export declare function generateGolingvuMetafile(testName: string, entryPoints: string[]): Promise<GolingvuMetafile>;

package/dist/types/src/utils/golingvuMetafile/fileDiscovery.d.ts

@@ -0,0 +1 @@
+export declare function collectGoDependencies(filePath: string, visited?: Set<string>): string[];

package/dist/types/src/utils/golingvuMetafile/goList.d.ts

@@ -0,0 +1,2 @@
+import { GoListOutput } from "./types";
+export declare function runGoList(pattern: string): GoListOutput[];

package/dist/types/src/utils/golingvuMetafile/helpers.d.ts

@@ -0,0 +1,7 @@
+export declare function findProjectRoot(): string;
+export declare function findAndParseGoMod(startDir: string): {
+    root: string;
+    modulePath: string;
+} | null;
+export declare function calculateImportPath(filePath: string): string | null;
+export declare function normalizeImportPath(importPath: string): string;

package/dist/types/src/utils/golingvuMetafile/importParser.d.ts

@@ -0,0 +1,5 @@
+export declare function parseGoImports(filePath: string): {
+    path: string;
+    kind: string;
+    external?: boolean;
+}[];

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

@@ -0,0 +1,66 @@
+export interface GolingvuMetafile {
+    errors: any[];
+    warnings: any[];
+    metafile: {
+        inputs: Record<string, {
+            bytes: number;
+            imports: {
+                path: string;
+                kind: string;
+                external?: boolean;
+            }[];
+            format?: string;
+        }>;
+        outputs: Record<string, {
+            imports: any[];
+            exports: any[];
+            entryPoint: string;
+            inputs: Record<string, {
+                bytesInOutput: number;
+            }>;
+            bytes: number;
+            signature: string;
+        }>;
+    };
+}
+export interface GoListOutput {
+    Dir: string;
+    ImportPath: string;
+    ImportComment?: string;
+    Name: string;
+    Target?: string;
+    Stale?: boolean;
+    StaleReason?: string;
+    Root?: string;
+    GoFiles?: string[];
+    CgoFiles?: string[];
+    IgnoredGoFiles?: string[];
+    CFiles?: string[];
+    CXXFiles?: string[];
+    MFiles?: string[];
+    HFiles?: string[];
+    FFiles?: string[];
+    SFiles?: string[];
+    SwigFiles?: string[];
+    SwigCXXFiles?: string[];
+    SysoFiles?: string[];
+    Imports?: string[];
+    Deps?: string[];
+    TestImports?: string[];
+    XTestImports?: string[];
+    Module?: {
+        Path: string;
+        Version: string;
+        Replace?: {
+            Path: string;
+            Version: string;
+        };
+        Main: boolean;
+        Dir: string;
+        GoMod: string;
+        GoVersion: string;
+    };
+    Match?: string[];
+    DepOnly?: boolean;
+    Standard?: boolean;
+}

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

@@ -0,0 +1,4 @@
+import { generateGolingvuMetafile as gmf } from "./generateGolingvuMetafile";
+import { writeGolingvuMetafile as wgmf } from "./writeGolingvuMetafile";
+export declare const generateGolingvuMetafile: typeof gmf;
+export declare const writeGolingvuMetafile: typeof wgmf;

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

@@ -0,0 +1,14 @@
+export declare class GolingvuWatcher {
+    private watcher;
+    private testName;
+    private entryPoints;
+    private onChangeCallback;
+    private debounceTimer;
+    constructor(testName: string, entryPoints: string[]);
+    start(): Promise<void>;
+    private handleFileChange;
+    private readAndCheckSignature;
+    regenerateMetafile(): Promise<void>;
+    onMetafileChange(callback: () => void): void;
+    stop(): void;
+}

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

@@ -0,0 +1,103 @@
+export type RuntimeName = 'node' | 'web' | 'pure' | 'python' | 'golang';
+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";
+    readonly BUILD: "build.json";
+};
+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: {};
+    readonly python: {
+        readonly STDOUT: "stdout.log";
+        readonly STDERR: "stderr.log";
+    };
+    readonly golang: {
+        readonly STDOUT: "stdout.log";
+        readonly STDERR: "stderr.log";
+    };
+};
+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 BUILD: "build.json";
+} | {
+    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 BUILD: "build.json";
+} | {
+    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 BUILD: "build.json";
+} | {
+    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 BUILD: "build.json";
+} | {
+    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 BUILD: "build.json";
+};
+export declare const getRuntimeLogs: (runtime: RuntimeName) => {
+    standard: ("tests.json" | "type_errors.txt" | "lint_errors.txt" | "prompt.txt" | "exit.log" | "message.txt" | "build.json")[];
+    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[];

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

@@ -0,0 +1,22 @@
+export interface PitonoMetafile {
+    errors: any[];
+    warnings: any[];
+    metafile: {
+        inputs: Record<string, {
+            bytes: number;
+            imports: any[];
+        }>;
+        outputs: Record<string, {
+            imports: any[];
+            exports: any[];
+            entryPoint: string;
+            inputs: Record<string, {
+                bytesInOutput: number;
+            }>;
+            bytes: number;
+            signature: string;
+        }>;
+    };
+}
+export declare function generatePitonoMetafile(testName: string, entryPoints: string[]): Promise<PitonoMetafile>;
+export declare function writePitonoMetafile(testName: string, metafile: PitonoMetafile): void;

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

@@ -0,0 +1,13 @@
+export declare class PitonoWatcher {
+    private watcher;
+    private testName;
+    private entryPoints;
+    private onChangeCallback;
+    constructor(testName: string, entryPoints: string[]);
+    start(): Promise<void>;
+    private handleFileChange;
+    private readAndCheckSignature;
+    regenerateMetafile(): Promise<void>;
+    onMetafileChange(callback: () => void): void;
+    stop(): void;
+}

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

@@ -0,0 +1,11 @@
+export declare class Queue<I> {
+    items: I[];
+    constructor();
+    enqueue(element: any): void;
+    dequeue(): I | "Queue is empty" | undefined;
+    peek(): I | "Queue is empty";
+    isEmpty(): boolean;
+    size(): number;
+    clear(): void;
+    print(): void;
+}

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

@@ -0,0 +1,2 @@
+import { GolingvuMetafile } from "./golingvuMetafile/types";
+export declare function writeGolingvuMetafile(testName: string, metafile: GolingvuMetafile): void;

package/dist/types/src/web.html.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (jsfilePath: string, htmlFilePath: string, cssfilePath: string) => string;
+export default _default;