339 lines
25 KiB
Python
339 lines
25 KiB
Python
from __future__ import annotations
|
||||
|
|
|
|||
|
|
import json
|
|||
|
|
import math
|
|||
|
|
import os
|
|||
|
|
import shutil
|
|||
|
|
import sys
|
|||
|
|
import time
|
|||
|
|
import unittest
|
|||
|
|
from pathlib import Path
|
|||
|
|
|
|||
|
|
HERE = Path(__file__).resolve().parent
|
|||
|
|
sys.path[:0] = [str(HERE.parent), str(HERE)]
|
|||
|
|
|
|||
|
|
import hub_e2e_kit as base
|
|||
|
|
from hub_e2e_kit import GRAPH_HOOK, OUT, WIDTHS
|
|||
|
|
from hub_e2e_plan import (
|
|||
|
|
BULK,
|
|||
|
|
BURN,
|
|||
|
|
ETA_LIST,
|
|||
|
|
GANTT,
|
|||
|
|
PLAN_VALUES,
|
|||
|
|
POINTS_ON,
|
|||
|
|
REQUEST,
|
|||
|
|
STATUS_ORDER,
|
|||
|
|
STEP_TIPS,
|
|||
|
|
TASKS_3D,
|
|||
|
|
TREND_DAYS,
|
|||
|
|
TREND_RELOADED,
|
|||
|
|
TREND_SET,
|
|||
|
|
)
|
|||
|
|
from hub_e2e_views import CAMERA
|
|||
|
|
from hub_support import iso
|
|||
|
|
from kvb_orchestrator import skill_scripts
|
|||
|
|
|
|||
|
|
|
|||
|
|
@unittest.skipUnless(shutil.which(os.environ.get("CHROMIUM", "chromium")), "no Chromium")
|
|||
|
|
class TestHubPlan(base.OrchestratorE2ECase):
|
|||
|
|
def plan_work(self, now: float) -> None:
|
|||
|
|
register = json.loads((self.council / "rasci.json").read_text(encoding="utf-8"))
|
|||
|
|
register["work/feature"]["start"] = iso(now - 1800)
|
|||
|
|
register["work/stage"]["start"] = iso(now - 900)
|
|||
|
|
register.update({
|
|||
|
|
"work/done-a": {"title": "Done A", "status": "done", "worker": "Stage", "branch": "feature/base", "start": iso(now - 36000), "end": iso(now - 28800), "roles": {"Stage": "RA"}, "estimates": {"Stage": {"value": 5, "complexity": 2}}},
|
|||
|
|
"work/done-b": {"title": "Done B", "status": "done", "worker": "Docs", "start": iso(now - 25200), "end": iso(now - 10800), "roles": {"Docs": "RA"}, "estimates": {"Docs": {"value": 3, "complexity": 2}}},
|
|||
|
|
"work/done-c": {"title": "Done C", "status": "done", "worker": "Docs", "start": iso(now - 14400), "end": iso(now - 10800), "roles": {"Docs": "RA"}},
|
|||
|
|
"work/next": {"title": "Next step", "status": "queued", "after": ["work/feature"], "roles": {"Skills": "R", "Maintainer": "A"}, "estimates": {"Skills": {"value": 8, "complexity": 3}}},
|
|||
|
|
"work/child": {"title": "Child of the base", "status": "queued", "base": "feature/base", "roles": {"Docs": "RA"}},
|
|||
|
|
})
|
|||
|
|
queue = json.loads((self.council / "queue.json").read_text(encoding="utf-8"))
|
|||
|
|
queue["entries"] += [
|
|||
|
|
{"id": "deploy-4", "seq": 4, "kind": "deploy", "task": "work/stage", "workdir": "/repo", "session": "s2", "name": "Stage", "hotfix": None, "status": "active", "enqueued": now - 400, "granted": now - 300, "cmd": "make deploy"},
|
|||
|
|
{"id": "test-5", "seq": 5, "kind": "test", "task": "work/docs", "workdir": "/repo", "session": "s2", "name": "Docs", "hotfix": None, "status": "waiting", "enqueued": now - 60, "granted": None, "cmd": "make test"},
|
|||
|
|
]
|
|||
|
|
self.write_council({"rasci.json": register, "queue.json": queue})
|
|||
|
|
|
|||
|
|
def plan_steps(self, browser: str, signs: bool) -> list[dict]:
|
|||
|
|
local = f"http://localhost:{self.port}/"
|
|||
|
|
flag = "true" if signs else "false"
|
|||
|
|
steps = []
|
|||
|
|
for width, height in WIDTHS:
|
|||
|
|
bulk = BULK.replace("@SIGNS@", flag).replace("@VALUE@", PLAN_VALUES[width])
|
|||
|
|
steps += [
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}#tasks/gantt", "wait": 1200, "probe": GANTT, "shot": str(OUT / f"{browser}-{width}-tasks-gantt.png")},
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}#tasks/burn", "wait": 900, "probe": BURN, "shot": str(OUT / f"{browser}-{width}-tasks-burn.png")},
|
|||
|
|
{"width": width, "height": height, "url": None, "wait": 0, "probe": POINTS_ON, "shot": None},
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}-reloaded#tasks/burn", "wait": 1200, "probe": REQUEST, "shot": str(OUT / f"{browser}-{width}-tasks-burn-points.png")},
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}-points#tasks/gantt", "wait": 1200, "probe": GANTT, "shot": str(OUT / f"{browser}-{width}-tasks-gantt-points.png")},
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}-list#tasks/list", "wait": 1200, "probe": bulk, "shot": str(OUT / f"{browser}-{width}-tasks-business-value.png")},
|
|||
|
|
]
|
|||
|
|
return steps
|
|||
|
|
|
|||
|
|
def planned(self, probe: dict, points: bool) -> None:
|
|||
|
|
hour = 3600
|
|||
|
|
edges = [["after", "work/feature", "work/next"], ["base", "work/done-a", "work/child"], ["queue", "queue/deploy-4", "queue/gate-3"], ["queue", "queue/gate-3", "queue/test-5"]]
|
|||
|
|
self.assertEqual(probe["forecast"], ["always", [["always", "always"], ["points", "points only"], ["real", "real only"]]])
|
|||
|
|
self.assertEqual(probe["modes"], [["none", str(not points).lower()], ["points", str(points).lower()]])
|
|||
|
|
self.assertEqual((probe["request"], probe["inner"]), (points, True))
|
|||
|
|
self.assertEqual(sorted([kind, start, end] for kind, start, end, _ in probe["edges"]), sorted(edges))
|
|||
|
|
self.assertEqual({tip for *_, tip in probe["edges"]}, {"url(#gantt-tip)"})
|
|||
|
|
bars = {task: (forecast, start, end, tag) for task, forecast, start, end, tag in probe["bars"]}
|
|||
|
|
self.assertNotIn("operator/push", bars)
|
|||
|
|
self.assertEqual((bars["work/old"][0], bars["work/old"][3]), (False, "circle"))
|
|||
|
|
self.assertEqual([bars[task][0] for task in ("work/feature", "work/stage", "queue/deploy-4", "work/done-a")], [False] * 4)
|
|||
|
|
self.assertGreaterEqual(bars["work/feature"][2] - bars["work/feature"][1], 1800)
|
|||
|
|
forecasts = ("work/next", "work/docs", "work/child", "queue/gate-3", "queue/test-5")
|
|||
|
|
lengths = {task: round(bars[task][2] - bars[task][1], 3) for task in forecasts}
|
|||
|
|
self.assertEqual(lengths, {"work/next": (4.5 if points else 2) * hour, "work/docs": (3 if points else 2) * hour, "work/child": 2 * hour, "queue/gate-3": 2 * hour, "queue/test-5": 2 * hour})
|
|||
|
|
self.assertTrue(all(bars[task][0] for task in forecasts))
|
|||
|
|
self.assertEqual((bars["work/next"][1], bars["queue/test-5"][1]), (bars["work/feature"][2], bars["queue/gate-3"][2]))
|
|||
|
|
self.assertTrue(probe["hatched"] and all(probe["hatched"]), probe["hatched"])
|
|||
|
|
self.assertEqual(probe["real"], 0)
|
|||
|
|
only = {task: (round(length, 3), tag) for task, length, tag in probe["pointsOnly"]}
|
|||
|
|
dot = (0, "circle")
|
|||
|
|
self.assertEqual(only, {"work/next": (4.5 * hour, "rect") if points else dot, "work/docs": (3 * hour, "rect") if points else dot, "work/child": dot, "queue/gate-3": dot, "queue/test-5": dot})
|
|||
|
|
|
|||
|
|
def check_plan(self, browser: str, driver: str, binary: str, signs: bool) -> None:
|
|||
|
|
"""Args:
|
|||
|
|
signs: cdp.mjs signs the bulk business value with its virtual
|
|||
|
|
passkey; bidi.mjs has no virtual authenticator, so the probe
|
|||
|
|
answers the prompt the way a canceled passkey dialog does.
|
|||
|
|
"""
|
|||
|
|
self.plan_work(time.time())
|
|||
|
|
authenticator = self.authenticator()
|
|||
|
|
data = self.drive(self.plan_steps(browser, signs), authenticator if signs else None, driver, binary)
|
|||
|
|
(OUT / f"{browser}-plan.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
|
|||
|
|
self.assertEqual([error for error in data["errors"] if "(style-src-elem)" not in error and "/favicon.ico" not in error], [])
|
|||
|
|
rows = self.snapshot()["tasks"]
|
|||
|
|
ranked = list(enumerate(rows))
|
|||
|
|
status_up = [row["task"] for _, row in sorted(ranked, key=lambda pair: (STATUS_ORDER.index(pair[1]["status"]), pair[0]))]
|
|||
|
|
status_down = [row["task"] for _, row in sorted(ranked, key=lambda pair: (-STATUS_ORDER.index(pair[1]["status"]), pair[0]))]
|
|||
|
|
for index, (width, _) in enumerate(WIDTHS):
|
|||
|
|
gantt, burn, points_on, request, gantt_points, bulk = data["results"][6 * index : 6 * (index + 1)]
|
|||
|
|
value = PLAN_VALUES[width]
|
|||
|
|
items = [["work/next", f"estimate work/next Operator --value {value}"], ["work/child", f"estimate work/child Operator --value {value}"]]
|
|||
|
|
with self.subTest(browser=browser, width=width):
|
|||
|
|
for probe in (gantt, burn, points_on, request, gantt_points, bulk):
|
|||
|
|
self.assertNotIn("error", probe)
|
|||
|
|
self.assertEqual((probe["tall"], probe["wide"], probe["layout"]), (False, False, ["toolbar", "chips", "body"]), probe)
|
|||
|
|
self.assertEqual(probe["rows"] == 1, width != 390, probe)
|
|||
|
|
self.planned(gantt, points=False)
|
|||
|
|
self.planned(gantt_points, points=True)
|
|||
|
|
self.assertEqual((burn["modes"], burn["request"]), ([["none", "true"], ["points", "false"]], False))
|
|||
|
|
self.assertEqual(burn["scope"][0], "all")
|
|||
|
|
self.assertEqual(burn["scope"][1][:2], ["all", "filter"])
|
|||
|
|
self.assertIn("agent:Docs", burn["scope"][1])
|
|||
|
|
self.assertIn("line:identity/oidc", burn["scope"][1])
|
|||
|
|
self.assertEqual(burn["series"], [["scope", 9], ["done", 4], ["remaining", 5]])
|
|||
|
|
self.assertEqual(burn["agent"], [["scope", 5], ["done", 2], ["remaining", 3]])
|
|||
|
|
self.assertEqual(points_on["before"], {"modes": [["none", "true"], ["points", "false"]], "request": False})
|
|||
|
|
self.assertEqual((points_on["modes"], points_on["request"]), ([["none", "false"], ["points", "true"]], True))
|
|||
|
|
self.assertEqual(request["modes"], [["none", "false"], ["points", "true"]])
|
|||
|
|
self.assertEqual(request["series"], [["scope", 12], ["done", 4], ["remaining", 8], ["unestimated", 2]])
|
|||
|
|
self.assertTrue(request["toast"].startswith(f"Request estimates: {'done' if signs else 'not signed'}"), request["toast"])
|
|||
|
|
self.assertEqual(bulk["sorts"], ["prio", "wsjf", "value", "complexity", "status", "start", "end", "agent", "title"])
|
|||
|
|
self.assertEqual((bulk["prio"], bulk["status"], bulk["statusDown"]), ([row["task"] for row in rows], status_up, [status_down, "Descending"]))
|
|||
|
|
self.assertEqual((bulk["picks"], bulk["armed"]), (["work/feature", "work/next", "work/docs", "work/child", "work/stage"], [False, "2"]))
|
|||
|
|
self.assertTrue(bulk["toast"].startswith(f"Business value {value} for 2 tasks: {'handed to the runner' if signs else 'not signed'}"), bulk["toast"])
|
|||
|
|
signed = [["/api/sign", ["items"], items]]
|
|||
|
|
self.assertEqual((bulk["asked"], bulk["posted"]), (1, [*signed, ["/api/tasks", ["items", "proof"], items]] if signs else signed))
|
|||
|
|
self.assertEqual((bulk["after"], bulk["reset"]), ([True, 0] if signs else [False, 2], True))
|
|||
|
|
self.assertEqual([args for script, args in self.scripts.calls if script == skill_scripts.ESTIMATE], [["request", "--session", "Operator"]] * (len(WIDTHS) if signs else 0))
|
|||
|
|
self.assertEqual(self.httpd.hub.settings.get()["estimation"], "none")
|
|||
|
|
jobs = self.runner_jobs()
|
|||
|
|
if not signs:
|
|||
|
|
self.assertEqual(jobs, [])
|
|||
|
|
register = json.loads((self.council / "rasci.json").read_text(encoding="utf-8"))
|
|||
|
|
self.assertEqual([task for task, row in register.items() if "Operator" in row.get("estimates", {})], [])
|
|||
|
|
return
|
|||
|
|
self.assertEqual([job["argv"][-1] for job in jobs], [PLAN_VALUES[width] for width, _ in WIDTHS for _ in range(2)])
|
|||
|
|
self.run_runner()
|
|||
|
|
register = json.loads((self.council / "rasci.json").read_text(encoding="utf-8"))
|
|||
|
|
self.assertEqual({task: register[task]["estimates"]["Operator"] for task in ("work/next", "work/child")}, {"work/next": {"value": 34, "at": register["work/next"]["estimates"]["Operator"]["at"]}, "work/child": {"value": 34, "at": register["work/child"]["estimates"]["Operator"]["at"]}})
|
|||
|
|
rows = {row["task"]: row for row in self.snapshot()["tasks"]}
|
|||
|
|
self.assertEqual((rows["work/next"]["wsjf"], rows["work/child"]["wsjf"], rows["work/child"]["value"]), ({"value": 34, "complexity": 3, "score": 11.33}, None, 34))
|
|||
|
|
|
|||
|
|
def test_chromium_draws_the_gantt_and_burn_switches_the_estimation_requests_estimates_and_signs_a_bulk_business_value_at_three_widths(self):
|
|||
|
|
self.check_plan("chromium", "cdp.mjs", os.environ.get("CHROMIUM", "chromium"), signs=True)
|
|||
|
|
|
|||
|
|
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
|
|||
|
|
def test_firefox_draws_the_gantt_and_burn_and_asks_the_passkey_for_a_bulk_business_value_storing_nothing_unsigned(self):
|
|||
|
|
self.check_plan("firefox", "bidi.mjs", os.environ.get("FIREFOX", "firefox"), signs=False)
|
|||
|
|
|
|||
|
|
def trend_work(self, now: float) -> None:
|
|||
|
|
day = 86400
|
|||
|
|
register = {
|
|||
|
|
"work/t1": {"title": "First", "status": "done", "worker": "Stage", "start": iso(now - 10 * day), "end": iso(now - 8 * day), "roles": {"Stage": "RA"}, "estimates": {"Stage": {"value": 5, "complexity": 1}}},
|
|||
|
|
"work/t2": {"title": "Second", "status": "done", "worker": "Docs", "start": iso(now - 10 * day), "end": iso(now - 6 * day), "roles": {"Docs": "RA"}, "estimates": {"Docs": {"value": 3, "complexity": 2}}},
|
|||
|
|
"work/t3": {"title": "Third", "status": "done", "worker": "Docs", "branch": "feature/t3", "start": iso(now - 10 * day), "end": iso(now - 4 * day), "roles": {"Docs": "RA"}, "estimates": {"Docs": {"value": 3, "complexity": 3}}},
|
|||
|
|
"work/t4": {"title": "Fourth", "status": "running", "worker": "Stage", "start": iso(now - day), "roles": {"Stage": "RA"}, "estimates": {"Stage": {"value": 8, "complexity": 5}}},
|
|||
|
|
"work/t5": {"title": "Fifth", "status": "queued", "after": ["work/t4"], "roles": {"Skills": "R"}, "estimates": {"Skills": {"value": 8, "complexity": 3}}},
|
|||
|
|
"work/t6": {"title": "Sixth", "status": "queued", "base": "feature/t3", "roles": {"Docs": "RA"}},
|
|||
|
|
}
|
|||
|
|
queue = {"seq": 2, "entries": [
|
|||
|
|
{"id": "deploy-1", "seq": 1, "kind": "deploy", "task": "work/t4", "workdir": "/repo", "session": "s2", "name": "Stage", "hotfix": None, "status": "active", "enqueued": now - 400, "granted": now - 300, "cmd": "make deploy"},
|
|||
|
|
{"id": "test-2", "seq": 2, "kind": "test", "task": "work/t5", "workdir": "/repo", "session": "s2", "name": "Docs", "hotfix": None, "status": "waiting", "enqueued": now - 60, "granted": None, "cmd": "make test"},
|
|||
|
|
]}
|
|||
|
|
self.write_council({"rasci.json": register, "queue.json": queue})
|
|||
|
|
|
|||
|
|
def trend_steps(self, browser: str) -> list[dict]:
|
|||
|
|
local = f"http://localhost:{self.port}/"
|
|||
|
|
steps = []
|
|||
|
|
for width, height in WIDTHS:
|
|||
|
|
days = str(TREND_DAYS[width])
|
|||
|
|
steps += [
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}#tasks/list", "wait": 1200, "probe": ETA_LIST, "shot": str(OUT / f"{browser}-{width}-tasks-eta.png")},
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}#tasks/burn", "wait": 900, "probe": TREND_SET.replace("@MODE@", "regression").replace("@DAYS@", days), "shot": str(OUT / f"{browser}-{width}-tasks-burn-regression.png")},
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}-regression#tasks/burn", "wait": 1200, "probe": TREND_RELOADED, "shot": None},
|
|||
|
|
{"width": width, "height": height, "url": None, "wait": 0, "probe": TREND_SET.replace("@MODE@", "velocity").replace("@DAYS@", days), "shot": str(OUT / f"{browser}-{width}-tasks-burn-velocity.png")},
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}-velocity#tasks/burn", "wait": 1200, "probe": TREND_RELOADED, "shot": None},
|
|||
|
|
{"width": width, "height": height, "url": None, "wait": 0, "probe": STEP_TIPS, "shot": str(OUT / f"{browser}-{width}-tasks-burn-steps.png")},
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}-3d#tasks/3d", "wait": 1200, "probe": TASKS_3D, "shot": str(OUT / f"{browser}-{width}-tasks-3d.png")},
|
|||
|
|
{"width": width, "height": height, "url": f"{local}?{width}-camera#tasks/3d", "wait": 900, "probe": CAMERA, "shot": str(OUT / f"{browser}-{width}-tasks-3d-steady-camera.png")},
|
|||
|
|
]
|
|||
|
|
return steps
|
|||
|
|
|
|||
|
|
def eta_checked(self, probe: dict, mode: str, rows: dict, edges: list[dict], window: tuple[float, float]) -> None:
|
|||
|
|
"""Args:
|
|||
|
|
probe: task -> [start, eta, forecast, text, title] as the list shows it.
|
|||
|
|
mode: the estimation mode the list was drawn in.
|
|||
|
|
rows: the snapshot's task rows by task.
|
|||
|
|
edges: the snapshot's task edges.
|
|||
|
|
window: the earliest and latest time the page can have taken as now.
|
|||
|
|
"""
|
|||
|
|
day = 86400
|
|||
|
|
points = {"none": {}, "points": {"work/t4": 10 * day, "work/t5": 6 * day}}[mode]
|
|||
|
|
self.assertEqual(sorted(probe), sorted(rows))
|
|||
|
|
for task, (start, eta, forecast, words, title) in probe.items():
|
|||
|
|
with self.subTest(mode=mode, task=task):
|
|||
|
|
row = rows[task]
|
|||
|
|
self.assertTrue(words.startswith("ETA ") and words != "ETA –", words)
|
|||
|
|
if row["ended"]:
|
|||
|
|
self.assertEqual((eta, forecast, title), (row["end"], False, "ETA: the end of the ended task"))
|
|||
|
|
continue
|
|||
|
|
self.assertTrue(forecast)
|
|||
|
|
self.assertAlmostEqual(eta - start, points.get(task, 4 * day), delta=0.01)
|
|||
|
|
ahead = [probe[edge["from"]][1] for edge in edges if edge["to"] == task and edge["from"] in probe and edge["from"] != task]
|
|||
|
|
if row["start"] is not None:
|
|||
|
|
self.assertEqual(start, row["start"])
|
|||
|
|
elif ahead and max(ahead) > window[1]:
|
|||
|
|
self.assertAlmostEqual(start, max(ahead), delta=0.01)
|
|||
|
|
else:
|
|||
|
|
self.assertTrue(window[0] <= start <= window[1], (start, window))
|
|||
|
|
|
|||
|
|
def trend_forecast(self, points: list[list[float]], mode: str, days: int) -> tuple[float, float | None]:
|
|||
|
|
"""Args:
|
|||
|
|
points: [t, remaining] of the drawn burndown points.
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
The trend's start and the time its remaining line reaches 0
|
|||
|
|
(None when it never falls), computed here independently of plan.js.
|
|||
|
|
"""
|
|||
|
|
last_t, last_y = points[-1]
|
|||
|
|
if mode == "regression":
|
|||
|
|
mean_t = sum(t for t, _ in points) / len(points)
|
|||
|
|
mean_y = sum(y for _, y in points) / len(points)
|
|||
|
|
slope = sum((t - mean_t) * (y - mean_y) for t, y in points) / sum((t - mean_t) ** 2 for t, _ in points)
|
|||
|
|
return points[0][0], (mean_t - mean_y / slope if slope < 0 else None)
|
|||
|
|
start = max(points[0][0], last_t - days * 86400)
|
|||
|
|
before = [y for t, y in points if t <= start][-1]
|
|||
|
|
slope = (last_y - before) / (last_t - start)
|
|||
|
|
return start, (last_t - last_y / slope if slope < 0 else None)
|
|||
|
|
|
|||
|
|
def trended(self, probe: dict, mode: str, days: int) -> None:
|
|||
|
|
start, forecast = self.trend_forecast(probe["points"], mode, days)
|
|||
|
|
self.assertEqual(probe["value"], mode)
|
|||
|
|
self.assertEqual(probe["days"], [days, mode == "velocity"])
|
|||
|
|
self.assertEqual(sorted(series for series, *_ in probe["lines"]), ["done", "remaining", "scope"])
|
|||
|
|
for _, begin, end in probe["lines"]:
|
|||
|
|
self.assertAlmostEqual(begin, start, delta=0.01)
|
|||
|
|
self.assertAlmostEqual(end, forecast if forecast is not None else probe["points"][-1][0], delta=0.01)
|
|||
|
|
if forecast is None:
|
|||
|
|
self.assertEqual((probe["note"], probe["marker"]), ([None, "∞"], None))
|
|||
|
|
return
|
|||
|
|
self.assertAlmostEqual(probe["note"][0], forecast, delta=0.01)
|
|||
|
|
self.assertAlmostEqual(probe["marker"], forecast, delta=0.01)
|
|||
|
|
self.assertNotEqual(probe["note"][1], "∞", probe["note"])
|
|||
|
|
|
|||
|
|
def check_trend_eta_3d(self, browser: str, driver: str, binary: str) -> None:
|
|||
|
|
self.trend_work(time.time())
|
|||
|
|
begun = time.time()
|
|||
|
|
data = self.drive(self.trend_steps(browser), None, driver, binary, init=GRAPH_HOOK)
|
|||
|
|
ended = time.time()
|
|||
|
|
(OUT / f"{browser}-trend-eta-3d.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
|
|||
|
|
self.assertEqual([error for error in data["errors"] if "(style-src-elem)" not in error and "/favicon.ico" not in error], [])
|
|||
|
|
snapshot = self.snapshot()
|
|||
|
|
rows = {row["task"]: row for row in snapshot["tasks"]}
|
|||
|
|
edges = snapshot["task_edges"]
|
|||
|
|
self.assertEqual(sorted([edge["kind"], edge["from"], edge["to"]] for edge in edges), [["after", "work/t4", "work/t5"], ["base", "work/t3", "work/t6"], ["queue", "queue/deploy-1", "queue/test-2"]])
|
|||
|
|
trends = [["off", "off"], ["regression", "linear regression"], ["velocity", "velocity"]]
|
|||
|
|
per = 8
|
|||
|
|
for index, (width, _) in enumerate(WIDTHS):
|
|||
|
|
eta, regression, reloaded, velocity, again, tips, shown, camera = data["results"][per * index : per * (index + 1)]
|
|||
|
|
days = TREND_DAYS[width]
|
|||
|
|
kept = TREND_DAYS[WIDTHS[index - 1][0]] if index else 7
|
|||
|
|
with self.subTest(browser=browser, width=width):
|
|||
|
|
for probe in (eta, regression, reloaded, velocity, again, tips, shown):
|
|||
|
|
self.assertNotIn("error", probe)
|
|||
|
|
self.assertEqual((probe["tall"], probe["wide"], probe["layout"]), (False, False, ["toolbar", "chips", "body"]), probe)
|
|||
|
|
self.assertEqual(probe["rows"] == 1, width != 390, probe["rows"])
|
|||
|
|
for mode in ("none", "points", "back"):
|
|||
|
|
self.eta_checked(eta[mode], "points" if mode == "points" else "none", rows, edges, (begun - 1, ended + 1))
|
|||
|
|
self.assertEqual(eta["modes"], [["none", "true"], ["points", "false"]])
|
|||
|
|
self.assertEqual((regression["before"]["value"], regression["before"]["options"], regression["before"]["note"], regression["before"]["lines"]), ("off", trends, None, []))
|
|||
|
|
self.assertEqual(regression["before"]["days"], [kept, False])
|
|||
|
|
self.assertEqual(regression["toasts"], ["Trend: linear regression"])
|
|||
|
|
self.trended(regression["after"], "regression", kept)
|
|||
|
|
self.trended(reloaded, "regression", kept)
|
|||
|
|
self.assertEqual(velocity["toasts"], [f"Trend: velocity over {kept} days", f"Trend: velocity over {days} days"])
|
|||
|
|
self.trended(velocity["after"], "velocity", days)
|
|||
|
|
self.trended(again, "velocity", days)
|
|||
|
|
self.assertEqual([step["t"] for step in tips["steps"]], [t for t, _ in again["points"]])
|
|||
|
|
listed = [[sorted(filter(None, step[key].split(" "))) for key in ("started", "ended", "joined")] for step in tips["steps"]]
|
|||
|
|
self.assertEqual(listed, [[["work/t1", "work/t2", "work/t3"], [], ["work/t5", "work/t6"]], [[], ["work/t1"], []], [[], ["work/t2"], []], [[], ["work/t3"], []], [["work/t4"], [], []], [[], [], []]])
|
|||
|
|
self.assertEqual([step["series"] for step in tips["steps"]], [["scope", "done", "remaining"]] * len(tips["steps"]))
|
|||
|
|
self.assertIn("Ended: work/t1", tips["steps"][1]["tip"])
|
|||
|
|
self.assertIn("No work package started, ended or joined the scope here", tips["steps"][-1]["tip"])
|
|||
|
|
self.assertEqual((tips["reset"], tips["note"], tips["lines"]), ("Trend: off", False, 0))
|
|||
|
|
self.tasks_3d(shown, snapshot)
|
|||
|
|
self.assertTrue(camera["hooked"], camera)
|
|||
|
|
self.assertGreater(math.dist(camera["built"], camera["moved"]), 1, camera)
|
|||
|
|
for refresh in camera["refreshes"]:
|
|||
|
|
self.assertEqual((refresh["rebuilt"], refresh["settled"]), (True, True), camera)
|
|||
|
|
self.assertLess(math.dist(refresh["camera"], camera["moved"]), 0.01, camera)
|
|||
|
|
self.assertEqual(self.httpd.hub.settings.get()["trend"], {"mode": "off", "days": TREND_DAYS[WIDTHS[-1][0]]})
|
|||
|
|
|
|||
|
|
def tasks_3d(self, shown: dict, snapshot: dict) -> None:
|
|||
|
|
tasks = sorted(row["task"] for row in snapshot["tasks"])
|
|||
|
|
colors = {"after": shown["palette"]["violet"], "base": shown["palette"]["info"], "queue": shown["palette"]["warn"]}
|
|||
|
|
edges = sorted([edge["from"], edge["to"], edge["kind"], colors[edge["kind"]]] for edge in snapshot["task_edges"])
|
|||
|
|
self.assertEqual(len(set(colors.values())), 3, colors)
|
|||
|
|
for layout, word in (("force", "Force"), ("time", "Time")):
|
|||
|
|
drawn = shown[layout]
|
|||
|
|
with self.subTest(layout=layout):
|
|||
|
|
self.assertEqual(drawn["note"], f"{len(tasks)} nodes · {len(edges)} edges · {word}")
|
|||
|
|
self.assertEqual(drawn["layouts"], [["none", str(layout == "force").lower()], ["time", str(layout == "time").lower()]])
|
|||
|
|
self.assertEqual(sorted(node for node, *_ in drawn["nodes"]), tasks)
|
|||
|
|
self.assertEqual(sorted(drawn["links"]), edges)
|
|||
|
|
self.assertEqual(drawn["label"], "work/t5 · Fifth")
|
|||
|
|
self.assertEqual([fz for _, fz, _ in shown["force"]["nodes"]], [None] * len(tasks))
|
|||
|
|
timed = sorted(shown["time"]["nodes"], key=lambda node: node[2])
|
|||
|
|
self.assertTrue(all(fz is not None for _, fz, _ in timed), timed)
|
|||
|
|
self.assertEqual([fz for _, fz, _ in timed], sorted(fz for _, fz, _ in timed))
|
|||
|
|
self.assertLess(timed[0][1], timed[-1][1])
|
|||
|
|
popup = shown["popup"]
|
|||
|
|
self.assertEqual((popup["open"], popup["title"], popup["id"], popup["picked"], popup["open_button"], popup["line"]), (True, "Fifth", "work/t5", "work/t5", "Open task", True), popup)
|
|||
|
|
self.assertTrue(popup["eta"], popup)
|
|||
|
|
self.assertEqual((popup["closed"], shown["back"]), ([False, None], f"{len(tasks)} nodes · {len(edges)} edges · Force"))
|
|||
|
|
|
|||
|
|
def test_chromium_draws_the_trend_forecast_point_tips_eta_and_tasks_3d_at_three_widths(self):
|
|||
|
|
self.check_trend_eta_3d("chromium", "cdp.mjs", os.environ.get("CHROMIUM", "chromium"))
|
|||
|
|
|
|||
|
|
@unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox")
|
|||
|
|
def test_firefox_draws_the_trend_forecast_point_tips_eta_and_tasks_3d_at_three_widths(self):
|
|||
|
|
self.check_trend_eta_3d("firefox", "bidi.mjs", os.environ.get("FIREFOX", "firefox"))
|
|||
|
|
|
|||
|
|
|
|||
|
|
if __name__ == "__main__":
|
|||
|
|
unittest.main()
|