ravenous_roll20/tests/test_ci_badges.py

200 lines
7.8 KiB
Python

import os
import stat
import subprocess
import tempfile
import unittest
import xml.etree.ElementTree as ET
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
RENDERER = ROOT / "scripts/ci-coverage-badges.sh"
PUBLISHER = ROOT / "scripts/publish-coverage-badges.sh"
class BadgeRendererTests(unittest.TestCase):
def render(self, directory: Path, kind: str, *args: str) -> Path:
output = directory / f"{kind}.svg"
subprocess.run(
[str(RENDERER), kind, *args, "--output", str(output)],
cwd=ROOT,
check=True,
)
ET.parse(output)
return output
def test_supported_badges_are_valid_xml_with_expected_colors(self):
cases = (
("version", ("--value", "0.1.0"), "#007ec6"),
("version", ("--value", "2026.10.04-very-long-version"), "#007ec6"),
("test", ("--value", "passing"), "#4c1"),
("test", ("--value", "failing"), "#e05d44"),
("coverage", ("--value", "42.4"), "#e05d44"),
("coverage", ("--value", "70"), "#dfb317"),
("coverage", ("--value", "91.8"), "#4c1"),
("coverage", ("--value", "-"), "#9f9f9f"),
)
with tempfile.TemporaryDirectory() as temporary:
directory = Path(temporary)
for index, (kind, args, color) in enumerate(cases):
with self.subTest(kind=kind, args=args):
output = directory / f"badge-{index}.svg"
subprocess.run(
[str(RENDERER), kind, *args, "--output", str(output)],
cwd=ROOT,
check=True,
)
ET.parse(output)
self.assertIn(color, output.read_text(encoding="utf-8"))
def test_custom_text_dimensions_and_xml_escaping(self):
with tempfile.TemporaryDirectory() as temporary:
output = self.render(
Path(temporary),
"version",
"--text", "release<&\"",
"--value", "v1<&\"",
"--color", "#8a2be2",
"--size", "12",
"--height", "24",
"--label-width", "100",
"--value-width", "110",
)
text = output.read_text(encoding="utf-8")
self.assertIn('width="210" height="24"', text)
self.assertIn("release&lt;&amp;&quot;", text)
self.assertIn("v1&lt;&amp;&quot;", text)
def test_invalid_input_does_not_replace_existing_badge(self):
invalid = (
("unknown",),
("coverage", "--unknown", "x"),
("coverage", "--value", "101"),
("coverage", "--value", "not-a-number"),
("test", "--height", "13"),
("version", "--color", "purple"),
("version", "--text", "line\nbreak"),
)
with tempfile.TemporaryDirectory() as temporary:
output = self.render(Path(temporary), "version", "--value", "valid")
original = output.read_bytes()
for args in invalid:
with self.subTest(args=args):
result = subprocess.run(
[str(RENDERER), *args, "--output", str(output)],
cwd=ROOT,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
self.assertNotEqual(0, result.returncode)
self.assertEqual(original, output.read_bytes())
class BadgePublicationTests(unittest.TestCase):
def setUp(self):
self.temporary = tempfile.TemporaryDirectory()
self.workspace = Path(self.temporary.name) / "workspace"
self.root = Path(self.temporary.name) / "publication"
(self.workspace / "coverage").mkdir(parents=True)
self.root.mkdir(mode=0o700)
for name in ("version", "test", "coverage"):
subprocess.run(
[str(RENDERER), name, "--output", f"coverage/{name}.svg"],
cwd=self.workspace,
check=True,
)
def tearDown(self):
self.temporary.cleanup()
def publish(self, *names: str, check: bool = True):
return subprocess.run(
[str(PUBLISHER), str(self.root), "Ravenous", "ravenous_roll20", "main", *names],
cwd=self.workspace,
check=check,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
def test_publication_is_atomic_idempotent_and_sets_public_modes(self):
old_umask = os.umask(0o077)
try:
self.publish("version", "test", "coverage")
self.publish("version", "test", "coverage")
finally:
os.umask(old_umask)
destination = self.root / "Ravenous/ravenous_roll20/main"
self.assertEqual(0o755, stat.S_IMODE(destination.stat().st_mode))
self.assertEqual({"version.svg", "test.svg", "coverage.svg"},
{path.name for path in destination.iterdir()})
for badge in destination.iterdir():
self.assertEqual(0o644, stat.S_IMODE(badge.stat().st_mode))
self.assertGreater(badge.stat().st_size, 0)
self.assertFalse(badge.is_symlink())
self.assertEqual([], list(destination.glob(".*.tmp-*")))
def test_old_default_branch_symlink_is_unlinked_without_touching_target(self):
project = self.root / "Ravenous/ravenous_roll20"
project.mkdir(parents=True)
old_target = Path(self.temporary.name) / "old-main"
old_target.mkdir()
sentinel = old_target / "keep.txt"
sentinel.write_text("keep", encoding="utf-8")
(project / "main").symlink_to(old_target, target_is_directory=True)
self.publish("version", "test", "coverage")
self.assertTrue(sentinel.is_file())
self.assertTrue((project / "main").is_dir())
self.assertFalse((project / "main").is_symlink())
def test_rejects_invalid_roots_names_duplicates_and_sources(self):
bad_calls = (
["relative", "Ravenous", "ravenous_roll20", "main", "version"],
[str(self.root), "Ravenous", "ravenous_roll20", "main", "other"],
[str(self.root), "Ravenous", "ravenous_roll20", "main", "test", "test"],
)
for arguments in bad_calls:
with self.subTest(arguments=arguments):
result = subprocess.run(
[str(PUBLISHER), *arguments],
cwd=self.workspace,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
self.assertNotEqual(0, result.returncode)
source = self.workspace / "coverage/version.svg"
source.unlink()
source.symlink_to(self.workspace / "coverage/test.svg")
self.assertNotEqual(0, self.publish("version", check=False).returncode)
source.unlink()
subprocess.run(
[str(RENDERER), "version", "--output", "coverage/version.svg"],
cwd=self.workspace,
check=True,
)
outside_owner = Path(self.temporary.name) / "outside-owner"
outside_owner.mkdir()
(self.root / "Ravenous").symlink_to(outside_owner, target_is_directory=True)
self.assertNotEqual(0, self.publish("version", check=False).returncode)
(self.root / "Ravenous").unlink()
symlink_root = Path(self.temporary.name) / "root-link"
symlink_root.symlink_to(self.root, target_is_directory=True)
result = subprocess.run(
[str(PUBLISHER), str(symlink_root), "Ravenous", "ravenous_roll20", "main", "test"],
cwd=self.workspace,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
self.assertNotEqual(0, result.returncode)
if __name__ == "__main__":
unittest.main()