@reventlessdev/reventless-gwt 1.0.0-alpha.237 → 1.0.0-alpha.239

package/src/InboundTranslation_GWT.res

@@ -30,6 +30,8 @@ module type T = {
   let thenTranslateError: (translateResult, string) => Outcome.outcome
 }
 
+/** Deprecated: takes an adapter module with `translate` on the spec. Use
+    `FromSlice`; this goes one release after the examples have moved. */
 module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
   module Spec = Spec
 
@@ -74,3 +76,113 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
     | Ok(_) => Outcome.fail(TranslateError({expected: expectedMsg, actual: None}))
     }
 }
+
+// The slice as written: its `Spec` and its `_Translation` body.
+module FromSlice = (
+  Spec: Reventless.InboundTranslationSlice.Spec,
+  Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec,
+) => {
+  let describe = JestBind.describe
+  let test = (name, body) => JestBind.test(~slice=Spec.name, name, body)
+
+  /** What became of one input. `InputRefused` is input that did not decode, so
+      `translate` never saw it; `NotUnderstood` is input it declined. */
+  type received =
+    | Translated(array<(string, Spec.command)>)
+    | NotUnderstood(string)
+    | InputRefused(string)
+
+  let encPairs = (pairs: array<(string, Spec.command)>) =>
+    pairs->Array.map(((id, cmd)) => {
+      let d = Dict.make()
+      d->Dict.set("id", JSON.Encode.string(id))
+      d->Dict.set("command", cmd->Message.encode(Spec.commandSchema))
+      JSON.Encode.object(d)
+    })
+
+  let whenInput = (input: Spec.externalInput) =>
+    switch Translation.translate(input) {
+    | Ok(pairs) => Translated(pairs)
+    | Error(msg) => NotUnderstood(msg)
+    }
+
+  /** Input as it arrives: decoded through `externalInputSchema` first. */
+  let whenReceived = (json: JSON.t) =>
+    switch json->Reventless.Util_Sury.fromJson(Spec.externalInputSchema) {
+    | input => whenInput(input)
+    // Sury's message names the field that failed.
+    | exception S.Exn(e) => InputRefused(e.message)
+    | exception _ => InputRefused("invalid input")
+    }
+
+  let describeOther = received =>
+    switch received {
+    | Translated(_) => None
+    | NotUnderstood(msg) => Some(`not understood: ${msg}`)
+    | InputRefused(msg) => Some(`input refused: ${msg}`)
+    }
+
+  // Each command must survive its own schema both ways, as it will on the topic.
+  let roundTrips = (cmd: Spec.command) =>
+    switch cmd
+    ->Message.encode(Spec.commandSchema)
+    ->Reventless.Util_Sury.fromJson(Spec.commandSchema) {
+    | back => back == cmd
+    | exception _ => false
+    }
+
+  let thenCommands = (received, expected) =>
+    switch received {
+    | Translated(actual) if actual == expected =>
+      switch actual->Array.find(((_, cmd)) => !roundTrips(cmd)) {
+      | None => Outcome.pass
+      | Some(pair) =>
+        Outcome.fail(
+          TranslateError({
+            expected: "commands that encode and decode through commandSchema",
+            actual: Some(`${JSON.stringifyAny(encPairs([pair]))->Option.getOr("")} does not`),
+          }),
+        )
+      }
+    | Translated(actual) =>
+      Outcome.fail(EventsMismatch({expected: encPairs(expected), actual: encPairs(actual)}))
+    | other => Outcome.fail(TranslateError({expected: "(commands)", actual: describeOther(other)}))
+    }
+
+  let thenCommand = (received, expectedId, expectedCmd) =>
+    thenCommands(received, [(expectedId, expectedCmd)])
+
+  let thenNoCommand = received =>
+    switch received {
+    | Translated([]) => Outcome.pass
+    | Translated(actual) => Outcome.fail(NoEventExpected({actual: encPairs(actual)}))
+    | other =>
+      Outcome.fail(TranslateError({expected: "(no commands)", actual: describeOther(other)}))
+    }
+
+  let thenNotUnderstood = (received, expectedMsg) =>
+    switch received {
+    | NotUnderstood(actual) if actual == expectedMsg => Outcome.pass
+    | NotUnderstood(actual) =>
+      Outcome.fail(TranslateError({expected: expectedMsg, actual: Some(actual)}))
+    | other => Outcome.fail(TranslateError({expected: expectedMsg, actual: describeOther(other)}))
+    }
+  let thenTranslateError = thenNotUnderstood
+
+  /** Passes when the input was refused and the reason contains `reason`: the
+      decoder words its own messages, so a test pins the part that matters. */
+  let thenRefusedInput = (received, reason) =>
+    switch received {
+    | InputRefused(actual) if actual->String.includes(reason) => Outcome.pass
+    | other =>
+      Outcome.fail(
+        TranslateError({
+          expected: `input refused: …${reason}…`,
+          actual: switch other {
+          | Translated(_) => Some("translated")
+          | other => describeOther(other)
+          },
+        }),
+      )
+    }
+}

package/src/InboundTranslation_GWT.res.mjs

@@ -1,6 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
 import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
@@ -86,7 +90,192 @@ function Make(Spec) {
   };
 }
 
+function FromSlice(Spec) {
+  return Translation => {
+    let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+    let encPairs = pairs => pairs.map(param => {
+      let d = {};
+      d["id"] = param[0];
+      d["command"] = Message$ReventlessCore.encode(param[1], Spec.commandSchema);
+      return d;
+    });
+    let whenInput = input => {
+      let pairs = Translation.translate(input);
+      if (pairs.TAG === "Ok") {
+        return {
+          TAG: "Translated",
+          _0: pairs._0
+        };
+      } else {
+        return {
+          TAG: "NotUnderstood",
+          _0: pairs._0
+        };
+      }
+    };
+    let whenReceived = json => {
+      let input;
+      try {
+        input = Util_Sury$Reventless.fromJson(json, Spec.externalInputSchema);
+      } catch (raw_e) {
+        let e = Primitive_exceptions.internalToException(raw_e);
+        if (e.RE_EXN_ID === S.Exn) {
+          return {
+            TAG: "InputRefused",
+            _0: e._1.message
+          };
+        } else {
+          return {
+            TAG: "InputRefused",
+            _0: "invalid input"
+          };
+        }
+      }
+      return whenInput(input);
+    };
+    let describeOther = received => {
+      switch (received.TAG) {
+        case "Translated" :
+          return;
+        case "NotUnderstood" :
+          return `not understood: ` + received._0;
+        case "InputRefused" :
+          return `input refused: ` + received._0;
+      }
+    };
+    let roundTrips = cmd => {
+      let back;
+      try {
+        back = Util_Sury$Reventless.fromJson(Message$ReventlessCore.encode(cmd, Spec.commandSchema), Spec.commandSchema);
+      } catch (exn) {
+        return false;
+      }
+      return Primitive_object.equal(back, cmd);
+    };
+    let thenCommands = (received, expected) => {
+      switch (received.TAG) {
+        case "Translated" :
+          let actual = received._0;
+          if (!Primitive_object.equal(actual, expected)) {
+            return Outcome$ReventlessGwt.fail({
+              TAG: "EventsMismatch",
+              expected: encPairs(expected),
+              actual: encPairs(actual)
+            });
+          }
+          let pair = actual.find(param => !roundTrips(param[1]));
+          if (pair !== undefined) {
+            return Outcome$ReventlessGwt.fail({
+              TAG: "TranslateError",
+              expected: "commands that encode and decode through commandSchema",
+              actual: Stdlib_Option.getOr(JSON.stringify(encPairs([pair])), "") + ` does not`
+            });
+          } else {
+            return Outcome$ReventlessGwt.pass;
+          }
+        case "NotUnderstood" :
+        case "InputRefused" :
+          return Outcome$ReventlessGwt.fail({
+            TAG: "TranslateError",
+            expected: "(commands)",
+            actual: describeOther(received)
+          });
+      }
+    };
+    let thenCommand = (received, expectedId, expectedCmd) => thenCommands(received, [[
+        expectedId,
+        expectedCmd
+      ]]);
+    let thenNoCommand = received => {
+      switch (received.TAG) {
+        case "Translated" :
+          let actual = received._0;
+          if (actual.length !== 0) {
+            return Outcome$ReventlessGwt.fail({
+              TAG: "NoEventExpected",
+              actual: encPairs(actual)
+            });
+          } else {
+            return Outcome$ReventlessGwt.pass;
+          }
+        case "NotUnderstood" :
+        case "InputRefused" :
+          return Outcome$ReventlessGwt.fail({
+            TAG: "TranslateError",
+            expected: "(no commands)",
+            actual: describeOther(received)
+          });
+      }
+    };
+    let thenNotUnderstood = (received, expectedMsg) => {
+      switch (received.TAG) {
+        case "NotUnderstood" :
+          let actual = received._0;
+          if (actual === expectedMsg) {
+            return Outcome$ReventlessGwt.pass;
+          } else {
+            return Outcome$ReventlessGwt.fail({
+              TAG: "TranslateError",
+              expected: expectedMsg,
+              actual: actual
+            });
+          }
+        case "Translated" :
+        case "InputRefused" :
+          return Outcome$ReventlessGwt.fail({
+            TAG: "TranslateError",
+            expected: expectedMsg,
+            actual: describeOther(received)
+          });
+      }
+    };
+    let thenRefusedInput = (received, reason) => {
+      switch (received.TAG) {
+        case "Translated" :
+        case "NotUnderstood" :
+          break;
+        case "InputRefused" :
+          if (received._0.includes(reason)) {
+            return Outcome$ReventlessGwt.pass;
+          }
+          break;
+      }
+      let tmp;
+      switch (received.TAG) {
+        case "Translated" :
+          tmp = "translated";
+          break;
+        case "NotUnderstood" :
+        case "InputRefused" :
+          tmp = describeOther(received);
+          break;
+      }
+      return Outcome$ReventlessGwt.fail({
+        TAG: "TranslateError",
+        expected: `input refused: …` + reason + `…`,
+        actual: tmp
+      });
+    };
+    return {
+      describe: JestBind$ReventlessGwt.describe,
+      test: test,
+      encPairs: encPairs,
+      whenInput: whenInput,
+      whenReceived: whenReceived,
+      describeOther: describeOther,
+      roundTrips: roundTrips,
+      thenCommands: thenCommands,
+      thenCommand: thenCommand,
+      thenNoCommand: thenNoCommand,
+      thenNotUnderstood: thenNotUnderstood,
+      thenTranslateError: thenNotUnderstood,
+      thenRefusedInput: thenRefusedInput
+    };
+  };
+}
+
 export {
   Make,
+  FromSlice,
 }
-/* Message-ReventlessCore Not a pure module */
+/* S Not a pure module */

package/src/OutboundTranslation_GWT.res

@@ -1,9 +1,7 @@
 open ReventlessCore
 
-// Minimal inline spec for OutboundTranslationSlice. `translate` is async and
-// supplied at test-time via `whenTranslateMocked` so the external service is
-// never hit. The spec's own `translate` is not part of the GWT — it's
-// exercised only through the runtime tests.
+// Minimal inline spec for the flat `Make`, which only mocks `translate`.
+// `FromSlice` below runs the slice's own `translate` against capability fakes.
 module type SliceSpec = {
   let name: string
 
@@ -73,6 +71,9 @@ module type T = {
   let thenTodoStatus: (promise<attempt>, string, todoStatus) => promise<Outcome.outcome>
 }
 
+/** Deprecated: takes an adapter module with `collect` on the spec and never
+    runs `translate`. Use `FromSlice`; this goes one release after the examples
+    have moved. */
 module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
   module Spec = Spec
 
@@ -223,3 +224,205 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
     }
   }
 }
+
+/** A to-do's status as the runtime leaves it after an attempt. `#Pending` is the
+    older name for `#Failed`, kept for one release. */
+type status = [#Completed | #Failed | #Abandoned | #Pending]
+
+// The slice as written: its `Spec` and its `_Translation` body, run against
+// recording capability fakes.
+module FromSlice = (
+  Spec: Reventless.OutboundTranslationSlice.Spec,
+  Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec,
+) => {
+  let describe = JestBind.describe
+  let test = (name, ~timeout=?, body) =>
+    JestBind.testPromise(~slice=Spec.name, name, ~timeout?, body)
+  let testSync = (name, body) => JestBind.test(~slice=Spec.name, name, body)
+
+  type translateResult = result<option<(string, Spec.inboundCommand)>, string>
+
+  type todo = {id: string, item: Spec.outboundItem, fakes: Capabilities_Fake.t}
+
+  /** What one or more attempts left behind. `retries` is the row's
+      `retryCount`: the attempts that failed. */
+  type attempt = {
+    id: string,
+    item: Spec.outboundItem,
+    result: translateResult,
+    retries: int,
+    status: status,
+    sent: array<Capabilities_Fake.call>,
+  }
+
+  let encItems = (arr: array<(string, Spec.outboundItem)>) =>
+    arr->Array.map(((id, i)) => (id, i->Message.encode(Spec.outboundItemSchema)))
+  let commandPairJson = (id, cmd) => {
+    let d = Dict.make()
+    d->Dict.set("id", JSON.Encode.string(id))
+    d->Dict.set("command", cmd->Message.encode(Spec.inboundCommandSchema))
+    JSON.Encode.object(d)
+  }
+  let errorOf = exn =>
+    switch exn {
+    | S.Exn(e) => e.message
+    | JsExn(e) => JsExn.message(e)->Option.getOr("unknown error")
+    | _ => "unknown error"
+    }
+
+  // Unit: collect
+  let givenEvent = (e: Spec.consumedEvent) => e
+  let whenCollect = (e, ~sourceId="") => Translation.collect(e, ~sourceId)
+  let thenTodos = (actual, expected) =>
+    actual == expected
+      ? Outcome.pass
+      : Outcome.fail(TodoMismatch({expected: encItems(expected), actual: encItems(actual)}))
+
+  // Unit: translate
+  let givenTodo = (id, item) => {id, item, fakes: Capabilities_Fake.make()}
+  /** Scripted capabilities for `givenCapabilities`; see `Capabilities_Fake.make`. */
+  let fakes = Capabilities_Fake.make
+  let givenCapabilities = (todo: todo, fakes) => {...todo, fakes}
+
+  // One attempt, judged as the runtime judges it: a throw is a failure, and so
+  // is a command its own schema cannot encode.
+  let attemptWith = async (todo: todo, run) => {
+    let result = try await run(todo.id, todo.item) catch {
+    | exn => Error(errorOf(exn))
+    }
+    switch result {
+    | Ok(Some((_, cmd))) =>
+      switch cmd->Message.encode(Spec.inboundCommandSchema) {
+      | _ => result
+      | exception exn => Error(`failed to encode inbound command: ${errorOf(exn)}`)
+      }
+    | other => other
+    }
+  }
+
+  // Attempts until one succeeds or `limit` have failed. The status is judged
+  // against `maxRetries`, the runtime's budget: that many failures abandon a row.
+  let attempts = async (todo: todo, ~limit, ~maxRetries, run) => {
+    let result = ref(await attemptWith(todo, run))
+    let failures = ref(Result.isError(result.contents) ? 1 : 0)
+    while Result.isError(result.contents) && failures.contents < limit {
+      result := (await attemptWith(todo, run))
+      if Result.isError(result.contents) {
+        failures := failures.contents + 1
+      }
+    }
+    {
+      id: todo.id,
+      item: todo.item,
+      result: result.contents,
+      retries: failures.contents,
+      status: switch result.contents {
+      | Ok(_) => #Completed
+      | Error(_) => failures.contents >= maxRetries ? #Abandoned : #Failed
+      },
+      sent: todo.fakes.calls(),
+    }
+  }
+
+  /** One attempt of the slice's own `translate`, against the given capabilities. */
+  let whenTranslated = (todo: todo) =>
+    attempts(todo, ~limit=1, ~maxRetries=Spec.maxRetries, (id, item) =>
+      Translation.translate(id, item, ~capabilities=todo.fakes.capabilities)
+    )
+  /** One attempt, answered by `mock` instead of `translate`. */
+  let whenTranslateMocked = (todo, mock) =>
+    attempts(todo, ~limit=1, ~maxRetries=Spec.maxRetries, mock)
+  /** Attempts as the sweeps would make them: until one succeeds or `maxRetries`
+      (the Spec's, unless given) have failed. */
+  let whenTranslateRetrying = (todo, ~maxRetries=Spec.maxRetries, mock) =>
+    attempts(todo, ~limit=maxRetries, ~maxRetries, mock)
+
+  /** The budget is spent: what `onExhausted` publishes, if anything. */
+  let whenExhausted = async (todo: todo, ~lastError=?) => {
+    id: todo.id,
+    item: todo.item,
+    result: Ok(Translation.onExhausted(todo.id, todo.item, ~lastError)),
+    retries: Spec.maxRetries,
+    status: #Abandoned,
+    sent: [],
+  }
+
+  let thenCommand = async (pending, expectedId, expectedCmd) => {
+    let {result, _} = await pending
+    switch result {
+    | Ok(Some((id, cmd))) if id == expectedId && cmd == expectedCmd => Outcome.pass
+    | Ok(actual) =>
+      Outcome.fail(
+        EventsMismatch({
+          expected: [commandPairJson(expectedId, expectedCmd)],
+          actual: actual->Option.mapOr([], ((id, cmd)) => [commandPairJson(id, cmd)]),
+        }),
+      )
+    | Error(msg) => Outcome.fail(TranslateError({expected: "(command)", actual: Some(msg)}))
+    }
+  }
+
+  let thenNoCommand = async pending => {
+    let {result, _} = await pending
+    switch result {
+    | Ok(None) => Outcome.pass
+    | Ok(Some((id, cmd))) => Outcome.fail(NoEventExpected({actual: [commandPairJson(id, cmd)]}))
+    | Error(msg) => Outcome.fail(TranslateError({expected: "(no command)", actual: Some(msg)}))
+    }
+  }
+
+  let thenSent = async (pending, expected: array<Capabilities_Fake.call>) => {
+    let {sent, _} = await pending
+    sent == expected
+      ? Outcome.pass
+      : Outcome.fail(
+          EventsMismatch({
+            expected: expected->Array.map(Capabilities_Fake.toJson),
+            actual: sent->Array.map(Capabilities_Fake.toJson),
+          }),
+        )
+  }
+  let thenNothingSent = pending => thenSent(pending, [])
+
+  let thenRetryRecorded = async (pending, expectedRetries) => {
+    let {retries, _} = await pending
+    retries == expectedRetries
+      ? Outcome.pass
+      : Outcome.fail(
+          StateMismatch({
+            key: "retries",
+            expected: Some(JSON.Encode.int(expectedRetries)),
+            actual: Some(JSON.Encode.int(retries)),
+          }),
+        )
+  }
+
+  let statusName = (s: status) =>
+    switch s {
+    | #Completed => "#Completed"
+    | #Failed | #Pending => "#Failed"
+    | #Abandoned => "#Abandoned"
+    }
+
+  let thenTodoStatus = async (pending, expectedId, expectedStatus: status) => {
+    let {id, status, _} = await pending
+    if id == expectedId && statusName(status) == statusName(expectedStatus) {
+      Outcome.pass
+    } else {
+      let encOne = (rid, s) =>
+        JSON.Encode.object(
+          Dict.fromArray([
+            ("id", JSON.Encode.string(rid)),
+            ("status", JSON.Encode.string(statusName(s))),
+          ]),
+        )
+      Outcome.fail(
+        StateMismatch({
+          key: id,
+          expected: Some(encOne(expectedId, expectedStatus)),
+          actual: Some(encOne(id, status)),
+        }),
+      )
+    }
+  }
+}