19377500035

Committed 14 Nov 2025 09:01PM UTC coverage: 80.078% (-0.2%) from 80.29%

Build # 19377500035

Build Type

Pull #22890

github

Committed by

web-flow

Commit Message

Merge 90397d509 into 42e1ebd41

Pull Request Pull Request #22890: Updated all python subsystem constraints to 3.14

Run Details

4 of 5 new or added lines in 5 files covered. (80.0%)

214 existing lines in 14 files now uncovered.

77661 of 96982 relevant lines covered (80.08%)

3.36 hits per line

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

80.25

/src/python/pants/backend/helm/check/kubeconform/deployment_test.py

# Copyright 2023 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
from textwrap import dedent

import pytest

from pants.backend.docker.target_types import DockerImageTarget
from pants.backend.helm.check.kubeconform import deployment
from pants.backend.helm.check.kubeconform.deployment import (
    KubeconformCheckDeploymentRequest,
    KubeconformDeploymentFieldSet,
)
from pants.backend.helm.target_types import HelmChartTarget, HelmDeploymentTarget
from pants.backend.helm.target_types import rules as target_types_rules
from pants.backend.helm.testutil import (
    HELM_CHART_FILE,
    HELM_TEMPLATE_HELPERS_FILE,
    HELM_VALUES_FILE,
    K8S_CRD_FILE,
    K8S_CUSTOM_RESOURCE_FILE,
    K8S_SERVICE_TEMPLATE,
)
from pants.backend.helm.util_rules import chart, tool
from pants.backend.python.util_rules import pex
from pants.core.goals import package
from pants.core.goals.check import CheckResults
from pants.core.util_rules import config_files, external_tool, source_files, stripped_source_files
from pants.engine import process
from pants.engine.addresses import Address
from pants.engine.internals.graph import rules as graph_rules
from pants.engine.rules import QueryRule
from pants.testutil.rule_runner import PYTHON_BOOTSTRAP_ENV, RuleRunner


@pytest.fixture
def rule_runner() -> RuleRunner:
    return RuleRunner(
        target_types=[HelmChartTarget, HelmDeploymentTarget, DockerImageTarget],
        rules=[
            *config_files.rules(),
            *chart.rules(),
            *external_tool.rules(),
            *deployment.rules(),
            *graph_rules(),
            *package.rules(),
            *pex.rules(),
            *process.rules(),
            *source_files.rules(),
            *stripped_source_files.rules(),
            *tool.rules(),
            *target_types_rules(),
            QueryRule(CheckResults, (KubeconformCheckDeploymentRequest,)),
        ],
    )


__COMMON_TEST_FILES = {
    "src/mychart/BUILD": "helm_chart()",
    "src/mychart/Chart.yaml": HELM_CHART_FILE,
    "src/mychart/values.yaml": HELM_VALUES_FILE,
    "src/mychart/templates/_helpers.tpl": HELM_TEMPLATE_HELPERS_FILE,
    "src/mychart/templates/service.yaml": K8S_SERVICE_TEMPLATE,
    "src/mychart/templates/pod.yaml": dedent(
        """\
        apiVersion: v1
        kind: Pod
        metadata:
          name: {{ template "fullname" . }}
          labels:
            chart: "{{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}"
        spec:
          containers:
            - name: myapp-container
              image: busybox:1.28
          initContainers:
            - name: init-service
              image: busybox:1.29
            - name: init-db
              image: example.com/containers/busybox:1.28
        """
    ),
}


def test_skip_check(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            **__COMMON_TEST_FILES,
            "src/deployment/BUILD": "helm_deployment(name='foo', chart='//src/mychart', skip_kubeconform=True)",
        }
    )

    addr = Address("src/deployment", target_name="foo")
    checked = run_check(rule_runner, addr)

    assert checked.exit_code == 0
    assert checked.checker_name == "kubeconform"
    assert len(checked.results) == 1
    assert checked.results[0].partition_description == addr.spec
    assert not checked.results[0].stdout


def test_valid_deployment(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            **__COMMON_TEST_FILES,
            "src/deployment/BUILD": "helm_deployment(name='foo', chart='//src/mychart')",
        }
    )
    rule_runner.set_options("--helm-infer-external-docker-images=['*']")

    addr = Address("src/deployment", target_name="foo")
    checked = run_check(rule_runner, addr)

    assert checked.exit_code == 0
    assert checked.checker_name == "kubeconform"
    assert len(checked.results) == 1
    assert checked.results[0].partition_description == addr.spec
    assert (
        checked.results[0].stdout
        == "Summary: 2 resources found in 2 files - Valid: 2, Invalid: 0, Errors: 0, Skipped: 0\n"
    )


@pytest.mark.platform_specific_behavior
def test_invalid(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "src/mychart/BUILD": "helm_chart()",
            "src/mychart/Chart.yaml": HELM_CHART_FILE,
            "src/mychart/templates/replication_controller.yml": dedent(
                """\
              apiVersion: v1
              kind: ReplicationController
              metadata:
                name: "bob"
              spec:
                replicas: asd"
                selector:
                  app: nginx
                templates:
                  metadata:
                    name: nginx
                    labels:
                      app: nginx
                  spec:
                    containers:
                    - name: nginx
                      image: nginx
                      ports:
                      - containerPort: 80
              """
            ),
            "src/deployment/BUILD": "helm_deployment(name='foo', chart='//src/mychart')",
        }
    )

    addr = Address("src/deployment", target_name="foo")
    checked = run_check(rule_runner, addr)

    assert checked.exit_code == 1
    assert len(checked.results) == 1
    assert checked.results[0].partition_description == addr.spec
    assert (
        "Summary: 1 resource found in 1 file - Valid: 0, Invalid: 1, Errors: 0, Skipped: 0"
        in checked.results[0].stdout
    )


def test_valid_deployment_ignoring_sources(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            **__COMMON_TEST_FILES,
            "src/deployment/BUILD": dedent(
                """\
              helm_deployment(
                name="foo",
                chart="//src/mychart",
                kubeconform_ignore_sources=[
                  "service.yaml"
                ]
              )
              """
            ),
        }
    )
    addr = Address("src/deployment", target_name="foo")
    checked = run_check(rule_runner, addr)

    assert checked.exit_code == 0
    assert len(checked.results) == 1
    assert checked.results[0].partition_description == addr.spec
    assert (
        checked.results[0].stdout
        == "Summary: 1 resource found in 1 file - Valid: 1, Invalid: 0, Errors: 0, Skipped: 0\n"
    )


_CRD_TEST_FILES = {
    "src/mychart/BUILD": "helm_chart()",
    "src/mychart/Chart.yaml": HELM_CHART_FILE,
    "src/mychart/crds/myplatform.yaml": K8S_CRD_FILE,
    "src/mychart/templates/mycustom.yml": K8S_CUSTOM_RESOURCE_FILE,
}


def test_fail_using_crd(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            **_CRD_TEST_FILES,
            "src/deployment/BUILD": "helm_deployment(name='foo', chart='//src/mychart')",
        }
    )

    addr = Address("src/deployment", target_name="foo")
    checked = run_check(rule_runner, addr)
    assert checked.exit_code == 1


def test_pass_using_crd_ignoring_schemas(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            **_CRD_TEST_FILES,
            "src/deployment/BUILD": dedent(
                """\
              helm_deployment(
                name='foo',
                chart='//src/mychart',
                kubeconform_ignore_missing_schemas=True
              )
              """
            ),
        }
    )

    addr = Address("src/deployment", target_name="foo")
    checked = run_check(rule_runner, addr)
    assert checked.exit_code == 0


def test_pass_using_crd_skipping_kinds(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            **_CRD_TEST_FILES,
            "src/deployment/BUILD": dedent(
                """\
              helm_deployment(
                name='foo',
                chart='//src/mychart',
                kubeconform_skip_kinds=["MyPlatform"]
              )
              """
            ),
        }
    )

    addr = Address("src/deployment", target_name="foo")
    checked = run_check(rule_runner, addr)
    assert checked.exit_code == 0


def run_check(
    rule_runner: RuleRunner, address: Address, *, source_root_patterns: Iterable[str] = ("/src/*",)
) -> CheckResults:
    rule_runner.set_options(
        [
            f"--source-root-patterns={repr(source_root_patterns)}",
            "--kubeconform-summary",
            "--helm-infer-external-docker-images=['*']",
        ],
        env_inherit=PYTHON_BOOTSTRAP_ENV,
    )

    target = rule_runner.get_target(address)
    field_set = KubeconformDeploymentFieldSet.create(target)
    return rule_runner.request(CheckResults, [KubeconformCheckDeploymentRequest([field_set])])

1	# Copyright 2023 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3
4	from __future__ import annotations	3✔
5
6	from collections.abc import Iterable	3✔
7	from textwrap import dedent	3✔
8
9	import pytest	3✔
10
11	from pants.backend.docker.target_types import DockerImageTarget	3✔
12	from pants.backend.helm.check.kubeconform import deployment	3✔
13	from pants.backend.helm.check.kubeconform.deployment import (	3✔
14	KubeconformCheckDeploymentRequest,
15	KubeconformDeploymentFieldSet,
16	)
17	from pants.backend.helm.target_types import HelmChartTarget, HelmDeploymentTarget	3✔
18	from pants.backend.helm.target_types import rules as target_types_rules	3✔
19	from pants.backend.helm.testutil import (	3✔
20	HELM_CHART_FILE,
21	HELM_TEMPLATE_HELPERS_FILE,
22	HELM_VALUES_FILE,
23	K8S_CRD_FILE,
24	K8S_CUSTOM_RESOURCE_FILE,
25	K8S_SERVICE_TEMPLATE,
26	)
27	from pants.backend.helm.util_rules import chart, tool	3✔
28	from pants.backend.python.util_rules import pex	3✔
29	from pants.core.goals import package	3✔
30	from pants.core.goals.check import CheckResults	3✔
31	from pants.core.util_rules import config_files, external_tool, source_files, stripped_source_files	3✔
32	from pants.engine import process	3✔
33	from pants.engine.addresses import Address	3✔
34	from pants.engine.internals.graph import rules as graph_rules	3✔
35	from pants.engine.rules import QueryRule	3✔
36	from pants.testutil.rule_runner import PYTHON_BOOTSTRAP_ENV, RuleRunner	3✔
37
38
39	@pytest.fixture	3✔
40	def rule_runner() -> RuleRunner:	3✔
41	return RuleRunner(	3✔
42	target_types=[HelmChartTarget, HelmDeploymentTarget, DockerImageTarget],
43	rules=[
44	*config_files.rules(),
45	*chart.rules(),
46	*external_tool.rules(),
47	*deployment.rules(),
48	*graph_rules(),
49	*package.rules(),
50	*pex.rules(),
51	*process.rules(),
52	*source_files.rules(),
53	*stripped_source_files.rules(),
54	*tool.rules(),
55	*target_types_rules(),
56	QueryRule(CheckResults, (KubeconformCheckDeploymentRequest,)),
57	],
58	)
59
60
61	__COMMON_TEST_FILES = {	3✔
62	"src/mychart/BUILD": "helm_chart()",
63	"src/mychart/Chart.yaml": HELM_CHART_FILE,
64	"src/mychart/values.yaml": HELM_VALUES_FILE,
65	"src/mychart/templates/_helpers.tpl": HELM_TEMPLATE_HELPERS_FILE,
66	"src/mychart/templates/service.yaml": K8S_SERVICE_TEMPLATE,
67	"src/mychart/templates/pod.yaml": dedent(
68	"""\
69	apiVersion: v1
70	kind: Pod
71	metadata:
72	name: {{ template "fullname" . }}
73	labels:
74	chart: "{{ .Chart.Name }}-{{ .Chart.Version \| replace "+" "_" }}"
75	spec:
76	containers:
77	- name: myapp-container
78	image: busybox:1.28
79	initContainers:
80	- name: init-service
81	image: busybox:1.29
82	- name: init-db
83	image: example.com/containers/busybox:1.28
84	"""
85	),
86	}
87
88
89	def test_skip_check(rule_runner: RuleRunner) -> None:	3✔
90	rule_runner.write_files(	1✔
91	{
92	**__COMMON_TEST_FILES,
93	"src/deployment/BUILD": "helm_deployment(name='foo', chart='//src/mychart', skip_kubeconform=True)",
94	}
95	)
96
97	addr = Address("src/deployment", target_name="foo")	1✔
98	checked = run_check(rule_runner, addr)	1✔
99
100	assert checked.exit_code == 0	1✔
101	assert checked.checker_name == "kubeconform"	1✔
102	assert len(checked.results) == 1	1✔
103	assert checked.results[0].partition_description == addr.spec	1✔
104	assert not checked.results[0].stdout	1✔
105
106
107	def test_valid_deployment(rule_runner: RuleRunner) -> None:	3✔
108	rule_runner.write_files(	1✔
109	{
110	**__COMMON_TEST_FILES,
111	"src/deployment/BUILD": "helm_deployment(name='foo', chart='//src/mychart')",
112	}
113	)
114	rule_runner.set_options("--helm-infer-external-docker-images=['*']")	1✔
115
116	addr = Address("src/deployment", target_name="foo")	1✔
117	checked = run_check(rule_runner, addr)	1✔
118
UNCOV 119	assert checked.exit_code == 0	×
UNCOV 120	assert checked.checker_name == "kubeconform"	×
UNCOV 121	assert len(checked.results) == 1	×
UNCOV 122	assert checked.results[0].partition_description == addr.spec	×
UNCOV 123	assert (	×
124	checked.results[0].stdout
125	== "Summary: 2 resources found in 2 files - Valid: 2, Invalid: 0, Errors: 0, Skipped: 0\n"
126	)
127
128
129	@pytest.mark.platform_specific_behavior	3✔
130	def test_invalid(rule_runner: RuleRunner) -> None:	3✔
131	rule_runner.write_files(	3✔
132	{
133	"src/mychart/BUILD": "helm_chart()",
134	"src/mychart/Chart.yaml": HELM_CHART_FILE,
135	"src/mychart/templates/replication_controller.yml": dedent(
136	"""\
137	apiVersion: v1
138	kind: ReplicationController
139	metadata:
140	name: "bob"
141	spec:
142	replicas: asd"
143	selector:
144	app: nginx
145	templates:
146	metadata:
147	name: nginx
148	labels:
149	app: nginx
150	spec:
151	containers:
152	- name: nginx
153	image: nginx
154	ports:
155	- containerPort: 80
156	"""
157	),
158	"src/deployment/BUILD": "helm_deployment(name='foo', chart='//src/mychart')",
159	}
160	)
161
162	addr = Address("src/deployment", target_name="foo")	3✔
163	checked = run_check(rule_runner, addr)	3✔
164
UNCOV 165	assert checked.exit_code == 1	×
UNCOV 166	assert len(checked.results) == 1	×
UNCOV 167	assert checked.results[0].partition_description == addr.spec	×
UNCOV 168	assert (	×
169	"Summary: 1 resource found in 1 file - Valid: 0, Invalid: 1, Errors: 0, Skipped: 0"
170	in checked.results[0].stdout
171	)
172
173
174	def test_valid_deployment_ignoring_sources(rule_runner: RuleRunner) -> None:	3✔
175	rule_runner.write_files(	1✔
176	{
177	**__COMMON_TEST_FILES,
178	"src/deployment/BUILD": dedent(
179	"""\
180	helm_deployment(
181	name="foo",
182	chart="//src/mychart",
183	kubeconform_ignore_sources=[
184	"service.yaml"
185	]
186	)
187	"""
188	),
189	}
190	)
191	addr = Address("src/deployment", target_name="foo")	1✔
192	checked = run_check(rule_runner, addr)	1✔
193
UNCOV 194	assert checked.exit_code == 0	×
UNCOV 195	assert len(checked.results) == 1	×
UNCOV 196	assert checked.results[0].partition_description == addr.spec	×
UNCOV 197	assert (	×
198	checked.results[0].stdout
199	== "Summary: 1 resource found in 1 file - Valid: 1, Invalid: 0, Errors: 0, Skipped: 0\n"
200	)
201
202
203	_CRD_TEST_FILES = {	3✔
204	"src/mychart/BUILD": "helm_chart()",
205	"src/mychart/Chart.yaml": HELM_CHART_FILE,
206	"src/mychart/crds/myplatform.yaml": K8S_CRD_FILE,
207	"src/mychart/templates/mycustom.yml": K8S_CUSTOM_RESOURCE_FILE,
208	}
209
210
211	def test_fail_using_crd(rule_runner: RuleRunner) -> None:	3✔
212	rule_runner.write_files(	1✔
213	{
214	**_CRD_TEST_FILES,
215	"src/deployment/BUILD": "helm_deployment(name='foo', chart='//src/mychart')",
216	}
217	)
218
219	addr = Address("src/deployment", target_name="foo")	1✔
220	checked = run_check(rule_runner, addr)	1✔
UNCOV 221	assert checked.exit_code == 1	×
222
223
224	def test_pass_using_crd_ignoring_schemas(rule_runner: RuleRunner) -> None:	3✔
225	rule_runner.write_files(	1✔
226	{
227	**_CRD_TEST_FILES,
228	"src/deployment/BUILD": dedent(
229	"""\
230	helm_deployment(
231	name='foo',
232	chart='//src/mychart',
233	kubeconform_ignore_missing_schemas=True
234	)
235	"""
236	),
237	}
238	)
239
240	addr = Address("src/deployment", target_name="foo")	1✔
241	checked = run_check(rule_runner, addr)	1✔
UNCOV 242	assert checked.exit_code == 0	×
243
244
245	def test_pass_using_crd_skipping_kinds(rule_runner: RuleRunner) -> None:	3✔
246	rule_runner.write_files(	1✔
247	{
248	**_CRD_TEST_FILES,
249	"src/deployment/BUILD": dedent(
250	"""\
251	helm_deployment(
252	name='foo',
253	chart='//src/mychart',
254	kubeconform_skip_kinds=["MyPlatform"]
255	)
256	"""
257	),
258	}
259	)
260
261	addr = Address("src/deployment", target_name="foo")	1✔
262	checked = run_check(rule_runner, addr)	1✔
UNCOV 263	assert checked.exit_code == 0	×
264
265
266	def run_check(	3✔
267	rule_runner: RuleRunner, address: Address, , source_root_patterns: Iterable[str] = ("/src/",)
268	) -> CheckResults:
269	rule_runner.set_options(	3✔
270	[
271	f"--source-root-patterns={repr(source_root_patterns)}",
272	"--kubeconform-summary",
273	"--helm-infer-external-docker-images=['*']",
274	],
275	env_inherit=PYTHON_BOOTSTRAP_ENV,
276	)
277
278	target = rule_runner.get_target(address)	3✔
279	field_set = KubeconformDeploymentFieldSet.create(target)	3✔
280	return rule_runner.request(CheckResults, [KubeconformCheckDeploymentRequest([field_set])])	3✔

pantsbuild / pants / 19377500035

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