backups/flake_env
1
0
Fork 0
mirror of https://git.sr.ht/~bryan_bennett/flake_env synced 2025-12-19 16:01:25 +01:00
Code Issues Projects Releases Packages Wiki Activity

WIP

Browse source
This commit is contained in:
Bryan Bennett 2024-01-05 06:25:13 -05:00
parent 31cac9373c
commit 5e505b178b
No known key found for this signature in database
GPG key ID: EE149E4215408DE9
13 changed files with 486 additions and 165 deletions
Download patch file Download diff file Expand all files Collapse all files

158
bin/flake_env.re
View file

@ -1,149 +1,55 @@
open Core;
module Unix = Core_unix;
open Lib;
let preflight = (layout_directory) => {
switch (Lib.Versions.preflight_versions(), Sys_unix.is_directory(layout_directory)) {
| (Ok(_), `Yes) => Ok()
| (Ok(_), _) => {
Unix.mkdir_p(layout_directory);
Ok()
}
| (err, _) => err
}
}
let hash_files = (filenames) => {
let ctx = Sha1.init();
let () = filenames
|> Array.filter(~f=f => switch (Sys_unix.file_exists(f)) {
| `Yes => true
| _ => false
})
|> Array.iter(~f=(f) => {
f |> In_channel.create |> In_channel.input_all |> Sha1.update_string(ctx);
});
Sha1.finalize(ctx) |> Sha1.to_hex
};
// TODO: Maybe make this more terse?
let rec rmrf = (path) => {
switch (Unix.lstat(path).st_kind) {
| exception Unix.Unix_error(_, _, _) => ()
| S_REG => Unix.unlink(path)
| S_LNK => Unix.unlink(path)
| S_DIR => {
Sys_unix.readdir(path) |> Array.iter(~f=name => rmrf(Filename.concat(path, name)));
Unix.rmdir(path)
}
| S_CHR => Printf.eprintf("Don't know how to handle Character Device file\n")
| S_BLK => Printf.eprintf("Don't know how to handle Block Device file\n")
| S_FIFO => Printf.eprintf("Don't know how to handle FIFO file\n")
| S_SOCK => Printf.eprintf("Don't know how to handle Socket file\n")
}
};
let clean_old_gcroots = (layout_dir) => {
rmrf(layout_dir ++ "/flake-inputs/");
rmrf(layout_dir);
Unix.mkdir_p(layout_dir ++ "/flake-inputs/");
};
let print_cur_cache = (profile_rc) => {
In_channel.read_all(profile_rc) |> Printf.printf("%s")
};
let add_gcroot = (store_path, symlink) => {
switch (Lib.Util.nix(["build", "--out-link", symlink, store_path])) {
| (Ok(), _) => Ok()
| (err, _) => err
}
}
let freshen_cache = (layout_dir, hash, flake_specifier) => {
clean_old_gcroots(layout_dir);
let tmp_profile = layout_dir ++ "flake-tmp-profile." ++ Core.Pid.to_string(Core_unix.getpid());
let (exit_code, stdout_content) = Lib.Util.nix(["print-dev-env", "--profile", tmp_profile, flake_specifier]);
let profile = layout_dir ++ "/flake-profile-" ++ hash;
let profile_rc = profile ++ ".rc";
switch (exit_code) {
| Ok() => {
Out_channel.with_file(~f=f=> Out_channel.output_string(f, stdout_content), profile_rc);
switch (add_gcroot(tmp_profile, profile)) {
| Ok() => {
Sys_unix.remove(tmp_profile);
let flake_input_cache_path = layout_dir ++ "/flake-inputs/"
let flake_inputs = Lib.Watches.get_input_paths();
flake_inputs |> List.iter(~f=(inpt) => {
switch (add_gcroot("/nix/store/" ++ inpt, flake_input_cache_path ++ inpt)) {
| Ok() => ()
| err => Printf.eprintf("Failed creating flake-input gcroot: %s\n", Core_unix.Exit_or_signal.to_string_hum(err));
};
});
print_cur_cache(profile_rc);
}
| err => {
Printf.eprintf("Failed creating gcroot: %s\n", Core_unix.Exit_or_signal.to_string_hum(err));
exit(1);
}
};
}
| err => {
Printf.eprintf("Failed evaluating flake: %s\n", Core_unix.Exit_or_signal.to_string_hum(err));
exit(1);
}
};
};
// TODO: Extend to add support for additional flags, maybe?
let main = () => {
let argv = Sys.get_argv();
switch (Array.length(argv)) {
| 3 => {
let flake_specifier = argv[1];
let layout_directory = argv[2];
switch (Util.get_args(argv)) {
| Ok((layout_directory, flake_specifier, other_args)) => {
switch (preflight(layout_directory)) {
| Ok() => {
switch (Lib.Watches.get()) {
| Ok(watches) => {
let paths = Array.map(~f=watch => watch.path, watches);
let hash = hash_files(paths);
let profile = layout_directory ++ "/flake-profile-" ++ hash;
let profile_rc = profile ++ ".rc";
| Ok() => {
switch (Lib.Watches.get()) {
| Ok(watches) => {
let paths = Array.map(~f=watch => watch.path, watches);
let hash = Util.hash_files(paths);
let profile = layout_directory ++ "/flake-profile-" ++ hash;
let profile_rc = profile ++ ".rc";
switch ((Sys_unix.is_file(profile_rc), Sys_unix.is_file(profile))) {
| (`Yes, `Yes) => {
let profile_rc_mtime = Unix.stat(profile_rc).st_mtime;
let all_older= Array.map(~f=watch => watch.modtime, watches)
|> Array.for_all(~f=watch_mtime => watch_mtime <= int_of_float(profile_rc_mtime))
switch (all_older) {
| true => print_cur_cache(profile_rc)
| false => freshen_cache(layout_directory, hash, flake_specifier)
}
switch ((Sys_unix.is_file(profile_rc), Sys_unix.is_file(profile))) {
| (`Yes, `Yes) => {
let profile_rc_mtime = Unix.stat(profile_rc).st_mtime;
let all_older = Array.map(
~f=watch => watch.modtime, watches)
|> Array.for_all(
~f=watch_mtime => watch_mtime <= int_of_float(profile_rc_mtime)
)
if (all_older) {
print_cur_cache(profile_rc)
} else {
freshen_cache(layout_directory, hash, flake_specifier, other_args)
}
| _ => freshen_cache(layout_directory, hash, flake_specifier)
}
};
| Error(e) => {
Printf.eprintf("%s\n", e);
exit(1);
| _ => freshen_cache(layout_directory, hash, flake_specifier, other_args)
}
};
| Error(e) => {
Printf.eprintf("%s\n", e);
exit(1);
}
}
}
| Error(e) => {
Printf.eprintf("%s\n", e);
exit(1);
}
};
}
| _ => {
Printf.eprintf("%s <flake specifier> <layout_directory>\n", argv[0]);
| Error() => {
Printf.eprintf("%s <layout_directory> <flake specifier> <...args>\n", argv[0]);
exit(1);
}
}
}
}
};
let () = main();

2
default.nix
View file

@ -2,6 +2,7 @@
, core
, core_unix
, findlib
, fmt
, lib
, nix-filter
, ocaml
@ -41,6 +42,7 @@ buildDunePackage {
core
core_unix
findlib
fmt
ocaml
ppx_yojson_conv
ppx_yojson_conv_lib

2
direnvrc
View file

@ -41,7 +41,7 @@ use_flake_env() {
local ld=$(direnv_layout_dir)
export direnv
eval "$(@flake_env@ "$1" "$ld")"
eval "$(@flake_env@ "$ld" "$@")"
export -n direnv

2
flake.nix
View file

@ -29,6 +29,8 @@
devShells.default = pkgs.mkShell {
inputsFrom = [ self'.packages.default ];
packages = [
pkgs.ocamlPackages.alcotest
pkgs.ocamlPackages.bisect_ppx
pkgs.ocamlPackages.dune_3
pkgs.ocamlPackages.findlib
pkgs.ocamlPackages.ocaml

81
lib/#flake_env__versions.re# Normal file
View file

@ -0,0 +1,81 @@
open Core;
module Unix = Core_unix;
module Util = Flake_env__util;
type t = {
major: int,
minor: int,
point: int,
};
let init = (major, minor, point) => {
{major, minor, point}
};
let required_direnv_version = init(2, 21, 3);
let required_nix_version = init(2, 10, 0);
let semver_re = Re.compile(Re.Posix.re({|([0-9]+)\.([0-9]+)\.([0-9]+)|}));
let compare = (a, b) => {
switch (a, b) {
| (a, b) when a.major == b.major && a.minor == b.minor && a.point == b.point => 0
| (a, b) when a.major < b.major => -1
| (a, b) when a.major == b.major && a.minor < b.minor => -1
| (a, b) when a.major == b.major && a.minor == b.minor && a.point < b.point => -1
| _ => 1
}
}
let extract_version_number = (cmd) => {
switch (Util.run_process(cmd, ["--version"])) {
| (Ok(), stdout) when String.length(stdout) > 0 => {
let substrings = Re.exec(semver_re, stdout);
let groups = Re.Group.all(substrings);
if ((groups |> Array.length) == 4) {
Ok({
major: groups[1] |> int_of_string,
minor: groups[2] |> int_of_string,
point: groups[3] |> int_of_string
})
} else {
Error(Printf.sprintf("Stdout did not contain a version number for `%s --version`", cmd))
}
}
| _ => Error(Printf.sprintf("Failed executing '%s'\n", cmd))
}
};
let is_new_enough = (cur, needed) => {
switch (cur) {
| Ok(cur) => {
switch (compare(cur, needed)) {
| x when x < 0 => Ok(false)
| _ => Ok(true)
}
}
| Error(e) => Error(e)
}
};
let in_direnv = () => switch (Sys.getenv("direnv")) {
| Some(_) => true
| None => false
};
let preflight_versions = () => {
let is_nix_new_enough = is_new_enough(extract_version_number("nix"), required_nix_version);
let is_direnv_new_enough = is_new_enough(extract_version_number("direnv"), required_direnv_version);
switch (in_direnv(), is_direnv_new_enough, is_nix_new_enough) {
| (false, _, _) => Error("Not in direnv!")
| (_, Ok(false), _) => Error("Direnv version is not new enough")
| (_, _, Ok(false)) => Error("Nix version is not new enough")
| (_, Error(e), _) => Error(e)
| (_, _, Error(e)) => Error(e)
| (true, Ok(true), Ok(true)) => Ok()
}
};

11
lib/dune
View file

@ -1,5 +1,14 @@
(library
(name lib)
(public_name flake_env.lib)
(libraries core core_unix core_unix.filename_unix core_unix.sys_unix ppx_yojson_conv re sha)
(libraries
core
core_unix
core_unix.filename_unix
core_unix.sys_unix
fmt
ppx_yojson_conv
re
sha)
(instrumentation (backend bisect_ppx))
(preprocess (pps ppx_yojson_conv ppx_jane ppx_inline_test)))

53
lib/flake_env__util.re
View file

@ -1,10 +1,55 @@
open Core;
module Unix = Core_unix;
let nix = (args) => {
let stdout_chan = Unix.open_process_in(
"nix --extra-experimental-features \"nix-command flakes\" " ++ (args |> String.concat(~sep=" ")));
let run_process = (name, args) => {
/*** Run a process [name] with args [args], returning (exit_code, stdout text) */
let stdout_chan = Unix.open_process_in(name ++ " " ++ (args |> String.concat(~sep=" ")));
let stdout_content = stdout_chan |> In_channel.input_all;
let exit_code = Unix.close_process_in(stdout_chan);
(exit_code, stdout_content)
}
};
let nix = (args) => run_process("nix", ["--extra-experimental-features", "\"nix-command flakes\" ", ...args]);
let hash_files = (filenames) => {
/*** Hash all entries in [filenames], returning a hex-encoded string of the hash of their contents */
let ctx = Sha1.init();
let () = filenames
|> Array.filter(~f=f => switch (Sys_unix.file_exists(f)) {
| `Yes => true
| _ => false
})
|> Array.iter(~f=(f) => {
f |> In_channel.create |> In_channel.input_all |> Sha1.update_string(ctx);
});
Sha1.finalize(ctx) |> Sha1.to_hex
};
let rec rmrf = (path) => {
switch (Unix.lstat(path).st_kind) {
| exception Unix.Unix_error(_, _, _) => ()
| S_REG => Unix.unlink(path)
| S_LNK => Unix.unlink(path)
| S_DIR => {
Sys_unix.readdir(path) |> Array.iter(~f=name => rmrf(Filename.concat(path, name)));
Unix.rmdir(path)
}
| S_CHR => Printf.eprintf("Don't know how to handle Character Device file\n")
| S_BLK => Printf.eprintf("Don't know how to handle Block Device file\n")
| S_FIFO => Printf.eprintf("Don't know how to handle FIFO file\n")
| S_SOCK => Printf.eprintf("Don't know how to handle Socket file\n")
}
};
let get_args = (argv) => {
switch (Array.length(argv)) {
| x when x >= 3 => {
let layout_directory = argv[1];
let flake_specifier = argv[2];
let other_args = snd(List.split_n(List.of_array(argv), 3));
Ok((layout_directory, flake_specifier, other_args))
}
| _ => Error()
}
};

67
lib/flake_env__versions.re
View file

@ -1,28 +1,28 @@
open Core;
module Unix = Core_unix;
module Util = Flake_env__util;
type t = {
major: int,
minor: int,
point: int,
};
let init = (major, minor, point) => {
{major, minor, point}
};
let required_direnv_version = init(2, 21, 3);
let required_nix_version = init(2, 10, 0);
let semver_re = Re.compile(Re.Posix.re({|([0-9]+)\.([0-9]+)\.([0-9]+)|}));
let required_direnv_version = {
major: 2,
minor: 21,
point: 3
};
let pprint = (pp_fmt, version) => Fmt.pf(pp_fmt, "{ major: %d, minor: %d, point: %d }", version.major, version.minor, version.point);
let required_nix_version = {
major: 2,
minor: 10,
point: 0
};
// TODO: test this
let compare_version_number = (a, b) => {
let compare = (a, b) => {
switch (a, b) {
| (a, b) when a.major == b.major && a.minor == b.minor && a.point == b.point => 0
| (a, b) when a.major < b.major => -1
@ -32,46 +32,47 @@ let compare_version_number = (a, b) => {
}
}
let%test_unit "compare_version_number" = [%test_eq: int](compare_version_number({major: 1, minor: 0, point: 0}, {major: 2, minor: 0, point: 0}), -1);
let extract_version_number = (cmd) => {
let full_cmd = cmd ++ " --version";
switch (Core_unix.open_process_in(full_cmd) |> In_channel.input_line) {
| Some(stdout) => {
switch (Util.run_process(cmd, ["--version"])) {
| (Ok(), stdout) when String.length(stdout) > 0 => {
let substrings = Re.exec(semver_re, stdout);
let groups = Re.Group.all(substrings);
Ok({
major: groups[1] |> int_of_string,
minor: groups[2] |> int_of_string,
point: groups[3] |> int_of_string
})
if ((groups |> Array.length) == 4) {
Ok({
major: groups[1] |> int_of_string,
minor: groups[2] |> int_of_string,
point: groups[3] |> int_of_string
})
} else {
Error(Printf.sprintf("Stdout did not contain a version number for `%s --version`", cmd))
}
}
| None => Error(Printf.sprintf("Failed executing '%s'\n", cmd))
| _ => Error(Printf.sprintf("Failed executing '%s'\n", cmd))
}
};
let is_version_new_enough = (cur, needed) => {
let is_new_enough = (cur, needed) => {
switch (cur) {
| Ok(cur) => {
switch (compare_version_number(cur, needed)) {
switch (compare(cur, needed)) {
| x when x < 0 => Ok(false)
| _ => Ok(true)
}
}
| Error(e) => Error(e)
}
}
};
let preflight_versions = () => {
let in_direnv = switch (Sys.getenv("direnv")) {
let in_direnv = () => switch (Sys.getenv("direnv")) {
| Some(_) => true
| None => false
};
};
let is_nix_new_enough = is_version_new_enough(extract_version_number("nix"), required_nix_version);
let is_direnv_new_enough = is_version_new_enough(extract_version_number("direnv"), required_direnv_version);
let preflight_versions = () => {
let is_nix_new_enough = is_new_enough(extract_version_number("nix"), required_nix_version);
let is_direnv_new_enough = is_new_enough(extract_version_number("direnv"), required_direnv_version);
switch (in_direnv, is_direnv_new_enough, is_nix_new_enough) {
switch (in_direnv(), is_direnv_new_enough, is_nix_new_enough) {
| (false, _, _) => Error("Not in direnv!")
| (_, Ok(false), _) => Error("Direnv version is not new enough")
| (_, _, Ok(false)) => Error("Nix version is not new enough")

70
lib/lib.re
View file

@ -1,3 +1,73 @@
open Core;
module Unix = Core_unix;
module Util = Flake_env__util;
module Watches = Flake_env__watches;
module Versions = Flake_env__versions;
let print_cur_cache = (profile_rc) => {
In_channel.read_all(profile_rc) |> Printf.printf("%s")
};
let clean_old_gcroots = (layout_dir) => {
Util.rmrf(layout_dir ++ "/flake-inputs/");
Util.rmrf(layout_dir);
Unix.mkdir_p(layout_dir ++ "/flake-inputs/");
};
let add_gcroot = (store_path, symlink) => {
switch (Util.nix(["build", "--out-link", symlink, store_path])) {
| (Ok(), _) => Ok()
| (err, _) => err
}
};
let freshen_cache = (layout_dir, hash, flake_specifier, other_args) => {
clean_old_gcroots(layout_dir);
let tmp_profile = layout_dir ++ "flake-tmp-profile." ++ Core.Pid.to_string(Core_unix.getpid());
let pde_args = ["print-dev-env", "--profile", tmp_profile, flake_specifier, ...other_args];
let (exit_code, stdout_content) = Util.nix(pde_args);
let profile = layout_dir ++ "/flake-profile-" ++ hash;
let profile_rc = profile ++ ".rc";
switch (exit_code) {
| Ok() => {
Out_channel.with_file(~f=f=> Out_channel.output_string(f, stdout_content), profile_rc);
switch (add_gcroot(tmp_profile, profile)) {
| Ok() => {
Sys_unix.remove(tmp_profile);
let flake_input_cache_path = layout_dir ++ "/flake-inputs/"
let flake_inputs = Watches.get_input_paths();
flake_inputs |> List.iter(~f=(inpt) => {
switch (add_gcroot("/nix/store/" ++ inpt, flake_input_cache_path ++ inpt)) {
| Ok() => ()
| err => Printf.eprintf("Failed creating flake-input gcroot: %s\n", Core_unix.Exit_or_signal.to_string_hum(err));
};
});
print_cur_cache(profile_rc);
}
| err => {
Printf.eprintf("Failed creating gcroot: %s\n", Core_unix.Exit_or_signal.to_string_hum(err));
exit(1);
}
};
}
| err => {
Printf.eprintf("Failed evaluating flake: %s\n", Core_unix.Exit_or_signal.to_string_hum(err));
exit(1);
}
};
};
let preflight = (layout_directory) => {
switch (Versions.preflight_versions(), Sys_unix.is_directory(layout_directory)) {
| (Ok(_), `Yes) => Ok()
| (Ok(_), _) => {
Unix.mkdir_p(layout_directory);
Ok()
}
| (err, _) => err
}
}

7
tests/dune Normal file
View file

@ -0,0 +1,7 @@
(tests
(names
flake_env_test_versions
flake_env_test_watches
flake_env_test_util)
(instrumentation (backend bisect_ppx))
(libraries lib alcotest))

39
tests/flake_env_test_util.re Normal file
View file

@ -0,0 +1,39 @@
open Core;
module Unix = Core_unix;
open Lib.Util;
let pp_exit_or_signal = (pp_fmt) => (e) => Fmt.pf(pp_fmt, "%s", Unix.Exit_or_signal.to_string_hum(e));
let exit_or_signal_eq = (a, b) => Unix.Exit_or_signal.compare(a, b) == 0;
let testable_exit_or_signal = Alcotest.testable(pp_exit_or_signal, exit_or_signal_eq);
let test_run_process_success = () =>
Alcotest.(check(Alcotest.pair(testable_exit_or_signal, string)))(
"Returns expected",
(Ok(), ""),
run_process("true", []));
let test_run_process_failure = () =>
Alcotest.(check(Alcotest.pair(testable_exit_or_signal, string)))(
"Returns expected",
(Error(`Exit_non_zero(1)), ""),
run_process("false", []));
let test_run_process_stdout = () =>
Alcotest.(check(Alcotest.pair(testable_exit_or_signal, string)))(
"Returns expected",
(Ok(), "echoed\n"),
run_process("echo", ["echoed"]));
let () =
Alcotest.(
run(
"Watches",
[("run_process",
[
test_case("Capture's Stdout", `Quick, test_run_process_stdout),
test_case("Success", `Quick, test_run_process_success),
test_case("Failure", `Quick, test_run_process_failure),
]),
]),
);

118
tests/flake_env_test_versions.re Normal file
View file

@ -0,0 +1,118 @@
open Lib;
let test_compare_equal = () => {
let a = Versions.init(1,0,0);
Alcotest.(check(int))("equal", 0, Versions.compare(a, a))
};
let test_compare_first_major_greater = () => {
let a = Versions.init(2,0,0);
let b = Versions.init(1, 0, 0);
Alcotest.(check(int))("First major greater", 1, Versions.compare(a, b))
};
let test_compare_first_minor_greater = () => {
let a = Versions.init(1,1,0);
let b = Versions.init(1, 0, 0);
Alcotest.(check(int))("First minor greater", 1, Versions.compare(a, b))
};
let test_compare_first_point_greater = () => {
let a = Versions.init(1, 0, 1);
let b = Versions.init(1,0,0);
Alcotest.(check(int))("First point greater", 1, Versions.compare(a, b))
};
let test_compare_second_major_greater = () => {
let a = Versions.init(1,0,0);
let b = Versions.init(2, 0, 0);
Alcotest.(check(int))("Second major greater", -1, Versions.compare(a, b))
};
let test_compare_second_minor_greater = () => {
let a = Versions.init(1,0,0);
let b = Versions.init(1, 1, 0);
Alcotest.(check(int))("Second minor greater", -1, Versions.compare(a, b))
};
let test_compare_second_point_greater = () => {
let a = Versions.init(1,0,0);
let b = Versions.init(1, 0, 1);
Alcotest.(check(int))("Second point greater", -1, Versions.compare(a, b))
};
let test_ine_cur_newer = () => {
let a = Ok(Versions.init(2,0,0));
let b = Versions.init(1, 0, 0);
let ine = Versions.is_new_enough(a, b);
Alcotest.(check(bool))("Curr newer", true, ine |> Result.get_ok)
};
let test_ine_cur_older = () => {
let a = Ok(Versions.init(1,0,0));
let b = Versions.init(2, 0, 0);
let ine = Versions.is_new_enough(a, b);
Alcotest.(check(bool))("Curr older", false, ine |> Result.get_ok)
};
let test_ine_cur_equal = () => {
let a = Versions.init(1,0,0);
let ine = Versions.is_new_enough(Ok(a), a);
Alcotest.(check(bool))("Curr equal", true, ine |> Result.get_ok)
};
// TODO: figure out typing of `Alcotest.check` here.
// I think we just add a `pprint` and `equal` function, but that is verbose
// let test_ine_error = () => {
// let a = Error("foobarbaz");
// let ine = Versions.is_new_enough(a, Versions.init(1, 0, 0));
// Alcotest.(check())("Error bubbled", Error("foobarbaz"), ine)
// };
let test_in_direnv_true = () => {
Core_unix.putenv(~key="direnv", ~data="direnv");
Alcotest.(check(bool))("In direnv", true, Versions.in_direnv())
};
let test_in_direnv_false = () => {
Core_unix.unsetenv("direnv");
Alcotest.(check(bool))("Not in direnv", false, Versions.in_direnv())
};
// TODO: Test:
// * extract_version_number: impure, don't know how to get a concrete version number to test against
// * preflight_versions? impure, but m
let () =
Alcotest.(
run(
"Versions",
[
(
"compare",
[
test_case("Versions Equal", `Quick, test_compare_equal),
test_case("First Major Greater", `Quick, test_compare_first_major_greater),
test_case("First Minor Greater", `Quick, test_compare_first_minor_greater),
test_case("First Point Greater", `Quick, test_compare_first_point_greater),
test_case("Second Major Greater", `Quick, test_compare_second_major_greater),
test_case("Second Minor Greater", `Quick, test_compare_second_minor_greater),
test_case("Second Point Greater", `Quick, test_compare_second_point_greater),
],
),
(
"is_new_enough",
[
test_case("Curr Newer", `Quick, test_ine_cur_newer),
test_case("Curr Older", `Quick, test_ine_cur_older),
test_case("Curr Equal", `Quick, test_ine_cur_equal),
]
),
(
"in_direnv",
[
test_case("true", `Quick, test_in_direnv_true),
test_case("false", `Quick, test_in_direnv_false),
],
)
])
);

41
tests/flake_env_test_watches.re Normal file
View file

@ -0,0 +1,41 @@
open Lib.Watches;
let test_get_path_removes_prefix = () => {
let input = `Assoc([
("path", `String("aaaaaaaaaaabbbbb"))
]);
Alcotest.(check(string))("Prefix removed", "bbbbb", get_path(input))
};
let test_get_paths_from_doc = () => {
let input = `Assoc([
("path", `String("aaaaaaaaaaabbbbb")),
("inputs", `Assoc([
("foo", `Assoc([
("path", `String("aaaaaaaaaaaccccc")),
("inputs", `Assoc([
("bar", `Assoc([
("path", `String("aaaaaaaaaaaddddd")),
("inputs", `Assoc([]))
]))
]))
]))
]))
]);
Alcotest.(check(list(string)))("Gathers all inputs", ["bbbbb", "ccccc", "ddddd"], get_paths_from_doc(input, []))
};
let () =
Alcotest.(
run(
"Watches",
[("get_path",
[
test_case("Removes prefix", `Quick, test_get_path_removes_prefix),
]),
("get_paths_from_doc",
[
test_case("Collects all paths", `Quick, test_get_paths_from_doc),
])
]),
);