simdjsont / test / test_readme.ml

let test_quick_start () =
  assert (Simdjsont.Validate.is_valid {|{"name": "Alice", "age": 30}|});
  let name =
    Simdjsont.Extract.string {|{"user": {"name": "Bob"}}|} ~pointer:"/user/name"
  in
  assert (name = Ok "Bob");
  let numbers =
    Simdjsont.Decode.decode_string Simdjsont.Decode.(list int) "[1, 2, 3]"
  in
  assert (numbers = Ok [ 1; 2; 3 ]);
  let json =
    Simdjsont.Encode.to_string Simdjsont.Decode.(list string) [ "a"; "b"; "c" ]
  in
  assert (json = {|["a","b","c"]|})

let test_validation () =
  assert (Simdjsont.Validate.is_valid "[1, 2, 3]");
  assert (not (Simdjsont.Validate.is_valid "{invalid"));
  match Simdjsont.Validate.check "null" with
  | Ok () -> ()
  | Error _ -> assert false

let test_extraction () =
  let json =
    {|{
    "users": [
      {"id": 1, "name": "Alice", "active": true},
      {"id": 2, "name": "Bob", "active": false}
    ],
    "count": 2
  }|}
  in
  assert (Simdjsont.Extract.string json ~pointer:"/users/0/name" = Ok "Alice");
  assert (Simdjsont.Extract.int json ~pointer:"/count" = Ok 2);
  assert (Simdjsont.Extract.int json ~pointer:"/users/1/id" = Ok 2);
  assert (Simdjsont.Extract.bool json ~pointer:"/users/0/active" = Ok true);
  assert (
    Simdjsont.Extract.is_null {|{"value": null}|} ~pointer:"/value" = Ok true)

let test_decoding_primitives () =
  assert (Simdjsont.Decode.decode_string Simdjsont.Decode.bool "true" = Ok true);
  assert (Simdjsont.Decode.decode_string Simdjsont.Decode.int "42" = Ok 42);
  assert (
    Simdjsont.Decode.decode_string Simdjsont.Decode.string {|"hello"|}
    = Ok "hello");
  assert (
    Simdjsont.Decode.decode_string Simdjsont.Decode.(list int) "[1, 2, 3, 4, 5]"
    = Ok [ 1; 2; 3; 4; 5 ]);
  assert (
    Simdjsont.Decode.decode_string Simdjsont.Decode.(optional string) "null"
    = Ok None)

type point = { x : int; y : int }

let point_codec =
  let open Simdjsont.Decode in
  Obj.field (fun x y -> { x; y })
  |> Obj.mem "x" int ~enc:(fun p -> p.x)
  |> Obj.mem "y" int ~enc:(fun p -> p.y)
  |> Obj.finish

let test_decoding_records () =
  match Simdjsont.Decode.decode_string point_codec {|{"x": 10, "y": 20}|} with
  | Ok p -> assert (p.x = 10 && p.y = 20)
  | Error _ -> assert false

type user = { id : int; name : string; email : string option }

let user_codec =
  let open Simdjsont.Decode in
  Obj.field (fun id name email -> { id; name; email })
  |> Obj.mem "id" int ~enc:(fun u -> u.id)
  |> Obj.mem "name" string ~enc:(fun u -> u.name)
  |> Obj.opt_mem "email" string ~enc:(fun u -> u.email)
  |> Obj.finish

let test_decoding_optional_fields () =
  let json = {|{"id": 1, "name": "Alice", "email": null}|} in
  match Simdjsont.Decode.decode_string user_codec json with
  | Ok user ->
      assert (user.id = 1);
      assert (user.name = "Alice");
      assert (user.email = None)
  | Error _ -> assert false

let test_encoding () =
  assert (Simdjsont.Encode.to_string Simdjsont.Decode.bool true = "true");
  assert (Simdjsont.Encode.to_string Simdjsont.Decode.int 42 = "42");
  assert (
    Simdjsont.Encode.to_string Simdjsont.Decode.string "hello" = {|"hello"|});
  assert (
    Simdjsont.Encode.to_string Simdjsont.Decode.(list int) [ 1; 2; 3 ]
    = "[1,2,3]");
  let p = { x = 100; y = 200 } in
  assert (Simdjsont.Encode.to_string point_codec p = {|{"x":100,"y":200}|})

type item = { name : string; price : float }

let item_codec =
  let open Simdjsont.Decode in
  Obj.field (fun name price -> { name; price })
  |> Obj.mem "name" string ~enc:(fun i -> i.name)
  |> Obj.mem "price" float ~enc:(fun i -> i.price)
  |> Obj.finish

let test_extract_with_codec () =
  let json =
    {|{
    "order": {
      "items": [
        {"name": "Book", "price": 12.99},
        {"name": "Pen", "price": 1.50}
      ]
    }
  }|}
  in
  match Simdjsont.Extract.at item_codec json ~pointer:"/order/items/0" with
  | Ok item ->
      assert (item.name = "Book");
      assert (abs_float (item.price -. 12.99) < 0.001)
  | Error _ -> assert false

let test_dynamic_json () =
  let open Simdjsont.Json in
  let json =
    Object
      [
        ("name", String "Alice");
        ("age", Int 30L);
        ("scores", Array [ Int 95L; Int 87L; Int 92L ]);
        ("active", Bool true);
      ]
  in
  let s = to_string json in
  assert (String.length s > 0);
  assert (String.sub s 0 1 = "{")

let test_dynamic_decode () =
  match
    Simdjsont.Decode.decode_string Simdjsont.Decode.value {|{"key": [1, 2, 3]}|}
  with
  | Ok v ->
      let s = Simdjsont.Json.to_string v in
      assert (s = {|{"key":[1,2,3]}|})
  | Error _ -> assert false

let test_low_level () =
  let open Simdjsont.Raw in
  let parser = create_parser () in
  match
    parse_string parser {|{"users": [{"name": "Alice"}, {"name": "Bob"}]}|}
  with
  | Ok root -> (
      (match at_pointer root "/users/1/name" with
      | Ok elt -> assert (string_exn elt = "Bob")
      | Error e -> failwith e.message);
      match at_pointer root "/users" with
      | Ok elt ->
          let arr = array_exn elt in
          let count = ref 0 in
          array_iter
            (fun user ->
              let obj = object_exn user in
              match object_find obj "name" with
              | Ok _ -> incr count
              | Error _ -> ())
            arr;
          assert (!count = 2)
      | Error e -> failwith e.message)
  | Error e -> failwith ("Parse error: " ^ e.message)

let () =
  Alcotest.run "readme"
    [
      ( "examples",
        [
          ("quick start", `Quick, test_quick_start);
          ("validation", `Quick, test_validation);
          ("extraction", `Quick, test_extraction);
          ("decoding primitives", `Quick, test_decoding_primitives);
          ("decoding records", `Quick, test_decoding_records);
          ("decoding optional fields", `Quick, test_decoding_optional_fields);
          ("encoding", `Quick, test_encoding);
          ("extract with codec", `Quick, test_extract_with_codec);
          ("dynamic json", `Quick, test_dynamic_json);
          ("dynamic decode", `Quick, test_dynamic_decode);
          ("low level", `Quick, test_low_level);
        ] );
    ]