200 lines
7.8 KiB
Python
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<&"", text)
|
|
self.assertIn("v1<&"", 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()
|