def run_goal(
targets: List[MockTarget],
*,
show_documented: bool = False,
show_provides: bool = False,
provides_columns: Optional[str] = None,
) -> Tuple[str, str]:
console = MockConsole(use_colors=False)
run_rule(
list_targets,
rule_args=[
Addresses(tgt.address for tgt in targets),
create_goal_subsystem(
ListOptions,
sep="\\n",
output_file=None,
documented=show_documented,
provides=show_provides,
provides_columns=provides_columns or "address,artifact_id",
),
console,
],
mock_gets=[
MockGet(product_type=Targets,
subject_type=Addresses,
mock=lambda _: targets)
],
)
return cast(str,
console.stdout.getvalue()), cast(str,
console.stderr.getvalue())
def run_lint_rule(
*,
config_collection_types: List[Type[LinterConfigurations]],
targets: List[TargetWithOrigin],
per_target_caching: bool,
include_sources: bool = True,
) -> Tuple[int, str]:
console = MockConsole(use_colors=False)
union_membership = UnionMembership({LinterConfigurations: config_collection_types})
result: Lint = run_rule(
lint,
rule_args=[
console,
TargetsWithOrigins(targets),
create_goal_subsystem(LintOptions, per_target_caching=per_target_caching),
union_membership,
],
mock_gets=[
MockGet(
product_type=LintResult,
subject_type=LinterConfigurations,
mock=lambda config_collection: config_collection.lint_result,
),
MockGet(
product_type=ConfigurationsWithSources,
subject_type=ConfigurationsWithSourcesRequest,
mock=lambda configs: ConfigurationsWithSources(
configs if include_sources else ()
),
),
],
union_membership=union_membership,
)
return result.exit_code, console.stdout.getvalue()
def run_goal(
targets: Sequence[Target],
*,
target_type: Optional[List[str]] = None,
address_regex: Optional[List[str]] = None,
tag_regex: Optional[List[str]] = None,
) -> str:
console = MockConsole(use_colors=False)
run_rule(
filter_targets,
rule_args=[
Targets(targets),
create_goal_subsystem(
FilterOptions,
sep="\\n",
output_file=None,
target_type=target_type or [],
address_regex=address_regex or [],
tag_regex=tag_regex or [],
),
console,
RegisteredTargetTypes.create({type(tgt)
for tgt in targets}),
],
)
assert not console.stderr.getvalue()
return cast(str, console.stdout.getvalue())
def test_line_oriented_goal() -> None:
class OutputtingGoalOptions(LineOriented, GoalSubsystem):
name = "dummy"
class OutputtingGoal(Goal):
subsystem_cls = OutputtingGoalOptions
@goal_rule
def output_rule(console: Console, options: OutputtingGoalOptions) -> OutputtingGoal:
with options.output(console) as write_stdout:
write_stdout("output...")
with options.line_oriented(console) as print_stdout:
print_stdout("line oriented")
return OutputtingGoal(0)
console = MockConsole()
result: OutputtingGoal = run_rule(
output_rule,
rule_args=[
console,
create_goal_subsystem(OutputtingGoalOptions, sep="\\n", output_file=None),
],
)
assert result.exit_code == 0
assert console.stdout.getvalue() == "output...line oriented\n"
def single_target_run(
self,
*,
console: MockConsole,
program_text: bytes,
address_spec: str,
) -> Run:
workspace = Workspace(self.scheduler)
interactive_runner = InteractiveRunner(self.scheduler)
class TestBinaryConfiguration(BinaryConfiguration):
required_fields = ()
class TestBinaryTarget(Target):
alias = "binary"
core_fields = ()
address = Address.parse(address_spec)
origin = SingleAddress(address.spec_path, address.target_name)
res = run_rule(
run,
rule_args=[
console,
workspace,
interactive_runner,
BuildRoot(),
TargetsWithOrigins([
TargetWithOrigin(
target=TestBinaryTarget(unhydrated_values={},
address=address),
origin=origin,
)
]),
create_goal_subsystem(RunOptions, args=[]),
create_subsystem(GlobalOptions,
pants_workdir=self.pants_workdir),
UnionMembership(union_rules={
BinaryConfiguration:
OrderedSet([TestBinaryConfiguration])
}),
RegisteredTargetTypes.create([TestBinaryTarget]),
],
mock_gets=[
MockGet(
product_type=CreatedBinary,
subject_type=TestBinaryConfiguration,
mock=lambda _: self.create_mock_binary(program_text),
),
],
)
return cast(Run, res)
def single_target_run(
self,
*,
console: MockConsole,
program_text: bytes,
address_spec: str,
) -> Run:
workspace = Workspace(self.scheduler)
interactive_runner = InteractiveRunner(self.scheduler)
class TestRunFieldSet(RunFieldSet):
required_fields = ()
class TestBinaryTarget(Target):
alias = "binary"
core_fields = ()
address = Address.parse(address_spec)
target = TestBinaryTarget({}, address=address)
target_with_origin = TargetWithOrigin(
target, AddressLiteralSpec(address.spec_path, address.target_name))
field_set = TestRunFieldSet.create(target)
res = run_rule(
run,
rule_args=[
create_goal_subsystem(RunSubsystem, args=[]),
create_subsystem(GlobalOptions,
pants_workdir=self.pants_workdir),
console,
interactive_runner,
workspace,
BuildRoot(),
],
mock_gets=[
MockGet(
product_type=TargetsToValidFieldSets,
subject_type=TargetsToValidFieldSetsRequest,
mock=lambda _: TargetsToValidFieldSets(
{target_with_origin: [field_set]}),
),
MockGet(
product_type=RunRequest,
subject_type=TestRunFieldSet,
mock=lambda _: self.create_mock_run_request(program_text),
),
],
)
return cast(Run, res)
def run_fmt_rule(
self,
*,
language_target_collection_types: List[Type[LanguageFmtTargets]],
targets: List[Target],
result_digest: Digest,
per_file_caching: bool,
include_sources: bool = True,
) -> str:
console = MockConsole(use_colors=False)
union_membership = UnionMembership(
{LanguageFmtTargets: language_target_collection_types})
result: Fmt = run_rule(
fmt,
rule_args=[
console,
Targets(targets),
create_goal_subsystem(FmtSubsystem,
per_file_caching=per_file_caching,
per_target_caching=False),
Workspace(self.scheduler),
union_membership,
],
mock_gets=[
MockGet(
product_type=LanguageFmtResults,
subject_type=LanguageFmtTargets,
mock=lambda language_targets_collection:
language_targets_collection.language_fmt_results(
result_digest),
),
MockGet(
product_type=TargetsWithSources,
subject_type=TargetsWithSourcesRequest,
mock=lambda tgts: TargetsWithSources(
tgts if include_sources else ()),
),
MockGet(
product_type=Digest,
subject_type=MergeDigests,
mock=lambda _: result_digest,
),
],
union_membership=union_membership,
)
assert result.exit_code == 0
assert not console.stdout.getvalue()
return cast(str, console.stderr.getvalue())
def run_goal(
*, union_membership: Optional[UnionMembership] = None, details_target: Optional[str] = None
) -> str:
console = MockConsole(use_colors=False)
run_rule(
list_target_types,
rule_args=[
RegisteredTargetTypes.create([FortranBinary, FortranLibrary, FortranTests]),
union_membership or UnionMembership({}),
create_goal_subsystem(
TargetTypesOptions, sep="\\n", output_file=None, details=details_target
),
create_subsystem(GlobalOptions, v1=False),
console,
],
)
return cast(str, console.stdout.getvalue())
def run_lint_rule(
self,
*,
lint_request_types: List[Type[LintRequest]],
targets: List[Target],
per_file_caching: bool,
include_sources: bool = True,
) -> Tuple[int, str]:
console = MockConsole(use_colors=False)
workspace = Workspace(self.scheduler)
union_membership = UnionMembership({LintRequest: lint_request_types})
result: Lint = run_rule(
lint,
rule_args=[
console,
workspace,
Targets(targets),
create_goal_subsystem(
LintSubsystem, per_file_caching=per_file_caching, per_target_caching=False
),
union_membership,
],
mock_gets=[
MockGet(
product_type=LintResults,
subject_type=LintRequest,
mock=lambda field_set_collection: field_set_collection.lint_results,
),
MockGet(
product_type=FieldSetsWithSources,
subject_type=FieldSetsWithSourcesRequest,
mock=lambda field_sets: FieldSetsWithSources(
field_sets if include_sources else ()
),
),
MockGet(
product_type=Digest, subject_type=MergeDigests, mock=lambda _: EMPTY_DIGEST
),
],
union_membership=union_membership,
)
assert not console.stdout.getvalue()
return result.exit_code, console.stderr.getvalue()
def test_list_backends() -> None:
# NB: Here, we assume that the code to find all the `register.py`s is valid. Instead, the focus
# is on us being able to correctly extract all the relevant information from those
# `register.py` files and then to format the information.
all_register_pys = FilesContent([
FileContent(
"src/python/pants/backend/fortran/register.py",
dedent('''\
"""Support for Fortran 98."""
# V1 entry-point
def register_goals():
pass
# This naively looks like a V2 entry-point, but it's not!
def rules(x: int):
pass
''').encode(),
),
FileContent(
"contrib/elixir/src/python/pants/contrib/elixir/register.py",
dedent("""\
# V1 entry-point
def register_goals():
pass
# V2 entry-point
def rules():
pass
""").encode(),
),
FileContent(
"src/python/pants/core/register.py",
dedent('''\
"""Core V2 rules.
These are always activated.
"""
def rules():
pass
''').encode(),
),
])
console = MockConsole(use_colors=False)
run_rule(
list_backends,
rule_args=[
create_goal_subsystem(BackendsOptions, sep="\\n",
output_file=None),
global_subsystem_instance(SourceRootConfig),
global_subsystem_instance(GlobalOptions),
console,
],
mock_gets=[
MockGet(product_type=Snapshot,
subject_type=PathGlobs,
mock=lambda _: EMPTY_SNAPSHOT),
MockGet(product_type=FilesContent,
subject_type=Digest,
mock=lambda _: all_register_pys),
],
)
assert console.stdout.getvalue() == dedent("""\
V1 backends
-----------
To enable V1 backends, add the backend to `backend_packages.add` in your
`pants.toml`, like this:
[GLOBAL]
backend_packages.add = ["pants.backend.python"]
In the below list, all activated backends end with `*`.
pants.backend.fortran Support for Fortran 98.
pants.contrib.elixir <no description>
V2 backends
-----------
To enable V2 backends, add the backend to `backend_packages2.add` in your
`pants.toml`, like this:
[GLOBAL]
backend_packages2.add = ["pants.backend.python"]
In the below list, all activated backends end with `*`.
pants.contrib.elixir <no description>
pants.core* Core V2 rules. These are always activated.
""")
def run_test_rule(
self,
*,
field_set: Type[TestFieldSet],
targets: List[TargetWithOrigin],
debug: bool = False,
use_coverage: bool = False,
include_sources: bool = True,
valid_targets: bool = True,
) -> Tuple[int, str]:
console = MockConsole(use_colors=False)
options = create_goal_subsystem(TestOptions,
debug=debug,
use_coverage=use_coverage)
interactive_runner = InteractiveRunner(self.scheduler)
workspace = Workspace(self.scheduler)
union_membership = UnionMembership({
TestFieldSet: [field_set],
CoverageDataCollection: [MockCoverageDataCollection]
})
def mock_find_valid_field_sets(
_: TargetsToValidFieldSetsRequest, ) -> TargetsToValidFieldSets:
if not valid_targets:
return TargetsToValidFieldSets({})
return TargetsToValidFieldSets({
tgt_with_origin: [field_set.create(tgt_with_origin)]
for tgt_with_origin in targets
})
def mock_coordinator_of_tests(
wrapped_field_set: WrappedTestFieldSet, ) -> AddressAndTestResult:
field_set = cast(MockTestFieldSet, wrapped_field_set.field_set)
return AddressAndTestResult(address=field_set.address,
test_result=field_set.test_result)
def mock_coverage_report_generation(
coverage_data_collection: MockCoverageDataCollection,
) -> CoverageReports:
addresses = ", ".join(
coverage_data.address.spec
for coverage_data in coverage_data_collection)
console_report = ConsoleCoverageReport(
f"Ran coverage on {addresses}")
return CoverageReports(reports=(console_report, ))
result: Test = run_rule(
run_tests,
rule_args=[
console, options, interactive_runner, workspace,
union_membership
],
mock_gets=[
MockGet(
product_type=TargetsToValidFieldSets,
subject_type=TargetsToValidFieldSetsRequest,
mock=mock_find_valid_field_sets,
),
MockGet(
product_type=AddressAndTestResult,
subject_type=WrappedTestFieldSet,
mock=lambda wrapped_config: mock_coordinator_of_tests(
wrapped_config),
),
MockGet(
product_type=TestDebugRequest,
subject_type=TestFieldSet,
mock=lambda _: TestDebugRequest(
self.make_interactive_process()),
),
MockGet(
product_type=FieldSetsWithSources,
subject_type=FieldSetsWithSourcesRequest,
mock=lambda field_sets: FieldSetsWithSources(
field_sets if include_sources else ()),
),
MockGet(
product_type=CoverageReports,
subject_type=CoverageDataCollection,
mock=mock_coverage_report_generation,
),
],
union_membership=union_membership,
)
assert not console.stdout.getvalue()
return result.exit_code, console.stderr.getvalue()
def run_test_rule(
self,
*,
field_set: Type[TestFieldSet],
targets: List[TargetWithOrigin],
debug: bool = False,
use_coverage: bool = False,
output: ShowOutput = ShowOutput.ALL,
include_sources: bool = True,
valid_targets: bool = True,
) -> Tuple[int, str]:
console = MockConsole(use_colors=False)
test_subsystem = create_goal_subsystem(
TestSubsystem, debug=debug, use_coverage=use_coverage, output=output,
)
interactive_runner = InteractiveRunner(self.scheduler)
workspace = Workspace(self.scheduler)
union_membership = UnionMembership(
{TestFieldSet: [field_set], CoverageDataCollection: [MockCoverageDataCollection]}
)
def mock_find_valid_field_sets(
_: TargetsToValidFieldSetsRequest,
) -> TargetsToValidFieldSets:
if not valid_targets:
return TargetsToValidFieldSets({})
return TargetsToValidFieldSets(
{
tgt_with_origin: [field_set.create(tgt_with_origin.target)]
for tgt_with_origin in targets
}
)
def mock_coverage_report_generation(
coverage_data_collection: MockCoverageDataCollection,
) -> CoverageReports:
addresses = ", ".join(
coverage_data.address.spec for coverage_data in coverage_data_collection
)
console_report = ConsoleCoverageReport(f"Ran coverage on {addresses}")
return CoverageReports(reports=(console_report,))
result: Test = run_rule(
run_tests,
rule_args=[console, test_subsystem, interactive_runner, workspace, union_membership],
mock_gets=[
MockGet(
product_type=TargetsToValidFieldSets,
subject_type=TargetsToValidFieldSetsRequest,
mock=mock_find_valid_field_sets,
),
MockGet(
product_type=EnrichedTestResult,
subject_type=TestFieldSet,
mock=lambda fs: fs.test_result,
),
MockGet(
product_type=TestDebugRequest,
subject_type=TestFieldSet,
mock=lambda _: TestDebugRequest(self.make_interactive_process()),
),
MockGet(
product_type=FieldSetsWithSources,
subject_type=FieldSetsWithSourcesRequest,
mock=lambda field_sets: FieldSetsWithSources(
field_sets if include_sources else ()
),
),
# Merge XML results.
MockGet(
product_type=Digest, subject_type=MergeDigests, mock=lambda _: EMPTY_DIGEST,
),
MockGet(
product_type=CoverageReports,
subject_type=CoverageDataCollection,
mock=mock_coverage_report_generation,
),
],
union_membership=union_membership,
)
assert not console.stdout.getvalue()
return result.exit_code, console.stderr.getvalue()
def run_test_rule(
self,
*,
config: Type[TestConfiguration],
targets: List[TargetWithOrigin],
debug: bool = False,
include_sources: bool = True,
) -> Tuple[int, str]:
console = MockConsole(use_colors=False)
options = create_goal_subsystem(TestOptions,
debug=debug,
run_coverage=False)
interactive_runner = InteractiveRunner(self.scheduler)
workspace = Workspace(self.scheduler)
union_membership = UnionMembership(
{TestConfiguration: OrderedSet([config])})
def mock_coordinator_of_tests(
wrapped_config: WrappedTestConfiguration,
) -> AddressAndTestResult:
config = wrapped_config.config
return AddressAndTestResult(
address=config.address,
test_result=config.test_result, # type: ignore[attr-defined]
)
result: Test = run_rule(
run_tests,
rule_args=[
console,
options,
interactive_runner,
TargetsWithOrigins(targets),
workspace,
union_membership,
RegisteredTargetTypes.create([MockTarget]),
],
mock_gets=[
MockGet(
product_type=AddressAndTestResult,
subject_type=WrappedTestConfiguration,
mock=lambda wrapped_config: mock_coordinator_of_tests(
wrapped_config),
),
MockGet(
product_type=TestDebugRequest,
subject_type=TestConfiguration,
mock=lambda _: TestDebugRequest(self.make_ipr()),
),
MockGet(
product_type=ConfigurationsWithSources,
subject_type=ConfigurationsWithSourcesRequest,
mock=lambda configs: ConfigurationsWithSources(
configs if include_sources else ()),
),
MockGet(
product_type=CoverageReport,
subject_type=CoverageDataCollection,
mock=lambda _: FilesystemCoverageReport(
result_digest=EMPTY_DIRECTORY_DIGEST,
directory_to_materialize_to=PurePath("mockety/mock"),
report_file=None,
),
),
],
union_membership=union_membership,
)
return result.exit_code, console.stdout.getvalue()
