sarlink/sarlinkportal
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

register and sign in pages

Browse Source
This commit is contained in:
shihaam
2026-09-22 00:50:30 +05:00
parent f313867653
commit 78d04f75d1
96 changed files with 6383 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/users/tests/test_registration.py
+250
View File
@@ -0,0 +1,250 @@
from datetime import date, timedelta
from django.test import TestCase
from django.urls import reverse
from django.utils import timezone
from rest_framework.test import APIClient
from locations.models import Atoll, Island
from users.models import OtpCode, RegistrationTicket, User
class RegistrationFlowTests(TestCase):
def setUp(self):
self.client = APIClient()
self.atoll = Atoll.objects.get(name="Faafu")
self.island = Island.objects.get(name="Dharanboodhoo")
self.other_atoll = Atoll.objects.create(name="Kaafu", code="K")
self.other_island = Island.objects.create(atoll=self.other_atoll, name="Male")
# --- verifying the number -------------------------------------------
def test_unknown_number_gets_a_code_without_being_told_anything(self):
response = self.client.post(reverse("auth-start"), {"mobile": "7700000"})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["next"], "otp")
self.assertEqual(response.data["mobile"], "+9607700000")
otp = OtpCode.objects.get(mobile="+9607700000")
self.assertEqual(otp.purpose, OtpCode.Purpose.REGISTRATION)
self.assertIsNone(otp.user)
def test_verifying_an_unknown_number_hands_back_a_ticket(self):
code = self._send_registration_code("7700000")
response = self.client.post(
reverse("auth-verify"), {"mobile": "7700000", "code": code}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["next"], "register")
self.assertTrue(response.data["registration_token"])
self.assertEqual(response.data["mobile"], "+9607700000")
self.assertNotIn("token", response.data)
def test_verify_rejects_a_wrong_code(self):
self._send_registration_code("7700000")
response = self.client.post(
reverse("auth-verify"), {"mobile": "7700000", "code": "000000"}
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data["code"], "invalid_code")
self.assertFalse(RegistrationTicket.objects.exists())
def test_a_code_signs_in_an_account_created_in_the_meantime(self):
code = self._send_registration_code("7700000")
User.objects.create_user(mobile="7700000")
response = self.client.post(
reverse("auth-verify"), {"mobile": "7700000", "code": code}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["next"], "dashboard")
self.assertFalse(RegistrationTicket.objects.exists())
# --- the form -------------------------------------------------------
def test_registration_creates_a_pending_account(self):
token = self._verified_token("7700000")
response = self.client.post(reverse("auth-register"), self._form(token))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data["status"], "pending")
# No token: registering does not sign anyone in.
self.assertNotIn("token", response.data)
user = User.objects.get(mobile="+9607700000")
self.assertEqual(user.status, User.Status.PENDING)
self.assertEqual(user.full_name, "Ahmed Ali")
self.assertEqual(user.idnumber, "WP123456")
self.assertEqual(user.date_of_birth, date(1995, 4, 17))
self.assertEqual(user.island, self.island)
self.assertTrue(user.mobile_verified)
self.assertFalse(user.has_usable_password())
self.assertIsNotNone(user.terms_accepted_at)
self.assertIsNotNone(user.policy_accepted_at)
def test_the_number_comes_from_the_token_not_the_form(self):
token = self._verified_token("7700000")
payload = self._form(token) | {"mobile": "7711111"}
self.client.post(reverse("auth-register"), payload)
self.assertTrue(User.objects.filter(mobile="+9607700000").exists())
self.assertFalse(User.objects.filter(mobile="+9607711111").exists())
def test_a_token_works_only_once(self):
token = self._verified_token("7700000")
self.client.post(reverse("auth-register"), self._form(token))
User.objects.all().delete()
response = self.client.post(reverse("auth-register"), self._form(token))
self.assertEqual(response.status_code, 400)
self.assertIn("registration_token", response.data["errors"])
def test_an_expired_token_is_refused(self):
token = self._verified_token("7700000")
RegistrationTicket.objects.filter(key=token).update(
expires_at=timezone.now() - timedelta(minutes=1)
)
response = self.client.post(reverse("auth-register"), self._form(token))
self.assertEqual(response.status_code, 400)
self.assertIn("registration_token", response.data["errors"])
def test_registration_requires_a_token(self):
payload = self._form("nope")
response = self.client.post(reverse("auth-register"), payload)
self.assertEqual(response.status_code, 400)
self.assertIn("registration_token", response.data["errors"])
def test_both_agreements_are_required(self):
for field in ["terms_accepted", "policy_accepted"]:
with self.subTest(field=field):
token = self._verified_token("7700000")
payload = self._form(token) | {field: False}
response = self.client.post(reverse("auth-register"), payload)
self.assertEqual(response.status_code, 400)
self.assertIn(field, response.data["errors"])
self.assertFalse(User.objects.exists())
def test_island_must_belong_to_the_selected_atoll(self):
token = self._verified_token("7700000")
payload = self._form(token) | {"island": self.other_island.pk}
response = self.client.post(reverse("auth-register"), payload)
self.assertEqual(response.status_code, 400)
self.assertIn("island", response.data["errors"])
def test_required_fields(self):
token = self._verified_token("7700000")
response = self.client.post(
reverse("auth-register"), {"registration_token": token}
)
self.assertEqual(response.status_code, 400)
for field in [
"full_name",
"idnumber",
"date_of_birth",
"atoll",
"island",
]:
self.assertIn(field, response.data["errors"])
def test_future_date_of_birth_is_refused(self):
token = self._verified_token("7700000")
payload = self._form(token) | {
"date_of_birth": (date.today() + timedelta(days=1)).isoformat()
}
response = self.client.post(reverse("auth-register"), payload)
self.assertEqual(response.status_code, 400)
self.assertIn("date_of_birth", response.data["errors"])
def test_cannot_register_a_number_that_already_has_an_account(self):
token = self._verified_token("7700000")
User.objects.create_user(mobile="7700000")
response = self.client.post(reverse("auth-register"), self._form(token))
self.assertEqual(response.status_code, 400)
self.assertIn("mobile", response.data["errors"])
# --- after submitting ------------------------------------------------
def test_a_pending_applicant_can_sign_in_and_see_their_status(self):
token = self._verified_token("7700000")
self.client.post(reverse("auth-register"), self._form(token))
start = self.client.post(reverse("auth-start"), {"mobile": "7700000"})
self.assertEqual(start.data["next"], "otp")
otp = OtpCode.objects.active().filter(mobile="+9607700000").first()
self.assertIsNotNone(otp)
self.assertEqual(otp.purpose, OtpCode.Purpose.LOGIN)
_, code = OtpCode.issue(
mobile="+9607700000",
purpose=OtpCode.Purpose.LOGIN,
user=User.objects.get(mobile="+9607700000"),
)
response = self.client.post(
reverse("auth-verify"), {"mobile": "7700000", "code": code}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["next"], "dashboard")
self.assertEqual(response.data["user"]["status"], "pending")
def test_approval_flips_the_status_and_records_the_reviewer(self):
admin = User.objects.create_superuser(mobile="7711111", password="x")
token = self._verified_token("7700000")
self.client.post(reverse("auth-register"), self._form(token))
user = User.objects.get(mobile="+9607700000")
user.approve(reviewer=admin)
user.refresh_from_db()
self.assertEqual(user.status, User.Status.APPROVED)
self.assertTrue(user.is_approved)
self.assertEqual(user.reviewed_by, admin)
self.assertIsNotNone(user.reviewed_at)
def test_rejection_records_the_reason(self):
token = self._verified_token("7700000")
self.client.post(reverse("auth-register"), self._form(token))
user = User.objects.get(mobile="+9607700000")
user.reject(reason="Document unreadable")
user.refresh_from_db()
self.assertEqual(user.status, User.Status.REJECTED)
self.assertEqual(user.rejection_reason, "Document unreadable")
# --- helpers ---------------------------------------------------------
def _send_registration_code(self, mobile: str) -> str:
otp, code = OtpCode.issue(
mobile=f"+960{mobile}", purpose=OtpCode.Purpose.REGISTRATION
)
self.assertIsNotNone(otp)
return code
def _verified_token(self, mobile: str) -> str:
code = self._send_registration_code(mobile)
response = self.client.post(
reverse("auth-verify"), {"mobile": mobile, "code": code}
)
self.assertEqual(response.status_code, 200, response.data)
return response.data["registration_token"]
def _form(self, token: str) -> dict:
return {
"registration_token": token,
"full_name": "Ahmed Ali",
"idnumber": "wp123456",
"date_of_birth": "1995-04-17",
"atoll": self.atoll.pk,
"island": self.island.pk,
"terms_accepted": True,
"policy_accepted": True,
}
class LocationsApiTests(TestCase):
def test_atolls_are_public_and_include_islands(self):
response = APIClient().get(reverse("atoll-list"))
self.assertEqual(response.status_code, 200)
names = {atoll["name"]: atoll for atoll in response.data}
self.assertIn("Faafu", names)
self.assertEqual(
[island["name"] for island in names["Faafu"]["islands"]],
["Dharanboodhoo"],
)