Files
caubet_m ef9974b738 Multiple updates:
- Add % usage for NH and storage
- Make storage information hidden by default
- Hide team status by default
- Minor improvements
2026-10-12 11:25:18 +02:00

287 lines
14 KiB
Python

"""Offline regression tests. Do not contact CSCS or require credentials."""
import contextlib
import csv
import importlib.util
import io
import json
import pathlib
import sys
import types
import unittest
from unittest.mock import patch
import requests
ROOT = pathlib.Path(__file__).resolve().parents[1]
def load_module(name, path):
spec = importlib.util.spec_from_file_location(name, path)
module = importlib.util.module_from_spec(spec)
sys.modules[name] = module
spec.loader.exec_module(module)
return module
# Domain/reporting tests must not import Playwright/keyring.
pkg = types.ModuleType("cscs_portal")
pkg.__path__ = [str(ROOT / "cscs_portal")]
sys.modules["cscs_portal"] = pkg
team = load_module("cscs_portal.team", ROOT / "cscs_portal/team.py")
project = load_module("cscs_portal.project", ROOT / "cscs_portal/project.py")
output = load_module("cscs_portal.output", ROOT / "cscs_portal/output.py")
class FakeResponse:
def __init__(self, data):
self.data = data
def json(self):
return self.data
class FakeClient:
def get(self, path, params=None):
params = params or {}
if path == "/api/projects/":
return FakeResponse([{
"name": "psi01", "uuid": "79ee170eac274206ad5281ce31898391",
"customer_name": "Paul Scherrer Institute, PSI",
"start_date": "2016-10-04", "end_date": "2027-04-30",
}])
if path.endswith("/list_users/"):
return FakeResponse([
{"role_name": "PROJECT.MANAGER", "user_email": "pi@example.org",
"user_username": "principal", "user_full_name": "Principal User", "user_uuid": "1"},
{"role_name": "PROJECT.DEPUTY", "user_email": "b@example.org",
"user_username": "deputy_b", "user_full_name": "Deputy B", "user_uuid": "2"},
{"role_name": "PROJECT.DEPUTY", "user_email": "c@example.org",
"user_username": "deputy_c", "user_full_name": "Deputy C", "user_uuid": "3"},
{"role_name": "PROJECT.MEMBER", "user_email": "d@example.org",
"user_username": "member_d", "user_full_name": "Member D", "user_uuid": "4"},
{"role_name": "PROJECT.OBSERVER", "user_email": "observer@example.org",
"user_username": "view_only", "user_full_name": "Observer", "user_uuid": "5"},
{"role_name": "PROJECT.DEPUTY", "user_email": "b@example.org",
"user_username": "deputy_b", "user_full_name": "Deputy B", "user_uuid": "2"},
])
if path.endswith("/components-usage/"):
return FakeResponse({"components": [
{"offering_name": "alps-eiger-q", "offering_uuid": "compute-offering",
"name": "Compute", "type": "compute", "measured_unit": "node hours",
"limit": 11000, "usage": 70, "limit_usage": 70, "limit_period": "quarterly"},
{"offering_name": "CAPSTOR", "offering_uuid": "storage-offering",
"name": "Inodes usage", "type": "inodes", "measured_unit": None,
"limit": None, "usage": 12612, "limit_period": "monthly"},
{"offering_name": "CAPSTOR", "offering_uuid": "storage-offering",
"name": "Storage", "type": "storage", "measured_unit": "TB",
"limit": 10, "usage": 5.99, "limit_period": "monthly"},
]})
if path.endswith("/components-usage-timeseries/"):
assert params["period_offset"] == -1
return FakeResponse({
"offering_name": "alps-eiger-q", "type": "compute", "name": "Compute",
"limit": 10000, "measured_unit": "node hours", "limit_period": "quarterly",
"current_period_start": "2026-07-01", "current_period_end": "2026-09-30",
"current_period_label": "2026-Q3",
})
if path == "/api/marketplace-component-usages/":
month = int(params["billing_period_month"])
offering = params["offering_uuid"]
kind = params["type"]
if offering == "compute-offering":
usage = {7: 6286.74, 8: 123.49, 9: 3594.07}[month]
elif kind == "storage":
usage = 5.92
else:
usage = 12612
return FakeResponse({"results": [{"usage": usage}], "next": None})
raise AssertionError(f"Unexpected fake request: {path}, {params}")
class ReportingTests(unittest.TestCase):
def setUp(self):
quarter_patch = patch.object(project, "current_quarter", return_value=(2026, 4))
quarter_patch.start()
self.addCleanup(quarter_patch.stop)
self.data = project.get_project_info(FakeClient(), "psi01", 2026, 3)
def parse_csv(self, options=None, projects=None, *, include_storage=False, show_team_status=False):
buf = io.StringIO()
output.print_csv(
projects or [self.data], stream=buf, team_selection=options,
include_storage=include_storage, show_team_status=show_team_status,
)
return buf.getvalue(), list(csv.DictReader(io.StringIO(buf.getvalue()), delimiter=":"))
def test_historical_nh_storage(self):
compute = self.data["compute"][0]
self.assertEqual(compute["unit"], "NH")
self.assertEqual(compute["allocation"], 10000)
self.assertAlmostEqual(compute["used"], 10004.30)
self.assertAlmostEqual(compute["remaining"], -4.30)
self.assertEqual(self.data["components"][0]["measured_unit"], "NH")
capacity = next(s for s in self.data["storage"] if s["component"] == "Storage")
self.assertEqual(capacity["unit"], "TB")
self.assertEqual(capacity["usage_snapshot"], "2026-09-01")
self.assertEqual(capacity["used"], 5.92)
def test_role_mapping_matches_cscs_observations(self):
self.assertEqual(team.role_label("PROJECT.MANAGER"), "PI")
self.assertEqual(team.role_label("PROJECT.ADMIN"), "PI")
self.assertEqual(team.role_label("PROJECT.DEPUTY"), "Deputy PI")
self.assertEqual(team.role_label("PROJECT.MEMBER"), "Project Member")
self.assertEqual(team.role_label("PROJECT.OBSERVER"), "PROJECT.OBSERVER")
self.assertEqual(self.data["team"]["PI"][0]["username"], "principal")
self.assertEqual(len(self.data["team"]["Deputy PI"]), 2)
self.assertEqual(team.roles_for_projects([self.data]), [
"PI", "Deputy PI", "Project Member", "PROJECT.OBSERVER"
])
def test_default_pi_only_csv_colon(self):
content, rows = self.parse_csv()
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0]["project"], "psi01")
self.assertEqual(rows[0]["organisation"], "Paul Scherrer Institute, PSI")
self.assertEqual(rows[0]["nh_unit"], "NH")
self.assertEqual(rows[0]["nh_allocated"], "10000")
self.assertEqual(rows[0]["nh_used"], "10004.3")
self.assertEqual(rows[0]["PI UIDs"], "principal")
self.assertEqual(rows[0]["PI names"], "Principal User")
self.assertEqual(rows[0]["PI emails"], "pi@example.org")
self.assertNotIn("Deputy PI emails", rows[0])
self.assertNotIn("Project Member UIDs", rows[0])
self.assertNotIn("PROJECT.OBSERVER emails", rows[0])
self.assertIn("project:uuid:organisation:", content)
self.assertNotIn("node hours", content)
def test_selected_deputies_and_members_independently(self):
_, rows = self.parse_csv(team.TeamSelection(deputy_pi=True))
self.assertEqual(rows[0]["Deputy PI emails"], "b@example.org, c@example.org")
self.assertEqual(rows[0]["Deputy PI UIDs"], "deputy_b, deputy_c")
self.assertEqual(rows[0]["Deputy PI names"], "Deputy B, Deputy C")
self.assertNotIn("Project Member emails", rows[0])
_, rows = self.parse_csv(team.TeamSelection(member_uids=True))
self.assertEqual(rows[0]["Project Member UIDs"], "member_d")
self.assertNotIn("Project Member emails", rows[0])
_, rows = self.parse_csv(team.TeamSelection(member_emails=True))
self.assertEqual(rows[0]["Project Member emails"], "d@example.org")
self.assertNotIn("Project Member UIDs", rows[0])
_, rows = self.parse_csv(team.TeamSelection(member_uids=True, member_emails=True))
self.assertEqual(rows[0]["Project Member UIDs"], "member_d")
self.assertEqual(rows[0]["Project Member emails"], "d@example.org")
def test_all_team_includes_dynamic_role_columns(self):
extra = dict(self.data)
extra["name"] = "another-project"
extra["team"] = {
"PROJECT.DATA_STEWARD": [{
"email": "steward@example.org", "username": "steward"}],
}
content, rows = self.parse_csv(team.TeamSelection(all_team=True), [self.data, extra])
self.assertEqual(len(rows), 2)
self.assertIn("PROJECT.OBSERVER emails", rows[0])
self.assertIn("PROJECT.DATA_STEWARD UIDs", rows[0])
self.assertEqual(rows[0]["PROJECT.DATA_STEWARD emails"], "")
self.assertEqual(rows[1]["PROJECT.DATA_STEWARD emails"], "steward@example.org")
self.assertEqual(rows[0]["Deputy PI emails"], "b@example.org, c@example.org")
self.assertIn("b@example.org, c@example.org", content)
def test_colon_contained_inside_one_quoted_csv_cell(self):
original = dict(self.data)
original["organisation"] = "Research: HPC, PSI"
content, rows = self.parse_csv(projects=[original])
self.assertEqual(rows[0]["organisation"], "Research: HPC, PSI")
self.assertIn('"Research: HPC, PSI"', content)
def test_detail_table_default_and_options(self):
for render in (
lambda: output.print_project(self.data),
lambda: output.print_table([self.data]),
):
buf = io.StringIO()
with contextlib.redirect_stdout(buf):
render()
content = buf.getvalue()
self.assertIn("PI", content)
self.assertIn("pi@example.org", content)
self.assertNotIn("Deputy PI", content)
self.assertNotIn("d@example.org", content)
self.assertIn("NH", content)
self.assertNotIn("node hours", content)
opts = team.TeamSelection(deputy_pi=True, member_uids=True)
buf = io.StringIO()
with contextlib.redirect_stdout(buf):
output.print_project(self.data, team_selection=opts)
self.assertIn("Deputy PI:", buf.getvalue())
self.assertIn("Project Member UIDs:", buf.getvalue())
self.assertNotIn("Project Member emails:", buf.getvalue())
def test_json_respects_selected_fields(self):
payload = team.selected_team_json(self.data, team.TeamSelection())
self.assertEqual(set(payload["team"]), {"PI"})
self.assertEqual(payload["team"]["PI"][0]["full_name"], "Principal User")
partial = team.selected_team_json(self.data, team.TeamSelection(member_uids=True))
self.assertEqual(partial["team"]["Project Member"], [{"username": "member_d"}])
self.assertNotIn('node hours', json.dumps(partial))
all_roles = team.selected_team_json(self.data, team.TeamSelection(all_team=True))
self.assertIn("PROJECT.OBSERVER", all_roles["team"])
def test_no_team_and_inaccessible_team(self):
without_team = project.get_project_info(FakeClient(), "psi01", 2026, 3, include_team=False)
self.assertNotIn("team", without_team)
_, rows = self.parse_csv(team.TeamSelection(enabled=False), [without_team])
self.assertNotIn("PI emails", rows[0])
self.assertNotIn("team_status", rows[0])
class ForbiddenClient(FakeClient):
def get(self, path, params=None):
if path.endswith("/list_users/"):
response = requests.Response()
response.status_code = 403
raise requests.HTTPError("Forbidden", response=response)
return super().get(path, params=params)
unavailable = project.get_project_info(ForbiddenClient(), "psi01", 2026, 3)
self.assertEqual(unavailable["team_status"], "unavailable")
self.assertIn("403", unavailable["team_error"])
def test_missing_email_is_not_invented(self):
groups = team.group_members_by_role([{
"role_name": "PROJECT.MEMBER", "user_username": "no_email",
}])
self.assertEqual(team.member_values(groups["Project Member"], "email"), "")
self.assertEqual(team.member_values(groups["Project Member"], "username"), "no_email")
def test_identity_dedup_across_roles(self):
raw = [
{"role_name": "PROJECT.ADMIN", "user_uuid": "same", "user_email": "a@example.org"},
{"role_name": "PROJECT.MANAGER", "user_uuid": "same", "user_email": "a@example.org"},
{"role_name": "PROJECT.DEPUTY", "user_uuid": "same", "user_email": "a@example.org"},
]
groups = team.group_members_by_role(raw)
self.assertEqual(len(groups["PI"]), 1)
self.assertEqual(len(groups["Deputy PI"]), 1)
def test_team_pagination(self):
class PaginatedClient:
def get(self, path, params=None):
if params["page"] == 1:
return FakeResponse({"results": [
{"role_name": "PROJECT.MANAGER", "user_email": "a@example.org"}
], "next": "https://portal.cscs.ch/api/?page=2"})
return FakeResponse({"results": [
{"role_name": "PROJECT.MEMBER", "user_email": "b@example.org"}
], "next": None})
self.assertEqual(len(team.get_project_members(PaginatedClient(), "fake")), 2)
def test_quarter_offsets(self):
self.assertEqual(project.quarter_offset(2026, 4), 0)
self.assertEqual(project.quarter_offset(2026, 3), -1)
self.assertEqual(project.quarter_offset(2026, 2), -2)
if __name__ == "__main__":
unittest.main()