codeforlife-portal 5.32.2__py2.py3-none-any.whl → 8.9.9__py2.py3-none-any.whl

cfl_common/common/tests/test_migration_blocked_time.py

@@ -0,0 +1,15 @@
+import pytest
+
+
+@pytest.mark.django_db
+def test_blocked_time_added(migrator):
+    migrator.apply_initial_migration(("common", "0008_unlock_worksheet_3"))
+    new_state = migrator.apply_tested_migration(("common", "0009_add_blocked_time_to_teacher_and_student"))
+
+    teacher_model = new_state.apps.get_model("common", "Teacher")
+
+    assert teacher_model._meta.get_field("blocked_time").get_internal_type() == "DateTimeField"
+
+    student_model = new_state.apps.get_model("common", "Student")
+
+    assert student_model._meta.get_field("blocked_time").get_internal_type() == "DateTimeField"

cfl_common/common/tests/test_migration_remove_teacher_title.py

@@ -0,0 +1,13 @@
+import pytest
+from django.db.models.query import QuerySet
+
+
+@pytest.mark.django_db
+def test_teacher_title_removed(migrator):
+    old_state = migrator.apply_initial_migration(("common", "0009_add_blocked_time_to_teacher_and_student"))
+    Teacher = old_state.apps.get_model("common", "Teacher")
+    assert hasattr(Teacher, "title")
+
+    new_state = migrator.apply_tested_migration(("common", "0010_remove_teacher_title"))
+    Teacher = new_state.apps.get_model("common", "Teacher")
+    assert not hasattr(Teacher, "title")

cfl_common/common/tests/test_migration_unique_school_names.py

@@ -0,0 +1,33 @@
+import pytest
+from django_test_migrations.migrator import Migrator
+
+
+@pytest.mark.django_db
+def test_migration_unique_school_names(migrator: Migrator):
+    state = migrator.apply_initial_migration(
+        ("common", "0047_delete_school_postcode")
+    )
+    School = state.apps.get_model("common", "School")
+
+    school_name = "ExampleSchool"
+    School.objects.bulk_create(
+        [
+            School(name=school_name),
+            School(name=school_name),
+            School(name=f"{school_name} 1"),
+        ]
+    )
+    school_ids = list(
+        School.objects.order_by("-id")[:3].values_list("id", flat=True)
+    )
+    school_ids.reverse()
+
+    migrator.apply_tested_migration(("common", "0048_unique_school_names"))
+    School = state.apps.get_model("common", "School")
+
+    def assert_school_name(index: int, name: str):
+        assert School.objects.get(id=school_ids[index]).name == name
+
+    assert_school_name(0, school_name)
+    assert_school_name(1, f"{school_name} 2")
+    assert_school_name(2, f"{school_name} 1")

cfl_common/common/tests/test_migration_verify_returning_users.py

@@ -0,0 +1,59 @@
+from datetime import datetime, timezone
+
+import pytest
+from django_test_migrations.migrator import Migrator
+
+from portal.views.api import __anonymise_user
+
+
+@pytest.mark.django_db
+def test_migration_verify_returning_users(migrator: Migrator):
+    state = migrator.apply_initial_migration(
+        ("common", "0050_anonymise_orphan_schools")
+    )
+    User = state.apps.get_model("auth", "User")
+    UserProfile = state.apps.get_model("common", "UserProfile")
+
+    returning_user = User.objects.create_user(
+        "ReturningUser",
+        password="password",
+        last_login=datetime.now(tz=timezone.utc),
+    )
+    returning_userprofile = UserProfile.objects.create(user=returning_user)
+
+    non_returning_user = User.objects.create_user(
+        "NonReturningUser", password="password"
+    )
+    non_returning_userprofile = UserProfile.objects.create(
+        user=non_returning_user
+    )
+
+    anonymised_returning_user = User.objects.create_user(
+        "AnonReturningUser",
+        password="password",
+        last_login=datetime.now(tz=timezone.utc),
+    )
+    anonymised_returning_userprofile = UserProfile.objects.create(
+        user=anonymised_returning_user
+    )
+    __anonymise_user(anonymised_returning_user)
+
+    anonymised_non_returning_user = User.objects.create_user(
+        "AnonNonReturningUser", password="password"
+    )
+    anonymised_non_returning_userprofile = UserProfile.objects.create(
+        user=anonymised_non_returning_user
+    )
+    __anonymise_user(anonymised_non_returning_user)
+
+    migrator.apply_tested_migration(("common", "0051_verify_returning_users"))
+
+    def assert_userprofile_is_verified(pk: int, verified: bool):
+        assert UserProfile.objects.get(pk=pk).is_verified == verified
+
+    assert_userprofile_is_verified(returning_userprofile.pk, True)
+    assert_userprofile_is_verified(non_returning_userprofile.pk, False)
+    assert_userprofile_is_verified(anonymised_returning_userprofile.pk, True)
+    assert_userprofile_is_verified(
+        anonymised_non_returning_userprofile.pk, False
+    )

cfl_common/common/tests/test_models.py

@@ -0,0 +1,87 @@
+from common.models import DailyActivity, Student, Teacher
+from django.test import TestCase
+from django.utils import timezone
+
+from ..helpers.organisation import sanitise_uk_postcode
+from .utils.classes import create_class_directly
+from .utils.organisation import create_organisation_directly, join_teacher_to_organisation
+from .utils.student import create_independent_student_directly
+from .utils.teacher import signup_teacher_directly
+
+
+class TestModels(TestCase):
+    def test_indep_student_pending_class_request_on_delete(self):
+        """
+        Given a class and an independent student,
+        When the student makes a request to join the class and the class is deleted,
+        Then the student's pending class request field is set to null.
+        """
+        teacher_email, _ = signup_teacher_directly()
+        create_organisation_directly(teacher_email)
+        class_name = "Test Class"
+        klass, _, _ = create_class_directly(teacher_email, class_name)
+
+        username, _, indep_student = create_independent_student_directly()
+
+        assert indep_student.is_independent()
+        assert indep_student.pending_class_request is None
+
+        indep_student.pending_class_request = klass
+        indep_student.save()
+
+        klass.anonymise()
+
+        indep_student = Student.objects.get(new_user__username=username)
+
+        assert indep_student.pending_class_request is None
+
+    def test_creation_time(self):
+        teacher_email, _ = signup_teacher_directly()
+
+        sometime = timezone.now()  # mark time before the school creation
+        school = create_organisation_directly(teacher_email)
+
+        # check the creation time
+        assert school.creation_time > sometime
+
+        sometime = timezone.now()  # mark time before the class creation
+        klass, name, access_code = create_class_directly(teacher_email)
+        # check the creation time
+        assert klass.creation_time > sometime
+
+    def test_school_admins(self):
+        """
+        Test that only the admins of a school are returned by the school.admins() function.
+        """
+        email1, password1 = signup_teacher_directly()
+        email2, password2 = signup_teacher_directly()
+        email3, password3 = signup_teacher_directly()
+        school = create_organisation_directly(email1)
+        join_teacher_to_organisation(email2, school.name)
+        join_teacher_to_organisation(email3, school.name, is_admin=True)
+
+        teacher1 = Teacher.objects.get(new_user__username=email1)
+        teacher2 = Teacher.objects.get(new_user__username=email2)
+        teacher3 = Teacher.objects.get(new_user__username=email3)
+
+        assert len(school.admins()) == 2
+        assert teacher1 in school.admins()
+        assert teacher2 not in school.admins()
+        assert teacher3 in school.admins()
+
+    def test_sanitise_uk_postcode(self):
+        postcode_with_space = "AL10 9NE"
+        postcode_without_space = "AL109UL"
+        invalid_postcode = "123"
+
+        assert sanitise_uk_postcode(postcode_with_space) == "AL10 9NE"  # Check it stays the same
+        assert sanitise_uk_postcode(postcode_without_space) == "AL10 9UL"  # Check a space is added
+        assert sanitise_uk_postcode(invalid_postcode) == "123"  # Check nothing happens
+
+    def test_daily_activity_serializer(self):
+        daily_activity = DailyActivity()
+
+        assert (
+            str(daily_activity)
+            == f"Activity on {daily_activity.date}: CSV clicks: 0, login cards clicks: 0, primary pack downloads: 0, python pack downloads: 0, level control submits: 0, teacher lockout resets: 0, indy lockout resets: 0, school student lockout resets: 0, unverified teachers anonymised: 0, unverified independents anonymised: 0"
+        )

cfl_common/common/tests/utils/classes.py

@@ -0,0 +1,38 @@
+from typing import Tuple
+
+from common.helpers.generators import generate_access_code
+from common.models import Class, Teacher
+
+
+def generate_details():
+    name = "Class %d" % generate_details.next_id
+    access_code = generate_access_code()
+
+    generate_details.next_id += 1
+
+    return name, access_code
+
+
+generate_details.next_id = 1
+
+
+def create_class_directly(teacher_email: str, class_name: str = None) -> Tuple[Class, str, str]:
+    """Generate a class with the details given.
+
+    Args:
+        teacher_email (str): The email of the teacher that will own the class.
+        class_name (str, optional): The name of the class. Defaults to auto-generated name.
+
+    Returns:
+        (class: Class, name: str, access_code: str): A tuple with the class model instance, name and access code.
+    """
+    name, access_code = generate_details()
+
+    if class_name is not None:
+        name = class_name
+
+    teacher = Teacher.objects.get(new_user__email=teacher_email)
+
+    klass = Class.objects.create(name=name, access_code=access_code, teacher=teacher)
+
+    return klass, name, access_code

cfl_common/common/tests/utils/email.py

@@ -0,0 +1,67 @@
+from builtins import str
+
+
+def follow_verify_email_link_to_onboarding(page, url):
+    page.browser.get(url)
+
+    return go_to_teacher_login_page(page.browser)
+
+
+def follow_verify_email_link_to_login(page, url, user_type):
+    page.browser.get(url)
+
+    if user_type == "teacher":
+        return go_to_teacher_login_page(page.browser)
+    elif user_type == "independent":
+        return go_to_independent_student_login_page(page.browser)
+
+
+def follow_duplicate_account_link_to_login(page, url, user_type):
+    page.browser.get(url)
+
+    if user_type == "teacher":
+        return go_to_teacher_login_page(page.browser)
+    elif user_type == "independent":
+        return go_to_independent_student_login_page(page.browser)
+
+
+def follow_reset_email_link(browser, link):
+    browser.get(link)
+
+    from portal.tests.pageObjects.portal.password_reset_form_page import (
+        PasswordResetPage,
+    )
+
+    return PasswordResetPage(browser)
+
+
+def follow_change_email_link_to_dashboard(page, url):
+    page.browser.get(url)
+
+    return go_to_teacher_login_page(page.browser)
+
+
+def follow_change_email_link_to_independent_dashboard(page, url):
+    page.browser.get(url)
+
+    return go_to_independent_student_login_page(page.browser)
+
+
+def go_to_teacher_login_page(browser):
+    from portal.tests.pageObjects.portal.teacher_login_page import TeacherLoginPage
+
+    return TeacherLoginPage(browser)
+
+
+def go_to_teacher_dashboard_page(browser):
+    from portal.tests.pageObjects.portal.teach.dashboard_page import TeachDashboardPage
+
+    return TeachDashboardPage(browser)
+
+
+def go_to_independent_student_login_page(browser):
+    from portal.tests.pageObjects.portal.independent_login_page import (
+        IndependentStudentLoginPage,
+    )
+
+    return IndependentStudentLoginPage(browser)

cfl_common/common/tests/utils/organisation.py

@@ -0,0 +1,41 @@
+from common.models import School, Teacher
+
+
+def generate_details(**kwargs):
+    name = kwargs.get("name", "School %d" % generate_details.next_id)
+
+    generate_details.next_id += 1
+
+    return name
+
+
+generate_details.next_id = 1
+
+
+def create_organisation_directly(teacher_email, **kwargs):
+    name = generate_details(**kwargs)
+
+    school = School.objects.create(name=name, country="GB")
+
+    teacher = Teacher.objects.get(new_user__email=teacher_email)
+    teacher.school = school
+    teacher.is_admin = True
+    teacher.save()
+
+    return school
+
+
+def join_teacher_to_organisation(teacher_email, org_name, is_admin=False):
+    teacher = Teacher.objects.get(new_user__email=teacher_email)
+    school = School.objects.get(name=org_name)
+
+    teacher.school = school
+    teacher.is_admin = is_admin
+    teacher.save()
+
+
+def create_organisation(page, password):
+    name = generate_details()
+    page = page.create_organisation(name, password)
+
+    return page, name

cfl_common/common/tests/utils/student.py

@@ -0,0 +1,123 @@
+from builtins import range
+from typing import Tuple
+from unittest.mock import patch
+
+from common.helpers.emails import generate_token
+from common.helpers.generators import generate_login_id
+from common.models import Class, Student
+
+from . import email
+
+
+def generate_school_details():
+    name = "Student %d" % generate_school_details.next_id
+    password = "Password2"
+
+    generate_school_details.next_id += 1
+
+    return name, password
+
+
+generate_school_details.next_id = 1
+
+
+def create_school_student_directly(access_code) -> Tuple[str, str, Student]:
+    """Creates a new student in the class with the specified access code.
+
+    Args:
+        access_code (str): The access code of the class the created student will be in
+
+    Returns:
+        Tuple[str, str, Student]: (name, password, student)
+    """
+    name, password = generate_school_details()
+
+    klass = Class.objects.get(access_code=access_code)
+
+    student = Student.objects.schoolFactory(klass, name, password)
+    return name, password, student
+
+
+def create_student_with_direct_login(access_code) -> Tuple[Student, str]:
+    name, password = generate_school_details()
+    klass = Class.objects.get(access_code=access_code)
+
+    # use random string for direct login)
+    login_id, hashed_login_id = generate_login_id()
+    student = Student.objects.schoolFactory(klass, name, password, hashed_login_id)
+
+    return student, login_id, name, password
+
+
+def create_independent_student_directly(preverified=True):
+    """
+    Creates a Student object and makes it independent by generating random details.
+    Also verifies the student's email if preverified is True.
+    :param preverified: whether or not the independent student's email should be
+    verified.
+    :return: the student's username, password and the student object itself.
+    """
+    name, username, email, password = generate_independent_student_details()
+
+    student = Student.objects.independentStudentFactory(name, email, password)
+
+    # verify student
+    generate_token(student.new_user, preverified=preverified)
+
+    return username, password, student
+
+
+def create_school_student(page):
+    name, _ = generate_school_details()
+
+    page = page.type_student_name(name).create_students()
+
+    return page, name
+
+
+def create_many_school_students(page, number_of_students):
+    names = ["" for i in range(number_of_students)]
+
+    for i in range(number_of_students):
+        names[i], _ = generate_school_details()
+        page = page.type_student_name(names[i])
+
+    page = page.create_students()
+
+    return page, names
+
+
+def generate_independent_student_details():
+    name = "Independent Student %d" % generate_independent_student_details.next_id
+    email_address = "student%d@codeforlife.com" % generate_independent_student_details.next_id
+    username = email_address
+    password = "$RFVBGT%^YHNmju7$RFVBGT%^YHNmju7$RFVBGT%^YHNmju7"
+
+    generate_independent_student_details.next_id += 1
+
+    return name, username, email_address, password
+
+
+generate_independent_student_details.next_id = 1
+
+
+@patch("common.helpers.emails.send_dotdigital_email")
+def create_independent_student(page, mock_send_dotdigital_email):
+    page = page.go_to_signup_page()
+
+    name, username, email_address, password = generate_independent_student_details()
+    page = page.independent_student_signup(name, email_address, password=password, confirm_password=password)
+
+    page = page.return_to_home_page()
+
+    verification_url = mock_send_dotdigital_email.call_args.kwargs["personalization_values"]["VERIFICATION_LINK"]
+
+    page = email.follow_verify_email_link_to_login(page, verification_url, "independent")
+
+    return page, name, username, email_address, password
+
+
+def verify_email(page, verification_url):
+    page = email.follow_verify_email_link_to_login(page, verification_url, "independent")
+
+    return page

cfl_common/common/tests/utils/teacher.py

@@ -0,0 +1,73 @@
+import random
+import sys
+from unittest.mock import patch
+
+from common.helpers.emails import generate_token
+from common.models import Teacher
+
+from . import email
+
+
+def generate_details(**kwargs):
+    random_int = random.randint(1, sys.maxsize)
+    first_name = kwargs.get("first_name", "Test")
+    last_name = kwargs.get("last_name", f"Teacher {random_int}")
+    email_address = kwargs.get("email_address", f"testteacher{random_int}@codeforlife.com")
+    password = kwargs.get("password", "$RFVBGT%6yhn$RFVBGT%6yhn$RFVBGT%6yhn$RFVBGT%6yhn")
+
+    return first_name, last_name, email_address, password
+
+
+def signup_teacher_directly(preverified=True, **kwargs):
+    """
+    Creates a Teacher object by using the details passed in as kwargs, or by
+    generating random details. Also verifies the teacher's email if preverified
+    is True.
+    :param preverified: whether or not the teacher's email should be verified.
+    :return: the teacher's email and password.
+    """
+    first_name, last_name, email_address, password = generate_details(**kwargs)
+    teacher = Teacher.objects.factory(first_name, last_name, email_address, password)
+    generate_token(teacher.new_user, preverified=preverified)
+    teacher.user.save()
+    return email_address, password
+
+
+@patch("portal.views.home.send_dotdigital_email")
+def signup_duplicate_teacher_fail(page, duplicate_email, mock_send_dotdigital_email):
+    page = page.go_to_signup_page()
+
+    first_name, last_name, email_address, password = generate_details()
+    page = page.signup(first_name, last_name, duplicate_email, password, password)
+
+    page = page.return_to_home_page()
+
+    login_link = mock_send_dotdigital_email.call_args.kwargs["personalization_values"]["LOGIN_URL"]
+
+    page = email.follow_duplicate_account_link_to_login(page, login_link, "teacher")
+
+    return page, email_address, password
+
+
+@patch("common.helpers.emails.send_dotdigital_email")
+def signup_teacher(page, mock_send_dotdigital_email, newsletter=False):
+    page = page.go_to_signup_page()
+
+    first_name, last_name, email_address, password = generate_details()
+    page = page.signup(
+        first_name, last_name, email_address, password=password, confirm_password=password, newsletter=newsletter
+    )
+
+    page = page.return_to_home_page()
+
+    verification_url = mock_send_dotdigital_email.call_args.kwargs["personalization_values"]["VERIFICATION_LINK"]
+
+    page = email.follow_verify_email_link_to_onboarding(page, verification_url)
+
+    return page, email_address, password
+
+
+def verify_email(page, verification_url):
+    page = email.follow_verify_email_link_to_login(page, verification_url, "teacher")
+
+    return page

cfl_common/common/tests/utils/user.py

@@ -0,0 +1,27 @@
+from django.contrib.auth.models import User
+from django.utils import timezone
+
+
+def get_superuser():
+    """Get a superuser for testing, or create one if there isn't one."""
+    try:
+        return User.objects.get(username="superuser")
+    except User.DoesNotExist:
+        return User.objects.create_superuser("superuser", "superuser@codeforlife.education", "password")
+
+
+def create_user_directly(active=True, **kwargs):
+    """Create a user in the database."""
+    days_to_subtract = 10 if active else 2000
+    username = "old_user+{:d}".format(create_user_directly.next_id)
+    user = User.objects.create_user(username, password="password")
+    user.last_login = timezone.now() - timezone.timedelta(days=days_to_subtract)
+    user.date_joined = timezone.now() - timezone.timedelta(days=days_to_subtract - 1)
+    user.save()
+
+    create_user_directly.next_id += 1
+
+    return user
+
+
+create_user_directly.next_id = 1

cfl_common/common/utils.py

@@ -0,0 +1,56 @@
+from django.contrib.auth.mixins import LoginRequiredMixin
+from django.contrib.auth.views import redirect_to_login
+from django.core.cache import cache
+from django.core.exceptions import FieldDoesNotExist
+from two_factor.utils import default_device
+
+
+def two_factor_cache_key(user):
+    """Cache key for using_two_factor."""
+    return "using-two-factor-%s" % user.pk
+
+
+def _using_two_factor(user):
+    """Returns whether the user is using 2fa or not."""
+    return default_device(user)
+
+
+def using_two_factor(user):
+    """Returns whether the user is using 2fa or not (Cached)."""
+    if hasattr(user, "using_two_factor_cache"):
+        # First try local memory, as we call this a lot in one request
+        return user.using_two_factor_cache
+    cache_key = two_factor_cache_key(user)
+    val = cache.get(cache_key)
+    if val is not None:
+        # If local memory failed, but we got it from memcache, set local memory
+        user.using_two_factor_cache = val
+        return val
+    val = bool(_using_two_factor(user))
+
+    # We didn't find it in the cache, so set it there and local memory
+    cache.set(cache_key, val, None)  # Cache forever
+    user.using_two_factor_cache = val
+    return val
+
+
+def field_exists(model, field):
+    try:
+        field = model._meta.get_field(field)
+    except FieldDoesNotExist:
+        return False
+    return True
+
+
+class LoginRequiredNoErrorMixin(LoginRequiredMixin):
+    """
+    Overwrites Django's 2.2 LoginRequiredMixin so as to not raise an error and
+    redirect instead.
+    """
+
+    def handle_no_permission(self):
+        return redirect_to_login(
+            self.request.get_full_path(),
+            self.get_login_url(),
+            self.get_redirect_field_name(),
+        )