Current section

Files

Jump to
oaspec src oaspec mock.gleam
Raw

src/oaspec/mock.gleam

//// Test helpers for `oaspec/transport`. The sync constructors return a
//// `transport.Send` value, and the `*_async` constructors return a
//// `transport.AsyncSend`, making it trivial to script fake responses in
//// tests without standing up a real HTTP runtime.
import oaspec/transport.{
type AsyncSend, type Request, type Response, type Send, type TransportError,
BytesBody, EmptyBody, Response, TextBody,
}
// Always respond with the given text body and status. Headers are empty.
pub fn text(status status: Int, body body: String) -> Send {
fn(_req: Request) {
Ok(Response(status: status, headers: [], body: TextBody(body)))
}
}
// Async variant of `text`.
pub fn text_async(status status: Int, body body: String) -> AsyncSend {
fn(_req: Request) {
transport.resolve(
Ok(Response(status: status, headers: [], body: TextBody(body))),
)
}
}
// Always respond with the given binary body and status. Headers are empty.
pub fn bytes(status status: Int, body body: BitArray) -> Send {
fn(_req: Request) {
Ok(Response(status: status, headers: [], body: BytesBody(body)))
}
}
// Async variant of `bytes`.
pub fn bytes_async(status status: Int, body body: BitArray) -> AsyncSend {
fn(_req: Request) {
transport.resolve(
Ok(Response(status: status, headers: [], body: BytesBody(body))),
)
}
}
// Always respond with the given status and an empty body.
pub fn empty(status status: Int) -> Send {
fn(_req: Request) {
Ok(Response(status: status, headers: [], body: EmptyBody))
}
}
// Async variant of `empty`.
pub fn empty_async(status status: Int) -> AsyncSend {
fn(_req: Request) {
transport.resolve(
Ok(Response(status: status, headers: [], body: EmptyBody)),
)
}
}
// Always fail with `transport.Timeout`.
pub fn timeout() -> Send {
fn(_req: Request) { Error(transport.Timeout) }
}
// Async variant of `timeout`.
pub fn timeout_async() -> AsyncSend {
fn(_req: Request) { transport.resolve(Error(transport.Timeout)) }
}
// Always fail with the given `TransportError`.
pub fn fail(error error: TransportError) -> Send {
fn(_req: Request) { Error(error) }
}
// Async variant of `fail`.
pub fn fail_async(error error: TransportError) -> AsyncSend {
fn(_req: Request) { transport.resolve(Error(error)) }
}
// Build a `Send` from an arbitrary handler — useful for asserting on
// the outbound request shape in tests.
pub fn from(
handler handler: fn(Request) -> Result(Response, TransportError),
) -> Send {
handler
}
// Build an `AsyncSend` from an arbitrary async handler.
pub fn from_async(
handler handler: fn(Request) ->
transport.Async(Result(Response, TransportError)),
) -> AsyncSend {
handler
}