Skip to content
Merged
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
262 changes: 262 additions & 0 deletions tests/test_desktop_contract.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,262 @@
"""The desktop contract gates must fail closed on a broken contract.

scripts/verify-desktop-contract.py and scripts/verify-gnome-extensions.py both
gate the build -- the first from `just check` (--check) and from the
Containerfile against a composed image, the second from the GNOME extension
contract -- but neither had any unit coverage, so a gate that silently stopped
rejecting anything would still report success.
"""

import importlib.util
import json
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch

ROOT = Path(__file__).resolve().parents[1]


def load(name):
spec = importlib.util.spec_from_file_location(name, ROOT / "scripts" / f"{name}.py")
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module


desktop = load("verify-desktop-contract")
extensions = load("verify-gnome-extensions")

VALID_CONTRACT = {
"branding": {"files": ["/usr/share/ublue-os/x.png"]},
"configuration": {"files": []},
"flatpak": {
"files": [],
"apps": ["org.gnome.Calculator", "org.mozilla.firefox"],
"brewfile": "/usr/share/ublue-os/firstboot/Brewfile",
},
"services": {"enabled": ["gdm.service"]},
}


def contract(**overrides):
merged = {key: dict(value) for key, value in VALID_CONTRACT.items()}
for key, value in overrides.items():
if value is None:
merged.pop(key, None)
else:
merged[key] = value
return merged


class ValidateContractTests(unittest.TestCase):
def test_valid_contract_has_no_errors(self):
self.assertEqual(desktop.validate_contract(contract()), [])

def test_shipped_contract_is_valid(self):
import tomllib

data = tomllib.loads((ROOT / "contracts/bluefin-desktop.toml").read_text())
self.assertEqual(desktop.validate_contract(data), [])

def test_every_missing_section_is_named(self):
errors = desktop.validate_contract({})
for section in ("branding", "configuration", "flatpak", "services"):
self.assertIn(f"missing [{section}] section", errors)

def test_relative_contract_files_are_rejected(self):
errors = desktop.validate_contract(
contract(branding={"files": ["usr/share/relative.png"]})
)
self.assertIn("branding file must be absolute: usr/share/relative.png", errors)

def test_empty_flatpak_app_list_is_rejected(self):
flatpak = dict(VALID_CONTRACT["flatpak"], apps=[])
self.assertIn(
"Flatpak app contract must not be empty",
desktop.validate_contract(contract(flatpak=flatpak)),
)

def test_duplicate_flatpak_ids_are_rejected(self):
flatpak = dict(VALID_CONTRACT["flatpak"], apps=["org.gnome.Calculator"] * 2)
self.assertIn(
"Flatpak app contract contains duplicate IDs",
desktop.validate_contract(contract(flatpak=flatpak)),
)

def test_relative_brewfile_is_rejected(self):
flatpak = dict(VALID_CONTRACT["flatpak"], brewfile="firstboot/Brewfile")
self.assertIn(
"Flatpak Brewfile path must be absolute",
desktop.validate_contract(contract(flatpak=flatpak)),
)


class ReadOsReleaseTests(unittest.TestCase):
def read(self, text):
with tempfile.TemporaryDirectory() as tmp:
path = Path(tmp) / "os-release"
path.write_text(text)
return desktop.read_os_release(path)

def test_quotes_and_comments_and_blank_lines(self):
values = self.read('# comment\nID=utah\nNAME="Utah"\n\nPRETTY_NAME="Utah (Version: 1)"\n')
self.assertEqual(values["ID"], "utah")
self.assertEqual(values["NAME"], "Utah")
self.assertEqual(values["PRETTY_NAME"], "Utah (Version: 1)")
self.assertNotIn("# comment", values)

def test_value_containing_equals_is_kept_whole(self):
self.assertEqual(self.read("CPE_NAME=cpe:/o:ub:utah=1\n")["CPE_NAME"], "cpe:/o:ub:utah=1")


class VerifyValuesTests(unittest.TestCase):
def test_exact_mismatch_names_expected_and_actual(self):
errors = desktop.verify_values("os-release", {"ID": "fedora"}, {"ID": "utah"}, {})
self.assertEqual(errors, ["os-release ID must be 'utah', got 'fedora'"])

def test_missing_key_is_reported_not_skipped(self):
self.assertEqual(
desktop.verify_values("os-release", {}, {"ID": "utah"}, {}),
["os-release ID must be 'utah', got None"],
)

def test_pattern_must_match_the_whole_value(self):
patterns = {"VARIANT_ID": r"utah(-.*)?"}
self.assertEqual(desktop.verify_values("x", {"VARIANT_ID": "utah-nvidia"}, {}, patterns), [])
self.assertEqual(len(desktop.verify_values("x", {"VARIANT_ID": "notutah"}, {}, patterns)), 1)

def test_missing_key_fails_a_pattern(self):
self.assertEqual(len(desktop.verify_values("x", {}, {}, {"BUILD_ID": r".+"})), 1)

def test_non_string_value_is_compared_as_text_for_patterns(self):
self.assertEqual(desktop.verify_values("x", {"n": 51}, {}, {"n": r"\d+"}), [])


class ParseBrewfileTests(unittest.TestCase):
def parse(self, text):
with tempfile.TemporaryDirectory() as tmp:
path = Path(tmp) / "Brewfile"
path.write_text(text)
return desktop.parse_brewfile(path)

def test_order_is_preserved_and_non_flatpak_lines_ignored(self):
apps = self.parse(
'# comment\nbrew "gh"\nflatpak "org.gnome.Calculator"\nflatpak "org.mozilla.firefox"\n'
)
self.assertEqual(apps, ["org.gnome.Calculator", "org.mozilla.firefox"])

def test_indented_entries_are_accepted(self):
self.assertEqual(self.parse(' flatpak "org.gnome.Loupe"\n'), ["org.gnome.Loupe"])

def test_trailing_arguments_are_not_treated_as_an_app(self):
self.assertEqual(self.parse('flatpak "org.gnome.Loupe", args: "x"\n'), [])


class UnitEnabledTests(unittest.TestCase):
def run_with(self, returncode, stdout):
result = type("R", (), {"returncode": returncode, "stdout": stdout})()
with patch.object(desktop.subprocess, "run", return_value=result) as runner:
enabled = desktop.unit_enabled("gdm.service")
runner.assert_called_once()
self.assertEqual(runner.call_args[0][0], ["systemctl", "is-enabled", "gdm.service"])
return enabled

def test_enabled_and_enabled_runtime_pass(self):
self.assertTrue(self.run_with(0, "enabled\n"))
self.assertTrue(self.run_with(0, "enabled-runtime\n"))

def test_static_and_masked_and_nonzero_exit_fail(self):
self.assertFalse(self.run_with(0, "static\n"))
self.assertFalse(self.run_with(1, "masked\n"))
self.assertFalse(self.run_with(1, "enabled\n"))


class CheckModeTests(unittest.TestCase):
def run_check(self, text):
with tempfile.TemporaryDirectory() as tmp:
path = Path(tmp) / "contract.toml"
path.write_text(text)
with patch.object(desktop.sys, "argv", ["verify", "--check", str(path)]):
return desktop.main()

def test_check_accepts_the_shipped_contract(self):
with patch.object(
desktop.sys, "argv", ["verify", "--check", str(ROOT / "contracts/bluefin-desktop.toml")]
):
self.assertEqual(desktop.main(), 0)

def test_check_rejects_a_contract_missing_sections(self):
self.assertEqual(self.run_check('[branding]\nfiles = []\n'), 1)

def test_check_does_not_touch_the_image_filesystem(self):
with patch.object(desktop, "read_os_release") as reader, patch.object(
desktop, "unit_enabled"
) as unit:
with patch.object(
desktop.sys,
"argv",
["verify", "--check", str(ROOT / "contracts/bluefin-desktop.toml")],
):
self.assertEqual(desktop.main(), 0)
reader.assert_not_called()
unit.assert_not_called()


class GnomeExtensionTests(unittest.TestCase):
def shipped_tree(self, tmp, versions="51", uuids=None):
base = Path(tmp) / "usr/share/gnome-shell/extensions"
for uuid in uuids if uuids is not None else extensions.SOURCE_EXTENSIONS:
path = base / uuid / "metadata.json"
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(json.dumps({"shell-version": [versions]}))
return Path(tmp)

def run_main(self, root):
with patch.object(extensions.sys, "argv", ["verify", "--root", str(root)]):
return extensions.main()

def test_complete_tree_declaring_gnome_51_passes(self):
with tempfile.TemporaryDirectory() as tmp:
self.assertEqual(self.run_main(self.shipped_tree(tmp)), 0)

def test_missing_extension_fails(self):
with tempfile.TemporaryDirectory() as tmp:
uuids = list(extensions.SOURCE_EXTENSIONS)[1:]
self.assertEqual(self.run_main(self.shipped_tree(tmp, uuids=uuids)), 1)

def test_extension_without_gnome_51_fails(self):
with tempfile.TemporaryDirectory() as tmp:
self.assertEqual(self.run_main(self.shipped_tree(tmp, versions="50")), 1)

def test_invalid_metadata_fails_instead_of_raising(self):
with tempfile.TemporaryDirectory() as tmp:
root = self.shipped_tree(tmp)
uuid = next(iter(extensions.SOURCE_EXTENSIONS))
(root / f"usr/share/gnome-shell/extensions/{uuid}/metadata.json").write_text("{")
self.assertEqual(self.run_main(root), 1)

def test_shell_versions_rejects_metadata_without_the_key(self):
with tempfile.TemporaryDirectory() as tmp:
path = Path(tmp) / "metadata.json"
path.write_text(json.dumps({"name": "x"}))
with self.assertRaises(ValueError):
extensions.shell_versions(path)

def test_shell_versions_substitutes_the_gsconnect_version_placeholder(self):
with tempfile.TemporaryDirectory() as tmp:
path = Path(tmp) / "metadata.json.in"
path.write_text('{"version": @PACKAGE_VERSION@, "shell-version": ["51"]}')
self.assertEqual(extensions.shell_versions(path), ["51"])

def test_source_mode_matches_the_checked_in_submodule_paths(self):
for uuid, relative in extensions.SOURCE_EXTENSIONS.items():
self.assertTrue(
relative == uuid + "/metadata.json" or relative.endswith("metadata.json")
or relative.endswith("metadata.json.in"),
f"{uuid} source path does not point at extension metadata: {relative}",
)


if __name__ == "__main__":
unittest.main()
Loading