kiosk-test-support 0.5.20

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 82f1f47c2715da7a7ef6897038c156d7033991f159d7dea50446ee3af8933d01
+  data.tar.gz: 0b06db9324f1ea8d0e7e11036f756db6e4eef3fffc9899961506e95f0f999183
+SHA512:
+  metadata.gz: 4b1c2beec651bb6bb2836c28cb5440903d113867d91f33bce3bdd42625c5d34336b0916332e39b3d92b60d5633668074decb3c5c2169597fd6c036c7b274595f
+  data.tar.gz: 66c9376f8e27a37bd455f503fa34f1617d8e7e790eb348fc44075494cc81e386f9e1ec23593a86f011781ec537909ec5a14a2feba01f7cb4fa4cee1684ccbbc9

data/CHANGELOG.md

@@ -0,0 +1,149 @@
+# Changelog
+
+All notable changes follow [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and [Semantic Versioning](https://semver.org/).
+
+How to write an entry, and what a release section means: `CHANGELOG-RULE.md` at
+the root of this repository —
+<https://github.com/kiosk-hq/kiosk/blob/main/CHANGELOG-RULE.md>. In short: under
+200 characters, one or two sentences, the essence rather than the content; write it
+under `## [Unreleased]`; a cut renames that heading to
+`## [MAJOR.MINOR.PATCH] — <date>` and opens a fresh empty one above it; nothing
+already written is edited.
+
+## [Unreleased]
+
+## [0.5.20] — 2026-10-20
+
+- 2026-10-20: `InProcessOrigin` and `InProcessExecutor` call a verb through its route with a linked assistant's token; `InProcessWire` does the call.
+- 2026-10-20: The conformance checks hold an action's arguments to its `input_schema` with no exemption for `limit` or `cursor`, as the wire does.
+
+## [0.5.19] — 2026-10-20
+
+- 2026-10-19: `Wire` and `Assistant::Events` connect to a base URL that names an IPv6 literal, such as `http://[::1]:3001`.
+
+## [0.5.18] — 2026-10-18
+
+- 2026-10-18: Version 0.5.18, the tree cut that matches skill 0.5.18.
+
+## [0.5.17] — 2026-10-18
+
+- 2026-10-18: `StripeMock` runs one stripe-mock per process on free ports unless `STRIPE_MOCK_URL` names one; `StripeMock.url` replaces `URL`.
+
+## [0.5.16] — 2026-10-18
+
+- 2026-10-18: The Stripe test front answers a refund that names no charge with a 400, as Stripe does.
+
+## [0.5.15] — 2026-10-18
+
+- 2026-10-18: `Kiosk::TestHelpers::Customer#pays_cart(cart, scope:)` signs the `cart` an action answered with and pays.
+
+- 2026-10-18: `Kiosk::StoryTest#assert_refused(answer, code)` asserts a wire refusal and prints the answer when it fails.
+
+- 2026-10-18: Declares `puma`, which the live server helper requires; a RubyGems install no longer fails to load it.
+
+## [0.5.14] — 2026-10-18
+
+- 2026-10-18: Version 0.5.14, the tree cut that matches skill 0.5.14.
+
+- 2026-10-17: New `kiosk/test_helpers/small_equihash`: required from test setup, it makes the Equihash default n=96 k=5 so test registrations stay fast.
+
+- 2026-10-17: Adds InProcessExecutor and Conformance::InProcessOrigin, moved from kiosk-server. Require them explicitly; they run against the host's kiosk-server.
+
+- 2026-10-17: `Assistant#pay` calls `payment_setup` when `pay` answers `payment_setup_required`, then pays once more.
+
+- 2026-10-17: `Customer#leaves` is removed; nothing called it.
+- 2026-10-17: `Person#links_a_newcomer` links a newly keyed assistant to the signed-in person, for scripts that need a bound principal.
+
+## [0.5.13] — 2026-10-11
+
+- 2026-10-11: Version 0.5.13, the tree cut that matches skill 0.5.13.
+
+- 2026-10-09: **A story's `Person` links, approves and unlinks assistants**, and a `Customer` pays a quote, signs back in, follows news checked against its schema; `kiosk/story_spec` is RSpec's form.
+
+- 2026-10-09: **`Kiosk::StoryTest` and `Kiosk::TestHelpers::Story`** let a test tell an operator's business story through a `Customer` who asks, does, pays and hears.
+
+- 2026-10-09: **`Assistant` drives an origin as an assistant does; `Kyc` stands in for the KYC provider** so a test decides how a check ends. `Wire` and `StripeMock` move here.
+
+- 2026-10-09: **`LiveServer` and `SeededDatabase`** serve the app over HTTP from the test process on committed, seeded data; **`DescriptorExamples`** checks each published example against its schema.
+
+## [0.5.12] — 2026-10-08
+
+- 2026-10-08: Version 0.5.12, the tree cut that matches skill 0.5.12; this gem's surface is unchanged.
+
+## [0.5.11] — 2026-10-08
+
+- 2026-10-08: Version 0.5.11, the tree cut that matches skill 0.5.11; this gem's surface is unchanged.
+
+## [0.5.10] — 2026-10-08
+
+- 2026-10-08: Version 0.5.10, the tree cut that matches skill 0.5.10; this gem's surface is unchanged.
+
+## [0.5.9] — 2026-10-08
+
+- 2026-10-08: Version 0.5.9, the tree cut that matches skill 0.5.9; this gem's surface is unchanged.
+
+## [0.5.8] — 2026-10-07
+
+- 2026-10-07: Version 0.5.8, the tree cut that matches skill 0.5.8; this gem's surface is unchanged.
+
+## [0.5.7] — 2026-10-07
+
+- 2026-10-07: Version 0.5.7, the tree cut that matches skill 0.5.7; this gem's surface is unchanged.
+
+## [0.5.6] — 2026-10-07
+
+- 2026-10-07: Version 0.5.6, the tree cut that matches skill 0.5.6; this gem's surface is unchanged.
+
+## [0.5.5] — 2026-10-07
+
+- 2026-10-07: Version 0.5.5, the tree cut that matches skill 0.5.5; this gem's surface is unchanged.
+
+## [0.5.4] — 2026-10-07
+
+- 2026-10-07: Version 0.5.4, the tree cut that matches skill 0.5.4; this gem's surface is unchanged.
+
+## [0.5.3] — 2026-10-06
+
+- 2026-10-06: Version 0.5.3, the tree cut that matches skill 0.5.3; this gem's surface is unchanged.
+
+## [0.5.2] — 2026-10-06
+
+- 2026-10-06: Version 0.5.2, the tree cut that matches skill 0.5.2; this gem's surface is unchanged.
+
+## [0.5.0] — 2026-09-26
+
+### Removed
+
+- **`NullExecutor#identity_stack` is no longer public, and `enqueue_action` is now `enqueue_run_action` (K-1708).** Ask `current_identity`; every rig helper is named for the kind it queues.
+
+- **`Conformance::Verb#action?` and `Conformance::Outcome#to_s`, neither of which had a caller anywhere (K-1703).** `kind` and `message` are public and say the same.
+
+### Changed
+
+- **`have_a_route_for_every_verb` took no block parameter, so `origin:` was accepted and discarded (K-1702).** It now honours the keyword its Minitest twin honours.
+
+- **The published journey-helper roll-call was short by `run_query` (K-1696).** The lists name it now, and the two «helpers are available» tests are held to the module rather than to themselves.
+
+- The route conformance check no longer special-cases the engine's refusal controller, which no longer exists: a declared verb whose route is missing is reported as declared-and-never-routed, which is what every caller now meets as an ordinary 404.
+- README: every `gem` line in the install section now carries `github: "kiosk-hq/kiosk"`, so a copied line resolves before publication; the banner above them states what the block does rather than asking the reader to add it.
+- Dropped the `kiosk-rls` dependency (RLS is opt-in now). This gem never
+  used `Kiosk::RLS` constants — `Errors::RLSDenied` is its own class and
+  stays.
+
+### Added
+
+- `Kiosk::TestHelpers::Conformance` — four checks an origin runs against itself for the four properties the protocol makes normative of it: that its routes resolve, that a verb executes, that a query answers the shape it declared, and that data access is scoped to the authenticated principal. Inert until an origin is wired (`Conformance.origin=`); `kiosk-server` ships the real one.
+- Two adapters, loaded by explicit require so this gem still depends on no test framework: `kiosk/test_helpers/conformance/minitest` (`assert_kiosk_verbs_routed`, `assert_kiosk_verb_executes`, `assert_kiosk_answer_matches_declared_schema`, `assert_kiosk_scoped_to_principal`) and `kiosk/test_helpers/conformance/rspec` (`have_a_route_for_every_verb`, `execute_as_a_kiosk_verb`, `answer_its_declared_schema`, `be_scoped_to_principal`). Both render the same failure sentence.
+- `Kiosk::TestHelpers::Conformance::NullOrigin` — the zero-dependency reference implementation of the origin contract, for unit-shaped tests with no Rails and no database.
+- `Journey#run_query(name, **args)` and a matching `run_query` on the executor contract. `query` takes SQL; without this, a declared `kind :query` verb was reachable through nothing.
+- `Errors::OriginNotConfigured` and `Errors::SchemaValidatorMissing`, both carrying wiring instructions.
+
+- Initial skeleton.
+- `Kiosk::TestHelpers::Journey` module — the journey-test DSL: `as_agent_of`, `as_user`, `as_agent`, `as_anonymous`, `query`, `run_action`, `pay_action`, `kiosk_seed`.
+- Pluggable executor contract — `Kiosk::TestHelpers.executor=` accepts any object responding to `with_identity(identity, &block)`, `query(sql)`, `run_action(name, args)`, `pay_action(name, args)`, `seed(table, attrs, count:)`. Default is unset; raises `Kiosk::TestHelpers::Errors::ExecutorNotConfigured` until wired.
+- `Kiosk::TestHelpers::NullExecutor` — records calls into an inspectable array; queues seeded results. Used by this gem's own specs and by `kiosk-rls-rspec` / `kiosk-rls-minitest` self-tests; `kiosk-server` ships the real `Kiosk::Server::TestExecutor` for production-shaped tests.
+- `Kiosk::TestHelpers::Errors` — `RLSDenied`, `QuotaExceeded`, `ExecutorNotConfigured`. Used by the framework-specific matchers / assertions.
+
+### Notes on the three-gem split
+
+The journey-test DSL was originally scoped to live inside `kiosk-rls-rspec` and `kiosk-rls-minitest`. We split the shared module out into this third gem so both harness gems can `include Kiosk::TestHelpers::Journey` without duplication or one harness depending on the other. The two harness gems remain ≤200 LOC each (framework wiring only); the shared DSL fits in ≤400 LOC here.

data/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,146 @@
+# kiosk-test-support
+
+Test helpers for [Kiosk](https://kiosk.tech) origins, and the journey-test DSL of the Kiosk test harnesses.
+
+## What it does
+
+- `Kiosk::TestHelpers::Assistant` — registers, pays tolls, queries, runs actions, pays and listens for events against an origin, as an AI assistant does.
+- `Kiosk::TestHelpers::Wire` — the same transport without a principal: any method, any path, any headers.
+- `Kiosk::StoryTest` / `Kiosk::TestHelpers::Story` — a test told as a business story by customers' assistants and the people on the operator's site.
+- `Kiosk::TestHelpers::Kyc` — stands in for the operator's KYC provider, so a test decides how an identity check ends.
+- `Kiosk::TestHelpers::StripeMock` — starts a local stripe-mock that answers a confirmed charge as paid.
+- `Kiosk::TestHelpers::LiveServer` — serves the app over HTTP from the test process and gives the test an assistant for it.
+- `Kiosk::TestHelpers::SeededDatabase` — each test starts from the seeds and leaves the database empty.
+- `Kiosk::TestHelpers::DescriptorExamples` — the examples a served `/kiosk/schema` publishes, each checked against its schema.
+
+Carries the shared pieces of the Kiosk journey-test DSL: the `Journey` module mixed into RSpec / Minitest tests, the pluggable `executor` contract, a `NullExecutor` for self-tests, and the structured error classes that the framework-specific matchers and assertions look for.
+
+The journey DSL comes with one of the harnesses:
+
+> **Not on RubyGems yet** — so every `gem` line below carries `github: "kiosk-hq/kiosk"`, which is what makes it copy-pasteable today. Publication status and the canonical install are stated once, in the monorepo README's [Install](https://github.com/kiosk-hq/kiosk#install) section.
+
+```ruby
+group :test do
+  gem "kiosk-rls-rspec", github: "kiosk-hq/kiosk"       # RSpec
+  # or
+  gem "kiosk-rls-minitest", github: "kiosk-hq/kiosk"    # Minitest
+end
+```
+
+Both harnesses pull `kiosk-test-support` as a transitive dependency.
+
+## DSL
+
+```ruby
+as_agent_of(alice) do
+  run_action :create_order, items: ["bread"]
+end
+
+as_user(alice) do
+  expect(query("select item from orders")).to contain_exactly({ item: "bread" })
+end
+
+as_anonymous do
+  expect { query("select * from orders") }.to be_rls_denied
+end
+```
+
+Helpers: `as_agent_of(user, role:)`, `as_user(user, role:)`, `as_agent(name)`, `as_anonymous`, `query(sql)`, `run_query(name, **args)`, `run_action(name, **args)`, `pay_action(name, **args)`, `kiosk_seed(table, count:, owner:, **attrs)`. See the `Kiosk::TestHelpers::Journey` docstrings for full semantics.
+
+## Wiring an executor
+
+The DSL is inert until you wire an executor. In production-shaped tests you wire `Kiosk::TestHelpers::InProcessExecutor`, which runs against `kiosk-server` in your Rails app:
+
+```ruby
+# spec/spec_helper.rb (RSpec) or test/test_helper.rb (Minitest)
+require "kiosk/test_helpers/in_process_executor"
+Kiosk::TestHelpers.executor = Kiosk::TestHelpers::InProcessExecutor.new
+```
+
+For unit-shaped tests where you only care about call ordering, use the bundled `NullExecutor`:
+
+```ruby
+Kiosk::TestHelpers.executor = Kiosk::TestHelpers::NullExecutor.new.tap do |e|
+  e.enqueue_query [{ item: "bread" }]
+end
+```
+
+The `NullExecutor` is the zero-dependency fallback for unit-shaped tests; production-shaped tests wire `Kiosk::TestHelpers::InProcessExecutor` (above).
+
+## Driving the wire as an assistant
+
+`Kiosk::TestHelpers::Assistant` registers, pays proof-of-work tolls, queries, runs, pays with signed mandates and listens on `<endpoint>/events`, against any origin — a test's own live server or a deployment:
+
+```ruby
+require "kiosk/test_helpers/assistant"
+
+assistant = Kiosk::TestHelpers::Assistant.new(base_url: live_url)
+rider     = assistant.register!
+events    = assistant.events(rider)
+events.subscribe("kyc_verification")
+assistant.run(rider, name: "reserve", scooter_code: "SK-001")
+```
+
+Every answer carries its status, parsed body and headers. `Kiosk::TestHelpers::Wire` is the same transport without a principal: any method, any path, any headers.
+
+## Telling a business story
+
+`Kiosk::StoryTest` (Minitest), or `require "kiosk/story_spec"` and `type: :story` (RSpec), serves the app from the test process and tells a story through `Customer`s, which a demo subclasses with its own business actions:
+
+```ruby
+class Shopper < Kiosk::TestHelpers::Customer
+  def orders(*skus) = does(:create_order, items: skus.map { { sku: _1, qty: 1 } })
+  def pays_for(order) = pays(total: order["total_cents"], scope: "grocery", line_items: [{ order_id: order["order_id"] }])
+end
+
+class ShopStory < Kiosk::StoryTest
+  test "a shopper orders and pays" do
+    shopper = a_customer(as: Shopper)
+    assert shopper.pays_for(shopper.orders("banana")).ok?
+  end
+end
+```
+
+- `a_customer(as:)` registers an assistant; `a_newcomer(as:)` holds a key and no account yet; `published(path)` reads what the origin shows anyone.
+- `Customer#asks` and `#does` answer an `Answer` (`ok?`, `refused?(code)`, `detail`, `hint`, `rows`, `header`, `tolls_paid`, `solved_toll`, `next_page`); `asks(…, unpaid: true)` or `asks(…, proofs: […])` leaves the toll to the story.
+- `Kiosk::StoryTest#assert_refused(answer, code)` asserts the wire refused the `Answer` with `code`.
+- `Customer#sets_up_payment` and `#requests_verification` run the engine's `payment_setup` and `request_kyc`, and `#hears_verification_passed` waits for the outcome of the check it asked for last; `#pays(total:, scope:, line_items:, currency:)` signs the intent, cart and payment mandates for a quote and pays; on `payment_setup_required` it calls `payment_setup` and pays once more.
+- `Customer#account`, `#role` and `#claims` read its credential; `#signs_back_in`, `#with_a_fresh_credential`, `#redeems(link_code)`, `#asks_to_be_linked`, `#polls` and `#collects` are the sign-in and linking ceremonies.
+- `Customer#listens_for`, `#follows(*topics, subject:, since:)` and `#hears(topic, about:, on:, **data)` read the event stream, holding each heard payload to the schema the origin publishes for its topic.
+- `a_person(email:, password:)` signs a person in on the operator's site through `kiosk-user-idp-devise`'s `DeviseSession`: `links(customer)`, `link_code`, `approves(user_code)`, `unlinks(customer)`, `visits(path)`.
+
+## Identity checks in tests
+
+A real identity check is a human showing documents to a provider; a test cannot do that, so `Kiosk::TestHelpers::Kyc` stands in for the operator's KYC provider for the length of each test and the test says how the check ends. The engine receives the provider's callback and runs the operator's code exactly as it would in production:
+
+```ruby
+require "kiosk/test_helpers/kyc"
+
+class LicenceStory < Kiosk::StoryTest   # or an RSpec group including Kiosk::TestHelpers::Story
+  include Kiosk::TestHelpers::Kyc
+
+  test "a motorcycle opens once the licence check passes" do
+    rider = a_customer
+    rider.requests_verification
+    the_verification_service_confirms(rider, age_over_18: true, licence_a: true)
+    assert rider.hears_verification_passed
+  end
+end
+```
+
+`kyc_attestation(principal, **attributes)` signs an attestation an assistant submits to `POST <endpoint>/agents/kyc`. A check the human refuses sends nothing, so there is no helper for it.
+
+`Kiosk::TestHelpers::StripeMock.start` fronts a local [stripe-mock](https://github.com/stripe/stripe-mock) that answers a confirmed charge as paid. stripe-mock lists a saved card for every Customer, so once `payment_setup` has mapped one, `pay` settles.
+
+## Status
+
+Pre-v1.0 alpha. The Journey DSL surface is stable across pre-v1.0 minor bumps; the executor contract may still evolve pre-v1.0 (`Kiosk::TestHelpers::InProcessExecutor` implements it today).
+
+## License
+
+Apache-2.0 — see `LICENSE.txt`.
+
+## Links
+
+- [kiosk.tech](https://kiosk.tech)
+- [Issue tracker](https://github.com/kiosk-hq/kiosk/issues)

data/lib/kiosk/story_spec.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'kiosk/test_helpers/story'
+
+# RSpec's form of Kiosk::StoryTest: every `type: :story` group tells a story.
+RSpec.configure { it.include Kiosk::TestHelpers::Story, type: :story }

data/lib/kiosk/story_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'active_support/test_case'
+require 'kiosk/test_helpers/story'
+
+module Kiosk
+  # Minitest's form of Kiosk::TestHelpers::Story; RSpec includes the module.
+  class StoryTest < ActiveSupport::TestCase
+    include TestHelpers::Story
+
+    # Asserts the wire refused `response` with `code`.
+    def assert_refused(response, code)
+      assert response.refused?(code), "expected a #{code} refusal, got #{response}"
+    end
+  end
+end

data/lib/kiosk/test_helpers/assistant/events.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'json_schemer'
+require 'openssl'
+require 'socket'
+require 'uri'
+require 'websocket/driver'
+
+module Kiosk
+  module TestHelpers
+    class Assistant
+      # The assistant's side of `<endpoint>/events`: one WebSocket, subscribed
+      # to topics, read until an event arrives.
+      #
+      #   events = assistant.events(rider)
+      #   events.subscribe("kyc_verification")
+      #   event = events.await { _1["topic"] == "kyc_verification" }
+      #   events.close
+      class Events
+        class Error < StandardError; end
+
+        # Every way an event's `data` breaks the `payload_schema` the origin serves
+        # for its topic, as "topic: error".
+        def self.payload_errors(schema_document, events)
+          schemas = Array(schema_document['events']).to_h { [it['name'], it['payload_schema']] }
+          events.flat_map do |event|
+            topic  = event['topic']
+            schema = schemas[topic] or next ["#{topic}: this origin serves no such topic"]
+            JSONSchemer.schema(schema, meta_schema: 'https://json-schema.org/draft/2020-12/schema')
+                       .validate(JSON.parse(JSON.generate(event['data'])))
+                       .map { "#{topic}: #{it['error']}" }
+          end
+        end
+
+        attr_reader :url
+
+        def initialize(base_url:, token:, path: '/kiosk/events', timeout: 10)
+          uri  = URI(base_url)
+          tls  = uri.scheme == 'https'
+          @url = "#{tls ? 'wss' : 'ws'}://#{uri.host}:#{uri.port}#{path}"
+          @io  = open_socket(uri.hostname, uri.port, tls)
+          @frames = []
+          @closed = false
+          @driver = start_driver(token)
+          pump(timeout) { @frames.any? { it['type'] == 'welcome' } } || raise(Error, "#{@url} did not welcome the connection")
+        end
+
+        # For the driver.
+        def write(data) = @io.write(data)
+
+        def subscribe(topic, timeout: 10, **params)
+          identifier = { 'channel' => 'KioskEvents', 'topic' => topic }.merge(params.transform_keys(&:to_s))
+          @driver.text(JSON.generate('command' => 'subscribe', 'identifier' => JSON.generate(identifier)))
+          frame = nil
+          pump(timeout) { frame = messages.find { it['type'] == 'subscribed' && it['topic'] == topic } }
+          frame || raise(Error, "subscribe to #{topic} was not confirmed")
+        end
+
+        def events = messages.select { it.key?('id') && it.key?('topic') }
+
+        def await(timeout: 30, &match) = await_in(:events, timeout, &match)
+
+        # Any message, including frames such as `{"type" => "unsubscribed", "reason" => "reach_revoked"}`.
+        def await_message(timeout: 30, &match) = await_in(:messages, timeout, &match)
+
+        # Reads for a fixed time, for asserting what did not arrive.
+        def listen(seconds)
+          pump(seconds) { false }
+          events
+        end
+
+        def close
+          @io.close
+        rescue IOError
+          nil
+        end
+
+        private
+
+        # A `ping` frame's message is a bare timestamp.
+        def messages = @frames.filter_map { it['message'] if it['message'].is_a?(Hash) }
+
+        def await_in(source, timeout, &)
+          found = nil
+          pump(timeout) { found = send(source).find(&) }
+          found || raise(Error, "nothing matching arrived within #{timeout}s")
+        end
+
+        def open_socket(host, port, tls)
+          tcp = TCPSocket.new(host, port)
+          return tcp unless tls
+
+          ssl = OpenSSL::SSL::SSLSocket.new(tcp, OpenSSL::SSL::SSLContext.new.tap(&:set_params))
+          ssl.hostname = host
+          ssl.sync_close = true
+          ssl.connect
+          ssl
+        end
+
+        def start_driver(token)
+          driver = WebSocket::Driver.client(self)
+          driver.set_header('Authorization', "Bearer #{token}")
+          driver.on(:message) { @frames << JSON.parse(it.data) }
+          driver.on(:close)   { @closed = true }
+          driver.on(:error)   { @closed = true }
+          driver.start
+          driver
+        end
+
+        def pump(seconds)
+          deadline = Time.now + seconds
+          until Time.now > deadline
+            return true if yield
+            break if @closed
+
+            read_frames if buffered? || @io.wait_readable(0.1)
+          end
+          yield
+        end
+
+        def read_frames
+          @driver.parse(@io.read_nonblock(8192))
+        rescue IO::WaitReadable
+          nil
+        rescue IOError, Errno::ECONNRESET
+          @closed = true
+        end
+
+        # TLS decrypts ahead of the socket.
+        def buffered? = @io.is_a?(OpenSSL::SSL::SSLSocket) && @io.pending.positive?
+      end
+    end
+  end
+end