rapid-router 5.4.1__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,52 +7,58 @@ 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)
+        self._complete_episode(1, 1, check_algorithm_score=False)
 
     def test_level_001(self):
-        self._complete_level(1)
+        self._complete_level(1, check_algorithm_score=False)
 
     def test_level_002(self):
-        self._complete_level(2)
+        self._complete_level(2, check_algorithm_score=False)
 
     def test_level_003(self):
-        self._complete_level(3)
+        self._complete_level(3, check_algorithm_score=False)
 
     def test_level_004(self):
-        self._complete_level(4)
+        self._complete_level(4, check_algorithm_score=False)
 
     def test_level_005(self):
-        self._complete_level(5)
+        self._complete_level(5, check_algorithm_score=False)
 
     def test_level_006(self):
-        self._complete_level(6)
+        self._complete_level(6, check_algorithm_score=False)
 
     def test_level_007(self):
-        self._complete_level(7)
+        self._complete_level(7, check_algorithm_score=False)
 
     def test_level_008(self):
-        self._complete_level(8)
+        self._complete_level(8, check_algorithm_score=False)
 
     def test_level_009(self):
-        self._complete_level(9)
+        self._complete_level(9, check_algorithm_score=False)
 
     def test_level_010(self):
-        self._complete_level(10)
+        self._complete_level(10, check_algorithm_score=False)
 
     def test_level_011(self):
-        self._complete_level(11)
+        self._complete_level(11, check_algorithm_score=False)
 
     def test_level_012(self):
-        self._complete_level(12, next_episode=2)
+        self._complete_level(12, check_algorithm_score=False)
 
     def test_episode_02(self):
         self._complete_episode(2, 13)
@@ -71,7 +79,7 @@ class TestPlayThrough(BaseGameTest):
         self._complete_level(17)
 
     def test_level_018(self):
-        self._complete_level(18, next_episode=3)
+        self._complete_level(18)
 
     def test_episode_03(self):
         self._complete_episode(3, 19)
@@ -104,7 +112,7 @@ class TestPlayThrough(BaseGameTest):
         self._complete_level(27)
 
     def test_level_028(self):
-        self._complete_level(28, next_episode=4)
+        self._complete_level(28)
 
     def test_episode_04(self):
         self._complete_episode(4, 29)
@@ -119,7 +127,7 @@ class TestPlayThrough(BaseGameTest):
         self._complete_level(31)
 
     def test_level_032(self):
-        self._complete_level(32, next_episode=5)
+        self._complete_level(32)
 
     def test_episode_05(self):
         self._complete_episode(5, 33)
@@ -143,7 +151,7 @@ class TestPlayThrough(BaseGameTest):
         self._complete_level(38)
 
     def test_level_039(self):
-        self._complete_level(39)
+        self._complete_level(39, check_route_score=False)
 
     def test_level_040(self):
         self._complete_level(40)
@@ -155,7 +163,7 @@ class TestPlayThrough(BaseGameTest):
         self._complete_level(42)
 
     def test_level_043(self):
-        self._complete_level(43, next_episode=6)
+        self._complete_level(43)
 
     def test_episode_06(self):
         self._complete_episode(6, 44)
@@ -179,7 +187,7 @@ class TestPlayThrough(BaseGameTest):
         self._complete_level(49)
 
     def test_level_050(self):
-        self._complete_level(50, next_episode=7)
+        self._complete_level(50)
 
     def test_episode_07(self):
         self._complete_episode(7, 51, check_algorithm_score=False)
@@ -212,7 +220,7 @@ class TestPlayThrough(BaseGameTest):
         self._complete_level(59, check_route_score=False)
 
     def test_level_060(self):
-        self._complete_level(60, next_episode=8, check_route_score=False)
+        self._complete_level(60, check_route_score=False)
 
     def test_episode_08(self):
         self._complete_episode(8, 61)
@@ -236,7 +244,7 @@ class TestPlayThrough(BaseGameTest):
         self._complete_level(66)
 
     def test_level_067(self):
-        self._complete_level(67, next_episode=9)
+        self._complete_level(67)
 
     def test_episode_09(self):
         self._complete_episode(9, 68, check_route_score=False)
@@ -275,100 +283,230 @@ class TestPlayThrough(BaseGameTest):
         self._complete_level(78, check_route_score=False)
 
     def test_level_079(self):
-        self._complete_level(79, next_episode=10)
-
-    def test_episode_10(self):
-        self._complete_episode(10, 80, check_algorithm_score=False)
-
-    def test_level_080(self):
-        self._complete_level(80, check_algorithm_score=False)
-
-    def test_level_081(self):
-        self._complete_level(81, check_algorithm_score=False)
-
-    def test_level_082(self):
-        self._complete_level(82, check_algorithm_score=False)
-
-    def test_level_083(self):
-        self._complete_level(83, check_algorithm_score=False)
-
-    def test_level_084(self):
-        self._complete_level(84, check_algorithm_score=False)
-
-    def test_level_085(self):
-        self._complete_level(85, check_algorithm_score=False)
-
-    def test_level_086(self):
-        self._complete_level(86, check_algorithm_score=False)
-
-    def test_level_087(self):
-        self._complete_level(87, check_algorithm_score=False)
-
-    def test_level_088(self):
-        self._complete_level(88, check_algorithm_score=False)
-
-    def test_level_089(self):
-        self._complete_level(89, check_algorithm_score=False)
+        self._complete_level(79, final_level=True)
 
-    def test_level_090(self):
-        self._complete_level(90, check_algorithm_score=False)
+    def test_episode_12(self):
+        self._complete_episode(
+            12, 1, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_091(self):
-        self._complete_level(91, next_episode=11, check_algorithm_score=False)
+    def test_python_level_001(self):
+        self._complete_level(1, from_python_den=True)
 
-    def test_episode_11(self):
-        self._complete_episode(11, 92, check_algorithm_score=False)
+    def test_python_level_002(self):
+        self._complete_level(2, from_python_den=True)
 
-    def test_level_092(self):
-        self._complete_level(92, check_algorithm_score=False)
+    def test_python_level_003(self):
+        self._complete_level(3, from_python_den=True)
 
-    def test_level_093(self):
-        self._complete_level(93, 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_094(self):
-        self._complete_level(94, 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_095(self):
-        self._complete_level(95, 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_096(self):
-        self._complete_level(96, check_algorithm_score=False)
+    def test_python_level_007(self):
+        self._complete_level(7, from_python_den=True)
 
-    def test_level_097(self):
-        self._complete_level(97, check_algorithm_score=False)
+    def test_python_level_008(self):
+        self._complete_level(8, from_python_den=True)
 
-    def test_level_098(self):
-        self._complete_level(98, check_algorithm_score=False)
+    def test_python_level_009(self):
+        self._complete_level(9, from_python_den=True)
 
-    def test_level_099(self):
-        self._complete_level(99, 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_100(self):
-        self._complete_level(100, check_algorithm_score=False)
+    def test_python_level_011(self):
+        self._complete_level(
+            11, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_101(self):
-        self._complete_level(101, check_algorithm_score=False)
+    def test_python_level_012(self):
+        self._complete_level(
+            12, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_102(self):
-        self._complete_level(102, check_algorithm_score=False)
+    def test_python_level_013(self):
+        self._complete_level(
+            13, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_103(self):
-        self._complete_level(103, check_algorithm_score=False)
+    def test_episode_13(self):
+        self._complete_episode(13, 14, from_python_den=True)
 
-    def test_level_104(self):
-        self._complete_level(104, check_algorithm_score=False)
+    def test_python_level_014(self):
+        self._complete_level(14, from_python_den=True)
 
-    def test_level_105(self):
-        self._complete_level(105, check_algorithm_score=False)
+    def test_python_level_015(self):
+        self._complete_level(15, from_python_den=True)
 
-    def test_level_106(self):
-        self._complete_level(106, check_algorithm_score=False)
+    def test_python_level_016(self):
+        self._complete_level(
+            16, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_107(self):
-        self._complete_level(107, check_algorithm_score=False)
+    def test_python_level_017(self):
+        self._complete_level(
+            17, check_algorithm_score=False, from_python_den=True
+        )
 
-    def test_level_108(self):
-        self._complete_level(108, check_algorithm_score=False)
+    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_level_109(self):
-        self._complete_level(109, check_algorithm_score=False, final_level=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

@@ -1,38 +1,69 @@
-from time import sleep
-from game.end_to_end_tests.base_game_test import BaseGameTest
-from portal.tests.pageObjects.portal.base_page import BasePage
-
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import WebDriverWait
-from selenium.common.exceptions import TimeoutException
+
+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)
-        run_code = self.selenium.find_element_by_id("run-code-button")
+        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

@@ -0,0 +1,22 @@
+import random
+import string
+
+from game.end_to_end_tests.base_game_test import BaseGameTest
+
+
+class TestSavingWorkspace(BaseGameTest):
+    already_logged_on = False
+    user_profile = None
+
+    def test_save_and_load_workspace(self):
+        self.login_once()
+        level = 10
+        random_save_entry_name = "".join(
+            random.choice(string.ascii_uppercase + string.digits)
+            for _ in range(10)
+        )
+        return (
+            self.go_to_level(level)
+            .save_solution(random_save_entry_name)
+            .load_solution_by_name(random_save_entry_name)
+        )

game/forms.py

@@ -9,17 +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 drop down menu
+        # Second element is the string displayed on the dropdown menu
         episodes_choices = (
-            (episode.id, episode.name) for episode in Episode.objects.all()
+            (episode.id, episode.name)
+            for episode in Episode.objects.filter(pk__in=episodes_range)
         )
         self.fields["episodes"] = forms.MultipleChoiceField(
             choices=itertools.chain(episodes_choices),