relay/testing

Test support: an in-process client, MCP HTTP requests for a mounted handler, and verifiers with fixed answers.

connect(server, context) returns a relay/client.Client wired to the server through its own runtime: no port, no mist, the same wire messages. For other client settings, build the configuration with relay/client.in_process and connect it yourself.

request(method, params) builds the Request(BitArray) a Streamable HTTP client sends, with the protocol metadata and routing headers, for relay/http.handle; body_text reads the response. verifier and unavailable_verifier stand in for a token validator.

import json/blueprint/codec
import relay/client
import relay/server
import relay/testing
import relay/tool

pub fn say_test() {
  let input = {
    use text <- codec.field("text", codec.string(), get: fn(text) { text })
    codec.success(text)
  }
  let say = tool.define("say", input, codec.string())
  let peer = testing.connect(server.new([tool.handle(say, Ok)]), Nil)
  let assert Ok(client.Succeeded("hi", _)) = client.call(peer, say, "hi")
  client.close(peer)
}

pub fn body_text(
  response: response.Response(bytes_tree.BytesTree),
) -> String

pub fn connect(
  server: server.Server(context),
  context: context,
) -> client.Client

pub fn error(reason: client.Reason) -> client.Error

pub fn request(
  method: String,
  params: List(#(String, json.Json)),
) -> request.Request(BitArray)

pub fn unavailable_verifier() -> authorization.Verifier(principal)

pub fn verifier(
  tokens: List(#(String, authorization.Attestation(principal))),
) -> authorization.Verifier(principal)