def run_create_coverage_config_rule(coverage_config: Optional[str]) -> str: coverage = create_subsystem( CoverageSubsystem, config="some_file" if coverage_config else None) resolved_config: List[str] = [] def mock_handle_config(request: CreateDigest) -> Digest: assert len(request) == 1 assert request[0].path == ".coveragerc" assert request[0].is_executable is False resolved_config.append(request[0].content.decode()) return Digest("jerry", 30) def mock_read_config(_: PathGlobs) -> DigestContents: # This shouldn't be called if no config file provided. assert coverage_config is not None return DigestContents([ FileContent(path="/dev/null/prelude", content=coverage_config.encode()) ]) mock_gets = [ MockGet(product_type=DigestContents, subject_type=PathGlobs, mock=mock_read_config), MockGet(product_type=Digest, subject_type=CreateDigest, mock=mock_handle_config), ] result = run_rule_with_mocks(create_coverage_config, rule_args=[coverage], mock_gets=mock_gets) assert result.digest.fingerprint == "jerry" assert len(resolved_config) == 1 return resolved_config[0]
def run_typecheck_rule( *, request_types: List[Type[TypecheckRequest]], targets: List[Target], include_sources: bool = True, ) -> Tuple[int, str]: console = MockConsole(use_colors=False) union_membership = UnionMembership({TypecheckRequest: request_types}) result: Typecheck = run_rule_with_mocks( typecheck, rule_args=[console, Targets(targets), union_membership], mock_gets=[ MockGet( output_type=TypecheckResults, 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 console.stdout.getvalue() return result.exit_code, console.stderr.getvalue()
def test_all_roots_with_root_at_buildroot() -> None: source_root_config = create_subsystem( SourceRootConfig, root_patterns=["/"], marker_filenames=[], ) # This function mocks out reading real directories off the file system def provider_rule(_: PathGlobs) -> Snapshot: dirs = ("foo", ) # A python package at the buildroot. return Snapshot(Digest("abcdef", 10), (), dirs) output = run_rule_with_mocks( all_roots, rule_args=[source_root_config], mock_gets=[ MockGet(product_type=Snapshot, subject_type=PathGlobs, mock=provider_rule), MockGet( product_type=OptionalSourceRoot, subject_type=SourceRootRequest, mock=lambda req: OptionalSourceRoot(SourceRoot(".")), ), ], ) assert {SourceRoot(".")} == set(output)
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 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 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 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_build_docker_image_rule(target_values, expected_features): address = Address("docker/test", target_name="image") image = DockerImage( address=address, unhydrated_values=target_values, ) field_set = DockerFieldSet.create(image) def build_context_mock( request: DockerBuildContextRequest) -> DockerBuildContext: return DockerBuildContext(digest=EMPTY_DIGEST) result = run_rule_with_mocks( build_docker_image, rule_args=[field_set], mock_gets=[ MockGet( output_type=DockerBinary, input_type=DockerBinaryRequest, mock=lambda _: DockerBinary("/dummy/docker"), ), MockGet( output_type=DockerBuildContext, input_type=DockerBuildContextRequest, mock=build_context_mock, ), MockGet( output_type=ProcessResult, input_type=Process, # Process() generation has its own tests in test_docker_binary_build_image mock=lambda _: ProcessResult( stdout=b"stdout", stdout_digest=EMPTY_FILE_DIGEST, stderr=b"stderr", stderr_digest=EMPTY_FILE_DIGEST, output_digest=EMPTY_DIGEST, ), ), ], ) assert result.digest == EMPTY_DIGEST assert len(result.artifacts) == 1 assert result.artifacts[0].relpath is None version = expected_features.get("version", "latest") assert f"Built docker image: image:{version}" in result.artifacts[ 0].extra_log_lines
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_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_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 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_run_rule_goal_rule_generator(self): res = run_rule_with_mocks( a_goal_rule_generator, rule_args=[Console()], mock_gets=[MockGet(product_type=A, subject_type=str, mock=lambda _: A())], ) self.assertEqual(res, Example(0))
def test_run_rule_goal_rule_generator(self) -> None: res = run_rule_with_mocks( a_goal_rule_generator, rule_args=[Console()], mock_gets=[MockGet(output_type=A, input_type=str, mock=lambda _: A())], ) assert res == Example(0)
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 resolve_config(path: str | None, content: str | None) -> str: coverage_subsystem = create_subsystem(CoverageSubsystem, config=path, config_discovery=True) resolved_config: list[str] = [] def mock_find_existing_config(request: ConfigFilesRequest) -> ConfigFiles: if request.specified: assert path is not None snapshot = RuleRunner().make_snapshot_of_empty_files([path]) else: snapshot = EMPTY_SNAPSHOT return ConfigFiles(snapshot) def mock_read_existing_config(_: Digest) -> DigestContents: # This shouldn't be called if no config file provided. assert path is not None assert content is not None return DigestContents([FileContent(path, content.encode())]) def mock_create_final_config(request: CreateDigest) -> Digest: assert len(request) == 1 assert isinstance(request[0], FileContent) assert request[0].path == path if path is not None else ".coveragerc" assert request[0].is_executable is False resolved_config.append(request[0].content.decode()) return EMPTY_DIGEST mock_gets = [ MockGet(output_type=ConfigFiles, input_type=ConfigFilesRequest, mock=mock_find_existing_config), MockGet(output_type=DigestContents, input_type=Digest, mock=mock_read_existing_config), MockGet(output_type=Digest, input_type=CreateDigest, mock=mock_create_final_config), ] result = run_rule_with_mocks(create_or_update_coverage_config, rule_args=[coverage_subsystem], mock_gets=mock_gets) assert result.digest == EMPTY_DIGEST assert len(resolved_config) == 1 return resolved_config[0]
def _do_find_root(src_root_req: SourceRootRequest) -> OptionalSourceRoot: return cast( OptionalSourceRoot, run_rule_with_mocks( get_optional_source_root, rule_args=[src_root_req, source_root_config], mock_gets=[ MockGet( product_type=OptionalSourceRoot, subject_type=SourceRootRequest, mock=_do_find_root, ), MockGet(product_type=Snapshot, subject_type=PathGlobs, mock=_mock_fs_check), ], ), )
def run_create_coverage_config_rule(coverage_config: Optional[str]) -> str: coverage = create_subsystem( CoverageSubsystem, config="some_file" if coverage_config else None) resolved_config: List[str] = [] def mock_find_existing_config(request: ConfigFilesRequest) -> ConfigFiles: snapshot = (EMPTY_SNAPSHOT if not request.specified else RuleRunner().make_snapshot_of_empty_files([".coveragerc"])) return ConfigFiles(snapshot) def mock_read_existing_config(_: Digest) -> DigestContents: # This shouldn't be called if no config file provided. assert coverage_config is not None return DigestContents([ FileContent(path="/dev/null/prelude", content=coverage_config.encode()) ]) def mock_create_final_config(request: CreateDigest) -> Digest: assert len(request) == 1 assert request[0].path == ".coveragerc" assert isinstance(request[0], FileContent) assert request[0].is_executable is False resolved_config.append(request[0].content.decode()) return EMPTY_DIGEST mock_gets = [ MockGet(output_type=ConfigFiles, input_type=ConfigFilesRequest, mock=mock_find_existing_config), MockGet(output_type=DigestContents, input_type=Digest, mock=mock_read_existing_config), MockGet(output_type=Digest, input_type=CreateDigest, mock=mock_create_final_config), ] result = run_rule_with_mocks(create_coverage_config, rule_args=[coverage], mock_gets=mock_gets) assert result.digest.fingerprint == EMPTY_DIGEST.fingerprint assert len(resolved_config) == 1 return resolved_config[0]
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_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_prelude_parsing_rule(prelude_content: str) -> BuildFilePreludeSymbols: symbols = run_rule_with_mocks( evaluate_preludes, rule_args=[BuildFileOptions((), prelude_globs=("prelude",))], mock_gets=[ MockGet( output_type=DigestContents, input_type=PathGlobs, mock=lambda _: DigestContents( [FileContent(path="/dev/null/prelude", content=prelude_content.encode())] ), ), ], ) return cast(BuildFilePreludeSymbols, symbols)
def hydrate_field( *, raw_source_files: List[str], hydrated_source_files: Tuple[str, ...] ) -> FortranSourcesResult: sources_field = FortranTarget( {FortranSources.alias: raw_source_files}, address=Address("", target_name="lib") )[FortranSources] result: FortranSourcesResult = run_rule_with_mocks( hydrate_fortran_sources, rule_args=[FortranSourcesRequest(sources_field)], mock_gets=[ MockGet( output_type=Snapshot, input_type=PathGlobs, mock=lambda _: Snapshot(EMPTY_DIGEST, files=hydrated_source_files, dirs=()), ) ], ) return result
def run_prelude_parsing_rule(prelude_content: str) -> BuildFilePreludeSymbols: symbols = run_rule_with_mocks( evaluate_preludes, rule_args=[ create_subsystem(GlobalOptions, build_file_prelude_globs=["prelude"]) ], mock_gets=[ MockGet( product_type=DigestContents, subject_type=PathGlobs, mock=lambda _: DigestContents([ FileContent(path="/dev/null/prelude", content=prelude_content.encode()) ]), ), ], ) return cast(BuildFilePreludeSymbols, symbols)
def test_parse_address_family_empty() -> None: """Test that parsing an empty BUILD file results in an empty AddressFamily.""" af = run_rule_with_mocks( parse_address_family, rule_args=[ Parser(build_root="", target_type_aliases=[], object_aliases=BuildFileAliases()), BuildFileOptions(("BUILD",)), BuildFilePreludeSymbols(FrozenDict()), AddressFamilyDir("/dev/null"), ], mock_gets=[ MockGet( output_type=DigestContents, input_type=PathGlobs, mock=lambda _: DigestContents([FileContent(path="/dev/null/BUILD", content=b"")]), ), ], ) assert len(af.name_to_target_adaptors) == 0
def assert_ics( lockfile: str, expected: list[str], *, ics: RankedValue = RankedValue(Rank.HARDCODED, Black.default_interpreter_constraints), metadata: PythonLockfileMetadata | None = PythonLockfileMetadata.new( InterpreterConstraints(["==2.7.*"]), set()), ) -> None: black = create_subsystem( Black, lockfile=lockfile, interpreter_constraints=ics, version="v", extra_requirements=[], ) loaded_lock = LoadedLockfile( EMPTY_DIGEST, "black.lock", metadata=metadata, requirement_estimate=1, is_pex_native=True, constraints_strings=None, original_lockfile=Lockfile("black.lock", file_path_description_of_origin="foo", resolve_name="black"), ) result = run_rule_with_mocks( _find_python_interpreter_constraints_from_lockfile, rule_args=[black], mock_gets=[ MockGet( output_type=LoadedLockfile, input_type=LoadedLockfileRequest, mock=lambda _: loaded_lock, ) ], ) assert result == InterpreterConstraints(expected)
def test_parse_address_family_empty() -> None: """Test that parsing an empty BUILD file results in an empty AddressFamily.""" af = run_rule_with_mocks( parse_address_family, rule_args=[ Parser(target_type_aliases=[], object_aliases=BuildFileAliases()), create_subsystem(GlobalOptions, build_patterns=["BUILD"], build_ignore=[]), BuildFilePreludeSymbols(FrozenDict()), Dir("/dev/null"), ], mock_gets=[ MockGet( product_type=DigestContents, subject_type=PathGlobs, mock=lambda _: DigestContents( [FileContent(path="/dev/null/BUILD", content=b"")]), ), ], ) assert len(af.name_to_target_adaptors) == 0
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()