rapid-router 5.18.0__py2.py3-none-any.whl → 7.6.8__py2.py3-none-any.whl

game/tests/test_level_selection.py

@@ -57,16 +57,16 @@ class LevelSelectionTestCase(TestCase):
     def level_data(self, levelID):
         data = {
             "origin": '{"coordinate":[3,5],"direction":"S"}',
-            "pythonEnabled": False,
+            "python_enabled": False,
             "decor": [],
-            "blocklyEnabled": True,
+            "blockly_enabled": True,
             "blocks": [
                 {"type": "move_forwards"},
                 {"type": "turn_left"},
                 {"type": "turn_right"},
             ],
             "max_fuel": "50",
-            "pythonViewEnabled": False,
+            "python_view_enabled": False,
             "character": "3",
             "name": f"level{levelID}",
             "theme": 1,
@@ -83,8 +83,23 @@ class LevelSelectionTestCase(TestCase):
         response = self.client.get(url)
 
         assert response.status_code == 200
-        assert response.context["blocklyEpisodes"][0]["name"] == "Getting Started"
-        assert response.context["blocklyEpisodes"][0]["levels"][0]["title"] == "Can you help the van get to the house?"
+        assert (
+            response.context["blocklyEpisodes"][0]["name"] == "Getting Started"
+        )
+        assert (
+            response.context["blocklyEpisodes"][0]["levels"][0]["title"]
+            == "Can you help the van get to the house?"
+        )
+
+    def test_list_python_episodes(self):
+        url = reverse("python_levels")
+        response = self.client.get(url)
+
+        assert response.status_code == 200
+        assert (
+            response.context["pythonEpisodes"][0]["name"]
+            == "Output, Operators, and Data"
+        )
 
     def test_custom_levels_access(self):
         email1, password1 = signup_teacher_directly()
@@ -100,41 +115,55 @@ class LevelSelectionTestCase(TestCase):
         # Create a class and a student for each teacher
         _, class_name1, access_code1 = create_class_directly(email1)
         _, class_name2, access_code2 = create_class_directly(email2)
-        student_name1, student_password1, student1 = create_school_student_directly(access_code1)
-        student_name2, student_password2, student2 = create_school_student_directly(access_code2)
+        (
+            student_name1,
+            student_password1,
+            student1,
+        ) = create_school_student_directly(access_code1)
+        (
+            student_name2,
+            student_password2,
+            student2,
+        ) = create_school_student_directly(access_code2)
 
         save_url = "save_level_for_editor"
 
-        # Login as the second teacher
+        # Log in as the second teacher
         self.login(email2, password2)
         teacher2_level = create_save_level(teacher2)
         save_level_url = reverse(save_url)
 
-        response = self.client.post(save_level_url, {"data": self.level_data(teacher2_level.id)})
+        response = self.client.post(
+            save_level_url, {"data": self.level_data(teacher2_level.id)}
+        )
 
         assert response.status_code == 200
 
-        # Login as the first student
+        # Log in as the first student
         self.logout()
         self.student_login(student_name1, access_code1, student_password1)
 
         student1_level = create_save_level(student1)
 
-        response = self.client.post(save_level_url, {"data": self.level_data(student1_level.id)})
+        response = self.client.post(
+            save_level_url, {"data": self.level_data(student1_level.id)}
+        )
 
         assert response.status_code == 200
 
-        # Login as the second student
+        # Log in as the second student
         self.logout()
         self.student_login(student_name2, access_code2, student_password2)
 
         student2_level = create_save_level(student2)
 
-        response = self.client.post(save_level_url, {"data": self.level_data(student2_level.id)})
+        response = self.client.post(
+            save_level_url, {"data": self.level_data(student2_level.id)}
+        )
 
         assert response.status_code == 200
 
-        # Login as first teacher again and check they have access to all the levels created above
+        # Log in as first teacher again and check they have access to all the levels created above
         self.logout()
         self.login(email1, password1)
 
@@ -143,13 +172,29 @@ class LevelSelectionTestCase(TestCase):
 
         assert response.status_code == 200
         assert len(response.context["directly_shared_levels"]) == 1
-        assert response.context["directly_shared_levels"][0]["owner"] == student1.new_user
+        assert (
+            response.context["directly_shared_levels"][0]["owner"]
+            == student1.new_user
+        )
         assert response.context["indirectly_shared_levels"][teacher2.new_user]
-        assert len(response.context["indirectly_shared_levels"][teacher2.new_user]) == 2
-        assert response.context["indirectly_shared_levels"][teacher2.new_user][0]["owner"] == teacher2.new_user
-        assert response.context["indirectly_shared_levels"][teacher2.new_user][1]["owner"] == student2.new_user
+        assert (
+            len(response.context["indirectly_shared_levels"][teacher2.new_user])
+            == 2
+        )
+        assert (
+            response.context["indirectly_shared_levels"][teacher2.new_user][0][
+                "owner"
+            ]
+            == teacher2.new_user
+        )
+        assert (
+            response.context["indirectly_shared_levels"][teacher2.new_user][1][
+                "owner"
+            ]
+            == student2.new_user
+        )
 
-        # Login as second teacher again and check they have access to only their student's level
+        # Log in as second teacher again and check they have access to only their student's level
         self.logout()
         self.login(email2, password2)
 
@@ -158,7 +203,10 @@ class LevelSelectionTestCase(TestCase):
 
         assert response.status_code == 200
         assert len(response.context["directly_shared_levels"]) == 1
-        assert response.context["directly_shared_levels"][0]["owner"] == student2.new_user
+        assert (
+            response.context["directly_shared_levels"][0]["owner"]
+            == student2.new_user
+        )
         assert response.context["indirectly_shared_levels"] == {}
 
     def test_cannot_access_locked_level(self):
@@ -196,51 +244,106 @@ class LevelSelectionTestCase(TestCase):
         level2 = Level.objects.get(name="2")
         level3 = Level.objects.get(name="3")
         level4 = Level.objects.get(name="4")
-        level106 = Level.objects.get(name="106")
-        level107 = Level.objects.get(name="107")
-        level108 = Level.objects.get(name="108")
-        level109 = Level.objects.get(name="109")
+        level76 = Level.objects.get(name="76")
+        level77 = Level.objects.get(name="77")
+        level78 = Level.objects.get(name="78")
+        level79 = Level.objects.get(name="79")
+        level1014 = Level.objects.get(name="1014")
+        level1015 = Level.objects.get(name="1015")
+        level1016 = Level.objects.get(name="1016")
 
         level2.locked_for_class.add(klass)
         level3.locked_for_class.add(klass)
-        level107.locked_for_class.add(klass)
-        level108.locked_for_class.add(klass)
-        level109.locked_for_class.add(klass)
+        level77.locked_for_class.add(klass)
+        level78.locked_for_class.add(klass)
+        level1015.locked_for_class.add(klass)
 
-        next_level_url = _next_level_url(level1, student.new_user, False)
+        next_level_url = _next_level_url(level1, student.new_user, False, False)
 
         assert next_level_url == f"/rapidrouter/{level4.name}/"
 
-        prev_level_url = _prev_level_url(level4, student.new_user, False)
+        prev_level_url = _prev_level_url(level4, student.new_user, False, False)
         assert prev_level_url == f"/rapidrouter/{level1.name}/"
 
-        next_level_url = _next_level_url(level106, student.new_user, False)
+        next_level_url = _next_level_url(
+            level76, student.new_user, False, False
+        )
+
+        assert next_level_url == f"/rapidrouter/{level79.name}/"
 
-        assert next_level_url == f"/rapidrouter/{level109.name}/"
+        prev_level_url = _prev_level_url(
+            level79, student.new_user, False, False
+        )
+        assert prev_level_url == f"/rapidrouter/{level76.name}/"
+
+        next_level_url = _next_level_url(
+            level1014, student.new_user, False, True
+        )
 
-        prev_level_url = _prev_level_url(level109, student.new_user, False)
-        assert prev_level_url == f"/rapidrouter/{level106.name}/"
+        assert next_level_url == f"/pythonden/16/"
+
+        prev_level_url = _prev_level_url(
+            level1016, student.new_user, False, True
+        )
+        assert prev_level_url == f"/pythonden/14/"
 
-    @patch("game.views.level.datetime", side_effect=lambda *args, **kw: datetime(*args, **kw))
+    @patch(
+        "game.views.level.datetime",
+        side_effect=lambda *args, **kw: datetime(*args, **kw),
+    )
     def test_xmas_theme(self, mock_datetime):
         november = datetime(2023, 11, 1, 0, 0, 0, 0)
         mock_datetime.now.return_value = november
 
         response = self.client.get(f"{reverse('home')}/rapidrouter/1/")
-        assert """CHARACTER_NAME = "Van"\n""" in response.content.decode("utf-8")
-        assert """CHARACTER_URL = "characters/top_view/Van.svg"\n""" in response.content.decode("utf-8")
-        assert """WRECKAGE_URL = "van_wreckage.svg"\n""" in response.content.decode("utf-8")
-        assert """BACKGROUND_URL = "decor/grass/tile1.svg"\n""" in response.content.decode("utf-8")
-        assert """HOUSE_URL = "decor/grass/house.svg"\n""" in response.content.decode("utf-8")
-        assert """CFC_URL = "decor/grass/cfc.svg"\n""" in response.content.decode("utf-8")
+        assert """CHARACTER_NAME = "Van"\n""" in response.content.decode(
+            "utf-8"
+        )
+        assert (
+            """CHARACTER_URL = "characters/top_view/Van.svg"\n"""
+            in response.content.decode("utf-8")
+        )
+        assert (
+            """WRECKAGE_URL = "van_wreckage.svg"\n"""
+            in response.content.decode("utf-8")
+        )
+        assert (
+            """BACKGROUND_URL = "decor/grass/tile1.svg"\n"""
+            in response.content.decode("utf-8")
+        )
+        assert (
+            """HOUSE_URL = "decor/grass/house.svg"\n"""
+            in response.content.decode("utf-8")
+        )
+        assert (
+            """CFC_URL = "decor/grass/cfc.svg"\n"""
+            in response.content.decode("utf-8")
+        )
 
         december = datetime(2023, 12, 1, 0, 0, 0, 0)
         mock_datetime.now.return_value = december
 
         response = self.client.get(f"{reverse('home')}/rapidrouter/1/")
-        assert """CHARACTER_NAME = "Van"\n""" in response.content.decode("utf-8")
-        assert """CHARACTER_URL = "characters/top_view/Sleigh.svg"\n""" in response.content.decode("utf-8")
-        assert """WRECKAGE_URL = "sleigh_wreckage.svg"\n""" in response.content.decode("utf-8")
-        assert """BACKGROUND_URL = "decor/snow/tile1.svg"\n""" in response.content.decode("utf-8")
-        assert """HOUSE_URL = "decor/snow/house.svg"\n""" in response.content.decode("utf-8")
-        assert """CFC_URL = "decor/snow/cfc.svg"\n""" in response.content.decode("utf-8")
+        assert """CHARACTER_NAME = "Van"\n""" in response.content.decode(
+            "utf-8"
+        )
+        assert (
+            """CHARACTER_URL = "characters/top_view/Sleigh.svg"\n"""
+            in response.content.decode("utf-8")
+        )
+        assert (
+            """WRECKAGE_URL = "sleigh_wreckage.svg"\n"""
+            in response.content.decode("utf-8")
+        )
+        assert (
+            """BACKGROUND_URL = "decor/snow/tile1.svg"\n"""
+            in response.content.decode("utf-8")
+        )
+        assert (
+            """HOUSE_URL = "decor/snow/house.svg"\n"""
+            in response.content.decode("utf-8")
+        )
+        assert (
+            """CFC_URL = "decor/snow/cfc.svg"\n"""
+            in response.content.decode("utf-8")
+        )

game/tests/test_python_den_worksheet.py

@@ -0,0 +1,85 @@
+from deploy import captcha
+from django.test.client import Client
+from django.test.testcases import TestCase
+from django.urls import reverse
+
+from game import messages
+from game.models import Worksheet
+
+
+class PythonDenWorksheetTestCase(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.orig_captcha_enabled = captcha.CAPTCHA_ENABLED
+        captcha.CAPTCHA_ENABLED = False
+        super(PythonDenWorksheetTestCase, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        captcha.CAPTCHA_ENABLED = cls.orig_captcha_enabled
+        super(PythonDenWorksheetTestCase, cls).tearDownClass()
+
+    def setUp(self):
+        self.client = Client()
+
+    def login(self, email, password):
+        self.client.post(
+            reverse("teacher_login"),
+            {
+                "auth-username": email,
+                "auth-password": password,
+                "teacher_login_view-current_step": "auth",
+            },
+            follow=True,
+        )
+
+    def logout(self):
+        self.client.post(reverse("logout_view"), follow=True)
+
+    def student_login(self, name, access_code, password):
+        self.client.post(
+            reverse("student_login", kwargs={"access_code": access_code}),
+            {"username": name, "password": password},
+            follow=True,
+        )
+
+    def independent_student_login(self, email, password):
+        self.client.login(username=email, password=password)
+
+    def test_page_permissions(self):
+        response = self.client.get(reverse("worksheet", args="1"))
+
+        assert response.status_code == 200
+        assert (
+            response.context["title"]
+            == messages.no_permission_python_den_worksheet_title()
+        )
+        assert (
+            response.context["message"]
+            == messages.no_permission_python_den_worksheet_page()
+        )
+
+        self.login("alberteinstein@codeforlife.com", "Password1")
+
+        response = self.client.get(reverse("worksheet", args="1"))
+
+        assert response.status_code == 200
+        assert response.context["worksheet"] == Worksheet.objects.get(pk=1)
+
+        self.logout()
+        self.student_login("Leonardo", "AB123", "Password1")
+
+        response = self.client.get(reverse("worksheet", args="1"))
+
+        assert response.status_code == 200
+        assert response.context["worksheet"] == Worksheet.objects.get(pk=1)
+
+        self.logout()
+        self.independent_student_login("indianajones@codeforlife.com", "Password1")
+
+        response = self.client.get(reverse("worksheet", args="1"))
+
+        assert response.status_code == 200
+        assert response.context["worksheet"] == Worksheet.objects.get(pk=1)
+
+        self.logout()

game/tests/test_scoreboard.py

@@ -5,7 +5,7 @@ from datetime import datetime, timedelta
 
 from common.models import Class, Teacher, Student
 from common.tests.utils.classes import create_class_directly
-from common.tests.utils.organisation import create_organisation_directly
+from common.tests.utils.organisation import create_organisation_directly, join_teacher_to_organisation
 from common.tests.utils.student import (
     create_school_student_directly,
     create_independent_student_directly,
@@ -80,7 +80,7 @@ class ScoreboardTestCase(TestCase):
 
         # Generate results
         student_data, headers, level_headers, levels_sorted = scoreboard_data(
-            episode_ids, attempts_per_student
+            episode_ids, attempts_per_student, "blockly"
         )
         (
             shared_headers,
@@ -153,7 +153,31 @@ class ScoreboardTestCase(TestCase):
 
         response = c.post(url, data)
 
-        active_levels = Level.objects.filter(episode__in_development=False)
+        active_levels = Level.objects.filter(episode__pk__in=range(1, 10))
+
+        assert response.status_code == 200
+        assert len(response.context["level_headers"]) == active_levels.count()
+
+    def test_python_scoreboard_loads(self):
+        email, password = signup_teacher_directly()
+        create_organisation_directly(email)
+        klass, name, access_code = create_class_directly(email)
+        create_school_student_directly(access_code)
+
+        url = reverse("python_scoreboard")
+        c = Client()
+        c.login(username=email, password=password)
+
+        # test scoreboard page loads properly
+        response = c.get(url)
+        assert response.status_code == 200
+
+        # test scoreboard shows all episodes if no episodes are manually selected
+        data = {"classes": [klass.id], "view": [""]}
+
+        response = c.post(url, data)
+
+        active_levels = Level.objects.filter(episode__pk__in=range(12, 16))
 
         assert response.status_code == 200
         assert len(response.context["level_headers"]) == active_levels.count()
@@ -186,15 +210,18 @@ class ScoreboardTestCase(TestCase):
 
     def test_admin_teacher_can_see_all_classes(self):
         """An admin should be able to see all classes, not just the ones they teach"""
+        teacher_email = "normal@school.edu"
+        admin_email = "admin@school.edu"
+
         normal_teacher = Teacher.objects.factory(
-            "Normal", "Teacher", "normal@school.edu", "secretpa$sword"
+            "Normal", "Teacher", teacher_email, "secretpa$sword"
         )
         admin_teacher = Teacher.objects.factory(
-            "Admin", "Admin", "admin@school.edu", "secretpa$sword2"
+            "Admin", "Admin", admin_email, "secretpa$sword2"
         )
 
-        admin_teacher.is_admin = True
-        admin_teacher.save()
+        school = create_organisation_directly(admin_email)
+        join_teacher_to_organisation(teacher_email, school.name)
 
         _, name1, _ = create_class_directly(
             admin_teacher.user.user.email, class_name="Class 1"

game/tests/utils/level.py

@@ -2,19 +2,42 @@ import game.level_management as level_management
 from game.models import Level
 
 
+multiple_house_data = {
+    "origin": '{"coordinate":[3,5],"direction":"S"}',
+    "python_enabled": False,
+    "decor": [],
+    "blockly_enabled": True,
+    "blocks": [
+        {"type": "move_forwards"},
+        {"type": "turn_left"},
+        {"type": "turn_right"},
+    ],
+    "max_fuel": "50",
+    "python_view_enabled": False,
+    "character": "3",
+    "name": "2",
+    "theme": 1,
+    "anonymous": False,
+    "cows": "[]",
+    "path": '[{"coordinate":[3,5],"connectedNodes":[1]},{"coordinate":[3,4],"connectedNodes":[0,2]}, {"coordinate": [3,3], "connectedNodes":[1]}]',
+    "traffic_lights": "[]",
+    "destinations": "[[3,4], [3,3]]",
+}
+
+
 def create_save_level(teacher_or_student, level_name="1", shared_with=None):
     data = {
         "origin": '{"coordinate":[3,5],"direction":"S"}',
-        "pythonEnabled": False,
+        "python_enabled": False,
         "decor": [],
-        "blocklyEnabled": True,
+        "blockly_enabled": True,
         "blocks": [
             {"type": "move_forwards"},
             {"type": "turn_left"},
             {"type": "turn_right"},
         ],
         "max_fuel": "50",
-        "pythonViewEnabled": False,
+        "python_view_enabled": False,
         "character": "3",
         "name": level_name,
         "theme": 1,
@@ -27,6 +50,10 @@ def create_save_level(teacher_or_student, level_name="1", shared_with=None):
     level = Level(default=False, anonymous=data["anonymous"])
     level.owner = teacher_or_student.user
     level_management.save_level(level, data)
+
+    if hasattr(level.owner, "teacher"):
+        level.needs_approval = False
+
     level.save()
 
     if shared_with is not None:
@@ -37,30 +64,9 @@ def create_save_level(teacher_or_student, level_name="1", shared_with=None):
     return level
 
 def create_save_level_with_multiple_houses(teacher_or_student, level_name="2", shared_with=None):
-    data = {
-        "origin": '{"coordinate":[3,5],"direction":"S"}',
-        "pythonEnabled": False,
-        "decor": [],
-        "blocklyEnabled": True,
-        "blocks": [
-            {"type": "move_forwards"},
-            {"type": "turn_left"},
-            {"type": "turn_right"},
-        ],
-        "max_fuel": "50",
-        "pythonViewEnabled": False,
-        "character": "3",
-        "name": level_name,
-        "theme": 1,
-        "anonymous": False,
-        "cows": "[]",
-        "path": '[{"coordinate":[3,5],"connectedNodes":[1]},{"coordinate":[3,4],"connectedNodes":[0,2]}, {"coordinate": [3,3], "connectedNodes":[1]}]',
-        "traffic_lights": "[]",
-        "destinations": "[[3,4], [3,3]]",
-    }
-    level = Level(default=False, anonymous=data["anonymous"])
+    level = Level(default=False, anonymous=multiple_house_data["anonymous"])
     level.owner = teacher_or_student.user
-    level_management.save_level(level, data)
+    level_management.save_level(level, multiple_house_data)
     level.save()
 
     if shared_with is not None:

game/theme.py

@@ -4,7 +4,7 @@
 
 from builtins import object
 from rest_framework.reverse import reverse
-from django.utils.translation import ugettext
+from django.utils.translation import gettext
 
 
 class Theme(object):
@@ -20,7 +20,7 @@ class Theme(object):
 THEME_DATA = {
     "grass": Theme(
         name="grass",
-        text=ugettext("Grass"),
+        text=gettext("Grass"),
         selected="#bce369",
         background="#a0c53a",
         border="#70961f",
@@ -28,7 +28,7 @@ THEME_DATA = {
     ),
     "snow": Theme(
         name="snow",
-        text=ugettext("Snow"),
+        text=gettext("Snow"),
         selected="#b3deff",
         background="#eef7ff",
         border="#83c9fe",
@@ -36,7 +36,7 @@ THEME_DATA = {
     ),
     "farm": Theme(
         name="farm",
-        text=ugettext("Farm"),
+        text=gettext("Farm"),
         selected="#bce369",
         background="#a0c53a",
         border="#70961f",
@@ -44,7 +44,7 @@ THEME_DATA = {
     ),
     "city": Theme(
         name="city",
-        text=ugettext("City"),
+        text=gettext("City"),
         selected="#C1C1C1",
         background="#969696",
         border="#686868",