testeranto 0.62.0 → 0.73.0

package/dist/module/esbuildConfigs/index.js

@@ -3,16 +3,16 @@ export default (config) => {
         target: "esnext",
         format: "esm",
         splitting: true,
-        outExtension: { '.js': '.mjs' },
+        outExtension: { ".js": ".mjs" },
         outbase: config.outbase,
-        jsx: 'transform',
+        jsx: "transform",
         bundle: true,
         minify: config.minify === true,
         write: true,
         loader: {
-            '.js': 'jsx',
-            '.png': 'binary',
-            '.jpg': 'binary',
+            ".js": "jsx",
+            ".png": "binary",
+            ".jpg": "binary",
         },
     };
 };

package/dist/module/esbuildConfigs/node.js

@@ -1,30 +1,32 @@
 import baseEsBuildConfig from "./index.js";
-// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
 export default (config, entryPoints) => {
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], supported: {
-            "dynamic-import": true
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], supported: {
+            "dynamic-import": true,
         }, define: {
-            "process.env.FLUENTFFMPEG_COV": "0"
+            "process.env.FLUENTFFMPEG_COV": "0",
         }, absWorkingDir: process.cwd(), banner: {
-            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
         }, platform: "node", external: [
-            "testeranto.json",
-            "features.test.js",
-            "react",
-            "events",
+            // "testeranto.json",
+            // "features.test.js",
+            // "react",
+            // "events",
             // "ganache"
-            ...config.externals
+            ...config.externals,
         ], entryPoints: [...entryPoints], plugins: [
             ...(config.nodePlugins || []),
             {
-                name: 'rebuild-notify',
+                name: "rebuild-notify",
                 setup(build) {
-                    build.onEnd(result => {
+                    build.onEnd((result) => {
                         console.log(`node build ended with ${result.errors.length} errors`);
-                        console.log(result);
-                        result.errors.length !== 0 && process.exit(-1);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
                     });
-                }
+                },
             },
         ] });
 };

package/dist/module/esbuildConfigs/report.js

@@ -1,48 +1,11 @@
-"use strict";
-// import { jsonc } from "jsonc";
-// import { IBaseConfig, IJsonConfig } from "../Types";
-// import baseEsBuildConfig from "./index.js";
-// import fs from "fs"
-// import { BuildOptions } from "esbuild";
-// // import { CssModulesPlugin } from 'esbuild-css-modules-plugin';
-// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
-// export default (config: IBaseConfig): BuildOptions => {
-//   return {
-//     bundle: true,
-//     entryPoints: ["./node_modules/testeranto/dist/module/report.js"],
-//     minify: config.minify === true,
-//     outbase: config.outbase,
-//     write: true,
-//     outfile: `${jsonConfig.outdir}/report.js`,
-//     external: [
-//       "tests.json",
-//       "features.test.js"
-//     ],
-//     // plugins: [
-//     //   CssModulesPlugin({
-//     //     // @see https://github.com/indooorsman/esbuild-css-modules-plugin/blob/main/index.d.ts for more details
-//     //     force: true,
-//     //     emitDeclarationFile: true,
-//     //     localsConvention: 'camelCaseOnly',
-//     //     namedExports: true,
-//     //     inject: false
-//     //   })
-//     // ]
-//   }
-//   // return {
-//   //   bundle: true,
-//   //   entryPoints: [
-//   //     "./node_modules/testeranto/dist/module/Report.js",
-//   //     jsonConfig.features
-//   //   ],
-//   //   minify: config.minify === true,
-//   //   outbase: ".",
-//   //   outdir: 'docs',
-//   //   write: true,
-//   //   // outfile: `${jsonConfig.outdir}/Report.js`,
-//   //   external: [
-//   //     "features.test.js",
-//   //     "testeranto.json"
-//   //   ]
-//   // }
-// }
+export default (config) => {
+    return {
+        bundle: true,
+        entryPoints: ["./node_modules/testeranto/dist/module/report.js"],
+        minify: config.minify === true,
+        outbase: config.outbase,
+        write: true,
+        outfile: `${config.outdir}/report.js`,
+        external: ["tests.json", "features.test.js"],
+    };
+};

package/dist/module/esbuildConfigs/tests.js

@@ -1,4 +1,3 @@
-// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
 export default (config) => {
     return {
         bundle: true,

package/dist/module/esbuildConfigs/web.js

@@ -1,20 +1,19 @@
 import path from "path";
 import baseEsBuildConfig from "./index.js";
-// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
 export default (config, entryPoints) => {
     return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { 
-        // inject: ['./node_modules/testeranto/dist/cjs-shim.js'],
+        // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
         // banner: {
-        //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+        //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
         // },
+        // splitting: true,
         outdir: config.outdir + "/web", alias: {
-            react: path.resolve("./node_modules/react")
+            react: path.resolve("./node_modules/react"),
         }, external: [
             "testeranto.json",
             "features.test.ts",
-            // "url", 
+            // "url",
             "react",
-            "electron",
             "path",
             "fs",
             "stream",
@@ -28,18 +27,24 @@ export default (config, entryPoints) => {
             "readline",
             "zlib",
             "crypto",
-            "https"
+            "https",
+            "util",
+            "process",
+            "dns",
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             ...(config.webPlugins || []),
             {
-                name: 'rebuild-notify',
+                name: "rebuild-notify",
                 setup(build) {
-                    build.onEnd(result => {
+                    build.onEnd((result) => {
                         console.log(`web build ended with ${result.errors.length} errors`);
-                        console.log(result);
-                        result.errors.length !== 0 && process.exit(-1);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
                     });
-                }
+                },
             },
         ] });
 };

package/dist/module/lib/abstractBase.js

@@ -13,38 +13,114 @@ export class BaseSuite {
             fails: this.fails,
         };
     }
-    setup(s, artifactory, tr, utils) {
+    setup(s, artifactory, tr, pm) {
         return new Promise((res) => res(s));
     }
     assertThat(t) {
-        // console.log("base assertThat")
         return t;
     }
-    async run(input, testResourceConfiguration, artifactory, tLog, utils) {
+    afterAll(store, artifactory, pm) {
+        return store;
+    }
+    async run(input, testResourceConfiguration, artifactory, tLog, pm) {
         this.testResourceConfiguration = testResourceConfiguration;
-        tLog("test resources: ", testResourceConfiguration);
+        tLog("test resources: ", JSON.stringify(testResourceConfiguration));
         const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
-        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, utils);
+        console.log("\nSuite:", this.index, this.name);
         tLog("\nSuite:", this.index, this.name);
-        for (const k of Object.keys(this.givens)) {
-            const giver = this.givens[k];
+        const sNdx = this.index;
+        const sName = this.name;
+        for (const [gNdx, g] of Object.entries(this.givens)) {
+            const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, pm);
+            const giver = this.givens[gNdx];
             try {
-                this.store = await giver.give(subject, k, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, utils);
+                this.store = await giver.give(subject, gNdx, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm, sNdx);
             }
             catch (e) {
                 console.error(e);
                 this.fails.push(giver);
-                return this;
+                // return this;
             }
         }
-        for (const [ndx, thater] of this.checks.entries()) {
-            await thater.check(subject, thater.name, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, utils);
+        const afterAllProxy = new Proxy(pm, {
+            get(target, prop, receiver) {
+                if (prop === "writeFileSync") {
+                    return (fp, contents) => target[prop](`suite-${sNdx}/afterAll/${fp}`, contents);
+                }
+                if (prop === "browser") {
+                    return new Proxy(target[prop], {
+                        get(bTarget, bProp, bReceiver) {
+                            if (bProp === "pages") {
+                                return async () => {
+                                    return bTarget.pages().then((pages) => {
+                                        return pages.map((page) => {
+                                            return new Proxy(page, {
+                                                get(pTarget, pProp, pReciever) {
+                                                    if (pProp === "screenshot") {
+                                                        return async (x) => {
+                                                            // console.log(
+                                                            //   "custom-screenshot-MARK-afterAllProxy",
+                                                            //   // arguments,
+                                                            //   // x,
+                                                            //   window["custom-screenshot"].toString()
+                                                            // );
+                                                            return await window["custom-screenshot"](Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
+                                                                    "/" +
+                                                                    x.path }));
+                                                        };
+                                                    }
+                                                    // else if (pProp === "mainFrame") {
+                                                    //   return () => target[pProp](...arguments);
+                                                    // }
+                                                    else {
+                                                        return Reflect.get(...arguments);
+                                                    }
+                                                },
+                                            });
+                                        });
+                                    });
+                                    // return (await target.pages()).map((page) => {
+                                    //   return new Proxy(page, handler2);
+                                    // });
+                                };
+                            }
+                        },
+                    });
+                }
+                return Reflect.get(...arguments);
+            },
+        });
+        // pm.browser
+        try {
+            this.afterAll(this.store, artifactory, afterAllProxy);
         }
-        // @TODO fix me
-        for (const k of Object.keys(this.givens)) {
-            const giver = this.givens[k];
-            giver.afterAll(this.store, artifactory, utils);
+        catch (e) {
+            console.error(e);
+            // this.fails.push(this);
+            // return this;
         }
+        // for (const [ndx, thater] of this.checks.entries()) {
+        //   await thater.check(
+        //     subject,
+        //     thater.name,
+        //     testResourceConfiguration,
+        //     this.assertThat,
+        //     suiteArtifactory,
+        //     tLog,
+        //     pm
+        //   );
+        // }
+        // @TODO fix me
+        // for (const k of Object.keys(this.givens)) {
+        //   const giver = this.givens[k];
+        //   try {
+        //     giver.afterAll(this.store, artifactory, pm);
+        //   } catch (e) {
+        //     console.error(e);
+        //     this.fails.push(giver);
+        //     return this;
+        //   }
+        // }
         ////////////////
         return this;
     }
@@ -61,32 +137,39 @@ export class BaseGiven {
     beforeAll(store, artifactory) {
         return store;
     }
-    afterAll(store, artifactory, utils) {
-        return store;
-    }
     toObj() {
         return {
             name: this.name,
             whens: this.whens.map((w) => w.toObj()),
             thens: this.thens.map((t) => t.toObj()),
             error: this.error ? [this.error, this.error.stack] : null,
+            // fail: this.fail ? [this.fail] : false,
             features: this.features,
         };
     }
-    async afterEach(store, key, artifactory) {
+    async afterEach(store, key, artifactory, pm) {
         return store;
     }
-    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, utils) {
+    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
         tLog(`\n Given: ${this.name}`);
         const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
         try {
-            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB);
             // tLog(`\n Given this.store`, this.store);
-            for (const whenStep of this.whens) {
-                await whenStep.test(this.store, testResourceConfiguration, tLog, utils);
+            const beforeEachProxy = new Proxy(pm, {
+                get(target, prop, receiver) {
+                    if (prop === "writeFileSync") {
+                        console.log("beforeEachProx", arguments, target[prop]);
+                        return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`, contents);
+                    }
+                    return Reflect.get(...arguments);
+                },
+            });
+            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, beforeEachProxy);
+            for (const [whenNdx, whenStep] of this.whens.entries()) {
+                await whenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/when/${whenNdx}`);
             }
             for (const thenStep of this.thens) {
-                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, utils);
+                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm);
                 tester(t);
             }
         }
@@ -98,7 +181,66 @@ export class BaseGiven {
         }
         finally {
             try {
-                await this.afterEach(this.store, key, givenArtifactory);
+                // const afterEachProxy = new Proxy(pm, {
+                //   get(target, prop, receiver) {
+                //     if (prop === "writeFileSync") {
+                //       console.log("afterEachProxy", arguments, target[prop]);
+                //       return (fp, contents) =>
+                //         // target[prop](`${key}/andWhen/${fp}`, contents);
+                //         target[prop](`${key}/afterEach/${fp}`, contents);
+                //     }
+                //     return Reflect.get(...arguments);
+                //   },
+                // });
+                // await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
+                // await this.afterEach(this.store, key, givenArtifactory, pm);
+                const afterEachProxy = new Proxy(pm, {
+                    get(target, prop, receiver) {
+                        if (prop === "writeFileSync") {
+                            return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/afterAll/${fp}`, contents);
+                        }
+                        if (prop === "browser") {
+                            return new Proxy(target[prop], {
+                                get(bTarget, bProp, bReceiver) {
+                                    if (bProp === "pages") {
+                                        return async () => {
+                                            return bTarget.pages().then((pages) => {
+                                                return pages.map((page) => {
+                                                    return new Proxy(page, {
+                                                        get(pTarget, pProp, pReciever) {
+                                                            if (pProp === "screenshot") {
+                                                                return async (x) => {
+                                                                    // console.log(
+                                                                    //   "custom-screenshot-MARK-afterEachProxy",
+                                                                    //   window["custom-screenshot"].toString()
+                                                                    // );
+                                                                    return await window["custom-screenshot"](Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
+                                                                            "/" +
+                                                                            x.path }));
+                                                                };
+                                                            }
+                                                            // else if (pProp === "mainFrame") {
+                                                            //   return () => target[pProp](...arguments);
+                                                            // }
+                                                            else {
+                                                                return Reflect.get(...arguments);
+                                                            }
+                                                        },
+                                                    });
+                                                });
+                                            });
+                                            // return (await target.pages()).map((page) => {
+                                            //   return new Proxy(page, handler2);
+                                            // });
+                                        };
+                                    }
+                                },
+                            });
+                        }
+                        return Reflect.get(...arguments);
+                    },
+                });
+                await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
             }
             catch (e) {
                 console.error("afterEach failed! no error will be recorded!", e);
@@ -118,10 +260,22 @@ export class BaseWhen {
             error: this.error,
         };
     }
-    async test(store, testResourceConfiguration, tLog, utils) {
+    async test(store, testResourceConfiguration, tLog, pm, key) {
         tLog(" When:", this.name);
+        const name = this.name;
+        const andWhenProxy = new Proxy(pm, {
+            get(target, prop, receiver) {
+                if (prop === "writeFileSync") {
+                    console.log("andWhenProxy", arguments, target[prop]);
+                    return (fp, contents) => 
+                    // target[prop](`${key}/andWhen/${fp}`, contents);
+                    target[prop](`${key}/andWhen/${fp}`, contents);
+                }
+                return Reflect.get(...arguments);
+            },
+        });
         try {
-            return await this.andWhen(store, this.whenCB, testResourceConfiguration);
+            return await this.andWhen(store, this.whenCB, testResourceConfiguration, andWhenProxy);
         }
         catch (e) {
             this.error = true;
@@ -133,6 +287,7 @@ export class BaseThen {
     constructor(name, thenCB) {
         this.name = name;
         this.thenCB = thenCB;
+        this.error = false;
     }
     toObj() {
         return {
@@ -140,15 +295,15 @@ export class BaseThen {
             error: this.error,
         };
     }
-    async test(store, testResourceConfiguration, tLog, utils) {
+    async test(store, testResourceConfiguration, tLog, pm) {
         tLog(" Then:", this.name);
         try {
-            const x = (await this.butThen(store, this.thenCB, testResourceConfiguration));
+            const x = await this.butThen(store, this.thenCB, testResourceConfiguration);
             return x;
         }
         catch (e) {
             console.log("test failed", e);
-            this.error = true;
+            this.error = e.message;
             throw e;
         }
     }
@@ -161,25 +316,25 @@ export class BaseCheck {
         this.whens = whens;
         this.thens = thens;
     }
-    async afterEach(store, key, cb) {
+    async afterEach(store, key, cb, pm) {
         return;
     }
-    async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, utils) {
+    async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm) {
         tLog(`\n Check: ${this.name}`);
         const store = await this.checkThat(subject, testResourceConfiguration, artifactory);
         await this.checkCB(Object.entries(this.whens).reduce((a, [key, when]) => {
             a[key] = async (payload) => {
-                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, utils);
+                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm, "x");
             };
             return a;
         }, {}), Object.entries(this.thens).reduce((a, [key, then]) => {
             a[key] = async (payload) => {
-                const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, utils);
+                const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm);
                 tester(t);
             };
             return a;
         }, {}));
-        await this.afterEach(store, key);
+        await this.afterEach(store, key, () => { }, pm);
         return;
     }
 }

package/dist/module/lib/basebuilder.js

@@ -1,5 +1,7 @@
 export class BaseBuilder {
-    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, logWriter, testResourceRequirement, testSpecification) {
+    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, testResourceRequirement, testSpecification
+    // puppetMaster: PM
+    ) {
         this.input = input;
         this.artifacts = [];
         this.artifacts = [];
@@ -10,52 +12,77 @@ export class BaseBuilder {
         this.thenOverides = thenOverides;
         this.checkOverides = checkOverides;
         this.testSpecification = testSpecification;
+        // this.puppetMaster = puppetMaster;
         this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then(), this.Check());
-        const suiteRunner = (suite, utils) => async (testResourceConfiguration, tLog, utils) => {
-            return await suite.run(input, testResourceConfiguration, (fPath, value) => logWriter.testArtiFactoryfileWriter(tLog, (p) => {
-                this.artifacts.push(p);
-            })(testResourceConfiguration.fs + "/" + fPath, value), tLog, utils);
-        };
-        this.testJobs = this.specs.map((suite, utils) => {
-            const runner = suiteRunner(suite, utils);
+        this.testJobs = this.specs.map((suite) => {
+            const suiteRunner = (suite) => async (
+            // testResourceConfiguration: ITTestResourceConfiguration,
+            puppetMaster, tLog) => {
+                await puppetMaster.startPuppeteer({
+                    browserWSEndpoint: puppetMaster.testResourceConfiguration.browserWSEndpoint,
+                }, puppetMaster.testResourceConfiguration.fs);
+                return await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
+                    this.artifacts.push(p);
+                })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
+            };
+            const runner = suiteRunner(suite);
             return {
                 test: suite,
-                testResourceRequirement,
+                // testResourceRequirement,
                 toObj: () => {
                     return suite.toObj();
                 },
                 runner,
-                receiveTestResourceConfig: async function (testResourceConfiguration = {
-                    name: "",
-                    fs: ".",
-                    ports: [],
-                    scheduled: false
-                }, y) {
-                    console.log(`testResourceConfiguration ${JSON.stringify(testResourceConfiguration, null, 2)}`);
-                    await logWriter.mkdirSync(testResourceConfiguration.fs);
-                    logWriter.writeFileSync(`${testResourceConfiguration.fs}/tests.json`, JSON.stringify(this.toObj(), null, 2));
-                    const logFilePath = `${testResourceConfiguration.fs}/log.txt`;
-                    const access = await logWriter.createWriteStream(logFilePath);
+                receiveTestResourceConfig: async function (
+                // testResourceConfiguration = {
+                //   name: "",
+                //   fs: ".",
+                //   ports: [],
+                //   browserWSEndpoint: "",
+                // },
+                puppetMaster) {
+                    // console.log(
+                    //   `testResourceConfiguration! ${JSON.stringify(
+                    //     testResourceConfiguration,
+                    //     null,
+                    //     2
+                    //   )}`
+                    // );
+                    // console.log("puppetMaster", puppetMaster);
+                    await puppetMaster
+                        .mkdirSync();
+                    //  if (!puppetMaster.existsSync(destFolder)) {
+                    //    puppetMaster.mkdirSync(destFolder, { recursive: true });
+                    //  }
+                    // puppetMaster.writeFileSync(
+                    //   // puppetMaster.testResourceConfiguration.fs + `/tests.json`,
+                    //   `tests.json`,
+                    //   JSON.stringify(this.toObj(), null, 2)
+                    // );
+                    const logFilePath = "log.txt";
+                    // puppetMaster.testResourceConfiguration.fs + `/log.txt`;
+                    const access = await puppetMaster.createWriteStream(logFilePath);
+                    // console.log("access", access);
                     const tLog = (...l) => {
-                        // console.log(...l);
-                        access.write(`${l.toString()}\n`);
+                        // access.write(`${l.toString()}\n`);
+                        // console.log("tLog", l);
+                        puppetMaster.write(access, `${l.toString()}\n`);
                     };
-                    const suiteDone = await runner(testResourceConfiguration, tLog, y);
-                    const resultsFilePath = (`${testResourceConfiguration.fs}/results.json`);
-                    logWriter.writeFileSync(resultsFilePath, JSON.stringify(suiteDone.toObj(), null, 2));
+                    const suiteDone = await runner(puppetMaster, tLog);
                     const logPromise = new Promise((res, rej) => {
-                        access.on("finish", () => { res(true); });
+                        puppetMaster.end(access);
+                        res(true);
                     });
-                    access.end();
                     const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
-                        // console.log(`suiteDone.givens[k].error`, suiteDone.givens[k].error);
                         return suiteDone.givens[k].error;
                     }).length;
+                    puppetMaster.writeFileSync(`exitcode`, numberOfFailures.toString());
+                    puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
                     console.log(`exiting gracefully with ${numberOfFailures} failures.`);
                     return {
                         failed: numberOfFailures,
                         artifacts: this.artifacts || [],
-                        logPromise
+                        logPromise,
                     };
                 },
             };