flake_env/tests/flake_env_test_versions.re

open Lib;

let testable_version =
  Alcotest.testable(Versions.pprint, (a, b) => Versions.compare(a, b) == 0);

let check_version =
  Alcotest.(check(Alcotest.result(testable_version, string)));

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);
};

let test_ine_error = () => {
  let a = Error("foobarbaz");
  let ine = Versions.is_new_enough(a, Versions.init(1, 0, 0));
  Alcotest.(check(Alcotest.result(bool, string)))(
    "Error bubbled",
    Error("foobarbaz"),
    ine,
  );
};

let test_in_direnv_true = () => {
  Unix.putenv("direnv", "direnv");
  Alcotest.(check(bool))("In direnv", true, Versions.in_direnv());
};

let test_in_direnv_false = () => {
  Unix.putenv("direnv", "");
  Alcotest.(check(bool))("Not in direnv", false, Versions.in_direnv());
};

let test_extract_version_number_success = () => {
  let result = Versions.extract_version_number("../tests/spit_version.sh");
  check_version("Versions", Ok(Versions.init(1, 1, 1)), result);
};

let test_extract_version_number_no_version = () => {
  let result = Versions.extract_version_number("../tests/spit_gibberish.sh");
  check_version(
    "Versions",
    Error(
      "Stdout did not contain a version number for `../tests/spit_gibberish.sh --version`",
    ),
    result,
  );
};

let test_extract_version_number_nonexistent = () => {
  let result = Versions.extract_version_number("nonexistent.sh");
  check_version(
    "Versions",
    Error("Failed executing 'nonexistent.sh'"),
    result,
  );
};

// TODO: Test:
// * 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),
            test_case("Error", `Quick, test_ine_error),
          ],
        ),
        (
          "in_direnv",
          [
            test_case("true", `Quick, test_in_direnv_true),
            test_case("false", `Quick, test_in_direnv_false),
          ],
        ),
        (
          "extract_version_number",
          [
            test_case("success", `Quick, test_extract_version_number_success),
            test_case(
              "no version number",
              `Quick,
              test_extract_version_number_no_version,
            ),
            test_case(
              "missing binary",
              `Quick,
              test_extract_version_number_nonexistent,
            ),
          ],
        ),
      ],
    )
  );