testeranto 0.80.0 → 0.81.1

package/dist/module/src/SubPackages/react-test-renderer/jsx/index.js

@@ -1,14 +1,29 @@
 import React from "react";
 import renderer, { act } from "react-test-renderer";
+const Context = React.createContext({});
+const AppContext = React.createContext({});
+const contextValue = {
+    ingredients: ["flour", "sugar", "eggs"],
+    temperature: "200",
+};
 export const testInterface = {
     butThen: async function (s, thenCB, tr) {
-        console.log("butThen", thenCB.toString());
+        // console.log("butThen", thenCB.toString());
         return thenCB(s);
     },
     beforeEach: function (CComponent, props) {
         let component;
         act(() => {
-            component = renderer.create(React.createElement(CComponent, props, []));
+            // component = renderer.create(
+            //   React.createElement(
+            //     AppContext.Provider,
+            //     { value: contextValue },
+            //     React.createElement(AppContext.Consumer, null, (context) =>
+            //       React.createElement(CComponent, Object.assign({}, context, {}))
+            //     )
+            //   )
+            // );
+            component = renderer.create(React.createElement(CComponent, props, React.createElement(CComponent, props, [])));
         });
         return component;
     },

package/dist/module/src/esbuildConfigs/inputFilesPlugin.js

@@ -1,20 +1,20 @@
 import fs from "fs";
 import path from "path";
 export default (platform, entryPoints) => {
-    console.log("mark3", platform);
     return {
         name: "metafileWriter",
         setup(build) {
             build.onEnd((result) => {
                 if (result.errors.length === 0) {
                     entryPoints.forEach((entryPoint) => {
-                        console.log("mark1", entryPoint);
                         const filePath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `inputFiles.json`);
+                        const promptPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `prompt.txt`);
+                        const testPaths = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
                         const dirName = path.dirname(filePath);
                         if (!fs.existsSync(dirName)) {
                             fs.mkdirSync(dirName, { recursive: true });
                         }
-                        const jsonContent = JSON.stringify(Object.keys(Object.keys(result.metafile.outputs)
+                        const j = Object.keys(Object.keys(result.metafile.outputs)
                             .filter((s) => {
                             if (!result.metafile.outputs[s].entryPoint) {
                                 return false;
@@ -25,20 +25,47 @@ export default (platform, entryPoints) => {
                             .reduce((mm, el) => {
                             mm.push(result.metafile.outputs[el].inputs);
                             return mm;
-                        }, [])[0])
-                            .filter((f) => {
+                        }, [])[0]).filter((f) => {
                             const regex = /^src\/.*/g;
                             const matches = f.match(regex);
                             const passes = (matches === null || matches === void 0 ? void 0 : matches.length) === 1;
                             return passes;
-                        })
-                            .filter((f) => {
-                            const regex = /.*\.test\..*/g;
-                            const matches = f.match(regex);
-                            const passes = (matches === null || matches === void 0 ? void 0 : matches.length) === 1;
-                            return !passes;
-                        }));
+                        });
+                        // .filter((f: string) => {
+                        //   const regex = /.*\.test\..*/g;
+                        //   const matches = f.match(regex);
+                        //   const passes = matches?.length === 1;
+                        //   return !passes;
+                        // })
+                        const jsonContent = JSON.stringify(j);
                         fs.writeFileSync(filePath, jsonContent);
+                        fs.writeFileSync(promptPath, `
+${j
+                            .map((x) => {
+                            return `/add ${x}`;
+                        })
+                            .join("\n")}
+/read ${testPaths}
+  
+/code fix the failing tests described in ${filePath}.
+`);
+                        //             fs.writeFileSync(
+                        //               promptPath,
+                        //               `
+                        // from aider.coders import Coder
+                        // from aider.models import Model
+                        // import os
+                        // model = Model("deepseek")
+                        // coder = Coder.create(main_model=model)
+                        // coder.run("/read-only", "${testPaths}")
+                        // ${j
+                        //   .map((x) => {
+                        //     return `coder.run("/add", "${x}")`;
+                        //   })
+                        //   .join("\n")}
+                        // coder.run("fix the failing tests described in ${filePath}.")
+                        // `
+                        //             );
                     });
                 }
             });

package/dist/module/src/esbuildConfigs/web.js

@@ -11,10 +11,10 @@ export default (config, entryPoints) => {
         outdir: config.outdir + "/web", alias: {
             react: path.resolve("./node_modules/react"),
         }, metafile: true, external: [
-            "testeranto.json",
-            "features.test.ts",
+            // "testeranto.json",
+            // "features.test.ts",
             // "url",
-            "react",
+            // "react",
             "path",
             "fs",
             "stream",

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

@@ -7,10 +7,22 @@ export class BaseSuite {
         this.fails = [];
     }
     toObj() {
+        const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
+        const features = Object.keys(this.givens)
+            .map((k) => this.givens[k].features)
+            .flat()
+            .filter((value, index, array) => {
+            return array.indexOf(value) === index;
+        })
+            .reduce((mm, lm) => {
+            mm[lm] = lm;
+            return mm;
+        }, {});
         return {
             name: this.name,
-            givens: Object.keys(this.givens).map((k) => this.givens[k].toObj()),
+            givens,
             fails: this.fails,
+            features,
         };
     }
     setup(s, artifactory, tr, pm) {
@@ -226,7 +238,7 @@ export class BaseGiven {
                 },
             });
             this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, beforeEachProxy);
-            console.log("mark6", this.store);
+            // console.log("mark6", this.store);
             for (const [whenNdx, whenStep] of this.whens.entries()) {
                 await whenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/when/${whenNdx}`);
             }
@@ -325,7 +337,7 @@ export class BaseGiven {
                         return Reflect.get(...arguments);
                     },
                 });
-                console.log("mark5", this.store, key);
+                // console.log("mark5", this.store, key);
                 await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
             }
             catch (e) {
@@ -443,13 +455,21 @@ export class BaseWhen {
                 return Reflect.get(...arguments);
             },
         });
-        try {
-            return await this.andWhen(store, this.whenCB, testResourceConfiguration, andWhenProxy);
-        }
-        catch (e) {
+        return this.andWhen(store, this.whenCB, testResourceConfiguration, andWhenProxy).catch((e) => {
             this.error = true;
-            throw e;
-        }
+            // throw e;
+        });
+        // try {
+        //   return await this.andWhen(
+        //     store,
+        //     this.whenCB,
+        //     testResourceConfiguration,
+        //     andWhenProxy
+        //   );
+        // } catch (e) {
+        //   this.error = true;
+        //   throw e;
+        // }
     }
 }
 export class BaseThen {
@@ -529,10 +549,18 @@ export class BaseThen {
                     return Reflect.get(...arguments);
                 },
             });
-            const x = await this.butThen(store, this.thenCB, testResourceConfiguration, butThenProxy
-            // pm
-            );
-            return x;
+            // const x = await this.butThen(
+            //   store,
+            //   this.thenCB,
+            //   testResourceConfiguration,
+            //   butThenProxy
+            // );
+            // return x;
+            return this.butThen(store, this.thenCB, testResourceConfiguration, butThenProxy).catch((e) => {
+                console.log("mar123");
+                this.error = true;
+                throw e;
+            });
         }
         catch (e) {
             console.log("test failed", e);

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

@@ -13,12 +13,15 @@ export class BaseBuilder {
         this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then(), this.Check());
         this.testJobs = this.specs.map((suite) => {
             const suiteRunner = (suite) => async (puppetMaster, tLog) => {
-                await puppetMaster.startPuppeteer({
+                const puppeteerBrowser = await puppetMaster.startPuppeteer({
                     browserWSEndpoint: puppetMaster.testResourceConfiguration.browserWSEndpoint,
                 }, puppetMaster.testResourceConfiguration.fs);
-                return await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
+                const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
                     this.artifacts.push(p);
                 })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
+                // await puppetMaster.browser.disconnect();
+                // puppeteerBrowser.close();
+                return x;
             };
             const runner = suiteRunner(suite);
             return {
@@ -28,7 +31,7 @@ export class BaseBuilder {
                 },
                 runner,
                 receiveTestResourceConfig: async function (puppetMaster) {
-                    await puppetMaster.mkdirSync();
+                    // await puppetMaster.mkdirSync();
                     const logFilePath = "log.txt";
                     const access = await puppetMaster.createWriteStream(logFilePath);
                     const tLog = (...l) => {

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

@@ -46,11 +46,55 @@ export default class Testeranto extends ClassBuilder {
             }
         }, class When extends BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {
-                return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
+                try {
+                    return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
+                }
+                catch (e) {
+                    throw e;
+                }
+                // return fullTestInterface
+                //   .andWhen(store, whenCB, testResource, pm)
+                //   .catch((e) => {
+                //     throw e;
+                //   });
+                // return new Promise((res, rej) => {
+                //   fullTestInterface.andWhen(store, whenCB, testResource, pm);
+                // });
+                // return await fullTestInterface.andWhen(
+                //   store,
+                //   whenCB,
+                //   testResource,
+                //   pm
+                // );
             }
         }, class Then extends BaseThen {
-            async butThen(store, thenCB, testResourceConfiguration, pm) {
-                return await fullTestInterface.butThen(store, thenCB, testResourceConfiguration, pm);
+            async butThen(store, thenCB, testResource, pm) {
+                return fullTestInterface
+                    .butThen(store, thenCB, testResource, pm)
+                    .then((v) => {
+                    return v;
+                }, (e) => {
+                    console.log(" ERROR ", e);
+                    throw e;
+                });
+                // try {
+                //   console.log("mark 4");
+                //   return await fullTestInterface.butThen(
+                //     store,
+                //     thenCB,
+                //     testResource,
+                //     pm
+                //   );
+                // } catch (e) {
+                //   console.log("mar123");
+                //   throw e;
+                // }
+                // return await fullTestInterface.butThen(
+                //   store,
+                //   thenCB,
+                //   testResourceConfiguration,
+                //   pm
+                // );
             }
         }, class Check extends BaseCheck {
             constructor(name, features, checkCallback, whens, thens, initialValues) {