@reventlessdev/online-shop-hybrid-ordering 1.0.0-alpha.268 → 1.0.0-alpha.270

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.270 (2026-10-10)
+
+### Features
+
+* **gwt:** automation and translation tests take the slice as written, and the sidecars read them ([93a0919](https://github.com/ReventlessDev/reventless-core/commit/93a0919a0d66730cf9bf89144ad8fba3cb025332))
+
+
+# 1.0.0-alpha.269 (2026-10-08)
+
+**Note:** Version bump only for package @reventlessdev/online-shop-hybrid-ordering
+
+
+
+
+
 # 1.0.0-alpha.268 (2026-10-08)
 
 **Note:** Version bump only for package @reventlessdev/online-shop-hybrid-ordering

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/online-shop-hybrid-ordering",
-  "version": "1.0.0-alpha.268",
+  "version": "1.0.0-alpha.270",
   "description": "Online Shop Hybrid example — Ordering plugin (Customer aggregate + Order/CatalogProduct DCB)",
   "license": "Apache-2.0",
   "jest": {
@@ -21,15 +21,15 @@
   },
   "dependencies": {
     "sury": "11.0.0",
-    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.156",
-    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.155",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.187",
+    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.158",
+    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.157",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.23",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.237",
-    "@reventlessdev/reventless-local": "3.0.0-alpha.280",
-    "@reventlessdev/trait-notification": "1.0.0-alpha.39",
-    "@reventlessdev/trait-address-geocoding": "1.0.0-alpha.39",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.159"
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.239",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.189",
+    "@reventlessdev/reventless-local": "3.0.0-alpha.282",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.161",
+    "@reventlessdev/trait-address-geocoding": "1.0.0-alpha.41",
+    "@reventlessdev/trait-notification": "1.0.0-alpha.41"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/tests/Customer/OutboundTranslation/GeocodeCustomerAddress_GWT.res

@@ -2,15 +2,9 @@
 // log, which is what makes `~sourceId` load-bearing: an aggregate's event payload
 // does not name its own subject.
 //
-// `OutboundTranslation_GWT.Make` expects a single SliceSpec with `collect` at the
-// top level, so compose it on locally. The graft rules — keying, outage-vs-verdict —
-// are asserted by the trait's suite in `AddressGeocodingConformance_GWT.res`; what
-// stays here is the host-specific wording of the answers.
-
-module GeocodeCustomerAddressSlice = {
-  include GeocodeCustomerAddress
-  let collect = GeocodeCustomerAddress_Translation.collect
-}
+// The graft rules — keying, outage-vs-verdict — are asserted by the trait's suite
+// in `AddressGeocodingConformance_GWT.res`; what stays here is the host-specific
+// wording of the answers.
 
 @@reventless.gwt
 
@@ -18,20 +12,8 @@ open Ordering_Examples
 
 let vienna: Reventless.GeoPoint.t = {lat: 48.2082, lng: 16.3738}
 
-// The real `translate`, driven by a stub geocoder. `whenTranslateMocked` takes any
-// (id, item) => promise<translateResult>, so no DSL verb is needed to reach it.
-let withGeocoder = (
-  answer: result<array<Reventless.Geocoding.candidate>, Reventless.Geocoding.failure>,
-) => {
-  // Spread `none` and override the one capability under test: a literal record
-  // would have to name every other capability the framework grows, and this test
-  // has nothing to say about them.
-  let capabilities: Reventless.Capabilities.t = {
-    ...Reventless.Capabilities.none,
-    geocode: (~text as _) => Promise.resolve(answer),
-  }
-  (id, item) => GeocodeCustomerAddress_Translation.translate(id, item, ~capabilities)
-}
+// The real `translate`, against a geocoder that answers `answer`.
+let geocoder = answer => fakes(~geocode=async (~text as _) => answer, ())
 
 describe("GeocodeCustomerAddress OutboundTranslationSlice", () => {
   // scenario-id: 8b319e75-7826-4d3d-bd88-a43a197fb014
@@ -63,8 +45,8 @@ describe("GeocodeCustomerAddress OutboundTranslationSlice", () => {
         address: viennaAddress,
       },
     )
-    ->whenTranslateMocked(
-      withGeocoder(
+    ->givenCapabilities(
+      geocoder(
         Ok([
           {
             label: "Stephansplatz 1, Vienna",
@@ -74,6 +56,7 @@ describe("GeocodeCustomerAddress OutboundTranslationSlice", () => {
         ]),
       ),
     )
+    ->whenTranslated
     ->thenCommand("cust-1", SetLocation({location: vienna, resolvedFrom: viennaAddress}))
   )
 
@@ -82,8 +65,8 @@ describe("GeocodeCustomerAddress OutboundTranslationSlice", () => {
   // scenario-id: 93103dd6-1304-42b1-83f9-fd4ac4a90160
   test("translate: an ambiguous answer produces a reason naming the candidates", () =>
     givenTodo("cust-1:Springfield", {customerId: cust1, address: "Springfield"})
-    ->whenTranslateMocked(
-      withGeocoder(
+    ->givenCapabilities(
+      geocoder(
         Ok([
           {
             label: "Springfield, IL",
@@ -98,6 +81,7 @@ describe("GeocodeCustomerAddress OutboundTranslationSlice", () => {
         ]),
       ),
     )
+    ->whenTranslated
     ->thenCommand(
       "cust-1",
       MarkAddressUnresolvable({
@@ -106,4 +90,34 @@ describe("GeocodeCustomerAddress OutboundTranslationSlice", () => {
       }),
     )
   )
+
+  // The address is what is asked, as written.
+  test("translate: the geocoder is asked for the address as written", () =>
+    givenTodo("cust-1:Stephansplatz 1, Vienna", {customerId: cust1, address: viennaAddress})
+    ->givenCapabilities(geocoder(Ok([])))
+    ->whenTranslated
+    ->thenSent([Geocoded({text: viennaAddress})])
+  )
+
+  // An outage is not a verdict: the row stays open for the next sweep.
+  test("translate: a geocoder that is down leaves the row to be retried", () =>
+    givenTodo("cust-1:Stephansplatz 1, Vienna", {customerId: cust1, address: viennaAddress})
+    ->givenCapabilities(geocoder(Error(Unavailable("timeout"))))
+    ->whenTranslated
+    ->thenTodoStatus("cust-1:Stephansplatz 1, Vienna", #Failed)
+  )
+
+  // The budget ran out with the geocoder never answering: the verdict is recorded
+  // rather than leaving the row pending forever.
+  test("exhausted: the address is recorded as unresolvable", () =>
+    givenTodo("cust-1:Stephansplatz 1, Vienna", {customerId: cust1, address: viennaAddress})
+    ->whenExhausted(~lastError="timeout")
+    ->thenCommand(
+      "cust-1",
+      MarkAddressUnresolvable({
+        address: viennaAddress,
+        reason: GeocodeCustomerAddress_Translation.Geocode.exhaustedReason(Some("timeout")),
+      }),
+    )
+  )
 })

package/tests/Customer/OutboundTranslation/GeocodeCustomerAddress_GWT.res.mjs

@@ -1,14 +1,14 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
 import * as Ordering_Examples$OrderingPlugin from "../../Ordering_Examples.res.mjs";
 import * as GeocodeCustomerAddress$OrderingPlugin from "../../../src/Customer/OutboundTranslation/GeocodeCustomerAddress.res.mjs";
 import * as OutboundTranslation_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/OutboundTranslation_GWT.res.mjs";
+import * as AddressGeocoding_Translate$TraitAddressGeocoding from "@reventlessdev/trait-address-geocoding/src/AddressGeocoding_Translate.res.mjs";
 import * as GeocodeCustomerAddress_Translation$OrderingPlugin from "../../../src/Customer/OutboundTranslation/GeocodeCustomerAddress_Translation.res.mjs";
 
-let GeocodeCustomerAddressSlice = {
+let include = OutboundTranslation_GWT$ReventlessGwt.FromSlice({
   name: GeocodeCustomerAddress$OrderingPlugin.name,
-  Id: GeocodeCustomerAddress$OrderingPlugin.Id,
+  moduleUrl: GeocodeCustomerAddress$OrderingPlugin.moduleUrl,
   consumedEventSchema: GeocodeCustomerAddress$OrderingPlugin.consumedEventSchema,
   outboundItemSchema: GeocodeCustomerAddress$OrderingPlugin.outboundItemSchema,
   inboundCommandSchema: GeocodeCustomerAddress$OrderingPlugin.inboundCommandSchema,
@@ -18,17 +18,12 @@ let GeocodeCustomerAddressSlice = {
   sourceNames: GeocodeCustomerAddress$OrderingPlugin.sourceNames,
   externalSystem: GeocodeCustomerAddress$OrderingPlugin.externalSystem,
   capabilityNeeds: GeocodeCustomerAddress$OrderingPlugin.capabilityNeeds,
-  traits: GeocodeCustomerAddress$OrderingPlugin.traits,
-  moduleUrl: GeocodeCustomerAddress$OrderingPlugin.moduleUrl,
-  collect: GeocodeCustomerAddress_Translation$OrderingPlugin.collect
-};
-
-let include = OutboundTranslation_GWT$ReventlessGwt.Make({
-  name: GeocodeCustomerAddress$OrderingPlugin.name,
-  consumedEventSchema: GeocodeCustomerAddress$OrderingPlugin.consumedEventSchema,
-  outboundItemSchema: GeocodeCustomerAddress$OrderingPlugin.outboundItemSchema,
-  inboundCommandSchema: GeocodeCustomerAddress$OrderingPlugin.inboundCommandSchema,
-  collect: GeocodeCustomerAddress_Translation$OrderingPlugin.collect
+  traits: GeocodeCustomerAddress$OrderingPlugin.traits
+})({
+  collect: GeocodeCustomerAddress_Translation$OrderingPlugin.collect,
+  translate: GeocodeCustomerAddress_Translation$OrderingPlugin.translate,
+  onExhausted: GeocodeCustomerAddress_Translation$OrderingPlugin.onExhausted,
+  moduleUrl: GeocodeCustomerAddress_Translation$OrderingPlugin.moduleUrl
 });
 
 let describe = include.describe;
@@ -37,10 +32,20 @@ let test = include.test;
 
 let givenTodo = include.givenTodo;
 
+let fakes = include.fakes;
+
+let givenCapabilities = include.givenCapabilities;
+
+let whenTranslated = include.whenTranslated;
+
 let whenTranslateMocked = include.whenTranslateMocked;
 
+let whenExhausted = include.whenExhausted;
+
 let thenCommand = include.thenCommand;
 
+let thenSent = include.thenSent;
+
 let thenTodoStatus = include.thenTodoStatus;
 
 let vienna = {
@@ -48,18 +53,8 @@ let vienna = {
   lng: 16.3738
 };
 
-function withGeocoder(answer) {
-  let capabilities_geocode = param => Promise.resolve(answer);
-  let capabilities_messaging = Capabilities$Reventless.none.messaging;
-  let capabilities_identityProvider = Capabilities$Reventless.none.identityProvider;
-  let capabilities_secrets = Capabilities$Reventless.none.secrets;
-  let capabilities = {
-    geocode: capabilities_geocode,
-    messaging: capabilities_messaging,
-    identityProvider: capabilities_identityProvider,
-    secrets: capabilities_secrets
-  };
-  return (id, item) => GeocodeCustomerAddress_Translation$OrderingPlugin.translate(id, item, capabilities);
+function geocoder(answer) {
+  return fakes(async param => answer, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
 }
 
 describe("GeocodeCustomerAddress OutboundTranslationSlice", () => {
@@ -77,25 +72,25 @@ describe("GeocodeCustomerAddress OutboundTranslationSlice", () => {
       }
     ]
   })), "cust-1:Stephansplatz 1, Vienna", "Completed"));
-  test("translate: a confident answer produces SetLocation", undefined, () => thenCommand(whenTranslateMocked(givenTodo("cust-1:Stephansplatz 1, Vienna", {
+  test("translate: a confident answer produces SetLocation", undefined, () => thenCommand(whenTranslated(givenCapabilities(givenTodo("cust-1:Stephansplatz 1, Vienna", {
     customerId: Ordering_Examples$OrderingPlugin.cust1,
     address: Ordering_Examples$OrderingPlugin.viennaAddress
-  }), withGeocoder({
+  }), geocoder({
     TAG: "Ok",
     _0: [{
         label: "Stephansplatz 1, Vienna",
         point: vienna,
         relevance: 0.995
       }]
-  })), "cust-1", {
+  }))), "cust-1", {
     TAG: "SetLocation",
     location: vienna,
     resolvedFrom: Ordering_Examples$OrderingPlugin.viennaAddress
   }));
-  test("translate: an ambiguous answer produces a reason naming the candidates", undefined, () => thenCommand(whenTranslateMocked(givenTodo("cust-1:Springfield", {
+  test("translate: an ambiguous answer produces a reason naming the candidates", undefined, () => thenCommand(whenTranslated(givenCapabilities(givenTodo("cust-1:Springfield", {
     customerId: Ordering_Examples$OrderingPlugin.cust1,
     address: "Springfield"
-  }), withGeocoder({
+  }), geocoder({
     TAG: "Ok",
     _0: [
       {
@@ -109,46 +104,96 @@ describe("GeocodeCustomerAddress OutboundTranslationSlice", () => {
         relevance: 0.985
       }
     ]
-  })), "cust-1", {
+  }))), "cust-1", {
     TAG: "MarkAddressUnresolvable",
     address: "Springfield",
     reason: `"Springfield" matched "Springfield, IL" and "Springfield, MA" about equally well`
   }));
+  test("translate: the geocoder is asked for the address as written", undefined, () => thenSent(whenTranslated(givenCapabilities(givenTodo("cust-1:Stephansplatz 1, Vienna", {
+    customerId: Ordering_Examples$OrderingPlugin.cust1,
+    address: Ordering_Examples$OrderingPlugin.viennaAddress
+  }), geocoder({
+    TAG: "Ok",
+    _0: []
+  }))), [{
+      TAG: "Geocoded",
+      text: Ordering_Examples$OrderingPlugin.viennaAddress
+    }]));
+  test("translate: a geocoder that is down leaves the row to be retried", undefined, () => thenTodoStatus(whenTranslated(givenCapabilities(givenTodo("cust-1:Stephansplatz 1, Vienna", {
+    customerId: Ordering_Examples$OrderingPlugin.cust1,
+    address: Ordering_Examples$OrderingPlugin.viennaAddress
+  }), geocoder({
+    TAG: "Error",
+    _0: {
+      TAG: "Unavailable",
+      _0: "timeout"
+    }
+  }))), "cust-1:Stephansplatz 1, Vienna", "Failed"));
+  test("exhausted: the address is recorded as unresolvable", undefined, () => thenCommand(whenExhausted(givenTodo("cust-1:Stephansplatz 1, Vienna", {
+    customerId: Ordering_Examples$OrderingPlugin.cust1,
+    address: Ordering_Examples$OrderingPlugin.viennaAddress
+  }), "timeout"), "cust-1", {
+    TAG: "MarkAddressUnresolvable",
+    address: Ordering_Examples$OrderingPlugin.viennaAddress,
+    reason: AddressGeocoding_Translate$TraitAddressGeocoding.exhaustedReason("timeout")
+  }));
 });
 
-let Spec = include.Spec;
-
 let testSync = include.testSync;
 
+let encItems = include.encItems;
+
+let commandPairJson = include.commandPairJson;
+
+let errorOf = include.errorOf;
+
 let givenEvent = include.givenEvent;
 
 let whenCollect = include.whenCollect;
 
 let thenTodos = include.thenTodos;
 
+let attemptWith = include.attemptWith;
+
+let attempts = include.attempts;
+
 let whenTranslateRetrying = include.whenTranslateRetrying;
 
 let thenNoCommand = include.thenNoCommand;
 
+let thenNothingSent = include.thenNothingSent;
+
 let thenRetryRecorded = include.thenRetryRecorded;
 
+let statusName = include.statusName;
+
 export {
-  GeocodeCustomerAddressSlice,
-  Spec,
   describe,
   test,
   testSync,
+  encItems,
+  commandPairJson,
+  errorOf,
   givenEvent,
   whenCollect,
   thenTodos,
   givenTodo,
+  fakes,
+  givenCapabilities,
+  attemptWith,
+  attempts,
+  whenTranslated,
   whenTranslateMocked,
   whenTranslateRetrying,
+  whenExhausted,
   thenCommand,
   thenNoCommand,
+  thenSent,
+  thenNothingSent,
   thenRetryRecorded,
+  statusName,
   thenTodoStatus,
   vienna,
-  withGeocoder,
+  geocoder,
 }
 /* include Not a pure module */

package/tests/Customer/OutboundTranslation/VerifyCustomerEmail_GWT.res

@@ -6,66 +6,41 @@
 // predict, and this file would otherwise be able to check only that *something*
 // was sent.
 
-module VerifyCustomerEmailSlice = {
-  include VerifyCustomerEmail
-  let collect = VerifyCustomerEmail_Translation.collect
-}
-
 @@reventless.gwt
 
 module Outcome = ReventlessGwt.Outcome
 
 let item: VerifyCustomerEmail.outboundItem = {customerId: "c1", email: "alice@x.y"}
 
-// What the run put on the wire, in both directions: the bodies that went to the
-// address, and the commands that reached the ledger.
-let bodies: ref<array<string>> = ref([])
-let issued: ref<array<string>> = ref([])
-
 // A known secret and a hash obviously derived from it, so an assertion can name
 // both. `hashed:` is not what the real backend computes — what matters is that
 // whatever the source produced is what the ledger was told about.
-let withSecrets = (~send): Reventless.Capabilities.t => {
-  ...Reventless.Capabilities.none,
-  secrets: Reventless.Secrets.fixed(~token="known-secret", ~hash=t => `hashed:${t}`),
-  messaging: Reventless.Messaging.makeProvider(~emailAndSms=[Email], ~pushServices=[], ~send),
-}
-
-// No secret source at all: `Capabilities.none` refuses, and messaging is wired
-// so the refusal cannot be mistaken for a mail problem.
-let withoutSecrets = (~send): Reventless.Capabilities.t => {
-  ...Reventless.Capabilities.none,
-  messaging: Reventless.Messaging.makeProvider(~emailAndSms=[Email], ~pushServices=[], ~send),
-}
-
-let accepts = (~recipient as _, ~message: Reventless.Messaging.message) => {
-  bodies := bodies.contents->Array.concat([message.body])
-  Promise.resolve(Ok({Reventless.Messaging.ref: "ses-1"}))
-}
-
-let refuses = failure => (~recipient as _, ~message as _) => Promise.resolve(Error(failure))
-
-// Records what reached the ledger, because the command carries an instant read
-// from the clock and so cannot be compared whole.
-let run = capabilities => {
-  bodies := []
-  issued := []
-  async (id, item) => {
-    let attempt = await VerifyCustomerEmail_Translation.translate(id, item, ~capabilities)
-    switch attempt {
-    | Ok(Some((_, IssueEmailChallenge({proofHash, email, purpose, _})))) =>
-      issued := issued.contents->Array.concat([`${email}|${purpose}|${proofHash}`])
-    | _ => ()
-    }
-    attempt
-  }
-}
+let withSecrets = (~send=?, ()) =>
+  fakes(~token="known-secret", ~hash=t => `hashed:${t}`, ~channels=[Email], ~send?, ())
+
+// No secret source at all, and messaging wired so the refusal cannot be
+// mistaken for a mail problem.
+let withoutSecrets = () =>
+  fakes(~secrets=Reventless.Secrets.unavailable(~reason="none provisioned"), ~channels=[Email], ())
+
+let refuses = failure => async (~recipient as _, ~message as _) => Error(failure)
 
-let alsoThat = async (pending, ~expected, holds) =>
-  switch await pending {
-  | Error(_) as failed => failed
-  | Ok() =>
-    holds() ? Outcome.pass : Outcome.fail(TranslateError({expected, actual: Some("it did not")}))
+// The challenge mail, as the slice words it for this secret.
+let challengeMail: ReventlessGwt.Capabilities_Fake.call = Sent({
+  recipient: ContactVerification.ByEmail("alice@x.y")->ContactVerification.toRecipient,
+  message: {subject: "Confirm your email address", body: body(~token="known-secret")},
+})
+
+// What reached the ledger. The command carries an instant read from the clock,
+// so it cannot be compared whole.
+let thenLedgerTold = async (pending, expected) =>
+  switch (await pending).result {
+  | Ok(Some((_, IssueEmailChallenge({proofHash, email, purpose, _})))) =>
+    let actual = `${email}|${purpose}|${proofHash}`
+    actual == expected
+      ? Outcome.pass
+      : Outcome.fail(TranslateError({expected, actual: Some(actual)}))
+  | _ => Outcome.fail(TranslateError({expected, actual: None}))
   }
 
 describe("VerifyCustomerEmail OutboundTranslationSlice", () => {
@@ -74,23 +49,21 @@ describe("VerifyCustomerEmail OutboundTranslationSlice", () => {
   // scenario-id: 866cd8c0-c30b-4049-85e1-98359a252c49
   test("a sent challenge is opened against the hash, never the secret", () =>
     givenTodo("c1:alice@x.y", item)
-    ->whenTranslateMocked(run(withSecrets(~send=accepts)))
-    ->thenTodoStatus("c1:alice@x.y", #Completed)
-    ->alsoThat(
-      ~expected="the ledger is told alice@x.y|ContactChange|hashed:known-secret",
-      () => issued.contents == ["alice@x.y|ContactChange|hashed:known-secret"],
-    )
+    ->givenCapabilities(withSecrets())
+    ->whenTranslated
+    ->thenLedgerTold("alice@x.y|ContactChange|hashed:known-secret")
   )
 
   // scenario-id: dea4775c-9c1f-41e2-bd54-751b308c65cd
   test("the secret itself is what goes to the address", () =>
     givenTodo("c1:alice@x.y", item)
-    ->whenTranslateMocked(run(withSecrets(~send=accepts)))
-    ->thenTodoStatus("c1:alice@x.y", #Completed)
-    ->alsoThat(
-      ~expected="the message carries known-secret",
-      () => bodies.contents->Array.some(body => body->String.includes("known-secret")),
-    )
+    ->givenCapabilities(withSecrets())
+    ->whenTranslated
+    ->thenSent([
+      TokenDrawn({length: policy.proofLength, alphabet: policy.proofAlphabet}),
+      Hashed({input: "known-secret"}),
+      challengeMail,
+    ])
   )
 
   // 🚨 Send first, then record. A challenge opened against a message that never
@@ -99,19 +72,21 @@ describe("VerifyCustomerEmail OutboundTranslationSlice", () => {
   // scenario-id: 7de712d8-9930-41a2-977d-137639e38812
   test("a refused send opens no challenge", () =>
     givenTodo("c1:alice@x.y", item)
-    ->whenTranslateMocked(
-      run(withSecrets(~send=refuses(Reventless.Messaging.Refused("no such mailbox")))),
+    ->givenCapabilities(
+      withSecrets(~send=refuses(Reventless.Messaging.Refused("no such mailbox")), ()),
     )
-    ->thenTodoStatus("c1:alice@x.y", #Pending)
+    ->whenTranslated
+    ->thenTodoStatus("c1:alice@x.y", #Failed)
   )
 
   // scenario-id: a04b17e9-d691-40d3-a431-894a1c75e9f2
   test("an unreachable provider opens no challenge either", () =>
     givenTodo("c1:alice@x.y", item)
-    ->whenTranslateMocked(
-      run(withSecrets(~send=refuses(Reventless.Messaging.Unavailable("smtp timeout")))),
+    ->givenCapabilities(
+      withSecrets(~send=refuses(Reventless.Messaging.Unavailable("smtp timeout")), ()),
     )
-    ->thenTodoStatus("c1:alice@x.y", #Pending)
+    ->whenTranslated
+    ->thenTodoStatus("c1:alice@x.y", #Failed)
   )
 
   // A deployment with no secret source cannot prove anything. That is a gap in
@@ -120,16 +95,17 @@ describe("VerifyCustomerEmail OutboundTranslationSlice", () => {
   // scenario-id: 70d4d062-1ba5-4d77-8e27-8af0f98d4bd8
   test("no secret source opens no challenge", () =>
     givenTodo("c1:alice@x.y", item)
-    ->whenTranslateMocked(run(withoutSecrets(~send=accepts)))
-    ->thenTodoStatus("c1:alice@x.y", #Pending)
+    ->givenCapabilities(withoutSecrets())
+    ->whenTranslated
+    ->thenTodoStatus("c1:alice@x.y", #Failed)
   )
 
   // scenario-id: 29f4868d-b099-401f-9609-913f6c55bddf
   test("no secret source sends nothing either", () =>
     givenTodo("c1:alice@x.y", item)
-    ->whenTranslateMocked(run(withoutSecrets(~send=accepts)))
-    ->thenTodoStatus("c1:alice@x.y", #Pending)
-    ->alsoThat(~expected="no message was sent", () => bodies.contents == [])
+    ->givenCapabilities(withoutSecrets())
+    ->whenTranslated
+    ->thenSent([TokenDrawn({length: policy.proofLength, alphabet: policy.proofAlphabet})])
   )
 })