From a9185c806a45ce090e196e8ab48f0ba0581847c0 Mon Sep 17 00:00:00 2001
From: Flavio Tarsetti <flavio.tarsetti@idiap.ch>
Date: Mon, 18 May 2020 13:11:13 +0200
Subject: [PATCH] [accounts][tests] Adding tests for TemporaryUrl
---
beat/web/accounts/models.py | 1 +
beat/web/accounts/tests.py | 969 +++++++++++++++++++++++++-----------
2 files changed, 690 insertions(+), 280 deletions(-)
diff --git a/beat/web/accounts/models.py b/beat/web/accounts/models.py
index 9eb4dbda9..9c6523002 100644
--- a/beat/web/accounts/models.py
+++ b/beat/web/accounts/models.py
@@ -168,6 +168,7 @@ def generate_url_hash():
)
return url_hash
+
class TemporaryUrlManager(models.Manager):
def create_temporary_url(self, status, supervision_track):
# Actions that result creating the object
diff --git a/beat/web/accounts/tests.py b/beat/web/accounts/tests.py
index 3d5d92300..ad2d4577b 100644
--- a/beat/web/accounts/tests.py
+++ b/beat/web/accounts/tests.py
@@ -35,38 +35,54 @@ from rest_framework.test import APITestCase
from django.contrib.auth.models import User
from django.conf import settings
-from .models import SupervisionTrack, Profile
+from .models import SupervisionTrack
+from .models import Profile
+from .models import TemporaryUrl
from datetime import datetime, timedelta
import datetime
import simplejson as json
-#----------------------------------------------------------
+# ----------------------------------------------------------
class AccountTestCase(APITestCase):
-
def setUp(self):
self.tearDown()
-
now = datetime.datetime.now()
- expiration_date_delta = datetime.timedelta(days=settings.ACCOUNT_BLOCKAGE_AFTER_FIRST_REJECTION_DAYS)
+ expiration_date_delta = datetime.timedelta(
+ days=settings.ACCOUNT_BLOCKAGE_AFTER_FIRST_REJECTION_DAYS
+ )
# Create the users
- self.password = '1234'
+ self.password = "1234"
- self.firstsupervisor = User.objects.create_user('firstsupervisor', 'firstsupervisor@test.org', self.password)
- self.secondsupervisor = User.objects.create_user('secondsupervisor', 'secondsupervisor@test.org', self.password)
- self.invalidsupervisor = User.objects.create_user('invalidsupervisor', 'invalidsupervisor@test.org', self.password)
+ self.firstsupervisor = User.objects.create_user(
+ "firstsupervisor", "firstsupervisor@test.org", self.password
+ )
+ self.secondsupervisor = User.objects.create_user(
+ "secondsupervisor", "secondsupervisor@test.org", self.password
+ )
+ self.invalidsupervisor = User.objects.create_user(
+ "invalidsupervisor", "invalidsupervisor@test.org", self.password
+ )
- self.accepteduser = User.objects.create_user('accepteduser', 'accepteduser@test.org', self.password)
- self.rejecteduser = User.objects.create_user('rejecteduser', 'rejecteduser@test.org', self.password)
- self.yearrevalidationuser = User.objects.create_user('yearrevalidationuser', 'yearrevalidationuser@test.org', self.password)
- self.blockeduser = User.objects.create_user('blockeduser', 'blockeduser@test.org', self.password)
+ self.accepteduser = User.objects.create_user(
+ "accepteduser", "accepteduser@test.org", self.password
+ )
+ self.rejecteduser = User.objects.create_user(
+ "rejecteduser", "rejecteduser@test.org", self.password
+ )
+ self.yearrevalidationuser = User.objects.create_user(
+ "yearrevalidationuser", "yearrevalidationuser@test.org", self.password
+ )
+ self.blockeduser = User.objects.create_user(
+ "blockeduser", "blockeduser@test.org", self.password
+ )
# Update the profiles
- #supervisors
+ # supervisors
self.firstsupervisor.profile.status = Profile.ACCEPTED
self.secondsupervisor.profile.status = Profile.ACCEPTED
self.invalidsupervisor.profile.status = Profile.BLOCKED
@@ -82,134 +98,138 @@ class AccountTestCase(APITestCase):
self.secondsupervisor.profile.save()
self.invalidsupervisor.profile.save()
- #users
+ # users
self.accepteduser.profile.status = Profile.ACCEPTED
self.rejecteduser.profile.status = Profile.REJECTED
self.yearrevalidationuser.profile.status = Profile.YEARREVALIDATION
self.blockeduser.profile.status = Profile.BLOCKED
# Create the supervision tracks
- #Accepted user
- #Create and assign key
- self.accepteduser.profile.supervision_key = self.accepteduser.profile._generate_current_supervision_key()
+ # Accepted user
+ # Create and assign key
+ self.accepteduser.profile.supervision_key = (
+ self.accepteduser.profile._generate_current_supervision_key()
+ )
supervisiontrack = SupervisionTrack.objects.create(
- supervisee = self.accepteduser,
- supervisor = self.firstsupervisor,
- is_valid = True,
- start_date = now,
- expiration_date = now + expiration_date_delta,
- last_validation_date = now
+ supervisee=self.accepteduser,
+ supervisor=self.firstsupervisor,
+ is_valid=True,
+ start_date=now,
+ expiration_date=now + expiration_date_delta,
+ last_validation_date=now,
)
- #Assign key to supervision track
+ # Assign key to supervision track
supervisiontrack.supervision_key = self.accepteduser.profile.supervision_key
supervisiontrack.save()
self.accepteduser.profile.supervision.add(supervisiontrack)
self.accepteduser.profile.save()
self.accepteduser.save()
- #Rejected user
- #No supervision key but a rejection date
+ # Rejected user
+ # No supervision key but a rejection date
self.rejecteduser.profile.supervision_key = None
self.rejecteduser.profile.rejection_date = now + expiration_date_delta
self.rejecteduser.profile.save()
self.rejecteduser.save()
- #YearRevalidation user
- #Create and assign key
- self.yearrevalidationuser.profile.supervision_key = self.yearrevalidationuser.profile._generate_current_supervision_key()
+ # YearRevalidation user
+ # Create and assign key
+ self.yearrevalidationuser.profile.supervision_key = (
+ self.yearrevalidationuser.profile._generate_current_supervision_key()
+ )
supervisiontrack = SupervisionTrack.objects.create(
- supervisee = self.yearrevalidationuser,
- supervisor = self.firstsupervisor,
- is_valid = True,
- start_date = now,
- expiration_date = now + expiration_date_delta,
- last_validation_date = now
+ supervisee=self.yearrevalidationuser,
+ supervisor=self.firstsupervisor,
+ is_valid=True,
+ start_date=now,
+ expiration_date=now + expiration_date_delta,
+ last_validation_date=now,
)
- #Assign key to supervision track
- supervisiontrack.supervision_key = self.yearrevalidationuser.profile.supervision_key
+ # Assign key to supervision track
+ supervisiontrack.supervision_key = (
+ self.yearrevalidationuser.profile.supervision_key
+ )
supervisiontrack.save()
self.yearrevalidationuser.profile.supervision.add(supervisiontrack)
self.yearrevalidationuser.profile.save()
self.yearrevalidationuser.save()
- #Blocked user
+ # Blocked user
self.blockeduser.profile.supervision_key = None
self.blockeduser.profile.rejection_date = None
self.blockeduser.is_active = False
self.blockeduser.profile.save()
self.blockeduser.save()
-
def tearDown(self):
user = None
pass
def test_check_access_and_setup(self):
- #Supervisors
+ # Supervisors
user = self.firstsupervisor
logged_in = self.client.login(username=user.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(user.username, 'firstsupervisor')
+ self.assertEqual(user.username, "firstsupervisor")
logged_out = self.client.logout()
user = self.secondsupervisor
logged_in = self.client.login(username=user.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(user.username, 'secondsupervisor')
+ self.assertEqual(user.username, "secondsupervisor")
logged_out = self.client.logout()
user = self.invalidsupervisor
logged_in = self.client.login(username=user.username, password=self.password)
self.assertFalse(logged_in)
- self.assertEqual(user.username, 'invalidsupervisor')
+ self.assertEqual(user.username, "invalidsupervisor")
logged_out = self.client.logout()
- #Users
+ # Users
user = self.accepteduser
logged_in = self.client.login(username=user.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(user.username, 'accepteduser')
+ self.assertEqual(user.username, "accepteduser")
logged_out = self.client.logout()
user = self.rejecteduser
logged_in = self.client.login(username=user.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(user.username, 'rejecteduser')
+ self.assertEqual(user.username, "rejecteduser")
logged_out = self.client.logout()
user = self.yearrevalidationuser
logged_in = self.client.login(username=user.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(user.username, 'yearrevalidationuser')
+ self.assertEqual(user.username, "yearrevalidationuser")
logged_out = self.client.logout()
user = self.blockeduser
logged_in = self.client.login(username=user.username, password=self.password)
self.assertFalse(logged_in)
- self.assertEqual(user.username, 'blockeduser')
+ self.assertEqual(user.username, "blockeduser")
logged_out = self.client.logout()
-#----------------------------------------------------------
+# ----------------------------------------------------------
class AccountListTestCase(AccountTestCase):
-
def setUp(self):
super(AccountListTestCase, self).setUp()
- self.url = reverse('api_accounts:list_supervisee')
+ self.url = reverse("api_accounts:list_supervisee")
def test_anonymous_user(self):
- response = self.client.get(self.url, format='json')
+ response = self.client.get(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
def test_logged_in_user_not_supervisor(self):
@@ -217,14 +237,14 @@ class AccountListTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'accepteduser')
+ self.assertEqual(client.username, "accepteduser")
- response = self.client.get(self.url, format='json')
+ response = self.client.get(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Not a supervisor account')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Not a supervisor account")
logged_out = self.client.logout()
@@ -234,49 +254,51 @@ class AccountListTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'firstsupervisor')
+ self.assertEqual(client.username, "firstsupervisor")
- response = self.client.get(self.url, format='json')
+ response = self.client.get(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 2)
- self.assertEqual(content[0]['supervisee']['username'], 'accepteduser')
- self.assertEqual(content[1]['supervisee']['username'], 'yearrevalidationuser')
+ self.assertEqual(content[0]["supervisee"]["username"], "accepteduser")
+ self.assertEqual(content[1]["supervisee"]["username"], "yearrevalidationuser")
logged_out = self.client.logout()
-#----------------------------------------------------------
+# ----------------------------------------------------------
class AccountRevalidationTestCase(AccountTestCase):
-
def setUp(self):
super(AccountRevalidationTestCase, self).setUp()
- self.url = reverse('api_accounts:revalidate_account')
+ self.url = reverse("api_accounts:revalidate_account")
def test_anonymous_user(self):
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
def test_logged_in_accepted_user(self):
client = self.accepteduser
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'accepteduser')
+ self.assertEqual(client.username, "accepteduser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['error']
- self.assertEqual(errormsg, "You don't need to revalidate at the moment, your supervision is still valid")
+ errormsg = content["error"]
+ self.assertEqual(
+ errormsg,
+ "You don't need to revalidate at the moment, your supervision is still valid",
+ )
logged_out = self.client.logout()
@@ -285,14 +307,17 @@ class AccountRevalidationTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'rejecteduser')
+ self.assertEqual(client.username, "rejecteduser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['error']
- self.assertEqual(errormsg, 'You are not allowed to perform this action, you first need to get a valid supervision')
+ errormsg = content["error"]
+ self.assertEqual(
+ errormsg,
+ "You are not allowed to perform this action, you first need to get a valid supervision",
+ )
logged_out = self.client.logout()
@@ -302,9 +327,9 @@ class AccountRevalidationTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'yearrevalidationuser')
+ self.assertEqual(client.username, "yearrevalidationuser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
logged_out = self.client.logout()
@@ -315,17 +340,20 @@ class AccountRevalidationTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'yearrevalidationuser')
+ self.assertEqual(client.username, "yearrevalidationuser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['error']
- self.assertEqual(errormsg, "You don't need to revalidate at the moment, your supervision is still valid")
+ errormsg = content["error"]
+ self.assertEqual(
+ errormsg,
+ "You don't need to revalidate at the moment, your supervision is still valid",
+ )
logged_out = self.client.logout()
@@ -335,14 +363,14 @@ class AccountRevalidationTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertFalse(logged_in)
- self.assertEqual(client.username, 'blockeduser')
+ self.assertEqual(client.username, "blockeduser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
logged_out = self.client.logout()
@@ -352,14 +380,17 @@ class AccountRevalidationTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'firstsupervisor')
+ self.assertEqual(client.username, "firstsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['error']
- self.assertEqual(errormsg, 'You are not allowed to perform this action, you first need to get a valid supervision')
+ errormsg = content["error"]
+ self.assertEqual(
+ errormsg,
+ "You are not allowed to perform this action, you first need to get a valid supervision",
+ )
logged_out = self.client.logout()
@@ -369,63 +400,74 @@ class AccountRevalidationTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertFalse(logged_in)
- self.assertEqual(client.username, 'invalidsupervisor')
+ self.assertEqual(client.username, "invalidsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
logged_out = self.client.logout()
-#----------------------------------------------------------
+# ----------------------------------------------------------
class AccountAddSupervisorTestCase(AccountTestCase):
-
def setUp(self):
super(AccountAddSupervisorTestCase, self).setUp()
- self.url = reverse('api_accounts:add_supervisor', kwargs={'supervisor_name': self.secondsupervisor.username})
+ self.url = reverse(
+ "api_accounts:add_supervisor",
+ kwargs={"supervisor_name": self.secondsupervisor.username},
+ )
def test_anonymous_user(self):
- response = self.client.post(self.url, format='json')
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
def test_logged_in_accepted_user_supervision_request_to_invalid_supervisor(self):
client = self.accepteduser
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'accepteduser')
+ self.assertEqual(client.username, "accepteduser")
previous_supervision_key = client.profile.supervision_key
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, True)
- self.url = reverse('api_accounts:add_supervisor', kwargs={'supervisor_name': self.invalidsupervisor.username})
- #change supervisor
- response = self.client.post(self.url, format='json')
+ self.url = reverse(
+ "api_accounts:add_supervisor",
+ kwargs={"supervisor_name": self.invalidsupervisor.username},
+ )
+ # change supervisor
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['error']
- self.assertEqual(errormsg, 'Not a valid supervisor request')
+ errormsg = content["error"]
+ self.assertEqual(errormsg, "Not a valid supervisor request")
client = User.objects.get(username=client.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ # check track change and supervisor
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track, new_supervision_track)
self.assertEqual(previous_supervision_track.is_valid, True)
self.assertEqual(previous_supervision_key, new_supervision_key)
@@ -438,26 +480,34 @@ class AccountAddSupervisorTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'accepteduser')
+ self.assertEqual(client.username, "accepteduser")
previous_supervision_key = client.profile.supervision_key
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, True)
- #change supervisor
- response = self.client.post(self.url, format='json')
+ # change supervisor
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
client = User.objects.get(username=client.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ # check track change and supervisor
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, False)
self.assertNotEqual(previous_supervision_key, new_supervision_key)
- self.assertNotEqual(previous_supervision_track.supervisor, new_supervision_track.supervisor)
+ self.assertNotEqual(
+ previous_supervision_track.supervisor, new_supervision_track.supervisor
+ )
self.assertEqual(client.profile.status, Profile.REJECTED)
logged_out = self.client.logout()
@@ -467,20 +517,22 @@ class AccountAddSupervisorTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'rejecteduser')
+ self.assertEqual(client.username, "rejecteduser")
previous_supervision_key = client.profile.supervision_key
self.assertEqual(previous_supervision_key, None)
- #change supervisor
- response = self.client.post(self.url, format='json')
+ # change supervisor
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
client = User.objects.get(username=client.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
+ # check track change and supervisor
self.assertNotEqual(previous_supervision_key, new_supervision_key)
self.assertEqual(new_supervision_track.supervisor.username, "secondsupervisor")
self.assertEqual(client.profile.status, Profile.REJECTED)
@@ -492,36 +544,43 @@ class AccountAddSupervisorTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'rejecteduser')
+ self.assertEqual(client.username, "rejecteduser")
previous_supervision_key = client.profile.supervision_key
self.assertEqual(previous_supervision_key, None)
- #change supervisor
- response = self.client.post(self.url, format='json')
+ # change supervisor
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
client = User.objects.get(username=client.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
+ # check track change and supervisor
self.assertNotEqual(previous_supervision_key, new_supervision_key)
self.assertEqual(new_supervision_track.supervisor.username, "secondsupervisor")
self.assertEqual(client.profile.status, Profile.REJECTED)
- #change supervisor second request
- response = self.client.post(self.url, format='json')
+ # change supervisor second request
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['error']
- self.assertEqual(errormsg, "You are not able to perform this action as you already have a pending request")
+ errormsg = content["error"]
+ self.assertEqual(
+ errormsg,
+ "You are not able to perform this action as you already have a pending request",
+ )
client = User.objects.get(username=client.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
+ # check track change and supervisor
self.assertNotEqual(previous_supervision_key, new_supervision_key)
self.assertEqual(new_supervision_track.supervisor.username, "secondsupervisor")
self.assertEqual(client.profile.status, Profile.REJECTED)
@@ -533,26 +592,34 @@ class AccountAddSupervisorTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'yearrevalidationuser')
+ self.assertEqual(client.username, "yearrevalidationuser")
previous_supervision_key = client.profile.supervision_key
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, True)
- #change supervisor
- response = self.client.post(self.url, format='json')
+ # change supervisor
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
client = User.objects.get(username=client.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ # check track change and supervisor
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, False)
self.assertNotEqual(previous_supervision_key, new_supervision_key)
- self.assertNotEqual(previous_supervision_track.supervisor, new_supervision_track.supervisor)
+ self.assertNotEqual(
+ previous_supervision_track.supervisor, new_supervision_track.supervisor
+ )
self.assertEqual(client.profile.status, Profile.REJECTED)
logged_out = self.client.logout()
@@ -563,16 +630,16 @@ class AccountAddSupervisorTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertFalse(logged_in)
- self.assertEqual(client.username, 'blockeduser')
+ self.assertEqual(client.username, "blockeduser")
- response = self.client.post(self.url, format='json')
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
- #This reactivation can be done through online request ONLY
+ # This reactivation can be done through online request ONLY
logged_out = self.client.logout()
@@ -582,14 +649,14 @@ class AccountAddSupervisorTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'firstsupervisor')
+ self.assertEqual(client.username, "firstsupervisor")
- response = self.client.post(self.url, format='json')
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Not a supervisee account')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Not a supervisee account")
logged_out = self.client.logout()
@@ -599,55 +666,59 @@ class AccountAddSupervisorTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertFalse(logged_in)
- self.assertEqual(client.username, 'invalidsupervisor')
+ self.assertEqual(client.username, "invalidsupervisor")
- response = self.client.post(self.url, format='json')
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
logged_out = self.client.logout()
-#----------------------------------------------------------
+# ----------------------------------------------------------
class AccountValidateSuperviseeTestCase(AccountTestCase):
-
def setUp(self):
super(AccountValidateSuperviseeTestCase, self).setUp()
- self.url = reverse('api_accounts:validate_supervisee', kwargs={'supervisee_name': self.accepteduser.username})
+ self.url = reverse(
+ "api_accounts:validate_supervisee",
+ kwargs={"supervisee_name": self.accepteduser.username},
+ )
def test_anonymous_user(self):
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
def test_logged_in_accepted_user(self):
client = self.accepteduser
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'accepteduser')
+ self.assertEqual(client.username, "accepteduser")
previous_supervision_key = client.profile.supervision_key
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, True)
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Not a supervisor account')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Not a supervisor account")
logged_out = self.client.logout()
@@ -656,15 +727,15 @@ class AccountValidateSuperviseeTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'rejecteduser')
+ self.assertEqual(client.username, "rejecteduser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Not a supervisor account')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Not a supervisor account")
logged_out = self.client.logout()
@@ -674,15 +745,15 @@ class AccountValidateSuperviseeTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'yearrevalidationuser')
+ self.assertEqual(client.username, "yearrevalidationuser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Not a supervisor account')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Not a supervisor account")
logged_out = self.client.logout()
@@ -692,14 +763,14 @@ class AccountValidateSuperviseeTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertFalse(logged_in)
- self.assertEqual(client.username, 'blockeduser')
+ self.assertEqual(client.username, "blockeduser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
logged_out = self.client.logout()
@@ -709,57 +780,74 @@ class AccountValidateSuperviseeTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'firstsupervisor')
+ self.assertEqual(client.username, "firstsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['error']
- self.assertEqual(errormsg, "You can't validate this supervisee as his supervision is still valid")
+ errormsg = content["error"]
+ self.assertEqual(
+ errormsg,
+ "You can't validate this supervisee as his supervision is still valid",
+ )
logged_out = self.client.logout()
def test_logged_in_user_secondsupervisor_validates_previously_accepted_user(self):
- self.url = reverse('api_accounts:add_supervisor', kwargs={'supervisor_name': self.secondsupervisor.username})
+ self.url = reverse(
+ "api_accounts:add_supervisor",
+ kwargs={"supervisor_name": self.secondsupervisor.username},
+ )
client = self.accepteduser
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'accepteduser')
+ self.assertEqual(client.username, "accepteduser")
previous_supervision_key = client.profile.supervision_key
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, True)
- #change supervisor
- response = self.client.post(self.url, format='json')
+ # change supervisor
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
client = User.objects.get(username=client.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ # check track change and supervisor
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, False)
self.assertEqual(new_supervision_track.is_valid, False)
self.assertNotEqual(previous_supervision_key, new_supervision_key)
- self.assertNotEqual(previous_supervision_track.supervisor, new_supervision_track.supervisor)
+ self.assertNotEqual(
+ previous_supervision_track.supervisor, new_supervision_track.supervisor
+ )
self.assertEqual(client.profile.status, Profile.REJECTED)
logged_out = self.client.logout()
- self.url = reverse('api_accounts:validate_supervisee', kwargs={'supervisee_name': self.accepteduser.username})
+ self.url = reverse(
+ "api_accounts:validate_supervisee",
+ kwargs={"supervisee_name": self.accepteduser.username},
+ )
client = self.secondsupervisor
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'secondsupervisor')
+ self.assertEqual(client.username, "secondsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
@@ -767,51 +855,62 @@ class AccountValidateSuperviseeTestCase(AccountTestCase):
client = User.objects.get(username=self.accepteduser.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
+ # check track change and supervisor
self.assertEqual(previous_supervision_track.is_valid, False)
self.assertEqual(new_supervision_track.is_valid, True)
self.assertNotEqual(previous_supervision_key, new_supervision_key)
- self.assertNotEqual(previous_supervision_track.supervisor, new_supervision_track.supervisor)
+ self.assertNotEqual(
+ previous_supervision_track.supervisor, new_supervision_track.supervisor
+ )
self.assertEqual(client.profile.status, Profile.ACCEPTED)
-
def test_logged_in_user_secondsupervisor_validates_rejected_user(self):
- self.url = reverse('api_accounts:add_supervisor', kwargs={'supervisor_name': self.secondsupervisor.username})
+ self.url = reverse(
+ "api_accounts:add_supervisor",
+ kwargs={"supervisor_name": self.secondsupervisor.username},
+ )
client = self.rejecteduser
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'rejecteduser')
+ self.assertEqual(client.username, "rejecteduser")
previous_supervision_key = client.profile.supervision_key
self.assertEqual(previous_supervision_key, None)
- #change supervisor
- response = self.client.post(self.url, format='json')
+ # change supervisor
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
client = User.objects.get(username=client.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
+ # check track change and supervisor
self.assertNotEqual(previous_supervision_key, new_supervision_key)
self.assertEqual(new_supervision_track.supervisor.username, "secondsupervisor")
self.assertEqual(client.profile.status, Profile.REJECTED)
logged_out = self.client.logout()
- self.url = reverse('api_accounts:validate_supervisee', kwargs={'supervisee_name': self.rejecteduser.username})
+ self.url = reverse(
+ "api_accounts:validate_supervisee",
+ kwargs={"supervisee_name": self.rejecteduser.username},
+ )
client = self.secondsupervisor
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'secondsupervisor')
+ self.assertEqual(client.username, "secondsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
@@ -819,53 +918,69 @@ class AccountValidateSuperviseeTestCase(AccountTestCase):
client = User.objects.get(username=self.rejecteduser.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
+ # check track change and supervisor
self.assertEqual(new_supervision_track.is_valid, True)
self.assertNotEqual(new_supervision_track.supervisor, "secondsupervisor")
self.assertEqual(client.profile.status, Profile.ACCEPTED)
def test_logged_in_user_secondsupervisor_validates_yearrevalidation_user(self):
- self.url = reverse('api_accounts:add_supervisor', kwargs={'supervisor_name': self.secondsupervisor.username})
+ self.url = reverse(
+ "api_accounts:add_supervisor",
+ kwargs={"supervisor_name": self.secondsupervisor.username},
+ )
client = self.yearrevalidationuser
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'yearrevalidationuser')
+ self.assertEqual(client.username, "yearrevalidationuser")
previous_supervision_key = client.profile.supervision_key
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, True)
- #change supervisor
- response = self.client.post(self.url, format='json')
+ # change supervisor
+ response = self.client.post(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
client = User.objects.get(username=client.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ # check track change and supervisor
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, False)
self.assertNotEqual(previous_supervision_key, new_supervision_key)
- self.assertNotEqual(previous_supervision_track.supervisor, new_supervision_track.supervisor)
+ self.assertNotEqual(
+ previous_supervision_track.supervisor, new_supervision_track.supervisor
+ )
self.assertEqual(client.profile.status, Profile.REJECTED)
logged_out = self.client.logout()
- self.url = reverse('api_accounts:validate_supervisee', kwargs={'supervisee_name': self.yearrevalidationuser.username})
+ self.url = reverse(
+ "api_accounts:validate_supervisee",
+ kwargs={"supervisee_name": self.yearrevalidationuser.username},
+ )
client = self.secondsupervisor
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'secondsupervisor')
+ self.assertEqual(client.username, "secondsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
@@ -873,13 +988,17 @@ class AccountValidateSuperviseeTestCase(AccountTestCase):
client = User.objects.get(username=self.yearrevalidationuser.username)
new_supervision_key = client.profile.supervision_key
- new_supervision_track = SupervisionTrack.objects.get(supervision_key = new_supervision_key)
+ new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=new_supervision_key
+ )
- #check track change and supervisor
+ # check track change and supervisor
self.assertEqual(previous_supervision_track.is_valid, False)
self.assertEqual(new_supervision_track.is_valid, True)
self.assertNotEqual(previous_supervision_key, new_supervision_key)
- self.assertNotEqual(previous_supervision_track.supervisor, new_supervision_track.supervisor)
+ self.assertNotEqual(
+ previous_supervision_track.supervisor, new_supervision_track.supervisor
+ )
self.assertEqual(client.profile.status, Profile.ACCEPTED)
def test_logged_in_user_supervisor_validation_try(self):
@@ -888,14 +1007,17 @@ class AccountValidateSuperviseeTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'firstsupervisor')
+ self.assertEqual(client.username, "firstsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['error']
- self.assertEqual(errormsg, "You can't validate this supervisee as his supervision is still valid")
+ errormsg = content["error"]
+ self.assertEqual(
+ errormsg,
+ "You can't validate this supervisee as his supervision is still valid",
+ )
logged_out = self.client.logout()
@@ -905,55 +1027,59 @@ class AccountValidateSuperviseeTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertFalse(logged_in)
- self.assertEqual(client.username, 'invalidsupervisor')
+ self.assertEqual(client.username, "invalidsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
logged_out = self.client.logout()
-#----------------------------------------------------------
+# ----------------------------------------------------------
class AccountRemoveSuperviseeTestCase(AccountTestCase):
-
def setUp(self):
super(AccountRemoveSuperviseeTestCase, self).setUp()
- self.url = reverse('api_accounts:remove_supervisee', kwargs={'supervisee_name': self.accepteduser.username})
+ self.url = reverse(
+ "api_accounts:remove_supervisee",
+ kwargs={"supervisee_name": self.accepteduser.username},
+ )
def test_anonymous_user(self):
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
def test_logged_in_accepted_user(self):
client = self.accepteduser
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'accepteduser')
+ self.assertEqual(client.username, "accepteduser")
previous_supervision_key = client.profile.supervision_key
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, True)
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Not a supervisor account')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Not a supervisor account")
logged_out = self.client.logout()
@@ -962,15 +1088,15 @@ class AccountRemoveSuperviseeTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'rejecteduser')
+ self.assertEqual(client.username, "rejecteduser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Not a supervisor account')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Not a supervisor account")
logged_out = self.client.logout()
@@ -980,15 +1106,15 @@ class AccountRemoveSuperviseeTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'yearrevalidationuser')
+ self.assertEqual(client.username, "yearrevalidationuser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Not a supervisor account')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Not a supervisor account")
logged_out = self.client.logout()
@@ -998,97 +1124,108 @@ class AccountRemoveSuperviseeTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertFalse(logged_in)
- self.assertEqual(client.username, 'blockeduser')
+ self.assertEqual(client.username, "blockeduser")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
logged_out = self.client.logout()
def test_logged_in_supervisor_remove_accepted_user(self):
- #accepted user before
+ # accepted user before
client = self.accepteduser
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'accepteduser')
+ self.assertEqual(client.username, "accepteduser")
previous_supervision_key = client.profile.supervision_key
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, True)
self.assertEqual(client.profile.status, Profile.ACCEPTED)
logged_out = self.client.logout()
- #accepted user removed
+ # accepted user removed
client = self.firstsupervisor
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'firstsupervisor')
+ self.assertEqual(client.username, "firstsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
logged_out = self.client.logout()
- #accepted user after
+ # accepted user after
client = User.objects.get(username=self.accepteduser.username)
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'accepteduser')
+ self.assertEqual(client.username, "accepteduser")
new_supervision_key = client.profile.supervision_key
self.assertEqual(new_supervision_key, None)
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, False)
self.assertEqual(client.profile.status, Profile.REJECTED)
logged_out = self.client.logout()
def test_logged_in_supervisor_remove_yearrevalidation_user(self):
- self.url = reverse('api_accounts:remove_supervisee', kwargs={'supervisee_name': self.yearrevalidationuser.username})
+ self.url = reverse(
+ "api_accounts:remove_supervisee",
+ kwargs={"supervisee_name": self.yearrevalidationuser.username},
+ )
- #yearrevalidationuser user before
+ # yearrevalidationuser user before
client = self.yearrevalidationuser
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'yearrevalidationuser')
+ self.assertEqual(client.username, "yearrevalidationuser")
previous_supervision_key = client.profile.supervision_key
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, True)
self.assertEqual(client.profile.status, Profile.YEARREVALIDATION)
logged_out = self.client.logout()
- #yearrevalidationuser user removed
+ # yearrevalidationuser user removed
client = self.firstsupervisor
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'firstsupervisor')
+ self.assertEqual(client.username, "firstsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
logged_out = self.client.logout()
- #yearrevalidationuser user after
+ # yearrevalidationuser user after
client = User.objects.get(username=self.yearrevalidationuser.username)
logged_in = self.client.login(username=client.username, password=self.password)
self.assertTrue(logged_in)
- self.assertEqual(client.username, 'yearrevalidationuser')
+ self.assertEqual(client.username, "yearrevalidationuser")
new_supervision_key = client.profile.supervision_key
self.assertEqual(new_supervision_key, None)
- previous_supervision_track = SupervisionTrack.objects.get(supervision_key = previous_supervision_key)
+ previous_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=previous_supervision_key
+ )
self.assertEqual(previous_supervision_track.is_valid, False)
self.assertEqual(client.profile.status, Profile.REJECTED)
logged_out = self.client.logout()
@@ -1099,13 +1236,285 @@ class AccountRemoveSuperviseeTestCase(AccountTestCase):
logged_in = self.client.login(username=client.username, password=self.password)
self.assertFalse(logged_in)
- self.assertEqual(client.username, 'invalidsupervisor')
+ self.assertEqual(client.username, "invalidsupervisor")
- response = self.client.put(self.url, format='json')
+ response = self.client.put(self.url, format="json")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = json.loads(response.content)
self.assertEqual(len(json.loads(response.content)), 1)
- errormsg = content['detail']
- self.assertEqual(errormsg, 'Authentication credentials were not provided.')
+ errormsg = content["detail"]
+ self.assertEqual(errormsg, "Authentication credentials were not provided.")
logged_out = self.client.logout()
+
+
+# ----------------------------------------------------------
+
+
+class TemporaryUrlTestCase(AccountTestCase):
+ def setUp(self):
+ super(TemporaryUrlTestCase, self).setUp()
+
+ # expired time
+ now = datetime.datetime.now()
+ expiration_date_delta = datetime.timedelta(
+ days=settings.ACCOUNT_ACTIVATION_DAYS_FROM_SUPERVISOR
+ )
+ self.expired_time = now - expiration_date_delta
+
+ # Generation of a new supervision track
+ # rejected user makes new supervision request
+ self.url_add_supervisor = reverse(
+ "api_accounts:add_supervisor",
+ kwargs={"supervisor_name": self.secondsupervisor.username},
+ )
+ client = self.rejecteduser
+
+ logged_in = self.client.login(username=client.username, password=self.password)
+ self.assertTrue(logged_in)
+ self.assertEqual(client.username, "rejecteduser")
+
+ previous_supervision_key = client.profile.supervision_key
+ self.assertEqual(previous_supervision_key, None)
+
+ # change supervisor
+ response = self.client.post(self.url_add_supervisor, format="json")
+ self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
+
+ client = User.objects.get(username=client.username)
+
+ # Supervision tracks
+ self.new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=client.profile.supervision_key
+ )
+ logged_out = self.client.logout()
+ self.valid_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=self.accepteduser.profile.supervision_key
+ )
+ self.revalidate_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=self.yearrevalidationuser.profile.supervision_key
+ )
+
+ # Temporary urls use cases
+ self.temp_url_validation = TemporaryUrl.objects.create_temporary_url(
+ TemporaryUrl.VALIDATION, self.new_supervision_track
+ )
+ self.temp_url_yearrevalidation = TemporaryUrl.objects.create_temporary_url(
+ TemporaryUrl.YEARREVALIDATION, self.revalidate_supervision_track
+ )
+ self.temp_url_rejection = TemporaryUrl.objects.create_temporary_url(
+ TemporaryUrl.REJECTION, self.new_supervision_track
+ )
+
+ # Endpoint use cases (validation/yearly revalidation/rejection)
+ self.url_false = reverse(
+ "accounts:temp_url_validation", kwargs={"hash_url": "some_inexistant_hash"}
+ )
+ self.url_validation = reverse(
+ "accounts:temp_url_validation",
+ kwargs={"hash_url": self.temp_url_validation.url_hash},
+ )
+ self.url_yearrevalidation = reverse(
+ "accounts:temp_url_validation",
+ kwargs={"hash_url": self.temp_url_yearrevalidation.url_hash},
+ )
+ self.url_rejection = reverse(
+ "accounts:temp_url_rejection",
+ kwargs={"hash_url": self.temp_url_rejection.url_hash},
+ )
+
+ def test_false_url(self):
+ response = self.client.get(self.url_false, format="json")
+ self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+ def test_validation_new_supervision_track(self):
+ # Temporary url exists and supervision track is not valid yet
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_validation.url_hash
+ ).count()
+ supervision_key_ = TemporaryUrl.objects.get(
+ url_hash=self.temp_url_validation.url_hash
+ ).supervision_track.supervision_key
+ self.assertEqual(count, 1)
+ self.assertEqual(self.new_supervision_track.is_valid, False)
+
+ # Post request temporary url vanishes and supervision track is valid
+ response = self.client.get(self.url_validation, format="json")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ self.new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=supervision_key_
+ )
+ self.assertEqual(self.new_supervision_track.is_valid, True)
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_validation.url_hash
+ ).count()
+ self.assertEqual(count, 0)
+
+ def test_expired_validation_new_supervision_track(self):
+ # Expired Temporary url exists and supervision track is not valid yet
+
+ self.temp_url_validation.expires = self.expired_time
+ self.temp_url_validation.save()
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_validation.url_hash
+ ).count()
+ supervision_key_ = TemporaryUrl.objects.get(
+ url_hash=self.temp_url_validation.url_hash
+ ).supervision_track.supervision_key
+ self.assertEqual(count, 1)
+ self.assertEqual(self.new_supervision_track.is_valid, False)
+
+ # Post request temporary url vanishes and supervision track remains invalid
+ response = self.client.get(self.url_validation, format="json")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ self.new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=supervision_key_
+ )
+ self.assertEqual(self.new_supervision_track.is_valid, False)
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_validation.url_hash
+ ).count()
+ self.assertEqual(count, 0)
+
+ def test_rejection_new_supervision_track(self):
+ # Temporary url exists and supervision track is not valid yet
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_rejection.url_hash
+ ).count()
+ supervision_key_ = TemporaryUrl.objects.get(
+ url_hash=self.temp_url_validation.url_hash
+ ).supervision_track.supervision_key
+ self.assertEqual(count, 1)
+ self.assertEqual(self.new_supervision_track.is_valid, False)
+
+ # Post request temporary url vanishes and supervision track remains invalid
+ response = self.client.get(self.url_rejection, format="json")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ self.new_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=supervision_key_
+ )
+ self.assertEqual(self.new_supervision_track.is_valid, False)
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_rejection.url_hash
+ ).count()
+ self.assertEqual(count, 0)
+
+ def test_validation_yearly(self):
+ # Temporary url exists and supervision track is still valid
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_yearrevalidation.url_hash
+ ).count()
+ supervision_key_ = TemporaryUrl.objects.get(
+ url_hash=self.temp_url_yearrevalidation.url_hash
+ ).supervision_track.supervision_key
+ self.assertEqual(count, 1)
+ self.assertEqual(self.revalidate_supervision_track.is_valid, True)
+ previous_expiration_date = self.revalidate_supervision_track.expiration_date
+
+ # Post request temporary url vanishes and supervision track remains valid
+ response = self.client.get(self.url_yearrevalidation, format="json")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ self.revalidate_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=supervision_key_
+ )
+ new_expiration_date = self.revalidate_supervision_track.expiration_date
+
+ # Verify change in expiry date (1 year postpone)
+ self.assertEqual(
+ new_expiration_date, previous_expiration_date + timedelta(days=365)
+ )
+ self.assertEqual(self.revalidate_supervision_track.is_valid, True)
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_yearrevalidation.url_hash
+ ).count()
+ self.assertEqual(count, 0)
+
+ def test_expired_validation_yearly(self):
+ # Temporary url exists and supervision track is still valid
+ self.temp_url_yearrevalidation.expires = self.expired_time
+ self.temp_url_yearrevalidation.save()
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_yearrevalidation.url_hash
+ ).count()
+ supervision_key_ = TemporaryUrl.objects.get(
+ url_hash=self.temp_url_yearrevalidation.url_hash
+ ).supervision_track.supervision_key
+ self.assertEqual(count, 1)
+ self.assertEqual(self.revalidate_supervision_track.is_valid, True)
+
+ # Post request temporary url vanishes and supervision track gets invalid
+ response = self.client.get(self.url_yearrevalidation, format="json")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ self.revalidate_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=supervision_key_
+ )
+
+ self.assertEqual(self.revalidate_supervision_track.is_valid, False)
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_yearrevalidation.url_hash
+ ).count()
+ self.assertEqual(count, 0)
+
+ def test_rejection_after_yearly_revalidation(self):
+ # Temporary url exists and supervision track is still valid
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_yearrevalidation.url_hash
+ ).count()
+ supervision_key_ = TemporaryUrl.objects.get(
+ url_hash=self.temp_url_yearrevalidation.url_hash
+ ).supervision_track.supervision_key
+ self.assertEqual(count, 1)
+ self.assertEqual(self.revalidate_supervision_track.is_valid, True)
+ previous_expiration_date = self.revalidate_supervision_track.expiration_date
+
+ # Post request temporary url vanishes and supervision track remains valid
+ response = self.client.get(self.url_yearrevalidation, format="json")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ self.revalidate_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=supervision_key_
+ )
+ new_expiration_date = self.revalidate_supervision_track.expiration_date
+
+ # Verify change in expiry date (1 year postpone)
+ self.assertEqual(
+ new_expiration_date, previous_expiration_date + timedelta(days=365)
+ )
+ self.assertEqual(self.revalidate_supervision_track.is_valid, True)
+ count = TemporaryUrl.objects.filter(
+ url_hash=self.temp_url_yearrevalidation.url_hash
+ ).count()
+ self.assertEqual(count, 0)
+
+ # Supervisor rejects this supervisee after yearly revalidation
+ # Temporary url rejection exists and supervision track is still valid
+ temp_url_supervisor = TemporaryUrl.objects.filter(
+ status=TemporaryUrl.REJECTION
+ ).exclude(url_hash=self.temp_url_rejection.url_hash)
+ count = temp_url_supervisor.count()
+ supervision_key_ = TemporaryUrl.objects.get(
+ url_hash=temp_url_supervisor[0].url_hash
+ ).supervision_track.supervision_key
+ self.assertEqual(count, 1)
+ self.assertEqual(self.revalidate_supervision_track.is_valid, True)
+ url_yearrevalidation_revoke = reverse(
+ "accounts:temp_url_rejection",
+ kwargs={"hash_url": temp_url_supervisor[0].url_hash},
+ )
+ # Post request temporary url vanishes and supervision track gets invalid
+ response = self.client.get(url_yearrevalidation_revoke, format="json")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ self.revalidate_supervision_track = SupervisionTrack.objects.get(
+ supervision_key=supervision_key_
+ )
+ self.assertEqual(self.revalidate_supervision_track.is_valid, False)
+ rejection_date = self.revalidate_supervision_track.expiration_date
+
+ # Verify rejection date is now
+ self.assertEqual(rejection_date.date(), datetime.date.today())
+
+ count = (
+ TemporaryUrl.objects.filter(status=TemporaryUrl.REJECTION)
+ .exclude(url_hash=self.temp_url_rejection.url_hash)
+ .count()
+ )
+ self.assertEqual(count, 0)
--
GitLab