22961863890

Committed 11 Mar 2026 03:59PM UTC coverage: 92.938%. Remained the same

Build # 22961863890

Build Type

Pull #23166

github

Committed by

web-flow

Commit Message

Merge 111e3acd6 into 3dcbfd399

Pull Request Pull Request #23166: un bitrot flaky tests

Coverage Stats

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

1 existing line in 1 file now uncovered.

91162 of 98089 relevant lines covered (92.94%)

4.39 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 / 22961863890

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