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'";
}