def test_exclude_pattern(self): """Test that targets are filtered based on exclude patterns.""" specs = Specs([SiblingAddresses('root')], exclude_patterns=tuple(['.exclude*'])) address_family = AddressFamily('root', {'exclude_me': ('root/BUILD', TargetAdaptor()), 'not_me': ('root/BUILD', TargetAdaptor()), } ) targets = self._resolve_build_file_addresses( specs, address_family, self._snapshot(), self._address_mapper()) self.assertEqual(len(targets.dependencies), 1) self.assertEqual(targets.dependencies[0].spec, 'root:not_me')
def test_tag_filter(self): """Test that targets are filtered based on `tags`.""" specs = Specs([SiblingAddresses('root')], tags=['+integration']) address_family = AddressFamily('root', {'a': ('root/BUILD', TargetAdaptor()), 'b': ('root/BUILD', TargetAdaptor(tags={'integration'})), 'c': ('root/BUILD', TargetAdaptor(tags={'not_integration'})) } ) targets = self._resolve_build_file_addresses( specs, address_family, self._snapshot(), self._address_mapper()) self.assertEqual(len(targets.dependencies), 1) self.assertEqual(targets.dependencies[0].spec, 'root:b')
def run_black( self, source_files: List[FileContent], *, config: Optional[str] = None, passthrough_args: Optional[str] = None, skip: bool = False, ) -> Tuple[LintResult, FmtResult]: args = ["--backend-packages2=pants.backend.python.lint.black"] if config is not None: self.create_file(relpath="pyproject.toml", contents=config) args.append("--black-config=pyproject.toml") if passthrough_args: args.append(f"--black-args='{passthrough_args}'") if skip: args.append(f"--black-skip") input_snapshot = self.request_single_product(Snapshot, InputFilesContent(source_files)) target_adaptor = TargetAdaptor( sources=EagerFilesetWithSpec('test', {'globs': []}, snapshot=input_snapshot), address=Address.parse("test:target"), ) lint_target = BlackTarget(target_adaptor) fmt_target = BlackTarget(target_adaptor, prior_formatter_result_digest=input_snapshot.directory_digest) options_bootstrapper = create_options_bootstrapper(args=args) lint_result = self.request_single_product(LintResult, Params(lint_target, options_bootstrapper)) fmt_result = self.request_single_product(FmtResult, Params(fmt_target, options_bootstrapper)) return lint_result, fmt_result
def hydrate_target(target_adaptor, hydrated_fields): """Construct a HydratedTarget from a TargetAdaptor and hydrated versions of its adapted fields.""" # Hydrate the fields of the adaptor and re-construct it. kwargs = target_adaptor.kwargs() for field in hydrated_fields: kwargs[field.name] = field.value return HydratedTarget(TargetAdaptor(**kwargs), tuple(target_adaptor.dependencies))
def test_fails_on_nonexistent_specs(self) -> None: """Test that address specs referring to nonexistent targets raise a ResolveError.""" address_family = AddressFamily('root', {'a': ('root/BUILD', TargetAdaptor())}) address_specs = AddressSpecs( [SingleAddress('root', 'b'), SingleAddress('root', 'a')]) expected_rx_str = re.escape( """"b" was not found in namespace "root". Did you mean one of: :a""") with self.assertRaisesRegex(ResolveError, expected_rx_str): self._resolve_build_file_addresses(address_specs, address_family, self._snapshot(), self._address_mapper()) # Ensure that we still catch nonexistent targets later on in the list of command-line # address specs. address_specs = AddressSpecs( [SingleAddress('root', 'a'), SingleAddress('root', 'b')]) with self.assertRaisesRegex(ResolveError, expected_rx_str): self._resolve_build_file_addresses(address_specs, address_family, self._snapshot(), self._address_mapper())
def make_ht(nm: str) -> HydratedTarget: if nm not in name_to_ht: dep_hts = tuple(make_ht(dep) for dep in name_to_deps[nm]) name_to_ht[nm] = HydratedTarget(address=nm, adaptor=TargetAdaptor(), dependencies=dep_hts) return name_to_ht[nm]
def reify_legacy_graph(target_adaptor, dependencies, hydrated_fields): """Construct a LegacyTarget from a TargetAdaptor, its deps, and hydrated versions of its adapted fields.""" kwargs = target_adaptor.kwargs() for field in hydrated_fields: kwargs[field.name] = field.value return LegacyTarget(TargetAdaptor(**kwargs), [d.adaptor.address for d in dependencies])
def test_exclude_pattern(self) -> None: """Test that targets are filtered based on exclude patterns.""" address_specs = AddressSpecs([SiblingAddresses("root")], exclude_patterns=tuple([".exclude*"])) address_family = AddressFamily( "root", { "exclude_me": ("root/BUILD", TargetAdaptor()), "not_me": ("root/BUILD", TargetAdaptor()), }, ) targets = self._resolve_addresses(address_specs, address_family, self._snapshot(), self._address_mapper()) assert len(targets) == 1 assert targets[0].spec == "root:not_me"
def test_exclude_pattern(self): """Test that targets are filtered based on exclude patterns.""" spec = SiblingAddresses('root') address_mapper = AddressMapper(JsonParser(TestTable())) snapshot = Snapshot(DirectoryDigest(str('xx'), 2), (Path('root/BUILD', File('root/BUILD')),)) address_family = AddressFamily('root', {'exclude_me': ('root/BUILD', TargetAdaptor()), 'not_me': ('root/BUILD', TargetAdaptor()), } ) targets = run_rule( addresses_from_address_families, address_mapper, Specs([spec], exclude_patterns=tuple(['.exclude*'])),{ (Snapshot, PathGlobs): lambda _: snapshot, (AddressFamily, Dir): lambda _: address_family, }) self.assertEquals(len(targets.dependencies), 1) self.assertEquals(targets.dependencies[0].spec, 'root:not_me')
def test_tag_filter(self) -> None: """Test that targets are filtered based on `tags`.""" address_specs = AddressSpecs([SiblingAddresses("root")], tags=["+integration"]) address_family = AddressFamily( "root", { "a": ("root/BUILD", TargetAdaptor()), "b": ("root/BUILD", TargetAdaptor(tags={"integration"})), "c": ("root/BUILD", TargetAdaptor(tags={"not_integration"})), }, ) targets = self._resolve_addresses( address_specs, address_family, self._snapshot(), self._address_mapper() ) assert len(targets) == 1 assert targets[0].spec == "root:b"
def test_tag_filter(self): """Test that targets are filtered based on `tags`.""" spec = SiblingAddresses('root') address_mapper = AddressMapper(JsonParser(TestTable())) snapshot = Snapshot(DirectoryDigest(str('xx'), 2), (Path('root/BUILD', File('root/BUILD')),)) address_family = AddressFamily('root', {'a': ('root/BUILD', TargetAdaptor()), 'b': ('root/BUILD', TargetAdaptor(tags={'integration'})), 'c': ('root/BUILD', TargetAdaptor(tags={'not_integration'})) } ) targets = run_rule( addresses_from_address_families, address_mapper, Specs([spec], tags=['+integration']), { (Snapshot, PathGlobs): lambda _: snapshot, (AddressFamily, Dir): lambda _: address_family, }) self.assertEquals(len(targets.dependencies), 1) self.assertEquals(targets.dependencies[0].spec, 'root:b')
def make_target_with_origin( self, source_files: List[FileContent], *, origin: Optional[OriginSpec] = None, ) -> TargetAdaptorWithOrigin: input_snapshot = self.request_single_product(Snapshot, InputFilesContent(source_files)) adaptor = TargetAdaptor( sources=EagerFilesetWithSpec("test", {"globs": []}, snapshot=input_snapshot), address=Address.parse("test:target"), ) if origin is None: origin = SingleAddress(directory="test", name="target") return TargetAdaptorWithOrigin(adaptor, origin)
def test_exclude_pattern_with_single_address(self) -> None: """Test that single address targets are filtered based on exclude patterns.""" address_specs = AddressSpecs( [SingleAddress("root", "not_me")], exclude_patterns=tuple(["root.*"]) ) address_family = AddressFamily("root", {"not_me": ("root/BUILD", TargetAdaptor())}) targets = self._resolve_addresses( address_specs, address_family, self._snapshot(), self._address_mapper() ) assert len(targets.dependencies) == 0
def hydrate_target(target_adaptor_container): target_adaptor = target_adaptor_container.value """Construct a HydratedTarget from a TargetAdaptor and hydrated versions of its adapted fields.""" # Hydrate the fields of the adaptor and re-construct it. hydrated_fields = yield [Get(HydratedField, HydrateableField, fa) for fa in target_adaptor.field_adaptors] kwargs = target_adaptor.kwargs() for field in hydrated_fields: kwargs[field.name] = field.value yield HydratedTarget(target_adaptor.address, TargetAdaptor(**kwargs), tuple(target_adaptor.dependencies))
def hydrate_target(target_adaptor): """Construct a HydratedTarget from a TargetAdaptor and hydrated versions of its adapted fields.""" # Hydrate the fields of the adaptor and re-construct it. hydrated_fields = yield [ (Get(HydratedField, BundlesField, fa) if type(fa) is BundlesField else Get(HydratedField, SourcesField, fa)) for fa in target_adaptor.field_adaptors ] kwargs = target_adaptor.kwargs() for field in hydrated_fields: kwargs[field.name] = field.value yield HydratedTarget(target_adaptor.address, TargetAdaptor(**kwargs), tuple(target_adaptor.dependencies))
def test_exclude_pattern_with_single_address(self): """Test that single address targets are filtered based on exclude patterns.""" specs = Specs([SingleAddress('root', 'not_me')], exclude_patterns=tuple(['root.*'])) address_family = AddressFamily('root', { 'not_me': ('root/BUILD', TargetAdaptor()), } ) targets = self._resolve_build_file_addresses( specs, address_family, self._snapshot(), self._address_mapper()) self.assertEqual(len(targets.dependencies), 0)
def mock_target( self, sources: TargetSources, *, origin: Optional[OriginSpec] = None, include_sources: bool = True, type_alias: Optional[str] = None, ) -> TargetAdaptorWithOrigin: sources_field = Mock() sources_field.snapshot = self.make_snapshot_of_empty_files( sources.source_file_absolute_paths if include_sources else [] ) adaptor = TargetAdaptor( address=Address.parse(f"{sources.source_root}:lib"), type_alias=type_alias, sources=sources_field, ) if origin is None: origin = SiblingAddresses(sources.source_root) return TargetAdaptorWithOrigin(adaptor, origin)
def run_black( self, source_files: List[FileContent], *, config: Optional[str] = None, passthrough_args: Optional[Sequence[str]] = None, ) -> Tuple[LintResult, FmtResult]: if config is not None: self.create_file(relpath="pyproject.toml", contents=config) input_snapshot = self.request_single_product( Snapshot, InputFilesContent(source_files)) target = FormattablePythonTarget( TargetAdaptor( sources=EagerFilesetWithSpec('test', {'globs': []}, snapshot=input_snapshot), address=Address.parse("test:target"), )) black_subsystem = global_subsystem_instance( Black, options={ Black.options_scope: { "config": "pyproject.toml" if config else None, "args": passthrough_args or [], } }) black_setup = self.request_single_product( BlackSetup, Params( black_subsystem, PythonNativeCode.global_instance(), PythonSetup.global_instance(), SubprocessEnvironment.global_instance(), )) fmt_and_lint_params = Params(target, black_setup, PythonSetup.global_instance(), SubprocessEnvironment.global_instance()) lint_result = self.request_single_product(LintResult, fmt_and_lint_params) fmt_result = self.request_single_product(FmtResult, fmt_and_lint_params) return lint_result, fmt_result
def run_isort( self, source_files: List[FileContent], *, config: Optional[str] = None, passthrough_args: Optional[Sequence[str]] = None, skip: bool = False, ) -> Tuple[LintResult, FmtResult]: if config is not None: self.create_file(relpath=".isort.cfg", contents=config) input_snapshot = self.request_single_product(Snapshot, InputFilesContent(source_files)) target_adaptor = TargetAdaptor( sources=EagerFilesetWithSpec('test', {'globs': []}, snapshot=input_snapshot), address=Address.parse("test:target"), ) lint_target = IsortTarget(target_adaptor) fmt_target = IsortTarget(target_adaptor, prior_formatter_result_digest=input_snapshot.directory_digest) isort_subsystem = global_subsystem_instance( Isort, options={Isort.options_scope: { "config": [".isort.cfg"] if config else None, "args": passthrough_args or [], "skip": skip, }} ) python_subsystems = [ PythonNativeCode.global_instance(), PythonSetup.global_instance(), SubprocessEnvironment.global_instance(), ] isort_setup = self.request_single_product( IsortSetup, Params(isort_subsystem, *python_subsystems) ) lint_result = self.request_single_product( LintResult, Params(lint_target, isort_setup, *python_subsystems) ) fmt_result = self.request_single_product( FmtResult, Params(fmt_target, isort_setup, *python_subsystems) ) return lint_result, fmt_result
def run_black_and_isort( self, source_files: List[FileContent], ) -> AggregatedFmtResults: input_snapshot = self.request_single_product(Snapshot, InputFilesContent(source_files)) target = _ConcretePythonFormatTarget( TargetAdaptor( sources=EagerFilesetWithSpec('test', {'globs': []}, snapshot=input_snapshot), address=Address.parse("test:target"), ), ) results = self.request_single_product( AggregatedFmtResults, Params( target, create_options_bootstrapper( args=[ "--backend-packages2=['pants.backend.python.lint.black', 'pants.backend.python.lint.isort']" ], ) ) ) return results
def get_stripped_files_for_target( *, source_paths: Optional[List[str]], type_alias: Optional[str] = None, specified_sources: Optional[List[str]] = None, ) -> List[str]: address = (Address(spec_path=PurePath( source_paths[0]).parent.as_posix(), target_name="target") if source_paths else Address.parse("src/python/project:target")) sources = Mock() sources.snapshot = self.make_snapshot_of_empty_files(source_paths or []) specified_sources_snapshot = ( None if not specified_sources else self.make_snapshot_of_empty_files(specified_sources)) return self.get_stripped_files( LegacyStripTargetRequest( TargetAdaptor(address=address, type_alias=type_alias, sources=sources), specified_files_snapshot=specified_sources_snapshot, ))
def run_black_and_isort( self, source_files: List[FileContent], *, extra_args: Optional[List[str]] = None) -> LanguageFmtResults: input_snapshot = self.request_single_product( Snapshot, InputFilesContent(source_files)) adaptor = TargetAdaptor( sources=EagerFilesetWithSpec("test", {"globs": []}, snapshot=input_snapshot), address=Address.parse("test:target"), ) origin = SingleAddress(directory="test", name="target") formatters = PythonFormatters( (TargetAdaptorWithOrigin(adaptor, origin), )) args = [ "--backend-packages2=['pants.backend.python.lint.black', 'pants.backend.python.lint.isort']", *(extra_args or []), ] results = self.request_single_product( LanguageFmtResults, Params(formatters, create_options_bootstrapper(args=args)), ) return results
def _make_target(self, address: str, **kwargs) -> TargetAdaptor: return TargetAdaptor(address=Address.parse(address), **kwargs)