openhub-bo-core 0.1.0

data/ext/openhub_bo_core/vendor/openhub-bo-core/src/envelope.rs

@@ -0,0 +1,374 @@
+//! Response envelopes. OpenHub wraps payloads differently per product family;
+//! each [`Envelope`] strategy turns an HTTP response into the payload or a
+//! typed [`Error`], so operations only deal with their own data.
+
+use serde::Deserialize;
+use serde::de::DeserializeOwned;
+use serde_json::Value;
+
+use crate::error::{ApiFieldError, Error, Result};
+use crate::http::HttpResponse;
+
+pub trait Envelope {
+    fn open<T: DeserializeOwned>(response: &HttpResponse) -> Result<T>;
+}
+
+/// QR Simple / MLD-BCB: `{success, message, data | errors[]}`.
+pub struct SuccessData;
+
+/// PIX / virtual assets / Binance: flat body with a top-level
+/// `codigoRespuesta`; the whole body is the payload. Errors seen in the
+/// sandbox come in three shapes, all handled here:
+/// - `{codigoRespuesta: "ERROR", detalleRespuesta: "... - GQ-00005"}` (HTTP 200)
+/// - `{error: true, code: "EG-00002", message, data: [..] | null}` (HTTP 400/500)
+/// - `{success: false, message, errors: [..]}` (HTTP 400, virtual assets)
+pub struct CodigoRespuesta;
+
+/// Payouts / merchant accounts: `{code: "00", data, message | errorMessage, errorCode}`.
+pub struct CodeData;
+
+const BODY_PREVIEW: usize = 200;
+
+#[derive(Deserialize)]
+struct SuccessWire {
+    #[serde(default)]
+    success: Option<bool>,
+    #[serde(default)]
+    message: Option<String>,
+    data: Option<Value>,
+    #[serde(default)]
+    errors: Vec<ApiFieldError>,
+}
+
+impl SuccessWire {
+    fn into_error(self, response: &HttpResponse) -> Error {
+        Error::business(
+            response.status,
+            self.message.unwrap_or_else(|| failed(response)),
+            self.errors,
+        )
+    }
+}
+
+impl Envelope for SuccessData {
+    fn open<T: DeserializeOwned>(response: &HttpResponse) -> Result<T> {
+        let wire: SuccessWire = json_body(response)?;
+        if wire.success == Some(false) {
+            return Err(wire.into_error(response));
+        }
+        if !response.is_success() {
+            return Err(Error::api(
+                response.status,
+                wire.message.unwrap_or_else(|| failed(response)),
+                wire.errors,
+            ));
+        }
+        let data = wire
+            .data
+            .ok_or_else(|| Error::decode("response has no `data` field"))?;
+        decode_payload(data)
+    }
+}
+
+impl Envelope for CodigoRespuesta {
+    fn open<T: DeserializeOwned>(response: &HttpResponse) -> Result<T> {
+        let body: Value = json_body(response)?;
+
+        if body.get("error").and_then(Value::as_bool) == Some(true) {
+            return Err(gateway_error(response, &body));
+        }
+        if body.get("success").and_then(Value::as_bool) == Some(false) {
+            let wire: SuccessWire = decode_payload(body)?;
+            return Err(wire.into_error(response));
+        }
+        let code = body.get("codigoRespuesta").and_then(Value::as_str);
+        if code.is_some_and(|c| c.eq_ignore_ascii_case("ERROR")) {
+            let detail = text_field(&body, &["detalleRespuesta", "message"])
+                .unwrap_or_else(|| failed(response));
+            // Backend codes travel at the end of the detail: "... - GQ-00005".
+            let backend_code = detail
+                .rsplit_once(" - ")
+                .map(|(_, c)| c.trim())
+                .filter(|c| c.starts_with("GQ-"))
+                .map(str::to_owned);
+            return Err(Error::business(
+                response.status,
+                detail.clone(),
+                vec![ApiFieldError {
+                    field: None,
+                    message: detail,
+                    code: backend_code.or_else(|| Some("ERROR".to_owned())),
+                }],
+            ));
+        }
+        if !response.is_success() {
+            let message = text_field(&body, &["detalleRespuesta", "message"])
+                .unwrap_or_else(|| failed(response));
+            return Err(Error::api(response.status, message, Vec::new()));
+        }
+        decode_payload(body)
+    }
+}
+
+impl Envelope for CodeData {
+    fn open<T: DeserializeOwned>(response: &HttpResponse) -> Result<T> {
+        let mut body: Value = json_body(response)?;
+        let code = body.get("code").and_then(Value::as_str).map(str::to_owned);
+        let rejected = code.as_deref().is_some_and(|c| c != "00");
+        if rejected || !response.is_success() {
+            let message =
+                text_field(&body, &["errorMessage", "message"]).unwrap_or_else(|| failed(response));
+            let error_code = text_field(&body, &["errorCode"]).or(code);
+            // Validation errors list every message in `data`, or join them
+            // with "; " in the message (both seen in the sandbox).
+            let mut details = string_list(body.get("data"));
+            if details.is_empty() && message.contains("; ") {
+                details = message.split("; ").map(str::to_owned).collect();
+            }
+            let errors = if details.is_empty() {
+                vec![ApiFieldError {
+                    field: None,
+                    message: message.clone(),
+                    code: error_code,
+                }]
+            } else {
+                details
+                    .into_iter()
+                    .map(|detail| ApiFieldError {
+                        field: None,
+                        message: detail,
+                        code: error_code.clone(),
+                    })
+                    .collect()
+            };
+            return Err(if rejected {
+                Error::business(response.status, message, errors)
+            } else {
+                Error::api(response.status, message, errors)
+            });
+        }
+        // Most responses nest the payload in `data`; some (batch status) are flat.
+        let payload = match body.get_mut("data").map(Value::take) {
+            Some(data) if !data.is_null() => data,
+            _ => body,
+        };
+        decode_payload(payload)
+    }
+}
+
+/// `{error: true, code, message, data: [messages] | null}` from the gateway layer.
+fn gateway_error(response: &HttpResponse, body: &Value) -> Error {
+    let code = text_field(body, &["code"]);
+    let message = text_field(body, &["message"]).unwrap_or_else(|| failed(response));
+    let details = string_list(body.get("data"));
+    let errors = if details.is_empty() {
+        vec![ApiFieldError {
+            field: None,
+            message: message.clone(),
+            code,
+        }]
+    } else {
+        details
+            .into_iter()
+            .map(|detail| ApiFieldError {
+                field: None,
+                message: detail,
+                code: code.clone(),
+            })
+            .collect()
+    };
+    Error::business(response.status, message, errors)
+}
+
+fn string_list(value: Option<&Value>) -> Vec<String> {
+    value
+        .and_then(Value::as_array)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(Value::as_str)
+                .map(str::to_owned)
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+/// Auth failures and non-JSON bodies are handled the same for every family.
+fn json_body<T: DeserializeOwned>(response: &HttpResponse) -> Result<T> {
+    if matches!(response.status, 401 | 403) {
+        return Err(Error::Authentication {
+            status: response.status,
+            message: message_from_body(&response.body),
+        });
+    }
+    serde_json::from_str(&response.body).map_err(|e| {
+        if response.is_success() {
+            Error::decode(format!("invalid JSON body: {e}"))
+        } else {
+            Error::api(response.status, preview(&response.body), Vec::new())
+        }
+    })
+}
+
+fn decode_payload<T: DeserializeOwned>(value: Value) -> Result<T> {
+    serde_json::from_value(value)
+        .map_err(|e| Error::decode(format!("unexpected payload shape: {e}")))
+}
+
+fn text_field(body: &Value, keys: &[&str]) -> Option<String> {
+    keys.iter()
+        .filter_map(|k| body.get(*k).and_then(Value::as_str))
+        .map(str::trim)
+        .find(|s| !s.is_empty())
+        .map(str::to_owned)
+}
+
+fn failed(response: &HttpResponse) -> String {
+    format!("request failed with HTTP {}", response.status)
+}
+
+/// Best-effort human message from an arbitrary error body.
+pub fn message_from_body(body: &str) -> String {
+    if let Ok(value) = serde_json::from_str::<Value>(body) {
+        if let Some(text) = text_field(&value, &["error_description", "message", "error"]) {
+            return text;
+        }
+    }
+    preview(body)
+}
+
+fn preview(body: &str) -> String {
+    let trimmed = body.trim();
+    if trimmed.is_empty() {
+        return "empty response body".to_owned();
+    }
+    trimmed.chars().take(BODY_PREVIEW).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn api_err(result: Result<Value>) -> (u16, String, Vec<ApiFieldError>, bool) {
+        match result {
+            Err(Error::Api {
+                status,
+                message,
+                errors,
+                retryable,
+            }) => (status, message, errors, retryable),
+            other => panic!("expected Api error, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn plain_text_gateway_errors_are_retryable() {
+        let (status, _, _, retryable) = api_err(SuccessData::open(&HttpResponse::new(
+            502,
+            "Error forwarding call",
+        )));
+        assert_eq!(status, 502);
+        assert!(retryable);
+    }
+
+    #[test]
+    fn auth_failures_win_over_body_parsing() {
+        let err = CodeData::open::<Value>(&HttpResponse::new(401, "Access Token ... is invalid"))
+            .unwrap_err();
+        assert!(matches!(err, Error::Authentication { status: 401, .. }));
+    }
+
+    #[test]
+    fn codigo_respuesta_returns_whole_body() {
+        // Documented PIX status response.
+        let body = r#"{"codigoRespuesta":"CANCELLED","detalleRespuesta":"Transaccion cancelada",
+            "data":{"numeroReferencia":"6780","monto":696.0}}"#;
+        let value: Value = CodigoRespuesta::open(&HttpResponse::new(200, body)).unwrap();
+        assert_eq!(value["codigoRespuesta"], "CANCELLED");
+        assert_eq!(value["data"]["numeroReferencia"], "6780");
+    }
+
+    #[test]
+    fn codigo_respuesta_error_extracts_backend_code() {
+        // Sandbox: merchant not enabled for PIX.
+        let body = r#"{"codigoRespuesta":"ERROR","detalleRespuesta":"El ID de comercio no está habilitado para utilizar el servicio PIX - GQ-00005"}"#;
+        let (status, message, errors, retryable) =
+            api_err(CodigoRespuesta::open(&HttpResponse::new(200, body)));
+        assert_eq!(status, 200);
+        assert!(message.contains("no está habilitado"));
+        assert_eq!(errors[0].code.as_deref(), Some("GQ-00005"));
+        assert!(!retryable);
+
+        let plain = r#"{"codigoRespuesta":"ERROR","detalleRespuesta":"Transacción no encontrada","data":null}"#;
+        let (_, _, errors, _) = api_err(CodigoRespuesta::open(&HttpResponse::new(200, plain)));
+        assert_eq!(errors[0].code.as_deref(), Some("ERROR"));
+    }
+
+    #[test]
+    fn gateway_business_errors_with_500_are_not_retryable() {
+        // Sandbox: PIX answers "not found" with HTTP 500.
+        let body =
+            r#"{"data":null,"error":true,"code":"EG-00001","message":"Transacción no encontrada"}"#;
+        let (status, message, errors, retryable) =
+            api_err(CodigoRespuesta::open(&HttpResponse::new(500, body)));
+        assert_eq!(
+            (status, message.as_str()),
+            (500, "Transacción no encontrada")
+        );
+        assert_eq!(errors[0].code.as_deref(), Some("EG-00001"));
+        assert!(!retryable);
+    }
+
+    #[test]
+    fn gateway_validation_lists_every_message() {
+        let body = r#"{"data":["glosa no puede estar vacía","cpf no puede ser nulo"],"error":true,"code":"EG-00002","message":"Errores de validación"}"#;
+        let (status, _, errors, _) = api_err(CodigoRespuesta::open(&HttpResponse::new(400, body)));
+        assert_eq!(status, 400);
+        assert_eq!(errors.len(), 2);
+        assert_eq!(errors[1].message, "cpf no puede ser nulo");
+        assert_eq!(errors[1].code.as_deref(), Some("EG-00002"));
+    }
+
+    #[test]
+    fn codigo_respuesta_accepts_success_false_errors() {
+        // Sandbox: virtual assets validation uses the QR-family shape.
+        let body = r#"{"success":false,"message":"Error de validación","errors":[{"field":"monto","message":"El monto mínimo permitido es 50","code":"INVALID_VALUE"}]}"#;
+        let (status, _, errors, _) = api_err(CodigoRespuesta::open(&HttpResponse::new(400, body)));
+        assert_eq!(status, 400);
+        assert_eq!(errors[0].field.as_deref(), Some("monto"));
+    }
+
+    #[test]
+    fn code_data_success_and_failure() {
+        let ok = r#"{"data":{"nit":"1023149021"},"code":"00","errorCode":null,"errorMessage":""}"#;
+        let data: Value = CodeData::open(&HttpResponse::new(200, ok)).unwrap();
+        assert_eq!(data["nit"], "1023149021");
+
+        // Batch status responses are flat.
+        let flat = r#"{"code":"00","message":"ok","nroLote":"L1","transacciones":[]}"#;
+        let data: Value = CodeData::open(&HttpResponse::new(200, flat)).unwrap();
+        assert_eq!(data["nroLote"], "L1");
+
+        // Sandbox: validation lists every message.
+        let invalid = r#"{"data":["Debe enviar el nit.","Debe enviar al menos una cuenta."],"code":"02","errorMessage":"Error de validación de solicitud"}"#;
+        let (_, _, errors, _) = api_err(CodeData::open(&HttpResponse::new(200, invalid)));
+        assert_eq!(errors.len(), 2);
+        assert_eq!(errors[1].message, "Debe enviar al menos una cuenta.");
+        assert_eq!(errors[1].code.as_deref(), Some("02"));
+
+        let joined = r#"{"code":"02","errorMessage":"El campo 'transaccionId' es obligatorio; El campo 'importe' es obligatorio"}"#;
+        let (status, _, errors, _) = api_err(CodeData::open(&HttpResponse::new(400, joined)));
+        assert_eq!(status, 400);
+        assert_eq!(errors[1].message, "El campo 'importe' es obligatorio");
+
+        let missing = r#"{"code":"04","errorMessage":"Transacción no encontrada."}"#;
+        let (status, message, errors, retryable) =
+            api_err(CodeData::open(&HttpResponse::new(200, missing)));
+        assert_eq!(
+            (status, message.as_str()),
+            (200, "Transacción no encontrada.")
+        );
+        assert_eq!(errors[0].code.as_deref(), Some("04"));
+        assert!(!retryable);
+    }
+}

data/ext/openhub_bo_core/vendor/openhub-bo-core/src/error.rs

@@ -0,0 +1,123 @@
+use serde::{Deserialize, Serialize};
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Field-level error as reported by OpenHub in `errors[]`.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ApiFieldError {
+    #[serde(default)]
+    pub field: Option<String>,
+    pub message: String,
+    #[serde(default)]
+    pub code: Option<String>,
+}
+
+/// Every failure the core can report. Serialized with a `kind` tag so bindings
+/// can map it to idiomatic exception types.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error, Serialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum Error {
+    /// Input rejected locally, before reaching OpenHub.
+    #[error("invalid `{field}`: {message}")]
+    Validation { field: String, message: String },
+
+    /// Credentials or access token rejected (HTTP 401/403). Hosts should drop
+    /// the cached token and retry once.
+    #[error("authentication failed (HTTP {status}): {message}")]
+    Authentication { status: u16, message: String },
+
+    /// OpenHub answered with an error. Build it with [`Error::api`] or
+    /// [`Error::business`] so `retryable` is set consistently.
+    #[error("OpenHub error (HTTP {status}): {message}")]
+    Api {
+        status: u16,
+        message: String,
+        errors: Vec<ApiFieldError>,
+        /// Whether repeating the call later may succeed.
+        retryable: bool,
+    },
+
+    /// OpenHub could not confirm whether a non-idempotent operation (e.g. a
+    /// payout) was applied. Query its status before trying again.
+    #[error("outcome unknown: {message}")]
+    Ambiguous {
+        message: String,
+        errors: Vec<ApiFieldError>,
+    },
+
+    /// The response could not be understood.
+    #[error("unexpected response: {message}")]
+    Decode { message: String },
+
+    /// Incoming webhook did not carry the expected auth header.
+    #[error("webhook rejected: {message}")]
+    WebhookAuth { message: String },
+
+    /// Unknown operation or malformed payload on the FFI boundary.
+    #[error("invalid FFI call: {message}")]
+    Ffi { message: String },
+}
+
+impl Error {
+    /// Whether repeating the same call later may succeed.
+    pub fn is_retryable(&self) -> bool {
+        matches!(
+            self,
+            Error::Api {
+                retryable: true,
+                ..
+            }
+        )
+    }
+
+    /// An error classified by HTTP status alone: gateway/backend failures
+    /// (5xx), timeouts (408) and throttling (429) are retryable.
+    pub fn api(status: u16, message: impl Into<String>, errors: Vec<ApiFieldError>) -> Self {
+        Error::Api {
+            status,
+            message: message.into(),
+            errors,
+            retryable: status >= 500 || matches!(status, 408 | 429),
+        }
+    }
+
+    /// A structured rejection from OpenHub's backend. Never retryable, even
+    /// when sent with HTTP 5xx (some FX endpoints answer "not found" with 500).
+    pub fn business(status: u16, message: impl Into<String>, errors: Vec<ApiFieldError>) -> Self {
+        Error::Api {
+            status,
+            message: message.into(),
+            errors,
+            retryable: false,
+        }
+    }
+
+    pub fn validation(field: &str, message: impl Into<String>) -> Self {
+        Error::Validation {
+            field: field.to_owned(),
+            message: message.into(),
+        }
+    }
+
+    pub fn decode(message: impl Into<String>) -> Self {
+        Error::Decode {
+            message: message.into(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn retryable_classification() {
+        let api = |status| Error::api(status, "", Vec::new());
+        assert!(api(502).is_retryable());
+        assert!(api(429).is_retryable());
+        assert!(!api(400).is_retryable());
+        assert!(!api(409).is_retryable());
+        assert!(!Error::business(500, "not found", Vec::new()).is_retryable());
+        assert!(!Error::validation("x", "y").is_retryable());
+    }
+}

data/ext/openhub_bo_core/vendor/openhub-bo-core/src/ffi.rs

@@ -0,0 +1,178 @@
+//! Language-neutral JSON boundary used by every binding.
+//!
+//! Each binding exposes one function, `call(op, payload) -> String`, backed by
+//! a [`Registry`]. The result is always an envelope:
+//! `{"ok": true, "value": ...}` or `{"ok": false, "error": {"kind", ..., "retryable"}}`.
+//! It never panics across the FFI.
+//!
+//! Op names:
+//! - `<operation>.build` with `{config, token?, input}` → `HttpRequest`
+//! - `<operation>.parse` with `{input, response}` → the operation's output
+//! - `<handler>` with the handler's input
+//! - `version`, `describe` (lists registered operations)
+
+use std::panic::{AssertUnwindSafe, catch_unwind};
+
+use serde::Deserialize;
+use serde::de::DeserializeOwned;
+pub use serde_json::Value as JsonValue;
+use serde_json::json;
+
+use crate::config::Config;
+use crate::error::{Error, Result};
+use crate::http::HttpResponse;
+use crate::operation::{Ctx, Handler, Operation, Registry};
+use crate::token::AccessToken;
+
+/// Bump when the payload/result contract changes incompatibly.
+pub const PROTOCOL_VERSION: u32 = 2;
+
+pub fn call(registry: &dyn Registry, op: &str, payload: &str) -> String {
+    let outcome = catch_unwind(AssertUnwindSafe(|| dispatch(registry, op, payload)))
+        .unwrap_or_else(|_| Err(ffi_error(format!("core panicked while handling `{op}`"))));
+    let envelope = match outcome {
+        Ok(value) => json!({ "ok": true, "value": value }),
+        Err(error) => {
+            let mut detail =
+                serde_json::to_value(&error).unwrap_or_else(|_| json!({ "kind": "ffi" }));
+            detail["retryable"] = error.is_retryable().into();
+            json!({ "ok": false, "error": detail })
+        }
+    };
+    envelope.to_string()
+}
+
+fn dispatch(registry: &dyn Registry, op: &str, payload: &str) -> Result<JsonValue> {
+    match op {
+        "version" => Ok(json!({
+            "core": env!("CARGO_PKG_VERSION"),
+            "protocol": PROTOCOL_VERSION,
+        })),
+        "describe" => to_value(registry.operations()),
+        _ => registry
+            .dispatch(op, payload)
+            .unwrap_or_else(|| Err(ffi_error(format!("unknown operation `{op}`")))),
+    }
+}
+
+#[derive(Deserialize)]
+struct Build<I> {
+    config: Config,
+    #[serde(default)]
+    token: Option<AccessToken>,
+    input: I,
+}
+
+#[derive(Deserialize)]
+struct Parse<I> {
+    input: I,
+    response: HttpResponse,
+}
+
+/// Runs one stage of an operation. Used by [`registry!`](crate::registry).
+pub fn run<O: Operation>(stage: &str, payload: &str) -> Result<JsonValue> {
+    match stage {
+        "build" => {
+            let p: Build<O::Input> = parse(payload)?;
+            to_value(O::request(
+                &Ctx::new(&p.config, p.token.as_ref()),
+                &p.input,
+            )?)
+        }
+        "parse" => {
+            let p: Parse<O::Input> = parse(payload)?;
+            to_value(O::response(&p.response, &p.input)?)
+        }
+        other => Err(ffi_error(format!(
+            "unknown stage `{other}` for `{}`",
+            O::NAME
+        ))),
+    }
+}
+
+/// Runs a handler. Used by [`registry!`](crate::registry).
+pub fn run_handler<H: Handler>(payload: &str) -> Result<JsonValue> {
+    to_value(H::handle(parse(payload)?)?)
+}
+
+fn parse<T: DeserializeOwned>(payload: &str) -> Result<T> {
+    serde_json::from_str(payload).map_err(|e| ffi_error(format!("invalid payload: {e}")))
+}
+
+fn to_value<T: serde::Serialize>(value: T) -> Result<JsonValue> {
+    serde_json::to_value(value).map_err(|e| ffi_error(e.to_string()))
+}
+
+fn ffi_error(message: String) -> Error {
+    Error::Ffi { message }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::CoreOps;
+
+    fn run_op(op: &str, payload: JsonValue) -> JsonValue {
+        serde_json::from_str(&call(&CoreOps, op, &payload.to_string())).unwrap()
+    }
+
+    #[test]
+    fn round_trips_token_flow() {
+        let config = json!({"client_id": "id", "client_secret": "s", "environment": "production"});
+        let request = run_op(
+            "token.build",
+            json!({ "config": config, "input": {"now": 0} }),
+        );
+        assert_eq!(request["ok"], true);
+        assert!(
+            request["value"]["url"]
+                .as_str()
+                .unwrap()
+                .starts_with("https://api.redenlace.com.bo/")
+        );
+
+        let body = include_str!("../../../fixtures/openhub/token_response.json");
+        let token = run_op(
+            "token.parse",
+            json!({ "input": {"now": 0}, "response": {"status": 201, "body": body} }),
+        );
+        assert_eq!(token["value"]["expires_at"], 3540);
+    }
+
+    #[test]
+    fn errors_are_tagged_and_classified() {
+        let missing = run_op(
+            "token.build",
+            json!({ "config": {"client_id": "id"}, "input": {"now": 0} }),
+        );
+        assert_eq!(missing["error"]["kind"], "validation");
+        assert_eq!(missing["error"]["retryable"], false);
+
+        let gateway = run_op(
+            "token.parse",
+            json!({ "input": {"now": 0}, "response": {"status": 503, "body": "down"} }),
+        );
+        assert_eq!(gateway["error"]["kind"], "authentication");
+    }
+
+    #[test]
+    fn unknown_op_stage_and_bad_json_do_not_panic() {
+        for (op, payload) in [
+            ("nope", "{}"),
+            ("token.nope", "{}"),
+            ("token.parse", "not json"),
+        ] {
+            let result: JsonValue = serde_json::from_str(&call(&CoreOps, op, payload)).unwrap();
+            assert_eq!(result["error"]["kind"], "ffi", "{op}");
+        }
+    }
+
+    #[test]
+    fn describe_lists_operations() {
+        let described = run_op("describe", json!({}));
+        assert_eq!(
+            described["value"],
+            json!([{"kind": "operation", "name": "token", "idempotent": true}])
+        );
+    }
+}