def run_goal(
targets: Sequence[Target],
*,
target_type: list[str] | None = None,
address_regex: list[str] | None = None,
tag_regex: list[str] | None = None,
granularity: TargetGranularity | None = None,
) -> str:
with mock_console(create_options_bootstrapper()) as (console,
stdio_reader):
run_rule_with_mocks(
filter_targets,
rule_args=[
Targets(targets),
create_goal_subsystem(
FilterSubsystem,
sep="\\n",
output_file=None,
target_type=target_type or [],
address_regex=address_regex or [],
tag_regex=tag_regex or [],
granularity=granularity or TargetGranularity.all_targets,
# Deprecated.
type=[],
target=[],
regex=[],
ancestor=[],
),
console,
RegisteredTargetTypes.create({type(tgt)
for tgt in targets}),
],
)
assert not stdio_reader.get_stderr()
return stdio_reader.get_stdout()
def run_lint_rule(
rule_runner: RuleRunner,
*,
lint_request_types: List[Type[LintRequest]],
targets: List[Target],
per_file_caching: bool,
) -> Tuple[int, str]:
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
union_membership = UnionMembership({LintRequest: lint_request_types})
result: Lint = run_rule_with_mocks(
lint,
rule_args=[
console,
Workspace(rule_runner.scheduler, _enforce_effects=False),
Targets(targets),
create_goal_subsystem(LintSubsystem,
per_file_caching=per_file_caching,
per_target_caching=False),
union_membership,
DistDir(relpath=Path("dist")),
],
mock_gets=[
MockGet(
output_type=LintResults,
input_type=LintRequest,
mock=lambda field_set_collection: field_set_collection.
lint_results,
)
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
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_with_mocks(
filter_targets,
rule_args=[
Targets(targets),
create_goal_subsystem(
FilterSubsystem,
sep="\\n",
output_file=None,
target_type=target_type or [],
address_regex=address_regex or [],
tag_regex=tag_regex or [],
# Deprecated.
type=[],
target=[],
regex=[],
ancestor=[],
),
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)
with mock_console(create_options_bootstrapper()) as (console,
stdio_reader):
result: OutputtingGoal = run_rule_with_mocks(
output_rule,
rule_args=[
console,
create_goal_subsystem(OutputtingGoalOptions,
sep="\\n",
output_file=None),
],
)
assert result.exit_code == 0
assert stdio_reader.get_stdout() == "output...line oriented\n"
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_with_mocks(
list_targets,
rule_args=[
Addresses(tgt.address for tgt in targets),
create_goal_subsystem(
ListSubsystem,
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=UnexpandedTargets,
subject_type=Addresses,
mock=lambda _: UnexpandedTargets(targets),
)
],
)
return cast(str,
console.stdout.getvalue()), cast(str,
console.stderr.getvalue())
def run_goal(targets: list[MockTarget],
*,
show_documented: bool = False) -> tuple[str, str]:
with mock_console(create_options_bootstrapper()) as (console,
stdio_reader):
run_rule_with_mocks(
list_targets,
rule_args=[
Addresses(tgt.address for tgt in targets),
create_goal_subsystem(
ListSubsystem,
sep="\\n",
output_file=None,
documented=show_documented,
),
console,
],
mock_gets=[
MockGet(
output_type=UnexpandedTargets,
input_type=Addresses,
mock=lambda _: UnexpandedTargets(targets),
)
],
)
return stdio_reader.get_stdout(), stdio_reader.get_stderr()
def test_goal_scope_flag() -> None:
class DummyGoal(GoalSubsystem):
name = "dummy"
dummy = create_goal_subsystem(DummyGoal)
assert dummy.get_scope_info() == ScopeInfo(scope="dummy",
subsystem_cls=DummyGoal,
is_goal=True)
def single_target_run(
rule_runner: RuleRunner,
address: Address,
*,
program_text: bytes,
) -> Run:
workspace = Workspace(rule_runner.scheduler, _enforce_effects=False)
class TestRunFieldSet(RunFieldSet):
required_fields = ()
class TestBinaryTarget(Target):
alias = "binary"
core_fields = ()
target = TestBinaryTarget({}, address)
field_set = TestRunFieldSet.create(target)
with mock_console(rule_runner.options_bootstrapper) as (console, _):
res = run_rule_with_mocks(
run,
rule_args=[
create_goal_subsystem(RunSubsystem, args=[], cleanup=True),
create_subsystem(GlobalOptions,
pants_workdir=rule_runner.pants_workdir,
process_cleanup=True),
workspace,
BuildRoot(),
rule_runner.environment,
],
mock_gets=[
MockGet(
output_type=TargetRootsToFieldSets,
input_type=TargetRootsToFieldSetsRequest,
mock=lambda _: TargetRootsToFieldSets(
{target: [field_set]}),
),
MockGet(
output_type=WrappedTarget,
input_type=WrappedTargetRequest,
mock=lambda _: WrappedTarget(target),
),
MockGet(
output_type=RunRequest,
input_type=TestRunFieldSet,
mock=lambda _: create_mock_run_request(
rule_runner, program_text),
),
MockEffect(
output_type=InteractiveProcessResult,
input_type=InteractiveProcess,
mock=rule_runner.run_interactive_process,
),
],
)
return cast(Run, res)
def test_validate_build_file_name(include: str, file_name: str,
raises: bool) -> None:
tailor_subsystem = create_goal_subsystem(TailorSubsystem,
build_file_name=file_name)
if raises:
with pytest.raises(ValueError):
tailor_subsystem.validate_build_file_name((include, ))
else:
with no_exception():
tailor_subsystem.validate_build_file_name((include, ))
def run_lint_rule(
rule_runner: RuleRunner,
*,
lint_request_types: Sequence[Type[LintTargetsRequest]],
targets: list[Target],
run_files_linter: bool = False,
batch_size: int = 128,
only: list[str] | None = None,
) -> Tuple[int, str]:
union_membership = UnionMembership({
LintTargetsRequest:
lint_request_types,
LintFilesRequest: [MockFilesRequest] if run_files_linter else [],
})
lint_subsystem = create_goal_subsystem(
LintSubsystem,
batch_size=batch_size,
only=only or [],
)
specs_snapshot = SpecsSnapshot(
rule_runner.make_snapshot_of_empty_files(["f.txt"]))
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
result: Lint = run_rule_with_mocks(
lint,
rule_args=[
console,
Workspace(rule_runner.scheduler, _enforce_effects=False),
Targets(targets),
specs_snapshot,
lint_subsystem,
union_membership,
DistDir(relpath=Path("dist")),
],
mock_gets=[
MockGet(
output_type=LintResults,
input_type=LintTargetsRequest,
mock=lambda mock_request: mock_request.lint_results,
),
MockGet(
output_type=LintResults,
input_type=LintFilesRequest,
mock=lambda mock_request: mock_request.lint_results,
),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
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_with_mocks(
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 test_filter_by_ignores() -> None:
tailor_subsystem = create_goal_subsystem(
TailorSubsystem,
build_file_name="BUILD",
ignore_paths=[
"path_ignore/**", "path_ignore_not_recursive/BUILD",
"path_ignore_unused/*"
],
ignore_adding_targets=["project:bad", "//:bad", "unused:t"],
)
def make_ptgt(path: str,
name: str,
*,
addressable: bool = True) -> PutativeTarget:
return PutativeTarget(
path=path,
name=name,
type_alias="some_tgt",
triggering_sources=[],
owned_sources=[],
)
valid_ptgts = [
make_ptgt("", "good"),
make_ptgt("project", "good"),
make_ptgt("project", "caof_macro", addressable=False),
make_ptgt("path_ignore_not_recursive/subdir", "t"),
make_ptgt("global_build_ignore_not_recursive/subdir", "t"),
]
ignored_ptgts = [
make_ptgt("", "bad"),
make_ptgt("project", "bad"),
make_ptgt("path_ignore", "t"),
make_ptgt("path_ignore/subdir", "t"),
make_ptgt("path_ignore_not_recursive", "t"),
make_ptgt("global_build_ignore", "t"),
make_ptgt("global_build_ignore/subdir", "t"),
make_ptgt("global_build_ignore_not_recursive", "t"),
]
result = tailor_subsystem.filter_by_ignores(
[*valid_ptgts, *ignored_ptgts],
build_file_ignores=(
"global_build_ignore/**",
"global_build_ignore_not_recursive/BUILD",
"global_unused/*",
),
)
assert set(result) == set(valid_ptgts)
def run_fmt_rule(
rule_runner: RuleRunner,
*,
language_target_collection_types: List[Type[LanguageFmtTargets]],
targets: List[Target],
result_digest: Digest,
per_file_caching: bool,
include_sources: bool = True,
) -> str:
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
union_membership = UnionMembership(
{LanguageFmtTargets: language_target_collection_types})
result: Fmt = run_rule_with_mocks(
fmt,
rule_args=[
console,
Targets(targets),
create_goal_subsystem(FmtSubsystem,
per_file_caching=per_file_caching,
per_target_caching=False),
Workspace(rule_runner.scheduler),
union_membership,
],
mock_gets=[
MockGet(
output_type=LanguageFmtResults,
input_type=LanguageFmtTargets,
mock=lambda language_targets_collection:
language_targets_collection.language_fmt_results(
result_digest),
),
MockGet(
output_type=TargetsWithSources,
input_type=TargetsWithSourcesRequest,
mock=lambda tgts: TargetsWithSources(
tgts if include_sources else ()),
),
MockGet(
output_type=Digest,
input_type=MergeDigests,
mock=lambda _: result_digest,
),
],
union_membership=union_membership,
)
assert result.exit_code == 0
assert not stdio_reader.get_stdout()
return stdio_reader.get_stderr()
def test_specs_filter() -> None:
class MockTgt1(Target):
alias = "tgt1"
core_fields = (Tags, )
class MockTgt2(Target):
alias = "tgt2"
core_fields = (Tags, )
specs_filter = SpecsFilter.create(
create_goal_subsystem(
FilterSubsystem,
target_type=["tgt1"],
tag_regex=[],
address_regex=[],
granularity=TargetGranularity.all_targets,
),
RegisteredTargetTypes({
"tgt1": MockTgt1,
"tgt2": MockTgt2
}),
tags=["-a", "+b"],
exclude_target_regexps=["skip-me"],
)
def make_tgt1(name: str, tags: list[str] | None = None) -> MockTgt1:
return MockTgt1({Tags.alias: tags}, Address("", target_name=name))
def make_tgt2(name: str, tags: list[str] | None = None) -> MockTgt2:
return MockTgt2({Tags.alias: tags}, Address("", target_name=name))
untagged_tgt = make_tgt1(name="untagged")
b_tagged_tgt = make_tgt1(name="b-tagged", tags=["b"])
b_tagged_exclude_regex_tgt = make_tgt1(name="skip-me", tags=["b"])
a_and_b_tagged_tgt = make_tgt1(name="a-and-b-tagged", tags=["a", "b"])
# Even though this has the tag `b`, it should be excluded because the target type.
tgt2 = make_tgt2("tgt2", tags=["b"])
def matches(tgt: Target) -> bool:
return specs_filter.matches(tgt)
assert matches(b_tagged_tgt) is True
for t in (untagged_tgt, b_tagged_exclude_regex_tgt, a_and_b_tagged_tgt,
tgt2):
assert matches(t) is False
def run_goal(
*, union_membership: Optional[UnionMembership] = None, details_target: Optional[str] = None
) -> str:
console = MockConsole(use_colors=False)
run_rule_with_mocks(
list_target_types,
rule_args=[
RegisteredTargetTypes.create([FortranBinary, FortranLibrary, FortranTests]),
union_membership or UnionMembership({}),
create_goal_subsystem(
TargetTypesSubsystem, sep="\\n", output_file=None, details=details_target
),
console,
PantsBin(name="./BNF"),
],
)
return cast(str, console.stdout.getvalue())
def single_target_run(
rule_runner: RuleRunner,
address: Address,
console: MockConsole,
*,
program_text: bytes,
) -> Run:
workspace = Workspace(rule_runner.scheduler)
interactive_runner = InteractiveRunner(rule_runner.scheduler)
class TestRunFieldSet(RunFieldSet):
required_fields = ()
class TestBinaryTarget(Target):
alias = "binary"
core_fields = ()
target = TestBinaryTarget({}, address=address)
field_set = TestRunFieldSet.create(target)
res = run_rule_with_mocks(
run,
rule_args=[
create_goal_subsystem(RunSubsystem, args=[]),
create_subsystem(GlobalOptions,
pants_workdir=rule_runner.pants_workdir),
console,
interactive_runner,
workspace,
BuildRoot(),
],
mock_gets=[
MockGet(
output_type=TargetRootsToFieldSets,
input_type=TargetRootsToFieldSetsRequest,
mock=lambda _: TargetRootsToFieldSets({target: [field_set]}),
),
MockGet(
output_type=RunRequest,
input_type=TestRunFieldSet,
mock=lambda _: create_mock_run_request(rule_runner,
program_text),
),
],
)
return cast(Run, res)
def run_lint_rule(
rule_runner: RuleRunner,
*,
lint_request_types: List[Type[LintRequest]],
targets: List[Target],
per_file_caching: bool,
include_sources: bool = True,
) -> Tuple[int, str]:
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
workspace = Workspace(rule_runner.scheduler)
union_membership = UnionMembership({LintRequest: lint_request_types})
result: Lint = run_rule_with_mocks(
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(
output_type=EnrichedLintResults,
input_type=LintRequest,
mock=lambda field_set_collection: field_set_collection.
lint_results,
),
MockGet(
output_type=FieldSetsWithSources,
input_type=FieldSetsWithSourcesRequest,
mock=lambda field_sets: FieldSetsWithSources(
field_sets if include_sources else ()),
),
MockGet(output_type=Digest,
input_type=MergeDigests,
mock=lambda _: EMPTY_DIGEST),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
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_with_mocks(
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 run_export_rule(rule_runner: RuleRunner,
targets: List[Target]) -> Tuple[int, str]:
union_membership = UnionMembership(
{ExportableDataRequest: [MockExportableDataRequest]})
with open(os.path.join(rule_runner.build_root, "somefile"), "wb") as fp:
fp.write(b"SOMEFILE")
with mock_console(create_options_bootstrapper()) as (console,
stdio_reader):
digest = rule_runner.request(
Digest, [CreateDigest([FileContent("foo/bar", b"BAR")])])
result: Export = run_rule_with_mocks(
export,
rule_args=[
console,
Targets(targets),
create_goal_subsystem(ExportSubsystem),
Workspace(rule_runner.scheduler, _enforce_effects=False),
union_membership,
BuildRoot(),
DistDir(relpath=Path("dist")),
],
mock_gets=[
MockGet(
output_type=ExportableData,
input_type=ExportableDataRequest,
mock=lambda edr: mock_export(edr, digest, (Symlink(
"somefile", "link_to_somefile"), )),
),
MockGet(
output_type=Digest,
input_type=MergeDigests,
mock=lambda md: rule_runner.request(Digest, [md]),
),
MockGet(
output_type=Digest,
input_type=AddPrefix,
mock=lambda ap: rule_runner.request(Digest, [ap]),
),
],
union_membership=union_membership,
)
return result.exit_code, stdio_reader.get_stdout()
def run_test_rule(
rule_runner: RuleRunner,
*,
field_set: type[TestFieldSet],
targets: list[Target],
debug: bool = False,
use_coverage: bool = False,
xml_dir: str | None = None,
output: ShowOutput = ShowOutput.ALL,
valid_targets: bool = True,
run_id: RunId = RunId(999),
) -> tuple[int, str]:
test_subsystem = create_goal_subsystem(
TestSubsystem,
debug=debug,
use_coverage=use_coverage,
xml_dir=xml_dir,
output=output,
extra_env_vars=[],
)
workspace = Workspace(rule_runner.scheduler, _enforce_effects=False)
union_membership = UnionMembership({
TestFieldSet: [field_set],
CoverageDataCollection: [MockCoverageDataCollection],
})
def mock_find_valid_field_sets(
_: TargetRootsToFieldSetsRequest, ) -> TargetRootsToFieldSets:
if not valid_targets:
return TargetRootsToFieldSets({})
return TargetRootsToFieldSets(
{tgt: [field_set.create(tgt)]
for tgt in targets})
def mock_debug_request(_: TestFieldSet) -> TestDebugRequest:
return TestDebugRequest(
InteractiveProcess(["/bin/example"], input_digest=EMPTY_DIGEST))
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(
coverage_insufficient=False, report=f"Ran coverage on {addresses}")
return CoverageReports(reports=(console_report, ))
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
result: Test = run_rule_with_mocks(
run_tests,
rule_args=[
console,
test_subsystem,
workspace,
union_membership,
DistDir(relpath=Path("dist")),
run_id,
],
mock_gets=[
MockGet(
output_type=TargetRootsToFieldSets,
input_type=TargetRootsToFieldSetsRequest,
mock=mock_find_valid_field_sets,
),
MockGet(
output_type=TestResult,
input_type=TestFieldSet,
mock=lambda fs: fs.test_result,
),
MockGet(
output_type=TestDebugRequest,
input_type=TestFieldSet,
mock=mock_debug_request,
),
# Merge XML results.
MockGet(
output_type=Digest,
input_type=MergeDigests,
mock=lambda _: EMPTY_DIGEST,
),
MockGet(
output_type=CoverageReports,
input_type=CoverageDataCollection,
mock=mock_coverage_report_generation,
),
MockGet(
output_type=OpenFiles,
input_type=OpenFilesRequest,
mock=lambda _: OpenFiles(()),
),
MockEffect(
output_type=InteractiveProcessResult,
input_type=InteractiveProcess,
mock=lambda _: InteractiveProcessResult(0),
),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
def test_tailor_rule(rule_runner: RuleRunner) -> None:
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
workspace = Workspace(rule_runner.scheduler)
union_membership = UnionMembership(
{PutativeTargetsRequest: [MockPutativeTargetsRequest]})
specs = Specs(address_specs=AddressSpecs(tuple()),
filesystem_specs=FilesystemSpecs(tuple()))
run_rule_with_mocks(
tailor.tailor,
rule_args=[
create_goal_subsystem(
TailorSubsystem,
build_file_name="BUILD",
build_file_header="",
build_file_indent=" ",
alias_mapping={"fortran_library": "my_fortran_lib"},
),
console,
workspace,
union_membership,
specs,
],
mock_gets=[
MockGet(
output_type=PutativeTargets,
input_type=PutativeTargetsRequest,
mock=lambda req: PutativeTargets([
PutativeTarget.
for_target_type(FortranTests, "src/fortran/foo",
"tests", ["bar1_test.f90"]),
PutativeTarget.for_target_type(
FortranLibrary, "src/fortran/baz", "baz",
["qux1.f90"]),
PutativeTarget.for_target_type(
FortranLibrary,
"src/fortran/conflict",
"conflict",
["conflict1.f90", "conflict2.f90"],
),
]),
),
MockGet(
output_type=UniquelyNamedPutativeTargets,
input_type=PutativeTargets,
mock=lambda pts: UniquelyNamedPutativeTargets(
PutativeTargets([
pt.rename("conflict0")
if pt.name == "conflict" else pt for pt in pts
])),
),
MockGet(
output_type=DisjointSourcePutativeTarget,
input_type=PutativeTarget,
# This test exists to test the console output, which isn't affected by
# whether the sources of a putative target were modified due to conflict,
# so we don't bother to inject such modifications. The BUILD file content
# generation, which is so affected, is tested separately above.
mock=lambda pt: DisjointSourcePutativeTarget(pt),
),
MockGet(
output_type=EditedBuildFiles,
input_type=EditBuildFilesRequest,
mock=lambda _: EditedBuildFiles(
# We test that the created digest contains what we expect above, and we
# don't need to test here that writing digests to the Workspace works.
# So the empty digest is sufficient.
digest=EMPTY_DIGEST,
created_paths=("src/fortran/baz/BUILD", ),
updated_paths=(
"src/fortran/foo/BUILD",
"src/fortran/conflict/BUILD",
),
),
),
],
union_membership=union_membership,
)
stdout_str = stdio_reader.get_stdout()
assert "Created src/fortran/baz/BUILD:\n - Added my_fortran_lib target baz" in stdout_str
assert "Updated src/fortran/foo/BUILD:\n - Added fortran_tests target tests" in stdout_str
assert (
"Updated src/fortran/conflict/BUILD:\n - Added my_fortran_lib target conflict0"
) in stdout_str
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_with_mocks(
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,
),
MockGet(
product_type=OpenFiles,
subject_type=OpenFilesRequest,
mock=lambda _: OpenFiles(()),
),
],
union_membership=union_membership,
)
assert not console.stdout.getvalue()
return result.exit_code, console.stderr.getvalue()
def run_test_rule(
rule_runner: RuleRunner,
*,
field_set: Type[TestFieldSet],
targets: List[Target],
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,
extra_env_vars=[],
)
interactive_runner = InteractiveRunner(rule_runner.scheduler)
workspace = Workspace(rule_runner.scheduler)
union_membership = UnionMembership({
TestFieldSet: [field_set],
CoverageDataCollection: [MockCoverageDataCollection]
})
def mock_find_valid_field_sets(
_: TargetRootsToFieldSetsRequest, ) -> TargetRootsToFieldSets:
if not valid_targets:
return TargetRootsToFieldSets({})
return TargetRootsToFieldSets(
{tgt: [field_set.create(tgt)]
for tgt in targets})
def mock_debug_request(_: TestFieldSet) -> TestDebugRequest:
digest = rule_runner.request(Digest, [
CreateDigest((FileContent(path="program.py",
content=b"def test(): pass"), ))
])
process = InteractiveProcess(["/usr/bin/python", "program.py"],
input_digest=digest)
return TestDebugRequest(process)
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_with_mocks(
run_tests,
rule_args=[
console,
test_subsystem,
interactive_runner,
workspace,
union_membership,
],
mock_gets=[
MockGet(
output_type=TargetRootsToFieldSets,
input_type=TargetRootsToFieldSetsRequest,
mock=mock_find_valid_field_sets,
),
MockGet(
output_type=EnrichedTestResult,
input_type=TestFieldSet,
mock=lambda fs: fs.test_result,
),
MockGet(
output_type=TestDebugRequest,
input_type=TestFieldSet,
mock=mock_debug_request,
),
MockGet(
output_type=FieldSetsWithSources,
input_type=FieldSetsWithSourcesRequest,
mock=lambda field_sets: FieldSetsWithSources(
field_sets if include_sources else ()),
),
# Merge XML results.
MockGet(
output_type=Digest,
input_type=MergeDigests,
mock=lambda _: EMPTY_DIGEST,
),
MockGet(
output_type=CoverageReports,
input_type=CoverageDataCollection,
mock=mock_coverage_report_generation,
),
MockGet(
output_type=OpenFiles,
input_type=OpenFilesRequest,
mock=lambda _: OpenFiles(()),
),
],
union_membership=union_membership,
)
assert not console.stdout.getvalue()
return result.exit_code, console.stderr.getvalue()
def run_lint_rule(
rule_runner: RuleRunner,
*,
lint_request_types: Sequence[Type[LintTargetsRequest]],
fmt_request_types: Sequence[Type[FmtRequest]] = (),
targets: list[Target],
run_files_linter: bool = False,
batch_size: int = 128,
only: list[str] | None = None,
skip_formatters: bool = False,
) -> Tuple[int, str]:
union_membership = UnionMembership({
LintTargetsRequest:
lint_request_types,
LintFilesRequest: [MockFilesRequest] if run_files_linter else [],
FmtRequest:
fmt_request_types,
})
lint_subsystem = create_goal_subsystem(
LintSubsystem,
batch_size=batch_size,
only=only or [],
skip_formatters=skip_formatters,
)
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
result: Lint = run_rule_with_mocks(
lint,
rule_args=[
console,
Workspace(rule_runner.scheduler, _enforce_effects=False),
Specs.empty(),
lint_subsystem,
union_membership,
DistDir(relpath=Path("dist")),
],
mock_gets=[
MockGet(
output_type=SourceFiles,
input_type=SourceFilesRequest,
mock=lambda _: SourceFiles(EMPTY_SNAPSHOT, ()),
),
MockGet(
output_type=LintResults,
input_type=LintTargetsRequest,
mock=lambda mock_request: mock_request.lint_results,
),
MockGet(
output_type=LintResults,
input_type=LintFilesRequest,
mock=lambda mock_request: mock_request.lint_results,
),
MockGet(
output_type=FmtResult,
input_type=FmtRequest,
mock=lambda mock_request: mock_request.fmt_result,
),
MockGet(
output_type=FilteredTargets,
input_type=Specs,
mock=lambda _: FilteredTargets(targets),
),
MockGet(
output_type=SpecsPaths,
input_type=Specs,
mock=lambda _: SpecsPaths(("f.txt", ), ()),
),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
