testeranto 0.200.1 → 0.202.0

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

@@ -12,33 +12,33 @@ exports.implementation = {
     givens: {
         Default: () => {
             console.log("Creating default test builder instance");
-            // Use a function to defer the implementation reference
-            const createBuilder = (impl) => {
-                return new MockTiposkripto_1.MockTiposkripto({}, // input
-                Tiposkripto_specification_1.specification, // Use the current specification
-                impl, // Use the passed implementation
-                { ports: [] }, // Default resource requirements
-                Tiposkripto_adapter_1.testAdapter, // Default adapter
-                (cb) => cb() // Default uberCatcher
-                );
-            };
-            const builder = createBuilder(exports.implementation);
+            const builder = new MockTiposkripto_1.MockTiposkripto({}, // input
+            Tiposkripto_specification_1.specification, // Use the current specification
+            exports.implementation, // Use the current implementation
+            { ports: [] }, // Default resource requirements
+            Tiposkripto_adapter_1.testAdapter, // Default adapter
+            (cb) => cb() // Default uberCatcher
+            );
             console.log("Builder created:", builder);
+            // Ensure the test adapter is properly set
+            if (!builder.testAdapter) {
+                builder.testAdapter = Tiposkripto_adapter_1.testAdapter;
+            }
             return builder;
         },
-        WithCustomInput: (input) => {
+        WithCustomInput: (input = {}) => {
             return new MockTiposkripto_1.MockTiposkripto(input, Tiposkripto_specification_1.specification, exports.implementation, { ports: [] }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
-        WithResourceRequirements: (requirements) => {
+        WithResourceRequirements: (requirements = { ports: 0 }) => {
             return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, exports.implementation, requirements, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
-        WithCustomImplementation: (impl) => {
+        WithCustomImplementation: (impl = exports.implementation) => {
             return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, impl, { ports: [] }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
-        WithCustomSpecification: (spec) => {
+        WithCustomSpecification: (spec = Tiposkripto_specification_1.specification) => {
             return new MockTiposkripto_1.MockTiposkripto({}, spec, exports.implementation, { ports: [] }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
-        WithCustomAdapter: (customAdapter) => {
+        WithCustomAdapter: (customAdapter = {}) => {
             return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, exports.implementation, { ports: [] }, Object.assign(Object.assign({}, Tiposkripto_adapter_1.testAdapter), customAdapter), (cb) => cb());
         },
     },
@@ -62,11 +62,14 @@ exports.implementation = {
         triggerError: (message) => (builder) => {
             throw new Error(message);
         },
+        // Add a when to simulate receiving test resource config
+        receiveTestResourceConfig: (config) => async (builder) => {
+            return await builder.receiveTestResourceConfig(config);
+        },
     },
     thens: {
-        "it is initialized": () => (builder, utils) => {
+        initializedProperly: () => (builder, utils) => {
             var _a;
-            utils.writeFileSync("hello.txt", "world");
             if (!builder) {
                 throw new Error("Builder is undefined");
             }
@@ -142,6 +145,21 @@ exports.implementation = {
             if (!builder.testAdapter) {
                 throw new Error("Test adapter not configured");
             }
+            // Check if the test adapter has the required methods
+            const requiredMethods = [
+                'beforeAll',
+                'beforeEach',
+                'andWhen',
+                'butThen',
+                'afterEach',
+                'afterAll',
+                'assertThis'
+            ];
+            for (const method of requiredMethods) {
+                if (typeof builder.testAdapter[method] !== 'function') {
+                    throw new Error(`Test adapter missing required method: ${method}`);
+                }
+            }
             return builder;
         },
         specsModified: (expectedCount) => (builder) => {
@@ -161,13 +179,35 @@ exports.implementation = {
             return builder;
         },
         testRunSuccessful: () => async (builder) => {
-            try {
-                await builder.receiveTestResourceConfig("");
-                return builder;
+            await builder.receiveTestResourceConfig("");
+            return builder;
+        },
+        runTimeTestsCounted: () => async (builder) => {
+            const result = await builder.receiveTestResourceConfig("");
+            // The total number of tests should be greater than 0
+            if (result.runTimeTests <= 0) {
+                throw new Error(`Expected runTimeTests > 0, got ${result.runTimeTests}`);
             }
-            catch (e) {
-                throw new Error(`Test run failed: ${e.message}`);
+            return builder;
+        },
+        runTimeTestsSetToNegativeOne: () => async (builder) => {
+            await builder.receiveTestResourceConfig("");
+            // If we reach here, no error was thrown, which is unexpected
+            // But we'll let the test fail naturally
+            return builder;
+        },
+        runTimeTestsCountIs: (expectedCount) => async (builder) => {
+            const result = await builder.receiveTestResourceConfig("");
+            if (result.runTimeTests !== expectedCount) {
+                throw new Error(`Expected runTimeTests to be ${expectedCount}, got ${result.runTimeTests}`);
             }
+            return builder;
+        },
+        runTimeTestsIsNegativeOne: () => async (builder) => {
+            await builder.receiveTestResourceConfig("");
+            // If we reach here, no error was thrown, which is unexpected
+            // But we'll let the test fail naturally
+            return builder;
         },
     },
 };

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

@@ -7,8 +7,8 @@ const specification = (Suite, Given, When, Then) => {
         Suite.Default("Tiposkripto Core Functionality", {
             // Basic initialization tests
             initialization: Given.Default(["Tiposkripto should initialize with default values"], [], [Then.initializedProperly()]),
-            customInput: Given.WithCustomInput({ custom: "input" }, [], [Then.initializedProperly()]),
-            resourceRequirements: Given.WithResourceRequirements({ ports: [3000, 3001] }, [], [Then.resourceRequirementsSet()]),
+            customInput: Given.WithCustomInput(["Custom input test"], [], [Then.initializedProperly()]),
+            resourceRequirements: Given.WithResourceRequirements(["Resource requirements test"], [], [Then.resourceRequirementsSet()]),
             // Core functionality tests
             specGeneration: Given.Default(["Should generate specs from test specification"], [], [Then.specsGenerated()]),
             jobCreation: Given.Default(["Should create test jobs from specs"], [], [Then.jobsCreated()]),
@@ -20,15 +20,15 @@ const specification = (Suite, Given, When, Then) => {
                 Then.whensOverridesConfigured(),
                 Then.thensOverridesConfigured(),
             ]),
-            interfaceConfiguration: Given.WithCustomAdapter({
+            interfaceConfiguration: Given.WithCustomAdapter(["Interface configuration test"], [], [Then.interfaceConfigured()], {
                 assertThis: (x) => !!x,
                 beforeEach: async (s, i) => i(),
-            }, [], [Then.interfaceConfigured()]),
+            }),
         }),
         Suite.ExtendedSuite("Tiposkripto Advanced Features", {
             // Custom implementations
-            customImplementation: Given.WithCustomImplementation(Tiposkripto_implementation_1.implementation, [], [Then.specsGenerated(), Then.jobsCreated()]),
-            customSpecification: Given.WithCustomSpecification(exports.specification, [], [Then.specsGenerated(), Then.jobsCreated()]),
+            customImplementation: Given.WithCustomImplementation(["Custom implementation test"], [], [Then.specsGenerated(), Then.jobsCreated()], Tiposkripto_implementation_1.implementation),
+            customSpecification: Given.WithCustomSpecification(["Custom specification test"], [], [Then.specsGenerated(), Then.jobsCreated()], exports.specification),
             // 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)]),
@@ -36,6 +36,14 @@ const specification = (Suite, Given, When, Then) => {
             errorHandling: Given.Default(["Should properly handle errors"], [When.triggerError("test error")], [Then.errorThrown("test error")]),
             // Full test run
             fullTestRun: Given.Default(["Should complete a full test run successfully"], [], [Then.testRunSuccessful()]),
+            // runTimeTests behavior
+            runTimeTestsCount: Given.Default(["Should correctly count the number of tests"], [], [Then.runTimeTestsCounted()]),
+            runTimeTestsOnError: Given.Default(["Should set runTimeTests to -1 on hard errors"], [When.triggerError("test error")], [Then.runTimeTestsSetToNegativeOne()]),
+            // 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 }),
         }),
     ];
 };

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

@@ -1,64 +1,179 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.specification = void 0;
+console.log("wtf");
 const specification = (Suite, Given, When, Then) => [
     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"),
-        testsJsonTest: Given.SomeBaseString(["butThenProxy should handle tests.json correctly"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/tests.json"),
-        ], "tests.json 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"),
+        // 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"
+        // ),
+        // testsJsonTest: Given.SomeBaseString(
+        //   ["butThenProxy should handle tests.json correctly"],
+        //   [],
+        //   [
+        //     Then.theButTheProxyReturns(
+        //       "writeFileSync",
+        //       "test/path/butThen/tests.json"
+        //     ),
+        //   ],
+        //   "tests.json 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"
+    //   ),
+    // }),
 ];
 exports.specification = specification;