21494992949

Committed 29 Jan 2026 09:15PM UTC coverage: 80.245%. First build

Build # 21494992949

Build Type

Pull #23053

github

Committed by

web-flow

Commit Message

Merge 16a8312ae into 78e2689de

Pull Request Pull Request #23053: Skip Preemptive Python

Run Details

71 of 124 new or added lines in 5 files covered. (57.26%)

78854 of 98267 relevant lines covered (80.24%)

3.09 hits per line

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

83.95

/src/python/pants/core/goals/publish_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 json
from dataclasses import dataclass
from textwrap import dedent

import pytest

from pants.backend.python.goals import package_dists
from pants.backend.python.macros.python_artifact import PythonArtifact
from pants.backend.python.target_types import PythonDistribution, PythonSourcesGeneratorTarget
from pants.backend.python.target_types_rules import rules as python_target_type_rules
from pants.core.goals import package, publish
from pants.core.goals.publish import (
    CheckSkipRequest,
    CheckSkipResult,
    Publish,
    PublishFieldSet,
    PublishPackages,
    PublishProcesses,
    PublishRequest,
)
from pants.engine.process import Process, ProcessCacheScope
from pants.engine.rules import rule
from pants.engine.target import StringSequenceField
from pants.engine.unions import UnionRule
from pants.testutil.rule_runner import RuleRunner


class MockRepositoriesField(StringSequenceField):
    alias = "repositories"


@dataclass(frozen=True)
class MockPublishRequest(PublishRequest):
    pass


@dataclass(frozen=True)
class PublishTestFieldSet(PublishFieldSet):
    publish_request_type = MockPublishRequest
    required_fields = (MockRepositoriesField,)

    repositories: MockRepositoriesField

    def make_skip_request(self, package_fs: package.PackageFieldSet) -> TestPreemptiveSkipRequest:
        return TestPreemptiveSkipRequest(publish_fs=self, package_fs=package_fs)


class TestPreemptiveSkipRequest(CheckSkipRequest[PublishTestFieldSet]):
    pass


@rule
async def mock_check_if_skip(request: TestPreemptiveSkipRequest) -> CheckSkipResult:
    if not request.publish_fs.repositories.value:
        return CheckSkipResult.skip(names=[], data=request.publish_fs.get_output_data())
    if request.publish_fs.repositories.value == ("skip-package",):
        return CheckSkipResult.skip(skip_packaging_only=True)
    if request.publish_fs.repositories.value == ("skip",):
        return CheckSkipResult.skip(
            names=["my_package-0.1.0-py3-none-any.whl", "my_package-0.1.0.tar.gz"],
            description="(requested)",
            data=request.publish_fs.get_output_data(),
        )
    return CheckSkipResult.no_skip()


@rule
async def mock_publish(request: MockPublishRequest) -> PublishProcesses:
    assert len(request.field_set.repositories.value) > 0
    names = (
        ("my_other_package-0.1.0-py3-none-any.whl", "my_other_package-0.1.0.tar.gz")
        if request.field_set.repositories.value == ("skip-package",)
        else tuple(
            artifact.relpath
            for pkg in request.packages
            for artifact in pkg.artifacts
            if artifact.relpath
        )
    )
    return PublishProcesses(
        PublishPackages(
            names=names,
            process=(
                None
                if repo == "skip"
                else Process(
                    ["/bin/echo", repo],
                    cache_scope=ProcessCacheScope.PER_SESSION,
                    description="mock publish",
                )
            ),
            description="(requested)" if repo == "skip" else repo,
        )
        for repo in request.field_set.repositories.value
    )


@pytest.fixture
def rule_runner() -> RuleRunner:
    return RuleRunner(
        rules=[
            *package.rules(),
            *publish.rules(),
            *package_dists.rules(),
            *python_target_type_rules(),
            mock_check_if_skip,
            mock_publish,
            PythonDistribution.register_plugin_field(MockRepositoriesField),
            *PublishTestFieldSet.rules(),
            UnionRule(CheckSkipRequest, TestPreemptiveSkipRequest),
        ],
        target_types=[PythonSourcesGeneratorTarget, PythonDistribution],
        objects={"python_artifact": PythonArtifact},
    )


def test_noop(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "src/BUILD": dedent(
                """\
                python_sources()
                python_distribution(
                  name="dist",
                  provides=python_artifact(
                    name="my-package",
                    version="0.1.0",
                  ),
                )
                """
            ),
        }
    )

    result = rule_runner.run_goal_rule(
        Publish,
        args=("src:dist",),
        env_inherit={"HOME", "PATH", "PYENV_ROOT"},
    )

    assert result.exit_code == 0
    assert "Nothing published." in result.stderr


def test_skipped_publish(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "src/BUILD": dedent(
                """\
                python_sources()
                python_distribution(
                  name="dist",
                  provides=python_artifact(
                    name="my-package",
                    version="0.1.0",
                  ),
                  repositories=["skip"],
                )
                """
            ),
        }
    )

    result = rule_runner.run_goal_rule(
        Publish,
        args=("src:dist",),
        env_inherit={"HOME", "PATH", "PYENV_ROOT"},
    )

    assert result.exit_code == 0
    assert "my_package-0.1.0.tar.gz skipped (requested)." in result.stderr
    assert "my_package-0.1.0-py3-none-any.whl skipped (requested)." in result.stderr


def test_skip_package_only(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "src/BUILD": dedent(
                """\
                python_sources()
                python_distribution(
                  name="dist",
                  provides=python_artifact(
                    name="my-package",
                    version="0.1.0",
                  ),
                  repositories=["skip-package"],
                )
                """
            ),
        }
    )
    result = rule_runner.run_goal_rule(
        Publish,
        args=("src:dist",),
        env_inherit={"HOME", "PATH", "PYENV_ROOT"},
    )

    assert result.exit_code == 0
    assert "my_other_package-0.1.0.tar.gz published to skip-package." in result.stderr
    assert "my_other_package-0.1.0-py3-none-any.whl published to skip-package." in result.stderr


def test_structured_output(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "src/BUILD": dedent(
                """\
                python_sources()
                python_distribution(
                  name="dist",
                  provides=python_artifact(
                    name="my-package",
                    version="0.1.0",
                  ),
                  repositories=["skip"],
                )
                """
            ),
        }
    )

    result = rule_runner.run_goal_rule(
        Publish,
        args=(
            "--output=published.json",
            "src:dist",
        ),
        env_inherit={"HOME", "PATH", "PYENV_ROOT"},
    )

    assert result.exit_code == 0
    assert "my_package-0.1.0.tar.gz skipped (requested)." in result.stderr
    assert "my_package-0.1.0-py3-none-any.whl skipped (requested)." in result.stderr

    expected = [
        {
            "names": [
                "my_package-0.1.0-py3-none-any.whl",
                "my_package-0.1.0.tar.gz",
            ],
            "published": False,
            "status": "skipped (requested)",
            "target": "src:dist",
        },
    ]

    with rule_runner.pushd():
        with open("published.json") as fd:
            data = json.load(fd)
            assert data == expected


def test_mocked_publish(rule_runner: RuleRunner) -> None:
    rule_runner.write_files(
        {
            "src/BUILD": dedent(
                """\
                python_sources()
                python_distribution(
                  name="dist",
                  provides=python_artifact(
                    name="my-package",
                    version="0.1.0",
                  ),
                  repositories=["mocked-repo"],
                )
                """
            ),
        }
    )

    result = rule_runner.run_goal_rule(
        Publish,
        args=("src:dist",),
        env_inherit={"HOME", "PATH", "PYENV_ROOT"},
    )

    assert result.exit_code == 0
    assert "my_package-0.1.0.tar.gz published to mocked-repo." in result.stderr
    assert "my_package-0.1.0-py3-none-any.whl published to mocked-repo." in result.stderr

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 json	1✔
7	from dataclasses import dataclass	1✔
8	from textwrap import dedent	1✔
9
10	import pytest	1✔
11
12	from pants.backend.python.goals import package_dists	1✔
13	from pants.backend.python.macros.python_artifact import PythonArtifact	1✔
14	from pants.backend.python.target_types import PythonDistribution, PythonSourcesGeneratorTarget	1✔
15	from pants.backend.python.target_types_rules import rules as python_target_type_rules	1✔
16	from pants.core.goals import package, publish	1✔
17	from pants.core.goals.publish import (	1✔
18	CheckSkipRequest,
19	CheckSkipResult,
20	Publish,
21	PublishFieldSet,
22	PublishPackages,
23	PublishProcesses,
24	PublishRequest,
25	)
26	from pants.engine.process import Process, ProcessCacheScope	1✔
27	from pants.engine.rules import rule	1✔
28	from pants.engine.target import StringSequenceField	1✔
29	from pants.engine.unions import UnionRule	1✔
30	from pants.testutil.rule_runner import RuleRunner	1✔
31
32
33	class MockRepositoriesField(StringSequenceField):	1✔
34	alias = "repositories"	1✔
35
36
37	@dataclass(frozen=True)	1✔
38	class MockPublishRequest(PublishRequest):	1✔
39	pass	1✔
40
41
42	@dataclass(frozen=True)	1✔
43	class PublishTestFieldSet(PublishFieldSet):	1✔
44	publish_request_type = MockPublishRequest	1✔
45	required_fields = (MockRepositoriesField,)	1✔
46
47	repositories: MockRepositoriesField	1✔
48
49	def make_skip_request(self, package_fs: package.PackageFieldSet) -> TestPreemptiveSkipRequest:	1✔
NEW 50	return TestPreemptiveSkipRequest(publish_fs=self, package_fs=package_fs)	×
51
52
53	class TestPreemptiveSkipRequest(CheckSkipRequest[PublishTestFieldSet]):	1✔
54	pass	1✔
55
56
57	@rule	1✔
58	async def mock_check_if_skip(request: TestPreemptiveSkipRequest) -> CheckSkipResult:	1✔
NEW 59	if not request.publish_fs.repositories.value:	×
NEW 60	return CheckSkipResult.skip(names=[], data=request.publish_fs.get_output_data())	×
NEW 61	if request.publish_fs.repositories.value == ("skip-package",):	×
NEW 62	return CheckSkipResult.skip(skip_packaging_only=True)	×
NEW 63	if request.publish_fs.repositories.value == ("skip",):	×
NEW 64	return CheckSkipResult.skip(	×
65	names=["my_package-0.1.0-py3-none-any.whl", "my_package-0.1.0.tar.gz"],
66	description="(requested)",
67	data=request.publish_fs.get_output_data(),
68	)
NEW 69	return CheckSkipResult.no_skip()	×
70
71
72	@rule	1✔
73	async def mock_publish(request: MockPublishRequest) -> PublishProcesses:	1✔
NEW 74	assert len(request.field_set.repositories.value) > 0	×
NEW 75	names = (	×
76	("my_other_package-0.1.0-py3-none-any.whl", "my_other_package-0.1.0.tar.gz")
77	if request.field_set.repositories.value == ("skip-package",)
78	else tuple(
79	artifact.relpath
80	for pkg in request.packages
81	for artifact in pkg.artifacts
82	if artifact.relpath
83	)
84	)
85	return PublishProcesses(	×
86	PublishPackages(
87	names=names,
88	process=(
89	None
90	if repo == "skip"
91	else Process(
92	["/bin/echo", repo],
93	cache_scope=ProcessCacheScope.PER_SESSION,
94	description="mock publish",
95	)
96	),
97	description="(requested)" if repo == "skip" else repo,
98	)
99	for repo in request.field_set.repositories.value
100	)
101
102
103	@pytest.fixture	1✔
104	def rule_runner() -> RuleRunner:	1✔
105	return RuleRunner(	1✔
106	rules=[
107	*package.rules(),
108	*publish.rules(),
109	*package_dists.rules(),
110	*python_target_type_rules(),
111	mock_check_if_skip,
112	mock_publish,
113	PythonDistribution.register_plugin_field(MockRepositoriesField),
114	*PublishTestFieldSet.rules(),
115	UnionRule(CheckSkipRequest, TestPreemptiveSkipRequest),
116	],
117	target_types=[PythonSourcesGeneratorTarget, PythonDistribution],
118	objects={"python_artifact": PythonArtifact},
119	)
120
121
122	def test_noop(rule_runner: RuleRunner) -> None:	1✔
123	rule_runner.write_files(	1✔
124	{
125	"src/BUILD": dedent(
126	"""\
127	python_sources()
128	python_distribution(
129	name="dist",
130	provides=python_artifact(
131	name="my-package",
132	version="0.1.0",
133	),
134	)
135	"""
136	),
137	}
138	)
139
140	result = rule_runner.run_goal_rule(	1✔
141	Publish,
142	args=("src:dist",),
143	env_inherit={"HOME", "PATH", "PYENV_ROOT"},
144	)
145
146	assert result.exit_code == 0	×
147	assert "Nothing published." in result.stderr	×
148
149
150	def test_skipped_publish(rule_runner: RuleRunner) -> None:	1✔
151	rule_runner.write_files(	1✔
152	{
153	"src/BUILD": dedent(
154	"""\
155	python_sources()
156	python_distribution(
157	name="dist",
158	provides=python_artifact(
159	name="my-package",
160	version="0.1.0",
161	),
162	repositories=["skip"],
163	)
164	"""
165	),
166	}
167	)
168
169	result = rule_runner.run_goal_rule(	1✔
170	Publish,
171	args=("src:dist",),
172	env_inherit={"HOME", "PATH", "PYENV_ROOT"},
173	)
174
175	assert result.exit_code == 0	1✔
176	assert "my_package-0.1.0.tar.gz skipped (requested)." in result.stderr	1✔
177	assert "my_package-0.1.0-py3-none-any.whl skipped (requested)." in result.stderr	1✔
178
179
180	def test_skip_package_only(rule_runner: RuleRunner) -> None:	1✔
181	rule_runner.write_files(	1✔
182	{
183	"src/BUILD": dedent(
184	"""\
185	python_sources()
186	python_distribution(
187	name="dist",
188	provides=python_artifact(
189	name="my-package",
190	version="0.1.0",
191	),
192	repositories=["skip-package"],
193	)
194	"""
195	),
196	}
197	)
198	result = rule_runner.run_goal_rule(	1✔
199	Publish,
200	args=("src:dist",),
201	env_inherit={"HOME", "PATH", "PYENV_ROOT"},
202	)
203
204	assert result.exit_code == 0	1✔
205	assert "my_other_package-0.1.0.tar.gz published to skip-package." in result.stderr	1✔
206	assert "my_other_package-0.1.0-py3-none-any.whl published to skip-package." in result.stderr	1✔
207
208
209	def test_structured_output(rule_runner: RuleRunner) -> None:	1✔
210	rule_runner.write_files(	1✔
211	{
212	"src/BUILD": dedent(
213	"""\
214	python_sources()
215	python_distribution(
216	name="dist",
217	provides=python_artifact(
218	name="my-package",
219	version="0.1.0",
220	),
221	repositories=["skip"],
222	)
223	"""
224	),
225	}
226	)
227
228	result = rule_runner.run_goal_rule(	1✔
229	Publish,
230	args=(
231	"--output=published.json",
232	"src:dist",
233	),
234	env_inherit={"HOME", "PATH", "PYENV_ROOT"},
235	)
236
237	assert result.exit_code == 0	1✔
238	assert "my_package-0.1.0.tar.gz skipped (requested)." in result.stderr	1✔
239	assert "my_package-0.1.0-py3-none-any.whl skipped (requested)." in result.stderr	1✔
240
241	expected = [	1✔
242	{
243	"names": [
244	"my_package-0.1.0-py3-none-any.whl",
245	"my_package-0.1.0.tar.gz",
246	],
247	"published": False,
248	"status": "skipped (requested)",
249	"target": "src:dist",
250	},
251	]
252
253	with rule_runner.pushd():	1✔
254	with open("published.json") as fd:	1✔
255	data = json.load(fd)	1✔
256	assert data == expected	1✔
257
258
259	def test_mocked_publish(rule_runner: RuleRunner) -> None:	1✔
260	rule_runner.write_files(	1✔
261	{
262	"src/BUILD": dedent(
263	"""\
264	python_sources()
265	python_distribution(
266	name="dist",
267	provides=python_artifact(
268	name="my-package",
269	version="0.1.0",
270	),
271	repositories=["mocked-repo"],
272	)
273	"""
274	),
275	}
276	)
277
278	result = rule_runner.run_goal_rule(	1✔
279	Publish,
280	args=("src:dist",),
281	env_inherit={"HOME", "PATH", "PYENV_ROOT"},
282	)
283
284	assert result.exit_code == 0	1✔
285	assert "my_package-0.1.0.tar.gz published to mocked-repo." in result.stderr	1✔
286	assert "my_package-0.1.0-py3-none-any.whl published to mocked-repo." in result.stderr	1✔

pantsbuild / pants / 21494992949

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