diff options
Diffstat (limited to 'nixpkgs/pkgs/build-support/trivial-builders/test')
14 files changed, 713 insertions, 0 deletions
diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/concat-test.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/concat-test.nix new file mode 100644 index 000000000000..5ce435619069 --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/concat-test.nix @@ -0,0 +1,12 @@ +{ callPackage, lib, pkgs, runCommand, concatText, writeText, hello, emptyFile }: +let + stri = writeText "pathToTest"; + txt1 = stri "abc"; + txt2 = stri hello; + res = concatText "textToTest" [ txt1 txt2 ]; +in +runCommand "test-concatPaths" { } '' + diff -U3 <(cat ${txt1} ${txt2}) ${res} + diff -U3 ${concatText "void" []} ${emptyFile} + touch $out +'' diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/default.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/default.nix new file mode 100644 index 000000000000..e1ed0be72bf3 --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/default.nix @@ -0,0 +1,36 @@ +/* + Run all tests with: + + cd nixpkgs + nix-build -A tests.trivial-builders + + or run a specific test with: + + cd nixpkgs + nix-build -A tests.trivial-builders.foo + +*/ + +{ callPackage, lib, stdenv }: +let + inherit (lib) recurseIntoAttrs; + references = callPackage ./references {}; +in +recurseIntoAttrs { + concat = callPackage ./concat-test.nix {}; + linkFarm = callPackage ./link-farm.nix {}; + overriding = callPackage ../test-overriding.nix {}; + inherit references; + writeCBin = callPackage ./writeCBin.nix {}; + writeClosure-union = callPackage ./writeClosure-union.nix { + inherit (references) samples; + }; + writeShellApplication = callPackage ./writeShellApplication.nix {}; + writeScriptBin = callPackage ./writeScriptBin.nix {}; + writeShellScript = callPackage ./write-shell-script.nix {}; + writeShellScriptBin = callPackage ./writeShellScriptBin.nix {}; + writeStringReferencesToFile = callPackage ./writeStringReferencesToFile.nix { + inherit (references) samples; + }; + writeTextFile = callPackage ./write-text-file.nix {}; +} diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/link-farm.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/link-farm.nix new file mode 100644 index 000000000000..1ebfc707632f --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/link-farm.nix @@ -0,0 +1,45 @@ +{ linkFarm, hello, writeTextFile, runCommand }: +let + foo = writeTextFile { + name = "foo"; + text = "foo"; + }; + + linkFarmFromList = linkFarm "linkFarmFromList" [ + { name = "foo"; path = foo; } + { name = "hello"; path = hello; } + ]; + + linkFarmWithRepeats = linkFarm "linkFarmWithRepeats" [ + { name = "foo"; path = foo; } + { name = "hello"; path = hello; } + { name = "foo"; path = hello; } + ]; + + linkFarmFromAttrs = linkFarm "linkFarmFromAttrs" { + inherit foo hello; + }; +in +runCommand "test-linkFarm" { } '' + function assertPathEquals() { + local a b; + a="$(realpath "$1")" + b="$(realpath "$2")" + if [ "$a" != "$b" ]; then + echo "path mismatch!" + echo "a: $1 -> $a" + echo "b: $2 -> $b" + exit 1 + fi + } + + assertPathEquals "${linkFarmFromList}/foo" "${foo}" + assertPathEquals "${linkFarmFromList}/hello" "${hello}" + + assertPathEquals "${linkFarmWithRepeats}/foo" "${hello}" + assertPathEquals "${linkFarmWithRepeats}/hello" "${hello}" + + assertPathEquals "${linkFarmFromAttrs}/foo" "${foo}" + assertPathEquals "${linkFarmFromAttrs}/hello" "${hello}" + touch $out +'' diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/references/default.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/references/default.nix new file mode 100644 index 000000000000..85df57ea210c --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/references/default.nix @@ -0,0 +1,135 @@ +{ lib +, stdenvNoCC +, testers +, callPackage +, writeText + # nativeBuildInputs +, shellcheck-minimal + # Samples +, samples ? cleanSamples (callPackage ./samples.nix { }) + # Filter out the non-string-like attributes such as <pkg>.override added by + # callPackage. +, cleanSamples ? lib.filterAttrs (n: lib.isStringLike) + # Test targets +, writeDirectReferencesToFile +, writeClosure +}: + +# -------------------------------------------------------------------------- # +# +# trivial-builders test +# +# -------------------------------------------------------------------------- # +# +# Execute this build script directly (quick): +# +# * Classic +# $ NIX_PATH="nixpkgs=$PWD" nix-shell -p tests.trivial-builders.references.testScriptBin --run references-test +# +# * Flake-based +# $ nix run .#tests.trivial-builders.references.testScriptBin +# +# or in the build sandbox with a ~20s VM overhead: +# +# * Classic +# $ nix-build --no-out-link -A tests.trivial-builders.references +# +# * Flake-based +# $ nix build -L --no-link .#tests.trivial-builders.references +# +# -------------------------------------------------------------------------- # + +let + # Map each attribute to an element specification of Bash associative arrary + # and concatenate them with white spaces, to be used to define a + # one-line Bash associative array. + samplesToString = attrs: + lib.concatMapStringsSep " " (name: "[${name}]=${lib.escapeShellArg "${attrs.${name}}"}") (builtins.attrNames attrs); + + closures = lib.mapAttrs (n: v: writeClosure [ v ]) samples; + directReferences = lib.mapAttrs (n: v: writeDirectReferencesToFile v) samples; + collectiveClosure = writeClosure (lib.attrValues samples); + + testScriptBin = stdenvNoCC.mkDerivation (finalAttrs: { + name = "references-test"; + + src = ./references-test.sh; + dontUnpack = true; + dontBuild = true; + + installPhase = '' + runHook preInstall + mkdir -p "$out/bin" + substitute "$src" "$out/bin/${finalAttrs.meta.mainProgram}" \ + --replace "@SAMPLES@" ${lib.escapeShellArg (samplesToString samples)} \ + --replace "@CLOSURES@" ${lib.escapeShellArg (samplesToString closures)} \ + --replace "@DIRECT_REFS@" ${lib.escapeShellArg (samplesToString directReferences)} \ + --replace "@COLLECTIVE_CLOSURE@" ${lib.escapeShellArg collectiveClosure} + runHook postInstall + chmod +x "$out/bin/${finalAttrs.meta.mainProgram}" + ''; + + doInstallCheck = true; + nativeInstallCheckInputs = [ + shellcheck-minimal + ]; + installCheckPhase = '' + runHook preInstallCheck + shellcheck "$out/bin/${finalAttrs.meta.mainProgram}" + runHook postInstallCheck + ''; + + passthru = { + inherit + collectiveClosure + directReferences + closures + samples + ; + }; + + meta = with lib; { + mainProgram = "references-test"; + }; + }); +in +testers.runNixOSTest ({ config, lib, ... }: +let + # Use the testScriptBin from guest pkgs. + # The attribute path to access the guest version of testScriptBin is + # tests.trivial-builders.references.config.node.pkgs.tests.trivial-builders.references.testScriptBin + # which is why passthru.guestTestScriptBin is provided. + guestTestScriptBin = config.node.pkgs.tests.trivial-builders.references.testScriptBin; +in +{ + name = "nixpkgs-trivial-builders-references"; + nodes.machine = { config, lib, pkgs, ... }: { + virtualisation.writableStore = true; + + # Test runs without network, so we don't substitute and prepare our deps + nix.settings.substituters = lib.mkForce [ ]; + system.extraDependencies = [ guestTestScriptBin ]; + }; + testScript = + '' + machine.succeed(""" + ${lib.getExe guestTestScriptBin} 2>/dev/console + """) + ''; + passthru = { + inherit + collectiveClosure + directReferences + closures + samples + testScriptBin + ; + inherit guestTestScriptBin; + }; + meta = { + maintainers = with lib.maintainers; [ + roberth + ShamrockLee + ]; + }; +}) diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/references/references-test.sh b/nixpkgs/pkgs/build-support/trivial-builders/test/references/references-test.sh new file mode 100755 index 000000000000..92e4467287ed --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/references/references-test.sh @@ -0,0 +1,68 @@ +#!/usr/bin/env bash + +# -------------------------------------------------------------------------- # +# +# trivial-builders test +# +# -------------------------------------------------------------------------- # +# +# Execute this build script directly (quick): +# +# * Classic +# $ NIX_PATH="nixpkgs=$PWD" nix-shell -p tests.trivial-builders.references.testScriptBin --run references-test +# +# * Flake-based +# $ nix run .#tests.trivial-builders.references.testScriptBin +# +# or in the build sandbox with a ~20s VM overhead: +# +# * Classic +# $ nix-build --no-out-link -A tests.trivial-builders.references +# +# * Flake-based +# $ nix build -L --no-link .#tests.trivial-builders.references +# +# -------------------------------------------------------------------------- # + +# strict bash +set -euo pipefail + +# debug +# set -x +# PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }' + +cd "$(dirname "${BASH_SOURCE[0]}")" # nixpkgs root + + # Inject the path to compare from the Nix expression + + # Associative Arrays + declare -A samples=( @SAMPLES@ ) + declare -A directRefs=( @DIRECT_REFS@ ) + declare -A closures=( @CLOSURES@ ) + + # Path string + collectiveClosure=@COLLECTIVE_CLOSURE@ + +echo >&2 Testing direct closures... +for i in "${!samples[@]}"; do + echo >&2 Checking "$i" "${samples[$i]}" "${directRefs[$i]}" + diff -U3 \ + <(sort <"${directRefs[$i]}") \ + <(nix-store -q --references "${samples[$i]}" | sort) +done + +echo >&2 Testing closure... +for i in "${!samples[@]}"; do + echo >&2 Checking "$i" "${samples[$i]}" "${closures[$i]}" + diff -U3 \ + <(sort <"${closures[$i]}") \ + <(nix-store -q --requisites "${samples[$i]}" | sort) +done + +echo >&2 Testing mixed closures... +echo >&2 Checking all samples "(${samples[*]})" "$collectiveClosure" +diff -U3 \ + <(sort <"$collectiveClosure") \ + <(nix-store -q --requisites "${samples[@]}" | sort) + +echo 'OK!' diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/references/samples.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/references/samples.nix new file mode 100644 index 000000000000..3afb970c08ae --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/references/samples.nix @@ -0,0 +1,30 @@ +{ lib +, runCommand +, writeText +, emptyFile +, emptyDirectory +, figlet +, hello +, zlib +}: +{ + inherit + figlet + hello + zlib + ; + zlib-dev = zlib.dev; + norefs = writeText "hi" "hello"; + norefsDup = writeText "hi" "hello"; + helloRef = writeText "hi" "hello ${hello}"; + helloRefDup = writeText "hi" "hello ${hello}"; + path = ./samples.nix; + pathLike.outPath = ./samples.nix; + helloFigletRef = writeText "hi" "hello ${hello} ${figlet}"; + selfRef = runCommand "self-ref-1" { } "echo $out >$out"; + selfRef2 = runCommand "self-ref-2" { } ''echo "${figlet}, $out" >$out''; + inherit + emptyFile + emptyDirectory + ; +} diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/write-shell-script.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/write-shell-script.nix new file mode 100644 index 000000000000..a5c9f1fae42f --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/write-shell-script.nix @@ -0,0 +1,14 @@ +{ lib, writeShellScript }: let + output = "hello"; +in (writeShellScript "test-script" '' + echo ${lib.escapeShellArg output} +'').overrideAttrs (old: { + checkPhase = old.checkPhase or "" + '' + expected=${lib.escapeShellArg output} + got=$("$target") + if [[ "$got" != "$expected" ]]; then + echo "wrong output: expected $expected, got $got" + exit 1 + fi + ''; +}) diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/write-text-file.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/write-text-file.nix new file mode 100644 index 000000000000..2e6685c1980b --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/write-text-file.nix @@ -0,0 +1,71 @@ +/* + To run: + + cd nixpkgs + nix-build -A tests.trivial-builders.writeTextFile + + or to run an individual test case + + cd nixpkgs + nix-build -A tests.trivial-builders.writeTextFile.foo +*/ +{ lib, runCommand, runtimeShell, writeTextFile }: +let + veryWeirdName = ''here's a name with some "bad" characters, like spaces and quotes''; +in +lib.recurseIntoAttrs { + + different-exe-name = + let + pkg = writeTextFile { + name = "bar"; + destination = "/bin/foo"; + executable = true; + text = '' + #!${runtimeShell} + echo hi + ''; + }; + in + assert pkg.meta.mainProgram == "foo"; + assert baseNameOf (lib.getExe pkg) == "foo"; + assert pkg.name == "bar"; + runCommand "test-writeTextFile-different-exe-name" {} '' + PATH="${lib.makeBinPath [ pkg ]}:$PATH" + x=$(foo) + [[ "$x" == hi ]] + touch $out + ''; + + weird-name = writeTextFile { + name = "weird-names"; + destination = "/etc/${veryWeirdName}"; + text = ''passed!''; + checkPhase = '' + # intentionally hardcode everything here, to make sure + # Nix does not mess with file paths + + name="here's a name with some \"bad\" characters, like spaces and quotes" + fullPath="$out/etc/$name" + + if [ -f "$fullPath" ]; then + echo "[PASS] File exists!" + else + echo "[FAIL] File was not created at expected path!" + exit 1 + fi + + content=$(<"$fullPath") + expected="passed!" + + if [ "$content" = "$expected" ]; then + echo "[PASS] Contents match!" + else + echo "[FAIL] File contents don't match!" + echo " Expected: $expected" + echo " Got: $content" + exit 2 + fi + ''; + }; +} diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/writeCBin.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/writeCBin.nix new file mode 100644 index 000000000000..56cab45b3801 --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/writeCBin.nix @@ -0,0 +1,43 @@ +/* + Run with: + + cd nixpkgs + nix-build -A tests.trivial-builders.writeCBin +*/ + +{ lib, writeCBin, runCommand }: +let + output = "hello"; + pkg = writeCBin "test-script" '' + #include <stdio.h> + int main () { + printf("hello\n"); + return 0; + } + ''; +in + assert pkg.meta.mainProgram == "test-script"; + runCommand "test-writeCBin" { } '' + + echo Testing with getExe... + + target=${lib.getExe pkg} + expected=${lib.escapeShellArg output} + got=$("$target") + if [[ "$got" != "$expected" ]]; then + echo "wrong output: expected $expected, got $got" + exit 1 + fi + + echo Testing with makeBinPath... + + PATH="${lib.makeBinPath [ pkg ]}:$PATH" + got=$(test-script) + if [[ "$got" != "$expected" ]]; then + echo "wrong output: expected $expected, got $got" + exit 1 + fi + + touch $out + '' + diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/writeClosure-union.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/writeClosure-union.nix new file mode 100644 index 000000000000..92a2bf9f0988 --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/writeClosure-union.nix @@ -0,0 +1,23 @@ +{ lib +, runCommandLocal + # Test targets +, writeClosure +, samples +}: +runCommandLocal "test-trivial-builders-writeClosure-union" { + __structuredAttrs = true; + closures = lib.mapAttrs (n: v: writeClosure [ v ]) samples; + collectiveClosure = writeClosure (lib.attrValues samples); + inherit samples; + meta.maintainers = with lib.maintainers; [ + ShamrockLee + ]; +} '' + set -eu -o pipefail + echo >&2 Testing mixed closures... + echo >&2 Checking all samples "(''${samples[*]})" "$collectiveClosure" + diff -U3 \ + <(sort <"$collectiveClosure") \ + <(cat "''${closures[@]}" | sort | uniq) + touch "$out" +'' diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/writeScriptBin.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/writeScriptBin.nix new file mode 100644 index 000000000000..1487443130da --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/writeScriptBin.nix @@ -0,0 +1,39 @@ +/* + Run with: + + cd nixpkgs + nix-build -A tests.trivial-builders.writeShellScriptBin +*/ + +{ lib, writeScriptBin, runCommand }: +let + output = "hello"; + pkg = writeScriptBin "test-script" '' + echo ${lib.escapeShellArg output} + ''; +in + assert pkg.meta.mainProgram == "test-script"; + runCommand "test-writeScriptBin" { } '' + + echo Testing with getExe... + + target=${lib.getExe pkg} + expected=${lib.escapeShellArg output} + got=$("$target") + if [[ "$got" != "$expected" ]]; then + echo "wrong output: expected $expected, got $got" + exit 1 + fi + + echo Testing with makeBinPath... + + PATH="${lib.makeBinPath [ pkg ]}:$PATH" + got=$(test-script) + if [[ "$got" != "$expected" ]]; then + echo "wrong output: expected $expected, got $got" + exit 1 + fi + + touch $out + '' + diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/writeShellApplication.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/writeShellApplication.nix new file mode 100644 index 000000000000..c50f5a4d283f --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/writeShellApplication.nix @@ -0,0 +1,141 @@ +# Run with: +# nix-build -A tests.trivial-builders.writeShellApplication +{ writeShellApplication +, writeTextFile +, runCommand +, lib +, linkFarm +, diffutils +, hello +}: +let + checkShellApplication = args@{name, expected, ...}: + let + writeShellApplicationArgs = builtins.removeAttrs args ["expected"]; + script = writeShellApplication writeShellApplicationArgs; + executable = lib.getExe script; + expected' = writeTextFile { + name = "${name}-expected"; + text = expected; + }; + actual = "${name}-actual"; + in + runCommand name { } '' + echo "Running test executable ${name}" + ${executable} > ${actual} + echo "Got output from test executable:" + cat ${actual} + echo "Checking test output against expected output:" + ${diffutils}/bin/diff --color --unified ${expected'} ${actual} + touch $out + ''; +in +linkFarm "writeShellApplication-tests" { + test-meta = + let + script = writeShellApplication { + name = "test-meta"; + text = ""; + meta.description = "A test for the `writeShellApplication` `meta` argument."; + }; + in + assert script.meta.mainProgram == "test-meta"; + assert script.meta.description == "A test for the `writeShellApplication` `meta` argument."; + script; + + test-runtime-inputs = + checkShellApplication { + name = "test-runtime-inputs"; + text = '' + hello + ''; + runtimeInputs = [ hello ]; + expected = "Hello, world!\n"; + }; + + test-runtime-env = + checkShellApplication { + name = "test-runtime-env"; + runtimeEnv = { + MY_COOL_ENV_VAR = "my-cool-env-value"; + MY_OTHER_COOL_ENV_VAR = "my-other-cool-env-value"; + # Check that we can serialize a bunch of different types: + BOOL = true; + INT = 1; + LIST = [1 2 3]; + MAP = { + a = "a"; + b = "b"; + }; + }; + text = '' + echo "$MY_COOL_ENV_VAR" + echo "$MY_OTHER_COOL_ENV_VAR" + ''; + expected = '' + my-cool-env-value + my-other-cool-env-value + ''; + }; + + test-check-phase = + checkShellApplication { + name = "test-check-phase"; + text = ""; + checkPhase = '' + echo "echo -n hello" > $target + ''; + expected = "hello"; + }; + + test-argument-forwarding = + checkShellApplication { + name = "test-argument-forwarding"; + text = ""; + derivationArgs.MY_BUILD_TIME_VARIABLE = "puppy"; + derivationArgs.postCheck = '' + if [[ "$MY_BUILD_TIME_VARIABLE" != puppy ]]; then + echo "\$MY_BUILD_TIME_VARIABLE is not set to 'puppy'!" + exit 1 + fi + ''; + meta.description = "A test checking that `writeShellApplication` forwards extra arguments to `stdenv.mkDerivation`."; + expected = ""; + }; + + test-exclude-shell-checks = writeShellApplication { + name = "test-exclude-shell-checks"; + excludeShellChecks = [ "SC2016" ]; + text = '' + # Triggers SC2016: Expressions don't expand in single quotes, use double + # quotes for that. + echo '$SHELL' + ''; + }; + + test-bash-options-pipefail = checkShellApplication { + name = "test-bash-options-pipefail"; + text = '' + touch my-test-file + echo puppy | grep doggy | sed 's/doggy/puppy/g' + # ^^^^^^^^^^ This will fail. + true + ''; + # Don't use `pipefail`: + bashOptions = ["errexit" "nounset"]; + expected = ""; + }; + + test-bash-options-nounset = checkShellApplication { + name = "test-bash-options-nounset"; + text = '' + echo -n "$someUndefinedVariable" + ''; + # Don't use `nounset`: + bashOptions = []; + # Don't warn about the undefined variable at build time: + excludeShellChecks = [ "SC2154" ]; + expected = ""; + }; + +} diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/writeShellScriptBin.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/writeShellScriptBin.nix new file mode 100644 index 000000000000..e93410e25bcb --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/writeShellScriptBin.nix @@ -0,0 +1,39 @@ +/* + Run with: + + cd nixpkgs + nix-build -A tests.trivial-builders.writeShellScriptBin +*/ + +{ lib, writeShellScriptBin, runCommand }: +let + output = "hello"; + pkg = writeShellScriptBin "test-script" '' + echo ${lib.escapeShellArg output} + ''; +in + assert pkg.meta.mainProgram == "test-script"; + runCommand "test-writeShellScriptBin" { } '' + + echo Testing with getExe... + + target=${lib.getExe pkg} + expected=${lib.escapeShellArg output} + got=$("$target") + if [[ "$got" != "$expected" ]]; then + echo "wrong output: expected $expected, got $got" + exit 1 + fi + + echo Testing with makeBinPath... + + PATH="${lib.makeBinPath [ pkg ]}:$PATH" + got=$(test-script) + if [[ "$got" != "$expected" ]]; then + echo "wrong output: expected $expected, got $got" + exit 1 + fi + + touch $out + '' + diff --git a/nixpkgs/pkgs/build-support/trivial-builders/test/writeStringReferencesToFile.nix b/nixpkgs/pkgs/build-support/trivial-builders/test/writeStringReferencesToFile.nix new file mode 100644 index 000000000000..dedd7e183a17 --- /dev/null +++ b/nixpkgs/pkgs/build-support/trivial-builders/test/writeStringReferencesToFile.nix @@ -0,0 +1,17 @@ +{ callPackage, lib, pkgs, runCommand, samples, writeText, writeStringReferencesToFile }: +let + samplePaths = lib.unique (lib.attrValues samples); + stri = x: "${x}"; + sampleText = writeText "sample-text" (lib.concatStringsSep "\n" (lib.unique (map stri samplePaths))); + stringReferencesText = + writeStringReferencesToFile + ((lib.concatMapStringsSep "fillertext" + stri + (lib.attrValues samples)) + '' + STORE=${builtins.storeDir};\nsystemctl start bar-foo.service + ''); +in +runCommand "test-writeStringReferencesToFile" { } '' + diff -U3 <(sort ${stringReferencesText}) <(sort ${sampleText}) + touch $out +'' |