diff options
Diffstat (limited to 'tvix/glue/src/tests/tvix_tests')
4 files changed, 162 insertions, 0 deletions
diff --git a/tvix/glue/src/tests/tvix_tests/eval-okay-context-introspection.exp b/tvix/glue/src/tests/tvix_tests/eval-okay-context-introspection.exp new file mode 100644 index 000000000000..3f8905e9bd0d --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-context-introspection.exp @@ -0,0 +1 @@ +[ true true true true true true true true true true true ] diff --git a/tvix/glue/src/tests/tvix_tests/eval-okay-context-introspection.nix b/tvix/glue/src/tests/tvix_tests/eval-okay-context-introspection.nix new file mode 100644 index 000000000000..ed78112ab7eb --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-context-introspection.nix @@ -0,0 +1,72 @@ +# Contrary to the Nix tests, this one does not make any use of `builtins.appendContext` +# It's a weaker yet interesting test by abusing knowledge on how does our builtins +# performs propagation. +let + drv = derivation { + name = "fail"; + builder = "/bin/false"; + system = "x86_64-linux"; + outputs = [ "out" "foo" ]; + }; + + # `substr` propagates context, we truncate to an empty string and concatenate to the target + # to infect it with the context of `copied`. + appendContextFrom = copied: target: (builtins.substring 0 0 "${copied}") + "${target}"; + + # `split` discards (!!) contexts, we first split by `/` (there's at least one such `/` by + # virtue of `target` being a store path, i.e. starting with `$store_root/$derivation_name`) + # then, we reassemble the list into a proper string. + discardContext = target: builtins.concatStringsSep "" (builtins.split "(.*)" "${target}"); + + hasContextInAttrKeys = attrs: builtins.all builtins.hasContext (builtins.attrNames attrs); + + path = "${./eval-okay-context-introspection.nix}"; + + # This is a context-less attribute set, which should be exactly the same + # as `builtins.getContext combo-path`. + desired-context = { + "${builtins.unsafeDiscardStringContext path}" = { + path = true; + }; + "${builtins.unsafeDiscardStringContext drv.drvPath}" = { + outputs = [ "foo" "out" ]; + allOutputs = true; + }; + }; + + combo-path = "${path}${drv.outPath}${drv.foo.outPath}${drv.drvPath}"; + legit-context = builtins.getContext combo-path; + + reconstructed-path = appendContextFrom combo-path + (builtins.unsafeDiscardStringContext combo-path); + + # Eta rule for strings with context. + etaRule = str: + str == appendContextFrom + str + (builtins.unsafeDiscardStringContext str); + + etaRule' = str: + str == appendContextFrom + str + (discardContext str); + +in +[ + (!hasContextInAttrKeys desired-context) + (legit-context."${builtins.unsafeDiscardStringContext path}".path) + (legit-context."${builtins.unsafeDiscardStringContext drv.drvPath}".outputs == [ "foo" "out" ]) + # `allOutputs` is present only on DrvClosure-style context string, i.e. the + # context string of a drvPath itself, not an outPath. + (!builtins.hasAttr "allOutputs" (builtins.getContext drv.outPath)."${builtins.unsafeDiscardStringContext drv.drvPath}") + (builtins.hasAttr "allOutputs" legit-context."${builtins.unsafeDiscardStringContext drv.drvPath}") + (builtins.hasAttr "allOutputs" (builtins.getContext drv.drvPath)."${builtins.unsafeDiscardStringContext drv.drvPath}") + (legit-context == desired-context) # FIXME(raitobezarius): this should not use `builtins.seq`, this is a consequence of excessive laziness of Tvix, I believe. + (reconstructed-path == combo-path) + # Those are too slow? + # (etaRule' "foo") + # (etaRule' combo-path) + (etaRule "foo") + (etaRule drv.drvPath) + (etaRule drv.foo.outPath) +] diff --git a/tvix/glue/src/tests/tvix_tests/eval-okay-context-propagation.exp b/tvix/glue/src/tests/tvix_tests/eval-okay-context-propagation.exp new file mode 100644 index 000000000000..71c6ded40612 --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-context-propagation.exp @@ -0,0 +1 @@ +[ true true true true true true true true true true true true true true true true true true true true true true true true true true ] diff --git a/tvix/glue/src/tests/tvix_tests/eval-okay-context-propagation.nix b/tvix/glue/src/tests/tvix_tests/eval-okay-context-propagation.nix new file mode 100644 index 000000000000..67f0ac46729b --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-context-propagation.nix @@ -0,0 +1,88 @@ +# We test various propagation of contexts under other builtins here. +let + drv = derivation { + name = "fail"; + builder = "/bin/false"; + system = "x86_64-linux"; + outputs = [ "out" "foo" ]; + }; + other-drv = derivation { + name = "other-fail"; + builder = "/bin/false"; + system = "x86_64-linux"; + outputs = [ "out" "bar" ]; + }; + + # `substr` propagates context, we truncate to an empty string and concatenate to the target + # to infect it with the context of `copied`. + appendContextFrom = copied: target: (builtins.substring 0 0 copied) + target; + + path = "${./eval-okay-context-introspection.nix}"; + + combo-path = "${path}${drv.outPath}${drv.foo.outPath}${drv.drvPath}"; + + mergeContext = a: b: + builtins.getContext a // builtins.getContext b; + + preserveContext = origin: result: + builtins.getContext "${result}" == builtins.getContext "${origin}"; + + preserveContexts = origins: result: + let union = builtins.foldl' (x: y: x // y) { } (builtins.map (d: builtins.getContext "${d}") origins); + in + union == builtins.getContext "${result}"; +in +[ + # `toFile` should produce context. + (builtins.hasContext "${(builtins.toFile "myself" "${./eval-okay-context-introspection.nix}")}") + # `derivation` should produce context. + (builtins.hasContext "${drv}") + # Low-level test to ensure that interpolation is working as expected. + (builtins.length (builtins.attrNames (builtins.getContext "${drv}${other-drv}")) == 2) + (builtins.getContext "${drv}${other-drv}" == mergeContext drv other-drv) + # Those three next tests are extremely related. + # To test interpolation, we need concatenation to be working and vice versa. + # In addition, we need `builtins.substring` empty string propagation to attach context + # in absence of `builtins.appendContext`. + # The previous test should ensure that we don't test vacuous truths. + # Substring preserves contexts. + (preserveContext combo-path (builtins.substring 0 0 combo-path)) # <- FIXME: broken + # Interpolation preserves contexts. + (preserveContext "${drv}${other-drv}" (appendContextFrom drv other-drv)) + # Concatenation preserves contexts. + (preserveContext "${drv}${other-drv}" (drv + other-drv)) + # Special case when Nix does not assert that the length argument is non-negative + # when the starting index is ≥ than the string's length. + # FIXME: those three are broken too, NON DETERMINISTIC!!! + (preserveContext combo-path (builtins.substring 5 (-5) (builtins.substring 0 0 combo-path))) + (preserveContext combo-path (toString combo-path)) + # No replacement should yield at least the same context. + (preserveContext combo-path (builtins.replaceStrings [ ] [ ] combo-path)) + # This is an idempotent replacement, it should yield therefore to full preservation of the context. + (preserveContext "${drv}${drv}" (builtins.replaceStrings [ "${drv}" ] [ "${drv}" ] "${drv}")) + # There's no context here, so no context should appear from `drv`. + (preserveContext "abc" (builtins.replaceStrings [ "${drv}" ] [ "${drv}" ] "abc")) + # Context should appear by a successful replacement. + (preserveContext "${drv}" (builtins.replaceStrings [ "a" ] [ "${drv}" ] "a")) + # We test multiple successful replacements. + (preserveContexts [ drv other-drv ] (builtins.replaceStrings [ "a" "b" ] [ "${drv}" "${other-drv}" ] "ab")) + # We test *empty* string replacements. + (preserveContext "${drv}" (builtins.replaceStrings [ "" ] [ "${drv}" ] "abc")) + (preserveContext "${drv}" (builtins.replaceStrings [ "" ] [ "${drv}" ] "")) + # There should be no context in a parsed derivation name. + (!builtins.any builtins.hasContext (builtins.attrValues (builtins.parseDrvName "${drv.name}"))) + # Nix does not propagate contexts for `match`. + (!builtins.any builtins.hasContext (builtins.match "(.*)" "${drv}")) + # `dirOf` preserves contexts of non-paths. + (preserveContext "${drv}" (builtins.dirOf "${drv}")) + (preserveContext "abc" (builtins.dirOf "abc")) + # `baseNameOf propagates context of argument + (preserveContext "${drv}" (builtins.baseNameOf drv)) + (preserveContext "abc" (builtins.baseNameOf "abc")) + # `concatStringsSep` preserves contexts of both arguments. + (preserveContexts [ drv other-drv ] (builtins.concatStringsSep "${other-drv}" (map toString [ drv drv drv drv drv ]))) + (preserveContext drv (builtins.concatStringsSep "|" (map toString [ drv drv drv drv drv ]))) + (preserveContext other-drv (builtins.concatStringsSep "${other-drv}" [ "abc" "def" ])) + # `attrNames` will never ever produce context. + (preserveContext "abc" (toString (builtins.attrNames { a = { }; b = { }; c = { }; }))) +] |