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

portal/tests/test_class.py

@@ -1,6 +1,9 @@
 from __future__ import absolute_import
 
-from common.models import Class, Teacher
+import time
+from datetime import datetime, timedelta
+
+from common.models import Class, DailyActivity, Teacher
 from common.tests.utils.classes import create_class_directly
 from common.tests.utils.organisation import (
     create_organisation_directly,
@@ -10,9 +13,12 @@ from common.tests.utils.student import create_school_student_directly
 from common.tests.utils.teacher import signup_teacher_directly
 from django.test import Client, TestCase
 from django.urls import reverse
+from game.models import Level
 
-from portal.tests.utils.classes import create_class
 from .base_test import BaseTest
+from .pageObjects.portal.home_page import HomePage
+from .pageObjects.portal.teach.class_page import TeachClassPage
+from .utils.classes import create_class
 from .utils.messages import is_class_created_message_showing
 
 
@@ -21,7 +27,7 @@ class TestClass(TestCase):
         email1, password1 = signup_teacher_directly()
         email2, password2 = signup_teacher_directly()
         create_organisation_directly(email1)
-        _, _, access_code = create_class_directly(email1)
+        klass, klass_name, access_code = create_class_directly(email1)
         _, _, student = create_school_student_directly(access_code)
 
         c = Client()
@@ -52,6 +58,7 @@ class TestClass(TestCase):
 
         assert response.status_code == 302
         assert len(teacher_classes) == 1
+        assert teacher.has_class()
 
         # Delete the student, and try again, check the class is deleted successfully
         student.delete()
@@ -62,6 +69,13 @@ class TestClass(TestCase):
 
         assert response.status_code == 302
         assert len(teacher_classes) == 0
+        assert not teacher.has_class()
+
+        # Check class is anonymised
+        new_klass = Class._base_manager.get(pk=klass.id)
+        assert new_klass.name != klass_name
+        assert new_klass.access_code == ""
+        assert not new_klass.is_active
 
     def test_edit_class(self):
         email1, password1 = signup_teacher_directly()
@@ -111,11 +125,321 @@ class TestClass(TestCase):
         assert klass.classmates_data_viewable
         assert klass.always_accept_requests
 
+    def test_level_control(self):
+        email, password = signup_teacher_directly()
+        create_organisation_directly(email)
+        klass1, _, access_code1 = create_class_directly(email)
+        klass2, _, access_code2 = create_class_directly(email)
+
+        c = Client()
+        old_date = datetime.now() - timedelta(days=1)
+        old_daily_activity = DailyActivity(date=old_date)
+        old_daily_activity.save()
+
+        url = reverse("teacher_edit_class", kwargs={"access_code": access_code1})
+        # POST request data for locking only the first level
+        data = {
+            "episode1": [
+                "level:2",
+                "level:3",
+                "level:4",
+                "level:5",
+                "level:6",
+                "level:7",
+                "level:8",
+                "level:9",
+                "level:10",
+                "level:11",
+                "level:12",
+            ],
+            "episode2": [
+                "level:13",
+                "level:14",
+                "level:15",
+                "level:16",
+                "level:17",
+                "level:18",
+            ],
+            "episode3": [
+                "level:19",
+                "level:20",
+                "level:21",
+                "level:22",
+                "level:23",
+                "level:24",
+                "level:25",
+                "level:26",
+                "level:27",
+                "level:28",
+            ],
+            "episode4": [
+                "level:29",
+                "level:30",
+                "level:31",
+                "level:32",
+            ],
+            "episode5": [
+                "level:33",
+                "level:34",
+                "level:35",
+                "level:36",
+                "level:37",
+                "level:38",
+                "level:39",
+                "level:40",
+                "level:41",
+                "level:42",
+                "level:43",
+            ],
+            "episode6": [
+                "level:44",
+                "level:45",
+                "level:46",
+                "level:47",
+                "level:48",
+                "level:49",
+                "level:50",
+            ],
+            "episode7": [
+                "level:53",
+                "level:78",
+                "level:79",
+                "level:80",
+                "level:81",
+                "level:82",
+                "level:83",
+                "level:84",
+                "level:54",
+                "level:55",
+            ],
+            "episode8": [
+                # "level:85",
+                # "level:52",
+                # "level:60",
+                # "level:86",
+                # "level:62",
+                # "level:87",
+                # "level:61",
+            ],
+            "episode9": [
+                "level:56",
+                "level:57",
+                "level:58",
+                "level:59",
+                "level:88",
+                "level:91",
+                "level:90",
+                "level:89",
+                "level:110",
+                "level:111",
+                "level:112",
+                "level:92",
+            ],
+            "episode10": [
+                "level:93",
+                "level:63",
+                "level:64",
+                "level:65",
+                "level:94",
+                "level:66",
+                "level:67",
+                "level:68",
+                "level:95",
+                "level:69",
+                "level:96",
+                "level:97",
+            ],
+            "episode11": [
+                "level:98",
+                "level:70",
+                "level:71",
+                "level:73",
+                "level:72",
+                "level:99",
+                "level:74",
+                "level:75",
+                "level:100",
+                "level:101",
+                "level:102",
+                "level:103",
+                "level:104",
+                "level:105",
+                "level:106",
+                "level:107",
+                "level:108",
+                "level:109",
+            ],
+            "level_control_submit": "",
+        }
+
+        c.login(username=email, password=password)
+
+        response = c.post(url, data)
+
+        assert response.status_code == 302
+
+        level1 = Level.objects.get(name=1)
+
+        assert klass1 in level1.locked_for_class.all()
+        assert klass2 not in level1.locked_for_class.all()
+        messages = list(response.wsgi_request._messages)
+        assert len(messages) == 1
+        assert str(messages[0]) == "Your level preferences have been saved."
+
+        # test the old analytic stays the same and the new one is incremented
+        assert DailyActivity.objects.get(date=old_date).level_control_submits == 0
+        assert DailyActivity.objects.get(date=datetime.now()).level_control_submits == 1
+
+        # Resubmitting to unlock level 1
+        data = {
+            "episode1": [
+                "level:1",
+                "level:2",
+                "level:3",
+                "level:4",
+                "level:5",
+                "level:6",
+                "level:7",
+                "level:8",
+                "level:9",
+                "level:10",
+                "level:11",
+                "level:12",
+            ],
+            "episode2": [
+                "level:13",
+                "level:14",
+                "level:15",
+                "level:16",
+                "level:17",
+                "level:18",
+            ],
+            "episode3": [
+                "level:19",
+                "level:20",
+                "level:21",
+                "level:22",
+                "level:23",
+                "level:24",
+                "level:25",
+                "level:26",
+                "level:27",
+                "level:28",
+            ],
+            "episode4": [
+                "level:29",
+                "level:30",
+                "level:31",
+                "level:32",
+            ],
+            "episode5": [
+                "level:33",
+                "level:34",
+                "level:35",
+                "level:36",
+                "level:37",
+                "level:38",
+                "level:39",
+                "level:40",
+                "level:41",
+                "level:42",
+                "level:43",
+            ],
+            "episode6": [
+                "level:44",
+                "level:45",
+                "level:46",
+                "level:47",
+                "level:48",
+                "level:49",
+                "level:50",
+            ],
+            "episode7": [
+                "level:53",
+                "level:78",
+                "level:79",
+                "level:80",
+                "level:81",
+                "level:82",
+                "level:83",
+                "level:84",
+                "level:54",
+                "level:55",
+            ],
+            "episode8": [
+                # "level:85",
+                # "level:52",
+                # "level:60",
+                # "level:86",
+                # "level:62",
+                # "level:87",
+                # "level:61",
+            ],
+            "episode9": [
+                "level:56",
+                "level:57",
+                "level:58",
+                "level:59",
+                "level:88",
+                "level:91",
+                "level:90",
+                "level:89",
+                "level:110",
+                "level:111",
+                "level:112",
+                "level:92",
+            ],
+            "episode10": [
+                "level:93",
+                "level:63",
+                "level:64",
+                "level:65",
+                "level:94",
+                "level:66",
+                "level:67",
+                "level:68",
+                "level:95",
+                "level:69",
+                "level:96",
+                "level:97",
+            ],
+            "episode11": [
+                "level:98",
+                "level:70",
+                "level:71",
+                "level:73",
+                "level:72",
+                "level:99",
+                "level:74",
+                "level:75",
+                "level:100",
+                "level:101",
+                "level:102",
+                "level:103",
+                "level:104",
+                "level:105",
+                "level:106",
+                "level:107",
+                "level:108",
+                "level:109",
+            ],
+            "level_control_submit": "",
+        }
+
+        response = c.post(url, data)
+
+        assert response.status_code == 302
+
+        level1 = Level.objects.get(name=1)
+
+        assert klass1 not in level1.locked_for_class.all()
+        assert klass2 not in level1.locked_for_class.all()
+
     def test_transfer_class(self):
         email1, password1 = signup_teacher_directly()
         email2, password2 = signup_teacher_directly()
-        school_name, postcode = create_organisation_directly(email1)
-        join_teacher_to_organisation(email2, school_name, postcode)
+        school = create_organisation_directly(email1)
+        join_teacher_to_organisation(email2, school.name)
         klass1, _, access_code1 = create_class_directly(email1)
         klass2, _, access_code2 = create_class_directly(email2)
         _, _, student1 = create_school_student_directly(access_code1)
@@ -158,29 +482,43 @@ class TestClassFrontend(BaseTest):
     def test_create(self):
         email, password = signup_teacher_directly()
         create_organisation_directly(email)
-        page = (
-            self.go_to_homepage()
-            .go_to_teacher_login_page()
-            .login_no_class(email, password)
-        )
+        page = self.go_to_homepage().go_to_teacher_login_page().login_no_class(email, password).open_classes_tab()
 
         assert page.does_not_have_classes()
 
         page, class_name = create_class(page)
         assert is_class_created_message_showing(self.selenium, class_name)
 
+    def test_create_class_as_admin_for_another_teacher(self):
+        email1, password1 = signup_teacher_directly()
+        email2, password2 = signup_teacher_directly()
+        teacher2 = Teacher.objects.get(new_user__email=email2)
+        school = create_organisation_directly(email1)
+        join_teacher_to_organisation(email2, school.name)
+
+        # Check teacher 2 doesn't have any classes
+        page = self.go_to_homepage().go_to_teacher_login_page().login(email2, password2).open_classes_tab()
+        assert page.does_not_have_classes()
+        page.logout()
+
+        # Log in as the first teacher and create a class for the second one
+        page = self.go_to_homepage().go_to_teacher_login_page().login(email1, password1).open_classes_tab()
+        page, class_name = create_class(page, teacher_id=teacher2.id)
+        page = TeachClassPage(page.browser)
+        assert is_class_created_message_showing(self.selenium, class_name)
+        page.logout()
+
+        # Check teacher 2 now has the class
+        page = self.go_to_homepage().go_to_teacher_login_page().login(email2, password2).open_classes_tab()
+        assert page.has_classes()
+
     def test_create_dashboard(self):
         email, password = signup_teacher_directly()
         create_organisation_directly(email)
         klass, name, access_code = create_class_directly(email)
         create_school_student_directly(access_code)
 
-        page = (
-            self.go_to_homepage()
-            .go_to_teacher_login_page()
-            .login(email, password)
-            .open_classes_tab()
-        )
+        page = self.go_to_homepage().go_to_teacher_login_page().login(email, password).open_classes_tab()
 
         page, class_name = create_class(page)
 
@@ -189,20 +527,32 @@ class TestClassFrontend(BaseTest):
     def test_create_dashboard_non_admin(self):
         email_1, password_1 = signup_teacher_directly()
         email_2, password_2 = signup_teacher_directly()
-        name, postcode = create_organisation_directly(email_1)
+        school = create_organisation_directly(email_1)
         klass_1, class_name_1, access_code_1 = create_class_directly(email_1)
         create_school_student_directly(access_code_1)
-        join_teacher_to_organisation(email_2, name, postcode)
+        join_teacher_to_organisation(email_2, school.name)
         klass_2, class_name_2, access_code_2 = create_class_directly(email_2)
         create_school_student_directly(access_code_2)
 
-        page = (
-            self.go_to_homepage()
-            .go_to_teacher_login_page()
-            .login(email_2, password_2)
-            .open_classes_tab()
-        )
+        page = self.go_to_homepage().go_to_teacher_login_page().login(email_2, password_2).open_classes_tab()
 
         page, class_name_3 = create_class(page)
 
         assert is_class_created_message_showing(self.selenium, class_name_3)
+
+    def test_create_invalid_name(self):
+        email, password = signup_teacher_directly()
+        create_organisation_directly(email)
+
+        class_name = "Class!"
+
+        self.selenium.get(self.live_server_url)
+        page = HomePage(self.selenium).go_to_teacher_login_page().login_no_class(email, password).open_classes_tab()
+
+        page = page.create_class(class_name, False)
+
+        time.sleep(1)
+
+        assert page.was_form_invalid(
+            "form-create-class", "Class name may only contain letters, numbers, dashes, underscores, and spaces."
+        )

portal/tests/test_emails.py

@@ -2,23 +2,29 @@ import datetime
 
 import pytest
 from common.helpers.emails import (
+    add_consent_record_to_dotmailer_user,
+    add_contact_to_address_book,
     add_to_dotmailer,
     create_contact,
-    add_contact_to_address_book,
-    add_consent_record_to_dotmailer_user,
+    delete_contact,
     send_dotmailer_consent_confirmation_email_to_user,
+    DotmailerUserType,
 )
-from django.core import mail
+from common.mail import address_book_ids
 from django.test import Client
 from django.urls import reverse
-from test_settings import (
+
+from example_project.portal_test_settings import (
     DOTMAILER_USER,
     DOTMAILER_PASSWORD,
     DOTMAILER_SEND_CAMPAIGN_URL,
     DOTMAILER_PUT_CONSENT_DATA_URL,
     DOTMAILER_THANKS_FOR_STAYING_CAMPAIGN_ID,
     DOTMAILER_CREATE_CONTACT_URL,
-    DOTMAILER_ADDRESS_BOOK_URL,
+    DOTMAILER_DELETE_USER_BY_ID_URL,
+    DOTMAILER_TEACHER_ADDRESS_BOOK_URL,
+    DOTMAILER_STUDENT_ADDRESS_BOOK_URL,
+    DOTMAILER_NO_ACCOUNT_ADDRESS_BOOK_URL,
 )
 
 FAKE_TIME = datetime.datetime(2020, 12, 25, 17, 5, 55)
@@ -34,26 +40,25 @@ def patch_datetime_now(monkeypatch):
     monkeypatch.setattr(datetime, "datetime", mydatetime)
 
 
-@pytest.mark.django_db
-def test_send_new_users_numbers_email():
-    client = Client()
-    response = client.get(reverse("send_new_users_report"))
-    assert response.status_code == 200
-    assert len(mail.outbox) == 1
-
-
 def test_newsletter_calls_correct_requests(mocker, monkeypatch):
     mocked_create_contact = mocker.patch("common.helpers.emails.create_contact")
     mocked_add_to_address_book = mocker.patch(
         "common.helpers.emails.add_contact_to_address_book"
     )
 
-    add_to_dotmailer("Ray", "Charles", "ray.charles@example.com")
+    add_to_dotmailer(
+        "Ray",
+        "Charles",
+        "ray.charles@example.com",
+        address_book_ids["newsletter"],
+        DotmailerUserType.TEACHER,
+    )
 
     mocked_create_contact.assert_called_once()
     mocked_add_to_address_book.assert_called_once()
 
 
+@pytest.mark.django_db
 def test_newsletter_get_not_allowed():
     c = Client()
 
@@ -62,7 +67,21 @@ def test_newsletter_get_not_allowed():
     assert response.status_code == 405
 
 
-def test_newsletter_sends_correct_request_data(mocker, monkeypatch, patch_datetime_now):
+def test_delete_account(mocker):
+    mocked_delete = mocker.patch("common.helpers.emails.delete")
+    mocker.patch("common.helpers.emails.get_dotmailer_user_by_email")
+
+    delete_contact("example@mail.com")
+
+    mocked_delete.assert_called_once_with(
+        DOTMAILER_DELETE_USER_BY_ID_URL,
+        auth=(DOTMAILER_USER, DOTMAILER_PASSWORD),
+    )
+
+
+def test_newsletter_sends_correct_request_data(
+    mocker, monkeypatch, patch_datetime_now
+):
     mocked_post = mocker.patch("common.helpers.emails.post")
 
     expected_body1 = {
@@ -79,7 +98,7 @@ def test_newsletter_sends_correct_request_data(mocker, monkeypatch, patch_dateti
         "consentFields": [
             {
                 "fields": [
-                    {"key": "DATETIMECONSENTED", "value": FAKE_TIME.__str__()},
+                    {"key": "DATETIMECONSENTED", "value": FAKE_TIME.__str__()}
                 ]
             }
         ],
@@ -105,10 +124,54 @@ def test_newsletter_sends_correct_request_data(mocker, monkeypatch, patch_dateti
         json=expected_body1,
     )
 
-    add_contact_to_address_book("Ray", "Charles", "ray.charles@example.com")
+    add_contact_to_address_book(
+        "Ray",
+        "Charles",
+        "ray.charles@example.com",
+        address_book_ids["newsletter"],
+        DotmailerUserType.TEACHER,
+    )
 
-    mocked_post.assert_called_with(
-        DOTMAILER_ADDRESS_BOOK_URL,
+    assert mocked_post.call_count == 3
+
+    mocked_post.assert_any_call(
+        DOTMAILER_TEACHER_ADDRESS_BOOK_URL,
+        auth=(DOTMAILER_USER, DOTMAILER_PASSWORD),
+        json=expected_body2,
+    )
+
+    mocked_post.reset_mock()
+
+    add_contact_to_address_book(
+        "Ray",
+        "Charles",
+        "ray.charles@example.com",
+        address_book_ids["newsletter"],
+        DotmailerUserType.STUDENT,
+    )
+
+    assert mocked_post.call_count == 2
+
+    mocked_post.assert_any_call(
+        DOTMAILER_STUDENT_ADDRESS_BOOK_URL,
+        auth=(DOTMAILER_USER, DOTMAILER_PASSWORD),
+        json=expected_body2,
+    )
+
+    mocked_post.reset_mock()
+
+    add_contact_to_address_book(
+        "Ray",
+        "Charles",
+        "ray.charles@example.com",
+        address_book_ids["newsletter"],
+        DotmailerUserType.NO_ACCOUNT,
+    )
+
+    assert mocked_post.call_count == 2
+
+    mocked_post.assert_any_call(
+        DOTMAILER_NO_ACCOUNT_ADDRESS_BOOK_URL,
         auth=(DOTMAILER_USER, DOTMAILER_PASSWORD),
         json=expected_body2,
     )
@@ -147,7 +210,7 @@ def test_consent_calls_send_correct_request_data(
         "consentFields": [
             {
                 "fields": [
-                    {"key": "DATETIMECONSENTED", "value": FAKE_TIME.__str__()},
+                    {"key": "DATETIMECONSENTED", "value": FAKE_TIME.__str__()}
                 ]
             }
         ],

portal/tests/{test_newsletter_footer.py → test_global_forms.py}

@@ -2,19 +2,19 @@ from django.urls import reverse
 from django.test import TestCase, Client
 
 
-class TestNewsletterFooter(TestCase):
+class TestGlobalForms(TestCase):
     def test_newsletter_signup_successful(self):
         url = reverse("process_newsletter_form")
         client = Client()
-        data = {"email": "valid_email@example.com"}
+        data = {"email": "valid_email@example.com", "age_verification": "on"}
         response = client.post(url, data)
         messages = list(response.wsgi_request._messages)
-        self.assertEquals(1, len([m for m in messages if m.tags == "success"]))
+        assert len([m for m in messages if m.tags == "success"]) == 1
 
     def test_newsletter_signup_fail(self):
         url = reverse("process_newsletter_form")
         client = Client()
-        data = {"email": "invalid_email"}
+        data = {"email": "invalid_email", "age_verification": "on"}
         response = client.post(url, data)
         messages = list(response.wsgi_request._messages)
-        self.assertEquals(1, len([m for m in messages if "error" in m.tags]))
+        assert len([m for m in messages if "error" in m.tags]) == 1

portal/tests/test_helper_methods.py

@@ -0,0 +1,30 @@
+import hashlib
+from unittest.mock import patch, Mock
+
+from portal.helpers.password import is_password_pwned
+
+
+class TestClass:
+    def test_is_password_pwned(self):
+        weak_password = "Password123$"
+        strong_password = "£EDCVFR$%TGBnhy667ujm"
+        assert is_password_pwned(weak_password)
+        assert not is_password_pwned(strong_password)
+
+    @patch("requests.get")
+    def test_is_password_pwned__status_code_not_200(self, mock_get):
+        # Arrange
+        password = "password123"
+        sha1_hash = hashlib.sha1(password.encode()).hexdigest()
+
+        mock_response = Mock()
+        mock_response.status_code = 500
+
+        mock_get.return_value = mock_response
+
+        # Act
+        result = is_password_pwned(password)
+
+        # Assert
+        mock_get.assert_called_once_with(f"https://api.pwnedpasswords.com/range/{sha1_hash[:5]}")
+        assert not result