honk / test / procedure_data_validation_test.gleam

import gleam/json
import gleeunit
import gleeunit/should
import honk/validation/context
import honk/validation/primary/procedure

pub fn main() {
  gleeunit.main()
}

// Test valid procedure input (object)
pub fn valid_procedure_input_object_test() {
  let schema =
    json.object([
      #("type", json.string("procedure")),
      #(
        "input",
        json.object([
          #("encoding", json.string("application/json")),
          #(
            "schema",
            json.object([
              #("type", json.string("object")),
              #("required", json.array([json.string("text")], fn(x) { x })),
              #(
                "properties",
                json.object([
                  #(
                    "text",
                    json.object([
                      #("type", json.string("string")),
                      #("maxLength", json.int(300)),
                    ]),
                  ),
                  #(
                    "langs",
                    json.object([
                      #("type", json.string("array")),
                      #(
                        "items",
                        json.object([#("type", json.string("string"))]),
                      ),
                    ]),
                  ),
                ]),
              ),
            ]),
          ),
        ]),
      ),
    ])

  let data =
    json.object([
      #("text", json.string("Hello world")),
      #("langs", json.array([json.string("en")], fn(x) { x })),
    ])

  let assert Ok(ctx) = context.builder() |> context.build()
  procedure.validate_data(data, schema, ctx) |> should.be_ok
}

// Test invalid: missing required field
pub fn invalid_procedure_missing_required_test() {
  let schema =
    json.object([
      #("type", json.string("procedure")),
      #(
        "input",
        json.object([
          #("encoding", json.string("application/json")),
          #(
            "schema",
            json.object([
              #("type", json.string("object")),
              #("required", json.array([json.string("text")], fn(x) { x })),
              #(
                "properties",
                json.object([
                  #("text", json.object([#("type", json.string("string"))])),
                ]),
              ),
            ]),
          ),
        ]),
      ),
    ])

  let data = json.object([#("description", json.string("No text field"))])

  let assert Ok(ctx) = context.builder() |> context.build()
  procedure.validate_data(data, schema, ctx) |> should.be_error
}

// Test procedure with no input
pub fn valid_procedure_no_input_test() {
  let schema = json.object([#("type", json.string("procedure"))])

  let data = json.object([])

  let assert Ok(ctx) = context.builder() |> context.build()
  procedure.validate_data(data, schema, ctx) |> should.be_ok
}

// Test valid output validation
pub fn valid_procedure_output_test() {
  let schema =
    json.object([
      #("type", json.string("procedure")),
      #(
        "output",
        json.object([
          #("encoding", json.string("application/json")),
          #(
            "schema",
            json.object([
              #("type", json.string("object")),
              #(
                "properties",
                json.object([
                  #("uri", json.object([#("type", json.string("string"))])),
                  #("cid", json.object([#("type", json.string("string"))])),
                ]),
              ),
            ]),
          ),
        ]),
      ),
    ])

  let data =
    json.object([
      #("uri", json.string("at://did:plc:abc/app.bsky.feed.post/123")),
      #("cid", json.string("bafyreiabc123")),
    ])

  let assert Ok(ctx) = context.builder() |> context.build()
  procedure.validate_output_data(data, schema, ctx) |> should.be_ok
}

// Test invalid output data
pub fn invalid_procedure_output_wrong_type_test() {
  let schema =
    json.object([
      #("type", json.string("procedure")),
      #(
        "output",
        json.object([
          #("encoding", json.string("application/json")),
          #(
            "schema",
            json.object([
              #("type", json.string("object")),
              #(
                "properties",
                json.object([
                  #("count", json.object([#("type", json.string("integer"))])),
                ]),
              ),
            ]),
          ),
        ]),
      ),
    ])

  let data = json.object([#("count", json.string("not-a-number"))])

  let assert Ok(ctx) = context.builder() |> context.build()
  procedure.validate_output_data(data, schema, ctx) |> should.be_error
}

// Test procedure with union input
pub fn valid_procedure_union_input_test() {
  let schema =
    json.object([
      #("type", json.string("procedure")),
      #(
        "input",
        json.object([
          #("encoding", json.string("application/json")),
          #(
            "schema",
            json.object([
              #("type", json.string("union")),
              #(
                "refs",
                json.array(
                  [json.string("#typeA"), json.string("#typeB")],
                  fn(x) { x },
                ),
              ),
            ]),
          ),
        ]),
      ),
    ])

  let data = json.object([#("$type", json.string("#typeA"))])

  let assert Ok(ctx) = context.builder() |> context.build()
  // This will fail because union needs the actual definitions
  // but it tests that we're dispatching correctly
  case procedure.validate_data(data, schema, ctx) {
    Ok(_) -> Ok(Nil)
    Error(_) -> Ok(Nil)
  }
  |> should.be_ok
}