testeranto 0.166.0 → 0.171.0

package/dist/module/src/components/stateful/TestPage.js

@@ -0,0 +1,82 @@
+import React, { useEffect, useState } from 'react';
+import { useLocation, useNavigate, useParams } from 'react-router-dom';
+import { TestPageView } from '../pure/TestPageView';
+import { fetchTestData } from '../../utils/api';
+export const TestPage = () => {
+    const navigate = useNavigate();
+    const location = useLocation();
+    const [route, setRoute] = useState('results');
+    // Sync route with hash changes
+    useEffect(() => {
+        const hash = location.hash.replace('#', '');
+        if (hash && ['results', 'logs', 'types', 'lint', 'coverage'].includes(hash)) {
+            setRoute(hash);
+        }
+        else {
+            setRoute('results');
+        }
+    }, [location.hash]);
+    const [testName, setTestName] = useState('');
+    const [testData, setTestData] = useState(null);
+    const [logs, setLogs] = useState('');
+    const [typeErrors, setTypeErrors] = useState('');
+    const [lintErrors, setLintErrors] = useState('');
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [testsExist, setTestsExist] = useState(true);
+    const [errorCounts, setErrorCounts] = useState({
+        typeErrors: 0,
+        staticErrors: 0,
+        runTimeErrors: 0
+    });
+    const [summary, setSummary] = useState(null);
+    const { projectName, '*': splat } = useParams();
+    const pathParts = splat ? splat.split('/') : [];
+    const runtime = pathParts.pop() || '';
+    const testPath = pathParts.join('/');
+    const decodedTestPath = testPath ? decodeURIComponent(testPath) : '';
+    useEffect(() => {
+        if (!projectName || !testPath || !runtime)
+            return;
+        setTestName(testPath);
+        const fetchData = async () => {
+            try {
+                const testResponse = await fetchTestData(projectName, testPath, runtime);
+                setTestData(testResponse.testData);
+                setTestsExist(!!testResponse.testData);
+                setLogs(testResponse.logs === null ? undefined : testResponse.logs);
+                setTypeErrors(testResponse.typeErrors);
+                setLintErrors(testResponse.lintErrors);
+                try {
+                    const summaryResponse = await fetch(`reports/${projectName}/summary.json`);
+                    if (!summaryResponse.ok)
+                        throw new Error('Failed to fetch summary');
+                    const allSummaries = await summaryResponse.json();
+                    const testSummary = allSummaries[testPath];
+                    if (testSummary) {
+                        const counts = {
+                            typeErrors: Number(testSummary.typeErrors) || 0,
+                            staticErrors: Number(testSummary.staticErrors) || 0,
+                            runTimeErrors: Number(testSummary.runTimeErrors) || 0
+                        };
+                        setSummary(testSummary);
+                        setErrorCounts(counts);
+                        setTestsExist(testSummary.testsExist !== false);
+                    }
+                }
+                catch (err) {
+                    console.error('Failed to load summary:', err);
+                }
+            }
+            catch (err) {
+                setError(err instanceof Error ? err.message : 'Unknown error');
+                setTestsExist(false);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        fetchData();
+    }, []);
+    return (React.createElement(TestPageView, { route: route, setRoute: setRoute, navigate: navigate, projectName: projectName, testName: testName, decodedTestPath: decodedTestPath, runtime: runtime, testData: testData, logs: logs, typeErrors: typeErrors, lintErrors: lintErrors, loading: loading, error: error, testsExist: testsExist, errorCounts: errorCounts, summary: summary }));
+};

package/dist/module/src/lib/BaseSuite.js

@@ -11,7 +11,7 @@ export class BaseSuite {
         this.givens = givens;
         this.fails = 0;
         console.log("[DEBUG] BaseSuite initialized:", this.name, this.index);
-        console.log("[DEBUG] BaseSuite givens:", Object.keys(givens));
+        console.log("[DEBUG] BaseSuite givens:", Object.keys(givens).toString());
     }
     features() {
         try {
@@ -21,7 +21,7 @@ export class BaseSuite {
                 .filter((value, index, array) => {
                 return array.indexOf(value) === index;
             });
-            console.debug("[DEBUG] Features extracted:", features);
+            console.debug("[DEBUG] Features extracted:", features.toString());
             return features || [];
         }
         catch (e) {
@@ -64,7 +64,7 @@ export class BaseSuite {
                 .catch((e) => {
                 this.failed = true;
                 this.fails = this.fails + 1;
-                console.error("Given error 1:", e);
+                // console.error("Given error 1:", e.toString());
                 throw e;
             });
         }

package/dist/module/src/lib/BaseSuite.test/test.js

@@ -246,7 +246,7 @@ export const testAdapter = {
             return result;
         }
         catch (e) {
-            console.error("Then error:", e);
+            console.error("Then error:", e.toString());
             console.error("Full store state:", JSON.stringify(store, null, 2));
             throw e;
         }

package/dist/module/src/lib/abstractBase.js

@@ -2,7 +2,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { afterEachProxy, andWhenProxy, beforeEachProxy, butThenProxy, } from "./pmProxy.js";
 export class BaseGiven {
+    addArtifact(path) {
+        console.log(`[Artifact] Adding to ${this.constructor.name}:`, path);
+        this.artifacts.push(path);
+    }
     constructor(name, features, whens, thens, givenCB, initialValues) {
+        this.artifacts = [];
         this.name = name;
         this.features = features;
         this.whens = whens;
@@ -20,13 +25,14 @@ export class BaseGiven {
             whens: this.whens.map((w) => {
                 if (w && w.toObj)
                     return w.toObj();
-                console.error("w is not as expected!", w);
+                console.error("w is not as expected!", w.toString());
                 return {};
             }),
             thens: this.thens.map((t) => t.toObj()),
             error: this.error ? [this.error, this.error.stack] : null,
             failed: this.failed,
             features: this.features,
+            artifacts: this.artifacts,
         };
     }
     async afterEach(store, key, artifactory, pm) {
@@ -38,15 +44,18 @@ export class BaseGiven {
         tLog(`\n Given: ${this.name}`);
         const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
         this.uberCatcher((e) => {
-            console.error(e);
+            console.error(e.toString());
             this.error = e.error;
             tLog(e.stack);
         });
         try {
-            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, beforeEachProxy(pm, suiteNdx.toString()));
+            const proxiedPm = beforeEachProxy(pm, suiteNdx.toString());
+            console.log(`[Given] Setting currentStep for beforeEach:`, this.name);
+            proxiedPm.currentStep = this;
+            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, proxiedPm);
         }
         catch (e) {
-            console.error("failure 4 ", e);
+            console.error("Given failure: ", e.toString());
             this.error = e;
             throw e;
         }
@@ -73,7 +82,7 @@ export class BaseGiven {
                 await this.afterEach(this.store, this.key, givenArtifactory, afterEachProxy(pm, suiteNdx.toString(), key));
             }
             catch (e) {
-                console.error("afterEach failed!", e);
+                console.error("afterEach failed!", e.toString());
                 this.failed = e;
                 throw e;
                 // this.error = e.message;
@@ -84,26 +93,39 @@ export class BaseGiven {
 }
 export class BaseWhen {
     constructor(name, whenCB) {
+        this.artifacts = [];
         this.name = name;
         this.whenCB = whenCB;
     }
     toObj() {
         console.log("toObj error", this.error);
-        return {
-            name: this.name,
-            error: this.error && this.error.name + this.error.stack,
-        };
+        if (this.error) {
+            return {
+                name: this.name,
+                error: this.error && this.error.name + this.error.stack,
+                artifacts: this.artifacts,
+            };
+        }
+        else {
+            return {
+                name: this.name,
+                artifacts: this.artifacts,
+            };
+        }
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
         try {
             tLog(" When:", this.name);
-            console.debug("[DEBUG] Executing When step:", this.name);
-            const result = await this.andWhen(store, this.whenCB, testResourceConfiguration, andWhenProxy(pm, filepath));
-            console.debug("[DEBUG] When step completed:", this.name);
+            console.debug("[DEBUG] Executing When step:", this.name.toString());
+            const proxiedPm = andWhenProxy(pm, filepath);
+            console.log(`[When] Setting currentStep for andWhen:`, this.name);
+            proxiedPm.currentStep = this;
+            const result = await this.andWhen(store, this.whenCB, testResourceConfiguration, proxiedPm);
+            console.debug("[DEBUG] When step completed:", this.name.toString());
             return result;
         }
         catch (e) {
-            console.error("[ERROR] When step failed:", this.name, e);
+            console.error("[ERROR] When step failed:", this.name.toString(), e.toString());
             this.error = e;
             throw e;
         }
@@ -111,6 +133,7 @@ export class BaseWhen {
 }
 export class BaseThen {
     constructor(name, thenCB) {
+        this.artifacts = [];
         this.name = name;
         this.thenCB = thenCB;
         this.error = false;
@@ -119,12 +142,16 @@ export class BaseThen {
         return {
             name: this.name,
             error: this.error,
+            artifacts: this.artifacts,
         };
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
+        const proxiedPm = butThenProxy(pm, filepath);
+        console.log(`[Then] Setting currentStep for butThen:`, this.name);
+        proxiedPm.currentStep = this;
         return this.butThen(store, async (s) => {
             if (typeof this.thenCB === "function") {
-                return await this.thenCB(s);
+                return await this.thenCB(s, proxiedPm);
             }
             else {
                 return this.thenCB;

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.adapter.js

@@ -7,7 +7,7 @@ export const testAdapter = {
             initialValues,
         });
         const result = initializer();
-        console.log("Initialization result:", result);
+        console.log("Initialization result:", result.toString());
         return result;
     },
     andWhen: async (store, whenCB, testResource, utils) => {

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.mock.js

@@ -24,7 +24,7 @@ export class MockBaseBuilder extends BaseBuilder {
             failed: false,
             fails: 0,
             artifacts: [],
-            logPromise: Promise.resolve(),
+            // logPromise: Promise.resolve(),
             features: [],
         });
     }

package/dist/module/src/lib/basebuilder.js

@@ -28,17 +28,19 @@ export class BaseBuilder {
                 },
                 runner,
                 receiveTestResourceConfig: async function (puppetMaster) {
-                    const logFilePath = "logs.txt";
-                    const access = await puppetMaster.createWriteStream(logFilePath);
+                    // const logFilePath = "logs.txt";
+                    // const access: number = await puppetMaster.createWriteStream(
+                    //   logFilePath
+                    // );
                     // deprecated?
                     const tLog = async (...l) => {
                         //
                     };
                     const suiteDone = await runner(puppetMaster, tLog);
-                    const logPromise = new Promise(async (res) => {
-                        await puppetMaster.end(access);
-                        res(true);
-                    });
+                    // const logPromise = new Promise(async (res) => {
+                    //   await puppetMaster.end(access);
+                    //   res(true);
+                    // });
                     const fails = suiteDone.fails;
                     await puppetMaster.writeFileSync(`bdd_errors.txt`, fails.toString());
                     await puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
@@ -46,7 +48,7 @@ export class BaseBuilder {
                         failed: fails > 0,
                         fails,
                         artifacts: this.artifacts || [],
-                        logPromise,
+                        // logPromise,
                         features: suiteDone.features(),
                     };
                 },

package/dist/module/src/lib/core.test/MockCore.js

@@ -1,32 +1,34 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import TesterantoCore from "../core";
 /**
  * Concrete implementation of Testeranto for testing purposes
  */
 export class MockCore extends TesterantoCore {
     constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter, uberCatcher = (cb) => cb()) {
-        console.log('[DEBUG] MockCore constructor starting...');
+        console.log("[DEBUG] MockCore constructor starting...");
         if (!testImplementation) {
-            throw new Error('testImplementation is required');
+            throw new Error("testImplementation is required");
         }
         if (!testSpecification) {
-            console.warn('[WARN] testSpecification is null/undefined - tests may fail');
+            console.warn("[WARN] testSpecification is null/undefined - tests may fail");
         }
-        console.log('[DEBUG] MockCore constructor called with:');
-        console.log('- input:', JSON.stringify(input, null, 2));
-        console.log('- testSpecification keys:', Object.keys(testSpecification));
-        console.log('- testImplementation keys:', Object.keys(testImplementation));
-        console.log('- testResourceRequirement:', JSON.stringify(testResourceRequirement));
-        console.log('- testAdapter keys:', Object.keys(testAdapter));
+        console.log("[DEBUG] MockCore constructor called with:");
+        console.log("- input:", JSON.stringify(input, null, 2));
+        console.log("- testSpecification keys:", Object.keys(testSpecification));
+        console.log("- testImplementation keys:", Object.keys(testImplementation));
+        console.log("- testResourceRequirement:", JSON.stringify(testResourceRequirement));
+        console.log("- testAdapter keys:", Object.keys(testAdapter));
         // Validate required implementation methods
-        const requiredMethods = ['suites', 'givens', 'whens', 'thens'];
-        requiredMethods.forEach(method => {
+        const requiredMethods = ["suites", "givens", "whens", "thens"];
+        requiredMethods.forEach((method) => {
             if (!testImplementation[method]) {
                 throw new Error(`Missing required implementation method: ${method}`);
             }
         });
-        console.log('[DEBUG] Validation passed, calling super...');
-        this.testResourceRequirement = testResourceRequirement;
-        this.testAdapter = testAdapter;
+        console.log("[DEBUG] Validation passed, calling super...");
+        // this.testResourceRequirement = testResourceRequirement;
+        // this.testAdapter = testAdapter;
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, uberCatcher);
         this.specs = [];
         this.testJobs = [];
@@ -37,7 +39,7 @@ export class MockCore extends TesterantoCore {
             failed: false,
             fails: 0,
             artifacts: [],
-            logPromise: Promise.resolve(),
+            // logPromise: Promise.resolve(),
             features: [],
         };
     }