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

game/end_to_end_tests/test_play_through.py

@@ -1,3 +1,5 @@
+import pytest
+
 from .base_game_test import BaseGameTest
 
 
@@ -5,13 +7,19 @@ class TestPlayThrough(BaseGameTest):
     def setUp(self):
         self.login_once()
 
-    def _complete_episode(self, episode_number, level_number, **kwargs):
+    def _complete_episode(
+        self, episode_number, level_number, from_python_den=False, **kwargs
+    ):
         page = self.go_to_episode(episode_number)
-        self.complete_and_check_level(level_number, page, **kwargs)
+        self.complete_and_check_level(
+            level_number, page, from_python_den, **kwargs
+        )
 
-    def _complete_level(self, level_number, **kwargs):
-        page = self.go_to_level(level_number)
-        self.complete_and_check_level(level_number, page, **kwargs)
+    def _complete_level(self, level_number, from_python_den=False, **kwargs):
+        page = self.go_to_level(level_number, from_python_den)
+        self.complete_and_check_level(
+            level_number, page, from_python_den, **kwargs
+        )
 
     def test_episode_01(self):
         self._complete_episode(1, 1, check_algorithm_score=False)
@@ -275,143 +283,230 @@ class TestPlayThrough(BaseGameTest):
         self._complete_level(78, check_route_score=False)
 
     def test_level_079(self):
-        self._complete_level(79)
-
-    def test_episode_10(self):
-        self._complete_episode(10, 80)
-
-    def test_level_080(self):
-        self._complete_level(80)
-
-    def test_level_081(self):
-        self._complete_level(81)
-
-    def test_level_082(self):
-        self._complete_level(82)
-
-    def test_level_083(self):
-        self._complete_level(83)
-
-    def test_level_084(self):
-        self._complete_level(84)
-
-    def test_level_085(self):
-        self._complete_level(85)
-
-    def test_level_086(self):
-        self._complete_level(86)
-
-    def test_level_087(self):
-        self._complete_level(87)
-
-    def test_level_088(self):
-        self._complete_level(88)
-
-    def test_level_089(self):
-        self._complete_level(89)
-
-    def test_level_090(self):
-        self._complete_level(90)
-
-    def test_level_091(self):
-        self._complete_level(91)
-
-    def test_episode_11(self):
-        self._complete_episode(11, 92, check_algorithm_score=False)
-
-    def test_level_092(self):
-        self._complete_level(92, check_algorithm_score=False)
+        self._complete_level(79, final_level=True)
 
-    def test_level_093(self):
-        self._complete_level(93, check_algorithm_score=False)
-
-    def test_level_094(self):
-        self._complete_level(94, check_algorithm_score=False)
-
-    def test_level_095(self):
-        self._complete_level(95, check_algorithm_score=False)
-
-    def test_level_096(self):
-        self._complete_level(96, check_algorithm_score=False)
-
-    def test_level_097(self):
-        self._complete_level(97, check_algorithm_score=False)
-
-    def test_level_098(self):
-        self._complete_level(98, check_algorithm_score=False)
-
-    def test_level_099(self):
-        self._complete_level(99, check_algorithm_score=False)
-
-    def test_level_100(self):
-        self._complete_level(100, check_algorithm_score=False)
-
-    def test_level_101(self):
-        self._complete_level(101, check_algorithm_score=False)
-
-    def test_level_102(self):
-        self._complete_level(102, check_algorithm_score=False)
-
-    def test_level_103(self):
-        self._complete_level(103, check_algorithm_score=False)
-
-    def test_level_104(self):
-        self._complete_level(104, check_algorithm_score=False)
-
-    def test_level_105(self):
-        self._complete_level(105, check_algorithm_score=False)
-
-    def test_level_106(self):
-        self._complete_level(106, check_algorithm_score=False)
-
-    def test_level_107(self):
-        self._complete_level(107, check_algorithm_score=False)
+    def test_episode_12(self):
+        self._complete_episode(
+            12, 1, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_001(self):
+        self._complete_level(1, from_python_den=True)
 
-    def test_level_108(self):
-        self._complete_level(108, check_algorithm_score=False)
+    def test_python_level_002(self):
+        self._complete_level(2, from_python_den=True)
 
-    def test_level_109(self):
-        self._complete_level(109, check_algorithm_score=False)
+    def test_python_level_003(self):
+        self._complete_level(3, from_python_den=True)
 
-    def test_episode_12(self):
-        self._complete_episode(12, 110, check_algorithm_score=False)
+    def test_python_level_004(self):
+        self._complete_level(
+            4, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_110(self):
-        self._complete_level(110, check_algorithm_score=False)
+    def test_python_level_005(self):
+        self._complete_level(
+            5, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_111(self):
-        self._complete_level(111, check_algorithm_score=False)
+    def test_python_level_006(self):
+        self._complete_level(
+            6, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_112(self):
-        self._complete_level(112)
+    def test_python_level_007(self):
+        self._complete_level(7, from_python_den=True)
 
-    def test_level_113(self):
-        self._complete_level(113, check_algorithm_score=False)
+    def test_python_level_008(self):
+        self._complete_level(8, from_python_den=True)
 
-    def test_level_114(self):
-        self._complete_level(114, check_algorithm_score=False)
+    def test_python_level_009(self):
+        self._complete_level(9, from_python_den=True)
 
-    def test_level_115(self):
-        self._complete_level(115, check_algorithm_score=False)
+    def test_python_level_010(self):
+        self._complete_level(
+            10, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_116(self):
-        self._complete_level(116)
+    def test_python_level_011(self):
+        self._complete_level(
+            11, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_117(self):
-        self._complete_level(117)
+    def test_python_level_012(self):
+        self._complete_level(
+            12, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_118(self):
-        self._complete_level(118)
+    def test_python_level_013(self):
+        self._complete_level(
+            13, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_119(self):
-        self._complete_level(119, check_algorithm_score=False)
+    def test_episode_13(self):
+        self._complete_episode(13, 14, from_python_den=True)
 
-    def test_level_120(self):
-        self._complete_level(120, check_algorithm_score=False)
+    def test_python_level_014(self):
+        self._complete_level(14, from_python_den=True)
 
-    def test_level_121(self):
-        self._complete_level(121, check_algorithm_score=False)
+    def test_python_level_015(self):
+        self._complete_level(15, from_python_den=True)
 
-    def test_level_122(self):
-        self._complete_level(122, check_algorithm_score=False, final_level=True)
+    def test_python_level_016(self):
+        self._complete_level(
+            16, check_algorithm_score=False, from_python_den=True
+        )
 
+    def test_python_level_017(self):
+        self._complete_level(
+            17, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_018(self):
+        self._complete_level(
+            18, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_019(self):
+        self._complete_level(19, from_python_den=True)
+
+    def test_python_level_020(self):
+        self._complete_level(
+            20, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_021(self):
+        self._complete_level(
+            21, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_022(self):
+        self._complete_level(22, from_python_den=True)
+
+    def test_python_level_023(self):
+        self._complete_level(23, from_python_den=True)
+
+    def test_python_level_024(self):
+        self._complete_level(
+            24, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_025(self):
+        self._complete_level(
+            25, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_episode_14(self):
+        self._complete_episode(14, 26, from_python_den=True)
+
+    def test_python_level_026(self):
+        self._complete_level(26, from_python_den=True)
+
+    def test_python_level_027(self):
+        self._complete_level(27, from_python_den=True)
+
+    def test_python_level_028(self):
+        self._complete_level(28, from_python_den=True)
+
+    def test_python_level_029(self):
+        self._complete_level(29, from_python_den=True)
+
+    def test_python_level_030(self):
+        self._complete_level(
+            30, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_031(self):
+        self._complete_level(31, from_python_den=True)
+
+    def test_python_level_032(self):
+        self._complete_level(32, from_python_den=True)
+
+    def test_python_level_033(self):
+        self._complete_level(
+            33, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_034(self):
+        self._complete_level(
+            34, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_035(self):
+        self._complete_level(35, from_python_den=True)
+
+    def test_python_level_036(self):
+        self._complete_level(36, from_python_den=True)
+
+    def test_python_level_037(self):
+        self._complete_level(
+            37, check_algorithm_score=False, from_python_den=True
+        )
+
+    @pytest.mark.skip(reason="this level's solution is currently flawed")
+    def test_python_level_038(self):
+        self._complete_level(
+            38, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_039(self):
+        self._complete_level(
+            39, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_040(self):
+        self._complete_level(
+            40,
+            check_algorithm_score=False,
+            from_python_den=True,
+            redirects=True,
+        )
+
+    def test_episode_15(self):
+        self._complete_episode(
+            15, 41, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_041(self):
+        self._complete_level(41, from_python_den=True)
+
+    def test_python_level_042(self):
+        self._complete_level(
+            42, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_043(self):
+        self._complete_level(
+            43, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_044(self):
+        self._complete_level(44, from_python_den=True)
+
+    def test_python_level_045(self):
+        self._complete_level(
+            45, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_046(self):
+        self._complete_level(
+            46, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_047(self):
+        self._complete_level(
+            47, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_048(self):
+        self._complete_level(
+            48, check_algorithm_score=False, from_python_den=True
+        )
+
+    def test_python_level_049(self):
+        self._complete_level(
+            49,
+            check_algorithm_score=False,
+            from_python_den=True,
+            final_level=True,
+        )

game/end_to_end_tests/test_python_levels.py

@@ -2,34 +2,68 @@ from selenium.webdriver.common.by import By
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import WebDriverWait
 
+from game.character import get_character
 from game.end_to_end_tests.base_game_test import BaseGameTest
+from game.models import Level
+from game.theme import get_theme
 
 DELAY_TIME = 10
 
 
 class TestPythonLevels(BaseGameTest):
     def test_can_see_python_commands(self):
-        self.run_python_commands_test(level=92)
+        self.go_to_level(4, from_python_den=True).check_python_commands()
 
     def test_clear_console(self):
-        self.run_clear_console_test(level=92)
+        self.go_to_level(4, from_python_den=True).write_to_then_clear_console()
 
     def test_console_parse_error(self):
-        self.run_console_parse_error_test(level=92)
+        self.go_to_level(4, from_python_den=True).run_parse_error_program()
 
     def test_console_attribute_error(self):
-        self.run_console_attribute_error_test(level=92)
+        self.go_to_level(4, from_python_den=True).run_attribute_error_program()
 
     def test_console_print(self):
-        self.run_console_print_test(level=92)
+        self.go_to_level(4, from_python_den=True).run_print_program()
 
     def test_invalid_import(self):
-        self.run_invalid_import_test(level=109)
+        self.go_to_level(5, from_python_den=True).run_invalid_import_program()
 
     def test_run_code(self):
-        self.go_to_level(92)
+        self.go_to_level(4, from_python_den=True)
         run_code = self.selenium.find_element(By.ID, "run-code-button")
         run_code.click()
         assert WebDriverWait(self.selenium, DELAY_TIME).until(
             EC.presence_of_all_elements_located((By.ID, "myModal-lead"))
         )
+
+    def test_animal_sound_horn(self):
+        grass = get_theme(name="grass")
+
+        van = get_character("Van")
+
+        animal_level = Level(
+            name="Animal commands",
+            anonymous=False,
+            blockly_enabled=False,
+            character=van,
+            cows='[{"minCows":1,"maxCows":1,"potentialCoordinates":[{"x":3,"y":4}],"type":"WHITE"}]',
+            default=False,
+            destinations="[[4,4]]",
+            fuel_gauge=False,
+            max_fuel=50,
+            model_solution="",
+            origin='{"coordinate":[2,4],"direction":"E"}',
+            path='[{"coordinate":[2,4],"connectedNodes":[1]},{"coordinate":[3,4],"connectedNodes":[0,2]},{"coordinate":[4,4],"connectedNodes":[1]}]',
+            python_enabled=True,
+            theme=grass,
+            threads=1,
+            traffic_lights="[]",
+            disable_algorithm_score=True,
+        )
+
+        user_profile = self.login_once()
+        animal_level.owner = user_profile
+        animal_level.save()
+
+        self.run_animal_sound_horn_test(animal_level).assert_success()

game/end_to_end_tests/test_saving_workspace.py

@@ -12,7 +12,8 @@ class TestSavingWorkspace(BaseGameTest):
         self.login_once()
         level = 10
         random_save_entry_name = "".join(
-            random.choice(string.ascii_uppercase + string.digits) for _ in range(10)
+            random.choice(string.ascii_uppercase + string.digits)
+            for _ in range(10)
         )
         return (
             self.go_to_level(level)

game/forms.py

@@ -9,18 +9,24 @@ from .models import Episode
 class ScoreboardForm(forms.Form):
     def __init__(self, *args, **kwargs):
         classes = kwargs.pop("classes")
+        language = kwargs.pop("language")
         super(ScoreboardForm, self).__init__(*args, **kwargs)
         classes_choices = [(c.id, c.name) for c in classes]
 
         self.fields["classes"] = forms.MultipleChoiceField(
             choices=classes_choices, widget=forms.CheckboxSelectMultiple()
         )
+
+        episodes_range = (
+            range(1, 10) if language == "blockly" else range(12, 16)
+        )
+
         # Each tuple in choices has two elements, id and name of each level
         # First element is the actual value set on the model
         # Second element is the string displayed on the dropdown menu
         episodes_choices = (
             (episode.id, episode.name)
-            for episode in Episode.objects.filter(in_development=False)
+            for episode in Episode.objects.filter(pk__in=episodes_range)
         )
         self.fields["episodes"] = forms.MultipleChoiceField(
             choices=itertools.chain(episodes_choices),

game/level_management.py

@@ -35,8 +35,12 @@ def levels_shared_with(user):
         return []
 
     shared_levels = user.shared
+    shared_levels = add_related_fields(shared_levels)
 
-    return add_related_fields(shared_levels)
+    if hasattr(user.userprofile, "student"):
+        shared_levels = shared_levels.filter(needs_approval=False)
+
+    return shared_levels
 
 
 def levels_owned_by(user):
@@ -52,13 +56,13 @@ def get_decor(level):
     """Helper method parsing decor into a dictionary format 'sendable' to javascript."""
     decorData = []
     for ld in LevelDecor.objects.filter(level=level):
-        decor = get_decor_element(name=ld.decorName, theme=level.theme)
+        decor = get_decor_element(name=ld.decor_name, theme=level.theme)
         decorData.append(
             {
                 "x": int(ld.x),
                 "y": int(ld.y),
                 "z": int(decor.z_index),
-                "decorName": str(ld.decorName),
+                "decorName": str(ld.decor_name),
                 "width": int(decor.width),
                 "height": int(decor.height),
                 "url": str(decor.url),
@@ -81,7 +85,10 @@ def set_decor_inner(level, decor, LevelDecor):
     for data in decor:
         level_decors.append(
             LevelDecor(
-                level_id=level.id, x=data["x"], y=data["y"], decorName=data["decorName"]
+                level_id=level.id,
+                x=data["x"],
+                y=data["y"],
+                decor_name=data["decorName"],
             )
         )
     LevelDecor.objects.bulk_create(level_decors)
@@ -160,11 +167,19 @@ def save_level(level, data):
     level.max_fuel = data["max_fuel"]
     level.traffic_lights = data["traffic_lights"]
     level.cows = data["cows"]
-    level.blocklyEnabled = data.get("blocklyEnabled", True)
-    level.pythonEnabled = data.get("pythonEnabled", False)
-    level.pythonViewEnabled = data.get("pythonViewEnabled", False)
+    level.blockly_enabled = data.get("blockly_enabled", True)
+    level.python_enabled = data.get("python_enabled", False)
+    level.python_view_enabled = data.get("python_view_enabled", False)
     level.theme = get_theme_by_pk(pk=data["theme"])
     level.character = get_character_by_pk(pk=data["character"])
+    level.disable_algorithm_score = data.get("disable_algorithm_score", False)
+    if data.get("subtitle") != None:
+        level.subtitle = data.get("subtitle")
+    if data.get("lesson") != None:
+        level.lesson = data.get("lesson")
+    if data.get("hint") != None:
+        level.hint = data.get("hint")
+
     level.save()
 
     set_decor(level, data["decor"])
@@ -184,9 +199,9 @@ def unshare_level(level, *users):
 
 
 def email_new_custom_level(
-    teacher_email, moderate_url, level_url, home_url, student_name, class_name
+    teacher_email, moderate_url, level_url, student_name, class_name
 ):
-    # email teacher when a new custom level is created by a pupil, so it can be moderated ASAP
+    # email teacher when a new custom level is created by a pupil, so it can be moderated
 
     send_dotdigital_email(
         campaign_ids["level_creation"],
@@ -195,6 +210,6 @@ def email_new_custom_level(
             "STUDENT_NAME": student_name,
             "CLASS_NAME": class_name,
             "LEVEL_URL": level_url,
-            "MODERATE_URL": moderate_url
-        }
+            "MODERATE_URL": moderate_url,
+        },
     )