core/pkgs/by-name/py/python/hooks/python-catch-conflicts-hook-tests.nix

{ pythonOnBuildForHost, runCommand, writeShellScript, coreutils, gnugrep }:
let

  pythonPkgs = pythonOnBuildForHost.pkgs;

  ### UTILITIES

  # customize a package so that its store paths differs
  customize = pkg: pkg.overrideAttrs { some_modification = true; };

  # generates minimal pyproject.toml
  pyprojectToml = pname:
    builtins.toFile "pyproject.toml" ''
      [project]
      name = "${pname}"
      version = "1.0.0"
    '';

  # generates source for a python project
  projectSource = pname:
    runCommand "my-project-source" { } ''
      mkdir -p $out/src
      cp ${pyprojectToml pname} $out/pyproject.toml
      touch $out/src/__init__.py
    '';

  # helper to reduce boilerplate
  generatePythonPackage = args:
    pythonPkgs.buildPythonPackage ({
      version = "1.0.0";
      src = runCommand "my-project-source" { } ''
        mkdir -p $out/src
        cp ${pyprojectToml args.pname} $out/pyproject.toml
        touch $out/src/__init__.py
      '';
      pyproject = true;
      catchConflicts = true;
      buildInputs = [ pythonPkgs.setuptools ];
    } // args);

  # in order to test for a failing build, wrap it in a shell script
  expectFailure = build: errorMsg:
    build.overrideDerivation (old: {
      builder = writeShellScript "test-for-failure" ''
        export PATH=${coreutils}/bin:${gnugrep}/bin:$PATH
        ${old.builder} "$@" > ./log 2>&1
        status=$?
        cat ./log
        if [ $status -eq 0 ] || ! grep -q "${errorMsg}" ./log; then
          echo "The build should have failed with '${errorMsg}', but it didn't"
          exit 1
        else
          echo "The build failed as expected with: ${errorMsg}"
          mkdir -p $out
        fi
      '';
    });
in {

  ### TEST CASES

  # Test case which must not trigger any conflicts.
  # This derivation has runtime dependencies on custom versions of multiple build tools.
  # This scenario is relevant for lang2nix tools which do not override the nixpkgs fix-point.
  # see https://github.com/NixOS/nixpkgs/issues/283695
  ignores-build-time-deps = generatePythonPackage {
    pname = "ignores-build-time-deps";
    buildInputs = [
      pythonPkgs.build
      pythonPkgs.packaging
      pythonPkgs.setuptools
      pythonPkgs.wheel
    ];
    propagatedBuildInputs = [
      # Add customized versions of build tools as runtime deps
      (customize pythonPkgs.packaging)
      (customize pythonPkgs.setuptools)
      (customize pythonPkgs.wheel)
    ];
  };

  # multi-output derivation with dependency on itself must not crash
  cyclic-dependencies = generatePythonPackage {
    pname = "cyclic-dependencies";
    preFixup = ''
      propagatedBuildInputs+=("$out")
    '';
  };

  # Simplest test case that should trigger a conflict
  catches-simple-conflict = let
    # this build must fail due to conflicts
    package = pythonPkgs.buildPythonPackage rec {
      pname = "catches-simple-conflict";
      version = "0.0.0";
      src = projectSource pname;
      pyproject = true;
      catchConflicts = true;
      buildInputs = [ pythonPkgs.setuptools ];
      # depend on two different versions of packaging
      # (an actual runtime dependency conflict)
      propagatedBuildInputs =
        [ pythonPkgs.packaging (customize pythonPkgs.packaging) ];
    };
  in expectFailure package
  "Found duplicated packages in closure for dependency 'packaging'";

  /* More complex test case with a transitive conflict

     Test sets up this dependency tree:

       toplevel
       ├── dep1
       │   └── leaf
       └── dep2
           └── leaf (customized version -> conflicting)
  */
  catches-transitive-conflict = let
    # package depending on both dependency1 and dependency2
    toplevel = generatePythonPackage {
      pname = "catches-transitive-conflict";
      propagatedBuildInputs = [ dep1 dep2 ];
    };
    # dep1 package depending on leaf
    dep1 = generatePythonPackage {
      pname = "dependency1";
      propagatedBuildInputs = [ leaf ];
    };
    # dep2 package depending on conflicting version of leaf
    dep2 = generatePythonPackage {
      pname = "dependency2";
      propagatedBuildInputs = [ (customize leaf) ];
    };
    # some leaf package
    leaf = generatePythonPackage { pname = "leaf"; };
  in expectFailure toplevel
  "Found duplicated packages in closure for dependency 'leaf'";
}