diff options
Diffstat (limited to 'tvix/glue/src/tests/tvix_tests')
10 files changed, 288 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 0000000000..a136b0035e --- /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 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 0000000000..ecd8ab0073 --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-context-introspection.nix @@ -0,0 +1,83 @@ +# 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}"); + + # Note that this should never return true for any attribute set. + hasContextInAttrKeys = attrs: builtins.any 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); + + an-str = { + a = "${drv}"; + }; + an-list = { + b = [ drv ]; + }; + + # 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) + # `toJSON` tests + (builtins.hasContext (builtins.toJSON an-str)) + (builtins.hasContext (builtins.toJSON an-list)) +] 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 0000000000..ff56f6ca18 --- /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 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 0000000000..41e7f207b9 --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-context-propagation.nix @@ -0,0 +1,119 @@ +# 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" ]; + }; + a-path-drv = builtins.path { + name = "a-path-drv"; + path = ./eval-okay-context-introspection.nix; + }; + another-path-drv = builtins.filterSource (_: true) ./eval-okay-context-introspection.nix; + + # `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}") + # `builtins.path` / `builtins.filterSource` should produce context. + (builtins.hasContext "${a-path-drv}") + (builtins.hasContext "${another-path-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 = { }; }))) + # `toJSON` preserves context of its inputs. + (preserveContexts [ drv other-drv ] (builtins.toJSON { + a = [ drv ]; + b = [ other-drv ]; + })) + (preserveContexts [ drv other-drv ] (builtins.toJSON { + a.deep = [ drv ]; + b = [ other-drv ]; + })) + (preserveContexts [ drv other-drv ] (builtins.toJSON { + a = "${drv}"; + b = [ other-drv ]; + })) + (preserveContexts [ drv other-drv ] (builtins.toJSON { + a.deep = "${drv}"; + b = [ other-drv ]; + })) + (preserveContexts [ drv other-drv ] (builtins.toJSON { + a = "${drv} ${other-drv}"; + })) + (preserveContexts [ drv other-drv ] (builtins.toJSON { + a.b.c.d.e.f = "${drv} ${other-drv}"; + })) +] diff --git a/tvix/glue/src/tests/tvix_tests/eval-okay-fetchtarball.exp b/tvix/glue/src/tests/tvix_tests/eval-okay-fetchtarball.exp new file mode 100644 index 0000000000..c7332c0503 --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-fetchtarball.exp @@ -0,0 +1 @@ +[ /nix/store/7adgvk5zdfq4pwrhsm3n9lzypb12gw0g-source /nix/store/7adgvk5zdfq4pwrhsm3n9lzypb12gw0g-source /nix/store/7adgvk5zdfq4pwrhsm3n9lzypb12gw0g-source /nix/store/7adgvk5zdfq4pwrhsm3n9lzypb12gw0g-source /nix/store/7adgvk5zdfq4pwrhsm3n9lzypb12gw0g-source /nix/store/md9dsn2zwa6aj7zzalvjwwwx82whcyva-some-name ] diff --git a/tvix/glue/src/tests/tvix_tests/eval-okay-fetchtarball.nix b/tvix/glue/src/tests/tvix_tests/eval-okay-fetchtarball.nix new file mode 100644 index 0000000000..e454f12444 --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-fetchtarball.nix @@ -0,0 +1,42 @@ +[ + # (fetchTarball "url") cannot be tested, as that one has to fetch from the + # internet to calculate the path. + + # with url and sha256 + (builtins.fetchTarball { + url = "https://github.com/NixOS/nixpkgs/archive/91050ea1e57e50388fa87a3302ba12d188ef723a.tar.gz"; + sha256 = "1hf6cgaci1n186kkkjq106ryf8mmlq9vnwgfwh625wa8hfgdn4dm"; + }) + + # with url and sha256 (as SRI) + (builtins.fetchTarball { + url = "https://github.com/NixOS/nixpkgs/archive/91050ea1e57e50388fa87a3302ba12d188ef723a.tar.gz"; + sha256 = "sha256-tRHbnoNI8SIM5O5xuxOmtSLnswEByzmnQcGGyNRjxsE="; + }) + + # with another url, it actually doesn't matter (no .gz prefix) + (builtins.fetchTarball { + url = "https://github.com/NixOS/nixpkgs/archive/91050ea1e57e50388fa87a3302ba12d188ef723a.tar"; + sha256 = "sha256-tRHbnoNI8SIM5O5xuxOmtSLnswEByzmnQcGGyNRjxsE="; + }) + + # also with an entirely different url, it doesn't change + (builtins.fetchTarball { + url = "https://test.example/owo"; + sha256 = "sha256-tRHbnoNI8SIM5O5xuxOmtSLnswEByzmnQcGGyNRjxsE="; + }) + + # … because `name` defaults to source, and that (and the sha256 affect the store path) + (builtins.fetchTarball { + name = "source"; + url = "https://test.example/owo"; + sha256 = "sha256-tRHbnoNI8SIM5O5xuxOmtSLnswEByzmnQcGGyNRjxsE="; + }) + + # … so changing name causes the hash to change. + (builtins.fetchTarball { + name = "some-name"; + url = "https://test.example/owo"; + sha256 = "sha256-tRHbnoNI8SIM5O5xuxOmtSLnswEByzmnQcGGyNRjxsE="; + }) +] diff --git a/tvix/glue/src/tests/tvix_tests/eval-okay-fetchurl.exp b/tvix/glue/src/tests/tvix_tests/eval-okay-fetchurl.exp new file mode 100644 index 0000000000..37a04d577c --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-fetchurl.exp @@ -0,0 +1 @@ +[ /nix/store/y0r1p1cqmlvm0yqkz3gxvkc1p8kg2sz8-null /nix/store/06qi00hylriyfm0nl827crgjvbax84mz-notmuch-extract-patch /nix/store/06qi00hylriyfm0nl827crgjvbax84mz-notmuch-extract-patch /nix/store/06qi00hylriyfm0nl827crgjvbax84mz-notmuch-extract-patch ] diff --git a/tvix/glue/src/tests/tvix_tests/eval-okay-fetchurl.nix b/tvix/glue/src/tests/tvix_tests/eval-okay-fetchurl.nix new file mode 100644 index 0000000000..8a39101525 --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-fetchurl.nix @@ -0,0 +1,25 @@ +[ + # (fetchurl "url") needs to immediately fetch, but our options without + # internet access are fairly limited. + # TODO: populate some fixtures at a known location instead. + (builtins.fetchurl "file:///dev/null") + + # fetchurl with url and sha256 + (builtins.fetchurl { + url = "https://raw.githubusercontent.com/aaptel/notmuch-extract-patch/f732a53e12a7c91a06755ebfab2007adc9b3063b/notmuch-extract-patch"; + sha256 = "0nawkl04sj7psw6ikzay7kydj3dhd0fkwghcsf5rzaw4bmp4kbax"; + }) + + # fetchurl with url and sha256 (as SRI) + (builtins.fetchurl { + url = "https://raw.githubusercontent.com/aaptel/notmuch-extract-patch/f732a53e12a7c91a06755ebfab2007adc9b3063b/notmuch-extract-patch"; + sha256 = "sha256-Xa1Jbl2Eq5+L0ww+Ph1osA3Z/Dxe/RkN1/dITQCdXFk="; + }) + + # fetchurl with another url, but same name + (builtins.fetchurl { + url = "https://test.example/owo"; + name = "notmuch-extract-patch"; + sha256 = "sha256-Xa1Jbl2Eq5+L0ww+Ph1osA3Z/Dxe/RkN1/dITQCdXFk="; + }) +] diff --git a/tvix/glue/src/tests/tvix_tests/eval-okay-toxml-context.exp b/tvix/glue/src/tests/tvix_tests/eval-okay-toxml-context.exp new file mode 100644 index 0000000000..e9600ecdad --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-toxml-context.exp @@ -0,0 +1 @@ +[ { "/nix/store/y1s2fiq89v2h9vkb38w508ir20dwv6v2-test.drv" = { allOutputs = true; }; } false ] diff --git a/tvix/glue/src/tests/tvix_tests/eval-okay-toxml-context.nix b/tvix/glue/src/tests/tvix_tests/eval-okay-toxml-context.nix new file mode 100644 index 0000000000..933aa46022 --- /dev/null +++ b/tvix/glue/src/tests/tvix_tests/eval-okay-toxml-context.nix @@ -0,0 +1,14 @@ +[ + # builtins.toXML retains context where there is. + (builtins.getContext (builtins.toXML { + inherit (derivation { + name = "test"; + builder = "/bin/sh"; + system = builtins.currentSystem; + }) drvPath; + })) + + # this should have no context. + (builtins.hasContext + (builtins.toXML { })) +] |