path: root/pkgs/build-support/trivial-builders/test-overriding.nix

# Check that overriding works for trivial-builders like
# `writeShellScript` via `overrideAttrs`. This is useful
# to override the `checkPhase`, e. g. if you want
# to disable extglob in `writeShellScript`.
#
# Run using `nix-build -A tests.trivial-builders.overriding`.
{ lib
, stdenv
, runtimeShell
, runCommand
, callPackage
, writeShellScript
, writeTextFile
, writeShellScriptBin
}:

let
  extglobScript = ''
    shopt -s extglob
    touch success
    echo @(success|failure)
    rm success
  '';

  simpleCase = case:
    writeShellScript "test-trivial-overriding-${case}" extglobScript;

  callPackageCase = case: callPackage (
    { writeShellScript }:
    writeShellScript "test-trivial-callpackage-overriding-${case}" extglobScript
  ) { };

  binCase = case:
    writeShellScriptBin "test-trivial-overriding-bin-${case}" extglobScript;

  # building this derivation would fail without overriding
  textFileCase = writeTextFile {
    name = "test-trivial-overriding-text-file";
    checkPhase = "false";
    text = ''
      #!${runtimeShell}
      echo success
    '';
    executable = true;
  };

    disallowExtglob = x: x.overrideAttrs (_: {
      checkPhase = ''
        ${stdenv.shell} -n "$target"
      '';
    });

    # Run old checkPhase, but only succeed if it fails.
    # This HACK is required because we can't introspect build failures
    # in nix: With `assertFail` we want to make sure that the default
    # `checkPhase` would fail if extglob was used in the script.
    assertFail = x: x.overrideAttrs (old: {
      checkPhase = ''
        if
          ${old.checkPhase}
        then exit 1; fi
      '';
    });

  mkCase = case: outcome: isBin:
    let
      drv = lib.pipe outcome ([ case ] ++ lib.optionals (outcome == "fail") [ disallowExtglob assertFail ]);
    in if isBin then "${drv}/bin/${drv.name}" else drv;

  writeTextOverrides = {
    # Make sure extglob works by default
    simpleSucc = mkCase simpleCase "succ" false;
    # Ensure it's possible to fail; in this case extglob is not enabled
    simpleFail = mkCase simpleCase "fail" false;
    # Do the same checks after wrapping with callPackage
    # to make sure callPackage doesn't mess with the override
    callpSucc = mkCase callPackageCase "succ" false;
    callpFail = mkCase callPackageCase "fail" false;
    # Do the same check using `writeShellScriptBin`
    binSucc = mkCase binCase "succ" true;
    binFail = mkCase binCase "fail" true;
    # Check that we can also override plain writeTextFile
    textFileSuccess = textFileCase.overrideAttrs (_: {
      checkPhase = "true";
    });
  };

  # `runTest` forces nix to build the script of our test case and
  # run its `checkPhase` which is our main interest. Additionally
  # it executes the script and thus makes sure that extglob also
  # works at run time.
  runTest = script:
    let
      name = script.name or (builtins.baseNameOf script);
    in writeShellScript "run-${name}" ''
      if [ "$(${script})" != "success" ]; then
        echo "Failed in ${name}"
        exit 1
      fi
    '';
in

runCommand "test-writeShellScript-overriding" {
  passthru = { inherit writeTextOverrides; };
} ''
  ${lib.concatMapStrings (test: ''
      ${runTest test}
    '') (lib.attrValues writeTextOverrides)}
  touch "$out"
''