testeranto 0.202.0 → 0.205.0

package/dist/module/src/lib/Tiposkripto.test/MockTiposkripto.js

@@ -5,24 +5,13 @@ import Tiposkripto from "../Tiposkripto";
  * Concrete implementation of Tiposkripto for testing purposes
  */
 export class MockTiposkripto extends Tiposkripto {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter, uberCatcher = (cb) => cb()) {
-        // Call super first
+    constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: 0 }, testAdapter, uberCatcher = (cb) => cb()) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, uberCatcher);
         this.specs = [];
         this.testJobs = [];
         this.artifacts = [];
         this.features = [];
         this.testImplementation = testImplementation;
-        // Add debug logging for features
-        console.log('MockTiposkripto constructor called with input:', JSON.stringify(input));
-        // Validate required implementation methods
-        const requiredMethods = ["suites", "givens", "whens", "thens"];
-        requiredMethods.forEach((method) => {
-            if (!testImplementation[method]) {
-                throw new Error(`Missing required implementation method: ${method}`);
-            }
-        });
-        // Store the test adapter
         this.testAdapter = testAdapter;
         // Store implementation methods as overrides
         this.suitesOverrides = testImplementation.suites;
@@ -34,9 +23,9 @@ export class MockTiposkripto extends Tiposkripto {
         // Each Given corresponds to one test
         let totalTests = Object.keys(testImplementation.givens).length;
         // Override with specific values for test cases
-        if (input && typeof input === 'object') {
+        if (input && typeof input === "object") {
             const inputObj = input;
-            if ('testCount' in inputObj) {
+            if ("testCount" in inputObj) {
                 totalTests = Number(inputObj.testCount);
             }
         }
@@ -45,27 +34,27 @@ export class MockTiposkripto extends Tiposkripto {
             this.features = this.extractFeaturesFromSpecification(testSpecification);
         }
         catch (error) {
-            console.error('Failed to extract features, using fallback:', error);
+            console.error("Failed to extract features, using fallback:", error);
             // Fallback to basic features
             this.features = [
-                'Tiposkripto should initialize with default values',
-                'Custom input test',
-                'Resource requirements test',
-                'Should generate specs from test specification',
-                'Should create test jobs from specs',
-                'Should track artifacts',
-                'Should properly configure all overrides',
-                'Interface configuration test',
-                'Custom implementation test',
-                'Custom specification test',
-                'Should allow modifying specs',
-                'Should allow modifying jobs',
-                'Should properly handle errors',
-                'Should complete a full test run successfully',
-                'Should correctly count the number of tests',
-                'Should set runTimeTests to -1 on hard errors',
-                'Given a config that has 1 suite containing 5 GivenWhenThens',
-                'Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens'
+                "Tiposkripto should initialize with default values",
+                "Custom input test",
+                "Resource requirements test",
+                "Should generate specs from test specification",
+                "Should create test jobs from specs",
+                "Should track artifacts",
+                "Should properly configure all overrides",
+                "Interface configuration test",
+                "Custom implementation test",
+                "Custom specification test",
+                "Should allow modifying specs",
+                "Should allow modifying jobs",
+                "Should properly handle errors",
+                "Should complete a full test run successfully",
+                "Should correctly count the number of tests",
+                "Should set runTimeTests to -1 on hard errors",
+                "Given a config that has 1 suite containing 5 GivenWhenThens",
+                "Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens",
             ];
         }
     }
@@ -76,14 +65,16 @@ export class MockTiposkripto extends Tiposkripto {
             const mockSuite = (name, tests, features) => ({
                 name,
                 tests,
-                features
+                features,
             });
             // The Given function should take features, whens, thens
             const mockGiven = (features, whens, thens) => {
                 return {
-                    features: Array.isArray(features) ? features.filter(f => typeof f === 'string') : [],
+                    features: Array.isArray(features)
+                        ? features.filter((f) => typeof f === "string")
+                        : [],
                     whens,
-                    thens
+                    thens,
                 };
             };
             // Create mock When and Then objects that have all the methods from the implementation
@@ -92,13 +83,13 @@ export class MockTiposkripto extends Tiposkripto {
             const mockThen = {};
             // Add all when methods
             if (this.testImplementation.whens) {
-                Object.keys(this.testImplementation.whens).forEach(key => {
+                Object.keys(this.testImplementation.whens).forEach((key) => {
                     mockWhen[key] = (...args) => ({ name: key, args });
                 });
             }
             // Add all then methods
             if (this.testImplementation.thens) {
-                Object.keys(this.testImplementation.thens).forEach(key => {
+                Object.keys(this.testImplementation.thens).forEach((key) => {
                     mockThen[key] = (...args) => ({ name: key, args });
                 });
             }
@@ -107,13 +98,13 @@ export class MockTiposkripto extends Tiposkripto {
             // Extract all features from all tests in all suites
             const features = [];
             for (const suite of suites) {
-                if (suite && suite.tests && typeof suite.tests === 'object') {
+                if (suite && suite.tests && typeof suite.tests === "object") {
                     for (const testKey of Object.keys(suite.tests)) {
                         const test = suite.tests[testKey];
                         if (test && test.features && Array.isArray(test.features)) {
                             // Ensure all features are strings
                             for (const feature of test.features) {
-                                if (typeof feature === 'string') {
+                                if (typeof feature === "string") {
                                     features.push(feature);
                                 }
                             }
@@ -123,11 +114,10 @@ export class MockTiposkripto extends Tiposkripto {
             }
             // Remove duplicates
             const uniqueFeatures = [...new Set(features)];
-            console.log('Extracted features:', JSON.stringify(uniqueFeatures));
             return uniqueFeatures;
         }
         catch (error) {
-            console.error('Error extracting features from specification:', error);
+            console.error("Error extracting features from specification:", error);
             return [];
         }
     }
@@ -138,13 +128,13 @@ export class MockTiposkripto extends Tiposkripto {
                 throw new Error("Test adapter not configured");
             }
             // Ensure features are always strings
-            const stringFeatures = this.features.filter(f => typeof f === 'string');
+            const stringFeatures = this.features.filter((f) => typeof f === "string");
             // Calculate totalTests based on input
             let totalTests = Object.keys(this.givenOverides).length;
             const input = this.input;
             // Override with specific values for test cases
-            if (input && typeof input === 'object') {
-                if ('testCount' in input) {
+            if (input && typeof input === "object") {
+                if ("testCount" in input) {
                     totalTests = input.testCount;
                 }
             }

package/dist/module/src/lib/Tiposkripto.test/Tiposkripto.implementation.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { MockTiposkripto } from "./MockTiposkripto";
 import { specification } from "./Tiposkripto.specification";
 import { testAdapter } from "./Tiposkripto.adapter";
@@ -12,7 +14,7 @@ export const implementation = {
             const builder = new MockTiposkripto({}, // input
             specification, // Use the current specification
             implementation, // Use the current implementation
-            { ports: [] }, // Default resource requirements
+            { ports: 0 }, // Default resource requirements
             testAdapter, // Default adapter
             (cb) => cb() // Default uberCatcher
             );
@@ -24,19 +26,19 @@ export const implementation = {
             return builder;
         },
         WithCustomInput: (input = {}) => {
-            return new MockTiposkripto(input, specification, implementation, { ports: [] }, testAdapter, (cb) => cb());
+            return new MockTiposkripto(input, specification, implementation, { ports: 0 }, testAdapter, (cb) => cb());
         },
         WithResourceRequirements: (requirements = { ports: 0 }) => {
             return new MockTiposkripto({}, specification, implementation, requirements, testAdapter, (cb) => cb());
         },
         WithCustomImplementation: (impl = implementation) => {
-            return new MockTiposkripto({}, specification, impl, { ports: [] }, testAdapter, (cb) => cb());
+            return new MockTiposkripto({}, specification, impl, { ports: 0 }, testAdapter, (cb) => cb());
         },
         WithCustomSpecification: (spec = specification) => {
-            return new MockTiposkripto({}, spec, implementation, { ports: [] }, testAdapter, (cb) => cb());
+            return new MockTiposkripto({}, spec, implementation, { ports: 0 }, testAdapter, (cb) => cb());
         },
         WithCustomAdapter: (customAdapter = {}) => {
-            return new MockTiposkripto({}, specification, implementation, { ports: [] }, Object.assign(Object.assign({}, testAdapter), customAdapter), (cb) => cb());
+            return new MockTiposkripto({}, specification, implementation, { ports: 0 }, Object.assign(Object.assign({}, testAdapter), customAdapter), (cb) => cb());
         },
     },
     whens: {
@@ -144,16 +146,16 @@ export const implementation = {
             }
             // Check if the test adapter has the required methods
             const requiredMethods = [
-                'beforeAll',
-                'beforeEach',
-                'andWhen',
-                'butThen',
-                'afterEach',
-                'afterAll',
-                'assertThis'
+                "beforeAll",
+                "beforeEach",
+                "andWhen",
+                "butThen",
+                "afterEach",
+                "afterAll",
+                "assertThis",
             ];
             for (const method of requiredMethods) {
-                if (typeof builder.testAdapter[method] !== 'function') {
+                if (typeof builder.testAdapter[method] !== "function") {
                     throw new Error(`Test adapter missing required method: ${method}`);
                 }
             }

package/dist/module/src/lib/Tiposkripto.test/Tiposkripto.specification.js

@@ -1,4 +1,3 @@
-import { implementation } from "./Tiposkripto.implementation";
 export const specification = (Suite, Given, When, Then) => {
     return [
         Suite.Default("Tiposkripto Core Functionality", {
@@ -24,8 +23,8 @@ export const specification = (Suite, Given, When, Then) => {
         }),
         Suite.ExtendedSuite("Tiposkripto Advanced Features", {
             // Custom implementations
-            customImplementation: Given.WithCustomImplementation(["Custom implementation test"], [], [Then.specsGenerated(), Then.jobsCreated()], implementation),
-            customSpecification: Given.WithCustomSpecification(["Custom specification test"], [], [Then.specsGenerated(), Then.jobsCreated()], specification),
+            customImplementation: Given.WithCustomImplementation(["Custom implementation test"], [], [Then.specsGenerated(), Then.jobsCreated()]),
+            customSpecification: Given.WithCustomSpecification(["Custom specification test"], [], [Then.specsGenerated(), Then.jobsCreated()]),
             // Dynamic modification tests
             specModification: Given.Default(["Should allow modifying specs"], [When.modifySpecs((specs) => [...specs, "extra"])], [Then.specsModified(1)]),
             jobModification: Given.Default(["Should allow modifying jobs"], [When.modifyJobs((jobs) => [...jobs, {}])], [Then.jobsModified(1)]),
@@ -39,8 +38,12 @@ export const specification = (Suite, Given, When, Then) => {
             // Specific test cases for runTimeTests behavior
             runTimeTestsSingleSuiteFiveTests: Given.WithCustomInput(["Given a config that has 1 suite containing 5 GivenWhenThens"], [], [Then.runTimeTestsCountIs(5)], { testCount: 5 }),
             runTimeTestsSingleSuiteFiveTestsError: Given.WithCustomInput(["Given a config that has 1 suite containing 5 GivenWhenThens"], [When.triggerError("hard error")], [Then.runTimeTestsIsNegativeOne()], { testCount: 5 }),
-            runTimeTestsTwoSuitesThreeTestsEach: Given.WithCustomInput(["Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens"], [], [Then.runTimeTestsCountIs(6)], { testCount: 6 }),
-            runTimeTestsTwoSuitesThreeTestsEachError: Given.WithCustomInput(["Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens"], [When.triggerError("hard error")], [Then.runTimeTestsIsNegativeOne()], { testCount: 6 }),
+            runTimeTestsTwoSuitesThreeTestsEach: Given.WithCustomInput([
+                "Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens",
+            ], [], [Then.runTimeTestsCountIs(6)], { testCount: 6 }),
+            runTimeTestsTwoSuitesThreeTestsEachError: Given.WithCustomInput([
+                "Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens",
+            ], [When.triggerError("hard error")], [Then.runTimeTestsIsNegativeOne()], { testCount: 6 }),
         }),
     ];
 };

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

@@ -8,7 +8,6 @@ const baseProxy = function (pm, mappings) {
                 const arger = mapping[1];
                 if (prop === method) {
                     return (...x) => {
-                        // Add debug logging
                         const modifiedArgs = arger(...x);
                         return target[prop](...modifiedArgs);
                     };
@@ -27,19 +26,6 @@ export const butThenProxy = (pm, filepath, addArtifact) => {
             (opts, p) => {
                 const path = `${filepath}/butThen/${opts.path}`;
                 addArtifact(path);
-                // console.log(
-                //   `[ARTIFACT] Preparing to add to ${step.constructor.name}:`,
-                //   path
-                // );
-                // try {
-                //   console.log(
-                //     `[ARTIFACT] Successfully added to ${step.constructor.name}`
-                //   );
-                //   console.log(`[ARTIFACT] Current artifacts:`, JSON.stringify(step.artifacts));
-                // } catch (e) {
-                //   console.error(`[ARTIFACT] Failed to add ${path}:`, e);
-                //   throw e;
-                // }
                 return [
                     Object.assign(Object.assign({}, opts), { path }),
                     p,
@@ -57,24 +43,7 @@ export const butThenProxy = (pm, filepath, addArtifact) => {
         [
             "writeFileSync",
             (fp, contents, testName) => {
-                console.log(`[DEBUG] butThenProxy writeFileSync: fp="${fp}" (type: ${typeof fp}), contents="${contents}" (type: ${typeof contents}), testName="${testName}" (type: ${typeof testName})`);
-                // Check if fp is being treated as individual characters
-                if (typeof fp !== "string") {
-                    console.log(`[ERROR] fp is not a string:`, fp);
-                    // If fp is not a string, try to handle it
-                    if (Array.isArray(fp)) {
-                        // If it's an array, join it back into a string
-                        fp = fp.join("");
-                        console.log(`[DEBUG] Converted array to string: "${fp}"`);
-                    }
-                    else {
-                        // For other cases, convert to string
-                        fp = String(fp);
-                        console.log(`[DEBUG] Converted to string: "${fp}"`);
-                    }
-                }
                 const path = `${filepath}/butThen/${fp}`;
-                console.log(`[DEBUG] Generated path: "${path}"`);
                 addArtifact(path);
                 return [path, contents, testName];
             },
@@ -125,7 +94,6 @@ export const andWhenProxy = (pm, filepath, addArtifact) => {
             "customScreenShot",
             (opts, p) => {
                 const path = `${filepath}/andWhen/${opts.path}`;
-                // console.log("STEP2", JSON.stringify(step));
                 addArtifact(path);
                 return [
                     Object.assign(Object.assign({}, opts), { path }),
@@ -169,7 +137,6 @@ export const afterEachProxy = (pm, suite, given, addArtifact) => {
             (opts, p) => {
                 const path = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
                 addArtifact(path);
-                // console.log("STEP3", JSON.stringify(step));
                 return [
                     Object.assign(Object.assign({}, opts), { path }),
                     p,

package/dist/module/src/lib/pmProxy.test/implementation.js

@@ -1,33 +1,31 @@
 import { MockPMBase } from "./mockPMBase";
 import { butThenProxy } from "../pmProxy";
-function createPathRewriter(basePath) {
-    return (path) => {
-        if (!path)
-            return path;
-        // Normalize paths and handle edge cases
-        const normalizedPath = path.replace(/\\/g, "/");
-        const normalizedBase = basePath.replace(/\\/g, "/");
-        // Handle absolute paths
-        if (normalizedPath.startsWith("/")) {
-            return `${normalizedBase}${normalizedPath}`;
-        }
-        // Handle parent directory references
-        if (normalizedPath.includes("../")) {
-            const parts = normalizedPath.split("/");
-            const baseParts = normalizedBase.split("/");
-            for (const part of parts) {
-                if (part === "..") {
-                    baseParts.pop();
-                }
-                else if (part !== ".") {
-                    baseParts.push(part);
-                }
-            }
-            return baseParts.join("/");
-        }
-        return `${normalizedBase}/${normalizedPath}`;
-    };
-}
+// function createPathRewriter(basePath: string): PathRewriter {
+//   return (path: string) => {
+//     if (!path) return path;
+//     // Normalize paths and handle edge cases
+//     const normalizedPath = path.replace(/\\/g, "/");
+//     const normalizedBase = basePath.replace(/\\/g, "/");
+//     // Handle absolute paths
+//     if (normalizedPath.startsWith("/")) {
+//       return `${normalizedBase}${normalizedPath}`;
+//     }
+//     // Handle parent directory references
+//     if (normalizedPath.includes("../")) {
+//       const parts = normalizedPath.split("/");
+//       const baseParts = normalizedBase.split("/");
+//       for (const part of parts) {
+//         if (part === "..") {
+//           baseParts.pop();
+//         } else if (part !== ".") {
+//           baseParts.push(part);
+//         }
+//       }
+//       return baseParts.join("/");
+//     }
+//     return `${normalizedBase}/${normalizedPath}`;
+//   };
+// }
 export const implementation = {
     suites: {
         Default: "PM Proxy Tests",
@@ -65,70 +63,65 @@ export const implementation = {
                 actualPath = opts.path;
                 return originalCustomScreenShot.call(mockPm, opts, testName, pageUid);
             };
-            try {
-                switch (method) {
-                    case "writeFileSync":
-                        await butThenProxy(mockPm, filepath, {}).writeFileSync("test.txt", "content", "test");
-                        break;
-                    case "createWriteStream":
-                        await butThenProxy(mockPm, filepath, {}).createWriteStream("stream.txt", "test");
-                        break;
-                    case "screencast":
-                        await butThenProxy(mockPm, filepath, {}).screencast({ path: "screen.png" }, "test");
-                        break;
-                    case "customScreenShot":
-                        await butThenProxy(mockPm, filepath, {}).customScreenShot({ path: "shot.png" }, "test");
-                        break;
-                    default:
-                        throw new Error(`Unknown method: ${method}`);
-                }
-                // For now, just return the actual path to be asserted against expectedPath
-                // The testAdapter.assertThis will handle the comparison
-                return actualPath;
-            }
-            catch (error) {
-                throw error;
+            switch (method) {
+                case "writeFileSync":
+                    await butThenProxy(mockPm, filepath, {}).writeFileSync("test.txt", "content", "test");
+                    break;
+                case "createWriteStream":
+                    await butThenProxy(mockPm, filepath, {}).createWriteStream("stream.txt", "test");
+                    break;
+                case "screencast":
+                    await butThenProxy(mockPm, filepath, {}).screencast({ path: "screen.png" }, "test");
+                    break;
+                case "customScreenShot":
+                    await butThenProxy(mockPm, filepath, {}).customScreenShot({ path: "shot.png" }, "test");
+                    break;
+                default:
+                    throw new Error(`Unknown method: ${method}`);
             }
+            // For now, just return the actual path to be asserted against expectedPath
+            // The testAdapter.assertThis will handle the comparison
+            return actualPath;
         },
-        verifyContent: (expectedContent) => (result) => {
-            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;
-        },
-        // Test to verify tests.json is written correctly
-        verifyTestsJsonWrite: () => async (store) => {
-            const mockPm = new MockPMBase();
-            // Track the actual parameters passed to writeFileSync
-            let actualArgs;
-            const originalWriteFileSync = mockPm.writeFileSync;
-            mockPm.writeFileSync = async (...args) => {
-                actualArgs = args;
-                // Check if the first argument is being split
-                if (args[0] && typeof args[0] === "string") {
-                    console.log(`[TESTS.JSON DEBUG] First argument length: ${args[0].length}, value: "${args[0]}"`);
-                }
-                return originalWriteFileSync.apply(mockPm, args);
-            };
-            // Simulate writing tests.json through the proxy
-            // This should mimic the call in BaseBuilder: puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2))
-            const testData = { test: "data" };
-            // const result = await butThenProxy(mockPm, "test/path", {}).writeFileSync(
-            //   "tests.json",
-            //   JSON.stringify(testData, null, 2),
-            //   "test"
-            // );
-            // Check if both path and content are correct
-            if (actualArgs &&
-                actualArgs[0] === "test/path/butThen/tests.json" &&
-                actualArgs[1] === JSON.stringify(testData, null, 2) &&
-                actualArgs[2] === "test") {
-                return "PASS";
-            }
-            else {
-                return `FAIL: args=${JSON.stringify(actualArgs)}`;
+    },
+    verifyContent: (expectedContent) => (result) => {
+        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;
+    },
+    // Test to verify tests.json is written correctly
+    verifyTestsJsonWrite: () => async (store) => {
+        const mockPm = new MockPMBase();
+        // Track the actual parameters passed to writeFileSync
+        let actualArgs;
+        const originalWriteFileSync = mockPm.writeFileSync;
+        mockPm.writeFileSync = async (...args) => {
+            actualArgs = args;
+            // Check if the first argument is being split
+            if (args[0] && typeof args[0] === "string") {
+                console.log(`[TESTS.JSON DEBUG] First argument length: ${args[0].length}, value: "${args[0]}"`);
             }
-        },
+            return originalWriteFileSync.apply(mockPm, args);
+        };
+        // Simulate writing tests.json through the proxy
+        // This should mimic the call in BaseBuilder: puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2))
+        const testData = { test: "data" };
+        // const result = await butThenProxy(mockPm, "test/path", {}).writeFileSync(
+        //   "tests.json",
+        //   JSON.stringify(testData, null, 2),
+        //   "test"
+        // );
+        // Check if both path and content are correct
+        if (actualArgs &&
+            actualArgs[0] === "test/path/butThen/tests.json" &&
+            actualArgs[1] === JSON.stringify(testData, null, 2) &&
+            actualArgs[2] === "test") {
+            return "PASS";
+        }
+        else {
+            return `FAIL: args=${JSON.stringify(actualArgs)}`;
+        }
     },
 };

package/dist/module/src/lib/pmProxy.test/index.js

@@ -3,8 +3,6 @@ import { implementation } from "./implementation";
 import { specification } from "./specification";
 import { testAdapter } from "./adapter";
 import { butThenProxy } from "../pmProxy";
-export default Testeranto(
-// because of the nature of testeranto, we must add all the testable items here
-{
+export default Testeranto({
     butThenProxy,
 }, specification, implementation, testAdapter);

package/dist/module/src/lib/pmProxy.test/mockPM.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { MockPMBase } from "./mockPMBase";
 export class MockPM extends MockPMBase {
     constructor(configs) {

package/dist/module/src/lib/pmProxy.test/specification.js

@@ -1,4 +1,3 @@
-console.log("wtf");
 export const specification = (Suite, Given, When, Then) => [
     Suite.Default("PM Proxy Functionality", {
         // Basic path rewriting tests