@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/FormatterJson.res.mjs

@@ -0,0 +1,320 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Diff$ReventlessGwt from "./Diff.res.mjs";
+import * as Hint$ReventlessGwt from "./Hint.res.mjs";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as RunnerTypes$ReventlessGwt from "./RunnerTypes.res.mjs";
+import * as RenderRescript$ReventlessGwt from "./RenderRescript.res.mjs";
+
+let schemaVersion = "1.1.0";
+
+function write(s) {
+  process.stdout.write(s);
+}
+
+function writeLine(s) {
+  process.stdout.write(s + "\n");
+}
+
+function renderValue(j) {
+  let obj = {};
+  let exit = 0;
+  if (j === null || Array.isArray(j)) {
+    exit = 1;
+  } else {
+    switch (typeof j) {
+      case "string" :
+        obj["type"] = j;
+        obj["payload"] = null;
+        break;
+      case "object" :
+        let match = j["TAG"];
+        let exit$1 = 0;
+        if (typeof match === "string") {
+          obj["type"] = match;
+          let payloadKeys = Object.keys(j).filter(k => {
+            if (k !== "TAG") {
+              return k.startsWith("_");
+            } else {
+              return false;
+            }
+          });
+          let payload;
+          let exit$2 = 0;
+          let len = payloadKeys.length;
+          if (len !== 1) {
+            if (len !== 0) {
+              exit$2 = 3;
+            } else {
+              payload = null;
+            }
+          } else {
+            let match$1 = payloadKeys[0];
+            if (match$1 === "_0") {
+              payload = Stdlib_Option.getOr(j["_0"], null);
+            } else {
+              exit$2 = 3;
+            }
+          }
+          if (exit$2 === 3) {
+            let payloadDict = {};
+            payloadKeys.forEach(k => {
+              payloadDict[k] = Stdlib_Option.getOr(j[k], null);
+            });
+            payload = payloadDict;
+          }
+          obj["payload"] = payload;
+        } else {
+          exit$1 = 2;
+        }
+        if (exit$1 === 2) {
+          obj["type"] = null;
+          obj["payload"] = j;
+        }
+        break;
+      default:
+        exit = 1;
+    }
+  }
+  if (exit === 1) {
+    obj["type"] = null;
+    obj["payload"] = j;
+  }
+  obj["rendered"] = RenderRescript$ReventlessGwt.render(undefined, j);
+  return obj;
+}
+
+function renderValues(arr) {
+  return arr.map(renderValue);
+}
+
+function mismatchJson(m, slice) {
+  let obj = {};
+  obj["kind"] = Outcome$ReventlessGwt.kindName(m);
+  let optVal = o => {
+    if (o !== undefined) {
+      return renderValue(o);
+    } else {
+      return null;
+    }
+  };
+  switch (m.TAG) {
+    case "EventsMismatch" :
+      let actual = m.actual;
+      let expected = m.expected;
+      obj["expected"] = expected.map(renderValue);
+      obj["actual"] = actual.map(renderValue);
+      obj["fieldDiff"] = Diff$ReventlessGwt.toJsonArray(Diff$ReventlessGwt.diffArrays(expected, actual));
+      break;
+    case "ErrorMismatch" :
+      obj["expected"] = renderValue(m.expected);
+      obj["actual"] = optVal(m.actual);
+      obj["actualEvents"] = m.actualEvents.map(renderValue);
+      break;
+    case "StateMismatch" :
+      let actual$1 = m.actual;
+      let expected$1 = m.expected;
+      obj["key"] = m.key;
+      obj["expected"] = optVal(expected$1);
+      obj["actual"] = optVal(actual$1);
+      let eJson = Stdlib_Option.getOr(expected$1, null);
+      let aJson = Stdlib_Option.getOr(actual$1, null);
+      obj["fieldDiff"] = Diff$ReventlessGwt.toJsonArray(Diff$ReventlessGwt.diff(eJson, aJson));
+      break;
+    case "NoEventExpected" :
+      obj["actual"] = m.actual.map(renderValue);
+      break;
+    case "TodoMismatch" :
+      let pairArr = pairs => pairs.map(param => {
+        let d = {};
+        d["id"] = param[0];
+        d["value"] = renderValue(param[1]);
+        return d;
+      });
+      obj["expected"] = pairArr(m.expected);
+      obj["actual"] = pairArr(m.actual);
+      break;
+    case "AppendConditionMismatch" :
+      obj["expected"] = m.expected;
+      obj["actual"] = m.actual;
+      break;
+    case "TranslateError" :
+      obj["expected"] = m.expected;
+      obj["actual"] = Stdlib_Option.mapOr(m.actual, null, prim => prim);
+      break;
+    case "QueryRowsMismatch" :
+      let actual$2 = m.actual;
+      let expected$2 = m.expected;
+      obj["expected"] = expected$2.map(renderValue);
+      obj["actual"] = actual$2.map(renderValue);
+      obj["fieldDiff"] = Diff$ReventlessGwt.toJsonArray(Diff$ReventlessGwt.diffArrays(expected$2, actual$2));
+      break;
+    case "PublishedActionsMismatch" :
+      let actual$3 = m.actual;
+      let expected$3 = m.expected;
+      obj["expected"] = expected$3.map(renderValue);
+      obj["actual"] = actual$3.map(renderValue);
+      obj["fieldDiff"] = Diff$ReventlessGwt.toJsonArray(Diff$ReventlessGwt.diffArrays(expected$3, actual$3));
+      break;
+    case "Throw" :
+      obj["error"] = m.error;
+      obj["stack"] = m.stack;
+      break;
+  }
+  let hint = Hint$ReventlessGwt.forMismatch(slice, m);
+  obj["hint"] = Hint$ReventlessGwt.toJson(hint);
+  return obj;
+}
+
+function locationJson(loc) {
+  if (loc === undefined) {
+    return null;
+  }
+  let d = {};
+  d["file"] = loc.file;
+  d["line"] = loc.line;
+  d["column"] = loc.column;
+  return d;
+}
+
+function testJson(t) {
+  let d = {};
+  d["id"] = t.id;
+  d["name"] = t.name;
+  d["describePath"] = t.describePath.map(prim => prim);
+  d["status"] = RunnerTypes$ReventlessGwt.statusString(t.status);
+  d["durationMs"] = t.durationMs;
+  d["location"] = locationJson(t.location);
+  let m = t.mismatch;
+  if (m !== undefined) {
+    d["mismatch"] = mismatchJson(m, t.slice);
+  }
+  let r = t.skipReason;
+  if (r !== undefined) {
+    d["skipReason"] = r;
+  }
+  return d;
+}
+
+function fileJson(f) {
+  let d = {};
+  d["path"] = f.path;
+  d["tests"] = f.tests.map(testJson);
+  return d;
+}
+
+function summaryJson(s) {
+  let d = {};
+  d["total"] = s.total;
+  d["passed"] = s.passed;
+  d["failed"] = s.failed;
+  d["skipped"] = s.skipped;
+  d["files"] = s.files;
+  return d;
+}
+
+function envelope(r, toolVersion) {
+  let d = {};
+  d["schemaVersion"] = schemaVersion;
+  d["tool"] = "reventless-gwt";
+  d["toolVersion"] = toolVersion;
+  d["startedAt"] = r.summary.startedAt;
+  d["durationMs"] = r.summary.durationMs;
+  d["summary"] = summaryJson(r.summary);
+  d["files"] = r.files.map(fileJson);
+  return d;
+}
+
+function emit(r, toolVersion) {
+  process.stdout.write(JSON.stringify(envelope(r, toolVersion), undefined, 2) + "\n");
+}
+
+function streamRunStart(toolVersion, startedAt) {
+  let d = {};
+  d["type"] = "runStarted";
+  d["schemaVersion"] = schemaVersion;
+  d["toolVersion"] = toolVersion;
+  d["at"] = startedAt;
+  let s = JSON.stringify(d);
+  process.stdout.write(s + "\n");
+}
+
+function streamFileStart(path) {
+  let d = {};
+  d["type"] = "fileStarted";
+  d["path"] = path;
+  let s = JSON.stringify(d);
+  process.stdout.write(s + "\n");
+}
+
+function streamTest(t) {
+  let d = {};
+  d["type"] = "testResult";
+  let tj = testJson(t);
+  if (typeof tj === "object" && tj !== null && !Array.isArray(tj)) {
+    Object.keys(tj).forEach(k => {
+      d[k] = tj[k];
+    });
+  }
+  let s = JSON.stringify(d);
+  process.stdout.write(s + "\n");
+}
+
+function streamFileFinished(f) {
+  let passed = {
+    contents: 0
+  };
+  let failed = {
+    contents: 0
+  };
+  f.tests.forEach(t => {
+    let match = t.status;
+    switch (match) {
+      case "Pass" :
+        passed.contents = passed.contents + 1 | 0;
+        return;
+      case "Fail" :
+        failed.contents = failed.contents + 1 | 0;
+        return;
+      case "Skip" :
+        return;
+    }
+  });
+  let d = {};
+  d["type"] = "fileFinished";
+  d["path"] = f.path;
+  d["passed"] = passed.contents;
+  d["failed"] = failed.contents;
+  let s = JSON.stringify(d);
+  process.stdout.write(s + "\n");
+}
+
+function streamRunEnd(r) {
+  let d = {};
+  d["type"] = "runFinished";
+  d["summary"] = summaryJson(r.summary);
+  let s = JSON.stringify(d);
+  process.stdout.write(s + "\n");
+}
+
+export {
+  schemaVersion,
+  write,
+  writeLine,
+  renderValue,
+  renderValues,
+  mismatchJson,
+  locationJson,
+  testJson,
+  fileJson,
+  summaryJson,
+  envelope,
+  emit,
+  streamRunStart,
+  streamFileStart,
+  streamTest,
+  streamFileFinished,
+  streamRunEnd,
+}
+/* No side effect */

package/src/FormatterJunit.res

@@ -0,0 +1,93 @@
+// JUnit XML emitter — one `<testsuite>` per file, one `<testcase>` per test.
+// Failures carry the human-readable mismatch + hint inside `<failure>` so
+// CI tools like Jenkins surface the ReScript-rendered expected/actual in
+// their test report UI.
+
+@val external processStdout: {"write": string => unit} = "process.stdout"
+let write = (s: string) => processStdout["write"](s)
+let writeLine = (s: string) => write(s ++ "\n")
+
+let escapeXml = (s: string) =>
+  s
+  ->String.replaceAll("&", "&amp;")
+  ->String.replaceAll("<", "&lt;")
+  ->String.replaceAll(">", "&gt;")
+  ->String.replaceAll("\"", "&quot;")
+  ->String.replaceAll("'", "&apos;")
+
+let emitFile = (f: RunnerTypes.fileResult) => {
+  let tests = f.tests->Array.length
+  let failures = ref(0)
+  let skipped = ref(0)
+  f.tests->Array.forEach(t =>
+    switch t.status {
+    | Fail => failures := failures.contents + 1
+    | Skip => skipped := skipped.contents + 1
+    | Pass => ()
+    }
+  )
+  let totalTime = f.tests->Array.reduce(0.0, (a, t) => a +. t.durationMs) /. 1000.0
+  writeLine(
+    `  <testsuite name="${escapeXml(f.path)}" tests="${Int.toString(
+        tests,
+      )}" failures="${Int.toString(failures.contents)}" skipped="${Int.toString(
+        skipped.contents,
+      )}" time="${Float.toString(totalTime)}">`,
+  )
+  f.tests->Array.forEach(t => {
+    let name = t.describePath->Array.join(" > ")
+    let classname = name == "" ? f.path : name
+    let time = t.durationMs /. 1000.0
+    write(
+      `    <testcase name="${escapeXml(t.name)}" classname="${escapeXml(
+          classname,
+        )}" time="${Float.toString(time)}"`,
+    )
+    switch t.status {
+    | Pass => writeLine(" />")
+    | Skip => {
+        writeLine(">")
+        writeLine(
+          `      <skipped message="${escapeXml(t.skipReason->Option.getOr("skipped"))}" />`,
+        )
+        writeLine(`    </testcase>`)
+      }
+    | Fail => {
+        writeLine(">")
+        switch t.mismatch {
+        | Some(m) => {
+            let hint = Hint.forMismatch(~slice=?t.slice, m)
+            let msg =
+              escapeXml(Outcome.kindName(m)) ++
+              ": " ++
+              escapeXml(Outcome.format(m)) ++
+              "\n\n" ++
+              escapeXml(Hint.format(hint))
+            writeLine(
+              `      <failure type="${escapeXml(Outcome.kindName(m))}" message="${escapeXml(
+                  Outcome.format(m),
+                )}">${msg}</failure>`,
+            )
+          }
+        | None =>
+          writeLine(`      <failure message="failed" type="unknown">failed</failure>`)
+        }
+        writeLine(`    </testcase>`)
+      }
+    }
+  })
+  writeLine(`  </testsuite>`)
+}
+
+let emit = (r: RunnerTypes.runResult) => {
+  writeLine(`<?xml version="1.0" encoding="UTF-8"?>`)
+  writeLine(
+    `<testsuites name="reventless-gwt" tests="${Int.toString(
+        r.summary.total,
+      )}" failures="${Int.toString(r.summary.failed)}" skipped="${Int.toString(
+        r.summary.skipped,
+      )}" time="${Float.toString(r.summary.durationMs /. 1000.0)}">`,
+  )
+  r.files->Array.forEach(emitFile)
+  writeLine(`</testsuites>`)
+}

package/src/FormatterJunit.res.mjs

@@ -0,0 +1,90 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Hint$ReventlessGwt from "./Hint.res.mjs";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+
+function write(s) {
+  process.stdout.write(s);
+}
+
+function writeLine(s) {
+  process.stdout.write(s + "\n");
+}
+
+function escapeXml(s) {
+  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+
+function emitFile(f) {
+  let tests = f.tests.length;
+  let failures = {
+    contents: 0
+  };
+  let skipped = {
+    contents: 0
+  };
+  f.tests.forEach(t => {
+    let match = t.status;
+    switch (match) {
+      case "Pass" :
+        return;
+      case "Fail" :
+        failures.contents = failures.contents + 1 | 0;
+        return;
+      case "Skip" :
+        skipped.contents = skipped.contents + 1 | 0;
+        return;
+    }
+  });
+  let totalTime = Stdlib_Array.reduce(f.tests, 0.0, (a, t) => a + t.durationMs) / 1000.0;
+  let s = `  <testsuite name="` + escapeXml(f.path) + `" tests="` + tests.toString() + `" failures="` + failures.contents.toString() + `" skipped="` + skipped.contents.toString() + `" time="` + totalTime.toString() + `">`;
+  process.stdout.write(s + "\n");
+  f.tests.forEach(t => {
+    let name = t.describePath.join(" > ");
+    let classname = name === "" ? f.path : name;
+    let time = t.durationMs / 1000.0;
+    process.stdout.write(`    <testcase name="` + escapeXml(t.name) + `" classname="` + escapeXml(classname) + `" time="` + time.toString() + `"`);
+    let match = t.status;
+    switch (match) {
+      case "Pass" :
+        return process.stdout.write(" />\n");
+      case "Fail" :
+        process.stdout.write(">\n");
+        let m = t.mismatch;
+        if (m !== undefined) {
+          let hint = Hint$ReventlessGwt.forMismatch(t.slice, m);
+          let msg = escapeXml(Outcome$ReventlessGwt.kindName(m)) + ": " + escapeXml(Outcome$ReventlessGwt.format(m)) + "\n\n" + escapeXml(Hint$ReventlessGwt.format(hint));
+          let s = `      <failure type="` + escapeXml(Outcome$ReventlessGwt.kindName(m)) + `" message="` + escapeXml(Outcome$ReventlessGwt.format(m)) + `">` + msg + `</failure>`;
+          process.stdout.write(s + "\n");
+        } else {
+          process.stdout.write(`      <failure message="failed" type="unknown">failed</failure>` + "\n");
+        }
+        return process.stdout.write(`    </testcase>` + "\n");
+      case "Skip" :
+        process.stdout.write(">\n");
+        let s$1 = `      <skipped message="` + escapeXml(Stdlib_Option.getOr(t.skipReason, "skipped")) + `" />`;
+        process.stdout.write(s$1 + "\n");
+        return process.stdout.write(`    </testcase>` + "\n");
+    }
+  });
+  process.stdout.write(`  </testsuite>` + "\n");
+}
+
+function emit(r) {
+  process.stdout.write(`<?xml version="1.0" encoding="UTF-8"?>` + "\n");
+  let s = `<testsuites name="reventless-gwt" tests="` + r.summary.total.toString() + `" failures="` + r.summary.failed.toString() + `" skipped="` + r.summary.skipped.toString() + `" time="` + (r.summary.durationMs / 1000.0).toString() + `">`;
+  process.stdout.write(s + "\n");
+  r.files.forEach(emitFile);
+  process.stdout.write(`</testsuites>` + "\n");
+}
+
+export {
+  write,
+  writeLine,
+  escapeXml,
+  emitFile,
+  emit,
+}
+/* No side effect */

package/src/FormatterTap.res

@@ -0,0 +1,139 @@
+// TAP 14 emitter with YAML diagnostic blocks on failure. Streamed line-by-line
+// so `tap-spec` and GitHub Actions' `actions/test-reporter` can consume the
+// output live.
+
+@val external processStdout: {"write": string => unit} = "process.stdout"
+let write = (s: string) => processStdout["write"](s)
+let writeLine = (s: string) => write(s ++ "\n")
+
+let escapeYamlString = (s: string) =>
+  s
+  ->String.replaceAll("\\", "\\\\")
+  ->String.replaceAll("\"", "\\\"")
+  ->String.replaceAll("\n", "\\n")
+
+let yamlString = (s: string) => "\"" ++ escapeYamlString(s) ++ "\""
+
+let yamlLine = (~indent=2, key: string, value: string) =>
+  String.repeat(" ", indent) ++ key ++ ": " ++ value
+
+let renderMismatchYaml = (m: Outcome.mismatch) => {
+  let lines = []
+  lines->Array.push(yamlLine("kind", yamlString(Outcome.kindName(m))))
+  switch m {
+  | EventsMismatch({expected, actual}) => {
+      lines->Array.push(yamlLine("expected", yamlString(RenderRescript.renderMany(expected))))
+      lines->Array.push(yamlLine("actual", yamlString(RenderRescript.renderMany(actual))))
+    }
+  | ErrorMismatch({expected, actual, actualEvents}) => {
+      lines->Array.push(
+        yamlLine("expected", yamlString("Error(" ++ RenderRescript.render(expected) ++ ")")),
+      )
+      let actualStr = switch actual {
+      | Some(v) => "Error(" ++ RenderRescript.render(v) ++ ")"
+      | None => "Ok(" ++ RenderRescript.renderMany(actualEvents) ++ ")"
+      }
+      lines->Array.push(yamlLine("actual", yamlString(actualStr)))
+    }
+  | StateMismatch({key, expected, actual}) => {
+      lines->Array.push(yamlLine("key", yamlString(key)))
+      lines->Array.push(yamlLine("expected", yamlString(RenderRescript.renderOption(expected))))
+      lines->Array.push(yamlLine("actual", yamlString(RenderRescript.renderOption(actual))))
+    }
+  | NoEventExpected({actual}) =>
+    lines->Array.push(yamlLine("actual", yamlString(RenderRescript.renderMany(actual))))
+  | TodoMismatch({expected, actual}) => {
+      let fmt = arr =>
+        arr
+        ->Array.map(((id, v)) => "(" ++ id ++ ", " ++ RenderRescript.render(v) ++ ")")
+        ->Array.join(", ")
+      lines->Array.push(yamlLine("expected", yamlString("[" ++ fmt(expected) ++ "]")))
+      lines->Array.push(yamlLine("actual", yamlString("[" ++ fmt(actual) ++ "]")))
+    }
+  | AppendConditionMismatch({expected, actual}) => {
+      lines->Array.push(yamlLine("expected", yamlString(RenderRescript.render(expected))))
+      lines->Array.push(yamlLine("actual", yamlString(RenderRescript.render(actual))))
+    }
+  | TranslateError({expected, actual}) => {
+      lines->Array.push(yamlLine("expected", yamlString(expected)))
+      lines->Array.push(yamlLine("actual", yamlString(actual->Option.getOr("(none)"))))
+    }
+  | QueryRowsMismatch({expected, actual}) => {
+      lines->Array.push(yamlLine("expected", yamlString(RenderRescript.renderMany(expected))))
+      lines->Array.push(yamlLine("actual", yamlString(RenderRescript.renderMany(actual))))
+    }
+  | PublishedActionsMismatch({expected, actual}) => {
+      lines->Array.push(yamlLine("expected", yamlString(RenderRescript.renderMany(expected))))
+      lines->Array.push(yamlLine("actual", yamlString(RenderRescript.renderMany(actual))))
+    }
+  | Throw({error, stack}) => {
+      lines->Array.push(yamlLine("error", yamlString(error)))
+      lines->Array.push(yamlLine("stack", yamlString(stack)))
+    }
+  }
+  lines->Array.join("\n")
+}
+
+let emit = (r: RunnerTypes.runResult) => {
+  writeLine("TAP version 14")
+  writeLine(`1..${Int.toString(r.summary.total)}`)
+  let index = ref(0)
+  r.files->Array.forEach(f => {
+    writeLine("")
+    writeLine(`# ${f.path}`)
+    f.tests->Array.forEach(t => {
+      index := index.contents + 1
+      let n = index.contents
+      let path = t.describePath->Array.join(" > ")
+      let title = path == "" ? t.name : `${path} > ${t.name}`
+      let ms = ` # time=${Float.toString(t.durationMs)}ms`
+      switch t.status {
+      | Pass => writeLine(`ok ${Int.toString(n)} - ${title}${ms}`)
+      | Skip => {
+          let reason = t.skipReason->Option.getOr("skipped")
+          writeLine(`ok ${Int.toString(n)} - ${title} # SKIP ${reason}`)
+        }
+      | Fail => {
+          writeLine(`not ok ${Int.toString(n)} - ${title}${ms}`)
+          writeLine("  ---")
+          switch t.location {
+          | Some(loc) =>
+            writeLine(
+              yamlLine(
+                "location",
+                `{ file: "${loc.file}", line: ${Int.toString(loc.line)} }`,
+              ),
+            )
+          | None => ()
+          }
+          switch t.mismatch {
+          | Some(m) => writeLine(renderMismatchYaml(m))
+          | None => ()
+          }
+          switch t.mismatch {
+          | Some(m) => {
+              let hint = Hint.forMismatch(~slice=?t.slice, m)
+              writeLine(yamlLine("hint", ""))
+              writeLine(yamlLine(~indent=4, "locus", yamlString(hint.locus)))
+              writeLine(
+                yamlLine(
+                  ~indent=4,
+                  "branch",
+                  yamlString(hint.branch->Option.getOr("(none)")),
+                ),
+              )
+              writeLine(yamlLine(~indent=4, "message", yamlString(hint.message)))
+            }
+          | None => ()
+          }
+          writeLine("  ...")
+        }
+      }
+    })
+  })
+  writeLine("")
+  writeLine(`# tests ${Int.toString(r.summary.total)}`)
+  writeLine(`# pass ${Int.toString(r.summary.passed)}`)
+  writeLine(`# fail ${Int.toString(r.summary.failed)}`)
+  writeLine(`# skip ${Int.toString(r.summary.skipped)}`)
+}