tools.graph:skip_build to omit tool/test-requires

conans/client/graph/graph.py

@@ -68,6 +68,7 @@ def __init__(self, ref, conanfile, context, recipe=None, path=None, test=False):
         self.build_allowed = False
         self.is_conf = False
         self.replaced_requires = {}  # To track the replaced requires for self.dependencies[old-ref]
+        self.skipped_build_requires = False
 
     def __lt__(self, other):
         """

conans/client/graph/graph_binaries.py

@@ -469,6 +469,9 @@ def _skip_binaries(graph):
         required_nodes.add(graph.root)
         for node in graph.nodes:
             if node.binary in (BINARY_BUILD, BINARY_EDITABLE_BUILD, BINARY_EDITABLE):
+                if node.skipped_build_requires:
+                    raise ConanException(f"Package {node.ref} skipped its test/tool requires with "
+                                         f"tools.graph:skip_build, but was marked to be built ")
                 can_skip = node.conanfile.conf.get("tools.graph:skip_binaries",
                                                    check_type=bool, default=True)
                 # Only those that are forced to build, not only "missing"

conans/client/graph/graph_builder.py

@@ -40,10 +40,10 @@ def load_graph(self, root_node, profile_host, profile_build, graph_lock=None):
         dep_graph = DepsGraph()
 
         self._prepare_node(root_node, profile_host, profile_build, Options())
-        self._initialize_requires(root_node, dep_graph, graph_lock, profile_build, profile_host)
+        rs = self._initialize_requires(root_node, dep_graph, graph_lock, profile_build, profile_host)
         dep_graph.add_node(root_node)
 
-        open_requires = deque((r, root_node) for r in root_node.conanfile.requires.values())
+        open_requires = deque((r, root_node) for r in rs)
         try:
             while open_requires:
                 # Fetch the first waiting to be expanded (depth-first)
@@ -56,10 +56,9 @@ def load_graph(self, root_node, profile_host, profile_build, graph_lock=None):
                                  or new_node.recipe == RECIPE_EDITABLE or
                                  new_node.conanfile.conf.get("tools.graph:vendor",
                                                              choices=("build",))):
-                    self._initialize_requires(new_node, dep_graph, graph_lock, profile_build,
-                                              profile_host)
-                    open_requires.extendleft((r, new_node)
-                                             for r in reversed(new_node.conanfile.requires.values()))
+                    newr = self._initialize_requires(new_node, dep_graph, graph_lock, profile_build,
+                                                     profile_host)
+                    open_requires.extendleft((r, new_node) for r in reversed(newr))
             self._remove_overrides(dep_graph)
             check_graph_provides(dep_graph)
         except GraphError as e:
@@ -192,7 +191,17 @@ def _prepare_node(node, profile_host, profile_build, down_options):
                                                          raise_if_duplicated=False)
 
     def _initialize_requires(self, node, graph, graph_lock, profile_build, profile_host):
+        result = []
+        skip_build = node.conanfile.conf.get("tools.graph:skip_build", check_type=bool)
+        skip_test = node.conanfile.conf.get("tools.graph:skip_test", check_type=bool)
         for require in node.conanfile.requires.values():
+            if not require.visible and not require.package_id_mode:
+                if skip_build and require.build:
+                    node.skipped_build_requires = True
+                    continue
+                if skip_test and require.test:
+                    continue
+            result.append(require)
             alias = require.alias  # alias needs to be processed this early
             if alias is not None:
                 resolved = False
@@ -205,6 +214,7 @@ def _initialize_requires(self, node, graph, graph_lock, profile_build, profile_h
             if graph_lock:
                 graph_lock.resolve_overrides(require)
             node.transitive_deps[require] = TransitiveRequirement(require, node=None)
+        return result
 
     def _resolve_alias(self, node, require, alias, graph):
         # First try cached

conans/model/conf.py

@@ -88,6 +88,8 @@
     "tools.files.unzip:filter": "Define tar extraction filter: 'fully_trusted', 'tar', 'data'",
     "tools.graph:vendor": "(Experimental) If 'build', enables the computation of dependencies of vendoring packages to build them",
     "tools.graph:skip_binaries": "Allow the graph to skip binaries not needed in the current configuration (True by default)",
+    "tools.graph:skip_build": "(Experimental) Do not expand build/tool_requires",
+    "tools.graph:skip_test": "(Experimental) Do not expand test_requires. If building it might need 'tools.build:skip_test=True'",
     "tools.gnu:make_program": "Indicate path to make program",
     "tools.gnu:define_libcxx11_abi": "Force definition of GLIBCXX_USE_CXX11_ABI=1 for libstdc++11",
     "tools.gnu:pkg_config": "Path to pkg-config executable used by PkgConfig build helper",

test/integration/graph/test_skip_build.py

@@ -0,0 +1,46 @@
+import textwrap
+
+from conan.test.assets.genconanfile import GenConanfile
+from conan.test.utils.tools import TestClient
+
+
+def test_graph_skip_build_test():
+    # app -> pkg -(test)-> gtest
+    #         \---(tool)-> cmake
+    c = TestClient(light=True)
+    pkg = textwrap.dedent("""
+        from conan import ConanFile
+        class Pkg(ConanFile):
+            name = "pkg"
+            version = "1.0"
+            test_requires = "gtest/1.0"
+            tool_requires = "cmake/1.0"
+        """)
+    c.save({"gtest/conanfile.py": GenConanfile("gtest", "1.0"),
+            "cmake/conanfile.py": GenConanfile("cmake", "1.0"),
+            "pkg/conanfile.py": pkg,
+            "app/conanfile.py": GenConanfile("app", "1.0").with_requires("pkg/1.0")})
+    c.run("create gtest")
+    c.run("create cmake")
+    c.run("create pkg")
+    c.run("create app -c tools.graph:skip_build=True -c tools.graph:skip_test=True")
+    assert "cmake" not in c.out
+    assert "gtest" not in c.out
+    c.run("create app -c tools.graph:skip_test=True")
+    assert "cmake" in c.out
+    assert "gtest" not in c.out
+    c.run("create app -c tools.graph:skip_build=True")
+    assert "cmake" not in c.out
+    assert "gtest" in c.out
+
+    c.run("install app")
+    assert "cmake" in c.out
+    assert "gtest" in c.out
+
+    c.run("install app -c tools.graph:skip_build=True -c tools.graph:skip_test=True")
+    assert "cmake" not in c.out
+    assert "gtest" not in c.out
+
+    c.run("install app -c tools.graph:skip_build=True --build=pkg/*", assert_error=True)
+    assert "ERROR: Package pkg/1.0 skipped its test/tool requires with tools.graph:skip_build, " \
+           "but was marked to be built " in c.out