24055979590

Committed 06 Apr 2026 11:17PM UTC coverage: 52.37% (-40.5%) from 92.908%

Build # 24055979590

Build Type

Pull #23225

github

Committed by

web-flow

Commit Message

Merge 67474653c into 542ca048d

Pull Request Pull Request #23225: Add --test-show-all-batch-targets to expose all targets in batched pytest

Coverage Stats

6 of 17 new or added lines in 2 files covered. (35.29%)

23030 existing lines in 605 files now uncovered.

31643 of 60422 relevant lines covered (52.37%)

1.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.18

/src/python/pants/backend/terraform/dependency_inference.py

# Copyright 2021 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from __future__ import annotations

from collections.abc import Iterable, Sequence
from dataclasses import dataclass
from pathlib import PurePath

from pants.backend.python.subsystems.python_tool_base import PythonToolRequirementsBase
from pants.backend.python.target_types import EntryPoint
from pants.backend.python.util_rules.pex import (
    VenvPex,
    VenvPexProcess,
    create_venv_pex,
    setup_venv_pex_process,
)
from pants.backend.python.util_rules.pex import rules as pex_rules
from pants.backend.terraform.target_types import (
    TerraformBackendTarget,
    TerraformDependenciesField,
    TerraformDeploymentFieldSet,
    TerraformLockfileTarget,
    TerraformModuleSourcesField,
    TerraformVarFileTarget,
)
from pants.base.glob_match_error_behavior import GlobMatchErrorBehavior
from pants.base.specs import DirGlobSpec, DirLiteralSpec, RawSpecs
from pants.core.target_types import LockfileTarget
from pants.engine.addresses import Addresses
from pants.engine.fs import CreateDigest, Digest, FileContent
from pants.engine.internals.build_files import resolve_address
from pants.engine.internals.graph import (
    determine_explicitly_provided_dependencies,
    hydrate_sources,
    resolve_targets,
)
from pants.engine.internals.native_engine import Address, AddressInput
from pants.engine.internals.selectors import concurrently
from pants.engine.intrinsics import create_digest
from pants.engine.process import Process, execute_process_or_raise
from pants.engine.rules import collect_rules, implicitly, rule
from pants.engine.target import (
    DependenciesRequest,
    FieldSet,
    HydrateSourcesRequest,
    InferDependenciesRequest,
    InferredDependencies,
    Target,
)
from pants.engine.unions import UnionRule
from pants.util.dirutil import group_by_dir
from pants.util.logging import LogLevel
from pants.util.ordered_set import OrderedSet
from pants.util.resources import read_resource
from pants.util.strutil import bullet_list, softwrap

# pants: infer-dep(hcl2.lock*)


class TerraformHcl2Parser(PythonToolRequirementsBase):
    options_scope = "terraform-hcl2-parser"
    help_short = "Used to parse Terraform modules to infer their dependencies."

    # versions 4.3.2+ have parsing issues; bump once resolved
    default_requirements = ["python-hcl2>=3.0.5,<=4.3.0"]

    register_interpreter_constraints = True

    default_lockfile_resource = ("pants.backend.terraform", "hcl2.lock")


@dataclass(frozen=True)
class ParserSetup:
    pex: VenvPex


@rule
async def setup_parser(hcl2_parser: TerraformHcl2Parser) -> ParserSetup:
    parser_script_content = read_resource("pants.backend.terraform", "hcl2_parser.py")
    if not parser_script_content:
        raise ValueError("Unable to find source to hcl2_parser.py wrapper script.")

    parser_content = FileContent(
        path="__pants_tf_parser.py", content=parser_script_content, is_executable=True
    )
    parser_digest = await create_digest(CreateDigest([parser_content]))

    parser_pex = await create_venv_pex(
        **implicitly(
            hcl2_parser.to_pex_request(
                main=EntryPoint(PurePath(parser_content.path).stem), sources=parser_digest
            )
        )
    )
    return ParserSetup(parser_pex)


@dataclass(frozen=True)
class ParseTerraformModuleSources:
    sources_digest: Digest
    paths: tuple[str, ...]


@rule
async def setup_process_for_parse_terraform_module_sources(
    request: ParseTerraformModuleSources, parser: ParserSetup
) -> Process:
    dir_paths = ", ".join(sorted(group_by_dir(request.paths).keys()))

    process = await setup_venv_pex_process(
        VenvPexProcess(
            parser.pex,
            argv=request.paths,
            input_digest=request.sources_digest,
            description=f"Parse Terraform module sources: {dir_paths}",
            level=LogLevel.DEBUG,
        ),
        **implicitly(),
    )
    return process


@dataclass(frozen=True)
class TerraformModuleDependenciesInferenceFieldSet(FieldSet):
    required_fields = (TerraformModuleSourcesField, TerraformDependenciesField)

    sources: TerraformModuleSourcesField
    dependencies: TerraformDependenciesField


class InferTerraformModuleDependenciesRequest(InferDependenciesRequest):
    infer_from = TerraformModuleDependenciesInferenceFieldSet


@dataclass(frozen=True)
class TerraformDeploymentDependenciesInferenceFieldSet(TerraformDeploymentFieldSet):
    pass


class InferTerraformDeploymentDependenciesRequest(InferDependenciesRequest):
    infer_from = TerraformDeploymentDependenciesInferenceFieldSet


def find_targets_of_type(tgts, of_type) -> tuple:
    if tgts:
        return tuple(e for e in tgts if isinstance(e, of_type))
    else:
        return ()


@dataclass(frozen=True)
class TerraformDeploymentInvocationFilesRequest:
    """TODO: is there a way to convert between FS? We could convert the inference FS to the deployment FS itself"""

    address: Address
    dependencies: TerraformDependenciesField


@dataclass(frozen=True)
class TerraformDeploymentInvocationFiles:
    """The files passed in to the invocation of `terraform`"""

    backend_configs: tuple[TerraformBackendTarget, ...]
    vars_files: tuple[TerraformVarFileTarget, ...]
    lockfile: LockfileTarget | None


@rule
async def get_terraform_backend_and_vars(
    field_set: TerraformDeploymentInvocationFilesRequest,
) -> TerraformDeploymentInvocationFiles:
    this_address = field_set.address

    explicit_deps = await determine_explicitly_provided_dependencies(
        **implicitly(DependenciesRequest(field_set.dependencies))
    )
    tgts_in_dir, explicit_deps_tgt = await concurrently(
        resolve_targets(
            **implicitly(
                RawSpecs(
                    description_of_origin="terraform infer deployment dependencies",
                    dir_literals=(DirLiteralSpec(this_address.spec_path),),
                )
            )
        ),
        resolve_targets(**implicitly(Addresses(explicit_deps.includes))),
    )
    return identify_terraform_backend_and_vars(explicit_deps_tgt, tgts_in_dir)


class InvalidLockfileException(Exception):
    @classmethod
    def too_many_lockfiles(
        cls, lockfiles: Iterable[TerraformLockfileTarget]
    ) -> InvalidLockfileException:
        addresses = sorted(tgt.address.spec for tgt in lockfiles)
        return cls(
            softwrap(
                f"""\
                A Terraform deployment has {len(addresses)} lockfiles supplied:
                {bullet_list(addresses)}
                Terraform requires at most 1 lockfile; it must be called `.terraform.lock.hcl`;
                and it must be in the same directory as the root module.

                Pants generates targets for Terraform lockfiles automatically.
                If you manually added `{TerraformLockfileTarget.alias}` targets, removing them should resolve this error.
                If you have not, please report this as a bug.
                """
            )
        )


def identify_terraform_backend_and_vars(
    explicit_deps: Sequence[Target], tgts_in_dir: Sequence[Target]
) -> TerraformDeploymentInvocationFiles:
    has_explicit_backend = find_targets_of_type(explicit_deps, TerraformBackendTarget)
    if not has_explicit_backend:
        # Note: Terraform does not support multiple backends, but dep inference isn't the place to enforce that
        backend_targets = find_targets_of_type(tgts_in_dir, TerraformBackendTarget)
    else:
        backend_targets = has_explicit_backend

    has_explicit_var = find_targets_of_type(explicit_deps, TerraformVarFileTarget)
    if not has_explicit_var:
        vars_targets = find_targets_of_type(tgts_in_dir, TerraformVarFileTarget)
    else:
        vars_targets = has_explicit_var

    lockfiles = find_targets_of_type(tgts_in_dir, TerraformLockfileTarget)
    if len(lockfiles) == 1:
        lockfile = lockfiles[0]
    elif len(lockfiles) > 1:
        # Unlikely, since we generate them based on a constant filename.
        # Indicates manual specification of targets
        raise InvalidLockfileException.too_many_lockfiles(lockfiles)
    else:
        lockfile = None

    return TerraformDeploymentInvocationFiles(backend_targets, vars_targets, lockfile)


async def _infer_dependencies_from_sources(
    request: InferTerraformModuleDependenciesRequest,
) -> list[Address]:
    """Parse the source code for references to other modules."""
    hydrated_sources = await hydrate_sources(
        HydrateSourcesRequest(request.field_set.sources), **implicitly()
    )
    paths = OrderedSet(
        filename for filename in hydrated_sources.snapshot.files if filename.endswith(".tf")
    )
    result = await execute_process_or_raise(
        **implicitly(
            ParseTerraformModuleSources(
                sources_digest=hydrated_sources.snapshot.digest,
                paths=tuple(paths),
            )
        )
    )
    candidate_spec_paths = [line for line in result.stdout.decode("utf-8").split("\n") if line]
    # For each path, see if there is a `terraform_module` target at the specified spec_path.
    candidate_targets = await resolve_targets(
        **implicitly(
            RawSpecs(
                dir_globs=tuple(DirGlobSpec(path) for path in candidate_spec_paths),
                unmatched_glob_behavior=GlobMatchErrorBehavior.ignore,
                description_of_origin="the `terraform_module` dependency inference rule",
            )
        )
    )
    # TODO: Need to either implement the standard ambiguous dependency logic or ban >1 terraform_module
    # per directory.
    terraform_module_addresses = [
        tgt.address for tgt in candidate_targets if tgt.has_field(TerraformModuleSourcesField)
    ]
    return terraform_module_addresses


async def _infer_lockfile(request: InferTerraformModuleDependenciesRequest) -> list[Address]:
    """Pull in the lockfile for a Terraform module.

    This is necessary for `terraform validate`.
    """
    invocation_files = await get_terraform_backend_and_vars(
        TerraformDeploymentInvocationFilesRequest(
            request.field_set.address, request.field_set.dependencies
        )
    )
    if invocation_files.lockfile:
        return [invocation_files.lockfile.address]
    else:
        return []


@rule
async def infer_terraform_module_dependencies(
    request: InferTerraformModuleDependenciesRequest,
) -> InferredDependencies:
    terraform_module_addresses = await _infer_dependencies_from_sources(request)
    lockfile_address = await _infer_lockfile(request)

    return InferredDependencies([*terraform_module_addresses, *lockfile_address])


@rule
async def infer_terraform_deployment_dependencies(
    request: InferTerraformDeploymentDependenciesRequest,
) -> InferredDependencies:
    root_module_address_input = request.field_set.root_module.to_address_input()
    root_module = await resolve_address(**implicitly({root_module_address_input: AddressInput}))
    deps = [root_module]

    invocation_files = await get_terraform_backend_and_vars(
        TerraformDeploymentInvocationFilesRequest(
            request.field_set.address, request.field_set.dependencies
        )
    )
    deps.extend(e.address for e in invocation_files.backend_configs)
    deps.extend(e.address for e in invocation_files.vars_files)
    # lockfile is attached to the module itself

    return InferredDependencies(deps)


def rules():
    return [
        *collect_rules(),
        *pex_rules(),
        UnionRule(InferDependenciesRequest, InferTerraformModuleDependenciesRequest),
        UnionRule(InferDependenciesRequest, InferTerraformDeploymentDependenciesRequest),
    ]

1	# Copyright 2021 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3	from __future__ import annotations	2✔
4
5	from collections.abc import Iterable, Sequence	2✔
6	from dataclasses import dataclass	2✔
7	from pathlib import PurePath	2✔
8
9	from pants.backend.python.subsystems.python_tool_base import PythonToolRequirementsBase	2✔
10	from pants.backend.python.target_types import EntryPoint	2✔
11	from pants.backend.python.util_rules.pex import (	2✔
12	VenvPex,
13	VenvPexProcess,
14	create_venv_pex,
15	setup_venv_pex_process,
16	)
17	from pants.backend.python.util_rules.pex import rules as pex_rules	2✔
18	from pants.backend.terraform.target_types import (	2✔
19	TerraformBackendTarget,
20	TerraformDependenciesField,
21	TerraformDeploymentFieldSet,
22	TerraformLockfileTarget,
23	TerraformModuleSourcesField,
24	TerraformVarFileTarget,
25	)
26	from pants.base.glob_match_error_behavior import GlobMatchErrorBehavior	2✔
27	from pants.base.specs import DirGlobSpec, DirLiteralSpec, RawSpecs	2✔
28	from pants.core.target_types import LockfileTarget	2✔
29	from pants.engine.addresses import Addresses	2✔
30	from pants.engine.fs import CreateDigest, Digest, FileContent	2✔
31	from pants.engine.internals.build_files import resolve_address	2✔
32	from pants.engine.internals.graph import (	2✔
33	determine_explicitly_provided_dependencies,
34	hydrate_sources,
35	resolve_targets,
36	)
37	from pants.engine.internals.native_engine import Address, AddressInput	2✔
38	from pants.engine.internals.selectors import concurrently	2✔
39	from pants.engine.intrinsics import create_digest	2✔
40	from pants.engine.process import Process, execute_process_or_raise	2✔
41	from pants.engine.rules import collect_rules, implicitly, rule	2✔
42	from pants.engine.target import (	2✔
43	DependenciesRequest,
44	FieldSet,
45	HydrateSourcesRequest,
46	InferDependenciesRequest,
47	InferredDependencies,
48	Target,
49	)
50	from pants.engine.unions import UnionRule	2✔
51	from pants.util.dirutil import group_by_dir	2✔
52	from pants.util.logging import LogLevel	2✔
53	from pants.util.ordered_set import OrderedSet	2✔
54	from pants.util.resources import read_resource	2✔
55	from pants.util.strutil import bullet_list, softwrap	2✔
56
57	# pants: infer-dep(hcl2.lock*)
58
59
60	class TerraformHcl2Parser(PythonToolRequirementsBase):	2✔
61	options_scope = "terraform-hcl2-parser"	2✔
62	help_short = "Used to parse Terraform modules to infer their dependencies."	2✔
63
64	# versions 4.3.2+ have parsing issues; bump once resolved
65	default_requirements = ["python-hcl2>=3.0.5,<=4.3.0"]	2✔
66
67	register_interpreter_constraints = True	2✔
68
69	default_lockfile_resource = ("pants.backend.terraform", "hcl2.lock")	2✔
70
71
72	@dataclass(frozen=True)	2✔
73	class ParserSetup:	2✔
74	pex: VenvPex	2✔
75
76
77	@rule	2✔
78	async def setup_parser(hcl2_parser: TerraformHcl2Parser) -> ParserSetup:	2✔
79	parser_script_content = read_resource("pants.backend.terraform", "hcl2_parser.py")	2✔
80	if not parser_script_content:	2✔
81	raise ValueError("Unable to find source to hcl2_parser.py wrapper script.")	×
82
83	parser_content = FileContent(	2✔
84	path="__pants_tf_parser.py", content=parser_script_content, is_executable=True
85	)
86	parser_digest = await create_digest(CreateDigest([parser_content]))	2✔
87
88	parser_pex = await create_venv_pex(	2✔
89	**implicitly(
90	hcl2_parser.to_pex_request(
91	main=EntryPoint(PurePath(parser_content.path).stem), sources=parser_digest
92	)
93	)
94	)
95	return ParserSetup(parser_pex)	2✔
96
97
98	@dataclass(frozen=True)	2✔
99	class ParseTerraformModuleSources:	2✔
100	sources_digest: Digest	2✔
101	paths: tuple[str, ...]	2✔
102
103
104	@rule	2✔
105	async def setup_process_for_parse_terraform_module_sources(	2✔
106	request: ParseTerraformModuleSources, parser: ParserSetup
107	) -> Process:
108	dir_paths = ", ".join(sorted(group_by_dir(request.paths).keys()))	2✔
109
110	process = await setup_venv_pex_process(	2✔
111	VenvPexProcess(
112	parser.pex,
113	argv=request.paths,
114	input_digest=request.sources_digest,
115	description=f"Parse Terraform module sources: {dir_paths}",
116	level=LogLevel.DEBUG,
117	),
118	**implicitly(),
119	)
120	return process	2✔
121
122
123	@dataclass(frozen=True)	2✔
124	class TerraformModuleDependenciesInferenceFieldSet(FieldSet):	2✔
125	required_fields = (TerraformModuleSourcesField, TerraformDependenciesField)	2✔
126
127	sources: TerraformModuleSourcesField	2✔
128	dependencies: TerraformDependenciesField	2✔
129
130
131	class InferTerraformModuleDependenciesRequest(InferDependenciesRequest):	2✔
132	infer_from = TerraformModuleDependenciesInferenceFieldSet	2✔
133
134
135	@dataclass(frozen=True)	2✔
136	class TerraformDeploymentDependenciesInferenceFieldSet(TerraformDeploymentFieldSet):	2✔
137	pass	2✔
138
139
140	class InferTerraformDeploymentDependenciesRequest(InferDependenciesRequest):	2✔
141	infer_from = TerraformDeploymentDependenciesInferenceFieldSet	2✔
142
143
144	def find_targets_of_type(tgts, of_type) -> tuple:	2✔
UNCOV 145	if tgts:	×
UNCOV 146	return tuple(e for e in tgts if isinstance(e, of_type))	×
147	else:
UNCOV 148	return ()	×
149
150
151	@dataclass(frozen=True)	2✔
152	class TerraformDeploymentInvocationFilesRequest:	2✔
153	"""TODO: is there a way to convert between FS? We could convert the inference FS to the deployment FS itself"""
154
155	address: Address	2✔
156	dependencies: TerraformDependenciesField	2✔
157
158
159	@dataclass(frozen=True)	2✔
160	class TerraformDeploymentInvocationFiles:	2✔
161	"""The files passed in to the invocation of `terraform`"""
162
163	backend_configs: tuple[TerraformBackendTarget, ...]	2✔
164	vars_files: tuple[TerraformVarFileTarget, ...]	2✔
165	lockfile: LockfileTarget \| None	2✔
166
167
168	@rule	2✔
169	async def get_terraform_backend_and_vars(	2✔
170	field_set: TerraformDeploymentInvocationFilesRequest,
171	) -> TerraformDeploymentInvocationFiles:
UNCOV 172	this_address = field_set.address	×
173
UNCOV 174	explicit_deps = await determine_explicitly_provided_dependencies(	×
175	**implicitly(DependenciesRequest(field_set.dependencies))
176	)
UNCOV 177	tgts_in_dir, explicit_deps_tgt = await concurrently(	×
178	resolve_targets(
179	**implicitly(
180	RawSpecs(
181	description_of_origin="terraform infer deployment dependencies",
182	dir_literals=(DirLiteralSpec(this_address.spec_path),),
183	)
184	)
185	),
186	resolve_targets(**implicitly(Addresses(explicit_deps.includes))),
187	)
UNCOV 188	return identify_terraform_backend_and_vars(explicit_deps_tgt, tgts_in_dir)	×
189
190
191	class InvalidLockfileException(Exception):	2✔
192	@classmethod	2✔
193	def too_many_lockfiles(	2✔
194	cls, lockfiles: Iterable[TerraformLockfileTarget]
195	) -> InvalidLockfileException:
196	addresses = sorted(tgt.address.spec for tgt in lockfiles)	×
197	return cls(	×
198	softwrap(
199	f"""\
200	A Terraform deployment has {len(addresses)} lockfiles supplied:
201	{bullet_list(addresses)}
202	Terraform requires at most 1 lockfile; it must be called `.terraform.lock.hcl`;
203	and it must be in the same directory as the root module.
204
205	Pants generates targets for Terraform lockfiles automatically.
206	If you manually added `{TerraformLockfileTarget.alias}` targets, removing them should resolve this error.
207	If you have not, please report this as a bug.
208	"""
209	)
210	)
211
212
213	def identify_terraform_backend_and_vars(	2✔
214	explicit_deps: Sequence[Target], tgts_in_dir: Sequence[Target]
215	) -> TerraformDeploymentInvocationFiles:
UNCOV 216	has_explicit_backend = find_targets_of_type(explicit_deps, TerraformBackendTarget)	×
UNCOV 217	if not has_explicit_backend:	×
218	# Note: Terraform does not support multiple backends, but dep inference isn't the place to enforce that
UNCOV 219	backend_targets = find_targets_of_type(tgts_in_dir, TerraformBackendTarget)	×
220	else:
UNCOV 221	backend_targets = has_explicit_backend	×
222
UNCOV 223	has_explicit_var = find_targets_of_type(explicit_deps, TerraformVarFileTarget)	×
UNCOV 224	if not has_explicit_var:	×
UNCOV 225	vars_targets = find_targets_of_type(tgts_in_dir, TerraformVarFileTarget)	×
226	else:
UNCOV 227	vars_targets = has_explicit_var	×
228
UNCOV 229	lockfiles = find_targets_of_type(tgts_in_dir, TerraformLockfileTarget)	×
UNCOV 230	if len(lockfiles) == 1:	×
UNCOV 231	lockfile = lockfiles[0]	×
UNCOV 232	elif len(lockfiles) > 1:	×
233	# Unlikely, since we generate them based on a constant filename.
234	# Indicates manual specification of targets
235	raise InvalidLockfileException.too_many_lockfiles(lockfiles)	×
236	else:
UNCOV 237	lockfile = None	×
238
UNCOV 239	return TerraformDeploymentInvocationFiles(backend_targets, vars_targets, lockfile)	×
240
241
242	async def _infer_dependencies_from_sources(	2✔
243	request: InferTerraformModuleDependenciesRequest,
244	) -> list[Address]:
245	"""Parse the source code for references to other modules."""
UNCOV 246	hydrated_sources = await hydrate_sources(	×
247	HydrateSourcesRequest(request.field_set.sources), **implicitly()
248	)
UNCOV 249	paths = OrderedSet(	×
250	filename for filename in hydrated_sources.snapshot.files if filename.endswith(".tf")
251	)
UNCOV 252	result = await execute_process_or_raise(	×
253	**implicitly(
254	ParseTerraformModuleSources(
255	sources_digest=hydrated_sources.snapshot.digest,
256	paths=tuple(paths),
257	)
258	)
259	)
UNCOV 260	candidate_spec_paths = [line for line in result.stdout.decode("utf-8").split("\n") if line]	×
261	# For each path, see if there is a `terraform_module` target at the specified spec_path.
UNCOV 262	candidate_targets = await resolve_targets(	×
263	**implicitly(
264	RawSpecs(
265	dir_globs=tuple(DirGlobSpec(path) for path in candidate_spec_paths),
266	unmatched_glob_behavior=GlobMatchErrorBehavior.ignore,
267	description_of_origin="the `terraform_module` dependency inference rule",
268	)
269	)
270	)
271	# TODO: Need to either implement the standard ambiguous dependency logic or ban >1 terraform_module
272	# per directory.
UNCOV 273	terraform_module_addresses = [	×
274	tgt.address for tgt in candidate_targets if tgt.has_field(TerraformModuleSourcesField)
275	]
UNCOV 276	return terraform_module_addresses	×
277
278
279	async def _infer_lockfile(request: InferTerraformModuleDependenciesRequest) -> list[Address]:	2✔
280	"""Pull in the lockfile for a Terraform module.
281
282	This is necessary for `terraform validate`.
283	"""
UNCOV 284	invocation_files = await get_terraform_backend_and_vars(	×
285	TerraformDeploymentInvocationFilesRequest(
286	request.field_set.address, request.field_set.dependencies
287	)
288	)
UNCOV 289	if invocation_files.lockfile:	×
UNCOV 290	return [invocation_files.lockfile.address]	×
291	else:
UNCOV 292	return []	×
293
294
295	@rule	2✔
296	async def infer_terraform_module_dependencies(	2✔
297	request: InferTerraformModuleDependenciesRequest,
298	) -> InferredDependencies:
UNCOV 299	terraform_module_addresses = await _infer_dependencies_from_sources(request)	×
UNCOV 300	lockfile_address = await _infer_lockfile(request)	×
301
UNCOV 302	return InferredDependencies([terraform_module_addresses, lockfile_address])	×
303
304
305	@rule	2✔
306	async def infer_terraform_deployment_dependencies(	2✔
307	request: InferTerraformDeploymentDependenciesRequest,
308	) -> InferredDependencies:
UNCOV 309	root_module_address_input = request.field_set.root_module.to_address_input()	×
UNCOV 310	root_module = await resolve_address(**implicitly({root_module_address_input: AddressInput}))	×
UNCOV 311	deps = [root_module]	×
312
UNCOV 313	invocation_files = await get_terraform_backend_and_vars(	×
314	TerraformDeploymentInvocationFilesRequest(
315	request.field_set.address, request.field_set.dependencies
316	)
317	)
UNCOV 318	deps.extend(e.address for e in invocation_files.backend_configs)	×
UNCOV 319	deps.extend(e.address for e in invocation_files.vars_files)	×
320	# lockfile is attached to the module itself
321
UNCOV 322	return InferredDependencies(deps)	×
323
324
325	def rules():	2✔
326	return [	2✔
327	*collect_rules(),
328	*pex_rules(),
329	UnionRule(InferDependenciesRequest, InferTerraformModuleDependenciesRequest),
330	UnionRule(InferDependenciesRequest, InferTerraformDeploymentDependenciesRequest),
331	]

pantsbuild / pants / 24055979590

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous