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

game/tests/test_scoreboard.py

@@ -5,45 +5,92 @@ 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.student import create_school_student_directly, create_independent_student_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,
+)
 from common.tests.utils.teacher import signup_teacher_directly
 from django.test import Client, TestCase
 from django.urls import reverse
 
 from game.models import Attempt, Level, Episode
 from game.tests.utils.level import create_save_level
-from game.views.scoreboard import StudentRow, scoreboard_data, Headers, StudentInTrouble, shared_level_to_name
-from game.views.scoreboard_csv import scoreboard_csv, Headers as CSVHeaders, SharedHeaders as CSVSharedHeaders
+from game.views.scoreboard import (
+    StudentRow,
+    scoreboard_data,
+    Headers,
+    StudentInTrouble,
+    shared_level_to_name,
+    shared_levels_data,
+    SharedHeaders,
+)
+from game.views.scoreboard_csv import (
+    scoreboard_csv,
+    Headers as CSVHeaders,
+    SharedHeaders as CSVSharedHeaders,
+)
 
 
 class ScoreboardTestCase(TestCase):
     def test_teacher_multiple_students_multiple_levels(self):
-        episode_ids = [1]
+        # Setup official levels data
+        episode_ids = [1, 2]
         episode1 = Episode.objects.get(id=1)
-        level_ids = [f"{x}" for x in range(1, len(episode1.levels) + 1)]
+        episode2 = Episode.objects.get(id=2)
+        level_ids = [
+            f"{x}"
+            for x in range(1, len(episode1.levels) + len(episode2.levels) + 1)
+        ]
         level1 = Level.objects.get(name="1")
-        level2 = Level.objects.get(name="2")
+        level13 = Level.objects.get(name="13")
 
         clas, student, student2 = set_up_data()
 
-        create_attempt(student, level1, 10)
+        create_attempt(student, level1, 20)
         create_attempt(student2, level1, 2)
-        create_attempt(student2, level2, 16)
+        create_attempt(student2, level13, 16)
 
-        all_levels = [level1, level2]
+        # Setup custom levels data
+        shared_level = create_save_level(
+            student, "custom_level1", shared_with=[student2.new_user]
+        )
+
+        create_attempt(student2, shared_level, 10)
+
+        all_levels = [level1, level13]
+        all_shared_levels = [shared_level]
 
         attempts_per_student = {
-            student: Attempt.objects.filter(level__in=all_levels, student=student, is_best_attempt=True).select_related(
-                "level"
-            ),
+            student: Attempt.objects.filter(
+                level__in=all_levels, student=student, is_best_attempt=True
+            ).select_related("level"),
             student2: Attempt.objects.filter(
                 level__in=all_levels, student=student2, is_best_attempt=True
             ).select_related("level"),
         }
 
-        student_data, headers, level_headers, levels_sorted = scoreboard_data(episode_ids, attempts_per_student)
+        shared_attempts_per_student = {
+            student2: Attempt.objects.filter(
+                level__in=all_shared_levels,
+                student=student2,
+                is_best_attempt=True,
+            ).select_related("level"),
+        }
+
+        # Generate results
+        student_data, headers, level_headers, levels_sorted = scoreboard_data(
+            episode_ids, attempts_per_student, "blockly"
+        )
+        (
+            shared_headers,
+            shared_level_headers,
+            shared_student_data,
+        ) = shared_levels_data(
+            student.new_user, all_shared_levels, shared_attempts_per_student
+        )
 
+        # Check data for official levels matches
         assert headers == Headers
         assert level_headers == [f"L{id}" for id in level_ids]
 
@@ -52,21 +99,40 @@ class ScoreboardTestCase(TestCase):
         student_row = student_data[0]
         assert student_row.class_field.name == clas.name
         assert student_row.name == student.user.user.first_name
-        assert student_row.total_score == 10
+        assert student_row.total_score == 20
         assert student_row.total_time == timedelta(0)
-        assert student_row.level_scores[1]["score"] == 10
+        assert student_row.level_scores[all_levels[0].id]["score"] == 20
         assert student_row.completed == 1
-        assert student_row.percentage_complete == 50.0
+        assert student_row.success_rate == 100.0
 
         student_row = student_data[1]
         assert student_row.class_field.name == clas.name
         assert student_row.name == student2.user.user.first_name
         assert student_row.total_score == 18
         assert student_row.total_time == timedelta(0)
-        assert student_row.level_scores[1]["score"] == 2
-        assert student_row.level_scores[2]["score"] == 16
+        assert student_row.level_scores[all_levels[0].id]["score"] == 2
+        assert student_row.level_scores[all_levels[1].id]["score"] == 16
         assert student_row.completed == 1
-        assert student_row.percentage_complete == 45.0
+        assert (
+            student_row.success_rate == 45.0
+        )  ## the scores, (2 + 16 = 18), divided by the total possible, (2 * 20 = 40), 18/40 = 45%
+
+        # Check data for custom levels matches
+        assert shared_headers == SharedHeaders
+        assert shared_level_headers == [
+            f"{shared_level.name} ({shared_level.owner})"
+        ]
+
+        assert len(shared_student_data) == 1
+
+        student_row = shared_student_data[0]
+        assert student_row.class_field.name == clas.name
+        assert student_row.name == student2.user.user.first_name
+        assert student_row.total_score == 10
+        assert student_row.total_time == timedelta(0)
+        assert student_row.level_scores[shared_level.id]["score"] == 10
+        assert student_row.completed == 1
+        assert student_row.success_rate == 100.0
 
     def test_scoreboard_loads(self):
         email, password = signup_teacher_directly()
@@ -86,14 +152,47 @@ class ScoreboardTestCase(TestCase):
         data = {"classes": [klass.id], "view": [""]}
 
         response = c.post(url, data)
+
+        active_levels = Level.objects.filter(episode__pk__in=range(1, 10))
+
         assert response.status_code == 200
-        assert len(response.context["level_headers"]) == 109
+        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()
 
     def test_student_can_see_classes(self):
         """A student should be able to see the classes they are in"""
-        mr_teacher = Teacher.objects.factory("Normal", "Teacher", "normal@school.edu", "secretpa$sword")
-        klass, name1, _ = create_class_directly(mr_teacher.user.user.email, class_name="Class 1")
-        _, name2, _ = create_class_directly(mr_teacher.user.user.email, class_name="Class 2")
+        mr_teacher = Teacher.objects.factory(
+            "Normal", "Teacher", "normal@school.edu", "secretpa$sword"
+        )
+        klass, name1, _ = create_class_directly(
+            mr_teacher.user.user.email, class_name="Class 1"
+        )
+        _, name2, _ = create_class_directly(
+            mr_teacher.user.user.email, class_name="Class 2"
+        )
         student = Student.objects.schoolFactory(klass, "some student", "secret")
 
         c = Client()
@@ -102,30 +201,49 @@ class ScoreboardTestCase(TestCase):
         url = reverse("scoreboard")
         response = c.get(url)
 
-        choices_in_form = [v for (k, v) in response.context["form"]["classes"].field.choices]
+        choices_in_form = [
+            v for (k, v) in response.context["form"]["classes"].field.choices
+        ]
         assert name1 in choices_in_form
         assert name2 not in choices_in_form
         assert len(choices_in_form) == 1
 
     def test_admin_teacher_can_see_all_classes(self):
         """An admin should be able to see all classes, not just the ones they teach"""
-        normal_teacher = Teacher.objects.factory("Normal", "Teacher", "normal@school.edu", "secretpa$sword")
-        admin_teacher = Teacher.objects.factory("Admin", "Admin", "admin@school.edu", "secretpa$sword2")
+        teacher_email = "normal@school.edu"
+        admin_email = "admin@school.edu"
 
-        admin_teacher.is_admin = True
-        admin_teacher.save()
+        normal_teacher = Teacher.objects.factory(
+            "Normal", "Teacher", teacher_email, "secretpa$sword"
+        )
+        admin_teacher = Teacher.objects.factory(
+            "Admin", "Admin", admin_email, "secretpa$sword2"
+        )
 
-        _, name1, _ = create_class_directly(admin_teacher.user.user.email, class_name="Class 1")
-        _, name2, _ = create_class_directly(admin_teacher.user.user.email, class_name="Class 2")
-        _, name3, _ = create_class_directly(normal_teacher.user.user.email, class_name="Class 3")
+        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"
+        )
+        _, name2, _ = create_class_directly(
+            admin_teacher.user.user.email, class_name="Class 2"
+        )
+        _, name3, _ = create_class_directly(
+            normal_teacher.user.user.email, class_name="Class 3"
+        )
 
         c = Client()
-        c.login(username=admin_teacher.user.user.email, password="secretpa$sword2")
+        c.login(
+            username=admin_teacher.user.user.email, password="secretpa$sword2"
+        )
 
         url = reverse("scoreboard")
         response = c.get(url)
 
-        choices_in_form = [v for (k, v) in response.context["form"]["classes"].field.choices]
+        choices_in_form = [
+            v for (k, v) in response.context["form"]["classes"].field.choices
+        ]
 
         assert name1 in choices_in_form
         assert name2 in choices_in_form
@@ -133,12 +251,22 @@ class ScoreboardTestCase(TestCase):
 
     def test_non_admin_teacher_can_only_see_their_own_classes(self):
         """A teacher who is not an admin should only be able to see their classes, not ones taught by others"""
-        teacher1 = Teacher.objects.factory("First", "Teacher", "normal@school.edu", "secretpa$sword")
-        teacher2 = Teacher.objects.factory("Second", "Teacher", "admin@school.edu", "secretpa$sword2")
+        teacher1 = Teacher.objects.factory(
+            "First", "Teacher", "normal@school.edu", "secretpa$sword"
+        )
+        teacher2 = Teacher.objects.factory(
+            "Second", "Teacher", "admin@school.edu", "secretpa$sword2"
+        )
 
-        _, name1, _ = create_class_directly(teacher2.user.user.email, class_name="Class 1")
-        _, name2, _ = create_class_directly(teacher2.user.user.email, class_name="Class 2")
-        _, name3, _ = create_class_directly(teacher1.user.user.email, class_name="Class 3")
+        _, name1, _ = create_class_directly(
+            teacher2.user.user.email, class_name="Class 1"
+        )
+        _, name2, _ = create_class_directly(
+            teacher2.user.user.email, class_name="Class 2"
+        )
+        _, name3, _ = create_class_directly(
+            teacher1.user.user.email, class_name="Class 3"
+        )
 
         c = Client()
         # First teacher logs in.  Should see only Class 3
@@ -147,7 +275,9 @@ class ScoreboardTestCase(TestCase):
         url = reverse("scoreboard")
         response = c.get(url)
 
-        choices_in_form = [v for (k, v) in response.context["form"]["classes"].field.choices]
+        choices_in_form = [
+            v for (k, v) in response.context["form"]["classes"].field.choices
+        ]
 
         assert name3 in choices_in_form
         assert name1 not in choices_in_form
@@ -158,7 +288,9 @@ class ScoreboardTestCase(TestCase):
         c.login(username="admin@school.edu", password="secretpa$sword2")
 
         response = c.get(url)
-        choices_in_form = [v for (k, v) in response.context["form"]["classes"].field.choices]
+        choices_in_form = [
+            v for (k, v) in response.context["form"]["classes"].field.choices
+        ]
 
         assert name3 not in choices_in_form
         assert name1 in choices_in_form
@@ -174,7 +306,10 @@ class ScoreboardTestCase(TestCase):
         url = reverse("scoreboard")
         response = c.get(url)
 
-        assert "Scoreboard is only visible to school students and teachers" in str(response.content)
+        assert (
+            "Scoreboard is only visible to school students and teachers"
+            in str(response.content)
+        )
 
 
 class ScoreboardCsvTestCase(TestCase):
@@ -190,14 +325,25 @@ class ScoreboardCsvTestCase(TestCase):
 
         # Create 2 custom levels and create the associated student data
         shared_level_rows = [None, None]
-        shared_level1 = create_save_level(students[0], "level1", shared_with=[students[1].new_user])
+        shared_level1 = create_save_level(
+            students[0], "level1", shared_with=[students[1].new_user]
+        )
         shared_level2 = create_save_level(students[1], "level2")
         shared_levels = [shared_level1, shared_level2]
 
-        shared_levels_headers = list([shared_level_to_name(level, level.owner) for level in shared_levels])
+        shared_levels_headers = list(
+            [
+                shared_level_to_name(level, level.owner)
+                for level in shared_levels
+            ]
+        )
 
-        shared_level_rows[0] = self.shared_student_row(students[0], shared_levels)
-        shared_level_rows[1] = self.shared_student_row(students[1], shared_levels)
+        shared_level_rows[0] = self.shared_student_row(
+            students[0], shared_levels
+        )
+        shared_level_rows[1] = self.shared_student_row(
+            students[1], shared_levels
+        )
 
         # Create students' improvement table data
         improvement_data = []
@@ -206,23 +352,44 @@ class ScoreboardCsvTestCase(TestCase):
             improvement_data.append(stud)
 
         # Generate the CSV
-        response = scoreboard_csv(student_rows, levels, improvement_data, shared_levels_headers, shared_level_rows)
+        response = scoreboard_csv(
+            student_rows,
+            levels,
+            improvement_data,
+            shared_levels_headers,
+            shared_level_rows,
+        )
 
         # Gather the data from the CSV
-        actual_scoreboard_header, actual_scoreboard_rows, actual_shared_levels_header, actual_shared_levels_rows = self.actual_data(
-            response.content.decode("utf-8"), len(students)
-        )
+        (
+            actual_scoreboard_header,
+            actual_scoreboard_rows,
+            actual_shared_levels_header,
+            actual_shared_levels_rows,
+        ) = self.actual_data(response.content.decode("utf-8"), len(students))
 
         # Check the headers and the number or rows match expectations
-        assert actual_scoreboard_header == self.expected_scoreboard_header(levels)
+        assert actual_scoreboard_header == self.expected_scoreboard_header(
+            levels
+        )
         assert len(actual_scoreboard_rows) == len(student_rows)
-        assert actual_shared_levels_header == self.expected_shared_levels_header(shared_levels)
+        assert (
+            actual_shared_levels_header
+            == self.expected_shared_levels_header(shared_levels)
+        )
         assert len(actual_shared_levels_rows) == len(shared_level_rows)
 
         # check first scoreboard row
-        (class_name, name, completed_levels, total_time, total_scores, l1, l2, improvement) = actual_scoreboard_rows[
-            0
-        ].split(",")
+        (
+            class_name,
+            name,
+            completed_levels,
+            total_time,
+            total_scores,
+            l1,
+            l2,
+            improvement,
+        ) = actual_scoreboard_rows[0].split(",")
         assert student_rows[0].class_field.name == class_name
         assert student_rows[0].name == name
         assert student_rows[0].level_scores[0]["score"] == int(l1)
@@ -231,9 +398,16 @@ class ScoreboardCsvTestCase(TestCase):
 
         # check last scoreboard row
         last = len(actual_scoreboard_rows) - 1
-        (class_name, name, completed_levels, total_time, total_scores, l1, l2, improvement) = actual_scoreboard_rows[
-            last
-        ].split(",")
+        (
+            class_name,
+            name,
+            completed_levels,
+            total_time,
+            total_scores,
+            l1,
+            l2,
+            improvement,
+        ) = actual_scoreboard_rows[last].split(",")
         assert student_rows[last].class_field.name == class_name
         assert student_rows[last].name == name
         assert str(student_rows[last].total_time) == total_time
@@ -279,7 +453,7 @@ class ScoreboardCsvTestCase(TestCase):
             total_score=total_score,
             level_scores=level_scores,
             completed=2,
-            percentage_complete=45,
+            success_rate=45,
         )
 
         return row, student
@@ -310,19 +484,26 @@ class ScoreboardCsvTestCase(TestCase):
             total_score=0,
             level_scores=level_scores,
             completed=0,
-            percentage_complete=0,
+            success_rate=0,
         )
 
         return row
 
     def expected_scoreboard_header(self, levels):
         level_strings = list(map(str, levels))
-        all_header_strings = CSVHeaders + level_strings + ["Areas for improvement"]
+        all_header_strings = (
+            CSVHeaders + level_strings + ["Areas for improvement"]
+        )
         joined = ",".join(all_header_strings)
         return joined
 
     def expected_shared_levels_header(self, shared_levels):
-        level_strings = list([shared_level_to_name(level, level.owner) for level in shared_levels])
+        level_strings = list(
+            [
+                shared_level_to_name(level, level.owner)
+                for level in shared_levels
+            ]
+        )
         all_header_strings = CSVSharedHeaders + level_strings
         joined = ",".join(all_header_strings)
         return joined
@@ -343,14 +524,25 @@ class ScoreboardCsvTestCase(TestCase):
         scoreboard_header = split[scoreboard_header_row]
         scoreboard_rows = split[scoreboard_rows_start:scoreboard_rows_end]
         shared_levels_header = split[shared_levels_header_row]
-        shared_levels_rows = split[shared_levels_rows_start:shared_levels_rows_end]
-
-        return scoreboard_header, scoreboard_rows, shared_levels_header, shared_levels_rows
+        shared_levels_rows = split[
+            shared_levels_rows_start:shared_levels_rows_end
+        ]
+
+        return (
+            scoreboard_header,
+            scoreboard_rows,
+            shared_levels_header,
+            shared_levels_rows,
+        )
 
 
 def create_attempt(student, level, score):
     attempt = Attempt.objects.create(
-        finish_time=datetime.fromtimestamp(1435305072), level=level, student=student, score=score, is_best_attempt=True
+        finish_time=datetime.fromtimestamp(1435305072),
+        level=level,
+        student=student,
+        score=score,
+        is_best_attempt=True,
     )
     attempt.start_time = datetime.fromtimestamp(1435305072)
     attempt.save()

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,23 @@ 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:
+        for user in shared_with:
+            level.shared_with.add(user)
+        level.save()
+
+    return level
+
+def create_save_level_with_multiple_houses(teacher_or_student, level_name="2", shared_with=None):
+    level = Level(default=False, anonymous=multiple_house_data["anonymous"])
+    level.owner = teacher_or_student.user
+    level_management.save_level(level, multiple_house_data)
     level.save()
 
     if shared_with is not None:

game/tests/utils/teacher.py

@@ -7,13 +7,13 @@ from common.models import School, Teacher
 def create_school() -> School:
     school = School()
     school.name = "".join(random.choice(string.ascii_uppercase) for _ in range(10))
-    school.postcode = "".join(random.choice(string.ascii_uppercase) for _ in range(7))
     school.country = "United Kingdom"
     school.save()
 
     return school
 
 
-def add_teacher_to_school(teacher: Teacher, school: School):
+def add_teacher_to_school(teacher: Teacher, school: School, is_admin=False):
     teacher.user.teacher.school = school
+    teacher.is_admin = is_admin
     teacher.user.teacher.save()

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):
@@ -19,35 +19,35 @@ class Theme(object):
 
 THEME_DATA = {
     "grass": Theme(
-        name=u"grass",
-        text=ugettext(u"Grass"),
-        selected=u"#bce369",
-        background=u"#a0c53a",
-        border=u"#70961f",
+        name="grass",
+        text=gettext("Grass"),
+        selected="#bce369",
+        background="#a0c53a",
+        border="#70961f",
         pk=1,
     ),
     "snow": Theme(
-        name=u"snow",
-        text=ugettext(u"Snow"),
-        selected=u"#b3deff",
-        background=u"#eef7ff",
-        border=u"#83c9fe",
+        name="snow",
+        text=gettext("Snow"),
+        selected="#b3deff",
+        background="#eef7ff",
+        border="#83c9fe",
         pk=2,
     ),
     "farm": Theme(
-        name=u"farm",
-        text=ugettext(u"Farm"),
-        selected=u"#bce369",
-        background=u"#a0c53a",
-        border=u"#70961f",
+        name="farm",
+        text=gettext("Farm"),
+        selected="#bce369",
+        background="#a0c53a",
+        border="#70961f",
         pk=3,
     ),
     "city": Theme(
-        name=u"city",
-        text=ugettext(u"City"),
-        selected=u"#C1C1C1",
-        background=u"#969696",
-        border=u"#686868",
+        name="city",
+        text=gettext("City"),
+        selected="#C1C1C1",
+        background="#969696",
+        border="#686868",
         pk=4,
     ),
 }