- Add % usage for NH and storage - Make storage information hidden by default - Hide team status by default - Minor improvements
287 lines
14 KiB
Python
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()
|