Archived
206 lines
12 KiB
Python
206 lines
12 KiB
Python
"""Reuse eligibility, CI-friendly Maven versions, safe XML in any encoding, the cache-save check, and the slimmed enrollment."""
|
|
|
|
import json
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
from typing import Any, cast
|
|
|
|
from platform_ci.__main__ import main
|
|
from platform_ci.caching import cache_save_unneeded_reason
|
|
from platform_ci.delivery.enrollment import parse_enrollment
|
|
from platform_ci.delivery.errors import EnrollmentError
|
|
from platform_ci.delivery.forge import ForgeGitHistory
|
|
from platform_ci.delivery.git_history import GitHistoryError
|
|
from platform_ci.safe_xml import ForbiddenDeclarationError, parse_without_declarations
|
|
from platform_ci.versions import UNDECLARED, command_properties, parse_declared_version
|
|
from platform_ci.workspace import PipelineError
|
|
from tests.support import PLATFORM_REVISION, SOURCE_TREE, event, example_configuration, plan_for
|
|
from tests.synthetic_services import CANONICAL_REFERENCE, enrollment
|
|
|
|
NS = 'xmlns="http://maven.apache.org/POM/4.0.0"'
|
|
|
|
|
|
def _pom(version: str, properties: str = "", parent: str = "") -> bytes:
|
|
"""A POM document with the given version expression, properties and parent block."""
|
|
return f"<project {NS}>{parent}<version>{version}</version><properties>{properties}</properties></project>".encode()
|
|
|
|
|
|
class ReuseEligibilityTest(unittest.TestCase):
|
|
"""Reuse can replace a required push or PR verification; manual and callable events still verify."""
|
|
|
|
def _plan(self, name: str, ref: str, tree: str = SOURCE_TREE) -> dict[str, Any]:
|
|
context = event(name, ref)
|
|
return cast("dict[str, Any]", plan_for(example_configuration("maven-publication.ci.yaml"), type(context)(context.name, context.ref, context.source_revision, context.platform_revision, context.default_branch, tree)))
|
|
|
|
def test_required_push_and_pr_are_eligible_but_manual_and_callable_events_verify(self) -> None:
|
|
self.assertTrue(self._plan("push", "refs/heads/develop")["reuse"]["eligible"])
|
|
self.assertTrue(self._plan("push", "refs/heads/main")["reuse"]["eligible"])
|
|
self.assertTrue(self._plan("pull_request", "refs/pull/1/merge")["reuse"]["eligible"])
|
|
self.assertFalse(self._plan("workflow_dispatch", "refs/heads/main")["reuse"]["eligible"])
|
|
self.assertFalse(self._plan("workflow_call", "refs/heads/main")["reuse"]["eligible"])
|
|
|
|
def test_an_unrequested_push_has_nothing_to_replace(self) -> None:
|
|
plan = self._plan("push", "refs/heads/feature-x")
|
|
self.assertFalse(plan["reuse"]["eligible"])
|
|
self.assertFalse(plan["verification"]["required"])
|
|
|
|
def test_without_a_tree_id_equality_cannot_be_proven_so_reuse_is_off(self) -> None:
|
|
self.assertFalse(self._plan("push", "refs/heads/develop", tree="")["reuse"]["eligible"])
|
|
self.assertFalse(self._plan("pull_request", "refs/pull/1/merge", tree="")["reuse"]["eligible"])
|
|
|
|
def test_prepare_refuses_a_malformed_tree_id(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
source = Path(directory)
|
|
(source / ".ci.yaml").write_text((Path(__file__).resolve().parent.parent / "examples" / "maven.ci.yaml").read_text(encoding="utf-8"), encoding="utf-8")
|
|
environment = {"CI_EVENT_NAME": "push", "CI_EVENT_REF": "refs/heads/main", "CI_SOURCE_REVISION": "a" * 40, "CI_PLATFORM_REVISION": PLATFORM_REVISION, "CI_SOURCE_TREE": "tree", "GITHUB_OUTPUT": str(source / "out")}
|
|
with self.assertLogs("platform_ci", level="ERROR"):
|
|
self.assertEqual(main(["prepare", "--source", str(source)], environment), 1)
|
|
|
|
|
|
class CiFriendlyVersionTest(unittest.TestCase):
|
|
"""Maven's CI-friendly version forms resolve as Maven resolves them; nothing valid is silently unusable and nothing is guessed."""
|
|
|
|
def test_revision_sha1_and_changelist_compose_from_the_pom_properties(self) -> None:
|
|
pom = _pom("${revision}${sha1}${changelist}", "<revision>1.4.0</revision><sha1></sha1><changelist>-SNAPSHOT</changelist>")
|
|
self.assertEqual(parse_declared_version("maven", pom), "1.4.0-SNAPSHOT")
|
|
|
|
def test_a_command_line_property_overrides_the_pom_like_the_build_does(self) -> None:
|
|
pom = _pom("${revision}${changelist}", "<revision>1.4.0</revision><changelist>-SNAPSHOT</changelist>")
|
|
commands = [["mvn", "-B", "-Dchangelist=", "-Drevision=2.0.0", "verify"]]
|
|
self.assertEqual(parse_declared_version("maven", pom, commands), "2.0.0")
|
|
self.assertEqual(command_properties(commands), {"changelist": "", "revision": "2.0.0"})
|
|
|
|
def test_properties_may_reference_other_properties(self) -> None:
|
|
pom = _pom("${app.version}", "<app.version>${major}.1</app.version><major>3</major>")
|
|
self.assertEqual(parse_declared_version("maven", pom), "3.1")
|
|
|
|
def test_parent_version_and_namespaced_documents(self) -> None:
|
|
self.assertEqual(parse_declared_version("maven", f"<project {NS}><parent><version>5.0.0</version></parent></project>".encode()), "5.0.0")
|
|
self.assertEqual(parse_declared_version("maven", b"<project><version>1.0.0</version></project>"), "1.0.0")
|
|
|
|
def test_unresolvable_expressions_are_undeclared_not_guessed(self) -> None:
|
|
self.assertEqual(parse_declared_version("maven", _pom("${revision}")), UNDECLARED)
|
|
self.assertEqual(parse_declared_version("maven", _pom("${env.BUILD_NUMBER}")), UNDECLARED)
|
|
self.assertEqual(parse_declared_version("maven", _pom("${loop}", "<loop>${loop}</loop>")), UNDECLARED)
|
|
|
|
def test_dtd_and_entities_are_refused_in_utf8_and_utf16(self) -> None:
|
|
document = '<?xml version="1.0"?><!DOCTYPE project [<!ENTITY v "1.0.0">]><project><version>&v;</version></project>'
|
|
for name, content in {"utf-8": document.encode("utf-8"), "utf-16": document.replace("1.0", '1.0"').encode("utf-16"), "utf-16le": ('<?xml version="1.0" encoding="UTF-16"?>' + document.split("?>", 1)[1]).encode("utf-16-le")}.items():
|
|
with self.subTest(name), self.assertRaisesRegex(PipelineError, "DTD or entity|well-formed"):
|
|
parse_declared_version("maven", content)
|
|
|
|
def test_a_utf16_pom_without_declarations_is_read(self) -> None:
|
|
content = '<?xml version="1.0" encoding="UTF-16"?><project><version>7.1.0</version></project>'.encode("utf-16")
|
|
self.assertEqual(parse_declared_version("maven", content), "7.1.0")
|
|
|
|
def test_shared_parser_matches_the_junit_readers_behaviour(self) -> None:
|
|
with self.assertRaises(ForbiddenDeclarationError):
|
|
parse_without_declarations('<!DOCTYPE a [<!ENTITY b "c">]><a/>'.encode("utf-16"))
|
|
self.assertEqual(parse_without_declarations(b"<a><b/></a>").tag, "a")
|
|
|
|
|
|
class CacheSaveCheckTest(unittest.TestCase):
|
|
"""A cache directory the build never created is reported as absent, never as a saved cache."""
|
|
|
|
def test_missing_empty_and_populated_directories(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = Path(directory)
|
|
self.assertIn("not created", cast(str, cache_save_unneeded_reason(root / "_cacache")))
|
|
(root / "_cacache").mkdir()
|
|
self.assertIn("empty", cast(str, cache_save_unneeded_reason(root / "_cacache")))
|
|
(root / "_cacache" / "index-v5").write_text("x", encoding="utf-8")
|
|
self.assertIsNone(cache_save_unneeded_reason(root / "_cacache"))
|
|
|
|
def test_command_publishes_exists_false_for_an_absent_directory_and_adds_no_dependency(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
output = Path(directory) / "out"
|
|
self.assertEqual(main(["cache-save-check"], {"CI_CACHE_PATH": str(Path(directory) / "missing"), "GITHUB_OUTPUT": str(output)}), 0)
|
|
self.assertIn("exists=false", output.read_text(encoding="utf-8"))
|
|
(Path(directory) / "present").mkdir()
|
|
(Path(directory) / "present" / "file").write_text("x", encoding="utf-8")
|
|
self.assertEqual(main(["cache-save-check"], {"CI_CACHE_PATH": str(Path(directory) / "present"), "GITHUB_OUTPUT": str(output)}), 0)
|
|
self.assertIn("exists=true", output.read_text(encoding="utf-8"))
|
|
|
|
|
|
class SlimEnrollmentTest(unittest.TestCase):
|
|
"""Fields that choose behavior come from repository configuration; the enrollment authorizes and bounds only."""
|
|
|
|
def _document(self) -> dict[str, Any]:
|
|
return {
|
|
"schema": 1,
|
|
"company": "kof",
|
|
"repository": "KofTwentyTwo/widget",
|
|
"repository_id": 41,
|
|
"workflow_references": [CANONICAL_REFERENCE],
|
|
"platform_revisions": ["b" * 40],
|
|
"max_artifact_bytes": 1000,
|
|
"max_runs_scanned": 10,
|
|
"destinations": [{"destination": "company-packages", "formats": ["maven"], "channels": ["snapshot"], "target": {"kind": "package", "owner": "KofTwentyTwo"}}],
|
|
}
|
|
|
|
def test_behavior_fields_are_not_accepted_in_an_enrollment(self) -> None:
|
|
for field_name in ("branch", "required_jobs", "versioning", "publications", "channels", "format"):
|
|
with self.subTest(field_name):
|
|
document = self._document()
|
|
document[field_name] = "x"
|
|
with self.assertRaises(EnrollmentError):
|
|
parse_enrollment(document)
|
|
|
|
def test_the_scope_carries_identity_bounds_and_trusted_revisions_only(self) -> None:
|
|
scope = parse_enrollment(self._document()).scope
|
|
self.assertEqual((scope.repository, scope.repository_id, scope.workflow_references, scope.platform_revisions), ("KofTwentyTwo/widget", 41, frozenset({CANONICAL_REFERENCE}), frozenset({"b" * 40})))
|
|
|
|
def test_enrollment_helper_and_documented_fields_agree(self) -> None:
|
|
self.assertEqual(sorted(json.loads(json.dumps(self._document()))), sorted(["schema", "company", "repository", "repository_id", "workflow_references", "platform_revisions", "max_artifact_bytes", "max_runs_scanned", "destinations"]))
|
|
self.assertEqual(enrollment().workflow_references, frozenset({CANONICAL_REFERENCE}))
|
|
|
|
|
|
class _HistoryForge:
|
|
"""A forge whose commit listing serves a fixed newest-first history, 50 per page, and counts page reads."""
|
|
|
|
def __init__(self, length: int) -> None:
|
|
self.commits = [f"{index:040x}" for index in range(length, 0, -1)]
|
|
self.pages: list[int] = []
|
|
|
|
def get(self, path: str) -> object:
|
|
page, limit = int(path.split("page=")[1].split("&", maxsplit=1)[0]), int(path.split("limit=")[1].split("&", maxsplit=1)[0])
|
|
self.pages.append(page)
|
|
return [{"sha": sha} for sha in self.commits[(page - 1) * limit : page * limit]]
|
|
|
|
def download(self, path: str, destination: Path, limit: int) -> None:
|
|
raise AssertionError
|
|
|
|
|
|
class AncestryEarlyStopTest(unittest.TestCase):
|
|
"""Ancestry reads history newest first and stops at the first page that proves it, instead of walking the whole history."""
|
|
|
|
def test_a_recent_ancestor_reads_one_page_of_a_long_history(self) -> None:
|
|
forge = _HistoryForge(500)
|
|
history = ForgeGitHistory(forge, "o/r", 20)
|
|
self.assertTrue(history.is_ancestor(forge.commits[3], forge.commits[0]))
|
|
self.assertEqual(forge.pages, [1])
|
|
|
|
def test_a_later_question_continues_where_the_last_stopped(self) -> None:
|
|
forge = _HistoryForge(500)
|
|
history = ForgeGitHistory(forge, "o/r", 20)
|
|
self.assertTrue(history.is_ancestor(forge.commits[60], forge.commits[0]))
|
|
self.assertTrue(history.is_ancestor(forge.commits[10], forge.commits[0]))
|
|
self.assertTrue(history.is_ancestor(forge.commits[120], forge.commits[0]))
|
|
self.assertEqual(forge.pages, [1, 2, 3])
|
|
|
|
def test_a_commit_outside_a_short_history_is_not_an_ancestor_and_is_not_reread(self) -> None:
|
|
forge = _HistoryForge(70)
|
|
history = ForgeGitHistory(forge, "o/r", 20)
|
|
self.assertFalse(history.is_ancestor("f" * 40, forge.commits[0]))
|
|
reads = len(forge.pages)
|
|
self.assertFalse(history.is_ancestor("e" * 40, forge.commits[0]))
|
|
self.assertEqual(len(forge.pages), reads)
|
|
|
|
def test_an_ancestor_beyond_the_bound_is_not_proven_rather_than_false(self) -> None:
|
|
forge = _HistoryForge(500)
|
|
history = ForgeGitHistory(forge, "o/r", 2)
|
|
with self.assertRaisesRegex(GitHistoryError, "not proven"):
|
|
history.is_ancestor(forge.commits[300], forge.commits[0])
|
|
self.assertEqual(forge.pages, [1, 2])
|