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()