def test_stdin_input() -> None: ob = create_options_bootstrapper([]) expected_input = "my_input" expected_output = "my_output" with mock_console(ob, stdin_content=f"{expected_input}\n") as (_, stdio_reader): assert expected_input == input(expected_output) assert expected_output == stdio_reader.get_stdout() with mock_console(ob, stdin_content=f"{expected_input}\n") as (console, stdio_reader): assert expected_input == console.input(expected_output) assert expected_output == stdio_reader.get_stdout()
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_pytest( rule_runner: RuleRunner, test_target: Target, *, extra_args: list[str] | None = None, env: dict[str, str] | None = None, ) -> TestResult: # pytest-html==1.22.1 has an undeclared dep on setuptools. This, unfortunately, # is the most recent version of pytest-html that works with the low version of # pytest that we pin to. plugins = [ "zipp==1.0.0", "pytest-cov>=2.8.1,<2.9", "pytest-html==1.22.1", "setuptools" ] plugins_str = "['" + "', '".join(plugins) + "']" args = [ "--backend-packages=pants.backend.python", f"--source-root-patterns={SOURCE_ROOT}", # pin to lower versions so that we can run Python 2 tests "--pytest-version=pytest>=4.6.6,<4.7", f"--pytest-pytest-plugins={plugins_str}", *(extra_args or ()), ] rule_runner.set_options(args, env=env, env_inherit={"PATH", "PYENV_ROOT", "HOME"}) inputs = [PythonTestFieldSet.create(test_target)] test_result = rule_runner.request(TestResult, inputs) debug_request = rule_runner.request(TestDebugRequest, inputs) if debug_request.process is not None: with mock_console(rule_runner.options_bootstrapper): debug_result = InteractiveRunner(rule_runner.scheduler).run( debug_request.process) assert test_result.exit_code == debug_result.exit_code return test_result
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_typecheck_rule( *, request_types: List[Type[TypecheckRequest]], targets: List[Target], include_sources: bool = True, ) -> Tuple[int, str]: union_membership = UnionMembership({TypecheckRequest: request_types}) with mock_console(create_options_bootstrapper()) as (console, stdio_reader): result: Typecheck = run_rule_with_mocks( typecheck, rule_args=[console, Targets(targets), union_membership], mock_gets=[ MockGet( output_type=EnrichedTypecheckResults, input_type=TypecheckRequest, mock=lambda field_set_collection: field_set_collection. typecheck_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 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_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: 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 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_repl_bogus_repl_name(rule_runner: RuleRunner) -> None: setup_sources(rule_runner) with mock_console(rule_runner.options_bootstrapper): result = rule_runner.run_goal_rule( Repl, global_args=["--backend-packages=pants.backend.python"], args=["--shell=bogus-repl", "src/python/lib.py"], ) assert result.exit_code == -1 assert "'bogus-repl' is not a registered REPL. Available REPLs" in result.stderr
def test_materialize_input_files(rule_runner: RuleRunner) -> None: program_text = b'#!/usr/bin/python\nprint("hello")' binary = create_mock_run_request(rule_runner, program_text) with mock_console(rule_runner.options_bootstrapper): result = rule_runner.run_interactive_process( InteractiveProcess( argv=("./program.py", ), run_in_workspace=False, input_digest=binary.digest, )) assert result.exit_code == 0
def test_repl_ipython(rule_runner: RuleRunner) -> None: setup_sources(rule_runner) with mock_console(rule_runner.options_bootstrapper): result = rule_runner.run_goal_rule( Repl, global_args=[ "--backend-packages=pants.backend.python", "--backend-packages=pants.backend.codegen.protobuf.python", ], args=["--shell=ipython", "src/python/lib.py"], ) assert result.exit_code == 0
def run_repl(rule_runner: RuleRunner, *, extra_args: list[str] | None = None) -> GoalRuleResult: # TODO(#9108): Expand `mock_console` to allow for providing input for the repl to verify # that, e.g., the generated protobuf code is available. Right now this test prepares for # that by including generated code, but cannot actually verify it. with mock_console(rule_runner.options_bootstrapper): return rule_runner.run_goal_rule( Repl, global_args=extra_args or (), args=["src/python/lib.py"], env_inherit={"PATH", "PYENV_ROOT", "HOME"}, )
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_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_repl_with_targets(rule_runner: RuleRunner) -> None: # TODO(#9108): Expand `mock_console` to allow for providing input for the repl to verify # that, e.g., the generated protobuf code is available. Right now this test prepares for # that by including generated code, but cannot actually verify it. setup_sources(rule_runner) with mock_console(rule_runner.options_bootstrapper): result = rule_runner.run_goal_rule( Repl, global_args=[ "--backend-packages=pants.backend.python", "--backend-packages=pants.backend.codegen.protobuf.python", ], args=["src/python/lib.py"], ) assert result.exit_code == 0
def run_pytest( rule_runner: RuleRunner, test_target: PythonTests, *, passthrough_args: Optional[str] = None, junit_xml_dir: Optional[str] = None, use_coverage: bool = False, execution_slot_var: Optional[str] = None, extra_env_vars: Optional[str] = None, env: Optional[Mapping[str, str]] = None, config: Optional[str] = None, force: bool = False, ) -> TestResult: args = [ "--backend-packages=pants.backend.python", f"--source-root-patterns={SOURCE_ROOT}", # pin to lower versions so that we can run Python 2 tests "--pytest-version=pytest>=4.6.6,<4.7", "--pytest-pytest-plugins=['zipp==1.0.0', 'pytest-cov>=2.8.1,<2.9']", ] if passthrough_args: args.append(f"--pytest-args='{passthrough_args}'") if extra_env_vars: args.append(f"--test-extra-env-vars={extra_env_vars}") if junit_xml_dir: args.append(f"--pytest-junit-xml-dir={junit_xml_dir}") if use_coverage: args.append("--test-use-coverage") if execution_slot_var: args.append(f"--pytest-execution-slot-var={execution_slot_var}") if config: rule_runner.create_file(relpath="pytest.ini", contents=config) args.append("--pytest-config=pytest.ini") if force: args.append("--test-force") rule_runner.set_options(args, env=env, env_inherit={"PATH", "PYENV_ROOT", "HOME"}) inputs = [PythonTestFieldSet.create(test_target)] test_result = rule_runner.request(TestResult, inputs) debug_request = rule_runner.request(TestDebugRequest, inputs) if debug_request.process is not None: with mock_console(rule_runner.options_bootstrapper): debug_result = InteractiveRunner(rule_runner.scheduler).run( debug_request.process) assert test_result.exit_code == debug_result.exit_code return test_result
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_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_shunit2( rule_runner: RuleRunner, test_target: Target, *, extra_args: list[str] | None = None, env: dict[str, str] | None = None, ) -> TestResult: rule_runner.set_options( [ "--backend-packages=pants.backend.shell", *(extra_args or ()), ], env=env, env_inherit={"PATH", "PYENV_ROOT", "HOME"}, ) inputs = [Shunit2FieldSet.create(test_target)] test_result = rule_runner.request(TestResult, inputs) debug_request = rule_runner.request(TestDebugRequest, inputs) if debug_request.process is not None: with mock_console(rule_runner.options_bootstrapper): debug_result = rule_runner.run_interactive_process(debug_request.process) assert test_result.exit_code == debug_result.exit_code return test_result
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_pytest( rule_runner: RuleRunner, test_target: Target, *, extra_args: list[str] | None = None, env: dict[str, str] | None = None, ) -> TestResult: args = [ "--backend-packages=pants.backend.python", f"--source-root-patterns={SOURCE_ROOT}", *(extra_args or ()), ] rule_runner.set_options(args, env=env, env_inherit={"PATH", "PYENV_ROOT", "HOME"}) inputs = [PythonTestFieldSet.create(test_target)] test_result = rule_runner.request(TestResult, inputs) debug_request = rule_runner.request(TestDebugRequest, inputs) if debug_request.process is not None: with mock_console(rule_runner.options_bootstrapper): debug_result = rule_runner.run_interactive_process( debug_request.process) assert test_result.exit_code == debug_result.exit_code return test_result
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_valid_repl(rule_runner: RuleRunner) -> None: with mock_console(rule_runner.options_bootstrapper): result = rule_runner.run_goal_rule(Repl, args=[f"--shell={MockRepl.name}"]) assert result.exit_code == 0
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 test_unrecognized_repl(rule_runner: RuleRunner) -> None: with mock_console(rule_runner.options_bootstrapper): result = rule_runner.run_goal_rule(Repl, args=["--shell=bogus-repl"]) assert result.exit_code == -1 assert "'bogus-repl' is not a registered REPL. Available REPLs" in result.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 test_url_assets(asset_type) -> None: rule_runner = RuleRunner( rules=[ *target_type_rules(), *pex_from_targets.rules(), *package_pex_binary.rules(), *run_pex_binary.rules(), *python_target_type_rules.rules(), *run.rules(), ], target_types=[ FileTarget, ResourceTarget, PythonSourceTarget, PexBinary ], objects={"http_source": HTTPSource}, ) http_source_info = ( 'url="https://raw.githubusercontent.com/python/cpython/7e46ae33bd522cf8331052c3c8835f9366599d8d/Lib/antigravity.py",' "len=500," 'sha256="8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967"' ) rule_runner.write_files({ "assets/BUILD": dedent(f"""\ {asset_type}( name='antigravity', source=http_source( {http_source_info}, ), ) {asset_type}( name='antigravity_renamed', source=http_source( {http_source_info}, filename="antigravity_renamed.py", ), ) """), "app/app.py": textwrap.dedent("""\ import pathlib assets_path = pathlib.Path(__file__).parent.parent / "assets" for path in assets_path.iterdir(): print(path.name) assert "https://xkcd.com/353/" in path.read_text() """), "app/BUILD": textwrap.dedent("""\ python_source( source="app.py", dependencies=[ "assets:antigravity", "assets:antigravity_renamed", ] ) pex_binary(name="app.py", entry_point='app.py') """), }) with mock_console(rule_runner.options_bootstrapper) as (console, stdout_reader): rule_runner.run_goal_rule( run.Run, args=["app/app.py"], env_inherit={"PATH", "PYENV_ROOT", "HOME"}, ) stdout = stdout_reader.get_stdout() assert "antigravity.py" in stdout assert "antigravity_renamed.py" in 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()
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()