forked from auxolotl/labs
Austreelis
866b8902c9
I figure it's a simple typo. This test expects entries `"a"`, `"b"`, `"c"`, `"d"` to be lexicographically sorted but fails. The actual result is that entries are sorted in this order: `c, b, a, d`. This is because the test adds the entry `"b" = lib.dag.entry.between [ "c" ] [ "a" ] "b"`, i.e. after `"c"` and before `"a"`. I haven't checked if it was a logic error in the sort implementation, as other pieces of labs rely on it (and use `lib.dag.entry.between` with the arguments flipped relative to the test, which makes sense), and the arguments of the function `lib.dag.entry.between` are named "after", *then* "before". Co-authored-by: Austreelis <dev.austreelis@swhaele.net> Reviewed-on: auxolotl/labs#9 Reviewed-by: Jake Hamilton <jake.hamilton@hey.com> Co-authored-by: Austreelis <austreelis@noreply.git.auxolotl.org> Co-committed-by: Austreelis <austreelis@noreply.git.auxolotl.org>
160 lines
3.5 KiB
Nix
160 lines
3.5 KiB
Nix
let
|
|
lib = import ./../default.nix;
|
|
in
|
|
{
|
|
"validate" = {
|
|
"entry" = {
|
|
"invalid value" =
|
|
let
|
|
expected = false;
|
|
actual = lib.dag.validate.entry { };
|
|
in
|
|
actual == expected;
|
|
|
|
"a manually created value" =
|
|
let
|
|
expected = true;
|
|
actual = lib.dag.validate.entry {
|
|
value = null;
|
|
before = [ ];
|
|
after = [ ];
|
|
};
|
|
in
|
|
actual == expected;
|
|
|
|
"entry.between" =
|
|
let
|
|
expected = true;
|
|
actual = lib.dag.validate.entry (lib.dag.entry.between [ ] [ ] null);
|
|
in
|
|
actual == expected;
|
|
|
|
"entry.anywhere" =
|
|
let
|
|
expected = true;
|
|
actual = lib.dag.validate.entry (lib.dag.entry.anywhere null);
|
|
in
|
|
actual == expected;
|
|
|
|
"entry.before" =
|
|
let
|
|
expected = true;
|
|
actual = lib.dag.validate.entry (lib.dag.entry.before [ ] null);
|
|
in
|
|
actual == expected;
|
|
|
|
"entry.after" =
|
|
let
|
|
expected = true;
|
|
actual = lib.dag.validate.entry (lib.dag.entry.after [ ] null);
|
|
in
|
|
actual == expected;
|
|
};
|
|
|
|
"graph" = {
|
|
"invalid value" =
|
|
let
|
|
expected = false;
|
|
actual = lib.dag.validate.graph { x = { }; };
|
|
in
|
|
actual == expected;
|
|
|
|
"a manually created value" =
|
|
let
|
|
expected = true;
|
|
actual = lib.dag.validate.graph {
|
|
x = {
|
|
value = null;
|
|
before = [ ];
|
|
after = [ ];
|
|
};
|
|
};
|
|
in
|
|
actual == expected;
|
|
|
|
"entries.between" =
|
|
let
|
|
expected = true;
|
|
graph = lib.dag.entries.between "example" [ ] [ ] [
|
|
null
|
|
null
|
|
];
|
|
actual = lib.dag.validate.graph graph;
|
|
in
|
|
actual == expected;
|
|
|
|
"entries.anywhere" =
|
|
let
|
|
expected = true;
|
|
graph = lib.dag.entries.anywhere "example" [
|
|
null
|
|
null
|
|
];
|
|
actual = lib.dag.validate.graph graph;
|
|
in
|
|
actual == expected;
|
|
|
|
"entries.before" =
|
|
let
|
|
expected = true;
|
|
graph = lib.dag.entries.before "example" [ ] [
|
|
null
|
|
null
|
|
];
|
|
actual = lib.dag.validate.graph graph;
|
|
in
|
|
actual == expected;
|
|
|
|
"entries.after" =
|
|
let
|
|
expected = true;
|
|
graph = lib.dag.entries.after "example" [ ] [
|
|
null
|
|
null
|
|
];
|
|
actual = lib.dag.validate.graph graph;
|
|
in
|
|
actual == expected;
|
|
};
|
|
};
|
|
|
|
"sort" = {
|
|
"topological" = {
|
|
"handles an empty graph" =
|
|
let
|
|
expected = [ ];
|
|
actual = lib.dag.sort.topological { };
|
|
in
|
|
actual.result == expected;
|
|
|
|
"sorts a graph" =
|
|
let
|
|
expected = [
|
|
{
|
|
name = "a";
|
|
value = "a";
|
|
}
|
|
{
|
|
name = "b";
|
|
value = "b";
|
|
}
|
|
{
|
|
name = "c";
|
|
value = "c";
|
|
}
|
|
{
|
|
name = "d";
|
|
value = "d";
|
|
}
|
|
];
|
|
actual = lib.dag.sort.topological {
|
|
a = lib.dag.entry.anywhere "a";
|
|
b = lib.dag.entry.between [ "a" ] [ "c" ] "b";
|
|
c = lib.dag.entry.before [ "c" ] "c";
|
|
d = lib.dag.entry.after [ "c" ] "d";
|
|
};
|
|
in
|
|
actual.result == expected;
|
|
};
|
|
};
|
|
}
|