tahamajs's picture
download
raw
18.5 kB
import json
from django.contrib.auth.models import User
from django.test import Client, TestCase, override_settings
from django.urls import reverse
from experiment.models import Experiment, TrainingRun
from rest_framework.authtoken.models import Token
from rest_framework.test import APIClient
# ----------------------------------------------------------------------
# Override middleware to remove the custom TokenAuthMiddleware during tests
# ----------------------------------------------------------------------
TEST_MIDDLEWARE = [
"django.middleware.security.SecurityMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
]
@override_settings(MIDDLEWARE=TEST_MIDDLEWARE)
class WebDashboardViewTests(TestCase):
"""Tests for all HTML page views and API endpoints in web_dashboard."""
def setUp(self):
self.client = Client()
self.api_client = APIClient()
self.user = User.objects.create_user(username="testuser", password="testpass")
self.exp = Experiment.objects.create(name="Sample Experiment")
self.run = TrainingRun.objects.create(
experiment=self.exp,
name="Sample Run",
status="running",
config={"model_name": "bert", "task_name": "mrpc"},
final_metrics={"eval_accuracy": 0.85},
current_step=50,
total_steps=100,
)
# A completed run with all required metrics for the statistics view
TrainingRun.objects.create(
experiment=self.exp,
name="Completed Run",
status="completed",
final_metrics={"eval_accuracy": 0.9, "eval_loss": 0.2, "eval_f1": 0.88},
config={"model_name": "distilbert", "task_name": "sst2"},
)
# ------------------------------------------------------------------
# Public pages (no login required)
# ------------------------------------------------------------------
def test_index(self):
response = self.client.get(reverse("dashboard_index"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Transformer Pro") # in the logo
def test_create_job_page(self):
response = self.client.get(reverse("dashboard_create_job"))
self.assertEqual(response.status_code, 200)
def test_login_page(self):
response = self.client.get(reverse("dashboard_login"))
self.assertEqual(response.status_code, 200)
def test_register_page(self):
response = self.client.get(reverse("dashboard_register"))
self.assertEqual(response.status_code, 200)
# ------------------------------------------------------------------
# Authenticated pages
# ------------------------------------------------------------------
def test_job_detail_authenticated(self):
self.client.force_login(self.user)
url = reverse("dashboard_job_detail", kwargs={"job_id": self.run.id})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, str(self.run.id)) # injected in JS
def test_dashboard_authenticated(self):
self.client.force_login(self.user)
response = self.client.get(reverse("dashboard_dashboard"))
self.assertEqual(response.status_code, 200)
def test_statistics_authenticated(self):
self.client.force_login(self.user)
response = self.client.get(reverse("dashboard_statistics"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "success_rate") # a context variable rendered
def test_job_detail_not_found_returns_404_when_authenticated(self):
self.client.force_login(self.user)
url = reverse(
"dashboard_job_detail",
kwargs={"job_id": "00000000-0000-0000-0000-000000000000"},
)
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
# ------------------------------------------------------------------
# Redirect tests (not logged in)
# ------------------------------------------------------------------
def test_job_detail_redirect_if_not_logged_in(self):
url = reverse("dashboard_job_detail", kwargs={"job_id": self.run.id})
response = self.client.get(url)
self.assertRedirects(
response, f"/login/?next={url}", fetch_redirect_response=False
)
def test_dashboard_redirect_if_not_logged_in(self):
url = reverse("dashboard_dashboard")
response = self.client.get(url)
self.assertRedirects(
response, f"/login/?next={url}", fetch_redirect_response=False
)
def test_statistics_redirect_if_not_logged_in(self):
url = reverse("dashboard_statistics")
response = self.client.get(url)
self.assertRedirects(
response, f"/login/?next={url}", fetch_redirect_response=False
)
# ------------------------------------------------------------------
# API endpoints (using APIClient)
# ------------------------------------------------------------------
def test_api_register_new_user(self):
data = {"username": "newuser", "password": "newpass123"}
response = self.api_client.post(
reverse("dashboard_api_register"),
data=json.dumps(data),
content_type="application/json",
)
self.assertEqual(response.status_code, 201)
self.assertIn("token", response.json())
self.assertIn("authToken", response.cookies)
def test_api_register_duplicate_user(self):
User.objects.create_user(username="existing", password="pass")
data = {"username": "existing", "password": "pass"}
response = self.api_client.post(
reverse("dashboard_api_register"),
data=json.dumps(data),
content_type="application/json",
)
self.assertEqual(response.status_code, 400)
self.assertIn("Username already taken", response.json()["error"])
def test_api_login_valid(self):
User.objects.create_user(username="loginuser", password="loginpass")
data = {"username": "loginuser", "password": "loginpass"}
response = self.api_client.post(
reverse("dashboard_api_login"),
data=json.dumps(data),
content_type="application/json",
)
self.assertEqual(response.status_code, 200)
json_data = response.json()
self.assertIn("token", json_data)
self.assertIn("authToken", response.cookies)
def test_api_login_invalid(self):
response = self.api_client.post(
reverse("dashboard_api_login"),
data=json.dumps({"username": "bad", "password": "wrong"}),
content_type="application/json",
)
self.assertEqual(response.status_code, 401)
self.assertIn("Invalid credentials", response.json()["error"])
def test_api_logout(self):
user = User.objects.create_user(username="logoutuser", password="logoutpass")
token = Token.objects.create(user=user)
# Simulate cookie-based authentication:
# 1. Force login so the user is known (request.user)
self.client.force_login(user)
# 2. Set the authToken cookie so CookieTokenAuthentication finds the token
self.client.cookies["authToken"] = token.key
response = self.client.post(reverse("dashboard_api_logout"))
self.assertEqual(response.status_code, 200)
self.assertFalse(Token.objects.filter(user=user).exists())
self.assertIn("authToken", response.cookies) # cookie cleared
def test_dashboard_api_jobs(self):
self.api_client.force_authenticate(user=self.user)
response = self.api_client.get(reverse("dashboard_api_jobs"))
self.assertEqual(response.status_code, 200)
data = response.json()
self.assertIsInstance(data, list)
self.assertEqual(len(data), 2)
run = data[0]
self.assertIn("id", run)
self.assertIn("status", run)
# ------------------------------------------------------------------
# Additional hard tests (20)
# ------------------------------------------------------------------
# 1. Index with no runs (empty dataset)
def test_index_empty_runs(self):
TrainingRun.objects.all().delete()
response = self.client.get(reverse("dashboard_index"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Transformer Pro") # page loads anyway
# 2. Job detail with invalid UUID format
def test_job_detail_invalid_uuid(self):
self.client.force_login(self.user)
# Manually construct a path with a non-UUID value – Django will return 404
response = self.client.get("/dashboard/job/not-a-uuid/")
self.assertEqual(response.status_code, 404)
# 3. Statistics with no runs (empty data)
def test_statistics_empty(self):
self.client.force_login(self.user)
TrainingRun.objects.all().delete()
response = self.client.get(reverse("dashboard_statistics"))
self.assertEqual(response.status_code, 200)
# Our minimal template renders: success_rate: 0 (float 0.0 is rendered as integer 0 by Django?)
# Actually 0.0 renders as '0.0' but we see '0' in the response. To be safe we check for 'success_rate: 0'
self.assertContains(response, "success_rate: 0") # no decimal
# 4. API register with missing username
def test_api_register_missing_username(self):
data = {"password": "test123"}
response = self.api_client.post(
reverse("dashboard_api_register"),
data=json.dumps(data),
content_type="application/json",
)
self.assertEqual(response.status_code, 400)
self.assertIn("error", response.json())
# 5. API register with missing password
def test_api_register_missing_password(self):
data = {"username": "user123"}
response = self.api_client.post(
reverse("dashboard_api_register"),
data=json.dumps(data),
content_type="application/json",
)
self.assertEqual(response.status_code, 400)
self.assertIn("error", response.json())
# 6. API login with missing fields
def test_api_login_missing_fields(self):
response = self.api_client.post(
reverse("dashboard_api_login"),
data=json.dumps({}),
content_type="application/json",
)
self.assertEqual(response.status_code, 401)
self.assertIn("error", response.json())
# 7. API logout when not authenticated
def test_api_logout_unauthenticated(self):
response = self.client.post(reverse("dashboard_api_logout"))
self.assertEqual(response.status_code, 401) # or 403; depends on DRF default
# 8. API jobs endpoint unauthenticated
def test_dashboard_api_jobs_unauthenticated(self):
response = self.api_client.get(reverse("dashboard_api_jobs"))
self.assertEqual(response.status_code, 401)
# 9. API register with very long username/password (boundary)
def test_api_register_long_credentials(self):
long_user = "a" * 151 # Django's default max_length is 150
data = {"username": long_user, "password": "validpass"}
response = self.api_client.post(
reverse("dashboard_api_register"),
data=json.dumps(data),
content_type="application/json",
)
# Should fail because username too long (400)
self.assertEqual(response.status_code, 400)
# 10. Statistics when a run has missing final_metrics keys
def test_statistics_partial_metrics(self):
# Create a completed run without 'eval_loss' key
TrainingRun.objects.create(
experiment=self.exp,
name="Partial Metrics Run",
status="completed",
final_metrics={"eval_accuracy": 0.5}, # missing eval_loss
config={"model_name": "xlm"},
)
self.client.force_login(self.user)
response = self.client.get(reverse("dashboard_statistics"))
self.assertEqual(response.status_code, 200)
# View should not crash (uses Coalesce)
self.assertContains(response, "success_rate")
# 11. Dashboard API jobs with empty list
def test_dashboard_api_jobs_empty(self):
TrainingRun.objects.all().delete()
self.api_client.force_authenticate(user=self.user)
response = self.api_client.get(reverse("dashboard_api_jobs"))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), [])
# 12. Create job page redirects if not authenticated? (It's public, stays)
# Instead: GET on an API endpoint that requires POST
def test_api_login_get_not_allowed(self):
# The API login view is POST-only, a GET should return 405
response = self.api_client.get(reverse("dashboard_api_login"))
self.assertEqual(response.status_code, 405)
# 13. Test that logout with an invalid token in cookie fails gracefully
def test_api_logout_invalid_token_cookie(self):
user = User.objects.create_user(username="invlogout", password="test")
self.client.force_login(user) # session login, but DRF ignores it
self.client.cookies["authToken"] = (
"invalid-token" # invalid cookie -> unauthenticated
)
response = self.client.post(reverse("dashboard_api_logout"))
self.assertEqual(response.status_code, 401) # not logged in via token
# 14. Test job detail with a run that has no name
def test_job_detail_unnamed_run(self):
unnamed_run = TrainingRun.objects.create(
experiment=self.exp, name="", status="running" # empty name
)
self.client.force_login(self.user)
url = reverse("dashboard_job_detail", kwargs={"job_id": unnamed_run.id})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
# 15. Test index page when many runs exist (pagination not applied, but view fetches last 20)
def test_index_many_runs(self):
# Create 25 runs, index shows only last 20
for i in range(25):
TrainingRun.objects.create(
experiment=self.exp, name=f"Run {i}", status="completed"
)
response = self.client.get(reverse("dashboard_index"))
self.assertEqual(response.status_code, 200)
# The view passes 'runs' to template, we can't check count easily in rendered HTML,
# but ensure no error.
self.assertContains(response, "Transformer Pro")
# 16. Statistics with multiple days (ensure date grouping works)
def test_statistics_multi_day(self):
from datetime import timedelta
from django.utils import timezone
today = timezone.now()
yesterday = today - timedelta(days=1)
TrainingRun.objects.create(
experiment=self.exp,
name="Yesterday Run",
status="completed",
created_at=yesterday,
)
self.client.force_login(self.user)
response = self.client.get(reverse("dashboard_statistics"))
self.assertEqual(response.status_code, 200)
# The view passes 'days_labels' (as JSON) to template, but our template doesn't show it.
# We just verify the page loads and contains some expected numbers.
self.assertContains(response, "success_rate") # the string is present
# 17. API register response includes token and cookie (already tested, but verify cookie values)
def test_api_register_cookie_details(self):
data = {"username": "cookieuser", "password": "cookiepass"}
response = self.api_client.post(
reverse("dashboard_api_register"),
data=json.dumps(data),
content_type="application/json",
)
self.assertEqual(response.status_code, 201)
# Cookie 'authToken' should exist and have a value
cookie = response.cookies.get("authToken")
self.assertIsNotNone(cookie)
self.assertTrue(cookie.value)
# 18. API login sets cookie with correct token
def test_api_login_cookie_token_match(self):
User.objects.create_user(username="cookiematch", password="test")
data = {"username": "cookiematch", "password": "test"}
response = self.api_client.post(
reverse("dashboard_api_login"),
data=json.dumps(data),
content_type="application/json",
)
self.assertEqual(response.status_code, 200)
json_data = response.json()
token_from_body = json_data["token"]
cookie_token = response.cookies["authToken"].value
self.assertEqual(token_from_body, cookie_token)
# 19. Dashboard API jobs contains correct fields
def test_dashboard_api_jobs_field_set(self):
self.api_client.force_authenticate(user=self.user)
response = self.api_client.get(reverse("dashboard_api_jobs"))
data = response.json()
run = data[0]
expected_fields = {
"id",
"status",
"config",
"created_at",
"started_at",
"completed_at",
"current_step",
"total_steps",
"eta_seconds",
"gpu_percent",
"gpu_memory_mb",
"cpu_percent",
"ram_mb",
}
self.assertTrue(expected_fields.issubset(run.keys()))
# 20. Test that login page is accessible even after middleware override (already tested)
# We'll test that the redirect to login sets the next parameter correctly
def test_redirect_next_parameter_preserved(self):
from urllib.parse import quote
target = "/dashboard/statistics/"
url = f"/dashboard/job/{self.run.id}/?next={quote(target)}"
response = self.client.get(url)
# Should redirect to login with next parameter
self.assertRedirects(
response, f"/login/?next={url}", fetch_redirect_response=False
)

Xet Storage Details

Size:
18.5 kB
·
Xet hash:
162c648fe8755fc6ce8b2bf49beb31ca04e1c83337ac2eac470ebf50c5ded80d

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.