23173232554

Committed 17 Mar 2026 12:55AM UTC coverage: 92.932% (-0.001%) from 92.933%

Build # 23173232554

Build Type

push

github

Committed by

web-flow

Commit Message

un bitrot flaky tests (#23166)

The goal isn't to fix the flakyness, just to make them runnable again as
a prerequisite to eventual fixing.

For `pantsd_integration_test.py` the files were moved around in
2d1794f582.

For `jdk_rules_test.py` the prefix switch pattern was already intoduced
in 45c51ae6de.

This was accomplished by having an LLM go through the list of all flaky
tests and uncomment the 'skip' one by one and then try to fix any
bitrot.

Run Details

0 of 2 new or added lines in 2 files covered. (0.0%)

1 existing line in 1 file now uncovered.

91172 of 98106 relevant lines covered (92.93%)

4.05 hits per line

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

92.78

/src/python/pants/jvm/jdk_rules_test.py

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

from __future__ import annotations

import textwrap

import pytest

from pants.core.util_rules import config_files, source_files, system_binaries
from pants.core.util_rules.external_tool import rules as external_tool_rules
from pants.core.util_rules.system_binaries import BashBinary
from pants.engine.fs import CreateDigest, Digest, FileContent
from pants.engine.internals.native_engine import EMPTY_DIGEST
from pants.engine.internals.scheduler import ExecutionError
from pants.engine.process import Process, ProcessResult
from pants.jvm.jdk_rules import InternalJdk, JvmProcess, parse_jre_major_version
from pants.jvm.jdk_rules import rules as jdk_rules
from pants.jvm.resolve.coursier_fetch import rules as coursier_fetch_rules
from pants.jvm.resolve.coursier_setup import rules as coursier_setup_rules
from pants.jvm.testutil import maybe_skip_jdk_test
from pants.jvm.util_rules import rules as util_rules
from pants.testutil.rule_runner import PYTHON_BOOTSTRAP_ENV, QueryRule, RuleRunner


@pytest.fixture
def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *config_files.rules(),
            *source_files.rules(),
            *coursier_setup_rules(),
            *coursier_fetch_rules(),
            *external_tool_rules(),
            *util_rules(),
            *jdk_rules(),
            *system_binaries.rules(),
            QueryRule(BashBinary, ()),
            QueryRule(InternalJdk, ()),
            QueryRule(Process, (JvmProcess,)),
            QueryRule(ProcessResult, (Process,)),
            QueryRule(ProcessResult, (JvmProcess,)),
        ],
    )
    rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV)
    return rule_runner


def javac_version_proc(rule_runner: RuleRunner) -> Process:
    jdk = rule_runner.request(InternalJdk, [])
    return rule_runner.request(
        Process,
        [
            JvmProcess(
                jdk=jdk,
                classpath_entries=(),
                argv=[
                    "-version",
                ],
                input_digest=EMPTY_DIGEST,
                description="",
                use_nailgun=False,
            )
        ],
    )


def run_javac_version(rule_runner: RuleRunner) -> str:
    process_result = rule_runner.request(
        ProcessResult,
        [javac_version_proc(rule_runner)],
    )
    return "\n".join(
        [process_result.stderr.decode("utf-8"), process_result.stdout.decode("utf-8")],
    )


@maybe_skip_jdk_test
def test_java_binary_system_version(rule_runner: RuleRunner) -> None:
    rule_runner.set_options(["--jvm-jdk=system"], env_inherit=PYTHON_BOOTSTRAP_ENV)
    assert "openjdk version" in run_javac_version(rule_runner)


@maybe_skip_jdk_test
def test_java_binary_bogus_version_fails(rule_runner: RuleRunner) -> None:
    rule_runner.set_options(["--jvm-tool-jdk=bogusjdk:999"], env_inherit=PYTHON_BOOTSTRAP_ENV)
    expected_exception_msg = r".*?JVM bogusjdk:999 not found in index.*?"
    with pytest.raises(ExecutionError, match=expected_exception_msg):
        run_javac_version(rule_runner)


@maybe_skip_jdk_test
@pytest.mark.skip(reason="#12293 Coursier JDK bootstrapping is currently flaky in CI")
@pytest.mark.no_error_if_skipped
def test_java_binary_versions(rule_runner: RuleRunner) -> None:
    # default version is 1.11
    assert 'openjdk version "11.0' in run_javac_version(rule_runner)

    rule_runner.set_options(["--jvm-tool-jdk=temurin:1.17"], env_inherit=PYTHON_BOOTSTRAP_ENV)
    assert 'openjdk version "17.' in run_javac_version(rule_runner)

    rule_runner.set_options(["--jvm-tool-jdk=bogusjdk:999"], env_inherit=PYTHON_BOOTSTRAP_ENV)
    expected_exception_msg = r".*?JVM bogusjdk:999 not found in index.*?"
    with pytest.raises(ExecutionError, match=expected_exception_msg):
        assert "javac 16.0" in run_javac_version(rule_runner)


@maybe_skip_jdk_test
def test_parse_java_version() -> None:
    version1 = textwrap.dedent(
        """\
    openjdk version "17.0.1" 2021-10-19
    OpenJDK Runtime Environment Homebrew (build 17.0.1+0)
    OpenJDK 64-Bit Server VM Homebrew (build 17.0.1+0, mixed mode, sharing)
    """
    )
    assert parse_jre_major_version(version1) == 17

    version2 = textwrap.dedent(
        """\
    openjdk version "11" 2018-09-25
    OpenJDK Runtime Environment AdoptOpenJDK (build 11+28)
    OpenJDK 64-Bit Server VM AdoptOpenJDK (build 11+28, mixed mode)
    """
    )
    assert parse_jre_major_version(version2) == 11


@maybe_skip_jdk_test
def test_include_default_heap_size_in_jvm_options(rule_runner: RuleRunner) -> None:
    proc = javac_version_proc(rule_runner)
    assert "-Xmx512m" in proc.argv


@maybe_skip_jdk_test
def test_include_child_mem_constraint_in_jvm_options(rule_runner: RuleRunner) -> None:
    rule_runner.set_options(
        ["--process-per-child-memory-usage=1GiB"],
        env_inherit=PYTHON_BOOTSTRAP_ENV,
    )
    proc = javac_version_proc(rule_runner)
    assert "-Xmx1g" in proc.argv


@maybe_skip_jdk_test
def test_error_if_users_specify_max_heap_as_jvm_option(rule_runner: RuleRunner) -> None:
    global_jvm_options = ["-Xmx1g"]
    rule_runner.set_options(
        [f"--jvm-global-options={repr(global_jvm_options)}"],
        env_inherit=PYTHON_BOOTSTRAP_ENV,
    )

    with pytest.raises(ExecutionError, match="Invalid value for JVM options: -Xmx1g."):
        javac_version_proc(rule_runner)


@maybe_skip_jdk_test
def test_pass_jvm_options_to_java_program(rule_runner: RuleRunner) -> None:
    global_jvm_options = ["-Dpants.jvm.global=true"]

    # Rely on JEP-330 to run a Java file from source so we don´t need a compile step.
    rule_runner.set_options(
        ["--jvm-tool-jdk=temurin:1.11.0.23", f"--jvm-global-options={repr(global_jvm_options)}"],
        env_inherit=PYTHON_BOOTSTRAP_ENV,
    )

    classname = "EchoSystemProperties"
    filename = f"{classname}.java"
    file_content = textwrap.dedent(
        f"""\
        public class {classname} {{
            public static void main(String[] args) {{
                System.getProperties().list(System.out);
            }}
        }}
        """
    )

    input_digest = rule_runner.request(
        Digest,
        [
            CreateDigest(
                [
                    FileContent(
                        filename,
                        file_content.encode("utf-8"),
                    )
                ]
            )
        ],
    )

    jdk = rule_runner.request(InternalJdk, [])
    process_result = rule_runner.request(
        ProcessResult,
        [
            JvmProcess(
                jdk=jdk,
                argv=[filename],
                classpath_entries=(),
                extra_jvm_options=["-Dpants.jvm.extra=true"],
                input_digest=input_digest,
                description="Echo JVM System properties",
                use_nailgun=False,
            )
        ],
    )

    jvm_properties = [
        prop for prop in process_result.stdout.decode("utf-8").splitlines() if "=" in prop
    ]
    assert "java.specification.version=11" in jvm_properties
    assert "pants.jvm.global=true" in jvm_properties
    assert "pants.jvm.extra=true" in jvm_properties


@maybe_skip_jdk_test
def test_jvm_not_found_when_empty_jvm_index(rule_runner: RuleRunner) -> None:
    # Prepare empty JVM Index file
    filename = "index.json"
    file_content = textwrap.dedent(
        """\
        {}
        """
    )
    rule_runner.write_files({filename: file_content})

    jdk_release_version = "21"
    jdk_binary = f"adoptium:1.{jdk_release_version}"

    # Assert jdk_binary is found with default JVM Index
    rule_runner.set_options([f"--jvm-tool-jdk={jdk_binary}"], env_inherit=PYTHON_BOOTSTRAP_ENV)
    assert f'openjdk version "{jdk_release_version}' in run_javac_version(rule_runner)

    # Assert jdk_binary is not found with empty JVM Index
    rule_runner.set_options(
        [
            f"--coursier-jvm-index={rule_runner.build_root}/{filename}",
            f"--jvm-tool-jdk={jdk_binary}",
        ],
        env_inherit=PYTHON_BOOTSTRAP_ENV,
    )
    expected_exception_msg = rf".*?JVM {jdk_binary} not found in index.*?"
    with pytest.raises(ExecutionError, match=expected_exception_msg):
        run_javac_version(rule_runner)

1	# Copyright 2021 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3
4	from __future__ import annotations	1✔
5
6	import textwrap	1✔
7
8	import pytest	1✔
9
10	from pants.core.util_rules import config_files, source_files, system_binaries	1✔
11	from pants.core.util_rules.external_tool import rules as external_tool_rules	1✔
12	from pants.core.util_rules.system_binaries import BashBinary	1✔
13	from pants.engine.fs import CreateDigest, Digest, FileContent	1✔
14	from pants.engine.internals.native_engine import EMPTY_DIGEST	1✔
15	from pants.engine.internals.scheduler import ExecutionError	1✔
16	from pants.engine.process import Process, ProcessResult	1✔
17	from pants.jvm.jdk_rules import InternalJdk, JvmProcess, parse_jre_major_version	1✔
18	from pants.jvm.jdk_rules import rules as jdk_rules	1✔
19	from pants.jvm.resolve.coursier_fetch import rules as coursier_fetch_rules	1✔
20	from pants.jvm.resolve.coursier_setup import rules as coursier_setup_rules	1✔
21	from pants.jvm.testutil import maybe_skip_jdk_test	1✔
22	from pants.jvm.util_rules import rules as util_rules	1✔
23	from pants.testutil.rule_runner import PYTHON_BOOTSTRAP_ENV, QueryRule, RuleRunner	1✔
24
25
26	@pytest.fixture	1✔
27	def rule_runner() -> RuleRunner:	1✔
28	rule_runner = RuleRunner(	1✔
29	rules=[
30	*config_files.rules(),
31	*source_files.rules(),
32	*coursier_setup_rules(),
33	*coursier_fetch_rules(),
34	*external_tool_rules(),
35	*util_rules(),
36	*jdk_rules(),
37	*system_binaries.rules(),
38	QueryRule(BashBinary, ()),
39	QueryRule(InternalJdk, ()),
40	QueryRule(Process, (JvmProcess,)),
41	QueryRule(ProcessResult, (Process,)),
42	QueryRule(ProcessResult, (JvmProcess,)),
43	],
44	)
45	rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV)	1✔
46	return rule_runner	1✔
47
48
49	def javac_version_proc(rule_runner: RuleRunner) -> Process:	1✔
50	jdk = rule_runner.request(InternalJdk, [])	1✔
51	return rule_runner.request(	1✔
52	Process,
53	[
54	JvmProcess(
55	jdk=jdk,
56	classpath_entries=(),
57	argv=[
58	"-version",
59	],
60	input_digest=EMPTY_DIGEST,
61	description="",
62	use_nailgun=False,
63	)
64	],
65	)
66
67
68	def run_javac_version(rule_runner: RuleRunner) -> str:	1✔
69	process_result = rule_runner.request(	1✔
70	ProcessResult,
71	[javac_version_proc(rule_runner)],
72	)
73	return "\n".join(	1✔
74	[process_result.stderr.decode("utf-8"), process_result.stdout.decode("utf-8")],
75	)
76
77
78	@maybe_skip_jdk_test	1✔
79	def test_java_binary_system_version(rule_runner: RuleRunner) -> None:	1✔
80	rule_runner.set_options(["--jvm-jdk=system"], env_inherit=PYTHON_BOOTSTRAP_ENV)	1✔
81	assert "openjdk version" in run_javac_version(rule_runner)	1✔
82
83
84	@maybe_skip_jdk_test	1✔
85	def test_java_binary_bogus_version_fails(rule_runner: RuleRunner) -> None:	1✔
86	rule_runner.set_options(["--jvm-tool-jdk=bogusjdk:999"], env_inherit=PYTHON_BOOTSTRAP_ENV)	1✔
87	expected_exception_msg = r".?JVM bogusjdk:999 not found in index.?"	1✔
88	with pytest.raises(ExecutionError, match=expected_exception_msg):	1✔
89	run_javac_version(rule_runner)	1✔
90
91
92	@maybe_skip_jdk_test	1✔
93	@pytest.mark.skip(reason="#12293 Coursier JDK bootstrapping is currently flaky in CI")	1✔
94	@pytest.mark.no_error_if_skipped	1✔
95	def test_java_binary_versions(rule_runner: RuleRunner) -> None:	1✔
96	# default version is 1.11
97	assert 'openjdk version "11.0' in run_javac_version(rule_runner)	×
98
99	rule_runner.set_options(["--jvm-tool-jdk=temurin:1.17"], env_inherit=PYTHON_BOOTSTRAP_ENV)	×
NEW 100	assert 'openjdk version "17.' in run_javac_version(rule_runner)	×
101
102	rule_runner.set_options(["--jvm-tool-jdk=bogusjdk:999"], env_inherit=PYTHON_BOOTSTRAP_ENV)	×
103	expected_exception_msg = r".?JVM bogusjdk:999 not found in index.?"	×
104	with pytest.raises(ExecutionError, match=expected_exception_msg):	×
105	assert "javac 16.0" in run_javac_version(rule_runner)	×
106
107
108	@maybe_skip_jdk_test	1✔
109	def test_parse_java_version() -> None:	1✔
110	version1 = textwrap.dedent(	1✔
111	"""\
112	openjdk version "17.0.1" 2021-10-19
113	OpenJDK Runtime Environment Homebrew (build 17.0.1+0)
114	OpenJDK 64-Bit Server VM Homebrew (build 17.0.1+0, mixed mode, sharing)
115	"""
116	)
117	assert parse_jre_major_version(version1) == 17	1✔
118
119	version2 = textwrap.dedent(	1✔
120	"""\
121	openjdk version "11" 2018-09-25
122	OpenJDK Runtime Environment AdoptOpenJDK (build 11+28)
123	OpenJDK 64-Bit Server VM AdoptOpenJDK (build 11+28, mixed mode)
124	"""
125	)
126	assert parse_jre_major_version(version2) == 11	1✔
127
128
129	@maybe_skip_jdk_test	1✔
130	def test_include_default_heap_size_in_jvm_options(rule_runner: RuleRunner) -> None:	1✔
131	proc = javac_version_proc(rule_runner)	1✔
132	assert "-Xmx512m" in proc.argv	1✔
133
134
135	@maybe_skip_jdk_test	1✔
136	def test_include_child_mem_constraint_in_jvm_options(rule_runner: RuleRunner) -> None:	1✔
137	rule_runner.set_options(	1✔
138	["--process-per-child-memory-usage=1GiB"],
139	env_inherit=PYTHON_BOOTSTRAP_ENV,
140	)
141	proc = javac_version_proc(rule_runner)	1✔
142	assert "-Xmx1g" in proc.argv	1✔
143
144
145	@maybe_skip_jdk_test	1✔
146	def test_error_if_users_specify_max_heap_as_jvm_option(rule_runner: RuleRunner) -> None:	1✔
147	global_jvm_options = ["-Xmx1g"]	1✔
148	rule_runner.set_options(	1✔
149	[f"--jvm-global-options={repr(global_jvm_options)}"],
150	env_inherit=PYTHON_BOOTSTRAP_ENV,
151	)
152
153	with pytest.raises(ExecutionError, match="Invalid value for JVM options: -Xmx1g."):	1✔
154	javac_version_proc(rule_runner)	1✔
155
156
157	@maybe_skip_jdk_test	1✔
158	def test_pass_jvm_options_to_java_program(rule_runner: RuleRunner) -> None:	1✔
159	global_jvm_options = ["-Dpants.jvm.global=true"]	1✔
160
161	# Rely on JEP-330 to run a Java file from source so we don´t need a compile step.
162	rule_runner.set_options(	1✔
163	["--jvm-tool-jdk=temurin:1.11.0.23", f"--jvm-global-options={repr(global_jvm_options)}"],
164	env_inherit=PYTHON_BOOTSTRAP_ENV,
165	)
166
167	classname = "EchoSystemProperties"	1✔
168	filename = f"{classname}.java"	1✔
169	file_content = textwrap.dedent(	1✔
170	f"""\
171	public class {classname} {{
172	public static void main(String[] args) {{
173	System.getProperties().list(System.out);
174	}}
175	}}
176	"""
177	)
178
179	input_digest = rule_runner.request(	1✔
180	Digest,
181	[
182	CreateDigest(
183	[
184	FileContent(
185	filename,
186	file_content.encode("utf-8"),
187	)
188	]
189	)
190	],
191	)
192
193	jdk = rule_runner.request(InternalJdk, [])	1✔
194	process_result = rule_runner.request(	1✔
195	ProcessResult,
196	[
197	JvmProcess(
198	jdk=jdk,
199	argv=[filename],
200	classpath_entries=(),
201	extra_jvm_options=["-Dpants.jvm.extra=true"],
202	input_digest=input_digest,
203	description="Echo JVM System properties",
204	use_nailgun=False,
205	)
206	],
207	)
208
209	jvm_properties = [	1✔
210	prop for prop in process_result.stdout.decode("utf-8").splitlines() if "=" in prop
211	]
212	assert "java.specification.version=11" in jvm_properties	1✔
213	assert "pants.jvm.global=true" in jvm_properties	1✔
214	assert "pants.jvm.extra=true" in jvm_properties	1✔
215
216
217	@maybe_skip_jdk_test	1✔
218	def test_jvm_not_found_when_empty_jvm_index(rule_runner: RuleRunner) -> None:	1✔
219	# Prepare empty JVM Index file
220	filename = "index.json"	1✔
221	file_content = textwrap.dedent(	1✔
222	"""\
223	{}
224	"""
225	)
226	rule_runner.write_files({filename: file_content})	1✔
227
228	jdk_release_version = "21"	1✔
229	jdk_binary = f"adoptium:1.{jdk_release_version}"	1✔
230
231	# Assert jdk_binary is found with default JVM Index
232	rule_runner.set_options([f"--jvm-tool-jdk={jdk_binary}"], env_inherit=PYTHON_BOOTSTRAP_ENV)	1✔
233	assert f'openjdk version "{jdk_release_version}' in run_javac_version(rule_runner)	1✔
234
235	# Assert jdk_binary is not found with empty JVM Index
236	rule_runner.set_options(	1✔
237	[
238	f"--coursier-jvm-index={rule_runner.build_root}/{filename}",
239	f"--jvm-tool-jdk={jdk_binary}",
240	],
241	env_inherit=PYTHON_BOOTSTRAP_ENV,
242	)
243	expected_exception_msg = rf".?JVM {jdk_binary} not found in index.?"	1✔
244	with pytest.raises(ExecutionError, match=expected_exception_msg):	1✔
245	run_javac_version(rule_runner)	1✔

pantsbuild / pants / 23173232554

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