testeranto 0.16.31 → 0.21.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testeranto",
   "description": "teeny tiny tightly-typed typescript tests",
-  "version": "0.16.31",
+  "version": "0.21.0",
   "type": "module",
   "types": "./src/index.d.mts",
   "main": "./src/index.mjs",
@@ -21,6 +21,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "dev": "tsc --watch",
     "bundle:reporter": "esbuild ./src/Report.tsx --bundle --outfile=./dist/reporter.js",
     "simpleserver": "cd dist && python -m SimpleHTTPServer 8080",
     "clean:dist": "rm -rf ./dist/results && rm -rf ./dist/tests  && rm -f ./dist/reporter.css && rm -f ./dist/reporter.js && rm -f ./dist/*.jpg ",

package/src/index.d.mts

@@ -1,12 +1,17 @@
 /// <reference types="node" />
+/// <reference types="node" />
+import { PassThrough } from 'stream';
 declare const DirectedGraph: any, UndirectedGraph: any;
-export declare class BaseFeature {
+declare type ITTestResource = {
+    "ports": number[];
+};
+declare abstract class TesterantoGraph {
     name: string;
+    abstract graph: any;
     constructor(name: string);
 }
-declare abstract class TesterantoGraph {
+export declare class BaseFeature {
     name: string;
-    abstract graph: any;
     constructor(name: string);
 }
 export declare class TesterantoGraphUndirected implements TesterantoGraph {
@@ -63,9 +68,6 @@ export declare class TesterantoFeatures {
 export declare type ITTestResourceRequirement = {
     "ports": number;
 };
-declare type ITTestResource = {
-    "ports": number[];
-};
 export declare type IT_FeatureNetwork = {
     name: string;
 };
@@ -79,7 +81,7 @@ export declare type IT = {
 export declare type ITestJob = {
     toObj(): object;
     test: IT;
-    runner: (testResource: any) => Promise<boolean>;
+    runner: (testResource: any, artificer: ITestArtificer) => Promise<boolean>;
     testResource: ITTestResourceRequirement;
 };
 export declare type ITestResults = Promise<{
@@ -125,10 +127,6 @@ export declare type ITestImplementation<IState, ISelection, IWhenShape, IThenSha
         [K in keyof ITestShape["checks"]]: (...Ic: ITestShape["checks"][K]) => IState;
     };
 };
-declare class TestArtifact {
-    binary: Buffer | string;
-    constructor(binary: any);
-}
 export declare abstract class BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITestShape extends ITTestShape, IFeatureShape> {
     name: string;
     givens: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[];
@@ -138,7 +136,6 @@ export declare abstract class BaseSuite<IInput, ISubject, IStore, ISelection, IT
     fails: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[];
     testResourceConfiguration: ITTestResource;
     constructor(name: string, givens?: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[], checks?: BaseCheck<ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>[]);
-    aborter(): Promise<void>;
     toObj(): {
         name: string;
         givens: {
@@ -153,13 +150,12 @@ export declare abstract class BaseSuite<IInput, ISubject, IStore, ISelection, IT
             }[];
             errors: Error;
             features: (keyof IFeatureShape)[];
-            testArtifacts: Record<string, any[]>;
         }[];
         fails: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[];
     };
-    setup(s: IInput): Promise<ISubject>;
+    setup(s: IInput, artifactory: ITestArtificer): Promise<ISubject>;
     test(t: IThenShape): unknown;
-    run(input: any, testResourceConfiguration: ITTestResource): Promise<boolean>;
+    run(input: any, testResourceConfiguration: ITTestResource, artifactory: IHyperTestArtificer): Promise<boolean>;
 }
 export declare abstract class BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape> {
     name: string;
@@ -169,8 +165,9 @@ export declare abstract class BaseGiven<ISubject, IStore, ISelection, IThenShape
     error: Error;
     abort: boolean;
     store: IStore;
-    testArtifacts: Record<string, any[]>;
+    recommendedFsPath: string;
     constructor(name: string, features: (keyof IFeatureShape)[], whens: BaseWhen<IStore, ISelection, IThenShape>[], thens: BaseThen<ISelection, IStore, IThenShape>[]);
+    afterAll(store: IStore, artifactory: ITestArtificer): void;
     toObj(): {
         name: string;
         whens: {
@@ -183,16 +180,11 @@ export declare abstract class BaseGiven<ISubject, IStore, ISelection, IThenShape
         }[];
         errors: Error;
         features: (keyof IFeatureShape)[];
-        testArtifacts: Record<string, any[]>;
-    };
-    abstract givenThat(subject: ISubject, testResourceConfiguration?: any): Promise<IStore>;
-    saveTestArtifact(k: string, testArtifact: TestArtifact): void;
-    artifactSaver: {
-        png: (testArtifact: any) => void;
     };
-    aborter(ndx: number): Promise<unknown>;
-    afterEach(store: IStore, ndx: number, cb: any): Promise<unknown>;
-    give(subject: ISubject, index: number, testResourceConfiguration: any, tester: any): Promise<IStore>;
+    abstract givenThat(subject: ISubject, testResourceConfiguration: any, artifactory: ITestArtificer): Promise<IStore>;
+    aborter(ndx: number, artifactory: ITestArtificer): Promise<unknown>;
+    afterEach(store: IStore, ndx: number, artifactory: ITestArtificer): Promise<unknown>;
+    give(subject: ISubject, index: number, testResourceConfiguration: any, tester: any, artifactory: ITestArtificer): Promise<IStore>;
 }
 export declare abstract class BaseWhen<IStore, ISelection, IThenShape> {
     name: string;
@@ -233,9 +225,9 @@ export declare abstract class BaseCheck<ISubject, IStore, ISelection, IThenShape
         [K in keyof ITestShape["thens"]]: (p: any, tc: any) => BaseThen<ISelection, IStore, IThenShape>;
     };
     constructor(name: string, features: (keyof IFeatureShape)[], checkCB: (whens: any, thens: any) => any, whens: any, thens: any);
-    abstract checkThat(subject: ISubject, testResourceConfiguration?: any): Promise<IStore>;
+    abstract checkThat(subject: ISubject, testResourceConfiguration: any, artifactory: ITestArtificer): Promise<IStore>;
     afterEach(store: IStore, ndx: number, cb?: any): Promise<unknown>;
-    check(subject: ISubject, ndx: number, testResourceConfiguration: any, tester: any): Promise<void>;
+    check(subject: ISubject, ndx: number, testResourceConfiguration: any, tester: any, artifactory: ITestArtificer): Promise<void>;
 }
 export declare abstract class TesterantoLevelZero<IInput, ISubject, IStore, ISelection, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions, IThenShape, IFeatureShape> {
     readonly cc: IStore;
@@ -265,13 +257,16 @@ export declare abstract class TesterantoLevelOne<ITestShape extends ITTestShape,
         [K in keyof ITestShape["checks"]]: (name: string, features: (keyof IFeatureShape)[], cbz: (...any: any[]) => Promise<void>) => any;
     }) => BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>[], input: IInput, suiteKlasser: (name: string, givens: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[], checks: BaseCheck<ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>[]) => BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>, givenKlasser: (n: any, f: any, w: any, t: any, z?: any) => BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>, whenKlasser: (s: any, o: any) => BaseWhen<IStore, ISelection, IThenShape>, thenKlasser: (s: any, o: any) => BaseThen<IStore, ISelection, IThenShape>, checkKlasser: (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>, testResource: any);
 }
+declare type ITestArtificer = (key: string, data: string | Buffer | PassThrough) => void;
+declare type IHyperTestArtificer = (name: string) => ITestArtificer;
 export declare const Testeranto: <TestShape extends ITTestShape, Input, Subject, Store, Selection_1, WhenShape, ThenShape, InitialStateShape, IFeatureShape>(input: Input, testSpecification: ITestSpecification<TestShape, IFeatureShape>, testImplementation: any, testResource: ITTestResourceRequirement, testInterface: {
     actionHandler?: ((b: (...any: any[]) => any) => any) | undefined;
-    afterEach?: ((store: Store, ndx: number, cb: any) => unknown) | undefined;
     andWhen: (store: Store, actioner: any, testResource: ITTestResource) => Promise<Selection_1>;
-    assertioner?: ((t: ThenShape) => any) | undefined;
-    beforeAll?: ((input: Input) => Promise<Subject>) | undefined;
-    beforeEach?: ((subject: Subject, initialValues: any, testResource: ITTestResource) => Promise<Store>) | undefined;
     butThen?: ((store: Store, callback: any, testResource: ITTestResource) => Promise<Selection_1>) | undefined;
+    assertioner?: ((t: ThenShape) => any) | undefined;
+    afterAll?: ((store: Store, artificer: ITestArtificer) => any) | undefined;
+    afterEach?: ((store: Store, ndx: number, artificer: ITestArtificer) => Promise<unknown>) | undefined;
+    beforeAll?: ((input: Input, artificer: ITestArtificer) => Promise<Subject>) | undefined;
+    beforeEach?: ((subject: Subject, initialValues: any, testResource: ITTestResource, artificer: ITestArtificer) => Promise<Store>) | undefined;
 }) => Promise<void>;
 export {};

package/src/index.mjs

@@ -1,16 +1,20 @@
+import fs from 'fs';
+import path from 'path';
 import pkg from 'graphology';
 /* @ts-ignore:next-line */
 const { DirectedGraph, UndirectedGraph } = pkg;
-export class BaseFeature {
+class TesterantoGraph {
     constructor(name) {
         this.name = name;
     }
 }
-class TesterantoGraph {
+;
+export class BaseFeature {
     constructor(name) {
         this.name = name;
     }
 }
+;
 export class TesterantoGraphUndirected {
     constructor(name) {
         this.name = name;
@@ -68,12 +72,7 @@ export class TesterantoFeatures {
         };
     }
 }
-const testOutPath = "./dist/results/";
-class TestArtifact {
-    constructor(binary) {
-        this.binary = binary;
-    }
-}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
 export class BaseSuite {
     constructor(name, givens = [], checks = []) {
         this.name = name;
@@ -81,10 +80,6 @@ export class BaseSuite {
         this.checks = checks;
         this.fails = [];
     }
-    async aborter() {
-        this.aborted = true;
-        await Promise.all((this.givens || []).map((g, ndx) => g.aborter(ndx)));
-    }
     toObj() {
         return {
             name: this.name,
@@ -92,20 +87,23 @@ export class BaseSuite {
             fails: this.fails
         };
     }
-    setup(s) {
+    setup(s, artifactory) {
         return new Promise((res) => res(s));
     }
     test(t) {
         return t;
     }
-    async run(input, testResourceConfiguration) {
-        this.testResourceConfiguration = Object.keys(testResourceConfiguration).length ? testResourceConfiguration : { ports: [] };
-        const subject = await this.setup(input);
+    async run(input, testResourceConfiguration, artifactory) {
+        this.testResourceConfiguration =
+            Object.keys(testResourceConfiguration).length ?
+                testResourceConfiguration :
+                { ports: [] };
+        const subject = await this.setup(input, artifactory('-1'));
         console.log("\nSuite:", this.name, testResourceConfiguration);
         for (const [ndx, giver] of this.givens.entries()) {
             try {
                 if (!this.aborted) {
-                    this.store = await giver.give(subject, ndx, testResourceConfiguration, this.test);
+                    this.store = await giver.give(subject, ndx, testResourceConfiguration, this.test, artifactory(ndx.toString()));
                 }
             }
             catch (e) {
@@ -115,22 +113,28 @@ export class BaseSuite {
             }
         }
         for (const [ndx, thater] of this.checks.entries()) {
-            await thater.check(subject, ndx, testResourceConfiguration, this.test);
+            await thater.check(subject, ndx, testResourceConfiguration, this.test, artifactory('`checkidk'));
+        }
+        // @TODO fix me
+        for (const [ndx, giver] of this.givens.entries()) {
+            giver.afterAll(this.store, artifactory);
         }
+        ////////////////
         return true;
     }
 }
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
 export class BaseGiven {
     constructor(name, features, whens, thens) {
-        this.artifactSaver = {
-            png: (testArtifact) => this.saveTestArtifact('afterEach', new TestArtifact(testArtifact))
-        };
         this.name = name;
         this.features = features;
         this.whens = whens;
         this.thens = thens;
-        this.testArtifacts = {};
     }
+    afterAll(store, artifactory) {
+        return;
+    }
+    ;
     toObj() {
         return {
             name: this.name,
@@ -138,33 +142,26 @@ export class BaseGiven {
             thens: this.thens.map((t) => t.toObj()),
             errors: this.error,
             features: this.features,
-            testArtifacts: this.testArtifacts,
         };
     }
-    saveTestArtifact(k, testArtifact) {
-        if (!this.testArtifacts[k]) {
-            this.testArtifacts[k] = [];
-        }
-        this.testArtifacts[k].push(testArtifact);
-    }
-    async aborter(ndx) {
+    async aborter(ndx, artifactory) {
         this.abort = true;
         return Promise.all([
             ...this.whens.map((w, ndx) => new Promise((res) => res(w.aborter()))),
             ...this.thens.map((t, ndx) => new Promise((res) => res(t.aborter()))),
         ])
             .then(async () => {
-            return await this.afterEach(this.store, ndx, this.artifactSaver);
+            return await this.afterEach(this.store, ndx, artifactory);
         });
     }
-    async afterEach(store, ndx, cb) {
+    async afterEach(store, ndx, artifactory) {
         return;
     }
-    async give(subject, index, testResourceConfiguration, tester) {
+    async give(subject, index, testResourceConfiguration, tester, artifactory) {
         console.log(`\n Given: ${this.name}`);
         try {
             if (!this.abort) {
-                this.store = await this.givenThat(subject, testResourceConfiguration);
+                this.store = await this.givenThat(subject, testResourceConfiguration, artifactory);
             }
             for (const whenStep of this.whens) {
                 await whenStep.test(this.store, testResourceConfiguration);
@@ -181,7 +178,8 @@ export class BaseGiven {
         }
         finally {
             try {
-                await this.afterEach(this.store, index, this.artifactSaver);
+                /* @ts-ignore:next-line */
+                this.testArtifacts = await this.afterEach(this.store, index, artifactory);
             }
             catch (_a) {
                 console.error("afterEach failed! no error will be recorded!");
@@ -257,9 +255,9 @@ export class BaseCheck {
     async afterEach(store, ndx, cb) {
         return;
     }
-    async check(subject, ndx, testResourceConfiguration, tester) {
+    async check(subject, ndx, testResourceConfiguration, tester, artifactory) {
         console.log(`\n Check: ${this.name}`);
-        const store = await this.checkThat(subject, testResourceConfiguration);
+        const store = await this.checkThat(subject, testResourceConfiguration, artifactory);
         await this.checkCB((Object.entries(this.whens)
             .reduce((a, [key, when]) => {
             a[key] = async (payload) => {
@@ -278,6 +276,7 @@ export class BaseCheck {
         return;
     }
 }
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
 export class TesterantoLevelZero {
     constructor(cc, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides) {
         this.cc = cc;
@@ -354,14 +353,36 @@ export class TesterantoLevelOne {
                 toObj: () => {
                     return suite.toObj();
                 },
-                runner: async (allocatedPorts) => {
-                    return suite.run(input, { ports: allocatedPorts });
+                runner: async (allocatedPorts, artifactory) => {
+                    return suite.run(input, { ports: allocatedPorts }, artifactory);
                 },
             };
         });
         return toReturn;
     }
 }
+const testArtiFactoryfileWriter = (fsPath) => (gindex) => (key, value) => {
+    const fPath = `${fsPath}/${gindex}/${key}`;
+    const cleanPath = path.resolve(fPath);
+    const targetDir = cleanPath.split('/').slice(0, -1).join('/');
+    fs.mkdir(targetDir, { recursive: true }, async (error) => {
+        if (error) {
+            console.error(`❗️testArtiFactory failed`, targetDir, error);
+        }
+        if (Buffer.isBuffer(value) || (`string` === (typeof value))) {
+            fs.writeFile(fPath, value.toString(), (error) => {
+                if (error) {
+                    console.error(`❗️testArtiFactory failed`, fPath, error);
+                }
+            });
+        }
+        else {
+            const pipeStream = value;
+            var myFile = fs.createWriteStream(fPath);
+            pipeStream.pipe(myFile);
+        }
+    });
+};
 export const Testeranto = async (input, testSpecification, testImplementation, 
 // testImplementation: ITestImplementation<
 //   InitialStateShape,
@@ -382,13 +403,14 @@ testResource, testInterface) => {
         return subject;
     };
     const afterEach = testInterface.afterEach || (async (s) => s);
+    const afterAll = testInterface.afterAll || ((store) => undefined);
     class MrT extends TesterantoLevelOne {
         constructor() {
             super(testImplementation, 
             /* @ts-ignore:next-line */
             testSpecification, input, (class extends BaseSuite {
-                async setup(s) {
-                    return beforeAll(s);
+                async setup(s, artifactory) {
+                    return beforeAll(s, artifactory);
                 }
                 test(t) {
                     return assertioner(t);
@@ -398,11 +420,14 @@ testResource, testInterface) => {
                     super(name, features, whens, thens);
                     this.initialValues = initialValues;
                 }
-                async givenThat(subject, testResource) {
-                    return beforeEach(subject, this.initialValues, testResource);
+                async givenThat(subject, testResource, artifactory) {
+                    return beforeEach(subject, this.initialValues, testResource, artifactory);
+                }
+                afterEach(store, ndx, artifactory) {
+                    return new Promise((res) => res(afterEach(store, ndx, artifactory)));
                 }
-                afterEach(store, ndx, cb) {
-                    return new Promise((res) => res(afterEach(store, ndx, cb)));
+                afterAll(store, artifactory) {
+                    return afterAll(store, artifactory);
                 }
             }, class When extends BaseWhen {
                 constructor(name, actioner, payload) {
@@ -426,11 +451,11 @@ testResource, testInterface) => {
                     super(name, features, checkCallback, whens, thens);
                     this.initialValues = initialValues;
                 }
-                async checkThat(subject, testResource) {
-                    return beforeEach(subject, this.initialValues, testResource);
+                async checkThat(subject, testResource, artifactory) {
+                    return beforeEach(subject, this.initialValues, testResource, artifactory);
                 }
-                afterEach(store, ndx, cb) {
-                    return new Promise((res) => res(afterEach(store, ndx, cb)));
+                afterEach(store, ndx, artifactory) {
+                    return new Promise((res) => res(afterEach(store, ndx, artifactory)));
                 }
             }, testResource);
         }
@@ -446,7 +471,7 @@ testResource, testInterface) => {
     });
     console.log("awaiting test resources from mothership...");
     process.on('message', async function (packet) {
-        await mrt[0].runner(packet.data.goWithTestResources);
+        await mrt[0].runner(packet.data.goWithTestResources, testArtiFactoryfileWriter(packet.data.recommendedFsPath));
         /* @ts-ignore:next-line */
         process.send({
             type: 'testeranto:adios',
@@ -461,7 +486,7 @@ testResource, testInterface) => {
             else {
                 console.error(`❗️`, err);
             }
-            process.exit(0); // :-)
+            // process.exit(0); // :-)
         });
     });
     process.on('SIGINT', function () {