test_manage.py

"""Exercise the real manage/delete/requeue routes with the Hub stubbed out."""
import sys, types, json, importlib.util

import os
os.environ["HF_TOKEN"] = "stub-token"
os.environ["LEADERBOARD_OWNER"] = "Mushari440"

# ---- fake Hub state -------------------------------------------------------
FILES = {
    "Mushari440/results": {
        "v7/org/results_alpha.json", "v7/org/results_beta.json",
        "v8/org/results_alpha.json",
    },
    "Mushari440/results-private": set(),
    "Mushari440/requests": {"org/alpha.json", "org/beta.json", "org/gamma.json"},
}
REQ = {
    "org/alpha.json": {"model": "org/alpha", "status": "FINISHED"},
    "org/beta.json":  {"model": "org/beta",  "status": "FINISHED"},
    "org/gamma.json": {"model": "org/gamma", "status": "PENDING"},
}
COMMITS = []

class FakeApi:
    def __init__(self, *a, **k): pass
    def list_repo_files(self, repo_id=None, repo_type=None, *a, **k):
        return sorted(FILES.get(repo_id or a[0] if a else repo_id, set()))
    def delete_file(self, path_in_repo=None, repo_id=None, **k):
        if path_in_repo not in FILES.get(repo_id, set()):
            raise RuntimeError("404")
        FILES[repo_id].discard(path_in_repo)
        if repo_id == "Mushari440/requests":
            REQ.pop(path_in_repo, None)      # the queue entry lives in both fakes
        COMMITS.append(("delete", repo_id, path_in_repo))
    def upload_file(self, path_or_fileobj=None, path_in_repo=None, repo_id=None, **k):
        body = json.loads(path_or_fileobj.decode() if isinstance(path_or_fileobj, bytes) else path_or_fileobj)
        REQ[path_in_repo] = body
        COMMITS.append(("upload", repo_id, path_in_repo, body.get("status")))

spec = importlib.util.spec_from_file_location("spaceapp", os.path.join(os.path.dirname(__file__), "app.py"))
app = importlib.util.module_from_spec(spec)
sys.modules["spaceapp"] = app
spec.loader.exec_module(app)

app.HfApi = FakeApi
app.api = FakeApi()
app._require_owner = lambda *a, **k: "Mushari440"
app._list_requests = lambda: [dict(v, _path=k) for k, v in REQ.items()]

fails = []
def check(name, got, want):
    ok = got == want
    if not ok:
        fails.append(name)
        print(f"  FAIL  {name}\n        got  {got}\n        want {want}")
    else:
        print(f"  PASS  {name}")

R = types.SimpleNamespace(headers={}, cookies={}, session={})

print("manage reports presence per version")
rows = {m["model"]: m for m in app.manage(R, version="v8")["models"]}
check("alpha scored on v7 and v8", sorted(rows["alpha" if "alpha" in rows else "org/alpha"]["results_by_version"]), ["v7", "v8"])
check("beta scored on v7 only",    sorted(rows["org/beta"]["results_by_version"]), ["v7"])
check("gamma scored nowhere",      rows["org/gamma"]["results_by_version"], {})
check("result_in follows the asked version", rows["org/beta"]["result_in"], [])

print("\ndelete scope='version' touches only that version")
app.model_delete(R, app.ModelRef(model="org/alpha", version="v8", scope="version"))
check("v8 score gone",        "v8/org/results_alpha.json" in FILES["Mushari440/results"], False)
check("v7 score untouched",   "v7/org/results_alpha.json" in FILES["Mushari440/results"], True)
check("request kept",         "org/alpha.json" in REQ, True)

print("\ndelete scope='all' removes the model everywhere")
app.model_delete(R, app.ModelRef(model="org/beta", version="v7", scope="all"))
check("v7 score gone",  "v7/org/results_beta.json" in FILES["Mushari440/results"], False)
check("request gone",   "org/beta.json" in REQ, False)

print("\nrequeue never revives a deliberately-set status")
REQ.clear()
REQ.update({
    "org/fin.json":   {"model": "org/fin",   "status": "FINISHED"},
    "org/fail.json":  {"model": "org/fail",  "status": "FAILED"},
    "org/held.json":  {"model": "org/held",  "status": "HELD"},
    "org/canc.json":  {"model": "org/canc",  "status": "CANCELLED"},
    "org/sup.json":   {"model": "org/sup",   "status": "SUPERSEDED"},
    "org/rej.json":   {"model": "org/rej",   "status": "REJECTED"},
    "org/pend.json":  {"model": "org/pend",  "status": "PENDING"},
})
FILES["Mushari440/results"] = set()
out = app.requeue_all(R, app.RequeueRef(version="v8", only_missing=True))
check("FINISHED is revived", "org/fin" in out["queued"], True)
check("FAILED is revived",   "org/fail" in out["queued"], True)
check("HELD is left parked",       out["skipped"].get("org/held"),  "held on purpose")
check("CANCELLED stays cancelled", out["skipped"].get("org/canc"),  "cancelled on purpose")
check("SUPERSEDED stays out",      out["skipped"].get("org/sup"),   "superseded on purpose")
check("REJECTED stays out",        out["skipped"].get("org/rej"),   "rejected on purpose")
check("PENDING not double-queued", out["skipped"].get("org/pend"),  "already queued")
check("only the two revivable ones", sorted(out["queued"]), ["org/fail", "org/fin"])

print("\nrequeue only_missing skips models already scored on the target version")
FILES["Mushari440/results"] = {"v7/org/results_alpha.json", "v8/org/results_alpha.json"}
REQ.clear()
REQ["org/alpha.json"] = {"model": "org/alpha", "status": "FINISHED"}
REQ["org/delta.json"] = {"model": "org/delta", "status": "FINISHED"}
REQ["org/gamma.json"] = {"model": "org/gamma", "status": "PENDING"}
out = app.requeue_all(R, app.RequeueRef(version="v8", only_missing=True))
check("alpha skipped (already on v8)", out["skipped"].get("org/alpha"), "already scored on v8")
check("delta queued",                  "org/delta" in out["queued"], True)
check("gamma skipped (already PENDING)", out["skipped"].get("org/gamma"), "already queued")
check("delta status is RERUN",         REQ["org/delta.json"]["status"], "RERUN")

print("\nrequeue only_missing=False re-queues scored models too")
REQ["org/alpha.json"] = {"model": "org/alpha", "status": "FINISHED"}
out = app.requeue_all(R, app.RequeueRef(version="v8", only_missing=False))
check("alpha queued this time", "org/alpha" in out["queued"], True)

print("\nFAILURES:", fails or "none")
sys.exit(1 if fails else 0)