repodb / test / test_embedded.ml

open Repodb

module YojsonJson : Embedded.JSON with type t = Yojson.Safe.t = struct
  type t = Yojson.Safe.t

  let null = `Null
  let to_string json = Yojson.Safe.to_string json

  let of_string s =
    try Ok (Yojson.Safe.from_string s) with Yojson.Json_error msg -> Error msg

  let get_field json key =
    match json with `Assoc fields -> List.assoc_opt key fields | _ -> None

  let get_string = function `String s -> Some s | _ -> None
  let get_int = function `Int i -> Some i | _ -> None

  let get_float = function
    | `Float f -> Some f
    | `Int i -> Some (float_of_int i)
    | _ -> None

  let get_bool = function `Bool b -> Some b | _ -> None
  let get_list = function `List l -> Some l | _ -> None
  let is_null = function `Null -> true | _ -> false
  let make_object fields = `Assoc fields
  let make_string s = `String s
  let make_int i = `Int i
  let make_float f = `Float f
  let make_bool b = `Bool b
  let make_list l = `List l
end

module E = Embedded.Make (YojsonJson)

type address = { street : string; city : string; zip : string }

let address_schema =
  E.schema ~name:"address"
    ~decode:(fun json ->
      match json with
      | `Assoc fields ->
          let get_string key =
            match List.assoc_opt key fields with
            | Some (`String s) -> s
            | _ -> ""
          in
          Ok
            {
              street = get_string "street";
              city = get_string "city";
              zip = get_string "zip";
            }
      | _ -> Error "Expected object")
    ~encode:(fun addr ->
      `Assoc
        [
          ("street", `String addr.street);
          ("city", `String addr.city);
          ("zip", `String addr.zip);
        ])
    ~fields:[ "street"; "city"; "zip" ]
    ()

let test_from_json () =
  let json =
    `Assoc
      [
        ("street", `String "123 Main St");
        ("city", `String "Springfield");
        ("zip", `String "12345");
      ]
  in
  match E.from_json address_schema json with
  | Ok embedded ->
      let data = E.data embedded in
      Alcotest.(check string) "street" "123 Main St" data.street;
      Alcotest.(check string) "city" "Springfield" data.city
  | Error msg -> Alcotest.fail msg

let test_to_json () =
  let addr = { street = "456 Oak Ave"; city = "Shelbyville"; zip = "67890" } in
  let embedded =
    { E.data = addr; fields = [ "street"; "city"; "zip" ]; source = E.Virtual }
  in
  let json = E.to_json address_schema embedded in
  match json with
  | `Assoc fields -> (
      match List.assoc_opt "street" fields with
      | Some (`String s) ->
          Alcotest.(check string) "street in json" "456 Oak Ave" s
      | _ -> Alcotest.fail "missing street")
  | _ -> Alcotest.fail "expected object"

let test_from_json_string () =
  let json_str = {|{"street":"789 Elm Blvd","city":"Capital","zip":"11111"}|} in
  match E.from_json_string address_schema json_str with
  | Ok embedded ->
      let data = E.data embedded in
      Alcotest.(check string) "parsed street" "789 Elm Blvd" data.street
  | Error msg -> Alcotest.fail msg

let test_to_json_string () =
  let addr = { street = "Test St"; city = "Test City"; zip = "00000" } in
  let embedded =
    { E.data = addr; fields = [ "street"; "city"; "zip" ]; source = E.Virtual }
  in
  let json_str = E.to_json_string address_schema embedded in
  Alcotest.(check bool) "contains street" true (String.length json_str > 0)

let test_embeds_one_from_json () =
  let json =
    `Assoc
      [
        ("street", `String "Single");
        ("city", `String "Town");
        ("zip", `String "1");
      ]
  in
  match E.embeds_one_from_json address_schema json with
  | Ok (Some embedded) ->
      Alcotest.(check string)
        "embeds_one street" "Single" (E.data embedded).street
  | Ok None -> Alcotest.fail "expected Some"
  | Error msg -> Alcotest.fail msg

let test_embeds_one_from_json_null () =
  match E.embeds_one_from_json address_schema `Null with
  | Ok None -> Alcotest.(check pass) "null is None" () ()
  | Ok (Some _) -> Alcotest.fail "expected None"
  | Error msg -> Alcotest.fail msg

let test_embeds_many_from_json () =
  let json =
    `List
      [
        `Assoc
          [
            ("street", `String "First");
            ("city", `String "A");
            ("zip", `String "1");
          ];
        `Assoc
          [
            ("street", `String "Second");
            ("city", `String "B");
            ("zip", `String "2");
          ];
      ]
  in
  match E.embeds_many_from_json address_schema json with
  | Ok embeddeds ->
      Alcotest.(check int) "two items" 2 (List.length embeddeds);
      Alcotest.(check string)
        "first street" "First" (E.data (List.hd embeddeds)).street
  | Error msg -> Alcotest.fail msg

let tests =
  [
    ("from_json", `Quick, test_from_json);
    ("to_json", `Quick, test_to_json);
    ("from_json_string", `Quick, test_from_json_string);
    ("to_json_string", `Quick, test_to_json_string);
    ("embeds_one from_json", `Quick, test_embeds_one_from_json);
    ("embeds_one from_json null", `Quick, test_embeds_one_from_json_null);
    ("embeds_many from_json", `Quick, test_embeds_many_from_json);
  ]