pkgs/build-support/testers/test/default.nix

   1 { testers, lib, pkgs, hello, runCommand, emptyFile, emptyDirectory, ... }:
   2 let
   3   pkgs-with-overlay = pkgs.extend(final: prev: {
   4     proof-of-overlay-hello = prev.hello;
   5   });
   6
   7   dummyVersioning = {
   8     revision = "test";
   9     versionSuffix = "test";
  10     label = "test";
  11   };
  12
  13 in
  14 lib.recurseIntoAttrs {
  15   lycheeLinkCheck = lib.recurseIntoAttrs pkgs.lychee.tests;
  16
  17   hasPkgConfigModules = pkgs.callPackage ../hasPkgConfigModules/tests.nix { };
  18
  19   shellcheck = pkgs.callPackage ../shellcheck/tests.nix { };
  20
  21   runCommand = lib.recurseIntoAttrs {
  22     bork = pkgs.python3Packages.bork.tests.pytest-network;
  23
  24     dns-resolution = testers.runCommand {
  25       name = "runCommand-dns-resolution-test";
  26       nativeBuildInputs = [ pkgs.ldns ];
  27       script = ''
  28         drill example.com
  29         touch $out
  30       '';
  31     };
  32
  33     nonDefault-hash = testers.runCommand {
  34       name = "runCommand-nonDefaultHash-test";
  35       script = ''
  36         mkdir $out
  37         touch $out/empty
  38         echo aaaaaaaaaaicjnrkeflncmrlk > $out/keymash
  39       '';
  40       hash = "sha256-eMy+6bkG+KS75u7Zt4PM3APhtdVd60NxmBRN5GKJrHs=";
  41     };
  42   };
  43
  44   runNixOSTest-example = pkgs-with-overlay.testers.runNixOSTest ({ lib, ... }: {
  45     name = "runNixOSTest-test";
  46     nodes.machine = { pkgs, ... }: {
  47       system.nixos = dummyVersioning;
  48       environment.systemPackages = [ pkgs.proof-of-overlay-hello pkgs.figlet ];
  49     };
  50     testScript = ''
  51       machine.succeed("hello | figlet >/dev/console")
  52     '';
  53   });
  54
  55   # Check that the wiring of nixosTest is correct.
  56   # Correct operation of the NixOS test driver should be asserted elsewhere.
  57   nixosTest-example = pkgs-with-overlay.testers.nixosTest ({ lib, ... }: {
  58     name = "nixosTest-test";
  59     nodes.machine = { pkgs, ... }: {
  60       system.nixos = dummyVersioning;
  61       environment.systemPackages = [ pkgs.proof-of-overlay-hello pkgs.figlet ];
  62     };
  63     testScript = ''
  64       machine.succeed("hello | figlet >/dev/console")
  65     '';
  66   });
  67
  68   testBuildFailure = lib.recurseIntoAttrs {
  69     happy = runCommand "testBuildFailure-happy" {
  70       failed = testers.testBuildFailure (runCommand "fail" {} ''
  71         echo ok-ish >$out
  72
  73         echo failing though
  74         echo also stderr 1>&2
  75         echo 'line\nwith-\bbackslashes'
  76         printf "incomplete line - no newline"
  77
  78         exit 3
  79       '');
  80     } ''
  81       grep -F 'ok-ish' $failed/result
  82
  83       grep -F 'failing though' $failed/testBuildFailure.log
  84       grep -F 'also stderr' $failed/testBuildFailure.log
  85       grep -F 'line\nwith-\bbackslashes' $failed/testBuildFailure.log
  86       grep -F 'incomplete line - no newline' $failed/testBuildFailure.log
  87
  88       [[ 3 = $(cat $failed/testBuildFailure.exit) ]]
  89
  90       touch $out
  91     '';
  92
  93     helloDoesNotFail = runCommand "testBuildFailure-helloDoesNotFail" {
  94       failed = testers.testBuildFailure (testers.testBuildFailure hello);
  95
  96       # Add hello itself as a prerequisite, so we don't try to run this test if
  97       # there's an actual failure in hello.
  98       inherit hello;
  99     } ''
 100       echo "Checking $failed/testBuildFailure.log"
 101       grep -F 'testBuildFailure: The builder did not fail, but a failure was expected' $failed/testBuildFailure.log >/dev/null
 102       [[ 1 = $(cat $failed/testBuildFailure.exit) ]]
 103       touch $out
 104       echo 'All good.'
 105     '';
 106
 107     multiOutput = runCommand "testBuildFailure-multiOutput" {
 108       failed = testers.testBuildFailure (runCommand "fail" {
 109         # dev will be the default output
 110         outputs = ["dev" "doc" "out"];
 111       } ''
 112         echo i am failing
 113         exit 1
 114       '');
 115     } ''
 116       grep -F 'i am failing' $failed/testBuildFailure.log >/dev/null
 117       [[ 1 = $(cat $failed/testBuildFailure.exit) ]]
 118
 119       # Checking our note that dev is the default output
 120       echo $failed/_ | grep -- '-dev/_' >/dev/null
 121       echo 'All good.'
 122       touch $out
 123     '';
 124   };
 125
 126   testEqualContents = lib.recurseIntoAttrs {
 127     equalDir = testers.testEqualContents {
 128       assertion = "The same directory contents at different paths are recognized as equal";
 129       expected = runCommand "expected" { } ''
 130         mkdir -p -- "$out/c"
 131         echo a >"$out/a"
 132         echo b >"$out/b"
 133         echo d >"$out/c/d"
 134         echo e >"$out/e"
 135         chmod a+x -- "$out/e"
 136       '';
 137       actual = runCommand "actual" { } ''
 138         mkdir -p -- "$out/c"
 139         echo a >"$out/a"
 140         echo b >"$out/b"
 141         echo d >"$out/c/d"
 142         echo e >"$out/e"
 143         chmod a+x -- "$out/e"
 144       '';
 145     };
 146
 147     fileMissing = testers.testBuildFailure (
 148       testers.testEqualContents {
 149         assertion = "Directories with different file list are not recognized as equal";
 150         expected = runCommand "expected" { } ''
 151           mkdir -p -- "$out/c"
 152           echo a >"$out/a"
 153           echo b >"$out/b"
 154           echo d >"$out/c/d"
 155         '';
 156         actual = runCommand "actual" { } ''
 157           mkdir -p -- "$out/c"
 158           echo a >"$out/a"
 159           echo d >"$out/c/d"
 160         '';
 161       }
 162     );
 163
 164     equalExe = testers.testEqualContents {
 165       assertion = "The same executable file contents at different paths are recognized as equal";
 166       expected = runCommand "expected" { } ''
 167         echo test >"$out"
 168         chmod a+x -- "$out"
 169       '';
 170       actual = runCommand "actual" { } ''
 171         echo test >"$out"
 172         chmod a+x -- "$out"
 173       '';
 174     };
 175
 176     unequalExe = testers.testBuildFailure (
 177       testers.testEqualContents {
 178         assertion = "Different file mode bits are not recognized as equal";
 179         expected = runCommand "expected" { } ''
 180           touch -- "$out"
 181           chmod a+x -- "$out"
 182         '';
 183         actual = runCommand "actual" { } ''
 184           touch -- "$out"
 185         '';
 186       }
 187     );
 188
 189     unequalExeInDir = testers.testBuildFailure (
 190       testers.testEqualContents {
 191         assertion = "Different file mode bits are not recognized as equal in directory";
 192         expected = runCommand "expected" { } ''
 193           mkdir -p -- "$out/a"
 194           echo b >"$out/b"
 195           chmod a+x -- "$out/b"
 196         '';
 197         actual = runCommand "actual" { } ''
 198           mkdir -p -- "$out/a"
 199           echo b >"$out/b"
 200         '';
 201       }
 202     );
 203
 204     nonExistentPath = testers.testBuildFailure (
 205       testers.testEqualContents {
 206         assertion = "Non existent paths are not recognized as equal";
 207         expected = "${emptyDirectory}/foo";
 208         actual = "${emptyDirectory}/bar";
 209       }
 210     );
 211
 212     emptyFileAndDir = testers.testBuildFailure (
 213       testers.testEqualContents {
 214         assertion = "Empty file and directory are not recognized as equal";
 215         expected = emptyFile;
 216         actual = emptyDirectory;
 217       }
 218     );
 219
 220     fileDiff =
 221       let
 222         log = testers.testBuildFailure (
 223           testers.testEqualContents {
 224             assertion = "Different files are not recognized as equal in subdirectories";
 225             expected = runCommand "expected" { } ''
 226               mkdir -p -- "$out/b"
 227               echo a >"$out/a"
 228               echo EXPECTED >"$out/b/c"
 229             '';
 230             actual = runCommand "actual" { } ''
 231               mkdir -p "$out/b"
 232               echo a >"$out/a"
 233               echo ACTUAL >"$out/b/c"
 234             '';
 235           }
 236         );
 237       in
 238       runCommand "testEqualContents-fileDiff" { inherit log; } ''
 239         (
 240           set -x
 241           # Note: use `&&` operator to chain commands because errexit (set -e)
 242           # does not work in this context (even when set explicitly and with
 243           # inherit_errexit), otherwise the subshell exits with the status of
 244           # the last run command and ignores preceding failures.
 245           grep -F -- 'Contents must be equal, but were not!' "$log/testBuildFailure.log" &&
 246           grep -E -- '\+\+\+ .*-expected/b/c' "$log/testBuildFailure.log" &&
 247           grep -E -- '--- .*-actual/b/c' "$log/testBuildFailure.log" &&
 248           grep -F -- -ACTUAL "$log/testBuildFailure.log" &&
 249           grep -F -- +EXPECTED "$log/testBuildFailure.log"
 250         ) || {
 251           echo "Test failed: could not find pattern in build log $log"
 252           false
 253         }
 254         echo 'All good.'
 255         touch -- "$out"
 256       '';
 257   };
 258 }