Replace collectRunComponents with haskellLib.check

.buildkite/pipeline.yml

@@ -7,7 +7,10 @@ steps:
   - label: 'Check that jobset will evaluate in Hydra'
     command:
       - nix-build build.nix -A maintainer-scripts.check-hydra -o check-hydra.sh
-      - ./check-hydra.sh
+      - ./check-hydra.sh 0
+      - ./check-hydra.sh 1
+      - ./check-hydra.sh 2
+      - ./check-hydra.sh 3
     agents:
       system: x86_64-linux
 

build.nix

@@ -9,27 +9,19 @@
 , crossSystem ? null
 , config ? {}
 , nixpkgsArgs ? { inherit system crossSystem; }
+, ifdLevel ? 1000
 }:
 
 let
   haskellNixArgs = import ./default.nix;
   pkgs = import nixpkgs ({
-    config   = haskellNixArgs.config // config;
-    overlays = haskellNixArgs.overlays ++
-      [(self: super: {
-        darcs = (self.haskell-nix.hackage-package {
-          name = "darcs";
-          version = "2.14.2";
-          index-state = "2019-10-28T00:00:00Z";
-          plan-sha256 = "1h8dxib0wz6mg8md6ldwa54dsr1dn7vxfij8cfhdawl4y3wr51k0";
-          # Apply the latest darcs.net Setup.hs patches
-          modules = [{packages.darcs.patches = [ ./patches/darcs-setup.patch ];}];
-        }).components.exes.darcs;
-      })]; } // nixpkgsArgs);
+      config = haskellNixArgs.config // config;
+      inherit (haskellNixArgs) overlays;
+    } // nixpkgsArgs);
   haskell = pkgs.haskell-nix;
 
 in rec {
-  tests = import ./test/default.nix { inherit nixpkgs nixpkgsArgs; };
+  tests = import ./test/default.nix { inherit nixpkgs nixpkgsArgs ifdLevel; };
 
   # Scripts for keeping Hackage and Stackage up to date, and CI tasks.
   # The dontRecurseIntoAttrs prevents these from building on hydra
@@ -52,6 +44,11 @@ in rec {
         }) {};
       };
     };
+    # Because this is going to be used to test caching on hydra, it must not
+    # use the darcs package from the haskell.nix we are testing.  For that reason
+    # it uses `pkgs.buildPackages.callPackage` not `haskell.callPackage`
+    # (We could pull in darcs from a known good haskell.nix for hydra to
+    # use)
     check-hydra = pkgs.buildPackages.callPackage ./scripts/check-hydra.nix {};
     check-closure-size = pkgs.buildPackages.callPackage ./scripts/check-closure-size.nix {
       inherit (haskell) nix-tools;
@@ -60,11 +57,16 @@ in rec {
 
   # These are pure parts of maintainer-script so they can be built by hydra
   # and added to the cache to speed up buildkite.
-  maintainer-script-cache = pkgs.recurseIntoAttrs {
-    inherit (maintainer-scripts) update-docs check-hydra check-closure-size;
-    # Some of the dependencies of the impure scripts so that they will
-    # will be in the cache too for buildkite.
-    inherit (pkgs.buildPackages) glibc coreutils git openssh cabal-install nix-prefetch-git;
-    inherit (haskell) nix-tools;
-  };
+  maintainer-script-cache = pkgs.recurseIntoAttrs (
+      (pkgs.lib.optionalAttrs pkgs.stdenv.hostPlatform.isWindows {
+        inherit (maintainer-scripts) check-hydra;
+      })
+    // (pkgs.lib.optionalAttrs (ifdLevel > 2) {
+        inherit (maintainer-scripts) update-docs check-closure-size;
+        # Some of the dependencies of the impure scripts so that they will
+        # will be in the cache too for buildkite.
+        inherit (pkgs.buildPackages) glibc coreutils git openssh cabal-install nix-prefetch-git;
+        inherit (haskell) nix-tools;
+      })
+  );
 }

builder/comp-builder.nix

@@ -20,8 +20,6 @@
 , preHaddock ? component.preHaddock , postHaddock ? component.postHaddock
 , shellHook ? ""
 
-, doCheck ? component.doCheck || haskellLib.isTest componentId
-, doCrossCheck ? component.doCrossCheck || false
 , dontPatchELF ? true
 , dontStrip ? true
 
@@ -128,13 +126,7 @@ let
 
   exeExt = lib.optionalString stdenv.hostPlatform.isWindows ".exe";
   testExecutable = "dist/build/${componentId.cname}/${componentId.cname}${exeExt}";
-  # exe components are in /bin, but test and benchmarks are not.  Perhaps to avoid
-  # them being from being added to the PATH when the all component added to an env.
-  # TODO revist this to find out why and document or maybe change this.
-  installedExeDir = if haskellLib.isTest componentId || haskellLib.isBenchmark componentId
-    then name
-    else "bin";
-  installedExe = "${installedExeDir}/${componentId.cname}${exeExt}";
+  installedExe = "bin/${componentId.cname}${exeExt}";
 
 in stdenv.lib.fix (drv:
 
@@ -143,20 +135,20 @@ stdenv.mkDerivation ({
 
   src = cleanSrc;
 
-  inherit doCheck doCrossCheck dontPatchELF dontStrip;
+  doCheck = false;
+  doCrossCheck = false;
+
+  inherit dontPatchELF dontStrip;
 
   passthru = {
     inherit (package) identifier;
     config = component;
-    inherit configFiles executableToolDepends cleanSrc;
+    inherit configFiles executableToolDepends cleanSrc installedExe;
     env = shellWrappers;
 
     # The directory containing the haddock documentation.
     # `null' if no haddock documentation was built.
     haddockDir = if doHaddock' then "${docdir drv.doc}/html" else null;
-    run = runCommand (fullName + "-run") {} ''
-      ${toString component.testWrapper} ${drv}/${installedExe} | tee $out
-    '';
   };
 
   meta = {
@@ -217,13 +209,7 @@ stdenv.mkDerivation ({
     runHook postBuild
   '';
 
-  checkPhase = ''
-    runHook preCheck
-
-    ${toString component.testWrapper} ${testExecutable} ${lib.concatStringsSep " " component.testFlags}
-
-    runHook postCheck
-  '';
+  checkPhase = "notice: Tests are only executed by building the .run sub-derivation of this component.";
 
   haddockPhase = ''
     runHook preHaddock
@@ -281,25 +267,25 @@ stdenv.mkDerivation ({
       fi
     ''}
     ${(lib.optionalString (haskellLib.isTest componentId || haskellLib.isBenchmark componentId || haskellLib.isAll componentId) ''
-      mkdir -p $out/${name}
+      mkdir -p $out/bin
       if [ -f ${testExecutable} ]; then
-        cp ${testExecutable} $out/${name}/
+        cp ${testExecutable} $out/bin/
       fi
     '')
     # In case `setup copy` did not creat this
     + (lib.optionalString enableSeparateDataOutput "mkdir -p $data")
     + (lib.optionalString (stdenv.hostPlatform.isWindows && (haskellLib.mayHaveExecutable componentId)) ''
-      echo "Copying libffi and gmp .dlls ..."
+      echo "Symlink libffi and gmp .dlls ..."
       for p in ${lib.concatStringsSep " " [ libffi gmp ]}; do
-        find "$p" -iname '*.dll' -exec cp {} $out/${installedExeDir} \;
+        find "$p" -iname '*.dll' -exec ln -s {} $out/bin \;
       done
-      # copy all .dlls into the local directory.
+      # symlink all .dlls into the local directory.
       # we ask ghc-pkg for *all* dynamic-library-dirs and then iterate over the unique set
-      # to copy over dlls as needed.
-      echo "Copying library dependencies..."
+      # to symlink over dlls as needed.
+      echo "Symlink library dependencies..."
       for libdir in $(x86_64-pc-mingw32-ghc-pkg --package-db=$packageConfDir field "*" dynamic-library-dirs --simple-output|xargs|sed 's/ /\n/g'|sort -u); do
         if [ -d "$libdir" ]; then
-          find "$libdir" -iname '*.dll' -exec cp {} $out/${installedExeDir} \;
+          find "$libdir" -iname '*.dll' -exec ln -s {} $out/bin \;
         fi
       done
     '')
@@ -316,7 +302,7 @@ stdenv.mkDerivation ({
 // lib.optionalAttrs (patches != []) { patches = map (p: if builtins.isFunction p then p { inherit (package.identifier) version; inherit revision; } else p) patches; }
 // haskellLib.optionalHooks {
   inherit preUnpack postUnpack preConfigure postConfigure
-    preBuild postBuild preCheck postCheck
+    preBuild postBuild
     preInstall postInstall preHaddock postHaddock;
 }
 // lib.optionalAttrs (stdenv.buildPlatform.libc == "glibc"){ LOCALE_ARCHIVE = "${buildPackages.glibcLocales}/lib/locale/locale-archive"; }

builder/hspkg-builder.nix

@@ -57,8 +57,11 @@ let
             ;
   };
 
-in {
+in rec {
   components = haskellLib.applyComponents buildComp config;
+  checks = pkgs.recurseIntoAttrs (builtins.mapAttrs
+    (_: d: haskellLib.check d)
+      (lib.filterAttrs (_: d: d.config.doCheck) components.tests));
   inherit (package) identifier detailLevel isLocal;
   inherit setup cabalFile;
   isHaskell = true;

docs/reference/library.md

@@ -286,7 +286,8 @@ Infrastructure.
 Extracts a selection of components from a Haskell [package set](#package-set).
 
 This can be used to filter out all test suites or benchmarks of
-your project, so that they can be built in Hydra.
+your project, so that they can be built in Hydra (see check if you
+waht to run the tests as well as build them).
 
 ```
 collectComponents =
@@ -311,6 +312,21 @@ tests = collectComponents "tests" (package: package.identifier.name == "mypackag
 Will result in moving derivations from `hsPkgs.mypackage.components.tests.unit-tests`
 to `tests.mypackage.unit-tests`.
 
+#### check
+
+This function turns a derivation that builds a test into one to run it.
+
+| Argument          | Type   | Description         |
+|-------------------|--------|---------------------|
+| `drv`           | Derivation | One of `$pkg.components.tests.$test`. |
+
+For convenience `$pkg.components.tests` are mapped with this function
+to `$pkg.components.checks`.
+
+This function is intended for use with `tests` but it should also work
+for `exes` and `benchmarks` if you just want to run them to make sure
+they execute.
+
 #### subComponentTypes
 
 Sub-component types identify [components](#component) and are one of:

lib/call-cabal-project-to-nix.nix

@@ -156,10 +156,11 @@ let
       }
       else replaceSoureRepos rawCabalProject;
 
-  plan-nix = runCommand "plan-to-nix-pkgs" ({
+  plan-nix = runCommand (if name == null then "plan-to-nix-pkgs" else name + "-plan-to-nix-pkgs") ({
     nativeBuildInputs = [ nix-tools ghc hpack cabal-install pkgs.rsync pkgs.git ];
     # Needed or stack-to-nix will die on unicode inputs
     LANG = "en_US.UTF-8";
+    preferLocalBuild = false;
   } // (if plan-sha256 == null
     then {}
     else {

lib/call-stack-to-nix.nix

@@ -20,6 +20,7 @@ let
     LOCALE_ARCHIVE = pkgs.lib.optionalString (pkgs.stdenv.hostPlatform.libc == "glibc") "${pkgs.glibcLocales}/lib/locale/locale-archive";
     LANG = "en_US.UTF-8";
     LC_ALL = "en_US.UTF-8";
+    preferLocalBuild = false;
   } (''
     mkdir -p $out
   '' + pkgs.lib.optionalString (cache != null) ''

lib/check.nix

@@ -0,0 +1,42 @@
+{ stdenv, lib, haskellLib, srcOnly }:
+drv:
+
+let
+  component = drv.config;
+
+# This derivation can be used to execute test component.
+# The $out of the derivation is a file containing the resulting
+# stdout output.
+in stdenv.mkDerivation ({
+  name = (drv.name + "-check");
+
+  # Useing `srcOnly` (rather than getting the `src` via a `drv.passthru`)
+  # should correctly apply the patches from `drv` (if any).
+  src = srcOnly drv;
+
+  passthru = {
+    inherit (drv) identifier config configFiles executableToolDepends cleanSrc env;
+  };
+
+  inherit (drv) meta LANG LC_ALL;
+
+  inherit (component) doCheck doCrossCheck;
+
+  phases = ["buildPhase" "checkPhase"];
+
+  # If doCheck or doCrossCheck are false we may still build this
+  # component and we want it to quietly succeed.
+  buildPhase = ''
+    touch $out
+  '';
+
+  checkPhase = ''
+    runHook preCheck
+
+    ${toString component.testWrapper} ${drv}/${drv.installedExe} ${lib.concatStringsSep " " component.testFlags} | tee $out
+
+    runHook postCheck
+  '';
+} // haskellLib.optionalHooks {
+  inherit (component) preCheck postCheck;
+})

lib/default.nix

@@ -1,4 +1,4 @@
-{ lib, haskellLib, runCommand, git }:
+{ stdenv, lib, haskellLib, runCommand, git, srcOnly }:
 
 with haskellLib;
 
@@ -149,4 +149,9 @@ with haskellLib;
   cleanGit = import ./clean-git.nix {
     inherit lib runCommand git cleanSourceWith;
   };
+
+  # Check a test component
+  check = import ./check.nix {
+    inherit stdenv lib haskellLib srcOnly;
+  };
 }

modules/plan.nix

@@ -81,7 +81,7 @@ let
           };
           doCheck = mkOption {
             type = bool;
-            default = (def.doCheck or false);
+            default = (def.doCheck or true);
           };
           doCrossCheck = mkOption {
             description = "Run doCheck also in cross compilation settings. This can be tricky as the test logic must know how to run the tests on the target.";

overlays/bootstrap.nix

@@ -267,7 +267,7 @@ self: super: {
                 index-state = "2019-10-20T00:00:00Z";
                 plan-sha256 = "086kd6aa5bir3y4aqb1wl5zkj6agz5q4wp4snvdnf6cidz5wra06";
             };
-            alex = bootstrap.packages.alex-project.alex.components.exes.alex;
+            alex = bootstrap.packages.alex-project.hsPkgs.alex.components.exes.alex;
             happy-project = hackage-project {
                 # Only a boot compiler is suitable here
                 ghc = ghc // { isHaskellNixCompiler = ghc.isHaskellNixBootCompiler; };
@@ -276,7 +276,7 @@ self: super: {
                 index-state = "2019-10-20T00:00:00Z";
                 plan-sha256 = "011bxlxdv239psgi80j00km2wcgb68j16sz3fng67d03sqf5i37w";
             };
-            happy = bootstrap.packages.happy-project.happy.components.exes.happy;
+            happy = bootstrap.packages.happy-project.hsPkgs.happy.components.exes.happy;
             hscolour-project = hackage-project {
                 # Only a boot compiler is suitable here
                 ghc = ghc // { isHaskellNixCompiler = ghc.isHaskellNixBootCompiler; };
@@ -285,7 +285,7 @@ self: super: {
                 index-state = "2019-10-20T00:00:00Z";
                 plan-sha256 = "021rwcmkshibc3mfr833ay5hfr19kq6k32lxyrrb6vp9vmihgw4b";
             };
-            hscolour = bootstrap.packages.hscolour-project.hscolour.components.exes.HsColour;
+            hscolour = bootstrap.packages.hscolour-project.hsPkgs.hscolour.components.exes.HsColour;
         };
     };
   };