def test_distdir() -> None:
buildroot = Path("/buildroot")
assert DistDir(relpath=Path("dist")) == validate_distdir(
Path("dist"), buildroot)
assert DistDir(relpath=Path("dist")) == validate_distdir(
Path("/buildroot/dist"), buildroot)
with pytest.raises(InvalidDistDir):
validate_distdir(Path("/other/dist"), buildroot)
def run_typecheck_rule(
*,
request_types: Sequence[Type[CheckRequest]],
targets: list[Target],
only: list[str] | None = None,
) -> Tuple[int, str]:
union_membership = UnionMembership({CheckRequest: request_types})
check_subsystem = create_subsystem(CheckSubsystem, only=only or [])
with mock_console(create_options_bootstrapper()) as (console, stdio_reader):
rule_runner = RuleRunner()
result: Check = run_rule_with_mocks(
check,
rule_args=[
console,
Workspace(rule_runner.scheduler, _enforce_effects=False),
Targets(targets),
DistDir(relpath=Path("dist")),
union_membership,
check_subsystem,
],
mock_gets=[
MockGet(
output_type=CheckResults,
input_type=CheckRequest,
mock=lambda field_set_collection: field_set_collection.check_results,
),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
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 test_write_reports() -> None:
rule_runner = RuleRunner()
report_digest = rule_runner.make_snapshot_of_empty_files(["r.txt"]).digest
no_results = CheckResults([], checker_name="none")
_empty_result = CheckResult(0, "", "", report=EMPTY_DIGEST)
empty_results = CheckResults([_empty_result], checker_name="empty")
_single_result = CheckResult(0, "", "", report=report_digest)
single_results = CheckResults([_single_result], checker_name="single")
duplicate_results = CheckResults(
[_single_result, _single_result, _empty_result], checker_name="duplicate"
)
partition_results = CheckResults(
[
CheckResult(0, "", "", report=report_digest, partition_description="p1"),
CheckResult(0, "", "", report=report_digest, partition_description="p2"),
],
checker_name="partition",
)
partition_duplicate_results = CheckResults(
[
CheckResult(0, "", "", report=report_digest, partition_description="p"),
CheckResult(0, "", "", report=report_digest, partition_description="p"),
],
checker_name="partition_duplicate",
)
def get_tool_name(res: CheckResults) -> str:
return res.checker_name
write_reports(
(
no_results,
empty_results,
single_results,
duplicate_results,
partition_results,
partition_duplicate_results,
),
Workspace(rule_runner.scheduler, _enforce_effects=False),
DistDir(Path("dist")),
goal_name="check",
get_tool_name=get_tool_name,
)
check_dir = Path(rule_runner.build_root, "dist", "check")
assert (check_dir / "none").exists() is False
assert (check_dir / "empty").exists() is False
assert (check_dir / "single/r.txt").exists() is True
assert (check_dir / "duplicate/all/r.txt").exists() is True
assert (check_dir / "duplicate/all_/r.txt").exists() is True
assert (check_dir / "partition/p1/r.txt").exists() is True
assert (check_dir / "partition/p2/r.txt").exists() is True
assert (check_dir / "partition_duplicate/p/r.txt").exists() is True
assert (check_dir / "partition_duplicate/p_/r.txt").exists() is True
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 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_typecheck_rule(
*,
request_types: List[Type[CheckRequest]],
targets: List[Target],
include_sources: bool = True,
) -> Tuple[int, str]:
union_membership = UnionMembership({CheckRequest: request_types})
with mock_console(create_options_bootstrapper()) as (console,
stdio_reader):
rule_runner = RuleRunner()
result: Check = run_rule_with_mocks(
check,
rule_args=[
console,
Workspace(rule_runner.scheduler),
Targets(targets),
DistDir(relpath=Path("dist")),
union_membership,
],
mock_gets=[
MockGet(
output_type=CheckResults,
input_type=CheckRequest,
mock=lambda field_set_collection: field_set_collection.
check_results,
),
MockGet(
output_type=FieldSetsWithSources,
input_type=FieldSetsWithSourcesRequest,
mock=lambda field_sets: FieldSetsWithSources(
field_sets if include_sources else ()),
),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
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 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]:
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,))
with mock_console(rule_runner.options_bootstrapper) as (console, stdio_reader):
result: Test = run_rule_with_mocks(
run_tests,
rule_args=[
console,
test_subsystem,
interactive_runner,
workspace,
union_membership,
DistDir(relpath=Path("dist")),
],
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 stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
def run_export_rule(rule_runner: RuleRunner,
targets: List[Target]) -> Tuple[int, str]:
union_membership = UnionMembership({ExportRequest: [MockExportRequest]})
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),
Workspace(rule_runner.scheduler, _enforce_effects=False),
union_membership,
BuildRoot(),
DistDir(relpath=Path("dist")),
],
mock_gets=[
MockGet(
output_type=ExportResults,
input_type=ExportRequest,
mock=lambda req: ExportResults((mock_export(
req,
digest,
(
PostProcessingCommand([
"cp", "{digest_root}/foo/bar",
"{digest_root}/foo/bar1"
]),
PostProcessingCommand([
"cp", "{digest_root}/foo/bar",
"{digest_root}/foo/bar2"
]),
),
), )),
),
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]),
),
MockGet(
output_type=Environment,
input_type=EnvironmentRequest,
mock=lambda env: rule_runner.request(Environment, [env]),
),
MockEffect(
output_type=InteractiveProcessResult,
input_type=InteractiveProcess,
mock=lambda ip: _mock_run(rule_runner, ip),
),
],
union_membership=union_membership,
)
return result.exit_code, stdio_reader.get_stdout()
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()