testeranto 0.9.20

package/src/Report.tsx

@@ -0,0 +1,347 @@
+import ReactDom from "react-dom/client";
+import React, { useEffect, useState } from "react";
+
+import Tab from 'react-bootstrap/Tab';
+import Tabs from 'react-bootstrap/Tabs';
+import Col from 'react-bootstrap/Col';
+import Nav from 'react-bootstrap/Nav';
+import Row from 'react-bootstrap/Row';
+
+import 'bootstrap/dist/css/bootstrap.min.css';
+
+export function Report() {
+
+  const [data, setData] = useState<{
+    configs: object,
+    features: {
+      features: any[]
+    },
+    tests: any[],
+    featureTests: object,
+    summaries: { dags: [], directed: [], undirected: [] }
+  }>({
+    configs: {},
+    features: {
+      features: []
+    },
+    tests: [],
+    featureTests: {},
+    summaries: { dags: [], directed: [], undirected: [] }
+  });
+
+  const getData = async () => {
+
+    const configs = await (await fetch('testeranto.config.json')).json();
+    const features = await (await fetch('TesterantoFeatures.json')).json();
+    const featureTests = await (await fetch('results/featureTestJoin.json')).json();
+    const summaries = await (await fetch('report.json')).json();
+    const testPromises = await configs.tests.map(async (test) => {
+      return await (await (await fetch(`results/${test[0]}.json`)).json())
+    })
+    const tests = await Promise.all(testPromises);
+
+    setData({ configs, features, tests, featureTests, summaries });
+  }
+
+  useEffect(() => { getData() }, []);
+
+  return (<div>
+    {
+      data && data.configs && <>
+        <Tabs defaultActiveKey="home">
+          <Tab eventKey="home" title="config">
+            <pre><code>{JSON.stringify(data.configs, null, 2)}</code></pre>
+          </Tab>
+          <Tab eventKey="features" title="features">
+            <Tab.Container id="left-tabs-example5" defaultActiveKey="feature-0">
+              <Row>
+                <Col sm={3}>
+                  <Nav variant="pills" className="flex-column">
+                    {data.features.features.map((feature, ndx) => <Nav.Item key={ndx}>
+                      <Nav.Link eventKey={`feature-${ndx}`}>
+                        {feature.name}
+                      </Nav.Link>
+                    </Nav.Item>)}
+                  </Nav>
+                </Col>
+                <Col sm={9}>
+                  <Tab.Content>
+                    {data.features.features.map((feature, ndx) => <Tab.Pane eventKey={`feature-${ndx}`} key={ndx}>
+                      <p>{feature.name}</p>
+
+
+                      <Tab.Container id="left-tabs-example5" defaultActiveKey="relations-0">
+                        <Row>
+                          <Col sm={3}>
+                            <Nav variant="pills" className="flex-column">
+                              {feature.inNetworks.map((summary, ndx2) => <Nav.Item key={ndx2}>
+                                <Nav.Link eventKey={`relations-${ndx2}`}>
+                                  {summary.network}
+                                </Nav.Link>
+                              </Nav.Item>)}
+                            </Nav>
+                          </Col>
+                          <Col sm={9}>
+                            <Tab.Content>
+                              {feature.inNetworks.map((summary, ndx2) => <Tab.Pane eventKey={`relations-${ndx2}`} key={ndx2}>
+                                <pre>{
+                                  JSON.stringify(summary.neighbors, null, 2)
+                                }</pre>
+                              </Tab.Pane>)}
+                            </Tab.Content>
+                          </Col>
+                        </Row>
+                      </Tab.Container>
+
+
+
+                    </Tab.Pane>)}
+                  </Tab.Content>
+                </Col>
+              </Row>
+            </Tab.Container>
+          </Tab>
+          <Tab eventKey="results" title="tests">
+            <Tab.Container id="left-tabs-example" defaultActiveKey="first">
+              <Row>
+                <Col sm={3}>
+                  <Nav variant="pills" className="flex-column">
+                    {data.tests.map((suite, ndx) => <Nav.Item key={ndx}>
+                      <Nav.Link eventKey={`suite-${ndx}`}>
+                        {(suite.fails.length > 0 ? `❌ * ${suite.fails.length.toString()}` : `✅ * ${suite.givens.length.toString()}`)} - {suite.name}
+                      </Nav.Link>
+                    </Nav.Item>)}
+                  </Nav>
+                </Col>
+                <Col sm={9}>
+                  <Tab.Content>
+                    {data.tests.map((suite, ndx) => <Tab.Pane eventKey={`suite-${ndx}`} key={ndx}>
+                      <Tab.Container id="left-tabs-example2" defaultActiveKey={`given-0`}>
+                        <Row>
+                          <Col sm={3}>
+                            <Nav variant="pills" className="flex-column">
+                              {suite.givens.map((g, ndx2) => <Nav.Item key={ndx2}>
+                                <Nav.Link eventKey={`given-${ndx2}`}>
+                                  {(g.errors ? `❌` : `✅`)} - {g.name}
+                                </Nav.Link>
+                              </Nav.Item>)}
+                            </Nav>
+                          </Col>
+                          <Col sm={9}>
+                            <Tab.Content>
+                              {suite.givens.map((g, ndx2) => <Tab.Pane key={ndx2} eventKey={`given-${ndx2}`} >
+                                <p>when</p>
+                                <ul>
+                                  {g.whens.map((w, ndx3) => <li key={ndx3}>
+                                    {/* <p>{w.name}</p> */}
+                                    {(w.error === true ? `❌` : `✅`)} - {w.name}
+                                  </li>)}
+                                </ul>
+                                <p>then</p>
+                                <ul>
+                                  {g.thens.map((t, ndx3) => <li key={ndx3}>
+                                    <p>
+                                      {(t.error === true ? `❌` : `✅`)} - {t.name}
+                                    </p>
+                                  </li>)}
+                                </ul>
+                                <pre><code>{JSON.stringify(g.errors, null, 2)}</code></pre>
+                              </Tab.Pane>)}
+                            </Tab.Content>
+                          </Col>
+                        </Row>
+                      </Tab.Container>
+                    </Tab.Pane>)}
+                  </Tab.Content>
+                </Col>
+              </Row>
+            </Tab.Container>
+          </Tab>
+          <Tab eventKey="featureTests" title="feature-tests">
+            <Tab.Container id="left-tabs-example7" defaultActiveKey="first">
+              <Row>
+                <Col sm={3}>
+                  <Nav variant="pills" className="flex-column">
+                    {Object.keys(data.featureTests).map((ftKey, ndx) => <Nav.Item key={ndx}>
+                      <Nav.Link eventKey={`featureTests-${ndx}`}>
+                        {Object.values(data.featureTests[ftKey]).reduce((testMemo, test: any) => test.errors) ? `❌` : `✅`} {ftKey}
+                      </Nav.Link>
+                    </Nav.Item>)}
+                  </Nav>
+                </Col>
+                <Col sm={9}>
+                  <Tab.Content>
+                    {Object.keys(data.featureTests).map((ftKey, ndx) => <Tab.Pane eventKey={`featureTests-${ndx}`} key={ndx}>
+                      <Tab.Container id="left-tabs-example8" defaultActiveKey={`ft-suite-0`}>
+                        <Row>
+                          <Col sm={6}>
+                            <Nav variant="pills" className="flex-column">
+                              {data.featureTests[ftKey].map((s, ndx2) => <Nav.Item key={ndx2}>
+                                <Nav.Link eventKey={`ft-suite-${ndx2}`}>
+                                  {s.errors ? `❌` : `✅`} <strong>{s.testKey}</strong>  <em>{s.name}</em>
+                                </Nav.Link>
+                              </Nav.Item>)}
+                            </Nav>
+                          </Col>
+                          <Col sm={6}>
+                            <Tab.Content>
+                              {data.featureTests[ftKey].map((g, ndx2) => <Tab.Pane key={ndx2} eventKey={`ft-suite-${ndx2}`} >
+
+                                {/* <pre> <code>{JSON.stringify(x)} </code></pre> */}
+
+                                <p>when</p>
+                                <ul>
+                                  {g.whens.map((w, ndx3) => <li key={ndx3}>
+                                    <p>{w}</p>
+                                  </li>)}
+                                </ul>
+                                <p>then</p>
+                                <ul>
+                                  {g.thens.map((t, ndx3) => <li key={ndx3}>
+                                    <p>{t}</p>
+                                  </li>)}
+                                </ul>
+
+                                <pre><code>{JSON.stringify(g.errors, null, 2)}</code></pre>
+
+                              </Tab.Pane>)}
+
+                            </Tab.Content>
+                          </Col>
+                        </Row>
+                      </Tab.Container>
+
+                    </Tab.Pane>)}
+
+                    {/* ////////////////////////// */}
+
+                  </Tab.Content>
+                </Col>
+              </Row>
+            </Tab.Container>
+          </Tab>
+
+          <Tab eventKey="networks" title="networks">
+            <Tab.Container id="left-tabs-example88" defaultActiveKey={`networks-dags`}>
+              <Row>
+                <Col sm={3}>
+                  <Nav variant="pills" className="flex-column">
+                    <Nav.Link eventKey={`networks-dags`}>
+                      DAG
+                    </Nav.Link>
+                    <Nav.Link eventKey={`networks-directed`}>
+                      Directed (not acyclic)
+                    </Nav.Link>
+                    <Nav.Link eventKey={`networks-undirected`}>
+                      Undirected
+                    </Nav.Link>
+                  </Nav>
+                </Col>
+                <Col sm={9}>
+                  <Tab.Content>
+                    <Tab.Pane eventKey={`networks-dags`} >
+                      <Tab.Container defaultActiveKey={`networks-dags-0`}>
+                        <Row>
+                          <Col sm={3}>
+                            <Nav variant="pills" className="flex-column">
+                              {data.summaries.dags.map((g: any, ndx2) => <Nav.Item key={ndx2}>
+                                <Nav.Link eventKey={`networks-dags-${ndx2}`}>
+                                  {g.name}
+                                </Nav.Link>
+                              </Nav.Item>)}
+                            </Nav>
+                          </Col>
+                          <Col sm={9}>
+                            <Tab.Content>
+                              <p>idk dags</p>
+                            </Tab.Content>
+                          </Col>
+                        </Row>
+                      </Tab.Container>
+                    </Tab.Pane>
+                    <Tab.Pane eventKey={`networks-directed`} >
+                      <Tab.Container defaultActiveKey={`networks-directed-0`}>
+                        <Row>
+                          <Col sm={3}>
+                            <Nav variant="pills" className="flex-column">
+                              {data.summaries.directed.map((g: any, ndx2) => <Nav.Item key={ndx2}>
+                                <Nav.Link eventKey={`networks-directed-${ndx2}`}>
+                                  {g.name}
+                                </Nav.Link>
+                              </Nav.Item>)}
+                            </Nav>
+                          </Col>
+                          <Col sm={9}>
+                            <Tab.Content>
+                              <p>idk directed</p>
+                            </Tab.Content>
+                          </Col>
+                        </Row>
+                      </Tab.Container>
+                    </Tab.Pane>
+                    <Tab.Pane eventKey={`networks-undirected`} >
+                      <Tab.Container defaultActiveKey={`networks-undirected-0`}>
+                        <Row>
+                          <Col sm={3}>
+                            <Nav variant="pills" className="flex-column">
+                              {data.summaries.undirected.map((g: any, ndx2) => <Nav.Item key={ndx2}>
+                                <Nav.Link eventKey={`networks-undirected-${ndx2}`}>
+                                  {g.name}
+                                </Nav.Link>
+                              </Nav.Item>)}
+                            </Nav>
+                          </Col>
+                          <Col sm={9}>
+                            <Tab.Content>
+                              <p>idk undirected</p>
+                            </Tab.Content>
+                          </Col>
+                        </Row>
+                      </Tab.Container>
+                    </Tab.Pane>
+                  </Tab.Content>
+                </Col>
+              </Row>
+            </Tab.Container>
+          </Tab>
+
+          <Tab eventKey="summary" title="summaries">
+            <Tab.Container id="left-tabs-example3" defaultActiveKey={`summary-0`}>
+              <Row>
+                <Col sm={3}>
+                  <Nav variant="pills" className="flex-column">
+                    {data.summaries.dags?.map((summary: any, ndx) => <Nav.Item key={ndx}>
+                      <Nav.Link eventKey={`summary-${ndx}`}>
+                        {summary.name}
+                      </Nav.Link>
+                    </Nav.Item>)}
+                  </Nav>
+                </Col>
+                <Col sm={9}>
+                  <Tab.Content>
+                    {Object.keys(data.summaries.dags).map((summaryKey, ndx2) => <Tab.Pane key={ndx2} eventKey={`summary-${ndx2}`} >
+                      <pre><code>{JSON.stringify(data.summaries.dags[summaryKey].dagReduction, null, 2)}</code></pre>
+                    </Tab.Pane>)}
+                  </Tab.Content>
+                </Col>
+              </Row>
+            </Tab.Container>
+          </Tab>
+        </Tabs>
+      </>
+    }
+    {
+      !data && <p>LOADING</p>
+    }
+
+    <footer style={{ position: 'fixed', bottom: 0, right: 0 }}>made with ❤️ and <a href="https://adamwong246.github.io/testeranto/" >testeranto</a></footer>
+
+  </div>)
+}
+
+document.addEventListener("DOMContentLoaded", function () {
+  const elem = document.getElementById("root");
+  if (elem) {
+    ReactDom.createRoot(elem).render(React.createElement(Report));
+  }
+});

package/src/build.js

@@ -0,0 +1,88 @@
+// /* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+const esbuild = require("esbuild");
+const fs = require("fs");
+const path = require("path");
+const createHash = require("node:crypto").createHash;
+
+console.log("hello build.sh", process.cwd(), process.argv);
+
+const testerantoConfig = require(process.argv[2]);
+
+fs.promises.writeFile("./dist/testeranto.config.json", JSON.stringify(testerantoConfig));
+
+esbuild.build({
+  entryPoints: [testerantoConfig.features],
+  bundle: true,
+  minify: false,
+  format: "esm",
+  target: ["esnext"],
+  write: false,
+  packages: 'external',
+}).then((res) => {
+  const text = res.outputFiles[0].text;
+  const hash = createHash('md5').update(text).digest('hex');
+  const jsFile = process.cwd() + "/dist/tests/testerantoFeatures.test.js";
+  const md5File = process.cwd() + "/dist/tests/testerantoFeatures.test.md5";
+
+  fs.promises.mkdir(path.dirname(process.cwd() + "./dist/tests/"), { recursive: true }).then(x => {
+    console.log("build.js feature", hash, jsFile);
+
+    fs.promises.writeFile(jsFile, text);
+    fs.promises.writeFile(md5File, hash)
+  })
+});
+
+/////////////////////////////////////////////////////////////////////////////////
+
+testerantoConfig.tests.forEach(([key, sourcefile, className]) => {
+  esbuild.build({
+    entryPoints: [sourcefile],
+    bundle: true,
+    minify: false,
+    format: "esm",
+    target: ["esnext"],
+    write: false,
+    packages: 'external',
+    plugins: [{
+      name: 'import-path',
+      setup(build) {
+        build.onResolve({ filter: /^\.{1,2}\// }, args => {
+
+          const importedPath = args.resolveDir + "/" + args.path;
+          const absolutePath = path.resolve(importedPath);
+
+          const absolutePath2 = path.resolve(testerantoConfig.features).split(".ts").slice(0, -1).join('.ts');
+
+          if (absolutePath === absolutePath2) {
+            return {
+              path: process.cwd() + "/dist/tests/testerantoFeatures.test.js",
+              external: true
+            }
+          } else {
+            // return {
+            //   path: path.resolve(importedPath), external: false
+            // }
+          }
+        })
+      },
+    }],
+    external: [
+      testerantoConfig.features
+    ],
+  }).then((res) => {
+
+    const text = res.outputFiles[0].text;
+
+    const pp = "./dist/" + (sourcefile.split(process.cwd()).pop()).split(".ts")[0] + '.js';
+    const xx = "./dist/" + (sourcefile.split(process.cwd()).pop()).split(".ts")[0] + `.md5`;
+
+    fs.promises.mkdir(path.dirname(pp), { recursive: true }).then(x => {
+      const hash = createHash('md5').update(text).digest('hex');
+      console.log("build.js test", key, hash);
+      fs.promises.writeFile(pp, text);
+      fs.promises.writeFile(xx, hash);
+    })
+  })
+});

package/src/index.ts

@@ -0,0 +1,153 @@
+import { BaseGiven, BaseCheck, BaseSuite, BaseFeature, BaseWhen, BaseThen } from "./BaseClasses";
+import { TesterantoLevelOne } from "./lib/level1";
+import { ITestImplementation, ITestSpecification, ITTestResource, ITTestResourceRequirement, ITTestShape, Modify } from "./types"
+
+export type { ITestImplementation, ITestSpecification, ITTestShape, Modify };
+
+export const Testeranto = <
+  TestShape extends ITTestShape,
+  Input,
+  Subject,
+  Store,
+  Selection,
+  WhenShape,
+  ThenShape,
+  InitialStateShape
+>(
+  input: Input,
+  testSpecification: ITestSpecification<TestShape>,
+  testImplementation,
+  // testImplementation: ITestImplementation<
+  //   InitialStateShape,
+  //   Selection,
+  //   WhenShape,
+  //   ThenShape,
+  //   TestShape
+  // >,
+  testResource: ITTestResourceRequirement,
+
+  testInterface: {
+    actionHandler?: (b: (...any) => any) => any,
+    afterEach?: (store: Store, ndx: number, cb) => unknown,
+    andWhen: (store: Store, actioner, testResource: ITTestResource) => Promise<Selection>,
+    assertioner?: (t: ThenShape) => any,
+    beforeAll?: (input: Input) => Promise<Subject>,
+    beforeEach?: (subject: Subject, initialValues, testResource: ITTestResource) => Promise<Store>,
+    butThen?: (store: Store, callback, testResource: ITTestResource) => Promise<Selection>,
+  },
+
+) => {
+
+  const butThen = testInterface.butThen || (async (a) => a as any);
+  const { andWhen } = testInterface;
+  const actionHandler = testInterface.actionHandler || function (b: (...any: any[]) => any) {
+    return b;
+  };
+  const assertioner = testInterface.assertioner || (async (t) => t as any);
+  const beforeAll = testInterface.beforeAll || (async (input) => input as any);
+  const beforeEach = testInterface.beforeEach || async function (subject: Input, initialValues: any, testResource: any) {
+    return subject as any;
+  }
+  const afterEach = testInterface.afterEach || (async (s) => s);
+
+  return class extends TesterantoLevelOne<
+    TestShape,
+    InitialStateShape,
+    Selection,
+    Store,
+    Subject,
+    WhenShape,
+    ThenShape,
+    Input
+  > {
+    constructor() {
+      super(
+        testImplementation,
+        /* @ts-ignore:next-line */
+        testSpecification,
+        input,
+        (class extends BaseSuite<Input, Subject, Store, Selection, ThenShape, TestShape> {
+          async setup(s: Input): Promise<Subject> {
+            return beforeAll(s);
+          }
+          test(t: ThenShape): unknown {
+            return assertioner(t);
+          }
+        }),
+
+        class Given extends BaseGiven<Subject, Store, Selection, ThenShape> {
+          initialValues: any;
+          constructor(
+            name: string,
+            features: BaseFeature[],
+            whens: BaseWhen<Store, Selection, ThenShape>[],
+            thens: BaseThen<Selection, Store, ThenShape>[],
+            initialValues: any
+          ) {
+            super(name, features, whens, thens);
+            this.initialValues = initialValues;
+          }
+          async givenThat(subject, testResource) {
+            return beforeEach(subject, this.initialValues, testResource);
+          }
+          afterEach(store: Store, ndx: number, cb): Promise<unknown> {
+            return new Promise((res) => res(afterEach(store, ndx, cb)))
+          }
+        },
+
+        class When extends BaseWhen<Store, Selection, WhenShape> {
+          payload?: any;
+
+          constructor(name: string, actioner: (...any) => any, payload?: any) {
+            super(name, (store) => {
+              return actionHandler(actioner)
+            });
+            this.payload = payload;
+          }
+
+          async andWhen(store, actioner, testResource) {
+            return await andWhen(store, actioner, testResource);
+          }
+        },
+
+        class Then extends BaseThen<Selection, Store, ThenShape> {
+          constructor(
+            name: string,
+            callback: (val: Selection) => ThenShape
+          ) {
+            super(name, callback);
+          }
+
+          async butThen(store: any, testResourceConfiguration?: any): Promise<Selection> {
+            return await butThen(store, this.thenCB, testResourceConfiguration)
+          }
+        },
+
+        class Check extends BaseCheck<Subject, Store, Selection, ThenShape, TestShape> {
+          initialValues: any;
+
+          constructor(
+            name: string,
+            features: BaseFeature[],
+            checkCallback: (a, b) => any,
+            whens,
+            thens,
+            initialValues: any,
+          ) {
+            super(name, features, checkCallback, whens, thens);
+            this.initialValues = initialValues;
+          }
+
+          async checkThat(subject, testResource) {
+            return beforeEach(subject, this.initialValues, testResource);
+          }
+
+          afterEach(store: Store, ndx: number, cb): Promise<unknown> {
+            return new Promise((res) => res(afterEach(store, ndx, cb)))
+          }
+        },
+        testResource
+      );
+    }
+  }
+};