Dasemu
40631362b3
Establishes version control for the personal Logseq DB fork before starting the server-client architecture migration and domain features described in docs/agent-guide and the approved implementation plan. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
8294 lines
335 KiB
OCaml
8294 lines
335 KiB
OCaml
open Test_support
|
|
|
|
let expect_equal name expected actual =
|
|
if expected = actual then pass
|
|
else fail_test (Printf.sprintf "%s: expected %S, got %S" name expected actual)
|
|
|
|
let expect_string_vec name expected actual =
|
|
if Vec.to_array actual = expected then pass
|
|
else
|
|
fail_test
|
|
(Printf.sprintf "%s: expected %S, got %S" name
|
|
(Vec.string_concat "," (Vec.of_array expected))
|
|
(Vec.string_concat "," actual))
|
|
|
|
let expect_bool name expected actual =
|
|
if expected = actual then pass
|
|
else fail_test (Printf.sprintf "%s: expected %b, got %b" name expected actual)
|
|
|
|
let expect_int name expected actual =
|
|
if expected = actual then pass
|
|
else fail_test (Printf.sprintf "%s: expected %d, got %d" name expected actual)
|
|
|
|
let expect_int64 name expected actual =
|
|
if expected = actual then pass
|
|
else
|
|
fail_test
|
|
(Printf.sprintf "%s: expected %s, got %s" name (Int64.to_string expected)
|
|
(Int64.to_string actual))
|
|
|
|
external string_char_code_at : string -> int -> int = "charCodeAt" [@@mel.send]
|
|
|
|
let expect_some name = function
|
|
| Some value -> value
|
|
| None ->
|
|
fail_test (name ^ ": expected Some value");
|
|
assert false
|
|
|
|
let expect_none name = function
|
|
| None -> pass
|
|
| Some _ -> fail_test (name ^ ": expected None")
|
|
|
|
let expect_ok name = function
|
|
| Ok value -> value
|
|
| Error err ->
|
|
fail_test (name ^ ": " ^ err.Error.message);
|
|
assert false
|
|
|
|
let expect_error_code name expected = function
|
|
| Error err ->
|
|
let normalize_code code =
|
|
if String.length code > 0 && code.[0] = ':' then
|
|
String.sub code 1 (String.length code - 1)
|
|
else code
|
|
in
|
|
expect_equal name (normalize_code expected)
|
|
(normalize_code (Error.code_to_string err.Error.code))
|
|
| Ok _ -> fail_test (name ^ ": expected Error")
|
|
|
|
let expect_error_context_code name expected err =
|
|
match err.Error.context with
|
|
| None -> fail_test (name ^ ": expected error context")
|
|
| Some context ->
|
|
expect_equal name expected
|
|
(expect_some (name ^ " code")
|
|
(Option.bind (Edn_util.get context "code") Edn_util.as_keyword))
|
|
|
|
let expect_parse_ok name argv =
|
|
match Cli_parse.parse (Vec.of_array argv) with
|
|
| Ok request -> request
|
|
| Error err ->
|
|
fail_test (name ^ ": " ^ err.Error.message);
|
|
assert false
|
|
|
|
let expect_parse_error_code name expected argv =
|
|
expect_error_code name expected (Cli_parse.parse (Vec.of_array argv))
|
|
|
|
let keyword_text value = Edn_util.keyword_to_string value
|
|
let edn_of_string text = Melange_edn_melange.of_edn_string text
|
|
let repo_text repo = Cli_primitive.string_of_repo repo
|
|
let graph_text graph = Cli_primitive.string_of_graph graph
|
|
|
|
let unicode_text codepoints =
|
|
codepoints |> Vec.of_array
|
|
|> Vec.map Js.String.fromCodePoint
|
|
|> Vec.string_concat ""
|
|
|
|
let start_open_url_capture () : unit =
|
|
[%mel.raw
|
|
{|
|
|
(function () {
|
|
const childProcess = require("child_process");
|
|
const capture = {
|
|
originalSpawn: childProcess.spawn,
|
|
originalPlatformDescriptor: Object.getOwnPropertyDescriptor(process, "platform"),
|
|
calls: []
|
|
};
|
|
globalThis.__logseqOpenUrlCapture = capture;
|
|
childProcess.spawn = function (command, args, options) {
|
|
capture.calls.push({ command, args: Array.from(args), options });
|
|
return { pid: 4242, unref: function () {} };
|
|
};
|
|
Object.defineProperty(process, "platform", { value: "win32", configurable: true });
|
|
})()
|
|
|}]
|
|
|
|
let stop_open_url_capture () : unit =
|
|
[%mel.raw
|
|
{|
|
|
(function () {
|
|
const capture = globalThis.__logseqOpenUrlCapture;
|
|
if (!capture) return;
|
|
const childProcess = require("child_process");
|
|
childProcess.spawn = capture.originalSpawn;
|
|
if (capture.originalPlatformDescriptor) {
|
|
Object.defineProperty(process, "platform", capture.originalPlatformDescriptor);
|
|
}
|
|
delete globalThis.__logseqOpenUrlCapture;
|
|
})()
|
|
|}]
|
|
|
|
let open_url_capture_calls () : string =
|
|
[%mel.raw
|
|
{|
|
|
JSON.stringify((globalThis.__logseqOpenUrlCapture && globalThis.__logseqOpenUrlCapture.calls) || [])
|
|
|}]
|
|
|
|
let start_spawn_capture () : unit =
|
|
[%mel.raw
|
|
{|
|
|
(function () {
|
|
const childProcess = require("child_process");
|
|
const capture = {
|
|
originalSpawn: childProcess.spawn,
|
|
calls: []
|
|
};
|
|
globalThis.__logseqSpawnCapture = capture;
|
|
childProcess.spawn = function (command, args, options) {
|
|
capture.calls.push({ command, args: Array.from(args), options });
|
|
if (typeof capture.onSpawn === "function") capture.onSpawn(command, args, options);
|
|
return { pid: 4242, unref: function () {} };
|
|
};
|
|
})()
|
|
|}]
|
|
|
|
let stop_spawn_capture () : unit =
|
|
[%mel.raw
|
|
{|
|
|
(function () {
|
|
const capture = globalThis.__logseqSpawnCapture;
|
|
if (!capture) return;
|
|
const childProcess = require("child_process");
|
|
childProcess.spawn = capture.originalSpawn;
|
|
delete globalThis.__logseqSpawnCapture;
|
|
})()
|
|
|}]
|
|
|
|
let spawn_capture_calls () : string =
|
|
[%mel.raw
|
|
{|
|
|
JSON.stringify((globalThis.__logseqSpawnCapture && globalThis.__logseqSpawnCapture.calls) || [])
|
|
|}]
|
|
|
|
let set_spawn_capture_on_spawn_raw : string -> string -> int -> unit =
|
|
[%mel.raw
|
|
{|
|
|
function (lockPath, serverListPath, port) {
|
|
const capture = globalThis.__logseqSpawnCapture;
|
|
if (!capture) throw new Error("spawn capture is not active");
|
|
capture.onSpawn = function () {
|
|
const fs = require("fs");
|
|
fs.writeFileSync(lockPath, JSON.stringify({
|
|
repo: "logseq_db_demo",
|
|
pid: process.pid,
|
|
"lock-id": "test",
|
|
"owner-source": "cli"
|
|
}));
|
|
fs.writeFileSync(serverListPath, process.pid + " " + port + "\n");
|
|
};
|
|
}
|
|
|}]
|
|
|
|
let set_spawn_capture_on_spawn ~lock_path ~server_list_path ~port : unit =
|
|
set_spawn_capture_on_spawn_raw lock_path server_list_path port
|
|
|
|
let set_env key value : unit = Js.Dict.set Node.Process.process##env key value
|
|
|
|
let unset_env_raw : string -> unit =
|
|
[%mel.raw {| function (key) { delete process.env[key]; } |}]
|
|
|
|
let unset_env key : unit = unset_env_raw key
|
|
|
|
let property_key_text = function
|
|
| Property.Key_ident ident -> keyword_text ident
|
|
| Property.Key_id id -> Int64.to_string id
|
|
| Property.Key_name name -> name
|
|
|
|
let empty_common_opts =
|
|
{
|
|
List_command.fields = None;
|
|
limit = None;
|
|
offset = None;
|
|
sort = None;
|
|
order = None;
|
|
}
|
|
|
|
let entity ?id ?title ?name ?ident ?updated_at ?created_at () =
|
|
let add_field fields key value =
|
|
Vec.push_back fields (Edn_util.keyword key, value)
|
|
in
|
|
let raw_fields =
|
|
( ( ( ( ( Vec.empty |> fun fields ->
|
|
match id with
|
|
| Some id -> add_field fields "db/id" (Edn_util.int64 id)
|
|
| None -> fields )
|
|
|> fun fields ->
|
|
match title with
|
|
| Some title ->
|
|
add_field fields "block/title" (Edn_util.string title)
|
|
| None -> fields )
|
|
|> fun fields ->
|
|
match name with
|
|
| Some name -> add_field fields "block/name" (Edn_util.string name)
|
|
| None -> fields )
|
|
|> fun fields ->
|
|
match ident with
|
|
| Some ident -> add_field fields "db/ident" (Edn_util.keyword ident)
|
|
| None -> fields )
|
|
|> fun fields ->
|
|
match updated_at with
|
|
| Some updated_at ->
|
|
add_field fields "block/updated-at" (Edn_util.int64 updated_at)
|
|
| None -> fields )
|
|
|> fun fields ->
|
|
match created_at with
|
|
| Some created_at ->
|
|
add_field fields "block/created-at" (Edn_util.int64 created_at)
|
|
| None -> fields
|
|
in
|
|
Entity.of_value (Edn_util.map_vec raw_fields)
|
|
|
|
let span stage span_id start_ms end_ms =
|
|
let start_time = Time.time_of_epoch_ms (Int64.of_int start_ms) in
|
|
let end_time = Time.time_of_epoch_ms (Int64.of_int end_ms) in
|
|
{
|
|
Profile_types.stage;
|
|
span_id;
|
|
start_time;
|
|
end_time;
|
|
elapsed_span = Time.non_negative_diff ~start_time ~end_time;
|
|
}
|
|
|
|
let stage_count stage summaries =
|
|
summaries
|
|
|> Vec.find_map (fun (summary : Profile_types.stage_summary) ->
|
|
if summary.stage = stage then Some summary.count else None)
|
|
|
|
let config ?graph ?repo ?output_format ?auth_path ?id_token ?access_token
|
|
?refresh_token ?raw_file_config ?list_title_max_display_width
|
|
?(root_dir = "/tmp/logseq-cli-test") () =
|
|
let defaults = Cli_config.defaults () in
|
|
{
|
|
Cli_config.graph = Option.map Cli_primitive.create_graph graph;
|
|
repo = Option.map Cli_primitive.create_repo repo;
|
|
root_dir;
|
|
config_path = Node.Path.join [| root_dir; "cli.edn" |];
|
|
timeout_span = defaults.timeout_span;
|
|
login_timeout_span = defaults.login_timeout_span;
|
|
logout_timeout_span = defaults.logout_timeout_span;
|
|
list_title_max_display_width =
|
|
Option.value list_title_max_display_width
|
|
~default:defaults.list_title_max_display_width;
|
|
output_format;
|
|
verbose = false;
|
|
profile = false;
|
|
ws_url = Some defaults.ws_url;
|
|
http_base = Some defaults.http_base;
|
|
auth_path;
|
|
id_token;
|
|
access_token;
|
|
refresh_token;
|
|
base_url = None;
|
|
owner_source = Cli_primitive.Cli;
|
|
project_dir = None;
|
|
raw_file_config;
|
|
profile_session = None;
|
|
}
|
|
|
|
let config_with_output config mode =
|
|
{ config with Cli_config.output_format = Some (Output.Mode.Packed mode) }
|
|
|
|
let execute_with_output execute action config mode =
|
|
execute action (config_with_output config mode)
|
|
|
|
let effect_result name task =
|
|
let value = ref None in
|
|
let error = ref None in
|
|
Cli_effect.on_any task
|
|
(fun result -> value := Some result)
|
|
(fun exn -> error := Some exn);
|
|
match (!value, !error) with
|
|
| Some value, None -> value
|
|
| None, Some exn ->
|
|
fail_test (name ^ ": " ^ Printexc.to_string exn);
|
|
assert false
|
|
| None, None ->
|
|
fail_test (name ^ ": effect is still pending");
|
|
assert false
|
|
| Some _, Some _ ->
|
|
fail_test (name ^ ": effect resolved and rejected");
|
|
assert false
|
|
|
|
let effect_to_promise task =
|
|
Js.Promise.make (fun ~resolve ~reject ->
|
|
Cli_effect.on_any task
|
|
(fun value -> (resolve value [@u]))
|
|
(fun exn -> (reject exn [@u])))
|
|
|
|
type lifecycle_output = {
|
|
stdout : string option;
|
|
stderr : string Rrbvec.t;
|
|
exit_code : int;
|
|
}
|
|
|
|
let run_cli_lifecycle ?(env = [||]) argv =
|
|
let result = spawn_cli ~env argv in
|
|
let stderr =
|
|
let stderr = string_trim_end result##stderr in
|
|
if stderr = "" then Vec.empty else Vec.of_array (string_split stderr "\n")
|
|
in
|
|
{ stdout = Some result##stdout; stderr; exit_code = result_status result }
|
|
|
|
let stdout_text name output = expect_some name output.stdout
|
|
|
|
let invoke_args body =
|
|
match Json_util.object_of_json_string body with
|
|
| Some object_ -> (
|
|
match
|
|
Option.bind (Js.Dict.get object_ "argsTransit") Js.Json.decodeString
|
|
with
|
|
| Some args -> Transit_melange.Transit.Json.(of_string args |> to_edn)
|
|
| None ->
|
|
fail_test ("missing invoke argsTransit: " ^ body);
|
|
Edn_util.vector_vec Vec.empty)
|
|
| None ->
|
|
fail_test ("invalid invoke JSON body: " ^ body);
|
|
Edn_util.vector_vec Vec.empty
|
|
|
|
let invoke_arg_string body index =
|
|
let args =
|
|
expect_some "invoke args vector" (Edn_util.as_seq (invoke_args body))
|
|
in
|
|
expect_some
|
|
("invoke arg " ^ string_of_int index)
|
|
(Edn_util.as_string (Vec.nth args index))
|
|
|
|
let sample_auth ?(id_token = Some "id-token-1")
|
|
?(access_token = Some "access-token-1")
|
|
?(refresh_token = Some "refresh-token-1") ?expires_at
|
|
?(updated_at = 1_735_686_000_000L) ?(sub = Some "user-123")
|
|
?(email = Some "user@example.com") () : Auth_state.auth_data =
|
|
{
|
|
provider = "cognito";
|
|
id_token;
|
|
access_token;
|
|
refresh_token;
|
|
expires_at;
|
|
sub;
|
|
email;
|
|
updated_at = Time.time_of_epoch_ms updated_at;
|
|
}
|
|
|
|
let env_from_pairs pairs key = Vec.assoc_opt key (Vec.of_array pairs)
|
|
|
|
let resolve_config ?(env = [||]) globals =
|
|
let resolved =
|
|
expect_ok "resolve config"
|
|
(effect_result "resolve config"
|
|
(Cli_config.resolve ~defaults:(Cli_config.defaults ())
|
|
~env:(env_from_pairs env) globals))
|
|
in
|
|
resolved.Cli_config.config
|
|
|
|
let mode_text (Output.Mode.Packed mode) = Output.Mode.to_string mode
|
|
|
|
let agent_task_entity ?(uuid = Some "11111111-1111-4111-8111-111111111111")
|
|
?(tags = [| "logseq.class/Task" |]) ?(status = Some "todo")
|
|
?(assignees = [| "build-host" |]) ?session_id () =
|
|
let tag_values =
|
|
tags |> Vec.of_array
|
|
|> Vec.map (fun ident ->
|
|
Edn_util.map_vec
|
|
(Vec.of_array
|
|
[|
|
|
(Edn_util.keyword "db/ident", Edn_util.keyword ident);
|
|
(Edn_util.keyword "block/title", Edn_util.string "Task");
|
|
|]))
|
|
in
|
|
let assignee_values =
|
|
assignees |> Vec.of_array
|
|
|> Vec.map (fun title ->
|
|
Edn_util.map_vec
|
|
(Vec.of_array
|
|
[| (Edn_util.keyword "block/title", Edn_util.string title) |]))
|
|
in
|
|
let fields =
|
|
Vec.of_array
|
|
[|
|
|
(Edn_util.keyword "db/id", Edn_util.int64 42L);
|
|
(Edn_util.keyword "block/title", Edn_util.string "Ship the CLI bridge");
|
|
(Edn_util.keyword "block/tags", Edn_util.vector_vec tag_values);
|
|
( Edn_util.keyword "logseq.property/assignee",
|
|
Edn_util.vector_vec assignee_values );
|
|
|]
|
|
in
|
|
let fields =
|
|
match uuid with
|
|
| Some uuid ->
|
|
Vec.push_front fields
|
|
(Edn_util.keyword "block/uuid", Edn_util.string uuid)
|
|
| None -> fields
|
|
in
|
|
let fields =
|
|
match status with
|
|
| Some status ->
|
|
Vec.push_front fields
|
|
( Edn_util.keyword "logseq.property/status",
|
|
Edn_util.map_vec
|
|
(Vec.of_array
|
|
[|
|
|
( Edn_util.keyword "db/ident",
|
|
Edn_util.keyword ("logseq.property/status." ^ status) );
|
|
|]) )
|
|
| None -> fields
|
|
in
|
|
let fields =
|
|
match session_id with
|
|
| Some session_id ->
|
|
Vec.push_front fields
|
|
( Edn_util.keyword "logseq.property.agent/session-id",
|
|
Edn_util.string session_id )
|
|
| None -> fields
|
|
in
|
|
Entity.of_value (Edn_util.map_vec fields)
|
|
|
|
let routable_reason_text = function
|
|
| Agent.Missing_stable_uuid -> "missing-stable-uuid"
|
|
| Missing_task_tag -> "missing-task-tag"
|
|
| Not_todo -> "not-todo"
|
|
| Assignee_mismatch -> "assignee-mismatch"
|
|
| Already_routed -> "already-routed"
|
|
|
|
let () =
|
|
test "CLI parity output modes parse and mark structured modes" (fun () ->
|
|
let mode_name = function
|
|
| Output.Mode.Packed mode -> Output.Mode.to_string mode
|
|
in
|
|
expect_equal "human mode" "human"
|
|
(mode_name (expect_some "human" (Output.Mode.of_string "human")));
|
|
expect_equal "json mode" "json"
|
|
(mode_name (expect_some "json" (Output.Mode.of_string "json")));
|
|
expect_equal "edn mode" "edn"
|
|
(mode_name (expect_some "edn" (Output.Mode.of_string "edn")));
|
|
expect_none "invalid output mode" (Output.Mode.of_string "yaml");
|
|
expect_bool "human structured" false (Output.Mode.structured Human);
|
|
expect_bool "json structured" true (Output.Mode.structured Json);
|
|
expect_bool "edn structured" true (Output.Mode.structured Edn));
|
|
|
|
test "CLI parity primitive parsers keep graph repo shell and uuid contracts"
|
|
(fun () ->
|
|
let graph = Cli_primitive.create_graph "demo" in
|
|
let repo = Cli_config.graph_to_repo graph in
|
|
expect_equal "graph text" "demo" (Cli_primitive.string_of_graph graph);
|
|
expect_equal "repo text" "logseq_db_demo"
|
|
(Cli_primitive.string_of_repo repo);
|
|
expect_equal "repo to graph" "demo"
|
|
(Cli_primitive.string_of_graph (Cli_config.repo_to_graph repo));
|
|
expect_bool "uuid valid" true
|
|
(Cli_primitive.is_uuid_string "00000000-0000-4000-8000-000000000001");
|
|
expect_bool "uuid invalid" false
|
|
(Cli_primitive.is_uuid_string "not-a-uuid");
|
|
(match expect_some "bash" (Cli_primitive.shell_of_string "bash") with
|
|
| Cli_primitive.Bash -> pass
|
|
| _ -> fail_test "expected bash shell");
|
|
expect_none "unknown shell" (Cli_primitive.shell_of_string "fish"));
|
|
|
|
test "CLI parity ustring decodes utf8 byte strings to JS unicode strings"
|
|
(fun () ->
|
|
let ascii = Ustring.of_string "ABC" |> Ustring.to_string in
|
|
expect_equal "ascii text" "ABC" ascii;
|
|
let utf8_byte_string =
|
|
Js.String.fromCharCode 0xe4
|
|
^ Js.String.fromCharCode 0xb8
|
|
^ Js.String.fromCharCode 0xad
|
|
in
|
|
let decoded = Ustring.of_string utf8_byte_string |> Ustring.to_string in
|
|
expect_equal "decoded unicode text" (unicode_text [| 0x4e2d |]) decoded;
|
|
expect_int "decoded JS length" 1 (String.length decoded);
|
|
expect_int "decoded char code" 0x4e2d (string_char_code_at decoded 0);
|
|
let latin1_unicode =
|
|
"Diese Vorteile " ^ unicode_text [| 0x00f6 |] ^ " und "
|
|
^ unicode_text [| 0x00fc |]
|
|
in
|
|
let preserved = Ustring.of_string latin1_unicode |> Ustring.to_string in
|
|
expect_equal "latin1 supplement unicode text" latin1_unicode preserved;
|
|
expect_int "latin1 supplement char code" 0x00f6
|
|
(string_char_code_at preserved 15);
|
|
expect_int "latin1 supplement char code 2" 0x00fc
|
|
(string_char_code_at preserved 21));
|
|
|
|
test
|
|
"CLI parity id parser accepts single multi comma whitespace and vector \
|
|
input" (fun () ->
|
|
let single = expect_ok "single id" (Id_parse.parse_id_string "42") in
|
|
expect_bool "single multi" false single.multi;
|
|
expect_int64 "single id value" 42L
|
|
(expect_some "single" (Id_parse.to_single single));
|
|
let multi =
|
|
expect_ok "multi ids" (Id_parse.parse_id_string "[1, 2 3\t4]")
|
|
in
|
|
expect_bool "multi flag" true multi.multi;
|
|
expect_int "multi length" 4 (Vec.length multi.ids);
|
|
expect_none "multi to_single" (Id_parse.to_single multi);
|
|
expect_error_code "zero id" ":invalid-options"
|
|
(Id_parse.parse_id_string "0");
|
|
expect_error_code "non numeric id" ":invalid-options"
|
|
(Id_parse.parse_id_string "abc"));
|
|
|
|
test
|
|
"CLI parity graph directory names preserve canonical and old-format \
|
|
encoding" (fun () ->
|
|
expect_equal "space graph dir" "space name"
|
|
(Graph_dir.encode_graph_dir_name "space name");
|
|
expect_equal "slash graph dir" "old~2Fname"
|
|
(Graph_dir.encode_graph_dir_name "old/name");
|
|
expect_equal "tilde graph dir" "tilde~7Ename"
|
|
(Graph_dir.encode_graph_dir_name "tilde~name");
|
|
expect_equal "decode canonical" "old/name"
|
|
(expect_some "canonical"
|
|
(Graph_dir.canonical_graph_name_of_dir "old~2Fname"));
|
|
expect_none "old-format dir is not canonical"
|
|
(Graph_dir.canonical_graph_name_of_dir "old++name");
|
|
expect_equal "decode old-format slash" "old/name"
|
|
(expect_some "old-format"
|
|
(Graph_dir.decode_legacy_graph_dir_name "old++name")));
|
|
|
|
test "CLI parity unlink graph moves canonical encoded dir to unlinked dir"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-unlink-graph-" in
|
|
let graphs_dir = Node.Path.join [| root; "graphs" |] in
|
|
let graph = Cli_primitive.create_graph "foo/bar" in
|
|
let repo = Cli_config.graph_to_repo graph in
|
|
let encoded_dir = Graph_dir.encode_graph_dir_name "foo/bar" in
|
|
let graph_path = Node.Path.join [| graphs_dir; encoded_dir |] in
|
|
let unlinked_path =
|
|
Node.Path.join [| graphs_dir; "Unlinked graphs"; encoded_dir |]
|
|
in
|
|
try
|
|
mkdir_p graph_path;
|
|
write_file (Node.Path.join [| graph_path; "db.sqlite" |]) "test-data";
|
|
let result =
|
|
effect_result "graph remove slash"
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_remove { graph; repo })
|
|
(config ~root_dir:root ()) Output.Mode.Human)
|
|
in
|
|
expect_bool "graph remove ok" true
|
|
(result.Cli_result.status = Cli_result.Ok);
|
|
expect_bool "source removed" false (Cli_unix.file_exists graph_path);
|
|
expect_bool "destination exists" true
|
|
(Cli_unix.file_exists unlinked_path);
|
|
expect_equal "contents preserved" "test-data"
|
|
(read_file (Node.Path.join [| unlinked_path; "db.sqlite" |]));
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test
|
|
"CLI parity unlink graph moves space-preserving canonical dir to unlinked \
|
|
dir" (fun () ->
|
|
let root = temp_dir "logseq-cli-parity-unlink-space-" in
|
|
let graphs_dir = Node.Path.join [| root; "graphs" |] in
|
|
let graph = Cli_primitive.create_graph "space name" in
|
|
let repo = Cli_config.graph_to_repo graph in
|
|
let graph_path = Node.Path.join [| graphs_dir; "space name" |] in
|
|
let unlinked_path =
|
|
Node.Path.join [| graphs_dir; "Unlinked graphs"; "space name" |]
|
|
in
|
|
try
|
|
mkdir_p graph_path;
|
|
write_file (Node.Path.join [| graph_path; "db.sqlite" |]) "test-data";
|
|
let result =
|
|
effect_result "graph remove space"
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_remove { graph; repo })
|
|
(config ~root_dir:root ()) Output.Mode.Human)
|
|
in
|
|
expect_bool "space graph remove ok" true
|
|
(result.Cli_result.status = Cli_result.Ok);
|
|
expect_bool "space source removed" false
|
|
(Cli_unix.file_exists graph_path);
|
|
expect_bool "space destination exists" true
|
|
(Cli_unix.file_exists unlinked_path);
|
|
expect_equal "space contents preserved" "test-data"
|
|
(read_file (Node.Path.join [| unlinked_path; "db.sqlite" |]));
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity root-dir helpers create directories and reject files"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-root-" in
|
|
let nested = Node.Path.join [| root; "a"; "b" |] in
|
|
let file_path = Node.Path.join [| root; "file" |] in
|
|
try
|
|
let ensured =
|
|
expect_ok "ensure nested"
|
|
(Root_dir_types.ensure_root_dir (Some nested))
|
|
in
|
|
expect_bool "nested exists" true (Node.Fs.existsSync ensured);
|
|
write_file file_path "not a dir";
|
|
expect_error_code "reject file" ":root-dir-permission"
|
|
(Root_dir_types.ensure_root_dir (Some file_path));
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity root-dir defaults and normalization stay stable" (fun () ->
|
|
let home = Sys.getenv_opt "HOME" |> Option.value ~default:"." in
|
|
let default_root = Node.Path.join [| home; "logseq" |] in
|
|
expect_equal "default root" default_root
|
|
(Root_dir_types.normalize_root_dir None);
|
|
expect_equal "relative root"
|
|
(Node.Path.join [| Sys.getcwd (); "relative-logseq" |])
|
|
(Root_dir_types.normalize_root_dir (Some "relative-logseq"));
|
|
expect_equal "home root"
|
|
(Node.Path.join [| home; "custom-logseq" |])
|
|
(Root_dir_types.normalize_root_dir (Some "~/custom-logseq")));
|
|
|
|
test "CLI parity root-dir rejects read-only directories" (fun () ->
|
|
if Node.Process.process##platform = "win32" then pass
|
|
else
|
|
let root = temp_dir "logseq-cli-parity-root-readonly-" in
|
|
try
|
|
chmod_sync root 0o555;
|
|
expect_error_code "read-only root" ":root-dir-permission"
|
|
(Root_dir_types.ensure_root_dir (Some root));
|
|
chmod_sync root 0o755;
|
|
remove_tree root
|
|
with exn ->
|
|
chmod_sync root 0o755;
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity auth default path follows HOME logseq auth.json" (fun () ->
|
|
let home = Sys.getenv_opt "HOME" |> Option.value ~default:"." in
|
|
let expected = Node.Path.join [| home; "logseq"; "auth.json" |] in
|
|
expect_equal "default auth path" expected
|
|
(Auth_state.default_auth_path ()));
|
|
|
|
test "CLI parity auth file write read and delete round-trips token data"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-auth-" in
|
|
let auth_path =
|
|
Node.Path.join [| root; "nested"; "tokens"; "auth.json" |]
|
|
in
|
|
let config = config ~root_dir:root ~auth_path () in
|
|
let auth = sample_auth () in
|
|
try
|
|
expect_bool "auth dir missing" false
|
|
(Node.Fs.existsSync (Node.Path.dirname auth_path));
|
|
ignore
|
|
(expect_ok "write auth"
|
|
(effect_result "write auth"
|
|
(Auth_state.write_auth_file config auth)));
|
|
expect_bool "auth dir exists" true
|
|
(Node.Fs.existsSync (Node.Path.dirname auth_path));
|
|
expect_bool "auth file exists" true (Node.Fs.existsSync auth_path);
|
|
let stored =
|
|
expect_some "stored auth"
|
|
(expect_ok "read auth"
|
|
(effect_result "read auth" (Auth_state.read_auth_file config)))
|
|
in
|
|
expect_equal "provider" auth.provider stored.provider;
|
|
expect_equal "id-token" "id-token-1"
|
|
(expect_some "id-token" stored.id_token);
|
|
expect_equal "access-token" "access-token-1"
|
|
(expect_some "access-token" stored.access_token);
|
|
expect_equal "refresh-token" "refresh-token-1"
|
|
(expect_some "refresh-token" stored.refresh_token);
|
|
expect_equal "sub" "user-123" (expect_some "sub" stored.sub);
|
|
expect_equal "email" "user@example.com"
|
|
(expect_some "email" stored.email);
|
|
ignore
|
|
(expect_ok "delete auth"
|
|
(effect_result "delete auth" (Auth_state.delete_auth_file config)));
|
|
expect_bool "auth file deleted" false (Node.Fs.existsSync auth_path);
|
|
ignore
|
|
(expect_ok "delete auth idempotent"
|
|
(effect_result "delete auth again"
|
|
(Auth_state.delete_auth_file config)));
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test
|
|
"CLI parity auth read returns none when missing and errors on invalid json"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-auth-read-" in
|
|
let missing_path = Node.Path.join [| root; "missing"; "auth.json" |] in
|
|
let invalid_path = Node.Path.join [| root; "auth.json" |] in
|
|
try
|
|
let missing =
|
|
expect_ok "missing auth"
|
|
(effect_result "read missing auth"
|
|
(Auth_state.read_auth_file
|
|
(config ~root_dir:root ~auth_path:missing_path ())))
|
|
in
|
|
expect_none "missing auth none" missing;
|
|
write_file invalid_path "{\"provider\":";
|
|
expect_error_code "invalid auth json" "invalid-auth-file"
|
|
(effect_result "read invalid auth"
|
|
(Auth_state.read_auth_file
|
|
(config ~root_dir:root ~auth_path:invalid_path ())));
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity auth expired status uses expires-at strictly" (fun () ->
|
|
expect_bool "missing expires-at is expired" true
|
|
(Auth_state.expired_auth (sample_auth ()));
|
|
expect_bool "past expires-at is expired" true
|
|
(Auth_state.expired_auth
|
|
(sample_auth ~expires_at:(Time.time_of_epoch_ms 0L) ()));
|
|
expect_bool "future expires-at is not expired" false
|
|
(Auth_state.expired_auth (sample_auth ~expires_at:Time.max_time ())));
|
|
|
|
test "CLI parity auth read supports old underscore fields and config tokens"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-auth-compat-" in
|
|
let auth_path = Node.Path.join [| root; "auth.json" |] in
|
|
try
|
|
write_file auth_path
|
|
"{\"id_token\":\"id-token-2\",\"access_token\":\"access-token-2\",\"refresh_token\":\"refresh-token-2\",\"updated_at\":1735686000000}";
|
|
let underscore =
|
|
expect_ok "read underscore auth"
|
|
(effect_result "read underscore auth"
|
|
(Auth_state.read_auth_file (config ~root_dir:root ~auth_path ())))
|
|
in
|
|
let underscore = expect_some "underscore auth" underscore in
|
|
expect_equal "default provider" "cognito" underscore.provider;
|
|
expect_equal "underscore id token" "id-token-2"
|
|
(expect_some "underscore id token" underscore.id_token);
|
|
expect_int64 "underscore updated-at" 1_735_686_000_000L
|
|
(Time.time_to_epoch_ms underscore.updated_at);
|
|
let from_config =
|
|
expect_ok "resolve config auth"
|
|
(effect_result "resolve config auth"
|
|
(Auth_state.resolve_auth
|
|
(config ~id_token:"id-token-cfg"
|
|
~access_token:"access-token-cfg"
|
|
~refresh_token:"refresh-token-cfg" ())))
|
|
in
|
|
expect_equal "config auth provider" "cognito" from_config.provider;
|
|
expect_equal "config auth id token" "id-token-cfg"
|
|
(expect_some "config id token" from_config.id_token);
|
|
expect_none "config auth expires-at" from_config.expires_at;
|
|
expect_error_code "resolve missing auth" "missing-auth"
|
|
(effect_result "resolve missing auth"
|
|
(Auth_state.resolve_auth
|
|
(config ~root_dir:root
|
|
~auth_path:(Node.Path.join [| root; "missing.json" |])
|
|
())));
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test_promise
|
|
"CLI parity auth refresh uses token endpoint and validates id token"
|
|
(fun () ->
|
|
let request_bodies = ref Vec.empty in
|
|
let token_server response_body =
|
|
create_server (fun[@u] req res ->
|
|
let body = ref "" in
|
|
req_set_encoding req "utf8";
|
|
req_on_data req "data" (fun[@u] chunk -> body := !body ^ chunk);
|
|
req_on_end req "end" (fun[@u] () ->
|
|
request_bodies := Vec.push_back !request_bodies !body;
|
|
if req_method req <> "POST" || req_url req <> "/oauth2/token"
|
|
then write_json res 404 (error_response "not found")
|
|
else write_json res 200 response_body))
|
|
in
|
|
let* () =
|
|
with_server
|
|
(token_server
|
|
"{\"id_token\":\"eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiJmcmVzaC11c2VyIiwiZW1haWwiOiJmcmVzaEBleGFtcGxlLmNvbSIsImV4cCI6NDEwMjQ0NDgwMH0.signature\",\"access_token\":\"fresh-access-token\"}")
|
|
(fun base_url ->
|
|
let raw_config =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "oauth-token-endpoint",
|
|
Edn_util.string (base_url ^ "/oauth2/token") );
|
|
( Edn_util.keyword "oauth-client-id",
|
|
Edn_util.string "client-1" );
|
|
]
|
|
in
|
|
let config =
|
|
config ~raw_file_config:raw_config
|
|
~refresh_token:"refresh-token-cfg" ()
|
|
in
|
|
let* refreshed =
|
|
effect_to_promise
|
|
(Auth_state.refresh_auth config
|
|
(sample_auth ~id_token:(Some "expired-id")
|
|
~access_token:(Some "expired-access")
|
|
~refresh_token:(Some "refresh-token-1")
|
|
~expires_at:(Time.time_of_epoch_ms 0L) ()))
|
|
in
|
|
let refreshed = expect_ok "refresh auth" refreshed in
|
|
expect_equal "fresh id token sub" "fresh-user"
|
|
(expect_some "fresh sub" refreshed.sub);
|
|
expect_equal "fresh email" "fresh@example.com"
|
|
(expect_some "fresh email" refreshed.email);
|
|
expect_equal "fresh access token" "fresh-access-token"
|
|
(expect_some "fresh access token" refreshed.access_token);
|
|
expect_equal "refresh token preserved" "refresh-token-1"
|
|
(expect_some "fresh refresh token" refreshed.refresh_token);
|
|
let body = Vec.string_concat "\n" !request_bodies in
|
|
expect_named_contains "refresh grant type" body
|
|
"grant_type=refresh_token";
|
|
expect_named_contains "refresh token body" body
|
|
"refresh_token=refresh-token-1";
|
|
expect_named_contains "refresh client id" body "client_id=client-1";
|
|
Js.Promise.resolve pass)
|
|
in
|
|
with_server
|
|
(token_server
|
|
"{\"access_token\":\"access-token-only\",\"refresh_token\":\"refresh-token-2\"}")
|
|
(fun base_url ->
|
|
let raw_config =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "oauth-token-endpoint",
|
|
Edn_util.string (base_url ^ "/oauth2/token") );
|
|
]
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(Auth_state.refresh_auth
|
|
(config ~raw_file_config:raw_config ())
|
|
(sample_auth ~refresh_token:(Some "refresh-token-1") ()))
|
|
in
|
|
expect_error_code "missing id token" "missing-id-token" result;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity auth refresh returns precise token errors" (fun () ->
|
|
let token_server response_body =
|
|
create_server (fun[@u] req res ->
|
|
let body = ref "" in
|
|
req_set_encoding req "utf8";
|
|
req_on_data req "data" (fun[@u] chunk -> body := !body ^ chunk);
|
|
req_on_end req "end" (fun[@u] () ->
|
|
ignore !body;
|
|
if req_method req <> "POST" || req_url req <> "/oauth2/token"
|
|
then write_json res 404 (error_response "not found")
|
|
else write_json res 200 response_body))
|
|
in
|
|
let config_for base_url =
|
|
config
|
|
~raw_file_config:
|
|
(Edn_util.map
|
|
[
|
|
( Edn_util.keyword "oauth-token-endpoint",
|
|
Edn_util.string (base_url ^ "/oauth2/token") );
|
|
])
|
|
()
|
|
in
|
|
let* () =
|
|
with_server
|
|
(token_server
|
|
"{\"id_token\":\"not-a-jwt\",\"access_token\":\"access-token\"}")
|
|
(fun base_url ->
|
|
let* result =
|
|
effect_to_promise
|
|
(Auth_state.refresh_auth (config_for base_url)
|
|
(sample_auth ~refresh_token:(Some "refresh-token-1") ()))
|
|
in
|
|
expect_error_code "invalid token" "invalid-auth-token" result;
|
|
Js.Promise.resolve pass)
|
|
in
|
|
let missing_result = ref None in
|
|
let* () =
|
|
with_server (token_server "{\"access_token\":\"access-token-only\"}")
|
|
(fun base_url ->
|
|
let* result =
|
|
effect_to_promise
|
|
(Auth_state.refresh_auth (config_for base_url)
|
|
(sample_auth ~refresh_token:(Some "refresh-token-1") ()))
|
|
in
|
|
missing_result := Some result;
|
|
Js.Promise.resolve pass)
|
|
in
|
|
let result = expect_some "missing id token result" !missing_result in
|
|
match result with
|
|
| Ok _ ->
|
|
fail_test "missing id token: expected Error";
|
|
Js.Promise.resolve pass
|
|
| Error err ->
|
|
expect_equal "missing id token code" "missing-id-token"
|
|
(Error.code_to_string err.Error.code);
|
|
Js.Promise.resolve pass);
|
|
|
|
test_promise
|
|
"CLI parity resolve auth refreshes expired file auth and stores it"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-auth-resolve-refresh-" in
|
|
let auth_path = Node.Path.join [| root; "auth.json" |] in
|
|
let refreshed_id_token =
|
|
id_token ~sub:"resolved-user" ~email:"resolved@example.com" ()
|
|
in
|
|
let response_body =
|
|
Printf.sprintf
|
|
"{\"id_token\":%s,\"access_token\":\"resolved-access-token\",\"refresh_token\":\"resolved-refresh-token\"}"
|
|
(Js.Json.stringify (Js.Json.string refreshed_id_token))
|
|
in
|
|
let server =
|
|
create_server (fun[@u] req res ->
|
|
let body = ref "" in
|
|
req_set_encoding req "utf8";
|
|
req_on_data req "data" (fun[@u] chunk -> body := !body ^ chunk);
|
|
req_on_end req "end" (fun[@u] () ->
|
|
ignore !body;
|
|
if req_method req <> "POST" || req_url req <> "/oauth2/token"
|
|
then write_json res 404 (error_response "not found")
|
|
else write_json res 200 response_body))
|
|
in
|
|
with_server server (fun base_url ->
|
|
let raw_config =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "oauth-token-endpoint",
|
|
Edn_util.string (base_url ^ "/oauth2/token") );
|
|
]
|
|
in
|
|
let config =
|
|
config ~root_dir:root ~auth_path ~raw_file_config:raw_config ()
|
|
in
|
|
let* written =
|
|
effect_to_promise
|
|
(Auth_state.write_auth_file config
|
|
(sample_auth ~id_token:(Some "expired-id-token")
|
|
~access_token:(Some "expired-access-token")
|
|
~refresh_token:(Some "refresh-token-1")
|
|
~expires_at:(Time.time_of_epoch_ms 0L) ()))
|
|
in
|
|
ignore (expect_ok "write expired auth" written);
|
|
let* resolved = effect_to_promise (Auth_state.resolve_auth config) in
|
|
let resolved = expect_ok "resolve refreshed auth" resolved in
|
|
expect_equal "resolved sub" "resolved-user"
|
|
(expect_some "resolved sub" resolved.sub);
|
|
expect_equal "resolved email" "resolved@example.com"
|
|
(expect_some "resolved email" resolved.email);
|
|
expect_equal "resolved access" "resolved-access-token"
|
|
(expect_some "resolved access" resolved.access_token);
|
|
let* stored = effect_to_promise (Auth_state.read_auth_file config) in
|
|
let stored =
|
|
expect_some "stored refreshed auth"
|
|
(expect_ok "read refreshed auth" stored)
|
|
in
|
|
expect_equal "stored id token" refreshed_id_token
|
|
(expect_some "stored id token" stored.id_token);
|
|
expect_equal "stored refresh token" "resolved-refresh-token"
|
|
(expect_some "stored refresh token" stored.refresh_token);
|
|
remove_tree root;
|
|
Js.Promise.resolve pass));
|
|
|
|
test "CLI parity auth commands parse and build login logout actions"
|
|
(fun () ->
|
|
let login_request = expect_parse_ok "login parse" [| "login" |] in
|
|
(match login_request.command with
|
|
| Cli_request.Auth Auth_command.Parsed_login -> pass
|
|
| _ -> fail_test "login parse: expected auth login");
|
|
let logout_request = expect_parse_ok "logout parse" [| "logout" |] in
|
|
(match logout_request.command with
|
|
| Cli_request.Auth Auth_command.Parsed_logout -> pass
|
|
| _ -> fail_test "logout parse: expected auth logout");
|
|
(match
|
|
Auth_command.build (config ()) (Global_opts.create ())
|
|
Auth_command.Parsed_login
|
|
with
|
|
| Ok Auth_command.Login -> pass
|
|
| Ok _ -> fail_test "login build: expected Login"
|
|
| Error err -> fail_test ("login build: " ^ err.Error.message));
|
|
match
|
|
Auth_command.build (config ()) (Global_opts.create ())
|
|
Auth_command.Parsed_logout
|
|
with
|
|
| Ok Auth_command.Logout -> pass
|
|
| Ok _ -> fail_test "logout build: expected Logout"
|
|
| Error err -> fail_test ("logout build: " ^ err.Error.message));
|
|
|
|
test "CLI parity Windows open_url keeps query params inside start URL"
|
|
(fun () ->
|
|
let url =
|
|
"https://logseq-prod.auth.us-east-1.amazoncognito.com/oauth2/authorize?response_type=code&client_id=abc&redirect_uri=http%3A%2F%2Flocalhost%3A8765%2Fauth%2Fcallback&state=xyz&code_challenge=pkce&code_challenge_method=S256"
|
|
in
|
|
try
|
|
start_open_url_capture ();
|
|
expect_bool "open url result" true (Cli_unix.open_url url);
|
|
let calls = open_url_capture_calls () in
|
|
stop_open_url_capture ();
|
|
expect_named_contains "windows open command" calls
|
|
"\"command\":\"cmd.exe\"";
|
|
expect_named_contains "windows verbatim arguments" calls
|
|
"\"windowsVerbatimArguments\":true";
|
|
expect_named_contains "windows quoted start url" calls
|
|
("start \\\"\\\" \\\"" ^ url ^ "\\\"");
|
|
expect_named_not_contains "windows split start args" calls
|
|
("\"start\",\"\",\"" ^ url ^ "\"")
|
|
with exn ->
|
|
stop_open_url_capture ();
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity auth logout command deletes file and reports absent file"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-auth-logout-" in
|
|
let auth_path = Node.Path.join [| root; "auth.json" |] in
|
|
let raw_config =
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "open-browser", Edn_util.bool false);
|
|
(Edn_util.keyword "oauth-logout-state", Edn_util.string "state-1");
|
|
]
|
|
in
|
|
let config =
|
|
{
|
|
(config ~root_dir:root ~auth_path ()) with
|
|
raw_file_config = Some raw_config;
|
|
}
|
|
in
|
|
let deleted_flag result =
|
|
let data = expect_some "logout data" (Cli_result.data_value result) in
|
|
expect_some "deleted flag" (Edn_util.get_bool data "deleted")
|
|
in
|
|
try
|
|
ignore
|
|
(expect_ok "write auth"
|
|
(effect_result "write auth"
|
|
(Auth_state.write_auth_file config (sample_auth ()))));
|
|
let result =
|
|
effect_result "logout existing"
|
|
(execute_with_output Auth_command.execute Auth_command.Logout config
|
|
Output.Mode.Json)
|
|
in
|
|
expect_bool "logout status" false (Cli_result.is_error result);
|
|
expect_bool "deleted existing" true (deleted_flag result);
|
|
expect_bool "auth file removed" false (Node.Fs.existsSync auth_path);
|
|
let missing_result =
|
|
effect_result "logout missing"
|
|
(execute_with_output Auth_command.execute Auth_command.Logout config
|
|
Output.Mode.Json)
|
|
in
|
|
expect_bool "missing logout status" false
|
|
(Cli_result.is_error missing_result);
|
|
expect_bool "deleted missing" false (deleted_flag missing_result);
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity config resolves argv over env over file" (fun () ->
|
|
let root = temp_dir "logseq-cli-parity-config-" in
|
|
let cfg_path = Node.Path.join [| root; "cli.edn" |] in
|
|
try
|
|
write_file cfg_path
|
|
"{:graph \"file-graph\" :root-dir \"file-root\" :timeout-ms 111 \
|
|
:login-timeout-ms 444 :logout-timeout-ms 555 :output-format :edn \
|
|
:auth-token \"legacy-secret\" :retries 2 :e2ee-password \
|
|
\"legacy-password\"}\n";
|
|
let config =
|
|
resolve_config
|
|
~env:
|
|
[|
|
|
("LOGSEQ_CLI_GRAPH", "env-graph");
|
|
("LOGSEQ_CLI_ROOT_DIR", "env-root");
|
|
("LOGSEQ_CLI_TIMEOUT_MS", "222");
|
|
("LOGSEQ_CLI_LOGIN_TIMEOUT_MS", "666");
|
|
("LOGSEQ_CLI_LOGOUT_TIMEOUT_MS", "777");
|
|
("LOGSEQ_CLI_OUTPUT", "json");
|
|
|]
|
|
(Global_opts.create
|
|
~graph:(Cli_primitive.create_graph "argv-graph")
|
|
~root_dir:"argv-root" ~config_path:cfg_path
|
|
~timeout_span:(Time.span_of_ms 333L)
|
|
~output_format:(Output.Mode.Packed Output.Mode.Human) ())
|
|
in
|
|
expect_equal "config path" cfg_path config.config_path;
|
|
expect_equal "graph" "argv-graph"
|
|
(Cli_primitive.string_of_graph (expect_some "graph" config.graph));
|
|
expect_equal "root-dir" "argv-root" config.root_dir;
|
|
expect_int64 "timeout" 333L (Time.span_to_ms config.timeout_span);
|
|
expect_int64 "login timeout" 666L
|
|
(Time.span_to_ms config.login_timeout_span);
|
|
expect_int64 "logout timeout" 777L
|
|
(Time.span_to_ms config.logout_timeout_span);
|
|
expect_equal "output" "human"
|
|
(mode_text (expect_some "output" config.output_format));
|
|
(match config.raw_file_config with
|
|
| Some raw ->
|
|
expect_none "sanitized auth-token" (Edn_util.get raw "auth-token");
|
|
expect_none "sanitized retries" (Edn_util.get raw "retries");
|
|
expect_none "sanitized e2ee-password"
|
|
(Edn_util.get raw "e2ee-password")
|
|
| None -> fail_test "missing raw file config");
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity config env output overrides file output" (fun () ->
|
|
let root = temp_dir "logseq-cli-parity-config-output-" in
|
|
let cfg_path = Node.Path.join [| root; "cli.edn" |] in
|
|
try
|
|
write_file cfg_path "{:output-format :edn}\n";
|
|
let config =
|
|
resolve_config
|
|
~env:[| ("LOGSEQ_CLI_OUTPUT", "json") |]
|
|
(Global_opts.create ~config_path:cfg_path ())
|
|
in
|
|
expect_equal "env output" "json"
|
|
(mode_text (expect_some "output" config.output_format));
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity config output-format key overrides old output key" (fun () ->
|
|
let root = temp_dir "logseq-cli-parity-config-output-key-" in
|
|
let cfg_path = Node.Path.join [| root; "cli.edn" |] in
|
|
try
|
|
write_file cfg_path "{:output :json :output-format :edn}\n";
|
|
let config =
|
|
resolve_config (Global_opts.create ~config_path:cfg_path ())
|
|
in
|
|
expect_equal "output-format wins" "edn"
|
|
(mode_text (expect_some "output" config.output_format));
|
|
write_file cfg_path "{:output :json}\n";
|
|
let config =
|
|
resolve_config (Global_opts.create ~config_path:cfg_path ())
|
|
in
|
|
expect_equal "old output fallback" "json"
|
|
(mode_text (expect_some "output" config.output_format));
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity config defaults use standard root URLs and timeouts"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-config-default-" in
|
|
let cfg_path = Node.Path.join [| root; "missing-cli.edn" |] in
|
|
try
|
|
let config =
|
|
resolve_config (Global_opts.create ~config_path:cfg_path ())
|
|
in
|
|
expect_equal "config path" cfg_path config.config_path;
|
|
expect_equal "root-dir"
|
|
(Node.Path.join
|
|
[| Sys.getenv_opt "HOME" |> Option.value ~default:"."; "logseq" |])
|
|
config.root_dir;
|
|
expect_equal "ws-url" "wss://api.logseq.io/sync/%s"
|
|
(expect_some "ws-url" config.ws_url);
|
|
expect_equal "http-base" "https://api.logseq.io"
|
|
(expect_some "http-base" config.http_base);
|
|
expect_int64 "timeout" 10_000L (Time.span_to_ms config.timeout_span);
|
|
expect_int64 "login timeout" 300_000L
|
|
(Time.span_to_ms config.login_timeout_span);
|
|
expect_int64 "logout timeout" 120_000L
|
|
(Time.span_to_ms config.logout_timeout_span);
|
|
expect_int "title max width" 40 config.list_title_max_display_width;
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity empty config file uses defaults" (fun () ->
|
|
let root = temp_dir "logseq-cli-parity-config-empty-" in
|
|
let cfg_path = Node.Path.join [| root; "cli.edn" |] in
|
|
try
|
|
write_file cfg_path " \n\t";
|
|
let config =
|
|
resolve_config (Global_opts.create ~config_path:cfg_path ())
|
|
in
|
|
expect_equal "config path" cfg_path config.config_path;
|
|
expect_equal "root-dir"
|
|
(Node.Path.join
|
|
[| Sys.getenv_opt "HOME" |> Option.value ~default:"."; "logseq" |])
|
|
config.root_dir;
|
|
expect_equal "ws-url" "wss://api.logseq.io/sync/%s"
|
|
(expect_some "ws-url" config.ws_url);
|
|
expect_equal "http-base" "https://api.logseq.io"
|
|
(expect_some "http-base" config.http_base);
|
|
expect_int64 "timeout" 10_000L (Time.span_to_ms config.timeout_span);
|
|
expect_int64 "login timeout" 300_000L
|
|
(Time.span_to_ms config.login_timeout_span);
|
|
expect_int64 "logout timeout" 120_000L
|
|
(Time.span_to_ms config.logout_timeout_span);
|
|
expect_int "title max width" 40 config.list_title_max_display_width;
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity config path follows root-dir unless explicitly set"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-config-path-" in
|
|
let custom_root = Node.Path.join [| root; "custom-logseq" |] in
|
|
let explicit_cfg =
|
|
Node.Path.join [| root; "nested"; "custom-cli.edn" |]
|
|
in
|
|
try
|
|
let derived =
|
|
resolve_config (Global_opts.create ~root_dir:custom_root ())
|
|
in
|
|
expect_equal "derived root" custom_root derived.root_dir;
|
|
expect_equal "derived config path"
|
|
(Node.Path.join [| custom_root; "cli.edn" |])
|
|
derived.config_path;
|
|
let explicit =
|
|
resolve_config
|
|
(Global_opts.create ~root_dir:custom_root ~config_path:explicit_cfg
|
|
())
|
|
in
|
|
expect_equal "explicit root" custom_root explicit.root_dir;
|
|
expect_equal "explicit config path" explicit_cfg explicit.config_path;
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity server runtime dirs are derived from resolved root"
|
|
(fun () ->
|
|
let config = config ~root_dir:"/tmp/logseq-root" () in
|
|
expect_equal "resolved root" "/tmp/logseq-root"
|
|
(Server_runtime.resolve_root_dir config);
|
|
expect_equal "graphs dir" "/tmp/logseq-root/graphs"
|
|
(Server_runtime.graphs_dir config));
|
|
|
|
test
|
|
"CLI parity config list title max width reads positive and defaults \
|
|
non-positive" (fun () ->
|
|
let root = temp_dir "logseq-cli-parity-title-width-" in
|
|
try
|
|
let cfg_path = Node.Path.join [| root; "cli.edn" |] in
|
|
write_file cfg_path "{:list-title-max-display-width 72}\n";
|
|
let config =
|
|
resolve_config (Global_opts.create ~config_path:cfg_path ())
|
|
in
|
|
expect_int "positive width" 72 config.list_title_max_display_width;
|
|
write_file cfg_path "{:list-title-max-display-width 0}\n";
|
|
let config =
|
|
resolve_config (Global_opts.create ~config_path:cfg_path ())
|
|
in
|
|
expect_int "zero width default" 40 config.list_title_max_display_width;
|
|
write_file cfg_path "{:list-title-max-display-width -3}\n";
|
|
let config =
|
|
resolve_config (Global_opts.create ~config_path:cfg_path ())
|
|
in
|
|
expect_int "negative width default" 40
|
|
config.list_title_max_display_width;
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity config invalid list title width fails fast" (fun () ->
|
|
let root = temp_dir "logseq-cli-parity-title-width-invalid-" in
|
|
let cfg_path = Node.Path.join [| root; "cli.edn" |] in
|
|
try
|
|
write_file cfg_path "{:list-title-max-display-width \"abc\"}\n";
|
|
let result =
|
|
effect_result "resolve invalid title width fallback"
|
|
(Cli_config.resolve ~defaults:(Cli_config.defaults ())
|
|
~env:(env_from_pairs [||])
|
|
(Global_opts.create ~config_path:cfg_path ()))
|
|
in
|
|
(match result with
|
|
| Ok _ -> fail_test "invalid width: expected Error"
|
|
| Error err ->
|
|
expect_equal "invalid width code" "invalid-config"
|
|
(Error.code_to_string err.Error.code);
|
|
expect_named_contains "invalid width message" err.Error.message
|
|
"Expected integer");
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity config invalid output fails fast" (fun () ->
|
|
let root = temp_dir "logseq-cli-parity-invalid-output-" in
|
|
let cfg_path = Node.Path.join [| root; "cli.edn" |] in
|
|
try
|
|
write_file cfg_path "{:output-format :edn}\n";
|
|
let result =
|
|
effect_result "resolve invalid output fallback"
|
|
(Cli_config.resolve ~defaults:(Cli_config.defaults ())
|
|
~env:(env_from_pairs [| ("LOGSEQ_CLI_OUTPUT", "yaml") |])
|
|
(Global_opts.create ~config_path:cfg_path ()))
|
|
in
|
|
(match result with
|
|
| Ok _ -> fail_test "invalid output: expected Error"
|
|
| Error err ->
|
|
expect_equal "invalid output code" "invalid-config"
|
|
(Error.code_to_string err.Error.code);
|
|
expect_named_contains "invalid output message" err.Error.message
|
|
"Expected one of human, json, edn");
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test
|
|
"CLI parity uuid ref helpers extract unique lowercase refs and replace \
|
|
labels" (fun () ->
|
|
let first = "11111111-1111-4111-8111-111111111111" in
|
|
let upper = "22222222-2222-4222-8222-222222222222" in
|
|
let text =
|
|
"A [[" ^ first ^ "]] B [[not-a-uuid]] C [["
|
|
^ String.uppercase_ascii upper
|
|
^ "]] A [[" ^ first ^ "]]"
|
|
in
|
|
let refs = Uuid_refs_types.extract_uuid_refs text in
|
|
expect_int "uuid ref count" 2 (Vec.length refs);
|
|
expect_equal "first uuid" first (Vec.nth refs 0);
|
|
expect_equal "second uuid" upper (Vec.nth refs 1);
|
|
let replaced =
|
|
Uuid_refs_types.replace_uuid_refs text
|
|
(Vec.of_array [| (first, "First"); (upper, "Second") |])
|
|
in
|
|
expect_named_contains "replace first" replaced "[[First]]";
|
|
expect_named_contains "replace second" replaced "[[Second]]";
|
|
expect_named_contains "keep invalid" replaced "[[not-a-uuid]]");
|
|
|
|
test "CLI parity uuid refs are collected from entity string fields" (fun () ->
|
|
let uuid = "33333333-3333-4333-8333-333333333333" in
|
|
let items =
|
|
Vec.of_array
|
|
[|
|
|
entity ~title:("Title [[" ^ uuid ^ "]]") ();
|
|
entity ~name:("Name [[" ^ uuid ^ "]]") ();
|
|
|]
|
|
in
|
|
let refs =
|
|
Uuid_refs_types.collect_uuid_refs_from_items items
|
|
(Vec.of_array
|
|
[|
|
|
Edn_util.keyword_t "block/title"; Edn_util.keyword_t "block/name";
|
|
|])
|
|
in
|
|
expect_int "collected uuid refs" 1 (Vec.length refs);
|
|
expect_equal "collected uuid" uuid (Vec.peek_front refs));
|
|
|
|
test "CLI parity human count helpers use grouped counts and pluralization"
|
|
(fun () ->
|
|
expect_equal "count" "1,234" (Humanize_types.format_count 1234);
|
|
expect_equal "singular" "1 graph"
|
|
(Humanize_types.format_count_with_noun 1 "graph");
|
|
expect_equal "plural" "2 graphs"
|
|
(Humanize_types.format_count_with_noun 2 "graph"));
|
|
|
|
test "CLI parity display width truncates ascii cjk and combining text"
|
|
(fun () ->
|
|
let cjk = decode_uri_component "%E7%95%8C" in
|
|
let combining_acute = decode_uri_component "%CC%81" in
|
|
let o_umlaut = decode_uri_component "%C3%B6" in
|
|
let accented_title =
|
|
decode_uri_component
|
|
"Diese%20Vorteile%20k%C3%B6nnten%20besonders%20f%C3%BCr%20eine"
|
|
in
|
|
let repeat count value =
|
|
Vec.string_concat "" (Vec.init count (fun _ -> value))
|
|
in
|
|
expect_int "ascii width" 5 (Display_width.width "Hello");
|
|
expect_int "cjk width" 2 (Display_width.width cjk);
|
|
expect_int "combining width" 1
|
|
(Display_width.width ("e" ^ combining_acute));
|
|
expect_int "latin-1 code point width" 1 (Display_width.width o_umlaut);
|
|
expect_int "latin-1 followed by ascii width" 4
|
|
(Display_width.width (o_umlaut ^ "abc"));
|
|
expect_int "accented latin title width" 41
|
|
(Display_width.width accented_title);
|
|
expect_equal "short segment" "Project Alpha"
|
|
(Display_width.truncate "Project Alpha" 24);
|
|
expect_equal "exact ascii segment" "123456789012345678901234"
|
|
(Display_width.truncate "123456789012345678901234" 24);
|
|
expect_equal "one over ascii segment"
|
|
("12345678901234567890123" ^ Cli_platform.Symbols.ellipsis)
|
|
(Display_width.truncate "1234567890123456789012345" 24);
|
|
expect_equal "exact cjk segment" (repeat 12 cjk)
|
|
(Display_width.truncate (repeat 12 cjk) 24);
|
|
expect_equal "one over cjk segment"
|
|
(repeat 11 cjk ^ Cli_platform.Symbols.ellipsis)
|
|
(Display_width.truncate (repeat 13 cjk) 24);
|
|
expect_equal "accented latin title truncation"
|
|
(decode_uri_component
|
|
"Diese%20Vorteile%20k%C3%B6nnten%20besonders%20f%C3%BCr%20ei"
|
|
^ Cli_platform.Symbols.ellipsis)
|
|
(Display_width.truncate accented_title 40));
|
|
|
|
test "CLI parity profile sessions aggregate repeated stages" (fun () ->
|
|
expect_none "disabled profile" (Profile_types.create_session false);
|
|
let session =
|
|
expect_some "enabled profile" (Profile_types.create_session true)
|
|
in
|
|
Profile_types.record_span session (span "cli.parse-argv" 1 0 2);
|
|
Profile_types.record_span session (span "cli.parse-argv" 2 3 5);
|
|
Profile_types.record_span session (span "cli.build-action" 3 6 8);
|
|
let report =
|
|
Profile_types.report session ~command:"graph-list"
|
|
~status:(Edn_util.keyword_t "ok")
|
|
in
|
|
expect_equal "profile command" "graph-list" report.command;
|
|
expect_equal "profile status" "ok" (keyword_text report.status);
|
|
expect_int "parse count" 2
|
|
(expect_some "parse count" (stage_count "cli.parse-argv" report.stages));
|
|
expect_int "build count" 1
|
|
(expect_some "build count"
|
|
(stage_count "cli.build-action" report.stages));
|
|
expect_int "total count" 1
|
|
(expect_some "total count" (stage_count "cli.total" report.stages)));
|
|
|
|
test "CLI parity profile render lines use containment tree" (fun () ->
|
|
let report : Profile_types.report =
|
|
{
|
|
command = "graph-list";
|
|
status = Edn_util.keyword_t "ok";
|
|
total_span = Time.span_of_ms 42L;
|
|
stages = Vec.empty;
|
|
spans =
|
|
Vec.of_array
|
|
[|
|
|
span "cli.total" 0 0 42;
|
|
span "cli.parse-argv" 1 1 3;
|
|
span "cli.execute-action" 2 5 35;
|
|
span "transport.invoke:thread-api/q" 3 12 20;
|
|
|];
|
|
}
|
|
in
|
|
let lines = Profile_types.render_lines report in
|
|
expect_equal "profile headline" "42ms command=graph-list status=ok"
|
|
(Vec.peek_front lines);
|
|
expect_bool "profile stages heading" true
|
|
(Vec.exists (fun line -> String.trim line = "stages") lines);
|
|
expect_bool "profile total line" true
|
|
(Vec.exists
|
|
(fun line -> Js.String.includes ~search:"cli.total" line)
|
|
lines);
|
|
expect_bool "profile nested transport" true
|
|
(Vec.exists
|
|
(fun line ->
|
|
Js.String.includes ~search:"transport.invoke:thread-api/q" line)
|
|
lines);
|
|
expect_bool "profile no aggregate count labels" false
|
|
(Vec.exists
|
|
(fun line -> Js.String.includes ~search:"count=" line)
|
|
lines));
|
|
|
|
test "CLI parity profile render keeps repeated stage calls separate"
|
|
(fun () ->
|
|
let report : Profile_types.report =
|
|
{
|
|
command = "query";
|
|
status = Edn_util.keyword_t "ok";
|
|
total_span = Time.span_of_ms 30L;
|
|
stages = Vec.empty;
|
|
spans =
|
|
Vec.of_array
|
|
[|
|
|
span "outer" 0 0 30;
|
|
span "transport.invoke:thread-api/q" 1 5 10;
|
|
span "transport.invoke:thread-api/q" 2 15 20;
|
|
|];
|
|
}
|
|
in
|
|
let lines = Profile_types.render_lines report in
|
|
let q_lines =
|
|
Vec.filter
|
|
(fun line ->
|
|
Js.String.includes ~search:"transport.invoke:thread-api/q" line)
|
|
lines
|
|
in
|
|
expect_int "repeated stage lines" 2 (Vec.length q_lines));
|
|
|
|
test "CLI parity human table formats blanks and appends footer" (fun () ->
|
|
let output =
|
|
Output.Human_output.create
|
|
~headers:(Vec.of_array [| "ID"; "TITLE" |])
|
|
~rows:
|
|
(Vec.of_array
|
|
[| Vec.of_array [| "1"; "Alpha" |]; Vec.of_array [| "2"; "" |] |])
|
|
~footer:"Count: 2" ()
|
|
|> Output.Human_output.to_string
|
|
in
|
|
expect_named_contains "header" output "ID TITLE";
|
|
expect_named_contains "blank value" output "2 -";
|
|
expect_named_contains "footer" output "Count: 2");
|
|
|
|
test "CLI parity human table renders keyword headers without namespaces"
|
|
(fun () ->
|
|
let output =
|
|
Output.Human_output.create
|
|
~headers:
|
|
(Vec.of_array
|
|
[|
|
|
"db/id";
|
|
"block/title";
|
|
":logseq.property/status";
|
|
"Input/Output";
|
|
|])
|
|
~rows:
|
|
(Vec.of_array
|
|
[|
|
|
Vec.of_array
|
|
[| "1"; "Ship"; "logseq.property/status.todo"; "Ready" |];
|
|
|])
|
|
()
|
|
|> Output.Human_output.to_string
|
|
in
|
|
expect_named_contains "keyword headers" output "id title status";
|
|
expect_named_contains "plain slash header" output "Input/Output";
|
|
expect_named_not_contains "db namespace" output "db/id";
|
|
expect_named_not_contains "block namespace" output "block/title";
|
|
expect_named_not_contains "property namespace" output
|
|
":logseq.property/status");
|
|
|
|
test "CLI parity output mode parser accepts exact lowercase values only"
|
|
(fun () ->
|
|
expect_equal "json" "json"
|
|
(mode_text (expect_some "json" (Output.Mode.of_string "json")));
|
|
expect_equal "edn" "edn"
|
|
(mode_text (expect_some "edn" (Output.Mode.of_string "edn")));
|
|
expect_none "uppercase json" (Output.Mode.of_string " JSON ");
|
|
expect_none "uppercase edn" (Output.Mode.of_string "EDN");
|
|
expect_none "blank output" (Output.Mode.of_string " ");
|
|
expect_none "unknown output" (Output.Mode.of_string "yaml"));
|
|
|
|
test "CLI parity log truncate preview keeps string length without EDN quotes"
|
|
(fun () ->
|
|
let long_value = String.make 50 'a' |> Edn_util.string in
|
|
let long_preview = Log_types.truncate_preview ~max_len:10 long_value in
|
|
expect_int "long string length" 50 long_preview.length;
|
|
expect_int "long preview length" 10 (String.length long_preview.preview);
|
|
expect_bool "long preview truncated" true long_preview.truncated;
|
|
let short_preview =
|
|
Log_types.truncate_preview ~max_len:10 (Edn_util.string "short")
|
|
in
|
|
expect_int "short string length" 5 short_preview.length;
|
|
expect_equal "short preview" "short" short_preview.preview;
|
|
expect_bool "short preview not truncated" false short_preview.truncated;
|
|
let nil_preview = Log_types.truncate_preview ~max_len:10 Edn_util.nil in
|
|
expect_int "nil length" 3 nil_preview.length;
|
|
expect_equal "nil preview" "nil" nil_preview.preview;
|
|
expect_bool "nil not truncated" false nil_preview.truncated;
|
|
let vector_preview =
|
|
Log_types.truncate_preview ~max_len:100
|
|
(Edn_util.vector_vec
|
|
(Vec.of_array [| Edn_util.int 1; Edn_util.int 2; Edn_util.int 3 |]))
|
|
in
|
|
expect_equal "vector preview" "[1 2 3]" vector_preview.preview;
|
|
expect_bool "vector not truncated" false vector_preview.truncated);
|
|
|
|
test "CLI parity pretty edn matches jet command formatting" (fun () ->
|
|
expect_equal "flat pretty edn" "{:a 1, :bb 22, :ccc 333, :dddd 4444}\n"
|
|
(Pretty_print.pprint_edn
|
|
(edn_of_string "{:a 1 :bb 22 :ccc 333 :dddd 4444}"));
|
|
expect_equal "escaped string pretty edn"
|
|
"{:text \"a { b [ c ] } \\\" q\", :empty [], :m {}}\n"
|
|
(Pretty_print.pprint_edn
|
|
(edn_of_string "{:text \"a { b [ c ] } \\\" q\" :empty [] :m {}}"));
|
|
expect_equal "nested pretty edn"
|
|
"{:classes {:user.class/DUOL {:block/title \"DUOL\",\n\
|
|
\ :block/created-at 1773581891284,\n\
|
|
\ :block/updated-at 1773581891284},\n\
|
|
\ :user.class/NVDA {:block/title \"NVDA\",\n\
|
|
\ :block/created-at 1773583745410,\n\
|
|
\ :block/updated-at 1773583745410}},\n\
|
|
\ :pages [{:block/title \"A\", :block/tags [:x :y]}\n\
|
|
\ {:block/title \"B\", :block/properties {:k \"v\"}}]}\n"
|
|
(Pretty_print.pprint_edn
|
|
(edn_of_string
|
|
"{:classes {:user.class/DUOL {:block/title \"DUOL\" \
|
|
:block/created-at 1773581891284 :block/updated-at \
|
|
1773581891284} :user.class/NVDA {:block/title \"NVDA\" \
|
|
:block/created-at 1773583745410 :block/updated-at \
|
|
1773583745410}} :pages [{:block/title \"A\" :block/tags [:x \
|
|
:y]} {:block/title \"B\" :block/properties {:k \"v\"}}]}")));
|
|
|
|
test "CLI parity json output preserves namespaced keys and keyword values"
|
|
(fun () ->
|
|
let value =
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "block/title", Edn_util.string "Block title");
|
|
(Edn_util.keyword "db/id", Edn_util.int64 42L);
|
|
(Edn_util.keyword "db/ident", Edn_util.keyword "logseq.class/Tag");
|
|
]
|
|
in
|
|
let output =
|
|
Format_types.to_json
|
|
(Cli_result.ok Output.Mode.Json (Cli_result.Raw value))
|
|
in
|
|
expect_named_contains "json title" output
|
|
"\"block/title\":\"Block title\"";
|
|
expect_named_contains "json id" output "\"db/id\":42";
|
|
expect_named_contains "json ident" output
|
|
"\"db/ident\":\"logseq.class/Tag\"");
|
|
|
|
test "CLI parity cli result exit codes follow status" (fun () ->
|
|
let ok = Cli_result.ok Output.Mode.Human (Cli_result.Message "ok") in
|
|
expect_bool "ok is not error" false (Cli_result.is_error ok);
|
|
expect_int "ok exit" 0 (Cli_result.exit_code ok);
|
|
let err = Error.make Error.Missing_auth "missing auth" in
|
|
let error = Cli_result.error Output.Mode.Human err in
|
|
expect_bool "error is error" true (Cli_result.is_error error);
|
|
expect_int "error exit" 1 (Cli_result.exit_code error));
|
|
|
|
test "CLI parity edn includes hint and human error stays concise" (fun () ->
|
|
let err =
|
|
Error.make ~hint:"Run `logseq login` first." Error.Missing_auth
|
|
"missing auth"
|
|
in
|
|
let edn = Format_types.to_edn (Cli_result.error Output.Mode.Edn err) in
|
|
let human =
|
|
Format_types.format_result
|
|
(Cli_result.error Output.Mode.Human err)
|
|
(config ())
|
|
in
|
|
expect_named_contains "edn code" edn ":missing-auth";
|
|
expect_named_contains "edn hint" edn "Run `logseq login` first.";
|
|
expect_equal "human error" "Error (missing-auth): missing auth" human);
|
|
|
|
test
|
|
"CLI parity parse rejects unknown command and retired qmd qsearch commands"
|
|
(fun () ->
|
|
expect_parse_error_code "unknown command" ":unknown-command" [| "bogus" |];
|
|
expect_parse_error_code "qmd retired" ":unknown-command" [| "qmd" |];
|
|
expect_parse_error_code "qsearch retired" ":unknown-command"
|
|
[| "qsearch" |]);
|
|
|
|
test
|
|
"CLI parity parse reads global graph output timeout verbose and profile \
|
|
flags" (fun () ->
|
|
let request =
|
|
expect_parse_ok "global parse"
|
|
[|
|
|
"--graph";
|
|
"demo";
|
|
"--output";
|
|
"json";
|
|
"--timeout-ms";
|
|
"1234";
|
|
"--verbose";
|
|
"--profile";
|
|
"graph";
|
|
"list";
|
|
|]
|
|
in
|
|
expect_equal "path" "graph/list" (Vec.string_concat "/" request.path);
|
|
expect_equal "graph" "demo"
|
|
(Cli_primitive.string_of_graph
|
|
(expect_some "graph" request.globals.Global_opts.graph));
|
|
expect_bool "verbose" true request.globals.verbose;
|
|
expect_bool "profile" true request.globals.profile;
|
|
match request.globals.output_format with
|
|
| Some (Output.Mode.Packed Output.Mode.Json) -> pass
|
|
| _ -> fail_test "expected json output mode");
|
|
|
|
test "CLI parity parse skips an earlier duplicate option without a value"
|
|
(fun () ->
|
|
let request =
|
|
expect_parse_ok "duplicate output parse"
|
|
[| "--output"; "--output"; "json"; "graph"; "list" |]
|
|
in
|
|
match request.globals.output_format with
|
|
| Some (Output.Mode.Packed Output.Mode.Json) -> pass
|
|
| _ -> fail_test "expected later json output mode");
|
|
|
|
test "CLI parity parse supports list page filters and validation" (fun () ->
|
|
let request =
|
|
expect_parse_ok "list page parse"
|
|
[|
|
|
"list";
|
|
"page";
|
|
"--fields";
|
|
"title,updated-at";
|
|
"--limit";
|
|
"10";
|
|
"--offset";
|
|
"2";
|
|
"--sort";
|
|
"updated-at";
|
|
"--order";
|
|
"asc";
|
|
"--include-hidden";
|
|
|]
|
|
in
|
|
match request.command with
|
|
| Cli_request.List (List_command.Parsed_page opts) ->
|
|
expect_int "limit" 10 (expect_some "limit" opts.common.limit);
|
|
expect_int "offset" 2 (expect_some "offset" opts.common.offset);
|
|
expect_equal "sort" "updated-at" (expect_some "sort" opts.common.sort);
|
|
expect_equal "order" "asc"
|
|
(List_command.string_of_order
|
|
(expect_some "order" opts.common.order));
|
|
expect_bool "include hidden" true opts.include_hidden
|
|
| _ ->
|
|
fail_test "expected list page request";
|
|
expect_parse_error_code "bad order" ":invalid-options"
|
|
[| "list"; "page"; "--order"; "sideways" |];
|
|
expect_parse_error_code "bad limit" ":invalid-options"
|
|
[| "list"; "page"; "--limit"; "nope" |]);
|
|
|
|
test "CLI parity parse rejects malformed boolean and selector values"
|
|
(fun () ->
|
|
expect_parse_error_code "bad boolean equals" ":invalid-options"
|
|
[| "list"; "page"; "--include-built-in=maybe" |];
|
|
expect_parse_error_code "bad boolean value" ":invalid-options"
|
|
[| "show"; "--id"; "1"; "--linked-references=maybe" |];
|
|
expect_parse_error_code "bad remove page id" ":invalid-options"
|
|
[| "remove"; "page"; "--id"; "abc"; "--page"; "Home" |];
|
|
expect_parse_error_code "bad sync asset id" ":invalid-options"
|
|
[| "sync"; "asset"; "download"; "--id"; "abc"; "--uuid"; "id" |];
|
|
expect_parse_error_code "bad debug id" ":invalid-options"
|
|
[| "debug"; "pull"; "--id"; "abc"; "--uuid"; "id" |]);
|
|
|
|
test "CLI parity parse supports list tag property task node and asset options"
|
|
(fun () ->
|
|
let tag =
|
|
expect_parse_ok "list tag parse"
|
|
[|
|
|
"list";
|
|
"tag";
|
|
"--expand";
|
|
"--include-built-in";
|
|
"--with-properties";
|
|
"--with-extends";
|
|
"--fields";
|
|
"title,properties";
|
|
|]
|
|
in
|
|
(match tag.command with
|
|
| Cli_request.List (List_command.Parsed_tag opts) ->
|
|
expect_bool "tag expand" true opts.expand;
|
|
expect_bool "tag include built in" true
|
|
(expect_some "tag include built in" opts.include_built_in);
|
|
expect_bool "tag with properties" true opts.with_properties;
|
|
expect_bool "tag with extends" true opts.with_extends;
|
|
expect_int "tag fields" 2
|
|
(Vec.length (expect_some "tag fields" opts.common.fields))
|
|
| _ -> fail_test "expected list tag");
|
|
let property =
|
|
expect_parse_ok "list property parse"
|
|
[|
|
|
"list";
|
|
"property";
|
|
"--expand";
|
|
"--include-built-in";
|
|
"--with-classes";
|
|
"--with-type";
|
|
"--sort";
|
|
"cardinality";
|
|
"--fields";
|
|
"title,type,cardinality";
|
|
|]
|
|
in
|
|
(match property.command with
|
|
| Cli_request.List (List_command.Parsed_property opts) ->
|
|
expect_bool "property expand" true opts.expand;
|
|
expect_bool "property include built in" true
|
|
(expect_some "property include built in" opts.include_built_in);
|
|
expect_bool "property with classes" true opts.with_classes;
|
|
expect_bool "property with type" true opts.with_type;
|
|
expect_equal "property sort" "cardinality"
|
|
(expect_some "property sort" opts.common.sort)
|
|
| _ -> fail_test "expected list property");
|
|
let task =
|
|
expect_parse_ok "list task parse"
|
|
[|
|
|
"list";
|
|
"task";
|
|
"--status";
|
|
"doing";
|
|
"--priority";
|
|
"high";
|
|
"-c";
|
|
"1111";
|
|
"--fields";
|
|
"id,title,status,priority";
|
|
"--limit";
|
|
"10";
|
|
"--offset";
|
|
"2";
|
|
"--sort";
|
|
"priority";
|
|
"--order";
|
|
"desc";
|
|
|]
|
|
in
|
|
(match task.command with
|
|
| Cli_request.List (List_command.Parsed_task opts) ->
|
|
expect_equal "task status" "doing"
|
|
(expect_some "task status" opts.status);
|
|
expect_equal "task priority" "high"
|
|
(expect_some "task priority" opts.priority);
|
|
expect_equal "task numeric content" "1111"
|
|
(expect_some "task content" opts.content);
|
|
expect_int "task limit" 10
|
|
(expect_some "task limit" opts.common.limit);
|
|
expect_equal "task order" "desc"
|
|
(List_command.string_of_order
|
|
(expect_some "task order" opts.common.order))
|
|
| _ -> fail_test "expected list task");
|
|
let node =
|
|
expect_parse_ok "list node parse"
|
|
[|
|
|
"list";
|
|
"node";
|
|
"--tags";
|
|
"project,work";
|
|
"--properties";
|
|
"status,priority";
|
|
"--fields";
|
|
"id,title,type,updated-at";
|
|
"--limit";
|
|
"10";
|
|
"--offset";
|
|
"2";
|
|
"--sort";
|
|
"updated-at";
|
|
"--order";
|
|
"desc";
|
|
|]
|
|
in
|
|
(match node.command with
|
|
| Cli_request.List (List_command.Parsed_node opts) ->
|
|
expect_int "node tags" 2 (Vec.length opts.tags);
|
|
expect_int "node properties" 2 (Vec.length opts.properties);
|
|
expect_equal "node sort" "updated-at"
|
|
(expect_some "node sort" opts.common.sort)
|
|
| _ -> fail_test "expected list node");
|
|
let asset =
|
|
expect_parse_ok "list asset parse"
|
|
[|
|
|
"list";
|
|
"asset";
|
|
"--fields";
|
|
"id,title,asset-type,size,updated-at";
|
|
"--limit";
|
|
"5";
|
|
"--offset";
|
|
"1";
|
|
"--sort";
|
|
"updated-at";
|
|
"--order";
|
|
"desc";
|
|
|]
|
|
in
|
|
match asset.command with
|
|
| Cli_request.List (List_command.Parsed_asset opts) ->
|
|
expect_int "asset limit" 5
|
|
(expect_some "asset limit" opts.common.limit);
|
|
expect_int "asset offset" 1
|
|
(expect_some "asset offset" opts.common.offset);
|
|
expect_equal "asset order" "desc"
|
|
(List_command.string_of_order
|
|
(expect_some "asset order" opts.common.order))
|
|
| _ -> fail_test "expected list asset");
|
|
|
|
test "CLI parity list rejects old name fields for tag and property" (fun () ->
|
|
expect_parse_error_code "list tag old name field" ":invalid-options"
|
|
[| "list"; "tag"; "--fields"; "name,properties" |];
|
|
expect_parse_error_code "list property old name field" ":invalid-options"
|
|
[| "list"; "property"; "--fields"; "name,type,cardinality" |]);
|
|
|
|
test "CLI parity list apply offset limit returns requested window" (fun () ->
|
|
let opts = { empty_common_opts with offset = Some 1; limit = Some 2 } in
|
|
let items =
|
|
Vec.of_array
|
|
[|
|
|
entity ~id:1L ();
|
|
entity ~id:2L ();
|
|
entity ~id:3L ();
|
|
entity ~id:4L ();
|
|
|]
|
|
in
|
|
let result = List_command.apply_offset_limit opts items in
|
|
expect_int "window size" 2 (Vec.length result);
|
|
expect_int64 "first window id" 2L
|
|
(expect_some "id" (Vec.peek_front result).Entity.id));
|
|
|
|
test "CLI parity list build action validates repo and option contracts"
|
|
(fun () ->
|
|
let page_opts =
|
|
List_command.Parsed_page
|
|
{
|
|
common =
|
|
{
|
|
empty_common_opts with
|
|
fields = Some (Vec.of_array [| "id"; "title" |]);
|
|
limit = Some 20;
|
|
sort = Some "updated-at";
|
|
order = Some List_command.Desc;
|
|
};
|
|
expand = false;
|
|
include_built_in = None;
|
|
include_journal = Some false;
|
|
journal_only = true;
|
|
include_hidden = false;
|
|
updated_after = None;
|
|
created_after = None;
|
|
}
|
|
in
|
|
let action =
|
|
expect_ok "list page build"
|
|
(List_command.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
page_opts)
|
|
in
|
|
expect_bool "list page kind" true
|
|
(action.List_command.kind = List_command.Page);
|
|
expect_equal "list page command" "list-page"
|
|
(Command_id.to_string action.command);
|
|
expect_equal "list page repo" "logseq_db_demo"
|
|
(Cli_primitive.string_of_repo action.repo);
|
|
expect_equal "list page graph" "demo"
|
|
(Cli_primitive.string_of_graph action.graph);
|
|
expect_int "list page limit" 20
|
|
(expect_some "limit" (Edn_util.get_int action.options "limit"));
|
|
expect_equal "list page order" "desc"
|
|
(expect_some "order" (Edn_util.get_string action.options "order"));
|
|
expect_error_code "list requires repo" "missing-repo"
|
|
(List_command.build (config ()) (Global_opts.create ()) page_opts);
|
|
let conflict =
|
|
List_command.Parsed_page
|
|
{
|
|
common = empty_common_opts;
|
|
expand = false;
|
|
include_built_in = None;
|
|
include_journal = Some true;
|
|
journal_only = true;
|
|
include_hidden = false;
|
|
updated_after = None;
|
|
created_after = None;
|
|
}
|
|
in
|
|
expect_error_code "journal conflict" "invalid-options"
|
|
(List_command.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
conflict);
|
|
let task =
|
|
List_command.Parsed_task
|
|
{
|
|
common = empty_common_opts;
|
|
status = Some "todo";
|
|
priority = Some "bad";
|
|
content = None;
|
|
}
|
|
in
|
|
expect_error_code "task bad priority" "invalid-options"
|
|
(List_command.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
task);
|
|
let node =
|
|
List_command.Parsed_node
|
|
{
|
|
common = empty_common_opts;
|
|
tags = Vec.empty;
|
|
properties = Vec.empty;
|
|
}
|
|
in
|
|
expect_error_code "node requires filters" "invalid-options"
|
|
(List_command.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
node));
|
|
|
|
test_promise
|
|
"CLI parity list execute default sort limit and explicit order contracts"
|
|
(fun () ->
|
|
let call_count = ref 0 in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/cli-list-pages" body then (
|
|
incr call_count;
|
|
match !call_count with
|
|
| 1 ->
|
|
"[[\"^ \",\"~:db/id\",11,\"~:block/title\",\"Page \
|
|
C\",\"~:block/updated-at\",30],[\"^ \
|
|
\",\"^0\",7,\"^1\",\"Page B\",\"^2\",10],[\"^ \
|
|
\",\"^0\",5,\"^1\",\"Page A\",\"^2\",10]]"
|
|
| 2 ->
|
|
"[[\"^ \",\"~:db/id\",4,\"~:block/title\",\"Page \
|
|
4\",\"~:block/updated-at\",4],[\"^ \
|
|
\",\"^0\",12,\"^1\",\"Page 12\",\"^2\",12],[\"^ \
|
|
\",\"^0\",1,\"^1\",\"Page 1\",\"^2\",1],[\"^ \
|
|
\",\"^0\",8,\"^1\",\"Page 8\",\"^2\",8],[\"^ \
|
|
\",\"^0\",3,\"^1\",\"Page 3\",\"^2\",3],[\"^ \
|
|
\",\"^0\",11,\"^1\",\"Page 11\",\"^2\",11],[\"^ \
|
|
\",\"^0\",2,\"^1\",\"Page 2\",\"^2\",2],[\"^ \
|
|
\",\"^0\",10,\"^1\",\"Page 10\",\"^2\",10],[\"^ \
|
|
\",\"^0\",5,\"^1\",\"Page 5\",\"^2\",5],[\"^ \
|
|
\",\"^0\",9,\"^1\",\"Page 9\",\"^2\",9],[\"^ \
|
|
\",\"^0\",6,\"^1\",\"Page 6\",\"^2\",6],[\"^ \
|
|
\",\"^0\",7,\"^1\",\"Page 7\",\"^2\",7]]"
|
|
| _ ->
|
|
"[[\"^ \
|
|
\",\"~:db/id\",3,\"~:block/title\",\"Beta\",\"~:block/updated-at\",20],[\"^ \
|
|
\",\"^0\",2,\"^1\",\"Gamma\",\"^2\",5],[\"^ \
|
|
\",\"^0\",1,\"^1\",\"Alpha\",\"^2\",10]]")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let run ?(common = empty_common_opts) () =
|
|
let action =
|
|
expect_ok "list page build"
|
|
(List_command.build cfg (Global_opts.create ())
|
|
(List_command.Parsed_page
|
|
{
|
|
common;
|
|
expand = false;
|
|
include_built_in = None;
|
|
include_journal = None;
|
|
journal_only = false;
|
|
include_hidden = false;
|
|
updated_after = None;
|
|
created_after = None;
|
|
}))
|
|
in
|
|
execute_with_output List_command.execute action cfg
|
|
Output.Mode.Human
|
|
in
|
|
let ids result =
|
|
let data = expect_some "list data" (Cli_result.data_value result) in
|
|
let items =
|
|
expect_some "items"
|
|
(Option.bind (Edn_util.get data "items") Edn_util.as_seq)
|
|
in
|
|
items
|
|
|> Vec.map (fun item ->
|
|
Int64.to_string
|
|
(expect_some "item id" (Edn_util.get_int64 item "db/id")))
|
|
|> Vec.string_concat ","
|
|
in
|
|
let* default_result = effect_to_promise (run ()) in
|
|
expect_equal "default updated-at desc with id tie" "11,7,5"
|
|
(ids default_result);
|
|
let* limited =
|
|
effect_to_promise
|
|
(run ~common:{ empty_common_opts with limit = Some 10 } ())
|
|
in
|
|
expect_equal "default limit newest records" "12,11,10,9,8,7,6,5,4,3"
|
|
(ids limited);
|
|
let* explicit_order =
|
|
effect_to_promise
|
|
(run
|
|
~common:
|
|
{ empty_common_opts with order = Some List_command.Asc }
|
|
())
|
|
in
|
|
expect_equal "explicit asc order" "2,1,3" (ids explicit_order);
|
|
let* explicit_sort =
|
|
effect_to_promise
|
|
(run ~common:{ empty_common_opts with sort = Some "title" } ())
|
|
in
|
|
expect_equal "explicit title sort desc" "2,3,1" (ids explicit_sort);
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise
|
|
"CLI parity list property execute supports cardinality sort and fields"
|
|
(fun () ->
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/cli-list-properties" body
|
|
then
|
|
"[[\"^ \
|
|
\",\"~:db/id\",30,\"~:block/title\",\"Gamma\",\"~:db/cardinality\",\"~:db.cardinality/one\"],[\"^ \
|
|
\",\"^0\",10,\"^1\",\"Alpha\",\"^2\",\"~:db.cardinality/many\"],[\"^ \
|
|
\",\"^0\",20,\"^1\",\"Beta\",\"^2\",\"~:db.cardinality/many\"]]"
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let action =
|
|
expect_ok "list property build"
|
|
(List_command.build cfg (Global_opts.create ())
|
|
(List_command.Parsed_property
|
|
{
|
|
common =
|
|
{
|
|
empty_common_opts with
|
|
sort = Some "cardinality";
|
|
fields =
|
|
Some
|
|
(Vec.of_array [| "id"; "title"; "cardinality" |]);
|
|
};
|
|
expand = false;
|
|
include_built_in = None;
|
|
with_classes = false;
|
|
with_type = true;
|
|
}))
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output List_command.execute action cfg
|
|
Output.Mode.Human)
|
|
in
|
|
let data =
|
|
expect_some "property list data" (Cli_result.data_value result)
|
|
in
|
|
let items =
|
|
expect_some "property items"
|
|
(Option.bind (Edn_util.get data "items") Edn_util.as_seq)
|
|
in
|
|
let ids =
|
|
items
|
|
|> Vec.map (fun item ->
|
|
Int64.to_string
|
|
(expect_some "item id" (Edn_util.get_int64 item "db/id")))
|
|
|> Vec.string_concat ","
|
|
in
|
|
expect_equal "cardinality sort ids" "30,20,10" ids;
|
|
Vec.iter
|
|
(fun item ->
|
|
expect_bool "has id" true
|
|
(Option.is_some (Edn_util.get item "db/id"));
|
|
expect_bool "has title" true
|
|
(Option.is_some (Edn_util.get item "block/title"));
|
|
expect_bool "has cardinality" true
|
|
(Option.is_some (Edn_util.get item "db/cardinality"));
|
|
expect_bool "only selected fields" true
|
|
(match Edn_util.as_map item with
|
|
| Some fields -> Vec.length fields = 3
|
|
| None -> false))
|
|
items;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity list asset execute filters by asset tag id"
|
|
(fun () ->
|
|
let calls = ref Vec.empty in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
calls := Vec.push_front !calls body;
|
|
if Js.String.includes ~search:"thread-api/pull" body then
|
|
"[\"^ \",\"~:db/id\",900]"
|
|
else if Js.String.includes ~search:"thread-api/cli-list-nodes" body
|
|
then (
|
|
expect_named_contains "asset tag id option" body "900";
|
|
"[[\"^ \
|
|
\",\"~:db/id\",2,\"~:block/title\",\"asset-b\",\"~:node/type\",\"block\",\"~:block/updated-at\",30],[\"^ \
|
|
\",\"^0\",1,\"^1\",\"asset-a\",\"^2\",\"block\",\"^3\",10]]")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let action =
|
|
expect_ok "list asset build"
|
|
(List_command.build cfg (Global_opts.create ())
|
|
(List_command.Parsed_asset
|
|
{ common = { empty_common_opts with limit = Some 1 } }))
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output List_command.execute action cfg
|
|
Output.Mode.Human)
|
|
in
|
|
let data =
|
|
expect_some "asset list data" (Cli_result.data_value result)
|
|
in
|
|
let items =
|
|
expect_some "asset items"
|
|
(Option.bind (Edn_util.get data "items") Edn_util.as_seq)
|
|
in
|
|
expect_int "asset limit" 1 (Vec.length items);
|
|
expect_int64 "newest asset first" 2L
|
|
(expect_some "asset id"
|
|
(Edn_util.get_int64 (Vec.peek_front items) "db/id"));
|
|
expect_int "pull plus list calls" 2 (Vec.length !calls);
|
|
Js.Promise.resolve pass));
|
|
|
|
test "CLI parity parse supports search scopes and rejects unknown option"
|
|
(fun () ->
|
|
let request =
|
|
expect_parse_ok "search tag" [| "search"; "tag"; "--content"; "quote" |]
|
|
in
|
|
match request.command with
|
|
| Cli_request.Search (Search.Parsed_tag opts) ->
|
|
expect_equal "query" "quote" opts.content
|
|
| _ ->
|
|
fail_test "expected search tag";
|
|
expect_parse_error_code "unknown search option" ":invalid-options"
|
|
[| "search"; "tag"; "--unknown"; "x"; "quote" |]);
|
|
|
|
test
|
|
"CLI parity search parser keeps content alias globals and strict \
|
|
positionals" (fun () ->
|
|
let alias =
|
|
expect_parse_ok "search block alias"
|
|
[| "search"; "block"; "-c"; "1111"; "--output"; "json" |]
|
|
in
|
|
(match alias.command with
|
|
| Cli_request.Search (Search.Parsed_block opts) ->
|
|
expect_equal "alias content" "1111" opts.content
|
|
| _ -> fail_test "expected search block");
|
|
(match alias.globals.output_format with
|
|
| Some (Output.Mode.Packed Output.Mode.Json) -> pass
|
|
| _ -> fail_test "expected search json output");
|
|
let page =
|
|
expect_parse_ok "search page multi-word"
|
|
[| "search"; "page"; "--content"; "project notes" |]
|
|
in
|
|
(match page.command with
|
|
| Cli_request.Search (Search.Parsed_page opts) ->
|
|
expect_equal "page query" "project notes" opts.content
|
|
| _ -> fail_test "expected search page");
|
|
expect_parse_error_code "search positional command" ":unknown-command"
|
|
[| "search"; "block"; "alpha" |]);
|
|
|
|
test "CLI parity search build action validates repo and query text" (fun () ->
|
|
let action =
|
|
expect_ok "search block action"
|
|
(Search.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Search.Parsed_block { content = " Alpha Beta " }))
|
|
in
|
|
expect_bool "search block scope" true (action.Search.scope = Search.Block);
|
|
expect_equal "search block command" "search-block"
|
|
(Command_id.to_string action.command);
|
|
expect_equal "search repo" "logseq_db_demo"
|
|
(Cli_primitive.string_of_repo action.repo);
|
|
expect_equal "search graph" "demo"
|
|
(Cli_primitive.string_of_graph action.graph);
|
|
expect_equal "search query trim" "Alpha Beta" action.query;
|
|
expect_error_code "search requires repo" "missing-repo"
|
|
(Search.build (config ()) (Global_opts.create ())
|
|
(Search.Parsed_page { content = "Home" }));
|
|
expect_error_code "search rejects blank content" "missing-query-text"
|
|
(Search.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Search.Parsed_tag { content = " " })));
|
|
|
|
test_promise "CLI parity search execute sorts scopes and strips raw fields"
|
|
(fun () ->
|
|
let calls = ref Vec.empty in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/q" body then (
|
|
calls := Vec.push_front !calls body;
|
|
"[[\"^ \
|
|
\",\"~:db/id\",9,\"~:block/title\",\"beta\",\"~:unused\",true],[\"^ \
|
|
\",\"^0\",7,\"^1\",\"Alpha\"]]")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let run scope command query =
|
|
execute_with_output Search.execute
|
|
{
|
|
Search.scope;
|
|
command;
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
query;
|
|
}
|
|
cfg Output.Mode.Human
|
|
in
|
|
let item_titles result =
|
|
let data =
|
|
expect_some "search data" (Cli_result.data_value result)
|
|
in
|
|
let items =
|
|
expect_some "search items"
|
|
(Option.bind (Edn_util.get data "items") Edn_util.as_seq)
|
|
in
|
|
Vec.map
|
|
(fun item ->
|
|
expect_some "item title"
|
|
(Edn_util.get_string item "block/title"))
|
|
items
|
|
in
|
|
let* block =
|
|
effect_to_promise (run Search.Block Command_id.Search_block "alpha")
|
|
in
|
|
let* page =
|
|
effect_to_promise (run Search.Page Command_id.Search_page "home")
|
|
in
|
|
let* property =
|
|
effect_to_promise
|
|
(run Search.Property Command_id.Search_property "owner")
|
|
in
|
|
let* tag =
|
|
effect_to_promise (run Search.Tag Command_id.Search_tag "quote")
|
|
in
|
|
Vec.iter
|
|
(fun result ->
|
|
expect_bool "search ok" false (Cli_result.is_error result);
|
|
expect_equal "sorted titles" "Alpha,beta"
|
|
(Vec.string_concat "," (item_titles result)))
|
|
(Vec.of_array [| block; page; property; tag |]);
|
|
expect_int "q calls" 4 (Vec.length !calls);
|
|
expect_named_contains "block query pulls deleted-at"
|
|
(Vec.nth !calls 3) "logseq.property/deleted-at";
|
|
expect_named_contains "page query uses block name" (Vec.nth !calls 2)
|
|
"block/name";
|
|
expect_named_contains "property query class" (Vec.nth !calls 1)
|
|
"logseq.class/Property";
|
|
expect_named_contains "tag query class" (Vec.nth !calls 0)
|
|
"logseq.class/Tag";
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity search execute filters recycled pages and blocks"
|
|
(fun () ->
|
|
let block_results =
|
|
"[[\"^ \",\"~:db/id\",1,\"~:block/title\",\"alpha \
|
|
live\",\"~:block/parent\",[\"^ \",\"^0\",51,\"^1\",\"Live \
|
|
Page\"]],[\"^ \",\"^0\",2,\"^1\",\"alpha orphan\",\"^2\",[\"^ \
|
|
\",\"^0\",10,\"^1\",\"intermediate\",\"^2\",[\"^ \
|
|
\",\"^0\",50,\"^1\",\"Old \
|
|
Page\",\"~:logseq.property/deleted-at\",1712000000000,\"^2\",[\"^ \
|
|
\",\"^0\",999,\"^1\",\"Recycle\"]]]],[\"^ \",\"^0\",3,\"^1\",\"alpha \
|
|
tombstone\",\"^2\",[\"^ \",\"^0\",50,\"^1\",\"Old \
|
|
Page\",\"^3\",1712000000000]]]"
|
|
in
|
|
let page_results =
|
|
"[[\"^ \",\"~:db/id\",1,\"~:block/title\",\"Home\"],[\"^ \
|
|
\",\"^0\",2,\"^1\",\"Recycled \
|
|
Home\",\"~:logseq.property/deleted-at\",1712000000000],[\"^ \
|
|
\",\"^0\",3,\"^1\",\"Homework\"]]"
|
|
in
|
|
let call_count = ref 0 in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/q" body then (
|
|
incr call_count;
|
|
if !call_count = 1 then block_results else page_results)
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let run scope command query =
|
|
execute_with_output Search.execute
|
|
{
|
|
Search.scope;
|
|
command;
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
query;
|
|
}
|
|
cfg Output.Mode.Human
|
|
in
|
|
let titles result =
|
|
let data =
|
|
expect_some "search data" (Cli_result.data_value result)
|
|
in
|
|
let items =
|
|
expect_some "items"
|
|
(Option.bind (Edn_util.get data "items") Edn_util.as_seq)
|
|
in
|
|
Vec.map
|
|
(fun item ->
|
|
expect_some "title" (Edn_util.get_string item "block/title"))
|
|
items
|
|
in
|
|
let* block =
|
|
effect_to_promise (run Search.Block Command_id.Search_block "alpha")
|
|
in
|
|
expect_equal "live block only" "alpha live"
|
|
(Vec.string_concat "," (titles block));
|
|
let* page =
|
|
effect_to_promise (run Search.Page Command_id.Search_page "home")
|
|
in
|
|
expect_equal "live pages only" "Home,Homework"
|
|
(Vec.string_concat "," (titles page));
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity search execute replaces uuid refs in block titles"
|
|
(fun () ->
|
|
let ref_uuid = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa" in
|
|
let calls = ref Vec.empty in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
calls := Vec.push_front !calls body;
|
|
if Js.String.includes ~search:"thread-api/q" body then
|
|
"[[\"^ \",\"~:db/id\",7,\"~:block/title\",\"foo \
|
|
[[aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa]]\"]]"
|
|
else if Js.String.includes ~search:"thread-api/pull" body then
|
|
"[\"^ \
|
|
\",\"~:db/id\",99,\"~:block/uuid\",\"~uaaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa\",\"~:block/title\",\"bar\"]"
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Search.execute
|
|
{
|
|
Search.scope = Search.Block;
|
|
command = Command_id.Search_block;
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
query = "foo";
|
|
}
|
|
cfg Output.Mode.Human)
|
|
in
|
|
let data = expect_some "search data" (Cli_result.data_value result) in
|
|
let items =
|
|
expect_some "items"
|
|
(Option.bind (Edn_util.get data "items") Edn_util.as_seq)
|
|
in
|
|
let title =
|
|
expect_some "title"
|
|
(Edn_util.get_string (Vec.peek_front items) "block/title")
|
|
in
|
|
expect_equal "replaced uuid ref" "foo [[bar]]" title;
|
|
expect_int "q and pull calls" 2 (Vec.length !calls);
|
|
expect_named_contains "pull lookup uuid" (Vec.peek_front !calls)
|
|
ref_uuid;
|
|
Js.Promise.resolve pass));
|
|
|
|
test "CLI parity remove validation rejects ambiguous and blank targets"
|
|
(fun () ->
|
|
expect_equal "remove page ambiguous"
|
|
"only one of --id or --page is allowed"
|
|
(expect_some "invalid"
|
|
(Remove.invalid_options
|
|
(Remove.Parsed_page { id = Some 1L; page = Some "Home" })));
|
|
expect_equal "remove tag blank" "name must be non-empty"
|
|
(expect_some "invalid"
|
|
(Remove.invalid_options
|
|
(Remove.Parsed_tag { id = None; name = Some " " }))));
|
|
|
|
test "CLI parity remove build action resolves targets and repo" (fun () ->
|
|
let block =
|
|
expect_ok "remove block ids"
|
|
(Remove.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Remove.Parsed_block { id_raw = Some "[1,2]"; uuid = None }))
|
|
in
|
|
(match block with
|
|
| Remove.Remove_block { repo; graph; id; ids; multi_id; uuid } ->
|
|
expect_equal "remove repo" "logseq_db_demo"
|
|
(Cli_primitive.string_of_repo repo);
|
|
expect_equal "remove graph" "demo"
|
|
(Cli_primitive.string_of_graph graph);
|
|
expect_none "remove block single id" id;
|
|
expect_int "remove block ids" 2 (Vec.length ids);
|
|
expect_bool "remove block multi" true multi_id;
|
|
expect_none "remove block uuid none" uuid
|
|
| _ -> fail_test "expected remove block");
|
|
let block_uuid =
|
|
expect_ok "remove block uuid"
|
|
(Remove.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Remove.Parsed_block
|
|
{
|
|
id_raw = None;
|
|
uuid = Some "00000000-0000-4000-8000-000000000001";
|
|
}))
|
|
in
|
|
(match block_uuid with
|
|
| Remove.Remove_block { uuid = Some uuid; multi_id; ids; _ } ->
|
|
expect_equal "remove block uuid"
|
|
"00000000-0000-4000-8000-000000000001" uuid;
|
|
expect_bool "remove uuid multi" false multi_id;
|
|
expect_int "remove uuid ids" 0 (Vec.length ids)
|
|
| _ -> fail_test "expected uuid remove block");
|
|
let page =
|
|
expect_ok "remove page by title"
|
|
(Remove.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Remove.Parsed_page { id = None; page = Some " Home " }))
|
|
in
|
|
(match page with
|
|
| Remove.Remove_page { page = Some page; id = None; _ } ->
|
|
expect_equal "remove page trims" "Home" page
|
|
| _ -> fail_test "expected remove page by title");
|
|
let tag =
|
|
expect_ok "remove tag by id"
|
|
(Remove.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Remove.Parsed_tag { id = Some 42L; name = None }))
|
|
in
|
|
(match tag with
|
|
| Remove.Remove_tag { id = Some 42L; name = None; _ } -> pass
|
|
| _ -> fail_test "expected remove tag by id");
|
|
expect_error_code "remove requires repo" "missing-repo"
|
|
(Remove.build (config ()) (Global_opts.create ())
|
|
(Remove.Parsed_block { id_raw = Some "1"; uuid = None }));
|
|
expect_error_code "remove block missing target" "missing-target"
|
|
(Remove.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Remove.Parsed_block { id_raw = None; uuid = None }));
|
|
expect_error_code "remove page missing" "missing-page-name"
|
|
(Remove.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Remove.Parsed_page { id = None; page = None })));
|
|
|
|
test_promise "CLI parity remove page unwraps apply result map" (fun () ->
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/cli-list-pages" body then
|
|
"[[\"^ \
|
|
\",\"~:db/id\",190,\"~:block/title\",\"Home\",\"~:block/name\",\"home\",\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000190\"]]"
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then "[\"^ \",\"~:result\",true]"
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let action =
|
|
Remove.Remove_page
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
id = None;
|
|
page = Some "Home";
|
|
}
|
|
in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Remove.execute action cfg Output.Mode.Json)
|
|
in
|
|
expect_bool "remove page succeeds" false (Cli_result.is_error result);
|
|
let data = expect_some "remove page data" (Cli_result.data_value result) in
|
|
expect_bool "remove page result" true
|
|
(expect_some "remove page result bool"
|
|
(Edn_util.get_bool data "result"));
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity remove block rejects page entities before delete"
|
|
(fun () ->
|
|
let apply_called = ref false in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/pull" body then
|
|
"[\"^ \
|
|
\",\"~:db/id\",190,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000190\",\"~:block/name\",\"some-page\"]"
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then (
|
|
apply_called := true;
|
|
"[\"^ \",\"~:result\",true]")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let action =
|
|
Remove.Remove_block
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
id = Some 190L;
|
|
ids = Vec.singleton 190L;
|
|
multi_id = false;
|
|
uuid = None;
|
|
}
|
|
in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Remove.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "remove page target is error" true
|
|
(Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "remove page target code" "invalid-target"
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test "expected remove error");
|
|
expect_bool "delete not called" false !apply_called;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity remove block by id deletes resolved block uuid"
|
|
(fun () ->
|
|
let captured_apply_body = ref None in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/pull" body then
|
|
"[\"^ \
|
|
\",\"~:db/id\",190,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000190\"]"
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then (
|
|
captured_apply_body := Some body;
|
|
"[\"^ \",\"~:result\",true]")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let action =
|
|
Remove.Remove_block
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
id = Some 190L;
|
|
ids = Vec.singleton 190L;
|
|
multi_id = false;
|
|
uuid = None;
|
|
}
|
|
in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Remove.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "remove block succeeds" false (Cli_result.is_error result);
|
|
let body = expect_some "captured apply body" !captured_apply_body in
|
|
expect_named_contains "delete method" body
|
|
"thread-api/apply-outliner-ops";
|
|
expect_named_contains "delete op" body "delete-blocks";
|
|
expect_named_contains "delete uuid" body
|
|
"00000000-0000-4000-8000-000000000190";
|
|
Js.Promise.resolve pass));
|
|
|
|
test "CLI parity show target resolves stdin ids vectors ids uuid and pages"
|
|
(fun () ->
|
|
expect_equal "stdin trim" "42"
|
|
(expect_some "stdin" (Show.normalize_stdin_id (Some " 42\n")));
|
|
expect_none "blank stdin" (Show.normalize_stdin_id (Some " \n"));
|
|
let by_id =
|
|
expect_ok "show id"
|
|
(Show.resolve_target
|
|
{
|
|
id_raw = Some "42";
|
|
uuid = None;
|
|
page = None;
|
|
page_hierarchy = false;
|
|
linked_references = None;
|
|
ref_id_footer = None;
|
|
level = None;
|
|
stdin_id = None;
|
|
})
|
|
in
|
|
(match by_id with
|
|
| Show.By_id 42L -> pass
|
|
| _ -> fail_test "expected By_id 42");
|
|
let multi =
|
|
expect_ok "show ids"
|
|
(Show.resolve_target
|
|
{
|
|
id_raw = Some "[1,2]";
|
|
uuid = None;
|
|
page = None;
|
|
page_hierarchy = false;
|
|
linked_references = None;
|
|
ref_id_footer = None;
|
|
level = None;
|
|
stdin_id = None;
|
|
})
|
|
in
|
|
(match multi with
|
|
| Show.By_ids ids ->
|
|
expect_int "show id count" 2 (Vec.length ids);
|
|
expect_int64 "show first id" 1L (Vec.nth ids 0);
|
|
expect_int64 "show second id" 2L (Vec.nth ids 1)
|
|
| _ -> fail_test "expected By_ids");
|
|
expect_equal "ambiguous show"
|
|
"only one of --id, --uuid, or --page is allowed"
|
|
(expect_some "invalid"
|
|
(Show.invalid_options
|
|
{
|
|
id_raw = Some "1";
|
|
uuid = Some "00000000-0000-4000-8000-000000000001";
|
|
page = None;
|
|
page_hierarchy = false;
|
|
linked_references = None;
|
|
ref_id_footer = None;
|
|
level = None;
|
|
stdin_id = None;
|
|
})));
|
|
|
|
test "CLI parity show build threads hierarchy references footer and level"
|
|
(fun () ->
|
|
let base_opts =
|
|
{
|
|
Show.id_raw = Some "42";
|
|
uuid = None;
|
|
page = None;
|
|
page_hierarchy = false;
|
|
linked_references = None;
|
|
ref_id_footer = None;
|
|
level = None;
|
|
stdin_id = None;
|
|
}
|
|
in
|
|
let default_action =
|
|
expect_ok "show defaults"
|
|
(Show.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Show.Parsed_show base_opts))
|
|
in
|
|
expect_equal "show repo" "logseq_db_demo"
|
|
(repo_text default_action.Show.repo);
|
|
expect_equal "show graph" "demo" (graph_text default_action.Show.graph);
|
|
(match default_action.Show.target with
|
|
| Show.By_id 42L -> pass
|
|
| _ -> fail_test "expected By_id target");
|
|
expect_bool "single id" false default_action.Show.multi_id;
|
|
expect_bool "linked refs default" true
|
|
default_action.Show.linked_references;
|
|
expect_bool "ref id footer default" true default_action.Show.ref_id_footer;
|
|
expect_bool "page hierarchy default" false
|
|
default_action.Show.page_hierarchy;
|
|
expect_int "default level" 10
|
|
(expect_some "level" default_action.Show.level);
|
|
let custom_action =
|
|
expect_ok "show custom flags"
|
|
(Show.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Show.Parsed_show
|
|
{
|
|
base_opts with
|
|
id_raw = Some "[1,2]";
|
|
linked_references = Some false;
|
|
ref_id_footer = Some false;
|
|
page_hierarchy = true;
|
|
level = Some 3;
|
|
}))
|
|
in
|
|
(match custom_action.Show.target with
|
|
| Show.By_ids ids ->
|
|
expect_int "multi id count" 2 (Vec.length ids);
|
|
expect_int64 "multi first id" 1L (Vec.nth ids 0);
|
|
expect_int64 "multi second id" 2L (Vec.nth ids 1)
|
|
| _ -> fail_test "expected multi-id target");
|
|
expect_bool "multi id flag" true custom_action.Show.multi_id;
|
|
expect_bool "linked refs disabled" false
|
|
custom_action.Show.linked_references;
|
|
expect_bool "ref id footer disabled" false
|
|
custom_action.Show.ref_id_footer;
|
|
expect_bool "page hierarchy enabled" true
|
|
custom_action.Show.page_hierarchy;
|
|
expect_int "custom level" 3
|
|
(expect_some "custom level" custom_action.Show.level);
|
|
expect_error_code "show requires repo" "missing-repo"
|
|
(Show.build (config ()) (Global_opts.create ())
|
|
(Show.Parsed_show base_opts));
|
|
expect_error_code "show invalid level" "invalid-options"
|
|
(Show.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Show.Parsed_show { base_opts with level = Some 0 })));
|
|
|
|
test_promise "CLI parity show rejects recycled pages" (fun () ->
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/pull" body then
|
|
"[\"^ \
|
|
\",\"~:db/id\",42,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000042\",\"~:block/name\",\"home\",\"~:block/title\",\"Home\",\"~:logseq.property/deleted-at\",1712000000000]"
|
|
else if Js.String.includes ~search:"thread-api/q" body then "[]"
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let action =
|
|
{
|
|
Show.repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
target = Show.By_page "home";
|
|
multi_id = false;
|
|
linked_references = false;
|
|
ref_id_footer = false;
|
|
page_hierarchy = false;
|
|
level = Some 10;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Show.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "show recycled page errors" true
|
|
(Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "show recycled code" "recycled-page"
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test "expected show error");
|
|
Js.Promise.resolve pass));
|
|
|
|
test
|
|
"CLI parity upsert validation rejects ambiguous and mode-specific options"
|
|
(fun () ->
|
|
expect_equal "upsert page ambiguous"
|
|
"only one of --id or --page is allowed"
|
|
(expect_some "invalid"
|
|
(Upsert.invalid_options
|
|
(Upsert.Parsed_page
|
|
{
|
|
id = Some 1L;
|
|
page = Some "Home";
|
|
restore = false;
|
|
update_tags_edn = None;
|
|
update_properties_edn = None;
|
|
remove_tags_edn = None;
|
|
remove_properties_edn = None;
|
|
})));
|
|
expect_equal "asset missing path" "--path is required in create mode"
|
|
(expect_some "invalid"
|
|
(Upsert.invalid_options
|
|
(Upsert.Parsed_asset
|
|
{
|
|
id = None;
|
|
uuid = None;
|
|
path = None;
|
|
target_id = None;
|
|
target_uuid = None;
|
|
target_page = None;
|
|
pos = None;
|
|
content = None;
|
|
})));
|
|
expect_equal "task no status conflict"
|
|
"--status and --no-status are mutually exclusive"
|
|
(expect_some "invalid"
|
|
(Upsert.invalid_options
|
|
(Upsert.Parsed_task
|
|
{
|
|
id = None;
|
|
uuid = None;
|
|
page = Some "Home";
|
|
content = None;
|
|
target_id = None;
|
|
target_uuid = None;
|
|
target_page = None;
|
|
pos = None;
|
|
status = Some "todo";
|
|
priority = None;
|
|
scheduled = None;
|
|
deadline = None;
|
|
no_status = true;
|
|
no_priority = false;
|
|
no_scheduled = false;
|
|
no_deadline = false;
|
|
}))));
|
|
|
|
test "CLI parity upsert page parses restore option" (fun () ->
|
|
let request =
|
|
expect_parse_ok "upsert page restore"
|
|
[|
|
|
"upsert";
|
|
"page";
|
|
"--page";
|
|
"Home";
|
|
"--restore";
|
|
"--update-properties";
|
|
"{\"status\" \"done\"}";
|
|
|]
|
|
in
|
|
match request.command with
|
|
| Cli_request.Upsert (Upsert.Parsed_page opts) ->
|
|
expect_equal "page" "Home" (expect_some "page" opts.page);
|
|
expect_bool "restore" true opts.restore
|
|
| _ -> fail_test "expected upsert page");
|
|
|
|
test_promise "CLI parity upsert page rejects recycled page by default"
|
|
(fun () ->
|
|
let apply_called = ref false in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/q" body then
|
|
"[[\"^ \
|
|
\",\"~:db/id\",50,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000050\",\"~:block/name\",\"home\",\"~:block/title\",\"Home\",\"~:logseq.property/deleted-at\",1712000000000]]"
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then (
|
|
apply_called := true;
|
|
"true")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let action =
|
|
Upsert.Upsert_page
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
mode = Upsert.Create;
|
|
id = None;
|
|
page = Some "Home";
|
|
restore = false;
|
|
plan = Property.empty_update_plan;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Upsert.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "upsert recycled page errors" true
|
|
(Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "upsert recycled code" "recycled-page"
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test "expected upsert error");
|
|
expect_bool "no ops applied" false !apply_called;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity upsert page update rejects recycled page by default"
|
|
(fun () ->
|
|
let apply_called = ref false in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/pull" body then
|
|
"[\"^ \
|
|
\",\"~:db/id\",50,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000050\",\"~:block/name\",\"home\",\"~:block/title\",\"Home\",\"~:logseq.property/deleted-at\",1712000000000]"
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then (
|
|
apply_called := true;
|
|
"true")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let action =
|
|
Upsert.Upsert_page
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
mode = Upsert.Update;
|
|
id = Some 50L;
|
|
page = None;
|
|
restore = false;
|
|
plan = Property.empty_update_plan;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Upsert.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "upsert recycled page update errors" true
|
|
(Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "upsert recycled update code" "recycled-page"
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test "expected upsert update error");
|
|
expect_bool "no update ops applied" false !apply_called;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity upsert page restores recycled page when requested"
|
|
(fun () ->
|
|
let apply_calls = ref Vec.empty in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/q" body then
|
|
"[[\"^ \
|
|
\",\"~:db/id\",50,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000050\",\"~:block/name\",\"home\",\"~:block/title\",\"Home\",\"~:logseq.property/deleted-at\",1712000000000]]"
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then (
|
|
apply_calls := Vec.push_back !apply_calls body;
|
|
"true")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let plan =
|
|
{
|
|
Property.empty_update_plan with
|
|
update_properties =
|
|
Vec.of_array
|
|
[|
|
|
{
|
|
Property.key =
|
|
Property.Key_ident
|
|
(Edn_util.keyword_t "user.property/status");
|
|
value = Edn_util.string "done";
|
|
};
|
|
|];
|
|
}
|
|
in
|
|
let action =
|
|
Upsert.Upsert_page
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
mode = Upsert.Create;
|
|
id = None;
|
|
page = Some "Home";
|
|
restore = true;
|
|
plan;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Upsert.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "upsert restore ok" false (Cli_result.is_error result);
|
|
expect_int "restore then update calls" 2 (Vec.length !apply_calls);
|
|
expect_named_contains "first op restores recycled page"
|
|
(Vec.nth !apply_calls 0) "restore-recycled";
|
|
expect_named_contains "second op updates restored page"
|
|
(Vec.nth !apply_calls 1) "batch-set-property";
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise
|
|
"CLI parity upsert page restore rejects recycled page without uuid"
|
|
(fun () ->
|
|
let apply_called = ref false in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/q" body then
|
|
"[[\"^ \
|
|
\",\"~:db/id\",50,\"~:block/name\",\"home\",\"~:block/title\",\"Home\",\"~:logseq.property/deleted-at\",1712000000000]]"
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then (
|
|
apply_called := true;
|
|
"true")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let action =
|
|
Upsert.Upsert_page
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
mode = Upsert.Create;
|
|
id = None;
|
|
page = Some "Home";
|
|
restore = true;
|
|
plan = Property.empty_update_plan;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Upsert.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "upsert recycled restore without uuid errors" true
|
|
(Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "upsert recycled restore without uuid code"
|
|
"recycled-page"
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test "expected upsert restore error");
|
|
expect_bool "no restore ops applied" false !apply_called;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise
|
|
"CLI parity upsert page update restore rejects recycled page without uuid"
|
|
(fun () ->
|
|
let apply_called = ref false in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/pull" body then
|
|
"[\"^ \
|
|
\",\"~:db/id\",50,\"~:block/name\",\"home\",\"~:block/title\",\"Home\",\"~:logseq.property/deleted-at\",1712000000000]"
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then (
|
|
apply_called := true;
|
|
"true")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let action =
|
|
Upsert.Upsert_page
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
mode = Upsert.Update;
|
|
id = Some 50L;
|
|
page = None;
|
|
restore = true;
|
|
plan = Property.empty_update_plan;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Upsert.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "upsert recycled update restore without uuid errors" true
|
|
(Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "upsert recycled update restore without uuid code"
|
|
"recycled-page"
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test "expected upsert update restore error");
|
|
expect_bool "no update restore ops applied" false !apply_called;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity upsert block create rejects recycled target page"
|
|
(fun () ->
|
|
let apply_called = ref false in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/q" body then
|
|
"[[\"^ \
|
|
\",\"~:db/id\",50,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000050\",\"~:block/name\",\"home\",\"~:block/title\",\"Home\",\"~:logseq.property/deleted-at\",1712000000000]]"
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then (
|
|
apply_called := true;
|
|
"true")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let action =
|
|
Upsert.Upsert_block
|
|
(Upsert.Block_create
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
target = Upsert.Target_page "Home";
|
|
pos = Block.Last_child;
|
|
status = None;
|
|
tags = Vec.empty;
|
|
properties = Vec.empty;
|
|
blocks = Vec.singleton (Block.make ~title:"Child" ());
|
|
update_plan = Property.empty_update_plan;
|
|
})
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Upsert.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "upsert block create recycled target errors" true
|
|
(Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "upsert block create recycled code" "recycled-page"
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test "expected upsert block create error");
|
|
expect_bool "no create ops applied" false !apply_called;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity upsert block update rejects recycled target page"
|
|
(fun () ->
|
|
let apply_called = ref false in
|
|
let pull_count = ref 0 in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/pull" body then (
|
|
incr pull_count;
|
|
match !pull_count with
|
|
| 1 ->
|
|
"[\"^ \
|
|
\",\"~:db/id\",207,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000207\",\"~:block/title\",\"Source\"]"
|
|
| 2 ->
|
|
"[\"^ \
|
|
\",\"~:db/id\",50,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000050\",\"~:block/name\",\"home\",\"~:block/title\",\"Home\",\"~:logseq.property/deleted-at\",1712000000000]"
|
|
| _ ->
|
|
fail_test
|
|
(Printf.sprintf "unexpected pull %d: %s" !pull_count body);
|
|
"")
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then (
|
|
apply_called := true;
|
|
"true")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let action =
|
|
Upsert.Upsert_block
|
|
(Upsert.Block_update
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
source = Upsert.Source_id 207L;
|
|
target = Some (Upsert.Target_page "Home");
|
|
pos = Some Block.Last_child;
|
|
update_tags = Vec.empty;
|
|
update_properties = Vec.empty;
|
|
remove_tags = Vec.empty;
|
|
remove_properties = Vec.empty;
|
|
content = None;
|
|
source_label = Some "207";
|
|
target_label = Some "page:Home";
|
|
})
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Upsert.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "upsert block update recycled target errors" true
|
|
(Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "upsert block update recycled code" "recycled-page"
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test "expected upsert block update error");
|
|
expect_bool "no update ops applied" false !apply_called;
|
|
Js.Promise.resolve pass));
|
|
|
|
test "CLI parity upsert block update property parsing keeps update contracts"
|
|
(fun () ->
|
|
let block_update_opts =
|
|
{
|
|
Upsert.id = Some 207L;
|
|
uuid = None;
|
|
target_id = None;
|
|
target_uuid = None;
|
|
target_page = None;
|
|
pos = None;
|
|
content = None;
|
|
blocks_edn = None;
|
|
blocks_file = None;
|
|
update_tags_edn = None;
|
|
update_properties_edn = None;
|
|
remove_tags_edn = None;
|
|
remove_properties_edn = None;
|
|
}
|
|
in
|
|
expect_error_code "update-properties vector" "invalid-options"
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_block
|
|
{ block_update_opts with update_properties_edn = Some "[\"p1\"]" }));
|
|
expect_error_code "update-tags map" "invalid-options"
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_block
|
|
{ block_update_opts with update_tags_edn = Some "{\"t1\" true}" }));
|
|
let action =
|
|
expect_ok "valid update-properties map"
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_block
|
|
{
|
|
block_update_opts with
|
|
update_properties_edn = Some "{\"p1\" \"val\"}";
|
|
}))
|
|
in
|
|
match action with
|
|
| Upsert.Upsert_block (Upsert.Block_update update) ->
|
|
expect_int "update property count" 1
|
|
(Vec.length update.update_properties);
|
|
expect_equal "update property key" "p1"
|
|
(property_key_text
|
|
(Vec.peek_front update.update_properties).Property.key)
|
|
| _ -> fail_test "expected Upsert_block update action");
|
|
|
|
test "CLI parity upsert tag parses schema property vectors" (fun () ->
|
|
let action =
|
|
expect_ok "valid tag schema properties"
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_tag
|
|
{
|
|
id = None;
|
|
name = Some "Project";
|
|
add_properties_edn = Some "[\"status\" :user.property/owner]";
|
|
remove_properties_edn = Some "[123]";
|
|
}))
|
|
in
|
|
(match action with
|
|
| Upsert.Upsert_tag
|
|
{ mode = Upsert.Create; add_properties; remove_properties; _ } ->
|
|
expect_int "add property count" 2 (Vec.length add_properties);
|
|
expect_equal "add property by name" "status"
|
|
(property_key_text (Vec.peek_front add_properties));
|
|
expect_equal "remove property by id" "123"
|
|
(property_key_text (Vec.peek_front remove_properties))
|
|
| _ -> fail_test "expected Upsert_tag create action");
|
|
expect_error_code "add-properties map" "invalid-options"
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_tag
|
|
{
|
|
id = None;
|
|
name = Some "Project";
|
|
add_properties_edn = Some "{\"status\" true}";
|
|
remove_properties_edn = None;
|
|
})));
|
|
|
|
test
|
|
"CLI parity upsert task build preserves create update and clear semantics"
|
|
(fun () ->
|
|
let base_task_opts =
|
|
{
|
|
Upsert.id = None;
|
|
uuid = None;
|
|
page = None;
|
|
content = None;
|
|
target_id = None;
|
|
target_uuid = None;
|
|
target_page = None;
|
|
pos = None;
|
|
status = None;
|
|
priority = None;
|
|
scheduled = None;
|
|
deadline = None;
|
|
no_status = false;
|
|
no_priority = false;
|
|
no_scheduled = false;
|
|
no_deadline = false;
|
|
}
|
|
in
|
|
let build_task name opts =
|
|
expect_ok name
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_task opts))
|
|
in
|
|
expect_error_code "task requires target" "missing-target"
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_task base_task_opts));
|
|
expect_error_code "task rejects page and content" "invalid-options"
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_task
|
|
{ base_task_opts with page = Some "Home"; content = Some "Task" }));
|
|
let scheduled =
|
|
expect_some "scheduled date"
|
|
(Time.parse_rfc3339 "2026-02-10T08:00:00.000Z")
|
|
in
|
|
let deadline =
|
|
expect_some "deadline date"
|
|
(Time.parse_rfc3339 "2026-02-12T18:00:00.000Z")
|
|
in
|
|
let created =
|
|
build_task "create task"
|
|
{
|
|
base_task_opts with
|
|
content = Some "Task from CLI";
|
|
status = Some "todo";
|
|
priority = Some "high";
|
|
scheduled = Some scheduled;
|
|
deadline = Some deadline;
|
|
}
|
|
in
|
|
(match created with
|
|
| Upsert.Upsert_task task ->
|
|
expect_bool "create mode" true (task.mode = Upsert.Create);
|
|
expect_equal "create repo" "logseq_db_demo" (repo_text task.repo);
|
|
expect_equal "create graph" "demo" (graph_text task.graph);
|
|
expect_equal "create content" "Task from CLI"
|
|
(expect_some "content" task.content);
|
|
expect_equal "status input" "todo"
|
|
(expect_some "status input" task.status_input);
|
|
let property_keys =
|
|
task.update_properties
|
|
|> Vec.map (fun item -> item.Property.key)
|
|
|> Vec.map property_key_text
|
|
in
|
|
expect_bool "priority update" true
|
|
(Vec.mem "logseq.property/priority" property_keys);
|
|
expect_bool "scheduled update" true
|
|
(Vec.mem "logseq.property/scheduled" property_keys);
|
|
expect_bool "deadline update" true
|
|
(Vec.mem "logseq.property/deadline" property_keys)
|
|
| _ -> fail_test "expected Upsert_task create action");
|
|
let updated =
|
|
build_task "update task"
|
|
{
|
|
base_task_opts with
|
|
id = Some 42L;
|
|
no_status = true;
|
|
no_priority = true;
|
|
no_scheduled = true;
|
|
no_deadline = true;
|
|
}
|
|
in
|
|
(match updated with
|
|
| Upsert.Upsert_task task ->
|
|
expect_bool "update mode" true (task.mode = Upsert.Update);
|
|
expect_int64 "update id" 42L (expect_some "update id" task.id);
|
|
let clear_keys = task.clear_properties |> Vec.map property_key_text in
|
|
expect_bool "clear status" true
|
|
(Vec.mem "logseq.property/status" clear_keys);
|
|
expect_bool "clear priority" true
|
|
(Vec.mem "logseq.property/priority" clear_keys);
|
|
expect_bool "clear scheduled" true
|
|
(Vec.mem "logseq.property/scheduled" clear_keys);
|
|
expect_bool "clear deadline" true
|
|
(Vec.mem "logseq.property/deadline" clear_keys)
|
|
| _ -> fail_test "expected Upsert_task update action");
|
|
Vec.iter
|
|
(fun opts ->
|
|
expect_error_code "task set no conflict" "invalid-options"
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_task opts)))
|
|
(Vec.of_array
|
|
[|
|
|
{
|
|
base_task_opts with
|
|
id = Some 42L;
|
|
status = Some "todo";
|
|
no_status = true;
|
|
};
|
|
{
|
|
base_task_opts with
|
|
id = Some 42L;
|
|
priority = Some "high";
|
|
no_priority = true;
|
|
};
|
|
{
|
|
base_task_opts with
|
|
id = Some 42L;
|
|
scheduled = Some scheduled;
|
|
no_scheduled = true;
|
|
};
|
|
{
|
|
base_task_opts with
|
|
id = Some 42L;
|
|
deadline = Some deadline;
|
|
no_deadline = true;
|
|
};
|
|
|]);
|
|
let unknown_status =
|
|
build_task "unknown status"
|
|
{
|
|
base_task_opts with
|
|
content = Some "Task from CLI";
|
|
status = Some "wat";
|
|
}
|
|
in
|
|
(match unknown_status with
|
|
| Upsert.Upsert_task task ->
|
|
expect_bool "unknown status create mode" true
|
|
(task.mode = Upsert.Create);
|
|
expect_equal "unknown status input" "wat"
|
|
(expect_some "unknown status input" task.status_input)
|
|
| _ -> fail_test "expected Upsert_task unknown status action");
|
|
let invalid_priority =
|
|
Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_task
|
|
{
|
|
base_task_opts with
|
|
content = Some "Task from CLI";
|
|
priority = Some "wat";
|
|
})
|
|
in
|
|
expect_error_code "invalid priority code" "invalid-options"
|
|
invalid_priority;
|
|
match invalid_priority with
|
|
| Error err ->
|
|
expect_named_contains "invalid priority message" err.Error.message
|
|
"Invalid value for option :priority: wat";
|
|
expect_named_contains "invalid priority values" err.Error.message
|
|
"Available values: low, medium, high, urgent"
|
|
| Ok _ -> fail_test "expected invalid priority");
|
|
|
|
test "CLI parity upsert asset build derives title and selector modes"
|
|
(fun () ->
|
|
let base_asset_opts =
|
|
{
|
|
Upsert.id = None;
|
|
uuid = None;
|
|
path = None;
|
|
target_id = None;
|
|
target_uuid = None;
|
|
target_page = Some "Home";
|
|
pos = None;
|
|
content = None;
|
|
}
|
|
in
|
|
let created =
|
|
expect_ok "asset create"
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_asset
|
|
{ base_asset_opts with path = Some "/tmp/images/team-logo.png" }))
|
|
in
|
|
(match created with
|
|
| Upsert.Upsert_asset asset ->
|
|
expect_bool "asset create mode" true (asset.mode = Upsert.Create);
|
|
expect_equal "asset create path" "/tmp/images/team-logo.png"
|
|
(expect_some "asset path" asset.path);
|
|
expect_equal "asset default title" "team-logo.png"
|
|
(expect_some "asset content" asset.content);
|
|
ignore (expect_some "asset create action" asset.create_action)
|
|
| _ -> fail_test "expected Upsert_asset create action");
|
|
let updated =
|
|
expect_ok "asset update"
|
|
(Upsert.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Upsert.Parsed_asset
|
|
{
|
|
base_asset_opts with
|
|
id = Some 42L;
|
|
target_page = None;
|
|
content = Some "Caption";
|
|
}))
|
|
in
|
|
match updated with
|
|
| Upsert.Upsert_asset asset ->
|
|
expect_bool "asset update mode" true (asset.mode = Upsert.Update);
|
|
expect_int64 "asset id" 42L (expect_some "asset id" asset.id);
|
|
expect_none "asset update path ignored" asset.path;
|
|
expect_equal "asset update content" "Caption"
|
|
(expect_some "asset update content" asset.content)
|
|
| _ -> fail_test "expected Upsert_asset update action");
|
|
|
|
test "CLI parity property and block option parsers normalize known values"
|
|
(fun () ->
|
|
expect_bool "position first-child" true
|
|
(Block.position_of_string "first-child" = Some Block.First_child);
|
|
expect_bool "position sibling" true
|
|
(Block.position_of_string "sibling" = Some Block.Sibling);
|
|
expect_none "position invalid" (Block.position_of_string "middle");
|
|
expect_bool "property url kind" true
|
|
(Property.kind_of_string "url" = Some Property.Url);
|
|
expect_equal "property kind string" "date"
|
|
(Property.string_of_kind Property.Date);
|
|
expect_equal "property other kind string" "user.property/custom"
|
|
(Property.string_of_kind
|
|
(Property.Other (Edn_util.keyword_t "user.property/custom")));
|
|
expect_bool "cardinality many" true
|
|
(Property.cardinality_of_string "many" = Some Property.Many);
|
|
expect_none "bad cardinality" (Property.cardinality_of_string "all");
|
|
(match Property.parse_key (Edn_util.int64 801L) with
|
|
| Some (Property.Key_id 801L) -> pass
|
|
| _ -> fail_test "expected property key id");
|
|
(match Property.parse_key (Edn_util.keyword "user.property/rating") with
|
|
| Some (Property.Key_ident ident) ->
|
|
expect_equal "property ident key" "user.property/rating"
|
|
(Edn_util.keyword_to_string ident)
|
|
| _ -> fail_test "expected property key ident");
|
|
(match Property.parse_key (Edn_util.string "Correct Answer") with
|
|
| Some (Property.Key_name name) ->
|
|
expect_equal "property name key" "Correct Answer" name
|
|
| _ -> fail_test "expected property key name");
|
|
expect_none "property key rejects bool"
|
|
(Property.parse_key (Edn_util.bool true));
|
|
let child =
|
|
Block.make ~uuid:"00000000-0000-4000-8000-000000000102" ~title:"Child"
|
|
()
|
|
in
|
|
let root =
|
|
Block.make ~uuid:"00000000-0000-4000-8000-000000000101" ~title:"Root"
|
|
~children:(Vec.singleton child) ()
|
|
in
|
|
let flat = Block.flatten (Vec.singleton root) in
|
|
expect_int "flatten count" 2 (Vec.length flat);
|
|
expect_equal "flatten root first" "Root"
|
|
(expect_some "root label" (Block.label (Vec.nth flat 0)));
|
|
expect_equal "flatten child second" "Child"
|
|
(expect_some "child label" (Block.label (Vec.nth flat 1)));
|
|
let serialized = Edn_util.any (Block.to_value root) in
|
|
expect_equal "serialized block title" "Root"
|
|
(expect_some "serialized title"
|
|
(Edn_util.get_string serialized "block/title"));
|
|
expect_bool "serialized child vector" true
|
|
(Option.is_some (Edn_util.get serialized "block/children")));
|
|
|
|
test "CLI parity add block parsing preserves uuids tags and raw blocks"
|
|
(fun () ->
|
|
let parsed =
|
|
expect_ok "parse blocks"
|
|
(Add.parse_blocks_edn ~label:"blocks"
|
|
"[{:block/title \"Root\" :block/uuid #uuid \
|
|
\"00000000-0000-4000-8000-000000000301\" :block/tags \
|
|
[\"Project\" :logseq.class/Tag] :block/children [{:block/content \
|
|
\"Child\" :block/uuid #uuid \
|
|
\"00000000-0000-4000-8000-000000000302\"}]} \"Loose\"]")
|
|
in
|
|
expect_int "parsed block count" 2 (Vec.length parsed);
|
|
let root = Vec.nth parsed 0 in
|
|
expect_equal "root title" "Root" (expect_some "root title" root.title);
|
|
expect_equal "root uuid" "00000000-0000-4000-8000-000000000301"
|
|
(expect_some "root uuid" root.uuid);
|
|
expect_int "root tags" 2 (Vec.length root.tags);
|
|
expect_int "root children" 1 (Vec.length root.children);
|
|
expect_equal "child content title" "Child"
|
|
(expect_some "child title" (Vec.peek_front root.children).title);
|
|
expect_equal "string block title" "Loose"
|
|
(expect_some "loose title" (Vec.nth parsed 1).title);
|
|
expect_error_code "blocks must be vector" "invalid-blocks"
|
|
(Add.parse_blocks_edn ~label:"blocks" "{:block/title \"Root\"}");
|
|
expect_error_code "invalid blocks edn" "invalid-options"
|
|
(Add.parse_blocks_edn ~label:"blocks" "[{:block/title"));
|
|
|
|
test "CLI parity add collect created block uuids depth-first and unique"
|
|
(fun () ->
|
|
let nested =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "block/uuid",
|
|
Edn_util.uuid "00000000-0000-4000-8000-000000000401" );
|
|
( Edn_util.keyword "block/children",
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "block/uuid",
|
|
Edn_util.uuid "00000000-0000-4000-8000-000000000402" );
|
|
];
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "block/title", Edn_util.string "No uuid");
|
|
( Edn_util.keyword "block/children",
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "block/uuid",
|
|
Edn_util.uuid
|
|
"00000000-0000-4000-8000-000000000403" );
|
|
];
|
|
] );
|
|
];
|
|
] );
|
|
]
|
|
in
|
|
let inserted =
|
|
Edn_util.vector
|
|
[
|
|
nested;
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "block/uuid",
|
|
Edn_util.uuid "00000000-0000-4000-8000-000000000404" );
|
|
];
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "block/uuid",
|
|
Edn_util.uuid "00000000-0000-4000-8000-000000000402" );
|
|
];
|
|
]
|
|
in
|
|
expect_equal "collected uuids"
|
|
"00000000-0000-4000-8000-000000000401,00000000-0000-4000-8000-000000000402,00000000-0000-4000-8000-000000000403,00000000-0000-4000-8000-000000000404"
|
|
(Vec.string_concat ","
|
|
(Add.collect_uuids_from_value inserted |> Add.unique));
|
|
let child =
|
|
Block.make ~uuid:"00000000-0000-4000-8000-000000000502" ~title:"Child"
|
|
()
|
|
in
|
|
let root =
|
|
Block.make ~uuid:"00000000-0000-4000-8000-000000000501" ~title:"Root"
|
|
~children:(Vec.singleton child) ()
|
|
in
|
|
let duplicate =
|
|
Block.make ~uuid:"00000000-0000-4000-8000-000000000502"
|
|
~title:"Duplicate" ()
|
|
in
|
|
expect_equal "action uuids"
|
|
"00000000-0000-4000-8000-000000000501,00000000-0000-4000-8000-000000000502"
|
|
(Vec.string_concat ","
|
|
(Add.collect_action_block_uuids (Vec.of_array [| root; duplicate |]))));
|
|
|
|
test "CLI parity add action validates targets metadata and status" (fun () ->
|
|
let base_opts =
|
|
{
|
|
Add.target_id = None;
|
|
target_uuid = None;
|
|
target_page_name = Some "Home";
|
|
pos = None;
|
|
status = None;
|
|
tags_edn = None;
|
|
properties_edn = None;
|
|
content = Some "Hello from add";
|
|
blocks_edn = None;
|
|
blocks_file = None;
|
|
}
|
|
in
|
|
expect_error_code "ambiguous target" "invalid-options"
|
|
(Add.build_add_block_action
|
|
{ base_opts with target_id = Some 42L }
|
|
Vec.empty
|
|
(Cli_primitive.create_repo "demo"));
|
|
expect_error_code "invalid target uuid" "invalid-options"
|
|
(Add.build_add_block_action
|
|
{ base_opts with target_page_name = None; target_uuid = Some "bad" }
|
|
Vec.empty
|
|
(Cli_primitive.create_repo "demo"));
|
|
expect_error_code "sibling requires block target" "invalid-options"
|
|
(Add.build_add_block_action
|
|
{ base_opts with pos = Some Block.Sibling }
|
|
Vec.empty
|
|
(Cli_primitive.create_repo "demo"));
|
|
expect_error_code "blocks cannot combine metadata" "invalid-options"
|
|
(Add.build_add_block_action
|
|
{
|
|
base_opts with
|
|
blocks_edn = Some "[\"Block\"]";
|
|
tags_edn = Some "[\"Project\"]";
|
|
}
|
|
Vec.empty
|
|
(Cli_primitive.create_repo "demo"));
|
|
expect_error_code "invalid status" "invalid-options"
|
|
(Add.build_add_block_action
|
|
{ base_opts with status = Some "wat" }
|
|
Vec.empty
|
|
(Cli_primitive.create_repo "demo"));
|
|
let action =
|
|
expect_ok "add action"
|
|
(Add.build_add_block_action
|
|
{
|
|
base_opts with
|
|
status = Some "in progress";
|
|
tags_edn =
|
|
Some
|
|
"[\"Project\" :logseq.class/Tag #uuid \
|
|
\"00000000-0000-4000-8000-000000000601\" 701]";
|
|
properties_edn = Some "{\"Correct Answer\" \"42\" 801 true}";
|
|
}
|
|
Vec.empty
|
|
(Cli_primitive.create_repo "demo"))
|
|
in
|
|
expect_equal "repo" "logseq_db_demo" (repo_text action.repo);
|
|
expect_equal "graph" "demo" (graph_text action.graph);
|
|
expect_bool "default position" true (action.pos = Block.Last_child);
|
|
expect_equal "normalized status" "logseq.property/status.doing"
|
|
(keyword_text (expect_some "status" action.status));
|
|
expect_int "tag selectors" 4 (Vec.length action.tags);
|
|
expect_int "property assignments" 2 (Vec.length action.properties);
|
|
expect_int "block count" 1 (Vec.length action.blocks);
|
|
expect_equal "content block" "Hello from add"
|
|
(expect_some "block title" (Vec.peek_front action.blocks).title);
|
|
ignore (expect_some "generated uuid" (Vec.peek_front action.blocks).uuid));
|
|
|
|
test "CLI parity add metadata ops apply status tags and properties by uuid"
|
|
(fun () ->
|
|
let ops =
|
|
Add.metadata_ops
|
|
(Vec.of_array
|
|
[|
|
|
"00000000-0000-4000-8000-000000000701";
|
|
"00000000-0000-4000-8000-000000000702";
|
|
|])
|
|
(Some (Edn_util.keyword_t "logseq.property/status.todo"))
|
|
(Vec.of_array
|
|
[|
|
|
Entity.of_value
|
|
(Edn_util.map_vec
|
|
(Vec.singleton
|
|
(Edn_util.keyword "db/id", Edn_util.int64 901L)));
|
|
Entity.of_value
|
|
(Edn_util.map_vec
|
|
(Vec.singleton
|
|
(Edn_util.keyword "db/id", Edn_util.int64 901L)));
|
|
|])
|
|
(Vec.of_array
|
|
[|
|
|
{
|
|
Property.key =
|
|
Property.Key_ident
|
|
(Edn_util.keyword_t "user.property/root-answer");
|
|
value = Edn_util.string "root";
|
|
};
|
|
|])
|
|
in
|
|
expect_int "metadata ops count" 3 (Vec.length ops);
|
|
let output =
|
|
Vec.string_concat "\n" (Vec.map Melange_edn_melange.to_edn_string ops)
|
|
in
|
|
expect_named_contains "status op" output ":logseq.property/status.todo";
|
|
expect_named_contains "tag op" output ":block/tags 901";
|
|
expect_named_contains "property op" output
|
|
":user.property/root-answer \"root\"");
|
|
|
|
test_promise
|
|
"CLI parity add reports target-not-found when concurrent delete removes \
|
|
insert target" (fun () ->
|
|
let pull_count = ref 0 in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/pull" body then (
|
|
incr pull_count;
|
|
match !pull_count with
|
|
| 1 ->
|
|
"[\"^ \
|
|
\",\"~:db/id\",627,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000627\"]"
|
|
| _ -> "null")
|
|
else if
|
|
Js.String.includes ~search:"thread-api/apply-outliner-ops" body
|
|
then "null"
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let action =
|
|
expect_ok "add action"
|
|
(Add.build_add_block_action
|
|
{
|
|
Add.target_id = Some 627L;
|
|
target_uuid = None;
|
|
target_page_name = None;
|
|
pos = Some Block.First_child;
|
|
status = None;
|
|
tags_edn = None;
|
|
properties_edn = None;
|
|
content = Some "Child";
|
|
blocks_edn = None;
|
|
blocks_file = None;
|
|
}
|
|
Vec.empty
|
|
(Cli_primitive.create_repo "demo"))
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(Add.execute_add_block action
|
|
(config_with_output cfg Output.Mode.Human)
|
|
Output.Mode.Human)
|
|
in
|
|
expect_bool "add result is error" true (Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "add concurrent target delete code"
|
|
"target-not-found"
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test "expected add error");
|
|
expect_int "target was rechecked" 3 !pull_count;
|
|
Js.Promise.resolve pass));
|
|
|
|
test "CLI parity update build action validates property and tag edn"
|
|
(fun () ->
|
|
let base_opts =
|
|
{
|
|
Update.id = Some 207L;
|
|
uuid = None;
|
|
target_id = None;
|
|
target_uuid = None;
|
|
target_page = None;
|
|
pos = None;
|
|
status = None;
|
|
content = None;
|
|
update_tags_edn = None;
|
|
update_properties_edn = None;
|
|
remove_tags_edn = None;
|
|
remove_properties_edn = None;
|
|
blocks_edn = None;
|
|
blocks_file = None;
|
|
}
|
|
in
|
|
expect_error_code "update properties vector" "invalid-options"
|
|
(Update.build_action
|
|
{ base_opts with update_properties_edn = Some "[\"p1\"]" }
|
|
(Cli_primitive.create_repo "demo"));
|
|
expect_error_code "update tags map" "invalid-options"
|
|
(Update.build_action
|
|
{ base_opts with update_tags_edn = Some "{\"t1\" true}" }
|
|
(Cli_primitive.create_repo "demo"));
|
|
expect_error_code "missing source" "missing-source"
|
|
(Update.build_action
|
|
{
|
|
base_opts with
|
|
id = None;
|
|
update_properties_edn = Some "{\"p1\" 1}";
|
|
}
|
|
(Cli_primitive.create_repo "demo"));
|
|
let action =
|
|
expect_ok "valid update"
|
|
(Update.build_action
|
|
{
|
|
base_opts with
|
|
status = Some "todo";
|
|
content = Some "Updated";
|
|
target_page = Some "Archive";
|
|
update_tags_edn = Some "[\"Project\"]";
|
|
update_properties_edn = Some "{\"p1\" \"val\"}";
|
|
remove_tags_edn = Some "[701]";
|
|
remove_properties_edn = Some "[\"old-prop\"]";
|
|
}
|
|
(Cli_primitive.create_repo "demo"))
|
|
in
|
|
expect_equal "repo" "logseq_db_demo" (repo_text action.repo);
|
|
expect_equal "graph" "demo" (graph_text action.graph);
|
|
expect_int64 "source id" 207L (expect_some "id" action.id);
|
|
expect_equal "content" "Updated" (expect_some "content" action.content);
|
|
expect_equal "target page" "Archive"
|
|
(expect_some "target page" action.target_page);
|
|
expect_bool "default move position" true
|
|
(action.pos = Some Block.First_child);
|
|
expect_equal "source label" "207"
|
|
(expect_some "source label" action.source_label);
|
|
expect_equal "target label" "page:Archive"
|
|
(expect_some "target label" action.target_label);
|
|
expect_int "update tags" 1 (Vec.length action.update_tags);
|
|
expect_int "remove tags" 1 (Vec.length action.remove_tags);
|
|
expect_int "update properties include status" 2
|
|
(Vec.length action.update_properties);
|
|
expect_int "remove properties" 1 (Vec.length action.remove_properties));
|
|
|
|
test "CLI parity update tag query uses datascript find syntax" (fun () ->
|
|
let query =
|
|
Melange_edn_melange.to_edn_string (Update.tag_query Update.tag_selector)
|
|
in
|
|
expect_named_contains "find" query ":find";
|
|
expect_named_contains "tag class" query "logseq.class/Tag");
|
|
|
|
test "CLI parity sync config key parser accepts ws-url and http-base only"
|
|
(fun () ->
|
|
expect_bool "ws-url" true
|
|
(Sync.config_key_of_string "ws-url" = Some Sync.Ws_url);
|
|
expect_bool "http-base" true
|
|
(Sync.config_key_of_string "http-base" = Some Sync.Http_base);
|
|
expect_equal "ws-url string" "ws-url"
|
|
(Sync.string_of_config_key Sync.Ws_url);
|
|
expect_none "bad sync key" (Sync.config_key_of_string "graph"));
|
|
|
|
test "CLI parity sync build validates repo selectors and e2ee options"
|
|
(fun () ->
|
|
let globals =
|
|
Global_opts.create ~graph:(Cli_primitive.create_graph "demo") ()
|
|
in
|
|
expect_error_code "sync status requires repo" "missing-repo"
|
|
(Sync.build (config ()) (Global_opts.create ()) Sync.Parsed_status);
|
|
expect_error_code "sync download requires graph" "missing-graph"
|
|
(Sync.build (config ()) (Global_opts.create ())
|
|
(Sync.Parsed_download { progress = None; e2ee_password = None }));
|
|
let default_download =
|
|
expect_ok "sync download default"
|
|
(Sync.build (config ()) globals
|
|
(Sync.Parsed_download { progress = None; e2ee_password = None }))
|
|
in
|
|
(match default_download with
|
|
| Sync.Sync_download action ->
|
|
expect_equal "download repo" "logseq_db_demo" (repo_text action.repo);
|
|
expect_equal "download graph" "demo" (graph_text action.graph);
|
|
expect_bool "download allow missing" true action.allow_missing_graph;
|
|
expect_bool "download require missing" true
|
|
action.require_missing_graph;
|
|
expect_bool "download progress default" false action.progress;
|
|
expect_bool "download progress not explicit" false
|
|
action.progress_explicit
|
|
| _ -> fail_test "expected Sync_download action");
|
|
let explicit_download =
|
|
expect_ok "sync download explicit"
|
|
(Sync.build (config ()) globals
|
|
(Sync.Parsed_download
|
|
{ progress = Some false; e2ee_password = Some "pw" }))
|
|
in
|
|
(match explicit_download with
|
|
| Sync.Sync_download action ->
|
|
expect_bool "download progress false" false action.progress;
|
|
expect_bool "download progress explicit" true action.progress_explicit;
|
|
expect_equal "download password" "pw"
|
|
(expect_some "download e2ee" action.e2ee_password)
|
|
| _ -> fail_test "expected explicit Sync_download action");
|
|
let start =
|
|
expect_ok "sync start"
|
|
(Sync.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Sync.Parsed_start { e2ee_password = Some "pw" }))
|
|
in
|
|
(match start with
|
|
| Sync.Sync_start action ->
|
|
expect_equal "start password" "pw"
|
|
(expect_some "start e2ee" action.e2ee_password)
|
|
| _ -> fail_test "expected Sync_start action");
|
|
let upload =
|
|
expect_ok "sync upload"
|
|
(Sync.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Sync.Parsed_upload { e2ee_password = Some "pw" }))
|
|
in
|
|
(match upload with
|
|
| Sync.Sync_upload action ->
|
|
expect_equal "upload password" "pw"
|
|
(expect_some "upload e2ee" action.e2ee_password)
|
|
| _ -> fail_test "expected Sync_upload action");
|
|
let ensure_keys =
|
|
expect_ok "sync ensure keys"
|
|
(Sync.build (config ()) (Global_opts.create ())
|
|
(Sync.Parsed_ensure_keys
|
|
{ e2ee_password = Some "pw"; upload_keys = true }))
|
|
in
|
|
match ensure_keys with
|
|
| Sync.Sync_ensure_keys action ->
|
|
expect_equal "ensure keys password" "pw"
|
|
(expect_some "ensure keys e2ee" action.e2ee_password);
|
|
expect_bool "ensure keys upload" true action.upload_keys
|
|
| _ -> fail_test "expected Sync_ensure_keys action");
|
|
|
|
test "CLI parity sync build validates config and asset download actions"
|
|
(fun () ->
|
|
expect_error_code "config set missing key" "invalid-options"
|
|
(Sync.build (config ()) (Global_opts.create ())
|
|
(Sync.Parsed_config_set { key = None; value = None }));
|
|
expect_error_code "config set missing value" "invalid-options"
|
|
(Sync.build (config ()) (Global_opts.create ())
|
|
(Sync.Parsed_config_set { key = Some Sync.Ws_url; value = None }));
|
|
expect_error_code "config get missing key" "invalid-options"
|
|
(Sync.build (config ()) (Global_opts.create ())
|
|
(Sync.Parsed_config_get { key = None }));
|
|
expect_error_code "config unset missing key" "invalid-options"
|
|
(Sync.build (config ()) (Global_opts.create ())
|
|
(Sync.Parsed_config_unset { key = None }));
|
|
let set_action =
|
|
expect_ok "config set"
|
|
(Sync.build (config ()) (Global_opts.create ())
|
|
(Sync.Parsed_config_set
|
|
{ key = Some Sync.Ws_url; value = Some "ws://example/%s" }))
|
|
in
|
|
(match set_action with
|
|
| Sync.Sync_config_set { key; value } ->
|
|
expect_bool "config set key" true (key = Sync.Ws_url);
|
|
expect_equal "config set value" "ws://example/%s" value
|
|
| _ -> fail_test "expected Sync_config_set action");
|
|
expect_error_code "grant access missing graph id" "invalid-options"
|
|
(Sync.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Sync.Parsed_grant_access
|
|
{ graph_id = None; email = Some "user@example.com" }));
|
|
expect_error_code "grant access missing email" "invalid-options"
|
|
(Sync.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Sync.Parsed_grant_access
|
|
{
|
|
graph_id = Some "11111111-1111-4111-8111-111111111111";
|
|
email = None;
|
|
}));
|
|
let by_id =
|
|
expect_ok "asset download id"
|
|
(Sync.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Sync.Parsed_asset_download { id = Some 123L; uuid = None }))
|
|
in
|
|
(match by_id with
|
|
| Sync.Sync_asset_download action ->
|
|
expect_equal "asset repo" "logseq_db_demo" (repo_text action.repo);
|
|
expect_equal "asset graph" "demo" (graph_text action.graph);
|
|
expect_int64 "asset id" 123L (expect_some "asset id" action.id);
|
|
expect_none "asset uuid absent" action.uuid
|
|
| _ -> fail_test "expected Sync_asset_download id action");
|
|
let asset_uuid = "11111111-1111-4111-8111-111111111111" in
|
|
let by_uuid =
|
|
expect_ok "asset download uuid"
|
|
(Sync.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Sync.Parsed_asset_download { id = None; uuid = Some asset_uuid }))
|
|
in
|
|
(match by_uuid with
|
|
| Sync.Sync_asset_download action ->
|
|
expect_equal "asset uuid" asset_uuid
|
|
(expect_some "asset uuid" action.uuid);
|
|
expect_none "asset id absent" action.id
|
|
| _ -> fail_test "expected Sync_asset_download uuid action");
|
|
expect_error_code "asset download requires repo" "missing-repo"
|
|
(Sync.build (config ()) (Global_opts.create ())
|
|
(Sync.Parsed_asset_download { id = Some 123L; uuid = None }));
|
|
expect_error_code "asset download requires selector" "invalid-options"
|
|
(Sync.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Sync.Parsed_asset_download { id = None; uuid = None }));
|
|
expect_error_code "asset download rejects conflict" "invalid-options"
|
|
(Sync.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Sync.Parsed_asset_download
|
|
{ id = Some 123L; uuid = Some asset_uuid })));
|
|
|
|
test_promise
|
|
"CLI parity sync asset download requests missing local remote asset"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-sync-asset-" in
|
|
let request_called = ref false in
|
|
let asset_uuid = "00000000-0000-4000-8000-000000000abc" in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/pull" body then (
|
|
expect_named_contains "uuid lookup" body asset_uuid;
|
|
"[\"^ \
|
|
\",\"~:db/id\",123,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000abc\",\"~:block/tags\",[[\"^ \
|
|
\",\"~:db/ident\",\"~:logseq.class/Asset\"]],\"~:logseq.property.asset/type\",\"png\",\"~:logseq.property.asset/checksum\",\"sha\",\"~:logseq.property.asset/remote-metadata\",[\"^ \
|
|
\"]]")
|
|
else if Js.String.includes ~search:"thread-api/db-sync-status" body
|
|
then
|
|
"[\"^ \
|
|
\",\"~:repo\",\"logseq_db_demo\",\"~:graph-id\",\"graph-id\",\"~:ws-state\",\"~:open\"]"
|
|
else if
|
|
Js.String.includes
|
|
~search:"thread-api/db-sync-request-asset-download" body
|
|
then (
|
|
request_called := true;
|
|
expect_named_contains "download request uuid" body asset_uuid;
|
|
"[\"^ \",\"~:result\",true]")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let action =
|
|
Sync.Sync_asset_download
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
id = None;
|
|
uuid = Some asset_uuid;
|
|
}
|
|
in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ~root_dir:root ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Sync.execute action cfg Output.Mode.Human)
|
|
in
|
|
remove_tree root;
|
|
expect_bool "asset download ok" false (Cli_result.is_error result);
|
|
let data =
|
|
expect_some "asset download data" (Cli_result.data_value result)
|
|
in
|
|
expect_equal "asset uuid" asset_uuid
|
|
(expect_some "asset uuid" (Edn_util.get_string data "asset-uuid"));
|
|
expect_equal "asset type" "png"
|
|
(expect_some "asset type" (Edn_util.get_string data "asset-type"));
|
|
expect_bool "download requested" true
|
|
(expect_some "download requested"
|
|
(Edn_util.get_bool data "download-requested?"));
|
|
expect_equal "checksum missing" "missing"
|
|
(expect_some "checksum status"
|
|
(Option.bind
|
|
(Edn_util.get data "checksum-status")
|
|
Edn_util.as_keyword));
|
|
expect_bool "request called" true !request_called;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise
|
|
"CLI parity sync asset download requires active sync before requesting"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-sync-asset-stopped-" in
|
|
let request_called = ref false in
|
|
let asset_uuid = "00000000-0000-4000-8000-000000000abc" in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/pull" body then
|
|
"[\"^ \
|
|
\",\"~:db/id\",123,\"~:block/uuid\",\"~u00000000-0000-4000-8000-000000000abc\",\"~:block/tags\",[[\"^ \
|
|
\",\"~:db/ident\",\"~:logseq.class/Asset\"]],\"~:logseq.property.asset/type\",\"png\",\"~:logseq.property.asset/checksum\",\"sha\",\"~:logseq.property.asset/remote-metadata\",[\"^ \
|
|
\"]]"
|
|
else if Js.String.includes ~search:"thread-api/db-sync-status" body
|
|
then
|
|
"[\"^ \
|
|
\",\"~:repo\",\"logseq_db_demo\",\"~:graph-id\",\"graph-id\",\"~:ws-state\",\"~:stopped\"]"
|
|
else if
|
|
Js.String.includes
|
|
~search:"thread-api/db-sync-request-asset-download" body
|
|
then (
|
|
request_called := true;
|
|
"[\"^ \",\"~:result\",true]")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let action =
|
|
Sync.Sync_asset_download
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
id = None;
|
|
uuid = Some asset_uuid;
|
|
}
|
|
in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ~root_dir:root ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Sync.execute action cfg Output.Mode.Human)
|
|
in
|
|
remove_tree root;
|
|
expect_bool "asset download error" true (Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "sync not started code" "sync-not-started"
|
|
(Error.code_to_string err.Error.code);
|
|
expect_equal "sync start hint"
|
|
"Run logseq sync start --graph demo first."
|
|
(expect_some "sync hint" err.hint)
|
|
| None -> fail_test "expected sync not started error");
|
|
expect_bool "request not called" false !request_called;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise "CLI parity sync asset download validates remote asset metadata"
|
|
(fun () ->
|
|
let asset_uuid = "00000000-0000-4000-8000-000000000abc" in
|
|
let valid_tags =
|
|
"\"~:block/tags\",[[\"^ \",\"~:db/ident\",\"~:logseq.class/Asset\"]]"
|
|
in
|
|
let base_fields =
|
|
"\"~:db/id\",123,\"~:block/uuid\",\"~u" ^ asset_uuid ^ "\","
|
|
^ valid_tags
|
|
^ ",\"~:logseq.property.asset/type\",\"png\",\"~:logseq.property.asset/checksum\",\"sha\",\"~:logseq.property.asset/remote-metadata\",[\"^ \
|
|
\"]"
|
|
in
|
|
let asset fields = "[\"^ \"," ^ fields ^ "]" in
|
|
let run_case label asset_transit expected_code =
|
|
let root = temp_dir ("logseq-cli-sync-asset-" ^ label ^ "-") in
|
|
let request_called = ref false in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/pull" body then
|
|
asset_transit
|
|
else if
|
|
Js.String.includes
|
|
~search:"thread-api/db-sync-request-asset-download" body
|
|
then (
|
|
request_called := true;
|
|
"[\"^ \",\"~:result\",true]")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let action =
|
|
Sync.Sync_asset_download
|
|
{
|
|
repo;
|
|
graph = Cli_config.repo_to_graph repo;
|
|
id = None;
|
|
uuid = Some asset_uuid;
|
|
}
|
|
in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ~root_dir:root ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Sync.execute action cfg Output.Mode.Human)
|
|
in
|
|
remove_tree root;
|
|
expect_bool (label ^ " error") true (Cli_result.is_error result);
|
|
(match result.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal (label ^ " code") expected_code
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test (label ^ ": expected error"));
|
|
expect_bool (label ^ " no request") false !request_called;
|
|
Js.Promise.resolve pass)
|
|
in
|
|
let* () = run_case "missing" "null" "asset-not-found" in
|
|
let* () =
|
|
run_case "non-asset"
|
|
(asset
|
|
("\"~:db/id\",123,\"~:block/uuid\",\"~u" ^ asset_uuid
|
|
^ "\",\"~:block/tags\",[],\"~:logseq.property.asset/type\",\"png\",\"~:logseq.property.asset/checksum\",\"sha\",\"~:logseq.property.asset/remote-metadata\",[\"^ \
|
|
\"]"))
|
|
"not-asset"
|
|
in
|
|
let* () =
|
|
run_case "missing-uuid"
|
|
(asset
|
|
("\"~:db/id\",123," ^ valid_tags
|
|
^ ",\"~:logseq.property.asset/type\",\"png\",\"~:logseq.property.asset/checksum\",\"sha\",\"~:logseq.property.asset/remote-metadata\",[\"^ \
|
|
\"]"))
|
|
"asset-uuid-missing"
|
|
in
|
|
let* () =
|
|
run_case "missing-type"
|
|
(asset
|
|
("\"~:db/id\",123,\"~:block/uuid\",\"~u" ^ asset_uuid ^ "\","
|
|
^ valid_tags
|
|
^ ",\"~:logseq.property.asset/checksum\",\"sha\",\"~:logseq.property.asset/remote-metadata\",[\"^ \
|
|
\"]"))
|
|
"asset-type-missing"
|
|
in
|
|
let* () =
|
|
run_case "missing-checksum"
|
|
(asset
|
|
("\"~:db/id\",123,\"~:block/uuid\",\"~u" ^ asset_uuid ^ "\","
|
|
^ valid_tags
|
|
^ ",\"~:logseq.property.asset/type\",\"png\",\"~:logseq.property.asset/remote-metadata\",[\"^ \
|
|
\"]"))
|
|
"asset-checksum-missing"
|
|
in
|
|
let* () =
|
|
run_case "missing-remote"
|
|
(asset
|
|
("\"~:db/id\",123,\"~:block/uuid\",\"~u" ^ asset_uuid ^ "\","
|
|
^ valid_tags
|
|
^ ",\"~:logseq.property.asset/type\",\"png\",\"~:logseq.property.asset/checksum\",\"sha\""
|
|
))
|
|
"asset-not-remote"
|
|
in
|
|
let* () =
|
|
run_case "external"
|
|
(asset
|
|
(base_fields
|
|
^ ",\"~:logseq.property.asset/external-url\",\"https://example.com/a.png\""
|
|
))
|
|
"external-asset"
|
|
in
|
|
Js.Promise.resolve pass);
|
|
|
|
test
|
|
"CLI parity query validation rejects db/id datom clauses and non-vector \
|
|
queries" (fun () ->
|
|
let valid =
|
|
edn_of_string "[:find ?b :in $ ?id :where [?b :block/title ?title]]"
|
|
in
|
|
ignore (expect_ok "valid query" (Query.validate_query valid));
|
|
let invalid = edn_of_string "[:find ?b :where [?b :db/id ?id]]" in
|
|
expect_error_code "db/id datom" ":invalid-query"
|
|
(Query.validate_query invalid);
|
|
expect_error_code "non vector query" ":invalid-options"
|
|
(Query.validate_query (Edn_util.map_vec Vec.empty)));
|
|
|
|
test "CLI parity datascript query primitive serializes query clauses"
|
|
(fun () ->
|
|
let title_clause =
|
|
Edn_util.vector_t
|
|
[
|
|
Edn_util.symbol "?b";
|
|
Edn_util.keyword "block/title";
|
|
Edn_util.symbol "?title";
|
|
]
|
|
in
|
|
let page_clause =
|
|
Edn_util.vector_t
|
|
[
|
|
Edn_util.symbol "?b";
|
|
Edn_util.keyword "block/page";
|
|
Edn_util.symbol "?page";
|
|
]
|
|
in
|
|
let predicate_clause =
|
|
Edn_util.list_t
|
|
[
|
|
Edn_util.symbol "clojure.string/includes?";
|
|
Edn_util.symbol "?title";
|
|
Edn_util.symbol "?query";
|
|
]
|
|
in
|
|
let edn query =
|
|
Melange_edn_melange.to_edn_string
|
|
(Edn_util.any (Cli_primitive.datascript_query_to_edn query))
|
|
in
|
|
let without_inputs =
|
|
Cli_primitive.make_datascript_query
|
|
~find:(Vec.singleton (Edn_util.symbol "?b"))
|
|
~where:(Vec.singleton (Cli_primitive.V title_clause))
|
|
()
|
|
in
|
|
expect_equal "datascript query without inputs"
|
|
"[:find ?b :where [?b :block/title ?title]]" (edn without_inputs);
|
|
let with_inputs =
|
|
Cli_primitive.make_datascript_query
|
|
~find:(Vec.singleton (Edn_util.symbol "?b"))
|
|
~in_:
|
|
(Vec.of_array
|
|
[|
|
|
Melange_edn_melange.symbol "$";
|
|
Melange_edn_melange.symbol "?title";
|
|
|])
|
|
~where:(Vec.singleton (Cli_primitive.V title_clause))
|
|
()
|
|
in
|
|
expect_equal "datascript query with inputs"
|
|
"[:find ?b :in $ ?title :where [?b :block/title ?title]]"
|
|
(edn with_inputs);
|
|
let with_empty_inputs =
|
|
Cli_primitive.make_datascript_query
|
|
~find:(Vec.singleton (Edn_util.symbol "?b"))
|
|
~in_:Vec.empty
|
|
~where:(Vec.singleton (Cli_primitive.V title_clause))
|
|
()
|
|
in
|
|
expect_equal "datascript query with empty inputs"
|
|
"[:find ?b :where [?b :block/title ?title]]" (edn with_empty_inputs);
|
|
let with_multiple_clauses =
|
|
Cli_primitive.make_datascript_query
|
|
~find:(Vec.singleton (Edn_util.symbol "?b"))
|
|
~where:
|
|
(Vec.of_array
|
|
[| Cli_primitive.V title_clause; Cli_primitive.V page_clause |])
|
|
()
|
|
in
|
|
expect_equal "datascript query with multiple where clauses"
|
|
"[:find ?b :where [?b :block/title ?title] [?b :block/page ?page]]"
|
|
(edn with_multiple_clauses);
|
|
let with_list_clause =
|
|
Cli_primitive.make_datascript_query
|
|
~find:
|
|
(Vec.of_array [| Edn_util.symbol "?b"; Edn_util.symbol "?title" |])
|
|
~where:
|
|
(Vec.of_array
|
|
[|
|
|
Cli_primitive.V title_clause; Cli_primitive.L predicate_clause;
|
|
|])
|
|
()
|
|
in
|
|
expect_equal "datascript query with list where clause"
|
|
"[:find ?b ?title :where [?b :block/title ?title] \
|
|
(clojure.string/includes? ?title ?query)]"
|
|
(edn with_list_clause));
|
|
|
|
test
|
|
"CLI parity query input normalization fills defaults and validates \
|
|
required inputs" (fun () ->
|
|
let entry =
|
|
{
|
|
Query.name = "custom";
|
|
source = Query.Custom;
|
|
doc = None;
|
|
inputs =
|
|
Vec.of_array
|
|
[|
|
|
({ name = "?required"; optional = false; default = None }
|
|
: Query.input_spec);
|
|
({
|
|
name = "?optional";
|
|
optional = true;
|
|
default = Some (Edn_util.string "fallback");
|
|
}
|
|
: Query.input_spec);
|
|
|];
|
|
query = Edn_util.vector_vec Vec.empty;
|
|
}
|
|
in
|
|
expect_error_code "missing required input" ":invalid-options"
|
|
(Query.normalize_inputs (Some entry) Vec.empty);
|
|
let inputs =
|
|
expect_ok "normalize inputs"
|
|
(Query.normalize_inputs (Some entry)
|
|
(Vec.singleton (Edn_util.string "value")))
|
|
in
|
|
expect_int "input count" 2 (Vec.length inputs);
|
|
expect_equal "default input" "fallback"
|
|
(expect_some "default" (Edn_util.as_string (Vec.nth inputs 1)));
|
|
let padded =
|
|
{
|
|
entry with
|
|
Query.name = "padded";
|
|
inputs =
|
|
Vec.of_array
|
|
[|
|
|
({ name = "required"; optional = false; default = None }
|
|
: Query.input_spec);
|
|
({ name = "?optional"; optional = true; default = None }
|
|
: Query.input_spec);
|
|
|];
|
|
}
|
|
in
|
|
let padded_inputs =
|
|
expect_ok "pad optional input"
|
|
(Query.normalize_inputs (Some padded)
|
|
(Vec.singleton (Edn_util.string "value")))
|
|
in
|
|
expect_bool "optional input pads nil" true
|
|
(Edn_util.is_null (Vec.nth padded_inputs 1));
|
|
let task_search =
|
|
expect_some "task-search entry"
|
|
(Query.find_query (config ()) "task-search")
|
|
in
|
|
let task_inputs =
|
|
expect_ok "task-search defaults"
|
|
(Query.normalize_inputs (Some task_search)
|
|
(Vec.singleton (Edn_util.string "doing")))
|
|
in
|
|
expect_equal "task status keyword" "logseq.property/status.doing"
|
|
(expect_some "status keyword"
|
|
(Edn_util.as_keyword (Vec.nth task_inputs 0)));
|
|
expect_equal "task title default" ""
|
|
(expect_some "title default"
|
|
(Edn_util.as_string (Vec.nth task_inputs 1)));
|
|
expect_int "task recent-days default" 0
|
|
(expect_some "recent-days default"
|
|
(Edn_util.as_int (Vec.nth task_inputs 2)));
|
|
ignore
|
|
(expect_some "task now-ms default"
|
|
(Edn_util.as_int64 (Vec.nth task_inputs 3))));
|
|
|
|
test "CLI parity query build action parses query inputs and named queries"
|
|
(fun () ->
|
|
let run =
|
|
expect_ok "query run"
|
|
(Query.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Query.Parsed_run
|
|
{
|
|
query_edn =
|
|
Some
|
|
"[:find ?e :in $ ?title :where [?e :block/title ?title]]";
|
|
name = None;
|
|
inputs_edn = Some "[\"Hello\"]";
|
|
}))
|
|
in
|
|
(match run with
|
|
| Query.Run { repo; graph; query; inputs; name } ->
|
|
expect_equal "query repo" "logseq_db_demo"
|
|
(Cli_primitive.string_of_repo repo);
|
|
expect_equal "query graph" "demo"
|
|
(Cli_primitive.string_of_graph graph);
|
|
ignore (expect_ok "built query valid" (Query.validate_query query));
|
|
expect_int "query inputs length" 1 (Vec.length inputs);
|
|
expect_equal "query input" "Hello"
|
|
(expect_some "query input string"
|
|
(Edn_util.as_string (Vec.peek_front inputs)));
|
|
expect_none "query name none" name
|
|
| Query.List -> fail_test "expected query run");
|
|
expect_error_code "query invalid edn" "invalid-options"
|
|
(Query.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Query.Parsed_run
|
|
{ query_edn = Some "[:find ?e"; name = None; inputs_edn = None }));
|
|
expect_error_code "query invalid inputs edn" "invalid-options"
|
|
(Query.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Query.Parsed_run
|
|
{
|
|
query_edn = Some "[:find ?e :where [?e :block/title \"Hello\"]]";
|
|
name = None;
|
|
inputs_edn = Some "[\"Hello";
|
|
}));
|
|
let non_vector_inputs =
|
|
Query.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Query.Parsed_run
|
|
{
|
|
query_edn = None;
|
|
name = Some "recent-updated";
|
|
inputs_edn = Some "1";
|
|
})
|
|
in
|
|
expect_error_code "query non-vector inputs" "invalid-options"
|
|
non_vector_inputs;
|
|
(match non_vector_inputs with
|
|
| Error err ->
|
|
expect_equal "query non-vector inputs message"
|
|
"inputs must be a vector" err.Error.message
|
|
| Ok _ -> fail_test "query non-vector inputs: expected error");
|
|
expect_error_code "query rejects db/id datom" "invalid-query"
|
|
(Query.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Query.Parsed_run
|
|
{
|
|
query_edn =
|
|
Some
|
|
"[:find (pull ?v [*]) :where [?b :db/id 400] [?b \
|
|
:user.property/owner ?v]]";
|
|
name = None;
|
|
inputs_edn = None;
|
|
}));
|
|
expect_error_code "query requires repo" "missing-repo"
|
|
(Query.build (config ()) (Global_opts.create ())
|
|
(Query.Parsed_run
|
|
{
|
|
query_edn = Some "[:find ?e :where [?e :block/title]]";
|
|
name = None;
|
|
inputs_edn = None;
|
|
}));
|
|
let raw_config =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "custom-queries",
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.string "my-query",
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "doc", Edn_util.string "Custom query");
|
|
( Edn_util.keyword "inputs",
|
|
Edn_util.vector_vec
|
|
(Vec.singleton (Edn_util.string "title")) );
|
|
( Edn_util.keyword "query",
|
|
edn_of_string
|
|
"[:find ?e :in $ ?title :where [?e :block/title \
|
|
?title]]" );
|
|
] );
|
|
] );
|
|
]
|
|
in
|
|
let named =
|
|
expect_ok "named query"
|
|
(Query.build
|
|
(config ~repo:"demo" ~raw_file_config:raw_config ())
|
|
(Global_opts.create ())
|
|
(Query.Parsed_run
|
|
{
|
|
query_edn = None;
|
|
name = Some ":my-query";
|
|
inputs_edn = Some "[\"Alpha\"]";
|
|
}))
|
|
in
|
|
(match named with
|
|
| Query.Run { inputs; name; _ } ->
|
|
expect_equal "named query normalized" "my-query"
|
|
(expect_some "named query name" name);
|
|
expect_equal "named query input" "Alpha"
|
|
(expect_some "named query input"
|
|
(Edn_util.as_string (Vec.peek_front inputs)))
|
|
| Query.List -> fail_test "expected named query run");
|
|
expect_error_code "unknown named query" "unknown-query"
|
|
(Query.build
|
|
(config ~repo:"demo"
|
|
~raw_file_config:(Edn_util.map_vec Vec.empty)
|
|
())
|
|
(Global_opts.create ())
|
|
(Query.Parsed_run
|
|
{ query_edn = None; name = Some "missing"; inputs_edn = None }));
|
|
expect_error_code "query name conflict" "invalid-options"
|
|
(Query.build
|
|
(config ~repo:"demo" ~raw_file_config:raw_config ())
|
|
(Global_opts.create ())
|
|
(Query.Parsed_run
|
|
{
|
|
query_edn = Some "[:find ?e]";
|
|
name = Some "my-query";
|
|
inputs_edn = None;
|
|
})));
|
|
|
|
test_promise "CLI parity query execute appends DSL rules for percent input"
|
|
(fun () ->
|
|
let raw_config =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "custom-queries",
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.string "task",
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "inputs",
|
|
Edn_util.vector
|
|
[ Edn_util.string "task statuses set" ] );
|
|
( Edn_util.keyword "query",
|
|
edn_of_string
|
|
"[:find (pull ?b [*]) :in $ ?status % :where (task \
|
|
?b ?status)]" );
|
|
] );
|
|
] );
|
|
]
|
|
in
|
|
let cfg = config ~repo:"demo" ~raw_file_config:raw_config () in
|
|
let action =
|
|
expect_ok "task query build"
|
|
(Query.build cfg (Global_opts.create ())
|
|
(Query.Parsed_run
|
|
{
|
|
query_edn = None;
|
|
name = Some "task";
|
|
inputs_edn = Some "[\"Todo\"]";
|
|
}))
|
|
in
|
|
let captured_body = ref None in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
captured_body := Some body;
|
|
"[]")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let cfg = { cfg with Cli_config.base_url = Some base_url } in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Query.execute action cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "query execute ok" false (Cli_result.is_error result);
|
|
let body = expect_some "query request body" !captured_body in
|
|
expect_named_contains "query method" body "thread-api/q";
|
|
expect_named_contains "query input" body "Todo";
|
|
expect_named_contains "rules parent" body "parent";
|
|
expect_named_contains "rules class extends" body "class-extends";
|
|
expect_named_contains "rules task" body "task";
|
|
Js.Promise.resolve pass));
|
|
|
|
test "CLI parity query list merges built-in and custom query metadata"
|
|
(fun () ->
|
|
let raw_config =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "custom-queries",
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.string "custom-q", edn_of_string "[:find ?e]");
|
|
(Edn_util.string "block-search", edn_of_string "[:find ?b]");
|
|
] );
|
|
]
|
|
in
|
|
let queries =
|
|
Query.list_queries (config ~raw_file_config:raw_config ())
|
|
in
|
|
let names =
|
|
Vec.map (fun (entry : Query.query_entry) -> entry.name) queries
|
|
in
|
|
expect_bool "task-search built-in listed" true
|
|
(Vec.mem "task-search" names);
|
|
expect_bool "list-status built-in listed" true
|
|
(Vec.mem "list-status" names);
|
|
expect_bool "list-priority built-in listed" true
|
|
(Vec.mem "list-priority" names);
|
|
expect_bool "custom query listed" true (Vec.mem "custom-q" names);
|
|
let block_search =
|
|
expect_some "block-search override"
|
|
(Vec.find_opt
|
|
(fun (entry : Query.query_entry) -> entry.name = "block-search")
|
|
queries)
|
|
in
|
|
expect_bool "block-search custom source" true
|
|
(block_search.source = Query.Custom);
|
|
let list_status =
|
|
expect_some "list-status"
|
|
(Vec.find_opt
|
|
(fun (entry : Query.query_entry) -> entry.name = "list-status")
|
|
queries)
|
|
in
|
|
expect_int "list-status inputs" 0 (Vec.length list_status.inputs);
|
|
let status_query = Melange_edn_melange.to_edn_string list_status.query in
|
|
expect_named_contains "list-status query status keyword" status_query
|
|
":logseq.property/status";
|
|
let list_priority =
|
|
expect_some "list-priority"
|
|
(Vec.find_opt
|
|
(fun (entry : Query.query_entry) -> entry.name = "list-priority")
|
|
queries)
|
|
in
|
|
expect_int "list-priority inputs" 0 (Vec.length list_priority.inputs);
|
|
expect_named_contains "list-priority query priority keyword"
|
|
(Melange_edn_melange.to_edn_string list_priority.query)
|
|
":logseq.property/priority");
|
|
|
|
test "CLI parity debug selector requires exactly one id uuid or ident"
|
|
(fun () ->
|
|
expect_error_code "missing selector" ":invalid-options"
|
|
(Debug.resolve_selector { id = None; uuid = None; ident = None });
|
|
let by_id =
|
|
expect_ok "debug id"
|
|
(Debug.resolve_selector { id = Some 9L; uuid = None; ident = None })
|
|
in
|
|
(match by_id with Debug.By_id 9L -> pass | _ -> fail_test "expected id");
|
|
expect_error_code "ambiguous selector" ":invalid-options"
|
|
(Debug.resolve_selector
|
|
{
|
|
id = Some 9L;
|
|
uuid = Some "00000000-0000-4000-8000-000000000001";
|
|
ident = None;
|
|
});
|
|
expect_error_code "bad uuid" ":invalid-options"
|
|
(Debug.resolve_selector
|
|
{ id = None; uuid = Some "not-a-uuid"; ident = None }));
|
|
|
|
test "CLI parity debug build action resolves id uuid ident and repo"
|
|
(fun () ->
|
|
let action =
|
|
expect_ok "debug id build"
|
|
(Debug.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Debug.Parsed_pull { id = Some 42L; uuid = None; ident = None }))
|
|
in
|
|
(match action with
|
|
| Debug.Debug_pull { repo; graph; lookup; selector } ->
|
|
expect_equal "debug repo" "logseq_db_demo"
|
|
(Cli_primitive.string_of_repo repo);
|
|
expect_equal "debug graph" "demo"
|
|
(Cli_primitive.string_of_graph graph);
|
|
(match lookup with
|
|
| Debug.By_id 42L -> pass
|
|
| _ -> fail_test "expected debug id lookup");
|
|
expect_equal "debug selector" "[*]"
|
|
(Melange_edn_melange.to_edn_string selector));
|
|
let ident =
|
|
expect_ok "debug ident option"
|
|
(Debug.parse_ident_option ":logseq.class/Tag")
|
|
in
|
|
let ident_action =
|
|
expect_ok "debug ident build"
|
|
(Debug.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
(Debug.Parsed_pull { id = None; uuid = None; ident = Some ident }))
|
|
in
|
|
(match ident_action with
|
|
| Debug.Debug_pull { lookup = Debug.By_ident parsed_ident; _ } ->
|
|
expect_equal "debug ident" "logseq.class/Tag"
|
|
(Edn_util.keyword_to_string parsed_ident)
|
|
| _ -> fail_test "expected ident lookup");
|
|
expect_error_code "debug invalid ident" "invalid-options"
|
|
(Debug.parse_ident_option "logseq.class/Tag");
|
|
expect_error_code "debug requires repo" "missing-repo"
|
|
(Debug.build (config ()) (Global_opts.create ())
|
|
(Debug.Parsed_pull { id = Some 1L; uuid = None; ident = None })));
|
|
|
|
test "CLI parity doctor build and filesystem checks report stable statuses"
|
|
(fun () ->
|
|
let missing_path = "/tmp/logseq-cli-missing-db-worker-node.js" in
|
|
let missing =
|
|
Doctor.check_db_worker_script
|
|
(Doctor.Doctor { script_path = Some missing_path })
|
|
in
|
|
expect_equal "doctor missing script id" "db-worker-script"
|
|
(Edn_util.keyword_to_string missing.id);
|
|
expect_bool "doctor missing status" true (missing.status = Doctor.Error);
|
|
expect_equal "doctor missing code" "doctor-script-missing"
|
|
(Error.code_to_string (expect_some "missing script code" missing.code));
|
|
expect_equal "doctor missing path" missing_path
|
|
(expect_some "missing script path" missing.path);
|
|
let root = temp_dir "logseq-cli-parity-doctor-" in
|
|
let script_path = Node.Path.join [| root; "db-worker-node.js" |] in
|
|
try
|
|
write_file script_path "console.log('ok');\n";
|
|
let readable =
|
|
Doctor.check_db_worker_script
|
|
(Doctor.Doctor { script_path = Some script_path })
|
|
in
|
|
expect_bool "doctor readable script" true (readable.status = Doctor.Ok);
|
|
expect_none "doctor readable script code" readable.code;
|
|
let nested_root = Node.Path.join [| root; "nested-root" |] in
|
|
let root_check =
|
|
Doctor.check_root_dir (config ~root_dir:nested_root ())
|
|
in
|
|
expect_equal "doctor root id" "root-dir"
|
|
(Edn_util.keyword_to_string root_check.id);
|
|
expect_bool "doctor root ok" true (root_check.status = Doctor.Ok);
|
|
expect_bool "doctor root created" true
|
|
(Cli_unix.file_exists nested_root);
|
|
(match
|
|
Doctor.build (config ()) (Global_opts.create ())
|
|
(Doctor.Parsed_doctor { dev_script = true })
|
|
with
|
|
| Ok (Doctor.Doctor { script_path = Some path }) ->
|
|
expect_named_contains "doctor dev script" path "db-worker-node.js"
|
|
| Ok (Doctor.Doctor { script_path = None }) ->
|
|
fail_test "doctor dev script: expected script path"
|
|
| Error err -> fail_test ("doctor build: " ^ err.Error.message));
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity command metadata keeps expected command ids and paths"
|
|
(fun () ->
|
|
expect_equal "graph list id" "graph-list"
|
|
(Command_id.to_string Command_id.Graph_list);
|
|
expect_bool "graph create write" true
|
|
(Command_id.is_write Command_id.Graph_create);
|
|
expect_bool "graph list read" false
|
|
(Command_id.is_write Command_id.Graph_list);
|
|
expect_bool "show requires graph" true
|
|
(Command_id.requires_graph Command_id.Show);
|
|
expect_bool "login does not require auth" false
|
|
(Command_id.requires_auth Command_id.Login));
|
|
|
|
test "CLI parity command lookup compares path contents" (fun () ->
|
|
let registry = (Cli.make_app_context ()).Cli.registry in
|
|
let path = Vec.push_front (Vec.singleton "list") "graph" in
|
|
let command =
|
|
expect_some "graph list command"
|
|
(Command_registry.find_by_path path registry)
|
|
in
|
|
expect_equal "graph list command id" "graph-list"
|
|
(Command_id.to_string command.id));
|
|
|
|
test "CLI parity example lookup compares selector contents" (fun () ->
|
|
let selector = Vec.push_front (Vec.singleton "list") "graph" in
|
|
let action =
|
|
expect_ok "graph list examples"
|
|
(Example.resolve_selector Command_registry.empty selector)
|
|
in
|
|
expect_equal "graph list selector" "graph list" action.selector;
|
|
expect_named_contains "graph list example"
|
|
(Vec.peek_front action.examples)
|
|
"logseq graph list");
|
|
|
|
test "CLI parity example selector returns matched commands and examples"
|
|
(fun () ->
|
|
let registry =
|
|
Command_registry.make
|
|
(Vec.of_array
|
|
[|
|
|
{
|
|
Command_registry.id = Command_id.Graph_list;
|
|
path = Vec.of_array [| "graph"; "list" |];
|
|
doc = "List graphs";
|
|
long_doc = None;
|
|
examples = Vec.singleton "logseq graph list";
|
|
options = Vec.empty;
|
|
category = Command_registry.Graph_management;
|
|
requires_graph = false;
|
|
requires_auth = false;
|
|
write_command = false;
|
|
human_table_headers_order = Vec.empty;
|
|
};
|
|
{
|
|
id = Command_id.Graph_create;
|
|
path = Vec.of_array [| "graph"; "create" |];
|
|
doc = "Create graph";
|
|
long_doc = None;
|
|
examples = Vec.singleton "logseq graph create --graph demo";
|
|
options = Vec.empty;
|
|
category = Graph_management;
|
|
requires_graph = true;
|
|
requires_auth = false;
|
|
write_command = true;
|
|
human_table_headers_order = Vec.empty;
|
|
};
|
|
|])
|
|
in
|
|
let action =
|
|
expect_ok "graph examples"
|
|
(Example.resolve_selector registry (Vec.singleton "graph"))
|
|
in
|
|
expect_equal "selector" "graph" action.selector;
|
|
expect_int "matched commands" 2 (Vec.length action.matched_commands);
|
|
expect_int "examples" 2 (Vec.length action.examples);
|
|
expect_error_code "unknown selector" ":unknown-command"
|
|
(Example.resolve_selector registry (Vec.singleton "sync")));
|
|
|
|
test "CLI parity example selector reports missing and large example counts"
|
|
(fun () ->
|
|
let registry =
|
|
Command_registry.make
|
|
(Vec.of_array
|
|
[|
|
|
{
|
|
Command_registry.id = Command_id.Upsert_page;
|
|
path = Vec.of_array [| "upsert"; "page" |];
|
|
doc = "Upsert page";
|
|
long_doc = None;
|
|
examples =
|
|
Vec.singleton "logseq upsert page --graph demo --page Home";
|
|
options = Vec.empty;
|
|
category = Graph_inspect_and_edit;
|
|
requires_graph = true;
|
|
requires_auth = false;
|
|
write_command = true;
|
|
human_table_headers_order = Vec.empty;
|
|
};
|
|
{
|
|
id = Command_id.Upsert_tag;
|
|
path = Vec.of_array [| "upsert"; "tag" |];
|
|
doc = "Upsert tag";
|
|
long_doc = None;
|
|
examples = Vec.empty;
|
|
options = Vec.empty;
|
|
category = Graph_inspect_and_edit;
|
|
requires_graph = true;
|
|
requires_auth = false;
|
|
write_command = true;
|
|
human_table_headers_order = Vec.empty;
|
|
};
|
|
|])
|
|
in
|
|
expect_error_code "missing examples" "missing-examples"
|
|
(Example.resolve_selector registry (Vec.singleton "upsert"));
|
|
let large_registry =
|
|
Command_registry.make
|
|
(Vec.of_array
|
|
[|
|
|
{
|
|
Command_registry.id = Command_id.Upsert_page;
|
|
path = Vec.of_array [| "upsert"; "page" |];
|
|
doc = "Upsert page";
|
|
long_doc = None;
|
|
examples =
|
|
Vec.init 1234 (fun index ->
|
|
"logseq upsert page --graph demo --page Page-"
|
|
^ string_of_int index);
|
|
options = Vec.empty;
|
|
category = Graph_inspect_and_edit;
|
|
requires_graph = true;
|
|
requires_auth = false;
|
|
write_command = true;
|
|
human_table_headers_order = Vec.empty;
|
|
};
|
|
|])
|
|
in
|
|
let action =
|
|
expect_ok "large example count"
|
|
(Example.resolve_selector large_registry
|
|
(Vec.of_array [| "upsert"; "page" |]))
|
|
in
|
|
expect_equal "large example message"
|
|
"Found 1,234 examples for selector upsert page" action.message);
|
|
|
|
test "CLI parity task status normalization resolves available statuses"
|
|
(fun () ->
|
|
let values =
|
|
Vec.of_array
|
|
[|
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "ident",
|
|
Edn_util.keyword "logseq.property/status.todo" );
|
|
(Edn_util.keyword "value", Edn_util.string "Todo");
|
|
];
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "ident",
|
|
Edn_util.keyword "logseq.property/status.done" );
|
|
(Edn_util.keyword "value", Edn_util.string "Done");
|
|
];
|
|
|]
|
|
in
|
|
let statuses = Task_status.normalize_available_statuses values in
|
|
expect_int "status count" 2 (Vec.length statuses);
|
|
expect_bool "resolve todo" true
|
|
(Option.is_some (Task_status.resolve_status_ident "todo" statuses));
|
|
expect_named_contains "invalid status message"
|
|
(Task_status.invalid_status_message "bad" statuses)
|
|
"Available values");
|
|
|
|
test
|
|
"CLI parity config graph repo conversion strips one leading db prefix only"
|
|
(fun () ->
|
|
expect_equal "repo to graph" "demo"
|
|
(Cli_primitive.string_of_graph
|
|
(Cli_config.repo_to_graph
|
|
(Cli_primitive.create_repo "logseq_db_demo")));
|
|
expect_equal "nested prefix graph" "logseq_db_other"
|
|
(Cli_primitive.string_of_graph
|
|
(Cli_config.repo_to_graph
|
|
(Cli_primitive.create_repo "logseq_db_logseq_db_other"))));
|
|
|
|
test
|
|
"CLI parity parse covers graph backup import export and sync requirements"
|
|
(fun () ->
|
|
let backup =
|
|
expect_parse_ok "backup restore"
|
|
[|
|
|
"graph";
|
|
"backup";
|
|
"restore";
|
|
"--src";
|
|
"demo-nightly";
|
|
"--dst";
|
|
"demo-restored";
|
|
|]
|
|
in
|
|
(match backup.command with
|
|
| Cli_request.Graph (Graph.Parsed_backup_restore opts) ->
|
|
expect_equal "backup src" "demo-nightly" opts.src;
|
|
expect_equal "backup dst" "demo-restored"
|
|
(Cli_primitive.string_of_graph opts.dst)
|
|
| _ -> fail_test "expected backup restore");
|
|
let export =
|
|
expect_parse_ok "graph export"
|
|
[|
|
|
"graph";
|
|
"export";
|
|
"--type";
|
|
"edn";
|
|
"--file";
|
|
"/tmp/export.edn";
|
|
"--edn-options";
|
|
"{:export-type :graph :include-timestamps? true}";
|
|
"--pretty-print";
|
|
|]
|
|
in
|
|
(match export.command with
|
|
| Cli_request.Graph (Graph.Parsed_export opts) ->
|
|
expect_bool "export edn" true (opts.export_type = Graph.Edn);
|
|
expect_equal "export file" "/tmp/export.edn"
|
|
(expect_some "file" opts.file);
|
|
expect_bool "pretty" true opts.pretty_print;
|
|
expect_some "edn options" opts.edn_options |> ignore
|
|
| _ -> fail_test "expected graph export");
|
|
let export_aliases =
|
|
expect_parse_ok "graph export aliases"
|
|
[|
|
|
"graph";
|
|
"export";
|
|
"-t";
|
|
"edn";
|
|
"--file";
|
|
"/tmp/export.edn";
|
|
"-e";
|
|
"{:export-type :graph}";
|
|
"-p";
|
|
|]
|
|
in
|
|
(match export_aliases.command with
|
|
| Cli_request.Graph (Graph.Parsed_export opts) ->
|
|
expect_bool "export alias edn" true (opts.export_type = Graph.Edn);
|
|
expect_bool "export alias pretty" true opts.pretty_print;
|
|
expect_some "export alias edn options" opts.edn_options |> ignore
|
|
| _ -> fail_test "expected graph export");
|
|
Vec.iter
|
|
(fun flag ->
|
|
expect_parse_error_code
|
|
("retired export option " ^ flag)
|
|
":invalid-options"
|
|
[|
|
|
"graph";
|
|
"export";
|
|
"--type";
|
|
"edn";
|
|
"--file";
|
|
"/tmp/export.edn";
|
|
flag;
|
|
|])
|
|
(Vec.of_array [| "--include-timestamps"; "--exclude-built-in-pages" |]);
|
|
expect_parse_error_code "retired export option --exclude-namespaces"
|
|
":invalid-options"
|
|
[|
|
|
"graph";
|
|
"export";
|
|
"--type";
|
|
"edn";
|
|
"--file";
|
|
"/tmp/export.edn";
|
|
"--exclude-namespaces";
|
|
"journal";
|
|
|];
|
|
expect_parse_error_code "missing backup src" ":invalid-options"
|
|
[| "graph"; "backup"; "restore"; "--dst"; "demo" |];
|
|
expect_parse_error_code "bad sync config key" ":invalid-options"
|
|
[| "sync"; "config"; "get"; "--key"; "graph" |]);
|
|
|
|
test "CLI parity graph build validates graph selection and export contracts"
|
|
(fun () ->
|
|
let globals =
|
|
Global_opts.create ~graph:(Cli_primitive.create_graph "demo") ()
|
|
in
|
|
expect_error_code "graph create requires explicit graph" "missing-graph"
|
|
(Graph.build (config ()) (Global_opts.create ())
|
|
(Graph.Parsed_create { enable_sync = false; e2ee_password = None }));
|
|
expect_error_code "graph create password requires sync" "invalid-options"
|
|
(Graph.build (config ()) globals
|
|
(Graph.Parsed_create
|
|
{ enable_sync = false; e2ee_password = Some "pw" }));
|
|
Vec.iter
|
|
(fun graph_name ->
|
|
expect_error_code
|
|
("reject graph name " ^ graph_name)
|
|
"invalid-options"
|
|
(Graph.build (config ())
|
|
(Global_opts.create
|
|
~graph:(Cli_primitive.create_graph graph_name)
|
|
())
|
|
(Graph.Parsed_create
|
|
{ enable_sync = false; e2ee_password = None })))
|
|
(Vec.of_array [| ""; " "; "."; " .. " |]);
|
|
let create =
|
|
expect_ok "graph create build"
|
|
(Graph.build (config ()) globals
|
|
(Graph.Parsed_create
|
|
{ enable_sync = true; e2ee_password = Some "pw" }))
|
|
in
|
|
(match create with
|
|
| Graph.Graph_create { graph; repo; opts } ->
|
|
expect_equal "create graph" "demo" (graph_text graph);
|
|
expect_equal "create repo" "logseq_db_demo" (repo_text repo);
|
|
expect_bool "create sync" true opts.enable_sync;
|
|
expect_equal "create password" "pw"
|
|
(expect_some "create password" opts.e2ee_password)
|
|
| _ -> fail_test "expected Graph_create action");
|
|
expect_error_code "export edn requires file" "invalid-options"
|
|
(Graph.build (config ~graph:"demo" ()) (Global_opts.create ())
|
|
(Graph.Parsed_export
|
|
{
|
|
export_type = Graph.Edn;
|
|
file = None;
|
|
edn_options = None;
|
|
pretty_print = false;
|
|
include_timestamps = false;
|
|
exclude_built_in_pages = false;
|
|
exclude_namespaces = Vec.empty;
|
|
}));
|
|
expect_error_code "sqlite rejects edn options" "invalid-options"
|
|
(Graph.build (config ~graph:"demo" ()) (Global_opts.create ())
|
|
(Graph.Parsed_export
|
|
{
|
|
export_type = Graph.Sqlite;
|
|
file = Some "/tmp/demo.sqlite";
|
|
edn_options = Some (Edn_util.map_vec Vec.empty);
|
|
pretty_print = false;
|
|
include_timestamps = false;
|
|
exclude_built_in_pages = false;
|
|
exclude_namespaces = Vec.empty;
|
|
}));
|
|
expect_error_code "export edn options must be map" "invalid-options"
|
|
(Graph.build (config ~graph:"demo" ()) (Global_opts.create ())
|
|
(Graph.Parsed_export
|
|
{
|
|
export_type = Graph.Edn;
|
|
file = Some "/tmp/demo.edn";
|
|
edn_options = Some (Edn_util.vector_vec Vec.empty);
|
|
pretty_print = false;
|
|
include_timestamps = false;
|
|
exclude_built_in_pages = false;
|
|
exclude_namespaces = Vec.empty;
|
|
}));
|
|
let export =
|
|
expect_ok "export edn build"
|
|
(Graph.build (config ~graph:"demo" ()) (Global_opts.create ())
|
|
(Graph.Parsed_export
|
|
{
|
|
export_type = Graph.Edn;
|
|
file = Some "/tmp/demo.edn";
|
|
edn_options =
|
|
Some
|
|
(edn_of_string
|
|
"{:export-type :graph :include-timestamps? true}");
|
|
pretty_print = true;
|
|
include_timestamps = false;
|
|
exclude_built_in_pages = false;
|
|
exclude_namespaces = Vec.empty;
|
|
}))
|
|
in
|
|
match export with
|
|
| Graph.Graph_export { graph; repo; opts } ->
|
|
expect_equal "export graph" "demo" (graph_text graph);
|
|
expect_equal "export repo" "logseq_db_demo" (repo_text repo);
|
|
expect_bool "export type" true (opts.export_type = Graph.Edn);
|
|
expect_equal "export file" "/tmp/demo.edn"
|
|
(expect_some "export file" opts.file);
|
|
expect_bool "export pretty" true opts.pretty_print;
|
|
expect_some "export edn options" opts.edn_options |> ignore
|
|
| _ -> fail_test "expected Graph_export action");
|
|
|
|
test_promise "CLI parity graph validate result reports ok and error states"
|
|
(fun () ->
|
|
let run_validate response_transit assert_result =
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/validate-db" body then
|
|
response_transit
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let action =
|
|
Graph.Graph_validate
|
|
{ graph = Cli_config.repo_to_graph repo; repo; fix = false }
|
|
in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute action cfg Output.Mode.Human)
|
|
in
|
|
assert_result result;
|
|
Js.Promise.resolve pass)
|
|
in
|
|
let* () =
|
|
run_validate
|
|
"[\"^ \",\"~:errors\",[[\"^ \",\"~:entity\",[\"^ \
|
|
\",\"~:db/id\",1],\"^0\",[\"^ \",\"~:foo\",[\"bad\"]]]]]"
|
|
(fun invalid ->
|
|
expect_bool "invalid graph status" true
|
|
(Cli_result.is_error invalid);
|
|
match invalid.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "validation error code" "graph-validation-failed"
|
|
(Error.code_to_string err.Error.code);
|
|
expect_named_contains "validation error count" err.message
|
|
"Found 1 entity with errors:"
|
|
| None -> fail_test "expected graph validation error")
|
|
in
|
|
let* () =
|
|
run_validate "[\"^ \",\"~:errors\",null,\"~:datoms\",10]" (fun valid ->
|
|
expect_bool "valid graph status" false (Cli_result.is_error valid);
|
|
let data =
|
|
expect_some "validation data" (Cli_result.data_value valid)
|
|
in
|
|
expect_bool "validation wraps result" true
|
|
(Option.is_some (Edn_util.get data "result")))
|
|
in
|
|
Js.Promise.resolve pass);
|
|
|
|
test_promise "CLI parity graph info queries kv rows with thread api q"
|
|
(fun () ->
|
|
let q_called = ref false in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/q" body then (
|
|
q_called := true;
|
|
expect_named_contains "graph info repo" body "logseq_db_demo";
|
|
expect_named_contains "graph info query namespace" body
|
|
"logseq.kv";
|
|
"[[\"~:logseq.kv/schema-version\",7],[\"~:logseq.kv/graph-created-at\",40000],[\"~:logseq.kv/db-type\",\"~:sqlite\"]]")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let action =
|
|
Graph.Graph_info { graph = Cli_config.repo_to_graph repo; repo }
|
|
in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute action cfg Output.Mode.Edn)
|
|
in
|
|
expect_bool "graph info ok" false (Cli_result.is_error result);
|
|
expect_bool "q called" true !q_called;
|
|
let data =
|
|
expect_some "graph info data" (Cli_result.data_value result)
|
|
in
|
|
expect_equal "graph info graph" "demo"
|
|
(expect_some "graph" (Edn_util.get_string data "graph"));
|
|
expect_int "schema version" 7
|
|
(expect_some "schema"
|
|
(Edn_util.get_int data "logseq.kv/schema-version"));
|
|
expect_bool "kv map present" true
|
|
(Option.is_some (Edn_util.get data "kv"));
|
|
Js.Promise.resolve pass));
|
|
|
|
test "CLI parity graph build normalizes backup and import actions" (fun () ->
|
|
let selected = config ~graph:"demo" () in
|
|
let backup =
|
|
expect_ok "backup create"
|
|
(Graph.build selected (Global_opts.create ())
|
|
(Graph.Parsed_backup_create { name = Some " nightly " }))
|
|
in
|
|
(match backup with
|
|
| Graph.Graph_backup_create { graph; repo; name; backup_name } ->
|
|
expect_equal "backup graph" "demo" (graph_text graph);
|
|
expect_equal "backup repo" "logseq_db_demo" (repo_text repo);
|
|
expect_equal "backup label" "nightly" (expect_some "name" name);
|
|
expect_named_contains "backup generated name"
|
|
(expect_some "backup name" backup_name)
|
|
"demo-nightly-"
|
|
| _ -> fail_test "expected Graph_backup_create action");
|
|
let restore =
|
|
expect_ok "backup restore"
|
|
(Graph.build selected (Global_opts.create ())
|
|
(Graph.Parsed_backup_restore
|
|
{
|
|
src = " nightly ";
|
|
dst = Cli_primitive.create_graph " restored ";
|
|
}))
|
|
in
|
|
(match restore with
|
|
| Graph.Graph_backup_restore
|
|
{ source_repo; source_graph; dst_repo; dst_graph; src; dst } ->
|
|
expect_equal "restore source repo" "logseq_db_demo"
|
|
(repo_text source_repo);
|
|
expect_equal "restore source graph" "demo" (graph_text source_graph);
|
|
expect_equal "restore dst repo" "logseq_db_restored"
|
|
(repo_text dst_repo);
|
|
expect_equal "restore dst graph" "restored" (graph_text dst_graph);
|
|
expect_equal "restore src trim" "nightly" src;
|
|
expect_equal "restore dst trim" "restored" dst
|
|
| _ -> fail_test "expected Graph_backup_restore action");
|
|
expect_error_code "backup restore blank dst" "missing-dst"
|
|
(Graph.build selected (Global_opts.create ())
|
|
(Graph.Parsed_backup_restore
|
|
{ src = "nightly"; dst = Cli_primitive.create_graph " " }));
|
|
let sqlite_import =
|
|
expect_ok "sqlite import"
|
|
(Graph.build selected (Global_opts.create ())
|
|
(Graph.Parsed_import
|
|
{
|
|
import_type = Graph.Import_sqlite;
|
|
input = "/tmp/demo.sqlite";
|
|
}))
|
|
in
|
|
(match sqlite_import with
|
|
| Graph.Graph_import { graph; repo; opts; require_missing_graph } ->
|
|
expect_equal "sqlite import graph" "demo" (graph_text graph);
|
|
expect_equal "sqlite import repo" "logseq_db_demo" (repo_text repo);
|
|
expect_bool "sqlite import type" true
|
|
(opts.import_type = Graph.Import_sqlite);
|
|
expect_bool "sqlite requires missing" true require_missing_graph
|
|
| _ -> fail_test "expected Graph_import sqlite action");
|
|
let edn_import =
|
|
expect_ok "edn import"
|
|
(Graph.build selected (Global_opts.create ())
|
|
(Graph.Parsed_import
|
|
{ import_type = Graph.Import_edn; input = "/tmp/demo.edn" }))
|
|
in
|
|
match edn_import with
|
|
| Graph.Graph_import { opts; require_missing_graph; _ } ->
|
|
expect_bool "edn import type" true
|
|
(opts.import_type = Graph.Import_edn);
|
|
expect_bool "edn does not require missing" false require_missing_graph
|
|
| _ -> fail_test "expected Graph_import edn action");
|
|
|
|
test_promise
|
|
"CLI parity graph backup create invokes worker and writes metadata"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-backup-create-" in
|
|
let invoke_calls = ref Vec.empty in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
invoke_calls := Vec.push_front !invoke_calls body;
|
|
if Js.String.includes ~search:"thread-api/backup-db-sqlite" body
|
|
then (
|
|
let tmp_path = invoke_arg_string body 1 in
|
|
mkdir_p (Filename.dirname tmp_path);
|
|
write_file tmp_path "sqlite-copy";
|
|
"[\"^ \",\"~:ok\",true]")
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let graph = Cli_primitive.create_graph "demo" in
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let backup_name = "demo-nightly-20260101T000000Z" in
|
|
let action =
|
|
Graph.Graph_backup_create
|
|
{
|
|
graph;
|
|
repo;
|
|
name = Some "nightly";
|
|
backup_name = Some backup_name;
|
|
}
|
|
in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ~root_dir:root ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute action cfg Output.Mode.Edn)
|
|
in
|
|
let backup_dir =
|
|
Node.Path.join [| root; "graphs"; "demo"; "backup"; backup_name |]
|
|
in
|
|
let db_path = Node.Path.join [| backup_dir; "db.sqlite" |] in
|
|
let metadata_path = Node.Path.join [| backup_dir; "metadata.edn" |] in
|
|
expect_bool "backup create ok" false (Cli_result.is_error result);
|
|
expect_int "backup invoke count" 1 (Vec.length !invoke_calls);
|
|
expect_equal "backup method repo" "logseq_db_demo"
|
|
(invoke_arg_string (Vec.peek_front !invoke_calls) 0);
|
|
expect_equal "final sqlite payload" "sqlite-copy" (read_file db_path);
|
|
let data =
|
|
expect_some "backup create data" (Cli_result.data_value result)
|
|
in
|
|
expect_equal "backup result name" backup_name
|
|
(expect_some "backup-name" (Edn_util.get_string data "backup-name"));
|
|
expect_equal "backup result path" db_path
|
|
(expect_some "path" (Edn_util.get_string data "path"));
|
|
let metadata = edn_of_string (read_file metadata_path) in
|
|
expect_equal "metadata source" "cli"
|
|
(expect_some "metadata source"
|
|
(Edn_util.get_string metadata "source"));
|
|
expect_equal "metadata name" backup_name
|
|
(expect_some "metadata name" (Edn_util.get_string metadata "name"));
|
|
remove_tree root;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise
|
|
"CLI parity graph backup create cleans reserved target after worker failure"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-backup-create-cleanup-" in
|
|
let backup_name = "demo-failure" in
|
|
let backup_dir =
|
|
Node.Path.join [| root; "graphs"; "demo"; "backup"; backup_name |]
|
|
in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
if Js.String.includes ~search:"thread-api/backup-db-sqlite" body
|
|
then failwith "snapshot failed"
|
|
else "null")
|
|
in
|
|
Js.Promise.make (fun ~resolve ~reject ->
|
|
server_listen server 0 "127.0.0.1" (fun[@u] () ->
|
|
let port = (server_address server)##port in
|
|
let base_url = Printf.sprintf "http://127.0.0.1:%d" port in
|
|
let resolve_after_close () =
|
|
server_close server (fun[@u] () -> (resolve pass [@u]))
|
|
in
|
|
let reject_after_close message =
|
|
server_close server (fun[@u] () ->
|
|
(reject (Failure message) [@u]))
|
|
in
|
|
let close_and_fail message =
|
|
remove_tree root;
|
|
reject_after_close message
|
|
in
|
|
let action =
|
|
Graph.Graph_backup_create
|
|
{
|
|
graph = Cli_primitive.create_graph "demo";
|
|
repo = Cli_primitive.create_repo "demo";
|
|
name = None;
|
|
backup_name = Some backup_name;
|
|
}
|
|
in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ~root_dir:root ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
Cli_effect.on_any
|
|
(execute_with_output Graph.execute action cfg Output.Mode.Human)
|
|
(fun result ->
|
|
if not (Cli_result.is_error result) then
|
|
close_and_fail "expected backup create error result"
|
|
else
|
|
let target_exists = Node.Fs.existsSync backup_dir in
|
|
if target_exists then
|
|
close_and_fail
|
|
"reserved backup target removed: expected false, got \
|
|
true"
|
|
else (
|
|
remove_tree root;
|
|
resolve_after_close ()))
|
|
(fun exn ->
|
|
let target_exists = Node.Fs.existsSync backup_dir in
|
|
if target_exists then
|
|
close_and_fail
|
|
"reserved backup target removed: expected false, got true"
|
|
else (
|
|
remove_tree root;
|
|
reject_after_close (Printexc.to_string exn))))));
|
|
|
|
test_promise
|
|
"CLI parity graph backup list restore and remove use scoped backup dirs"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-backup-flow-" in
|
|
let demo_backup =
|
|
Node.Path.join
|
|
[| root; "graphs"; "demo"; "backup"; "demo-nightly"; "db.sqlite" |]
|
|
in
|
|
let other_backup =
|
|
Node.Path.join
|
|
[| root; "graphs"; "other"; "backup"; "other-nightly"; "db.sqlite" |]
|
|
in
|
|
mkdir_p (Filename.dirname demo_backup);
|
|
mkdir_p (Filename.dirname other_backup);
|
|
write_file demo_backup "demo";
|
|
write_file other_backup "other";
|
|
let calls = ref Vec.empty in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
calls := Vec.push_front !calls body;
|
|
if Js.String.includes ~search:"thread-api/import-db-binary" body
|
|
then "[\"^ \",\"~:ok\",true]"
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let graph = Cli_primitive.create_graph "demo" in
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ~root_dir:root ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let* list_result =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_backup_list { graph; repo })
|
|
cfg Output.Mode.Edn)
|
|
in
|
|
let backups =
|
|
expect_some "backups"
|
|
(Option.bind
|
|
(Option.bind (Cli_result.data_value list_result) (fun data ->
|
|
Edn_util.get data "backups"))
|
|
Edn_util.as_seq)
|
|
in
|
|
expect_int "only current graph backups" 1 (Vec.length backups);
|
|
expect_equal "backup name" "demo-nightly"
|
|
(expect_some "backup name"
|
|
(Edn_util.get_string (Vec.peek_front backups) "name"));
|
|
let* missing_restore =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_backup_restore
|
|
{
|
|
source_repo = repo;
|
|
source_graph = graph;
|
|
dst_repo = Cli_primitive.create_repo "restored";
|
|
dst_graph = Cli_primitive.create_graph "restored";
|
|
src = "missing";
|
|
dst = "restored";
|
|
})
|
|
cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "missing restore is error" true
|
|
(Cli_result.is_error missing_restore);
|
|
(match missing_restore.Cli_result.error with
|
|
| Some err ->
|
|
expect_equal "missing restore code" "backup-not-found"
|
|
(Error.code_to_string err.Error.code)
|
|
| None -> fail_test "expected missing restore error");
|
|
let* restore_result =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_backup_restore
|
|
{
|
|
source_repo = repo;
|
|
source_graph = graph;
|
|
dst_repo = Cli_primitive.create_repo "restored";
|
|
dst_graph = Cli_primitive.create_graph "restored";
|
|
src = "demo-nightly";
|
|
dst = "restored";
|
|
})
|
|
cfg Output.Mode.Edn)
|
|
in
|
|
expect_bool "restore ok" false (Cli_result.is_error restore_result);
|
|
expect_bool "restore invokes import" true
|
|
(Vec.exists
|
|
(fun body ->
|
|
Js.String.includes ~search:"thread-api/import-db-binary" body)
|
|
!calls);
|
|
let* missing_remove =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_backup_remove
|
|
{ graph; repo; src = "missing-nightly" })
|
|
cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "missing remove is error" true
|
|
(Cli_result.is_error missing_remove);
|
|
let* remove_result =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_backup_remove
|
|
{ graph; repo; src = "demo-nightly" })
|
|
cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "remove ok" false (Cli_result.is_error remove_result);
|
|
expect_bool "backup dir removed" false
|
|
(Node.Fs.existsSync (Filename.dirname demo_backup));
|
|
remove_tree root;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise
|
|
"CLI parity graph export and import execute through transport and files"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-graph-io-" in
|
|
let edn_export = Node.Path.join [| root; "export.edn" |] in
|
|
let import_edn = Node.Path.join [| root; "import.edn" |] in
|
|
let import_sqlite = Node.Path.join [| root; "import.sqlite" |] in
|
|
write_file import_edn "{:page \"Import Page\"}";
|
|
write_file import_sqlite "sqlite";
|
|
let calls = ref Vec.empty in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
calls := Vec.push_front !calls body;
|
|
if Js.String.includes ~search:"thread-api/backup-db-sqlite" body
|
|
then (
|
|
let path = invoke_arg_string body 1 in
|
|
mkdir_p (Filename.dirname path);
|
|
write_file path "sqlite-copy";
|
|
"[\"^ \",\"~:ok\",true]")
|
|
else if Js.String.includes ~search:"thread-api/export-edn" body then
|
|
"[\"^ \",\"~:exported\",true]"
|
|
else if Js.String.includes ~search:"thread-api/import-edn" body then
|
|
"[\"^ \",\"~:ok\",true]"
|
|
else if
|
|
Js.String.includes ~search:"thread-api/import-db-binary" body
|
|
then "[\"^ \",\"~:ok\",true]"
|
|
else "null")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let graph = Cli_primitive.create_graph "demo" in
|
|
let repo = Cli_primitive.create_repo "demo" in
|
|
let cfg =
|
|
{
|
|
(config ~repo:"demo" ~root_dir:root ()) with
|
|
Cli_config.base_url = Some base_url;
|
|
}
|
|
in
|
|
let edn_opts =
|
|
{
|
|
Graph.export_type = Graph.Edn;
|
|
file = Some edn_export;
|
|
edn_options =
|
|
Some
|
|
(edn_of_string
|
|
"{:export-type :graph :include-timestamps? true}");
|
|
pretty_print = true;
|
|
include_timestamps = false;
|
|
exclude_built_in_pages = false;
|
|
exclude_namespaces = Vec.empty;
|
|
}
|
|
in
|
|
let sqlite_opts =
|
|
{
|
|
Graph.export_type = Graph.Sqlite;
|
|
file = None;
|
|
edn_options = None;
|
|
pretty_print = false;
|
|
include_timestamps = false;
|
|
exclude_built_in_pages = false;
|
|
exclude_namespaces = Vec.empty;
|
|
}
|
|
in
|
|
let* edn_result =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_export { graph; repo; opts = edn_opts })
|
|
cfg Output.Mode.Edn)
|
|
in
|
|
expect_bool "edn export ok" false (Cli_result.is_error edn_result);
|
|
expect_named_contains "export file content" (read_file edn_export)
|
|
":exported true";
|
|
expect_named_contains "pretty export writes multiline edn"
|
|
(read_file edn_export) "\n";
|
|
let* sqlite_result =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_export { graph; repo; opts = sqlite_opts })
|
|
cfg Output.Mode.Human)
|
|
in
|
|
expect_bool "sqlite export ok" false
|
|
(Cli_result.is_error sqlite_result);
|
|
let sqlite_path = invoke_arg_string (Vec.peek_front !calls) 1 in
|
|
expect_named_contains "default sqlite export path" sqlite_path
|
|
(Node.Path.join [| root; "graphs"; "demo"; "export"; "demo_" |]);
|
|
expect_bool "default sqlite export suffix" true
|
|
(Js.String.endsWith ~suffix:".sqlite" sqlite_path);
|
|
let* import_edn_result =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_import
|
|
{
|
|
graph;
|
|
repo;
|
|
opts =
|
|
{
|
|
Graph.import_type = Graph.Import_edn;
|
|
input = import_edn;
|
|
};
|
|
require_missing_graph = false;
|
|
})
|
|
cfg Output.Mode.Edn)
|
|
in
|
|
expect_bool "edn import ok" false
|
|
(Cli_result.is_error import_edn_result);
|
|
let* import_sqlite_result =
|
|
effect_to_promise
|
|
(execute_with_output Graph.execute
|
|
(Graph.Graph_import
|
|
{
|
|
graph;
|
|
repo;
|
|
opts =
|
|
{
|
|
Graph.import_type = Graph.Import_sqlite;
|
|
input = import_sqlite;
|
|
};
|
|
require_missing_graph = true;
|
|
})
|
|
cfg Output.Mode.Edn)
|
|
in
|
|
expect_bool "sqlite import ok" false
|
|
(Cli_result.is_error import_sqlite_result);
|
|
let joined = Vec.string_concat "\n" !calls in
|
|
expect_named_contains "export edn invoked" joined
|
|
"thread-api/export-edn";
|
|
expect_named_contains "sqlite export invoked" joined
|
|
"thread-api/backup-db-sqlite";
|
|
expect_named_contains "import edn invoked" joined
|
|
"thread-api/import-edn";
|
|
expect_named_contains "import sqlite invoked" joined
|
|
"thread-api/import-db-binary";
|
|
remove_tree root;
|
|
Js.Promise.resolve pass));
|
|
|
|
test "CLI parity top-level graph constraints reject existing sqlite imports"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-graph-constraints-" in
|
|
let graph_dir = Node.Path.join [| root; "graphs"; "demo" |] in
|
|
let sqlite_path = Node.Path.join [| root; "input.sqlite" |] in
|
|
mkdir_p graph_dir;
|
|
write_file sqlite_path "sqlite";
|
|
let output =
|
|
run_cli_lifecycle
|
|
[|
|
|
"--root-dir";
|
|
root;
|
|
"--graph";
|
|
"demo";
|
|
"graph";
|
|
"import";
|
|
"--type";
|
|
"sqlite";
|
|
"--input";
|
|
sqlite_path;
|
|
|]
|
|
in
|
|
expect_int "existing sqlite import exit" 1 output.exit_code;
|
|
expect_named_contains "existing sqlite import code"
|
|
(stdout_text "existing sqlite import stdout" output)
|
|
"graph-exists";
|
|
remove_tree root);
|
|
|
|
test "CLI parity errors are printed to stdout with non-zero exit" (fun () ->
|
|
let result = spawn_cli [| "list"; "page"; "--limit"; "nope" |] in
|
|
ignore (expect_exit_non_zero "bad list limit" result);
|
|
expect_named_contains "error code" result##stdout "invalid-options";
|
|
expect_named_contains "error message" result##stdout "Expected integer");
|
|
|
|
test "CLI parity main version output includes build metadata" (fun () ->
|
|
let output = run_cli_lifecycle [| "--version" |] in
|
|
expect_int "version exit" 0 output.exit_code;
|
|
let stdout = stdout_text "version stdout" output in
|
|
expect_named_contains "version build time" stdout "Build time: ";
|
|
expect_named_contains "version revision" stdout "Revision: ";
|
|
expect_bool "profile disabled" true (Vec.is_empty output.stderr));
|
|
|
|
test "CLI parity main uses a later duplicate option with a value" (fun () ->
|
|
let output =
|
|
run_cli_lifecycle [| "--output"; "--output"; "json"; "--version" |]
|
|
in
|
|
expect_int "duplicate output version exit" 0 output.exit_code;
|
|
let stdout = stdout_text "duplicate output version stdout" output in
|
|
expect_valid_json "duplicate output version json" stdout;
|
|
expect_named_contains "duplicate output version status" stdout
|
|
"\"status\":\"ok\"");
|
|
|
|
test "CLI parity version action output includes build metadata" (fun () ->
|
|
let result =
|
|
effect_result "version action"
|
|
(execute_with_output Cli_action.execute Cli_action.Version (config ())
|
|
Output.Mode.Human)
|
|
in
|
|
let output = Format_types.format_result result (config ()) in
|
|
expect_named_contains "version action build time" output "Build time: ";
|
|
expect_named_contains "version action revision" output "Revision: ");
|
|
|
|
test "CLI parity main structured help respects output modes" (fun () ->
|
|
let json_output = run_cli_lifecycle [| "--output"; "json"; "--help" |] in
|
|
expect_int "json help exit" 0 json_output.exit_code;
|
|
let json_stdout = stdout_text "json help stdout" json_output in
|
|
expect_valid_json "json help output" json_stdout;
|
|
expect_named_contains "json help status" json_stdout "\"status\":\"ok\"";
|
|
expect_named_contains "json help message" json_stdout "Usage: logseq";
|
|
let edn_output = run_cli_lifecycle [| "--output"; "edn"; "--help" |] in
|
|
expect_int "edn help exit" 0 edn_output.exit_code;
|
|
let edn_stdout = stdout_text "edn help stdout" edn_output in
|
|
expect_valid_edn "edn help output" edn_stdout;
|
|
expect_named_contains "edn help status" edn_stdout ":status :ok";
|
|
expect_named_contains "edn help message" edn_stdout "Usage: logseq");
|
|
|
|
test "CLI parity main structured parse errors respect output modes" (fun () ->
|
|
let json_output = run_cli_lifecycle [| "--output"; "json"; "wat" |] in
|
|
expect_int "json parse exit" 1 json_output.exit_code;
|
|
let json_stdout = stdout_text "json parse stdout" json_output in
|
|
expect_valid_json "json parse error output" json_stdout;
|
|
expect_named_contains "json parse error status" json_stdout
|
|
"\"status\":\"error\"";
|
|
expect_named_contains "json parse error message" json_stdout "\"message\"";
|
|
let edn_output = run_cli_lifecycle [| "--output"; "edn"; "wat" |] in
|
|
expect_int "edn parse exit" 1 edn_output.exit_code;
|
|
let edn_stdout = stdout_text "edn parse stdout" edn_output in
|
|
expect_valid_edn "edn parse error output" edn_stdout;
|
|
expect_named_contains "edn parse error status" edn_stdout ":status :error";
|
|
expect_named_contains "edn parse error message" edn_stdout ":message");
|
|
|
|
test "CLI parity main profile lines are emitted for version" (fun () ->
|
|
let output = run_cli_lifecycle [| "--profile"; "--version" |] in
|
|
expect_int "profile version exit" 0 output.exit_code;
|
|
let stdout = stdout_text "profile version stdout" output in
|
|
expect_named_contains "profile version build time" stdout "Build time: ";
|
|
let profile = Vec.string_concat "\n" output.stderr in
|
|
expect_named_contains "profile version headline" profile
|
|
"command=version status=ok";
|
|
expect_named_contains "profile version stages" profile "stages";
|
|
expect_named_contains "profile version parse stage" profile
|
|
"cli.parse-args";
|
|
expect_named_contains "profile version total stage" profile "cli.total");
|
|
|
|
test "CLI parity main profile lines are disabled by default" (fun () ->
|
|
let output = run_cli_lifecycle [| "--help" |] in
|
|
expect_int "help exit" 0 output.exit_code;
|
|
expect_bool "no profile lines" true (Vec.is_empty output.stderr));
|
|
|
|
test "CLI parity command help includes primary and secondary command groups"
|
|
(fun () ->
|
|
let output = run_cli [| "--help" |] in
|
|
expect_named_contains "graph command" output "graph list";
|
|
expect_named_contains "upsert command" output "upsert block";
|
|
expect_named_contains "sync command" output "sync upload";
|
|
expect_named_contains "skill command" output "skill show";
|
|
expect_named_not_contains "retired qmd" output "qmd");
|
|
|
|
test "CLI parity group help surfaces subcommands without option suffix"
|
|
(fun () ->
|
|
let list_help = run_cli [| "list" |] in
|
|
expect_named_contains "list usage" list_help
|
|
"Usage: logseq list <subcommand> [options]";
|
|
expect_named_contains "list page command" list_help "list page";
|
|
expect_named_contains "list asset command" list_help "list asset";
|
|
expect_named_not_contains "list command options suffix" list_help
|
|
"list page [options]";
|
|
let backup_help = run_cli [| "graph"; "backup" |] in
|
|
expect_named_contains "backup usage" backup_help
|
|
"Usage: logseq graph backup <subcommand> [options]";
|
|
expect_named_contains "backup list command" backup_help
|
|
"graph backup list";
|
|
expect_named_contains "backup restore command" backup_help
|
|
"graph backup restore";
|
|
let query_help = run_cli [| "query"; "-h" |] in
|
|
expect_named_contains "query option" query_help "--query";
|
|
expect_named_contains "query name" query_help "--name";
|
|
expect_named_contains "query inputs" query_help "--inputs");
|
|
|
|
test "CLI parity command help includes registry examples" (fun () ->
|
|
let remove_help = run_cli [| "remove"; "block"; "--help" |] in
|
|
expect_named_contains "remove block usage" remove_help
|
|
"Usage: logseq remove block";
|
|
expect_named_contains "remove block options" remove_help
|
|
"Command options:";
|
|
expect_named_contains "remove block examples" remove_help "Examples:";
|
|
let upsert_help = run_cli [| "upsert"; "block"; "--help" |] in
|
|
expect_named_contains "upsert block usage" upsert_help
|
|
"Usage: logseq upsert block";
|
|
expect_named_contains "upsert block examples" upsert_help "Examples:";
|
|
let example_help = run_cli [| "example"; "upsert"; "--help" |] in
|
|
expect_named_contains "example upsert usage" example_help
|
|
"Usage: logseq example upsert";
|
|
expect_named_not_contains "example upsert group has no examples"
|
|
example_help "Examples:");
|
|
|
|
test
|
|
"CLI parity structured example output keeps selector matched commands and \
|
|
message" (fun () ->
|
|
let result = spawn_cli [| "--output"; "json"; "example"; "upsert" |] in
|
|
ignore (expect_exit_zero "example upsert json" result);
|
|
expect_named_contains "selector" result##stdout "\"selector\":\"upsert\"";
|
|
expect_named_contains "matched command" result##stdout "upsert block";
|
|
expect_named_contains "message" result##stdout "Found");
|
|
|
|
test "CLI parity show validation rejects ambiguous targets" (fun () ->
|
|
expect_error_code "show id uuid" "invalid-options"
|
|
(Show.validate_parsed
|
|
(Show.Parsed_show
|
|
{
|
|
id_raw = Some "1";
|
|
uuid = Some "00000000-0000-4000-8000-000000000001";
|
|
page = None;
|
|
page_hierarchy = false;
|
|
linked_references = None;
|
|
ref_id_footer = None;
|
|
level = None;
|
|
stdin_id = None;
|
|
}));
|
|
let result =
|
|
spawn_cli [| "--graph"; "demo"; "show"; "--id"; "1"; "--page"; "Home" |]
|
|
in
|
|
ignore (expect_exit_non_zero "show ambiguous cli" result);
|
|
expect_named_contains "show ambiguous message" result##stdout
|
|
"only one of --id, --uuid, or --page is allowed");
|
|
|
|
test "CLI parity completion command parses shell argument and validation"
|
|
(fun () ->
|
|
let positional =
|
|
expect_parse_ok "completion positional" [| "completion"; "zsh" |]
|
|
in
|
|
(match positional.command with
|
|
| Cli_request.Completion
|
|
(Completion.Parsed_completion { shell = Some Cli_primitive.Zsh }) ->
|
|
pass
|
|
| _ -> fail_test "expected zsh completion request");
|
|
let option =
|
|
expect_parse_ok "completion option"
|
|
[| "completion"; "--shell"; "bash" |]
|
|
in
|
|
(match option.command with
|
|
| Cli_request.Completion
|
|
(Completion.Parsed_completion { shell = Some Cli_primitive.Bash }) ->
|
|
pass
|
|
| _ -> fail_test "expected bash completion request");
|
|
expect_parse_error_code "completion missing shell" ":invalid-options"
|
|
[| "completion" |];
|
|
expect_parse_error_code "completion unsupported shell" ":invalid-options"
|
|
[| "completion"; "fish" |]);
|
|
|
|
test "CLI parity path-specific short aliases resolve to command specific meanings"
|
|
(fun () ->
|
|
let validate =
|
|
expect_parse_ok "graph validate -f" [| "graph"; "validate"; "-f" |]
|
|
in
|
|
(match validate.command with
|
|
| Cli_request.Graph (Graph.Parsed_validate { fix }) ->
|
|
expect_bool "validate -f is fix" true fix
|
|
| _ -> fail_test "expected graph validate");
|
|
let export =
|
|
expect_parse_ok "graph export -f"
|
|
[| "graph"; "export"; "-t"; "edn"; "-f"; "/tmp/export.edn" |]
|
|
in
|
|
(match export.command with
|
|
| Cli_request.Graph (Graph.Parsed_export opts) ->
|
|
expect_equal "export -f is file" "/tmp/export.edn"
|
|
(expect_some "export file" opts.file)
|
|
| _ -> fail_test "expected graph export");
|
|
let export_eq =
|
|
expect_parse_ok "graph export -f= form"
|
|
[| "graph"; "export"; "-t"; "edn"; "-f=/tmp/export.edn" |]
|
|
in
|
|
(match export_eq.command with
|
|
| Cli_request.Graph (Graph.Parsed_export opts) ->
|
|
expect_equal "export -f= is file" "/tmp/export.edn"
|
|
(expect_some "export file eq" opts.file)
|
|
| _ -> fail_test "expected graph export");
|
|
let page = expect_parse_ok "list page -e" [| "list"; "page"; "-e" |] in
|
|
(match page.command with
|
|
| Cli_request.List (List_command.Parsed_page opts) ->
|
|
expect_bool "list page -e is expand" true opts.expand
|
|
| _ -> fail_test "expected list page");
|
|
expect_parse_error_code "graph validate rejects --fields"
|
|
":invalid-options"
|
|
[| "graph"; "validate"; "--fields"; "id" |]);
|
|
|
|
test "CLI parity completion generation includes top nested and value cases"
|
|
(fun () ->
|
|
let registry = (Cli.make_app_context ()).Cli.registry in
|
|
let zsh = Completion.generate Cli_primitive.Zsh registry in
|
|
expect_named_contains "zsh header" zsh "#compdef logseq";
|
|
expect_named_contains "zsh graph group" zsh "_logseq_graph()";
|
|
expect_named_contains "zsh nested backup" zsh "_logseq_graph_backup()";
|
|
expect_named_contains "zsh graph completions" zsh "_logseq_graphs";
|
|
expect_named_contains "zsh graph compadd" zsh "compadd -a graphs";
|
|
expect_named_contains "zsh graph short alias" zsh
|
|
"'(-g --graph)'{-g=,--graph=}'[Graph name]:graph:{_logseq_graphs}'";
|
|
expect_named_contains "zsh output choices" zsh
|
|
"'(-o --output)'{-o=,--output=}'[Output format]:mode:(human json edn)'";
|
|
expect_named_contains "zsh nested leaf function" zsh "_logseq_graph_list()";
|
|
expect_named_contains "zsh show id option" zsh "'--id=[Entity id]::id:'";
|
|
expect_named_contains "zsh show level option" zsh
|
|
"'--level=[Tree depth]:n:'";
|
|
expect_named_contains "zsh query group dispatcher keeps own options" zsh
|
|
"'--query=[Datascript query]:edn:'";
|
|
expect_named_contains "zsh comma separated fields completion" zsh
|
|
"'--fields=[Comma-separated fields to include]:fields:{_values -s , \
|
|
fields id title ident uuid created-at updated-at}'";
|
|
expect_named_contains "zsh export file short alias" zsh
|
|
"'(-f --file)'{-f=,--file=}'[Output file]:path:_files'";
|
|
expect_named_contains "zsh list expand short alias" zsh
|
|
"'(-e --expand)'{-e,--expand}'[Expand page data]'";
|
|
let bash = Completion.generate Cli_primitive.Bash registry in
|
|
expect_named_contains "bash header" bash
|
|
"# Auto-generated by `logseq completion bash`";
|
|
expect_named_contains "bash graph command" bash " graph ";
|
|
expect_named_contains "bash upsert command" bash " upsert";
|
|
expect_named_contains "bash search command" bash " search ";
|
|
expect_named_contains "bash nested backup case" bash "graph:backup";
|
|
expect_named_contains "bash graph names" bash "_logseq_json_names_bash");
|
|
|
|
test "CLI parity completion generation keeps current dynamic helper surface"
|
|
(fun () ->
|
|
let registry = (Cli.make_app_context ()).Cli.registry in
|
|
let zsh = Completion.generate Cli_primitive.Zsh registry in
|
|
expect_named_contains "zsh graph helper" zsh "_logseq_graphs";
|
|
expect_named_not_contains "zsh page helper removed" zsh "_logseq_pages";
|
|
expect_named_not_contains "zsh query helper removed" zsh "_logseq_queries";
|
|
expect_named_not_contains "zsh current graph helper removed" zsh
|
|
"_logseq_current_graph";
|
|
let bash = Completion.generate Cli_primitive.Bash registry in
|
|
expect_named_not_contains "bash page helper removed" bash
|
|
"_logseq_pages_bash";
|
|
expect_named_not_contains "bash query helper removed" bash
|
|
"_logseq_queries_bash";
|
|
expect_named_contains "bash json name helper" bash
|
|
"_logseq_json_names_bash";
|
|
expect_named_not_contains "bash current graph helper removed" bash
|
|
"_logseq_current_graph_bash");
|
|
|
|
test "CLI parity zsh completion keeps current global option contracts"
|
|
(fun () ->
|
|
let registry = (Cli.make_app_context ()).Cli.registry in
|
|
let zsh = Completion.generate Cli_primitive.Zsh registry in
|
|
expect_named_contains "zsh top dispatcher" zsh "_logseq()";
|
|
expect_named_contains "zsh graph helper" zsh "_logseq_graphs";
|
|
expect_named_contains "zsh global output option" zsh
|
|
"'(-o --output)'{-o=,--output=}'[Output format]:mode:(human json edn)'";
|
|
expect_named_contains "zsh graph export edn options" zsh "--edn-options";
|
|
expect_named_contains "zsh graph create sync option" zsh "--enable-sync";
|
|
expect_named_contains "zsh search content option" zsh "--content";
|
|
expect_named_not_contains "zsh content short alias removed" zsh "-c[";
|
|
expect_named_not_contains "zsh command boolean negation removed" zsh
|
|
"--no-include-built-in";
|
|
expect_named_not_contains "zsh global boolean negation" zsh "--no-verbose";
|
|
expect_named_not_contains "zsh multi value helper removed" zsh
|
|
"_logseq_multi_values");
|
|
|
|
test "CLI parity bash completion keeps current global option contracts"
|
|
(fun () ->
|
|
let registry = (Cli.make_app_context ()).Cli.registry in
|
|
let bash = Completion.generate Cli_primitive.Bash registry in
|
|
expect_named_contains "bash global opts helper" bash "_logseq_opts_for";
|
|
expect_named_contains "bash global options" bash
|
|
"--help -h --version --config --graph -g --root-dir --timeout-ms \
|
|
--output -o --verbose -v --profile";
|
|
expect_named_not_contains "bash graph export edn options removed" bash
|
|
"--edn-options";
|
|
expect_named_not_contains "bash search content option removed" bash
|
|
"--content -c";
|
|
expect_named_not_contains "bash command boolean negation removed" bash
|
|
"--no-include-built-in";
|
|
expect_named_not_contains "bash global boolean negation" bash
|
|
"--no-verbose";
|
|
expect_named_not_contains "bash multi value helper removed" bash
|
|
"_logseq_multi_values_bash";
|
|
expect_named_not_contains "bash enum whitespace helper removed" bash
|
|
"_logseq_enum_values_bash");
|
|
|
|
test "CLI parity command registry fills catalog options for known paths"
|
|
(fun () ->
|
|
let registry = (Cli.make_app_context ()).Cli.registry in
|
|
let has_name name (option : Command_registry.option_meta) =
|
|
Vec.mem name option.names
|
|
in
|
|
let option_by_name name options = Vec.find_opt (has_name name) options in
|
|
let assert_timestamp_headers_last
|
|
(command : Command_registry.command_meta) =
|
|
let headers = command.human_table_headers_order in
|
|
if Vec.mem "created-at" headers || Vec.mem "updated-at" headers then
|
|
let reversed = Vec.rev headers in
|
|
if
|
|
Vec.length reversed >= 2
|
|
&& Vec.nth reversed 0 = "updated-at"
|
|
&& Vec.nth reversed 1 = "created-at"
|
|
then pass
|
|
else
|
|
fail_test
|
|
(Printf.sprintf
|
|
"%s: expected created-at,updated-at suffix, got %s"
|
|
(Vec.string_concat " " command.path)
|
|
(Vec.string_concat "," headers))
|
|
in
|
|
Vec.iter assert_timestamp_headers_last registry.commands;
|
|
let output_option =
|
|
expect_some "global output option"
|
|
(option_by_name "--output" Command_registry.global_options)
|
|
in
|
|
expect_bool "global output has -o alias" true
|
|
(has_name "-o" output_option);
|
|
expect_equal "global output default" "human"
|
|
(expect_some "output default" output_option.default);
|
|
expect_string_vec "global output choices"
|
|
[| "human"; "json"; "edn" |]
|
|
output_option.choices;
|
|
let graph_option =
|
|
expect_some "global graph option"
|
|
(option_by_name "--graph" Command_registry.global_options)
|
|
in
|
|
expect_bool "global graph has -g alias" true (has_name "-g" graph_option);
|
|
let profile_option =
|
|
expect_some "global profile option"
|
|
(option_by_name "--profile" Command_registry.global_options)
|
|
in
|
|
expect_bool "profile is flag" true
|
|
(profile_option.arity = Command_registry.Flag);
|
|
let completion =
|
|
expect_some "completion command"
|
|
(Command_registry.find_by_path (Vec.singleton "completion") registry)
|
|
in
|
|
expect_bool "completion shell choices" true
|
|
(Vec.exists
|
|
(fun (option : Command_registry.option_meta) ->
|
|
Vec.to_array option.names = [| "--shell" |]
|
|
&& Vec.to_array option.choices = [| "zsh"; "bash" |])
|
|
completion.Command_registry.options);
|
|
let graph_create =
|
|
expect_some "graph create"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "graph"; "create" |])
|
|
registry)
|
|
in
|
|
expect_bool "graph create enable sync" true
|
|
(Option.is_some (option_by_name "--enable-sync" graph_create.options));
|
|
expect_bool "graph create password" true
|
|
(Option.is_some (option_by_name "--e2ee-password" graph_create.options));
|
|
let graph_export =
|
|
expect_some "graph export"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "graph"; "export" |])
|
|
registry)
|
|
in
|
|
let export_type =
|
|
expect_some "export type option"
|
|
(option_by_name "--type" graph_export.options)
|
|
in
|
|
expect_string_vec "export type choices" [| "edn"; "sqlite" |]
|
|
export_type.choices;
|
|
expect_bool "export edn options" true
|
|
(Option.is_some (option_by_name "--edn-options" graph_export.options));
|
|
expect_bool "export edn options alias" true
|
|
(Option.is_some (option_by_name "-e" graph_export.options));
|
|
expect_bool "export pretty print" true
|
|
(Option.is_some (option_by_name "--pretty-print" graph_export.options));
|
|
expect_bool "export pretty print alias" true
|
|
(Option.is_some (option_by_name "-p" graph_export.options));
|
|
expect_bool "export timestamps retired" true
|
|
(Option.is_none
|
|
(option_by_name "--include-timestamps" graph_export.options));
|
|
expect_bool "export built-ins retired" true
|
|
(Option.is_none
|
|
(option_by_name "--exclude-built-in-pages" graph_export.options));
|
|
expect_bool "export namespaces retired" true
|
|
(Option.is_none
|
|
(option_by_name "--exclude-namespaces" graph_export.options));
|
|
let graph_import =
|
|
expect_some "graph import"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "graph"; "import" |])
|
|
registry)
|
|
in
|
|
let import_input =
|
|
expect_some "import input option"
|
|
(option_by_name "--input" graph_import.options)
|
|
in
|
|
expect_bool "import input required" true import_input.required;
|
|
let list_page =
|
|
expect_some "list page"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "list"; "page" |])
|
|
registry)
|
|
in
|
|
let page_sort =
|
|
expect_some "page sort option"
|
|
(option_by_name "--sort" list_page.options)
|
|
in
|
|
expect_bool "page sort has title" true (Vec.mem "title" page_sort.choices);
|
|
let page_order =
|
|
expect_some "page order option"
|
|
(option_by_name "--order" list_page.options)
|
|
in
|
|
expect_string_vec "page order choices" [| "asc"; "desc" |]
|
|
page_order.choices;
|
|
let list_tag =
|
|
expect_some "list tag"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "list"; "tag" |])
|
|
registry)
|
|
in
|
|
let tag_fields =
|
|
expect_some "tag fields option"
|
|
(option_by_name "--fields" list_tag.options)
|
|
in
|
|
expect_bool "tag fields include title" true
|
|
(Vec.mem "title" tag_fields.choices);
|
|
expect_bool "tag fields include uuid" true
|
|
(Vec.mem "uuid" tag_fields.choices);
|
|
let list_task =
|
|
expect_some "list task"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "list"; "task" |])
|
|
registry)
|
|
in
|
|
expect_equal "list task human header order"
|
|
"id,title,status,priority,scheduled,deadline,created-at,updated-at"
|
|
(Vec.string_concat "," list_task.human_table_headers_order);
|
|
let show =
|
|
expect_some "show command"
|
|
(Command_registry.find_by_path (Vec.singleton "show") registry)
|
|
in
|
|
expect_bool "show page option" true
|
|
(Option.is_some (option_by_name "--page" show.options));
|
|
let upsert_block =
|
|
expect_some "upsert block"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "upsert"; "block" |])
|
|
registry)
|
|
in
|
|
let block_pos =
|
|
expect_some "block pos option"
|
|
(option_by_name "--pos" upsert_block.options)
|
|
in
|
|
expect_string_vec "block pos choices"
|
|
[| "first-child"; "last-child"; "sibling" |]
|
|
block_pos.choices;
|
|
let task =
|
|
expect_some "upsert task"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "upsert"; "task" |])
|
|
registry)
|
|
in
|
|
expect_bool "task status option" true
|
|
(Vec.exists
|
|
(fun (option : Command_registry.option_meta) ->
|
|
Vec.to_array option.names = [| "--status" |])
|
|
task.options);
|
|
expect_bool "task clear status option" true
|
|
(Vec.exists
|
|
(fun (option : Command_registry.option_meta) ->
|
|
Vec.to_array option.names = [| "--no-status" |])
|
|
task.options);
|
|
let property =
|
|
expect_some "upsert property"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "upsert"; "property" |])
|
|
registry)
|
|
in
|
|
expect_bool "property type choices" true
|
|
(Vec.exists
|
|
(fun (option : Command_registry.option_meta) ->
|
|
Vec.to_array option.names = [| "--type" |]
|
|
&& Vec.mem "default" option.choices
|
|
&& Vec.mem "checkbox" option.choices)
|
|
property.options);
|
|
let query =
|
|
expect_some "query command"
|
|
(Command_registry.find_by_path (Vec.singleton "query") registry)
|
|
in
|
|
let query_list =
|
|
expect_some "query list command"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "query"; "list" |])
|
|
registry)
|
|
in
|
|
expect_bool "query examples metadata" true
|
|
(not (Vec.is_empty query.examples));
|
|
expect_bool "query name option" true
|
|
(Option.is_some (option_by_name "--name" query.options));
|
|
expect_bool "query list examples metadata" true
|
|
(not (Vec.is_empty query_list.examples));
|
|
let search_block =
|
|
expect_some "search block"
|
|
(Command_registry.find_by_path
|
|
(Vec.of_array [| "search"; "block" |])
|
|
registry)
|
|
in
|
|
let search_content =
|
|
expect_some "search content option"
|
|
(option_by_name "--content" search_block.options)
|
|
in
|
|
expect_equal "search content doc" "Content search text" search_content.doc;
|
|
expect_equal "search block human header order" "id,ident,title"
|
|
(Vec.string_concat "," search_block.human_table_headers_order));
|
|
|
|
test "CLI parity command registry help renders command and option details"
|
|
(fun () ->
|
|
let registry = (Cli.make_app_context ()).Cli.registry in
|
|
let top_help = Command_registry.render_help registry in
|
|
expect_named_contains "top commands heading" top_help
|
|
"Available commands:";
|
|
expect_named_contains "skill show command" top_help "skill show";
|
|
expect_named_contains "completion command" top_help "completion";
|
|
let upsert_help =
|
|
Command_registry.render_help
|
|
~group:(Vec.of_array [| "upsert"; "task" |])
|
|
registry
|
|
in
|
|
expect_named_contains "task usage" upsert_help
|
|
"Usage: logseq upsert task [options]";
|
|
expect_named_contains "task status option" upsert_help "--status <status>";
|
|
expect_named_contains "task no status option" upsert_help "--no-status");
|
|
|
|
test "CLI parity skill install target resolves local global and missing home"
|
|
(fun () ->
|
|
let local =
|
|
expect_ok "local skill target"
|
|
(Skill.resolve_install_target ~global:false ~cwd:"/tmp/work"
|
|
~home_dir:(Some "/Users/demo"))
|
|
in
|
|
expect_equal "local scope" "local" (keyword_text local.scope);
|
|
expect_equal "local path" "/tmp/work/.agents/skills/logseq-cli/SKILL.md"
|
|
local.path;
|
|
expect_equal "local update command" "logseq skill install"
|
|
local.update_command;
|
|
let global =
|
|
expect_ok "global skill target"
|
|
(Skill.resolve_install_target ~global:true ~cwd:"/tmp/work"
|
|
~home_dir:(Some "/Users/demo"))
|
|
in
|
|
expect_equal "global scope" "global" (keyword_text global.scope);
|
|
expect_equal "global path"
|
|
"/Users/demo/.agents/skills/logseq-cli/SKILL.md" global.path;
|
|
expect_error_code "missing home" ":skill-home-dir-unavailable"
|
|
(Skill.resolve_install_target ~global:true ~cwd:"/tmp/work"
|
|
~home_dir:None));
|
|
|
|
test "CLI parity installed skill targets omit unavailable global target"
|
|
(fun () ->
|
|
let targets =
|
|
Skill.installed_skill_targets ~cwd:"/tmp/work"
|
|
~home_dir:(Some "/Users/demo")
|
|
in
|
|
expect_int "two targets" 2 (Vec.length targets);
|
|
expect_equal "local target" "/tmp/work/.agents/skills/logseq-cli/SKILL.md"
|
|
(Vec.nth targets 0).Skill.path;
|
|
expect_equal "global target"
|
|
"/Users/demo/.agents/skills/logseq-cli/SKILL.md"
|
|
(Vec.nth targets 1).path;
|
|
let local_only =
|
|
Skill.installed_skill_targets ~cwd:"/tmp/work" ~home_dir:None
|
|
in
|
|
expect_int "local only" 1 (Vec.length local_only);
|
|
expect_equal "local only scope" "local"
|
|
(keyword_text (Vec.peek_front local_only).scope));
|
|
|
|
test "CLI parity skill show and install read source and preserve neighbors"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-skill-" in
|
|
let source = Node.Path.join [| root; "source"; "SKILL.md" |] in
|
|
let destination_dir =
|
|
Node.Path.join [| root; "work"; ".agents"; "skills"; "logseq-cli" |]
|
|
in
|
|
let destination_file = Node.Path.join [| destination_dir; "SKILL.md" |] in
|
|
let neighbor =
|
|
Node.Path.join
|
|
[| root; "work"; ".agents"; "skills"; "other"; "SKILL.md" |]
|
|
in
|
|
try
|
|
mkdir_p (Node.Path.dirname source);
|
|
mkdir_p (Node.Path.dirname neighbor);
|
|
write_file source "# skill\nfrom source";
|
|
write_file neighbor "keep me";
|
|
let show =
|
|
effect_result "skill show"
|
|
(execute_with_output Skill.execute
|
|
(Skill.Skill_show { source_path = Some source })
|
|
(config ~root_dir:root ()) Output.Mode.Human)
|
|
in
|
|
expect_equal "show output" "# skill\nfrom source"
|
|
(Format_types.format_result show (config ~root_dir:root ()));
|
|
let install =
|
|
effect_result "skill install"
|
|
(execute_with_output Skill.execute
|
|
(Skill.Skill_install
|
|
{
|
|
global = false;
|
|
source_path = Some source;
|
|
destination_dir = Some destination_dir;
|
|
destination_file = Some destination_file;
|
|
})
|
|
(config ~root_dir:root ()) Output.Mode.Json)
|
|
in
|
|
let json_config =
|
|
config ~root_dir:root
|
|
~output_format:(Output.Mode.Packed Output.Mode.Json) ()
|
|
in
|
|
let output = Format_types.format_result install json_config in
|
|
expect_named_contains "installed path" output destination_file;
|
|
expect_equal "installed content" "# skill\nfrom source"
|
|
(read_file destination_file);
|
|
expect_equal "neighbor preserved" "keep me" (read_file neighbor);
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity example selector uses registry examples before defaults"
|
|
(fun () ->
|
|
let registry =
|
|
Command_registry.make
|
|
(Vec.of_array
|
|
[|
|
|
{
|
|
Command_registry.id = Command_id.Graph_list;
|
|
path = Vec.of_array [| "graph"; "list" |];
|
|
doc = "List graphs";
|
|
long_doc = None;
|
|
examples = Vec.singleton "custom graph list example";
|
|
options = Vec.empty;
|
|
category = Command_registry.Graph_management;
|
|
requires_graph = false;
|
|
requires_auth = false;
|
|
write_command = false;
|
|
human_table_headers_order = Vec.empty;
|
|
};
|
|
|])
|
|
in
|
|
let action =
|
|
expect_ok "registry graph examples"
|
|
(Example.resolve_selector registry (Vec.singleton "graph"))
|
|
in
|
|
expect_equal "registry example" "custom graph list example"
|
|
(Vec.peek_front action.examples);
|
|
let defaults =
|
|
expect_ok "default examples"
|
|
(Example.resolve_selector Command_registry.empty
|
|
(Vec.of_array [| "graph"; "list" |]))
|
|
in
|
|
expect_equal "default selector" "graph list" defaults.selector;
|
|
expect_named_contains "default graph list example"
|
|
(Vec.peek_front defaults.examples)
|
|
"logseq graph list");
|
|
|
|
test "CLI parity config update writes sanitized patch and removes null fields"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-config-update-" in
|
|
let cfg_path = Node.Path.join [| root; "cli.edn" |] in
|
|
try
|
|
write_file cfg_path
|
|
"{:graph \"old\" :ws-url \"wss://old.example/%s\" :auth-token \
|
|
\"secret\" :retries 2 :e2ee-password \"password\"}\n";
|
|
let resolved =
|
|
resolve_config (Global_opts.create ~config_path:cfg_path ())
|
|
in
|
|
ignore
|
|
(expect_ok "update config"
|
|
(effect_result "update config"
|
|
(Cli_config.update_config resolved
|
|
(Edn_util.map
|
|
[
|
|
(Edn_util.keyword "graph", Edn_util.string "new");
|
|
(Edn_util.keyword "ws-url", Edn_util.nil);
|
|
]))));
|
|
let parsed = edn_of_string (read_file cfg_path) in
|
|
expect_equal "updated graph" "new"
|
|
(expect_some "graph" (Edn_util.get_string parsed "graph"));
|
|
expect_none "removed ws-url" (Edn_util.get parsed "ws-url");
|
|
expect_none "sanitized auth-token" (Edn_util.get parsed "auth-token");
|
|
expect_none "sanitized retries" (Edn_util.get parsed "retries");
|
|
expect_none "sanitized e2ee-password"
|
|
(Edn_util.get parsed "e2ee-password");
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity agent name resolves config hostname and invalid blanks"
|
|
(fun () ->
|
|
let with_raw raw =
|
|
{ (config ()) with Cli_config.raw_file_config = Some raw }
|
|
in
|
|
expect_equal "configured agent" "bridge-a"
|
|
(expect_ok "configured agent"
|
|
(Agent.resolve_agent_name
|
|
(with_raw
|
|
(Edn_util.map
|
|
[
|
|
( Edn_util.keyword "agent-name",
|
|
Edn_util.string " bridge-a " );
|
|
]))
|
|
(Some "fallback-host")));
|
|
expect_equal "hostname fallback" "fallback-host"
|
|
(expect_ok "hostname fallback"
|
|
(Agent.resolve_agent_name (config ()) (Some "fallback-host")));
|
|
expect_error_code "blank configured agent" ":agent-name-invalid"
|
|
(Agent.resolve_agent_name
|
|
(with_raw
|
|
(Edn_util.map
|
|
[ (Edn_util.keyword "agent-name", Edn_util.string " ") ]))
|
|
(Some "fallback-host"));
|
|
let platform_hostname =
|
|
expect_ok "missing hostname falls back to platform hostname"
|
|
(Agent.resolve_agent_name (config ()) (Some ""))
|
|
in
|
|
expect_bool "platform hostname non-empty" true
|
|
(String.trim platform_hostname <> ""));
|
|
|
|
test "CLI parity agent task routing returns explicit non-routable reasons"
|
|
(fun () ->
|
|
(match
|
|
Agent.routable_task_decision (agent_task_entity ())
|
|
~agent_name:"build-host"
|
|
with
|
|
| Agent.Routable -> pass
|
|
| Not_routable reason ->
|
|
fail_test ("expected routable, got " ^ routable_reason_text reason));
|
|
let expect_reason name expected entity =
|
|
match Agent.routable_task_decision entity ~agent_name:"build-host" with
|
|
| Agent.Not_routable reason ->
|
|
expect_equal name expected (routable_reason_text reason)
|
|
| Routable -> fail_test (name ^ ": expected non-routable")
|
|
in
|
|
expect_reason "missing uuid" "missing-stable-uuid"
|
|
(agent_task_entity ~uuid:None ());
|
|
expect_reason "missing task tag" "missing-task-tag"
|
|
(agent_task_entity ~tags:[||] ());
|
|
expect_reason "done status" "not-todo"
|
|
(agent_task_entity ~status:(Some "done") ());
|
|
expect_reason "assignee mismatch" "assignee-mismatch"
|
|
(agent_task_entity ~assignees:[| "other-host" |] ());
|
|
expect_reason "already routed" "already-routed"
|
|
(agent_task_entity ~session_id:"codex-1" ()));
|
|
|
|
test "CLI parity agent prompt template validates required and unknown vars"
|
|
(fun () ->
|
|
let template body =
|
|
{
|
|
Agent.kind = Agent.Task;
|
|
body;
|
|
required_vars = Vec.of_array [| "graph"; "task-block-tree" |];
|
|
allowed_vars =
|
|
Vec.of_array [| "graph"; "agent-name"; "task-block-tree" |];
|
|
}
|
|
in
|
|
ignore
|
|
(expect_ok "valid template"
|
|
(Agent.validate_prompt_template
|
|
(template "{{graph}}\n{{task-block-tree}}\n{{agent-name}}")));
|
|
expect_error_code "blank template" ":missing-template-code-block"
|
|
(Agent.validate_prompt_template (template " "));
|
|
expect_error_code "unknown var" ":unknown-template-vars"
|
|
(Agent.validate_prompt_template
|
|
(template "{{graph}}\n{{task-block-tree}}\n{{other}}"));
|
|
expect_error_code "missing var" ":missing-template-vars"
|
|
(Agent.validate_prompt_template (template "{{graph}}"));
|
|
let documented_template =
|
|
template "{{graph}}\n{{task-block-tree}}\n'{{documented-only}}'"
|
|
in
|
|
ignore
|
|
(expect_ok "quoted docs var ignored"
|
|
(Agent.validate_prompt_template documented_template)));
|
|
|
|
test "CLI parity parse covers additional command option surfaces" (fun () ->
|
|
let list_node =
|
|
expect_parse_ok "list node"
|
|
[|
|
|
"list";
|
|
"node";
|
|
"--tags";
|
|
"project,work";
|
|
"--properties";
|
|
"owner,status";
|
|
"--sort";
|
|
"updated-at";
|
|
|]
|
|
in
|
|
(match list_node.command with
|
|
| Cli_request.List (List_command.Parsed_node opts) ->
|
|
expect_int "node tags" 2 (Vec.length opts.tags);
|
|
expect_int "node properties" 2 (Vec.length opts.properties);
|
|
expect_equal "node sort" "updated-at"
|
|
(expect_some "node sort" opts.common.sort)
|
|
| _ -> fail_test "expected list node");
|
|
let query_run =
|
|
expect_parse_ok "query run"
|
|
[|
|
|
"query";
|
|
"--query";
|
|
"[:find ?e :in $ ?title :where [?e :block/title ?title]]";
|
|
"--inputs";
|
|
"[\"Hello\"]";
|
|
"--graph";
|
|
"demo";
|
|
"--output";
|
|
"json";
|
|
|]
|
|
in
|
|
(match query_run.command with
|
|
| Cli_request.Query
|
|
(Query.Parsed_run
|
|
{ query_edn = Some query; inputs_edn = Some inputs; name = None })
|
|
-> (
|
|
expect_equal "query parse text"
|
|
"[:find ?e :in $ ?title :where [?e :block/title ?title]]" query;
|
|
expect_equal "query parse inputs" "[\"Hello\"]" inputs;
|
|
match query_run.globals.output_format with
|
|
| Some (Output.Mode.Packed Output.Mode.Json) -> pass
|
|
| _ -> fail_test "expected json output mode")
|
|
| _ -> fail_test "expected query run");
|
|
let query_list = expect_parse_ok "query list" [| "query"; "list" |] in
|
|
(match query_list.command with
|
|
| Cli_request.Query Query.Parsed_list -> pass
|
|
| _ -> fail_test "expected query list");
|
|
let task =
|
|
expect_parse_ok "upsert task"
|
|
[|
|
|
"upsert";
|
|
"task";
|
|
"--page";
|
|
"Inbox";
|
|
"--content";
|
|
"Ship release";
|
|
"--status";
|
|
"todo";
|
|
"--priority";
|
|
"high";
|
|
"--no-deadline";
|
|
|]
|
|
in
|
|
(match task.command with
|
|
| Cli_request.Upsert (Upsert.Parsed_task opts) ->
|
|
expect_equal "task page" "Inbox" (expect_some "page" opts.page);
|
|
expect_equal "task content" "Ship release"
|
|
(expect_some "content" opts.content);
|
|
expect_equal "task status" "todo" (expect_some "status" opts.status);
|
|
expect_bool "task no deadline" true opts.no_deadline
|
|
| _ -> fail_test "expected upsert task");
|
|
let property =
|
|
expect_parse_ok "upsert property"
|
|
[|
|
|
"upsert";
|
|
"property";
|
|
"--name";
|
|
"status";
|
|
"--type";
|
|
"default";
|
|
"--cardinality";
|
|
"many";
|
|
"--hide";
|
|
"false";
|
|
"--public";
|
|
"true";
|
|
|]
|
|
in
|
|
(match property.command with
|
|
| Cli_request.Upsert (Upsert.Parsed_property opts) ->
|
|
expect_equal "property name" "status" (expect_some "name" opts.name);
|
|
expect_bool "property kind" true (opts.kind = Some Property.Default);
|
|
expect_bool "property cardinality" true
|
|
(opts.cardinality = Some Property.Many);
|
|
expect_bool "hide false" false (expect_some "hide" opts.hide);
|
|
expect_bool "public true" true (expect_some "public" opts.public)
|
|
| _ -> fail_test "expected upsert property");
|
|
let tag =
|
|
expect_parse_ok "upsert tag schema properties"
|
|
[|
|
|
"upsert";
|
|
"tag";
|
|
"--name";
|
|
"project";
|
|
"--add-properties";
|
|
"[\"status\"]";
|
|
"--remove-properties";
|
|
"[:user.property/owner]";
|
|
|]
|
|
in
|
|
(match tag.command with
|
|
| Cli_request.Upsert (Upsert.Parsed_tag opts) ->
|
|
expect_equal "tag name" "project" (expect_some "name" opts.name);
|
|
expect_equal "add properties" "[\"status\"]"
|
|
(expect_some "add-properties" opts.add_properties_edn);
|
|
expect_equal "remove properties" "[:user.property/owner]"
|
|
(expect_some "remove-properties" opts.remove_properties_edn)
|
|
| _ -> fail_test "expected upsert tag");
|
|
let sync_download =
|
|
expect_parse_ok "sync download"
|
|
[| "sync"; "download"; "--progress"; "--e2ee-password"; "secret" |]
|
|
in
|
|
(match sync_download.command with
|
|
| Cli_request.Sync (Sync.Parsed_download opts) ->
|
|
expect_bool "progress" true (expect_some "progress" opts.progress);
|
|
expect_equal "download password" "secret"
|
|
(expect_some "password" opts.e2ee_password)
|
|
| _ -> fail_test "expected sync download");
|
|
let sync_asset =
|
|
expect_parse_ok "sync asset"
|
|
[|
|
|
"sync";
|
|
"asset";
|
|
"download";
|
|
"--uuid";
|
|
"00000000-0000-4000-8000-000000000001";
|
|
|]
|
|
in
|
|
(match sync_asset.command with
|
|
| Cli_request.Sync (Sync.Parsed_asset_download opts) ->
|
|
expect_equal "asset uuid" "00000000-0000-4000-8000-000000000001"
|
|
(expect_some "asset uuid" opts.uuid)
|
|
| _ -> fail_test "expected sync asset download");
|
|
let grant =
|
|
expect_parse_ok "sync grant"
|
|
[|
|
|
"sync";
|
|
"grant-access";
|
|
"--graph-id";
|
|
"00000000-0000-4000-8000-000000000001";
|
|
"--email";
|
|
"user@example.com";
|
|
|]
|
|
in
|
|
(match grant.command with
|
|
| Cli_request.Sync (Sync.Parsed_grant_access opts) ->
|
|
expect_equal "grant graph id" "00000000-0000-4000-8000-000000000001"
|
|
(expect_some "graph id" opts.graph_id);
|
|
expect_equal "grant email" "user@example.com"
|
|
(expect_some "email" opts.email)
|
|
| _ -> fail_test "expected sync grant access");
|
|
let graph_create =
|
|
expect_parse_ok "graph create sync"
|
|
[| "graph"; "create"; "--enable-sync"; "--e2ee-password"; "secret" |]
|
|
in
|
|
(match graph_create.command with
|
|
| Cli_request.Graph (Graph.Parsed_create opts) ->
|
|
expect_bool "enable sync" true opts.enable_sync;
|
|
expect_equal "graph password" "secret"
|
|
(expect_some "graph password" opts.e2ee_password)
|
|
| _ -> fail_test "expected graph create");
|
|
expect_parse_error_code "unknown agent subcommand" ":unknown-command"
|
|
[| "agent"; "bridge"; "list" |];
|
|
expect_parse_error_code "unknown option" ":invalid-options"
|
|
[| "server"; "cleanup"; "--graph"; "demo"; "--unknown"; "x" |]);
|
|
|
|
test "CLI parity transport reads and writes edn sqlite and db files"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-parity-transport-io-" in
|
|
let edn_path = Node.Path.join [| root; "data.edn" |] in
|
|
let edn_utf8_path = Node.Path.join [| root; "utf8.edn" |] in
|
|
let edn_bytes_path = Node.Path.join [| root; "bytes.edn" |] in
|
|
let sqlite_path = Node.Path.join [| root; "graph.sqlite" |] in
|
|
let db_path = Node.Path.join [| root; "graph.db" |] in
|
|
let title = unicode_text [| 0x4e2d; 0x6587; 0x6807; 0x9898 |] in
|
|
let imported_title = unicode_text [| 0x5bfc; 0x5165; 0x4e2d; 0x6587 |] in
|
|
try
|
|
ignore
|
|
(expect_ok "write edn"
|
|
(effect_result "write edn"
|
|
(Transport.write_output ~format:(Edn_util.keyword_t "edn")
|
|
~path:edn_path
|
|
~data:
|
|
(Edn_util.map
|
|
[
|
|
(Edn_util.keyword "title", Edn_util.string "中文标题");
|
|
(Edn_util.keyword "count", Edn_util.int 2);
|
|
]))));
|
|
expect_named_contains "edn file preserves utf8" (read_file edn_path)
|
|
title;
|
|
let edn_value =
|
|
expect_ok "read edn"
|
|
(effect_result "read edn"
|
|
(Transport.read_input ~format:(Edn_util.keyword_t "edn")
|
|
~path:edn_path))
|
|
in
|
|
expect_equal "edn title" title
|
|
(expect_some "title" (Edn_util.get_string edn_value "title"));
|
|
write_file edn_utf8_path ("{:title \"" ^ imported_title ^ "\"}");
|
|
let edn_utf8_value =
|
|
expect_ok "read utf8 edn"
|
|
(effect_result "read utf8 edn"
|
|
(Transport.read_input ~format:(Edn_util.keyword_t "edn")
|
|
~path:edn_utf8_path))
|
|
in
|
|
expect_equal "utf8 edn title" imported_title
|
|
(expect_some "utf8 title"
|
|
(Edn_util.get_string edn_utf8_value "title"));
|
|
ignore
|
|
(expect_ok "write bytes edn"
|
|
(effect_result "write bytes edn"
|
|
(Transport.write_output ~format:(Edn_util.keyword_t "edn")
|
|
~path:edn_bytes_path
|
|
~data:
|
|
(Edn_util.map
|
|
[
|
|
( Edn_util.keyword "payload",
|
|
Edn_util.bytes (Bytes.of_string "payload") );
|
|
]))));
|
|
expect_named_contains "edn bytes use transit tag"
|
|
(read_file edn_bytes_path) "#transit/bytes";
|
|
ignore
|
|
(expect_ok "write sqlite"
|
|
(effect_result "write sqlite"
|
|
(Transport.write_output
|
|
~format:(Edn_util.keyword_t "sqlite")
|
|
~path:sqlite_path
|
|
~data:(Edn_util.string "sqlite-bytes"))));
|
|
let sqlite_value =
|
|
expect_ok "read sqlite"
|
|
(effect_result "read sqlite"
|
|
(Transport.read_input
|
|
~format:(Edn_util.keyword_t "sqlite")
|
|
~path:sqlite_path))
|
|
in
|
|
expect_equal "sqlite bytes" "sqlite-bytes"
|
|
(Bytes.to_string
|
|
(expect_some "sqlite bytes" (Edn_util.as_bytes sqlite_value)));
|
|
expect_named_contains "read sqlite uses transit bytes tag"
|
|
(Melange_edn_melange.to_edn_string sqlite_value)
|
|
"#transit/bytes";
|
|
ignore
|
|
(expect_ok "write db"
|
|
(effect_result "write db"
|
|
(Transport.write_output ~format:(Edn_util.keyword_t "db")
|
|
~path:db_path
|
|
~data:(Edn_util.bytes (Bytes.of_string "db")))));
|
|
let db_value =
|
|
expect_ok "read db"
|
|
(effect_result "read db"
|
|
(Transport.read_input ~format:(Edn_util.keyword_t "db")
|
|
~path:db_path))
|
|
in
|
|
expect_equal "db bytes" "db"
|
|
(Bytes.to_string
|
|
(expect_some "db bytes" (Edn_util.as_bytes db_value)));
|
|
expect_named_contains "read db uses transit bytes tag"
|
|
(Melange_edn_melange.to_edn_string db_value)
|
|
"#transit/bytes";
|
|
expect_error_code "bad write format" ":unsupported-output-format"
|
|
(effect_result "bad write format"
|
|
(Transport.write_output
|
|
~format:(Edn_util.keyword_t "json")
|
|
~path:(Node.Path.join [| root; "data.json" |])
|
|
~data:(Edn_util.string "nope")));
|
|
expect_error_code "bad read format" ":unsupported-input-format"
|
|
(effect_result "bad read format"
|
|
(Transport.read_input
|
|
~format:(Edn_util.keyword_t "json")
|
|
~path:edn_path));
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test_promise
|
|
"CLI parity transport thread-api invoke sends transit args and decodes \
|
|
resultTransit" (fun () ->
|
|
let request_count = ref 0 in
|
|
let large_int = 1_773_666_723_828L in
|
|
let server =
|
|
invoke_server (fun body ->
|
|
incr request_count;
|
|
expect_named_contains "invoke method" body "thread-api/q";
|
|
expect_named_contains "invoke repo" body "logseq_db_alpha";
|
|
expect_named_contains "invoke args transit field" body "argsTransit";
|
|
let args =
|
|
expect_some "invoke args" (Edn_util.as_seq (invoke_args body))
|
|
in
|
|
let query =
|
|
expect_some "invoke query" (Edn_util.as_seq (Vec.nth args 1))
|
|
in
|
|
expect_int64 "invoke large int" large_int
|
|
(expect_some "invoke large int value"
|
|
(Edn_util.as_int64 (Vec.nth query 5)));
|
|
(match Vec.nth query 6 with
|
|
| Melange_edn_melange.Any (Melange_edn_melange.Bigint value) ->
|
|
expect_equal "invoke bigint" "900719925474099312345" value
|
|
| _ -> fail_test "invoke bigint: expected Bigint");
|
|
(match Vec.nth query 7 with
|
|
| Melange_edn_melange.Any (Melange_edn_melange.Decimal value) ->
|
|
expect_equal "invoke decimal" "1234567890.123456789" value
|
|
| _ -> fail_test "invoke decimal: expected Decimal");
|
|
"\"ok\"")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let invoke_config =
|
|
{
|
|
Transport.base_url;
|
|
timeout_span = Time.span_of_ms 1_000L;
|
|
profile_session = None;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(Transport.thread_api_q invoke_config
|
|
~repo:(Cli_primitive.create_repo "logseq_db_alpha")
|
|
~query:
|
|
(Edn_util.vector_t
|
|
[
|
|
Edn_util.keyword "find";
|
|
Edn_util.symbol "?title";
|
|
Edn_util.keyword "where";
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.symbol "?b";
|
|
Edn_util.keyword "block/title";
|
|
Edn_util.symbol "?title";
|
|
];
|
|
Edn_util.keyword "created-at";
|
|
Edn_util.int64 large_int;
|
|
Edn_util.any
|
|
(Melange_edn_melange.bigint "900719925474099312345");
|
|
Edn_util.any
|
|
(Melange_edn_melange.decimal "1234567890.123456789");
|
|
]))
|
|
in
|
|
expect_equal "decoded invoke result" "ok"
|
|
(expect_some "invoke result string" (Edn_util.as_string result));
|
|
expect_int "one invoke request" 1 !request_count;
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise
|
|
"CLI parity transport keeps prefixed symbol-looking strings as strings"
|
|
(fun () ->
|
|
let server =
|
|
invoke_server (fun body ->
|
|
let args =
|
|
expect_some "invoke args" (Edn_util.as_seq (invoke_args body))
|
|
in
|
|
let query =
|
|
expect_some "invoke query" (Edn_util.as_seq (Vec.nth args 1))
|
|
in
|
|
expect_equal "string stays string" "~$?title"
|
|
(expect_some "string value"
|
|
(Edn_util.as_string (Vec.nth query 1)));
|
|
"\"ok\"")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let invoke_config =
|
|
{
|
|
Transport.base_url;
|
|
timeout_span = Time.span_of_ms 1_000L;
|
|
profile_session = None;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(Transport.thread_api_q invoke_config
|
|
~repo:(Cli_primitive.create_repo "logseq_db_alpha")
|
|
~query:
|
|
(Edn_util.vector_t
|
|
[ Edn_util.keyword "find"; Edn_util.string "~$?title" ]))
|
|
in
|
|
expect_equal "decoded invoke result" "ok"
|
|
(expect_some "invoke result string" (Edn_util.as_string result));
|
|
Js.Promise.resolve pass));
|
|
|
|
test_promise
|
|
"CLI parity transport thread-api invoke decodes cached keyword vectors"
|
|
(fun () ->
|
|
let server =
|
|
invoke_server (fun body ->
|
|
expect_named_contains "invoke method" body "thread-api/q";
|
|
"[\"~:block/uuid\",[\"^0\",\"x\"]]")
|
|
in
|
|
with_server server (fun base_url ->
|
|
let invoke_config =
|
|
{
|
|
Transport.base_url;
|
|
timeout_span = Time.span_of_ms 1_000L;
|
|
profile_session = None;
|
|
}
|
|
in
|
|
let* result =
|
|
effect_to_promise
|
|
(Transport.thread_api_q invoke_config
|
|
~repo:(Cli_primitive.create_repo "logseq_db_alpha")
|
|
~query:
|
|
(Edn_util.vector_t_vec
|
|
(Vec.singleton (Edn_util.keyword "find"))))
|
|
in
|
|
match Edn_util.as_seq result with
|
|
| Some values when Vec.length values = 2 -> (
|
|
let key = Vec.nth values 0 in
|
|
let nested = Vec.nth values 1 in
|
|
expect_equal "decoded key" "block/uuid"
|
|
(expect_some "keyword" (Edn_util.as_keyword key));
|
|
match Edn_util.as_seq nested with
|
|
| Some nested_values when Vec.length nested_values = 2 ->
|
|
let nested_key = Vec.nth nested_values 0 in
|
|
let value = Vec.nth nested_values 1 in
|
|
expect_equal "decoded nested key" "block/uuid"
|
|
(expect_some "nested keyword"
|
|
(Edn_util.as_keyword nested_key));
|
|
expect_equal "decoded nested value" "x"
|
|
(expect_some "nested value" (Edn_util.as_string value));
|
|
Js.Promise.resolve pass
|
|
| _ -> fail_promise "expected nested vector")
|
|
| _ -> fail_promise "expected decoded vector"));
|
|
|
|
test_promise
|
|
"CLI parity transport connect-events decodes rtc-log and closes \
|
|
subscription" (fun () ->
|
|
let received = ref Vec.empty in
|
|
let closed = ref false in
|
|
let server =
|
|
create_server (fun[@u] req res ->
|
|
if req_method req = "GET" && req_url req = "/v1/events" then (
|
|
res_write_head res 200
|
|
(Js.Dict.fromArray
|
|
[|
|
|
("Content-Type", "text/event-stream");
|
|
("Cache-Control", "no-cache");
|
|
("Connection", "keep-alive");
|
|
|]);
|
|
res_write res
|
|
"data: {\"payload\":\"[\\\"~:rtc-log\\\",[\\\"^ \
|
|
\\\",\\\"~:type\\\",\\\"~:rtc.log/download\\\",\\\"~:graph-uuid\\\",\\\"~u00000000-0000-4000-8000-000000000001\\\",\\\"~:message\\\",\\\"downloaded \
|
|
1 block\\\"]]\"}\n\n";
|
|
req_on_end req "close" (fun[@u] () -> closed := true))
|
|
else write_json res 404 (error_response "not found"))
|
|
in
|
|
with_server server (fun base_url ->
|
|
let invoke_config =
|
|
{
|
|
Transport.base_url;
|
|
timeout_span = Time.span_of_ms 1_000L;
|
|
profile_session = None;
|
|
}
|
|
in
|
|
let* subscription =
|
|
effect_to_promise
|
|
(Transport.connect_events invoke_config (fun event_type payload ->
|
|
received :=
|
|
Vec.push_front !received
|
|
(event_type, Melange_edn_melange.to_edn_string payload);
|
|
Cli_effect.pure ()))
|
|
in
|
|
let* () = sleep_ms 50 in
|
|
let* () = effect_to_promise (subscription.Transport.close ()) in
|
|
let* () = sleep_ms 50 in
|
|
let event_type, payload =
|
|
match Vec.peek_back_opt !received with
|
|
| Some event -> event
|
|
| None ->
|
|
fail_test "received event: expected Some value";
|
|
assert false
|
|
in
|
|
expect_equal "event type" "rtc-log"
|
|
(Edn_util.keyword_to_string event_type);
|
|
expect_named_contains "event payload" payload "downloaded 1 block";
|
|
expect_bool "subscription closed" true !closed;
|
|
Js.Promise.resolve pass));
|
|
|
|
test "CLI parity server lock paths use canonical graph directory names"
|
|
(fun () ->
|
|
expect_equal "plain lock path"
|
|
"/tmp/logseq-root/graphs/demo/db-worker.lock"
|
|
(Server_runtime.lock_path ~root_dir:"/tmp/logseq-root"
|
|
(Cli_primitive.create_repo "logseq_db_demo"));
|
|
expect_equal "encoded lock path"
|
|
"/tmp/logseq-root/graphs/foo~2Fbar/db-worker.lock"
|
|
(Server_runtime.lock_path ~root_dir:"/tmp/logseq-root"
|
|
(Cli_primitive.create_repo "logseq_db_foo/bar")));
|
|
|
|
test_promise
|
|
"CLI parity server start launches db-worker-node with parent executable"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-server-parent-exec-" in
|
|
let worker_script = Node.Path.join [| root; "db-worker-node.js" |] in
|
|
let graphs_dir = Node.Path.join [| root; "graphs" |] in
|
|
let graph_dir = Node.Path.join [| graphs_dir; "demo" |] in
|
|
let lock_path = Node.Path.join [| graph_dir; "db-worker.lock" |] in
|
|
let server_list_path = Node.Path.join [| root; "server-list" |] in
|
|
let server =
|
|
create_server (fun[@u] req res ->
|
|
if req_method req = "GET" && req_url req = "/healthz" then
|
|
write_json res 200
|
|
(Printf.sprintf
|
|
"{\"repo\":\"logseq_db_demo\",\"status\":\"ready\",\"host\":\"127.0.0.1\",\"pid\":%d,\"owner-source\":\"cli\",\"root-dir\":%S,\"revision\":\"test-revision\"}"
|
|
(Cli_unix.getpid ()) root)
|
|
else write_json res 404 (error_response "not found"))
|
|
in
|
|
try
|
|
mkdir_p graph_dir;
|
|
write_file worker_script "console.log('db-worker');\n";
|
|
start_spawn_capture ();
|
|
set_env "LOGSEQ_DB_WORKER_NODE_SCRIPT" worker_script;
|
|
Js.Promise.make (fun ~resolve ~reject ->
|
|
server_listen server 0 "127.0.0.1" (fun[@u] () ->
|
|
let port = (server_address server)##port in
|
|
set_spawn_capture_on_spawn ~lock_path ~server_list_path ~port;
|
|
let config = config ~root_dir:root ~repo:"demo" () in
|
|
let finish_ok () =
|
|
server_close server (fun[@u] () -> (resolve pass [@u]))
|
|
in
|
|
let finish_error message =
|
|
server_close server (fun[@u] () ->
|
|
(reject (Failure message) [@u]))
|
|
in
|
|
Cli_effect.on_any
|
|
(Server_runtime.start_server config
|
|
(Cli_primitive.create_repo "logseq_db_demo")
|
|
~create_empty_db:false)
|
|
(fun result ->
|
|
let calls = spawn_capture_calls () in
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
match result with
|
|
| Error err ->
|
|
finish_error
|
|
("server start failed: " ^ err.Error.message)
|
|
| Ok _ -> (
|
|
let expected_command = Node.Process.argv.(0) in
|
|
try
|
|
expect_named_contains "spawn command" calls
|
|
("\"command\":\"" ^ expected_command ^ "\"");
|
|
expect_named_contains "spawn worker arg" calls
|
|
worker_script;
|
|
finish_ok ()
|
|
with exn -> finish_error (Printexc.to_string exn)))
|
|
(fun exn ->
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
finish_error (Printexc.to_string exn))))
|
|
with exn ->
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
server_close server (fun[@u] () -> ());
|
|
fail_promise (Printexc.to_string exn));
|
|
|
|
test_promise "CLI parity server start reuses starting db-worker-node"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-server-starting-existing-" in
|
|
let worker_script = Node.Path.join [| root; "db-worker-node.js" |] in
|
|
let graphs_dir = Node.Path.join [| root; "graphs" |] in
|
|
let graph_dir = Node.Path.join [| graphs_dir; "demo" |] in
|
|
let lock_path = Node.Path.join [| graph_dir; "db-worker.lock" |] in
|
|
let server_list_path = Node.Path.join [| root; "server-list" |] in
|
|
let health_calls = ref 0 in
|
|
let server =
|
|
create_server (fun[@u] req res ->
|
|
if req_method req = "GET" && req_url req = "/healthz" then (
|
|
incr health_calls;
|
|
let status_code, status =
|
|
if !health_calls = 1 then (503, "starting") else (200, "ready")
|
|
in
|
|
write_json res status_code
|
|
(Printf.sprintf
|
|
"{\"repo\":\"logseq_db_demo\",\"status\":%S,\"host\":\"127.0.0.1\",\"pid\":%d,\"owner-source\":\"cli\",\"root-dir\":%S,\"revision\":\"test-revision\"}"
|
|
status (Cli_unix.getpid ()) root))
|
|
else write_json res 404 (error_response "not found"))
|
|
in
|
|
try
|
|
mkdir_p graph_dir;
|
|
write_file worker_script "console.log('db-worker');\n";
|
|
write_file lock_path
|
|
(Printf.sprintf
|
|
"{\"repo\":\"logseq_db_demo\",\"pid\":%d,\"lock-id\":\"test\",\"owner-source\":\"cli\"}"
|
|
(Cli_unix.getpid ()));
|
|
start_spawn_capture ();
|
|
set_env "LOGSEQ_DB_WORKER_NODE_SCRIPT" worker_script;
|
|
Js.Promise.make (fun ~resolve ~reject ->
|
|
server_listen server 0 "127.0.0.1" (fun[@u] () ->
|
|
let port = (server_address server)##port in
|
|
write_file server_list_path
|
|
(string_of_int (Cli_unix.getpid ())
|
|
^ " " ^ string_of_int port ^ "\n");
|
|
let config = config ~root_dir:root ~repo:"demo" () in
|
|
let finish_ok () =
|
|
server_close server (fun[@u] () -> (resolve pass [@u]))
|
|
in
|
|
let finish_error message =
|
|
server_close server (fun[@u] () ->
|
|
(reject (Failure message) [@u]))
|
|
in
|
|
Cli_effect.on_any
|
|
(Server_runtime.start_server config
|
|
(Cli_primitive.create_repo "logseq_db_demo")
|
|
~create_empty_db:false)
|
|
(fun result ->
|
|
let calls = spawn_capture_calls () in
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
match result with
|
|
| Error err ->
|
|
finish_error
|
|
("server start failed: " ^ err.Error.message)
|
|
| Ok _ -> (
|
|
try
|
|
expect_equal "spawn calls" "[]" calls;
|
|
expect_bool "health calls include ready retry" true
|
|
(!health_calls >= 2);
|
|
finish_ok ()
|
|
with exn -> finish_error (Printexc.to_string exn)))
|
|
(fun exn ->
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
finish_error (Printexc.to_string exn))))
|
|
with exn ->
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
server_close server (fun[@u] () -> ());
|
|
fail_promise (Printexc.to_string exn));
|
|
|
|
test_promise "CLI parity ensure server retries final health discovery"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-ensure-final-health-" in
|
|
let worker_script = Node.Path.join [| root; "db-worker-node.js" |] in
|
|
let graphs_dir = Node.Path.join [| root; "graphs" |] in
|
|
let graph_dir = Node.Path.join [| graphs_dir; "demo" |] in
|
|
let lock_path = Node.Path.join [| graph_dir; "db-worker.lock" |] in
|
|
let server_list_path = Node.Path.join [| root; "server-list" |] in
|
|
let health_calls = ref 0 in
|
|
let server =
|
|
create_server (fun[@u] req res ->
|
|
if req_method req = "GET" && req_url req = "/healthz" then (
|
|
incr health_calls;
|
|
match !health_calls with
|
|
| 1 ->
|
|
write_json res 503
|
|
(Printf.sprintf
|
|
"{\"repo\":\"logseq_db_demo\",\"status\":\"starting\",\"host\":\"127.0.0.1\",\"pid\":%d,\"owner-source\":\"cli\",\"root-dir\":%S,\"revision\":\"test-revision\"}"
|
|
(Cli_unix.getpid ()) root)
|
|
| 3 -> write_json res 500 (error_response "busy")
|
|
| _ ->
|
|
write_json res 200
|
|
(Printf.sprintf
|
|
"{\"repo\":\"logseq_db_demo\",\"status\":\"ready\",\"host\":\"127.0.0.1\",\"pid\":%d,\"owner-source\":\"cli\",\"root-dir\":%S,\"revision\":\"test-revision\"}"
|
|
(Cli_unix.getpid ()) root))
|
|
else write_json res 404 (error_response "not found"))
|
|
in
|
|
try
|
|
mkdir_p graph_dir;
|
|
write_file worker_script "console.log('db-worker');\n";
|
|
start_spawn_capture ();
|
|
set_env "LOGSEQ_DB_WORKER_NODE_SCRIPT" worker_script;
|
|
Js.Promise.make (fun ~resolve ~reject ->
|
|
server_listen server 0 "127.0.0.1" (fun[@u] () ->
|
|
let port = (server_address server)##port in
|
|
set_spawn_capture_on_spawn ~lock_path ~server_list_path ~port;
|
|
let config = config ~root_dir:root ~repo:"demo" () in
|
|
let finish_ok () =
|
|
server_close server (fun[@u] () -> (resolve pass [@u]))
|
|
in
|
|
let finish_error message =
|
|
server_close server (fun[@u] () ->
|
|
(reject (Failure message) [@u]))
|
|
in
|
|
Cli_effect.on_any
|
|
(Server_runtime.ensure_server config
|
|
(Cli_primitive.create_repo "logseq_db_demo")
|
|
~create_empty_db:false)
|
|
(fun result ->
|
|
let calls = spawn_capture_calls () in
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
match result with
|
|
| Error err ->
|
|
finish_error
|
|
("ensure server failed: " ^ err.Error.message)
|
|
| Ok _ -> (
|
|
try
|
|
expect_named_contains "spawned worker" calls
|
|
worker_script;
|
|
expect_bool "final health retried" true
|
|
(!health_calls >= 4);
|
|
finish_ok ()
|
|
with exn -> finish_error (Printexc.to_string exn)))
|
|
(fun exn ->
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
finish_error (Printexc.to_string exn))))
|
|
with exn ->
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
server_close server (fun[@u] () -> ());
|
|
fail_promise (Printexc.to_string exn));
|
|
|
|
test_promise
|
|
"CLI parity server start orphan timeout reports db-worker-node command"
|
|
(fun () ->
|
|
let root = temp_dir "logseq-cli-server-orphan-command-" in
|
|
let worker_script = Node.Path.join [| root; "db-worker-node.js" |] in
|
|
let graphs_dir = Node.Path.join [| root; "graphs" |] in
|
|
let graph_dir = Node.Path.join [| graphs_dir; "demo" |] in
|
|
try
|
|
mkdir_p graph_dir;
|
|
write_file worker_script "console.log('db-worker');\n";
|
|
start_spawn_capture ();
|
|
set_env "LOGSEQ_DB_WORKER_NODE_SCRIPT" worker_script;
|
|
let config = config ~root_dir:root ~repo:"demo" () in
|
|
effect_to_promise
|
|
(Server_runtime.start_server config
|
|
(Cli_primitive.create_repo "logseq_db_demo")
|
|
~create_empty_db:false)
|
|
|> Js.Promise.then_ (fun result ->
|
|
let calls = spawn_capture_calls () in
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
match result with
|
|
| Ok _ -> fail_promise "expected orphan timeout"
|
|
| Error err ->
|
|
expect_equal "orphan error code" "server-start-timeout-orphan"
|
|
(Error.code_to_string err.Error.code);
|
|
expect_named_contains "orphan command executable"
|
|
err.Error.message Node.Process.argv.(0);
|
|
expect_named_contains "orphan command worker" err.Error.message
|
|
worker_script;
|
|
expect_named_contains "orphan command repo" err.Error.message
|
|
"--repo logseq_db_demo";
|
|
expect_named_contains "orphan command root" err.Error.message
|
|
("--root-dir " ^ root);
|
|
expect_named_contains "orphan command owner" err.Error.message
|
|
"--owner-source cli";
|
|
expect_named_contains "spawn was attempted" calls worker_script;
|
|
Js.Promise.resolve pass)
|
|
with exn ->
|
|
stop_spawn_capture ();
|
|
unset_env "LOGSEQ_DB_WORKER_NODE_SCRIPT";
|
|
remove_tree root;
|
|
fail_promise (Printexc.to_string exn));
|
|
|
|
test "CLI parity server command build keeps cleanup repo-free contract"
|
|
(fun () ->
|
|
(match
|
|
Server_command.build (config ()) (Global_opts.create ())
|
|
Server_command.Parsed_list
|
|
with
|
|
| Ok Server_command.Server_list -> pass
|
|
| Ok _ -> fail_test "server list: expected list action"
|
|
| Error err -> fail_test ("server list: " ^ err.Error.message));
|
|
(match
|
|
Server_command.build (config ()) (Global_opts.create ())
|
|
Server_command.Parsed_cleanup
|
|
with
|
|
| Ok Server_command.Server_cleanup -> pass
|
|
| Ok _ -> fail_test "server cleanup: expected cleanup action"
|
|
| Error err -> fail_test ("server cleanup: " ^ err.Error.message));
|
|
expect_error_code "server start requires repo" "missing-repo"
|
|
(Server_command.build (config ()) (Global_opts.create ())
|
|
Server_command.Parsed_start);
|
|
expect_error_code "server stop requires repo" "missing-repo"
|
|
(Server_command.build (config ()) (Global_opts.create ())
|
|
Server_command.Parsed_stop);
|
|
expect_error_code "server restart requires repo" "missing-repo"
|
|
(Server_command.build (config ()) (Global_opts.create ())
|
|
Server_command.Parsed_restart);
|
|
(match
|
|
Server_command.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
Server_command.Parsed_start
|
|
with
|
|
| Ok (Server_command.Server_start { repo; graph }) ->
|
|
expect_equal "server start repo" "logseq_db_demo"
|
|
(Cli_primitive.string_of_repo repo);
|
|
expect_equal "server start graph" "demo"
|
|
(Cli_primitive.string_of_graph graph)
|
|
| Ok _ -> fail_test "server start: expected start action"
|
|
| Error err -> fail_test ("server start: " ^ err.Error.message));
|
|
(match
|
|
Server_command.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
Server_command.Parsed_stop
|
|
with
|
|
| Ok (Server_command.Server_stop { repo; graph }) ->
|
|
expect_equal "server stop repo" "logseq_db_demo"
|
|
(Cli_primitive.string_of_repo repo);
|
|
expect_equal "server stop graph" "demo"
|
|
(Cli_primitive.string_of_graph graph)
|
|
| Ok _ -> fail_test "server stop: expected stop action"
|
|
| Error err -> fail_test ("server stop: " ^ err.Error.message));
|
|
(match
|
|
Server_command.build (config ~repo:"demo" ()) (Global_opts.create ())
|
|
Server_command.Parsed_restart
|
|
with
|
|
| Ok (Server_command.Server_restart { repo; graph }) ->
|
|
expect_equal "server restart repo" "logseq_db_demo"
|
|
(Cli_primitive.string_of_repo repo);
|
|
expect_equal "server restart graph" "demo"
|
|
(Cli_primitive.string_of_graph graph)
|
|
| Ok _ -> fail_test "server restart: expected restart action"
|
|
| Error err -> fail_test ("server restart: " ^ err.Error.message));
|
|
pass);
|
|
|
|
test
|
|
"CLI parity server graph item listing ignores non-graphs and marks old dir \
|
|
conflicts" (fun () ->
|
|
let root = temp_dir "logseq-cli-parity-graph-items-" in
|
|
let graphs = Node.Path.join [| root; "graphs" |] in
|
|
try
|
|
Vec.iter
|
|
(fun dir -> mkdir_p (Node.Path.join [| graphs; dir |]))
|
|
(Vec.of_array
|
|
[|
|
|
"alpha";
|
|
"backup";
|
|
"foo~2G";
|
|
"Unlinked graphs";
|
|
"logseq_local_1";
|
|
"old++name";
|
|
"old~2Fname";
|
|
"yy y";
|
|
"yy~20y";
|
|
"yy%20y";
|
|
"bad%ZZname";
|
|
|]);
|
|
let items =
|
|
Server_runtime.list_graph_items (config ~root_dir:root ())
|
|
in
|
|
let canonical =
|
|
Vec.filter
|
|
(fun item -> item.Graph_types.kind = Graph_types.Canonical)
|
|
items
|
|
in
|
|
expect_bool "has alpha canonical" true
|
|
(Vec.exists
|
|
(fun item ->
|
|
Option.equal String.equal
|
|
(Option.map Cli_primitive.string_of_graph
|
|
item.Graph_types.graph_name)
|
|
(Some "alpha")
|
|
&& item.Graph_types.graph_dir = Some "alpha")
|
|
canonical);
|
|
expect_bool "ignores backup" false
|
|
(Vec.exists
|
|
(fun item -> item.Graph_types.graph_dir = Some "backup")
|
|
items);
|
|
let old_item =
|
|
expect_some "old format item"
|
|
(Vec.find_opt
|
|
(fun item -> item.Graph_types.legacy_dir = Some "old++name")
|
|
items)
|
|
in
|
|
expect_bool "old item kind" true
|
|
(old_item.Graph_types.kind = Graph_types.Legacy);
|
|
expect_equal "old graph name" "old/name"
|
|
(Cli_primitive.string_of_graph
|
|
(expect_some "old graph name" old_item.Graph_types.graph_name));
|
|
expect_equal "old target dir" "old~2Fname"
|
|
(expect_some "target dir" old_item.Graph_types.target_graph_dir);
|
|
expect_bool "old conflict" true old_item.Graph_types.conflict;
|
|
let percent_encoded_old_dirs =
|
|
items
|
|
|> Vec.filter (fun item ->
|
|
match item.Graph_types.legacy_dir with
|
|
| Some ("yy~20y" | "yy%20y") -> true
|
|
| _ -> false)
|
|
in
|
|
expect_int "percent encoded old dir count" 1
|
|
(Vec.length percent_encoded_old_dirs);
|
|
Vec.iter
|
|
(fun item ->
|
|
expect_bool "percent encoded item kind" true
|
|
(item.Graph_types.kind = Graph_types.Legacy);
|
|
expect_equal "percent encoded graph name" "yy y"
|
|
(Cli_primitive.string_of_graph
|
|
(expect_some "percent encoded graph name"
|
|
item.Graph_types.graph_name));
|
|
expect_equal "percent encoded target dir" "yy y"
|
|
(expect_some "percent encoded target"
|
|
item.Graph_types.target_graph_dir);
|
|
expect_bool "percent encoded conflict" true
|
|
item.Graph_types.conflict)
|
|
percent_encoded_old_dirs;
|
|
let undecodable =
|
|
expect_some "undecodable item"
|
|
(Vec.find_opt
|
|
(fun item -> item.Graph_types.legacy_dir = Some "bad%ZZname")
|
|
items)
|
|
in
|
|
expect_bool "undecodable kind" true
|
|
(undecodable.Graph_types.kind = Graph_types.Legacy_undecodable);
|
|
remove_tree root
|
|
with exn ->
|
|
remove_tree root;
|
|
fail_test (Printexc.to_string exn));
|
|
|
|
test "CLI parity format renders basic success outputs by selected mode"
|
|
(fun () ->
|
|
let message mode = Cli_result.ok mode (Cli_result.Message "ok") in
|
|
expect_equal "human message" "ok"
|
|
(Format_types.format_result (message Output.Mode.Human) (config ()));
|
|
expect_equal "json message"
|
|
"{\"status\":\"ok\",\"data\":{\"message\":\"ok\"}}"
|
|
(Format_types.format_result (message Output.Mode.Json)
|
|
(config ~output_format:(Output.Mode.Packed Output.Mode.Json) ()));
|
|
expect_equal "edn message" "{:status :ok :data {:message \"ok\"}}"
|
|
(Format_types.format_result (message Output.Mode.Edn)
|
|
(config ~output_format:(Output.Mode.Packed Output.Mode.Edn) ())));
|
|
|
|
test "CLI parity default human tables keep discovered header order" (fun () ->
|
|
let value =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "items",
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "block/updated-at",
|
|
Edn_util.int64 90000L );
|
|
(Edn_util.keyword "block/title", Edn_util.string "Alpha");
|
|
( Edn_util.keyword "block/created-at",
|
|
Edn_util.int64 40000L );
|
|
];
|
|
] );
|
|
]
|
|
in
|
|
let output =
|
|
Format_types.format_result
|
|
(Cli_result.ok Output.Mode.Human (Cli_result.Raw value))
|
|
(config ())
|
|
in
|
|
expect_equal "default table header order" "updated-at,title,created-at"
|
|
(headers_from output |> Vec.of_array |> Vec.string_concat ","));
|
|
|
|
test "CLI parity format graph list marks current graph and old graph dirs"
|
|
(fun () ->
|
|
let graph_list_data =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "graphs",
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.string "alpha";
|
|
Edn_util.string "old/name";
|
|
Edn_util.string "mystery";
|
|
] );
|
|
( Edn_util.keyword "graph-items",
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "kind", Edn_util.keyword "canonical");
|
|
(Edn_util.keyword "graph-name", Edn_util.string "alpha");
|
|
(Edn_util.keyword "graph-dir", Edn_util.string "alpha");
|
|
];
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "kind", Edn_util.keyword "legacy");
|
|
( Edn_util.keyword "legacy-dir",
|
|
Edn_util.string "old++name" );
|
|
( Edn_util.keyword "legacy-graph-name",
|
|
Edn_util.string "old/name" );
|
|
( Edn_util.keyword "target-graph-dir",
|
|
Edn_util.string "old~2Fname" );
|
|
(Edn_util.keyword "conflict?", Edn_util.bool false);
|
|
];
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "kind",
|
|
Edn_util.keyword "legacy-undecodable" );
|
|
(Edn_util.keyword "legacy-dir", Edn_util.string "mystery");
|
|
(Edn_util.keyword "reason", Edn_util.keyword "undecodable");
|
|
];
|
|
] );
|
|
]
|
|
in
|
|
let output =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Graph_list Output.Mode.Human
|
|
(Cli_result.Raw graph_list_data))
|
|
(config ~graph:"old/name" ~root_dir:"/tmp/logseq-root" ())
|
|
in
|
|
expect_named_contains "current graph marker" output "* old/name";
|
|
expect_named_not_contains "old graph marker" output "old/name [legacy]";
|
|
expect_named_not_contains "old graph warning" output
|
|
"legacy graph directories detected";
|
|
expect_named_not_contains "rename guidance" output "old++name");
|
|
|
|
test "CLI parity format list and search table outputs keep count footer"
|
|
(fun () ->
|
|
let list_value =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "items",
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "db/id", Edn_util.int64 1L);
|
|
(Edn_util.keyword "block/title", Edn_util.string "Alpha");
|
|
( Edn_util.keyword "block/updated-at",
|
|
Edn_util.int64 90000L );
|
|
( Edn_util.keyword "block/created-at",
|
|
Edn_util.int64 40000L );
|
|
];
|
|
] );
|
|
]
|
|
in
|
|
let list_output =
|
|
Format_types.format_result
|
|
~human_table_headers_order:
|
|
(Vec.of_array
|
|
[| "id"; "ident"; "title"; "uuid"; "created-at"; "updated-at" |])
|
|
(Cli_result.ok ~command:Command_id.List_page Output.Mode.Human
|
|
(Cli_result.Raw list_value))
|
|
(config ())
|
|
in
|
|
expect_named_contains "list id header" list_output "id";
|
|
expect_named_contains "list title" list_output "Alpha";
|
|
expect_named_contains "list count" list_output "Count: 1";
|
|
let empty_order_output =
|
|
Format_types.format_result ~human_table_headers_order:Vec.empty
|
|
(Cli_result.ok ~command:Command_id.List_page Output.Mode.Human
|
|
(Cli_result.Raw list_value))
|
|
(config ())
|
|
in
|
|
expect_equal "empty header order does not infer columns" "Count: 1"
|
|
(String.trim empty_order_output);
|
|
let search_value =
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "items",
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "db/id", Edn_util.int64 3L);
|
|
( Edn_util.keyword "block/title",
|
|
Edn_util.string "Alpha block" );
|
|
];
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "db/id", Edn_util.int64 7L);
|
|
( Edn_util.keyword "block/title",
|
|
Edn_util.string "Second line\nIndented" );
|
|
];
|
|
] );
|
|
]
|
|
in
|
|
let search_output =
|
|
Format_types.format_result
|
|
~human_table_headers_order:(Vec.of_array [| "id"; "ident"; "title" |])
|
|
(Cli_result.ok ~command:Command_id.Search_block Output.Mode.Human
|
|
(Cli_result.Raw search_value))
|
|
(config ())
|
|
in
|
|
expect_named_contains "search title" search_output "Alpha block";
|
|
expect_named_contains "search multiline" search_output "Indented";
|
|
expect_named_contains "search count" search_output "Count: 2");
|
|
|
|
test "CLI parity format list variants use current generic table contracts"
|
|
(fun () ->
|
|
let row fields = Edn_util.map_vec (Vec.of_array fields) in
|
|
let items values =
|
|
Edn_util.map_vec
|
|
(Vec.singleton
|
|
( Edn_util.keyword "items",
|
|
Edn_util.vector_vec (Vec.of_array values) ))
|
|
in
|
|
let human command value =
|
|
Format_types.format_result
|
|
~human_table_headers_order:
|
|
(let registry = (Cli.make_app_context ()).Cli.registry in
|
|
let meta =
|
|
expect_some "command metadata"
|
|
(Command_registry.find_by_path
|
|
(Command_id.to_path command)
|
|
registry)
|
|
in
|
|
meta.human_table_headers_order)
|
|
(Cli_result.ok ~command Output.Mode.Human (Cli_result.Raw value))
|
|
(config ())
|
|
in
|
|
let tag_output =
|
|
human Command_id.List_tag
|
|
(items
|
|
[|
|
|
row
|
|
[|
|
|
(Edn_util.keyword "block/title", Edn_util.string "Tag");
|
|
(Edn_util.keyword "db/id", Edn_util.int64 42L);
|
|
( Edn_util.keyword "db/ident",
|
|
Edn_util.keyword "logseq.class/Tag" );
|
|
|];
|
|
|])
|
|
in
|
|
expect_named_contains "tag id header" tag_output "id";
|
|
expect_named_contains "tag title header" tag_output "title";
|
|
expect_named_contains "tag ident value" tag_output "logseq.class/Tag";
|
|
let property_output =
|
|
human Command_id.List_property
|
|
(items
|
|
[|
|
|
row
|
|
[|
|
|
(Edn_util.keyword "block/title", Edn_util.string "Prop");
|
|
(Edn_util.keyword "db/id", Edn_util.int64 99L);
|
|
( Edn_util.keyword "logseq.property/type",
|
|
Edn_util.keyword "node" );
|
|
( Edn_util.keyword "db/cardinality",
|
|
Edn_util.keyword "db.cardinality/many" );
|
|
|];
|
|
row
|
|
[|
|
|
(Edn_util.keyword "block/title", Edn_util.string "Untyped");
|
|
(Edn_util.keyword "db/id", Edn_util.int64 100L);
|
|
|];
|
|
|])
|
|
in
|
|
expect_named_contains "property type header" property_output "type";
|
|
expect_named_contains "property cardinality header" property_output
|
|
"cardinality";
|
|
expect_named_contains "property cardinality value" property_output
|
|
"db.cardinality/many";
|
|
let task_output =
|
|
human Command_id.List_task
|
|
(items
|
|
[|
|
|
row
|
|
[|
|
|
(Edn_util.keyword "db/id", Edn_util.int64 12L);
|
|
(Edn_util.keyword "block/title", Edn_util.string "Alpha task");
|
|
( Edn_util.keyword "logseq.property/status",
|
|
Edn_util.keyword "logseq.property/status.todo" );
|
|
( Edn_util.keyword "logseq.property/priority",
|
|
Edn_util.keyword "logseq.property/priority.high" );
|
|
|];
|
|
|])
|
|
in
|
|
expect_named_contains "task status column" task_output "status";
|
|
expect_named_contains "task priority column" task_output "priority";
|
|
let unordered_task_output =
|
|
Format_types.format_result
|
|
~human_table_headers_order:
|
|
(Vec.of_array
|
|
[|
|
|
"id";
|
|
"title";
|
|
"status";
|
|
"priority";
|
|
"scheduled";
|
|
"deadline";
|
|
"updated-at";
|
|
"created-at";
|
|
|])
|
|
(Cli_result.ok ~command:Command_id.List_task Output.Mode.Human
|
|
(Cli_result.Raw
|
|
(items
|
|
[|
|
|
row
|
|
[|
|
|
( Edn_util.keyword "logseq.property/priority",
|
|
Edn_util.keyword "logseq.property/priority.high" );
|
|
(Edn_util.keyword "block/title", Edn_util.string "Ship");
|
|
( Edn_util.keyword "logseq.property/status",
|
|
Edn_util.keyword "logseq.property/status.todo" );
|
|
( Edn_util.keyword "block/created-at",
|
|
Edn_util.int64 40000L );
|
|
( Edn_util.keyword "block/updated-at",
|
|
Edn_util.int64 90000L );
|
|
(Edn_util.keyword "db/id", Edn_util.int64 12L);
|
|
(Edn_util.keyword "block/uuid", Edn_util.string "u1");
|
|
|];
|
|
|])))
|
|
(config ())
|
|
in
|
|
expect_equal "ordered task headers"
|
|
"id,title,status,priority,updated-at,created-at"
|
|
(headers_from unordered_task_output
|
|
|> Vec.of_array |> Vec.string_concat ",");
|
|
let node_output =
|
|
human Command_id.List_node
|
|
(items
|
|
[|
|
|
row
|
|
[|
|
|
(Edn_util.keyword "db/id", Edn_util.int64 1L);
|
|
(Edn_util.keyword "block/title", Edn_util.string "Node Page");
|
|
(Edn_util.keyword "node/type", Edn_util.string "page");
|
|
( Edn_util.keyword "block/uuid",
|
|
Edn_util.uuid "11111111-1111-1111-1111-111111111111" );
|
|
|];
|
|
|])
|
|
in
|
|
expect_named_contains "node type column" node_output "type";
|
|
expect_named_not_contains "node uuid column" node_output "uuid";
|
|
let asset_output =
|
|
human Command_id.List_asset
|
|
(items
|
|
[|
|
|
row
|
|
[|
|
|
(Edn_util.keyword "db/id", Edn_util.int64 3L);
|
|
(Edn_util.keyword "block/title", Edn_util.string "Asset Node");
|
|
( Edn_util.keyword "logseq.property.asset/type",
|
|
Edn_util.string "md" );
|
|
( Edn_util.keyword "logseq.property.asset/size",
|
|
Edn_util.int64 2552L );
|
|
|];
|
|
|])
|
|
in
|
|
expect_named_contains "asset type column" asset_output "type";
|
|
expect_named_contains "asset size column" asset_output "size";
|
|
expect_named_contains "asset raw size" asset_output "2552");
|
|
|
|
test "CLI parity format list title truncation keeps current display contracts"
|
|
(fun () ->
|
|
let ellipsis = decode_uri_component "%E2%80%A6" in
|
|
let item title =
|
|
Edn_util.map_vec
|
|
(Vec.of_array
|
|
[|
|
|
(Edn_util.keyword "db/id", Edn_util.int64 1L);
|
|
(Edn_util.keyword "block/title", Edn_util.string title);
|
|
|])
|
|
in
|
|
let value title =
|
|
Edn_util.map_vec
|
|
(Vec.singleton
|
|
( Edn_util.keyword "items",
|
|
Edn_util.vector_vec (Vec.singleton (item title)) ))
|
|
in
|
|
let truncated =
|
|
Format_types.format_result
|
|
~human_table_headers_order:
|
|
(Vec.of_array
|
|
[| "id"; "ident"; "title"; "uuid"; "created-at"; "updated-at" |])
|
|
(Cli_result.ok ~command:Command_id.List_page Output.Mode.Human
|
|
(Cli_result.Raw (value "ABCDEFGH")))
|
|
(config ~list_title_max_display_width:6 ())
|
|
in
|
|
expect_named_contains "single line display truncation" truncated
|
|
("ABCDE" ^ ellipsis);
|
|
expect_named_not_contains "single line hides full title" truncated
|
|
"ABCDEFGH";
|
|
let multiline =
|
|
Format_types.format_result
|
|
~human_table_headers_order:
|
|
(Vec.of_array
|
|
[| "id"; "ident"; "title"; "uuid"; "created-at"; "updated-at" |])
|
|
(Cli_result.ok ~command:Command_id.List_page Output.Mode.Human
|
|
(Cli_result.Raw (value "Line 1\nLine 2\nLine 3\nLine 4\nLine 5")))
|
|
(config ())
|
|
in
|
|
expect_named_contains "multiline line one" multiline "Line 1";
|
|
expect_named_not_contains "multiline line two" multiline "Line 2";
|
|
ignore ellipsis;
|
|
expect_named_not_contains "multiline line three" multiline "Line 3";
|
|
expect_named_not_contains "multiline line four" multiline "Line 4";
|
|
expect_named_not_contains "multiline line five" multiline "Line 5");
|
|
|
|
test "CLI parity list task aligns status after accented latin titles"
|
|
(fun () ->
|
|
let accented_title =
|
|
decode_uri_component
|
|
"Diese%20Vorteile%20k%C3%B6nnten%20besonders%20f%C3%BCr%20eine"
|
|
in
|
|
let item id title =
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "db/id", Edn_util.int64 id);
|
|
(Edn_util.keyword "block/title", Edn_util.string title);
|
|
( Edn_util.keyword "logseq.property/status",
|
|
Edn_util.keyword "logseq.property/status.todo" );
|
|
]
|
|
in
|
|
let value =
|
|
Edn_util.map_vec
|
|
(Vec.singleton
|
|
( Edn_util.keyword "items",
|
|
Edn_util.vector_vec
|
|
(Vec.of_array [| item 1L "yyy"; item 2L accented_title |]) ))
|
|
in
|
|
let output =
|
|
Format_types.format_result
|
|
~human_table_headers_order:
|
|
(Vec.of_array [| "id"; "title"; "status" |])
|
|
(Cli_result.ok ~command:Command_id.List_task Output.Mode.Human
|
|
(Cli_result.Raw value))
|
|
(config ())
|
|
in
|
|
let status_column line token =
|
|
match Js.String.indexOf ~search:token line with
|
|
| -1 ->
|
|
fail_test ("missing " ^ token ^ " in line:\n" ^ line ^ "\n" ^ output);
|
|
0
|
|
| index -> display_width (String.sub line 0 index)
|
|
in
|
|
let lines = Vec.of_array (string_split (string_trim_end output) "\n") in
|
|
if Vec.length lines = 4 then (
|
|
let header = Vec.nth lines 0 in
|
|
let short_row = Vec.nth lines 1 in
|
|
let accented_row = Vec.nth lines 2 in
|
|
let expected = status_column header "status" in
|
|
expect_int "short task status column" expected
|
|
(status_column short_row "status.todo");
|
|
expect_int "accented task status column" expected
|
|
(status_column accented_row "status.todo"))
|
|
else fail_test ("unexpected list task output:\n" ^ output));
|
|
|
|
test "CLI parity format upsert summaries use current generic tables"
|
|
(fun () ->
|
|
let raw_ids ids =
|
|
let ids = Vec.of_array ids in
|
|
Cli_result.Raw
|
|
(Edn_util.map
|
|
[
|
|
( Edn_util.keyword "result",
|
|
Edn_util.vector_vec (Vec.map Edn_util.int64 ids) );
|
|
])
|
|
in
|
|
let upsert_block =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Upsert_block Output.Mode.Human
|
|
(raw_ids [| 201L; 202L |]))
|
|
(config ())
|
|
in
|
|
expect_equal "upsert block table" "Value\n201\n202\nCount: 2" upsert_block;
|
|
let upsert_page =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Upsert_page Output.Mode.Human
|
|
(raw_ids [| 123L |]))
|
|
(config ())
|
|
in
|
|
expect_equal "upsert page table" "Value\n123\nCount: 1" upsert_page);
|
|
|
|
test "CLI parity format remove summaries use current generic tables"
|
|
(fun () ->
|
|
let success_data =
|
|
Cli_result.Raw
|
|
(Edn_util.map_vec
|
|
(Vec.singleton
|
|
( Edn_util.keyword "result",
|
|
Edn_util.map_vec
|
|
(Vec.singleton (Edn_util.keyword "ok", Edn_util.bool true))
|
|
)))
|
|
in
|
|
let page_output =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Remove_page Output.Mode.Human
|
|
success_data)
|
|
(config ~repo:"demo-repo" ())
|
|
in
|
|
expect_equal "remove page result table" "result {:ok true}" page_output;
|
|
let block_output =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Remove_block Output.Mode.Human
|
|
success_data)
|
|
(config ~repo:"demo-repo" ())
|
|
in
|
|
expect_equal "remove block result table" "result {:ok true}" block_output);
|
|
|
|
test
|
|
"CLI parity format graph sync and auth summaries use current generic output"
|
|
(fun () ->
|
|
let graph_export =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Graph_export Output.Mode.Human
|
|
Cli_result.Empty)
|
|
(config ())
|
|
in
|
|
expect_equal "graph export empty output" "" graph_export;
|
|
let sync_status =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Sync_status Output.Mode.Human
|
|
(Cli_result.Raw
|
|
(Edn_util.map
|
|
[
|
|
(Edn_util.keyword "repo", Edn_util.string "demo-graph");
|
|
(Edn_util.keyword "graph-id", Edn_util.string "graph-uuid");
|
|
(Edn_util.keyword "ws-state", Edn_util.keyword "open");
|
|
(Edn_util.keyword "pending-local", Edn_util.int64 2345L);
|
|
])))
|
|
(config ())
|
|
in
|
|
expect_named_contains "sync status repo" sync_status "demo-graph";
|
|
expect_named_contains "sync status pending" sync_status "2345";
|
|
let login =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Login Output.Mode.Human
|
|
(Cli_result.Raw
|
|
(Edn_util.map
|
|
[
|
|
( Edn_util.keyword "auth-path",
|
|
Edn_util.string "/tmp/auth.json" );
|
|
( Edn_util.keyword "email",
|
|
Edn_util.string "user@example.com" );
|
|
( Edn_util.keyword "id-token",
|
|
Edn_util.string "secret-token" );
|
|
])))
|
|
(config ())
|
|
in
|
|
expect_named_contains "login email" login "user@example.com";
|
|
expect_named_contains "login current token field" login "secret-token");
|
|
|
|
test "CLI parity format graph info keeps old kv redaction contracts"
|
|
(fun () ->
|
|
let token = "secret-token-value" in
|
|
let kv_value =
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.string "logseq.kv/api-token", Edn_util.string token);
|
|
(Edn_util.string "logseq.kv/db-type", Edn_util.keyword "sqlite");
|
|
]
|
|
in
|
|
let graph_info_value =
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "graph", Edn_util.string "demo-graph");
|
|
(Edn_util.keyword "kv", kv_value);
|
|
]
|
|
in
|
|
let output =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Graph_info Output.Mode.Human
|
|
(Cli_result.Raw graph_info_value))
|
|
(config ())
|
|
in
|
|
expect_named_contains "graph info graph row" output "graph";
|
|
expect_named_contains "graph info graph value" output "demo-graph";
|
|
expect_named_contains "graph info redacts token" output "[REDACTED]";
|
|
expect_named_not_contains "graph info hides token" output token;
|
|
let json_graph_info_value =
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "graph", Edn_util.string "demo-graph");
|
|
( Edn_util.keyword "kv",
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.string "logseq.kv/api-token", Edn_util.string token);
|
|
] );
|
|
]
|
|
in
|
|
let json_output =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Graph_info Output.Mode.Json
|
|
(Cli_result.Raw json_graph_info_value))
|
|
(config ~output_format:(Output.Mode.Packed Output.Mode.Json) ())
|
|
in
|
|
expect_named_contains "graph info json redaction" json_output
|
|
"\"logseq.kv/api-token\":\"[REDACTED]\"";
|
|
expect_named_not_contains "graph info json hides token" json_output token);
|
|
|
|
test "CLI parity format server outputs use current owner revision contracts"
|
|
(fun () ->
|
|
let server =
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "repo", Edn_util.string "demo-repo");
|
|
(Edn_util.keyword "status", Edn_util.keyword "ready");
|
|
(Edn_util.keyword "host", Edn_util.string "127.0.0.1");
|
|
(Edn_util.keyword "port", Edn_util.int64 1234L);
|
|
(Edn_util.keyword "pid", Edn_util.int64 9876L);
|
|
(Edn_util.keyword "owner-source", Edn_util.keyword "cli");
|
|
(Edn_util.keyword "revision", Edn_util.string "worker-revision");
|
|
]
|
|
in
|
|
let list_output =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Server_list Output.Mode.Human
|
|
(Cli_result.Raw
|
|
(Edn_util.map_vec
|
|
(Vec.singleton
|
|
( Edn_util.keyword "servers",
|
|
Edn_util.vector_vec (Vec.singleton server) )))))
|
|
(config ())
|
|
in
|
|
expect_named_contains "server repo header" list_output "repo";
|
|
expect_named_contains "server owner header" list_output "owner-source";
|
|
expect_named_contains "server revision" list_output "worker-revision";
|
|
let cleanup_output =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Server_cleanup Output.Mode.Human
|
|
(Cli_result.Raw
|
|
(Edn_util.map_vec
|
|
(Vec.of_array
|
|
[|
|
|
( Edn_util.keyword "cli-revision",
|
|
Edn_util.string "cli-rev" );
|
|
(Edn_util.keyword "checked", Edn_util.int64 4321L);
|
|
(Edn_util.keyword "mismatched", Edn_util.int64 3210L);
|
|
( Edn_util.keyword "killed",
|
|
Edn_util.vector_vec (Vec.singleton server) );
|
|
|]))))
|
|
(config ())
|
|
in
|
|
expect_named_contains "cleanup checked row" cleanup_output "checked";
|
|
expect_named_contains "cleanup checked value" cleanup_output "4321");
|
|
|
|
test "CLI parity format doctor and validation outputs use current contracts"
|
|
(fun () ->
|
|
let validation_success =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Graph_validate
|
|
~context:
|
|
(Edn_util.map
|
|
[ (Edn_util.keyword "graph", Edn_util.string "foo") ])
|
|
Output.Mode.Human
|
|
(Cli_result.Raw
|
|
(Edn_util.map
|
|
[
|
|
( Edn_util.keyword "result",
|
|
Edn_util.map
|
|
[ (Edn_util.keyword "errors", Edn_util.nil) ] );
|
|
])))
|
|
(config ())
|
|
in
|
|
expect_equal "graph validation result table" "result {:errors nil}"
|
|
validation_success;
|
|
let validation_error =
|
|
Format_types.format_result
|
|
(Cli_result.error ~command:Command_id.Graph_validate Output.Mode.Human
|
|
(Error.make Error.Graph_validation_failed
|
|
"Found 1 entity with errors:\n({:entity {:db/id 1}})\n"))
|
|
(config ())
|
|
in
|
|
expect_named_contains "graph validation error code" validation_error
|
|
"Error (graph-validation-failed):";
|
|
expect_named_contains "graph validation error body" validation_error
|
|
"Found 1 entity with errors";
|
|
let doctor_value =
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "status", Edn_util.keyword "warning");
|
|
( Edn_util.keyword "checks",
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.map
|
|
[
|
|
(Edn_util.keyword "id", Edn_util.keyword "root-dir");
|
|
(Edn_util.keyword "status", Edn_util.keyword "ok");
|
|
( Edn_util.keyword "message",
|
|
Edn_util.string "Read/write access confirmed" );
|
|
];
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "id",
|
|
Edn_util.keyword "server-revision-mismatch" );
|
|
(Edn_util.keyword "status", Edn_util.keyword "warning");
|
|
( Edn_util.keyword "message",
|
|
Edn_util.string
|
|
"1 server uses a different revision than this CLI" );
|
|
( Edn_util.keyword "servers",
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.map
|
|
[
|
|
( Edn_util.keyword "graph",
|
|
Edn_util.string "team graph" );
|
|
];
|
|
] );
|
|
];
|
|
] );
|
|
]
|
|
in
|
|
let doctor_output =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Doctor Output.Mode.Human
|
|
(Cli_result.Raw doctor_value))
|
|
(config ())
|
|
in
|
|
expect_named_contains "doctor status" doctor_output "warning";
|
|
expect_named_contains "doctor root check" doctor_output "root-dir";
|
|
expect_named_contains "doctor restart target" doctor_output "team graph";
|
|
let revision_error =
|
|
Format_types.format_result
|
|
(Cli_result.error ~command:Command_id.Server_start Output.Mode.Human
|
|
(Error.make
|
|
~hint:
|
|
"Logseq restarted db-worker-node, but the replacement still \
|
|
reports a different revision. Check the installed Logseq \
|
|
build and retry"
|
|
Error.Server_revision_mismatch_after_restart
|
|
"db-worker-node revision still does not match after restart"))
|
|
(config ())
|
|
in
|
|
expect_named_contains "revision mismatch error" revision_error
|
|
"Error (server-revision-mismatch-after-restart):");
|
|
|
|
test "CLI parity format query and show outputs keep current raw contracts"
|
|
(fun () ->
|
|
let query_output =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Query Output.Mode.Human
|
|
(Cli_result.Query_result
|
|
(Edn_util.map
|
|
[
|
|
( Edn_util.keyword "result",
|
|
Edn_util.vector
|
|
[
|
|
Edn_util.int64 1L;
|
|
Edn_util.int64 2L;
|
|
Edn_util.int64 3L;
|
|
] );
|
|
])))
|
|
(config ())
|
|
in
|
|
expect_equal "query scalar vector lines" "1\n2\n3" query_output;
|
|
let show_output =
|
|
Format_types.format_result
|
|
(Cli_result.ok ~command:Command_id.Show Output.Mode.Human
|
|
(Cli_result.Message "Line 1\nLine 2"))
|
|
(config ())
|
|
in
|
|
expect_equal "show text payload" "Line 1\nLine 2" show_output)
|
|
|
|
let touch = ()
|