def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*tailor.rules(),
QueryRule(PutativeTargets,
[PutativeShellTargetsRequest, AllOwnedSources]),
],
target_types=[],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*debian_rules(),
*target_types_rules.rules(),
QueryRule(BuiltPackage, (DebianPackageFieldSet, )),
],
target_types=[DebianPackage],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*tailor_rules(),
QueryRule(PutativeTargets,
(PutativeProtobufTargetsRequest, AllOwnedSources)),
],
target_types=[],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*tailor.rules(),
*target_types_rules.rules(),
QueryRule(PutativeTargets, (PutativePythonTargetsRequest, AllOwnedSources)),
],
target_types=[PexBinary],
)
def rules(cls):
return (
*super().rules(),
get_requirements,
get_owned_dependencies,
get_exporting_owner,
QueryRule(ExportedTargetRequirements,
(DependencyOwner, OptionsBootstrapper)),
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*tailor.rules(),
*source_files.rules(),
*pants_bin.rules(),
extract_build_file_options,
find_fortran_targets,
infer_fortran_module_dependency,
UnionRule(PutativeTargetsRequest, PutativeFortranTargetsRequest),
QueryRule(PutativeTargets, (MockPutativeFortranModuleRequest, )),
QueryRule(UniquelyNamedPutativeTargets, (PutativeTargets, )),
QueryRule(DisjointSourcePutativeTarget, (PutativeTarget, )),
QueryRule(EditedBuildFiles, (EditBuildFilesRequest, )),
QueryRule(AllOwnedSources, ()),
],
target_types=[FortranLibraryTarget, FortranTestsTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*mypy_rules(),
*dependency_inference_rules.rules(), # Used for import inference.
QueryRule(TypecheckResults, (MyPyRequest,)),
],
target_types=[PythonLibrary, PythonRequirementLibrary],
)
def __init__(
self,
*,
rules: Optional[Iterable] = None,
target_types: Optional[Iterable[Type[Target]]] = None,
objects: Optional[Dict[str, Any]] = None,
context_aware_object_factories: Optional[Dict[str, Any]] = None,
) -> None:
self.build_root = os.path.realpath(mkdtemp(suffix="_BUILD_ROOT"))
safe_mkdir(self.build_root, clean=True)
safe_mkdir(self.pants_workdir)
BuildRoot().path = self.build_root
# TODO: Redesign rule registration for tests to be more ergonomic and to make this less
# special-cased.
all_rules = (
*(rules or ()),
*source_root.rules(),
*pants_environment.rules(),
QueryRule(WrappedTarget, (Address,)),
)
build_config_builder = BuildConfiguration.Builder()
build_config_builder.register_aliases(
BuildFileAliases(
objects=objects, context_aware_object_factories=context_aware_object_factories
)
)
build_config_builder.register_rules(all_rules)
build_config_builder.register_target_types(target_types or ())
self.build_config = build_config_builder.create()
options_bootstrapper = create_options_bootstrapper()
global_options = options_bootstrapper.bootstrap_options.for_global_scope()
local_store_dir = global_options.local_store_dir
local_execution_root_dir = global_options.local_execution_root_dir
named_caches_dir = global_options.named_caches_dir
graph_session = EngineInitializer.setup_graph_extended(
pants_ignore_patterns=[],
use_gitignore=False,
local_store_dir=local_store_dir,
local_execution_root_dir=local_execution_root_dir,
named_caches_dir=named_caches_dir,
native=Native(),
options_bootstrapper=options_bootstrapper,
build_root=self.build_root,
build_configuration=self.build_config,
execution_options=ExecutionOptions.from_bootstrap_options(global_options),
).new_session(
build_id="buildid_for_test",
session_values=SessionValues(
{OptionsBootstrapper: options_bootstrapper, PantsEnvironment: PantsEnvironment()}
),
should_report_workunits=True,
)
self.scheduler = graph_session.scheduler_session
def test_platform_on_local_epr_result() -> None:
rule_runner = RuleRunner(
rules=[QueryRule(FallibleProcessResultWithPlatform, (Process, ))])
this_platform = Platform.current
process = Process(argv=("/bin/echo", "test"),
description="Run some program that will exit cleanly.")
result = rule_runner.request_product(FallibleProcessResultWithPlatform,
[process])
assert result.exit_code == 0
assert result.platform == this_platform
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*external_tool.rules(),
*sdk.rules(),
*import_analysis.rules(),
QueryRule(GoStdLibImports, []),
],
)
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*tailor.rules(),
QueryRule(PutativeTargets, (PutativeJavaTargetsRequest, AllOwnedSources)),
],
target_types=[JavaSourcesGeneratorTarget, JunitTestsGeneratorTarget],
)
rule_runner.set_options(["--backend-packages=pants.backend.experimental.java"])
return rule_runner
def rule_runner() -> RuleRunner:
return RuleRunner(
target_types=[TerraformModuleTarget, TerraformModulesGeneratorTarget],
rules=[
*external_tool.rules(),
*target_gen.rules(),
QueryRule(GeneratedTargets,
[GenerateTerraformModuleTargetsRequest]),
],
)
def rules(cls):
return (
*super().rules(),
get_sources,
*source_files.rules(),
*stripped_source_files.rules(),
*python_sources.rules(),
QueryRule(SetupPySources,
(SetupPySourcesRequest, OptionsBootstrapper)),
)
def test_multiple_depend_on_same_rule(self):
@rule
def a_from_suba(suba: SubA) -> A:
pass
@rule
def b_from_a(a: A) -> B:
pass
@rule
def c_from_a(a: A) -> C:
pass
rules = [
a_from_suba,
b_from_a,
c_from_a,
QueryRule(A, (SubA,)),
QueryRule(B, (SubA,)),
QueryRule(C, (SubA,)),
]
fullgraph = self.create_full_graph(rules)
assert_equal_graph_output(
self,
dedent(
f"""\
digraph {{
// queries: Query(A for SubA), Query(B for SubA), Query(C for SubA)
// root entries
{fmt_non_param_edge(A, SubA)}
{fmt_non_param_edge(A, SubA, RuleFormatRequest(a_from_suba))}
{fmt_non_param_edge(B, SubA)}
{fmt_non_param_edge(B, SubA, RuleFormatRequest(b_from_a))}
{fmt_non_param_edge(C, SubA)}
{fmt_non_param_edge(C, SubA, RuleFormatRequest(c_from_a))}
// internal entries
{fmt_non_param_edge(b_from_a, SubA, RuleFormatRequest(a_from_suba))}
{fmt_non_param_edge(c_from_a, SubA, RuleFormatRequest(a_from_suba))}
{fmt_param_edge(SubA, SubA, RuleFormatRequest(a_from_suba))}
}}"""
).strip(),
fullgraph,
)
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
target_types=[TerraformModuleTarget],
rules=[
*external_tool.rules(),
*source_files.rules(),
*pex_rules(),
*dependency_inference.rules(),
QueryRule(InferredDependencies,
[InferTerraformModuleDependenciesRequest]),
QueryRule(HydratedSources, [HydrateSourcesRequest]),
QueryRule(ProcessResult, [ParseTerraformModuleSources]),
],
)
rule_runner.set_options(
["--backend-packages=pants.backend.experimental.terraform"],
env_inherit={"PATH", "PYENV_ROOT", "HOME"},
)
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*go_mod.rules(),
*first_party_pkg.rules(),
*sdk.rules(),
*third_party_pkg.rules(),
*target_type_rules.rules(),
*build_pkg.rules(),
*link.rules(),
*assembly.rules(),
QueryRule(FallibleFirstPartyPkgAnalysis, [FirstPartyPkgAnalysisRequest]),
QueryRule(FallibleFirstPartyPkgDigest, [FirstPartyPkgDigestRequest]),
QueryRule(FirstPartyPkgImportPath, [FirstPartyPkgImportPathRequest]),
],
target_types=[GoModTarget, GoPackageTarget, ResourcesGeneratorTarget],
)
rule_runner.set_options([], env_inherit={"PATH"})
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*sdk.rules(),
*assembly.rules(),
*build_pkg.rules(),
*import_analysis.rules(),
*go_mod.rules(),
*first_party_pkg.rules(),
*link.rules(),
*third_party_pkg.rules(),
*target_type_rules.rules(),
QueryRule(BuiltGoPackage, [BuildGoPackageRequest]),
QueryRule(FallibleBuiltGoPackage, [BuildGoPackageRequest]),
],
target_types=[GoModTarget],
)
rule_runner.set_options([], env_inherit={"PATH"})
return rule_runner
def rule_runner() -> RuleRunner:
return RuleRunner(
target_types=[GoBinary, GoPackage],
rules=[
*external_tool.rules(),
*source_files.rules(),
*build.rules(),
QueryRule(BuiltPackage, (GoBinaryFieldSet, )),
],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
target_types=[
HelmChartTarget, ResourcesGeneratorTarget, FilesGeneratorTarget
],
rules=[
*sources.rules(),
*stripped_source_files.rules(),
QueryRule(HelmChartSourceFiles, (HelmChartSourceFilesRequest, )),
],
)
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*sdk.rules(),
*third_party_pkg.rules(),
*first_party_pkg.rules(),
*load_go_binary.rules(),
*build_pkg.rules(),
*import_analysis.rules(),
*link.rules(),
*assembly.rules(),
*target_type_rules.rules(),
*go_mod.rules(),
QueryRule(AllThirdPartyPackages, [AllThirdPartyPackagesRequest]),
QueryRule(ThirdPartyPkgAnalysis, [ThirdPartyPkgAnalysisRequest]),
],
target_types=[GoModTarget],
)
rule_runner.set_options([], env_inherit={"PATH"})
return rule_runner
def test_run_export_rule() -> None:
rule_runner = RuleRunner(
rules=[
UnionRule(ExportRequest, MockExportRequest),
QueryRule(Digest, [CreateDigest]),
QueryRule(Environment, [EnvironmentRequest]),
QueryRule(InteractiveProcessResult, [InteractiveProcess]),
],
target_types=[MockTarget],
)
exit_code, stdout = run_export_rule(rule_runner,
[make_target("foo/bar", "baz")])
assert exit_code == 0
assert "Wrote mock export for foo/bar:baz to dist/export/mock" in stdout
for filename in ["bar", "bar1", "bar2"]:
expected_dist_path = os.path.join(rule_runner.build_root, "dist",
"export", "mock", "foo", filename)
assert os.path.isfile(expected_dist_path)
with open(expected_dist_path, "rb") as fp:
assert fp.read() == b"BAR"
def assert_digest(self, filespecs_or_globs, expected_files):
with self.mk_project_tree() as project_tree:
scheduler = self.mk_scheduler(
rules=[*fs_rules(),
QueryRule(Snapshot, (PathGlobs, ))],
project_tree=project_tree)
result = self.execute(scheduler, Snapshot,
self.path_globs(filespecs_or_globs))[0]
# Confirm all expected files were digested.
assert set(expected_files) == set(result.files)
assert result.digest.fingerprint is not None
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*sdk.rules(),
*go_mod.rules(),
QueryRule(GoModInfo, [GoModInfoRequest]),
],
target_types=[GoModTarget],
)
rule_runner.set_options([], env_inherit={"PATH"})
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*go_mod.rules(),
*first_party_pkg.rules(),
*third_party_pkg.rules(),
*sdk.rules(),
*target_type_rules.rules(),
*build_pkg.rules(),
*link.rules(),
*assembly.rules(),
QueryRule(Addresses, [DependenciesRequest]),
QueryRule(GoBinaryMainPackage, [GoBinaryMainPackageRequest]),
QueryRule(InjectedDependencies,
[InjectGoBinaryMainDependencyRequest]),
],
target_types=[GoModTarget, GoBinaryTarget, GenericTarget],
)
rule_runner.set_options([], env_inherit={"PATH"})
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*config_files.rules(),
*external_tool_rules(),
*source_files.rules(),
*protobuf_target_types_rules(),
*protobuf_dependency_inference.rules(),
*stripped_source_files.rules(),
*go_protobuf_rules(),
*sdk.rules(),
*target_types.rules(),
# Rules needed to run Go unit test.
*test.rules(),
*assembly.rules(),
*build_pkg.rules(),
*build_pkg_target.rules(),
*first_party_pkg.rules(),
*go_mod.rules(),
*link.rules(),
*sdk.rules(),
*target_type_rules.rules(),
*tests_analysis.rules(),
*third_party_pkg.rules(),
QueryRule(HydratedSources, [HydrateSourcesRequest]),
QueryRule(GeneratedSources, [GenerateGoFromProtobufRequest]),
QueryRule(DigestContents, (Digest, )),
QueryRule(TestResult, (GoTestFieldSet, )),
],
target_types=[
GoModTarget,
GoPackageTarget,
ProtobufSourceTarget,
ProtobufSourcesGeneratorTarget,
],
)
rule_runner.set_options(
[],
env_inherit=PYTHON_BOOTSTRAP_ENV,
)
return rule_runner
def rules(cls):
return (
*super().rules(),
generate_chroot,
get_sources,
get_requirements,
get_owned_dependencies,
get_exporting_owner,
*python_sources.rules(),
QueryRule(SetupPyChroot,
(SetupPyChrootRequest, OptionsBootstrapper)),
)
def test_python_interpreter_search_path_file_entries() -> None:
rule_runner = RuleRunner(rules=[
*system_binaries.rules(),
QueryRule(PythonBinary, input_types=())
])
current_python = os.path.realpath(sys.executable)
rule_runner.set_options(args=[
f"--python-bootstrap-search-path=[{current_python!r}]",
f"--python-bootstrap-names=[{os.path.basename(current_python)!r}]",
])
python_binary = rule_runner.request(PythonBinary, inputs=())
assert current_python == python_binary.path
def rule_runner() -> RuleRunner:
return RuleRunner(
target_types=[
HelmChartTarget, HelmUnitTestTestsGeneratorTarget,
HelmUnitTestTestTarget
],
rules=[
*target_types_rules(),
*inject_deps_rules(),
QueryRule(InjectedDependencies,
(InjectHelmUnitTestChartDependencyRequest, )),
],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*mypy_rules(),
*mypy_subystem_rules(),
*dependency_inference_rules.rules(), # Used for import inference.
*pants_bin.rules(),
*config_files.rules(),
*target_types_rules.rules(),
QueryRule(CheckResults, (MyPyRequest,)),
],
target_types=[PythonSourcesGeneratorTarget, PythonRequirementTarget],
)
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
target_types=[TerraformModule, TerraformModules],
rules=[
*external_tool.rules(),
*source_files.rules(),
*target_gen.rules(),
QueryRule(GeneratedTargets,
[GenerateTerraformModuleTargetsRequest]),
],
)
rule_runner.set_options(
["--backend-packages=pants.backend.experimental.terraform"])
return rule_runner
