psychopy 2024.1.1__py3-none-any.whl → 2024.1.3__py3-none-any.whl

psychopy/tests/test_experiment/test_components/{test_Mouse.py → test_MouseComponent.py}

@@ -1,65 +1,52 @@
 from pathlib import Path
 
-from . import _TestDisabledMixin, _TestBaseComponentsMixin
-from psychopy.experiment import Experiment
+from . import BaseComponentTests
 from psychopy.experiment.loops import TrialHandler
-from psychopy.experiment.routines import Routine
 from psychopy.experiment.components.mouse import MouseComponent
 from psychopy.experiment.components.polygon import PolygonComponent
 from psychopy.tests.utils import TESTS_DATA_PATH
 from psychopy.hardware.mouse import Mouse
 
 
-class TestMouseComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
+class TestMouseComponent(BaseComponentTests):
     """
     Test that Mouse coponents have the correct params and write as expected.
     """
+    comp = MouseComponent
     libraryClass = Mouse
 
-    def setup_method(self):
-        # Make blank experiment
-        self.exp = Experiment()
-        # Make blank routine
-        self.routine = Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # Add loop around routine
-        self.loop = TrialHandler(exp=self.exp, name="testLoop")
-        self.exp.flow.addLoop(self.loop, 0, -1)
-        # Make Mouse component
-        self.comp = MouseComponent(exp=self.exp, parentName="testRoutine", name="testMouse")
-        self.routine.addComponent(self.comp)
-        # Make a rect for when we need something to click on
-        self.target = PolygonComponent(exp=self.exp, parentName="testRoutine", name="testPolygon")
-        self.routine.addComponent(self.target)
-
     def test_click_save_end_clickable_cases(self):
         """
         Test all combinations of options for what to save, what can be clicked on & what kind of clicks to end the
         routine on.
         """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # make a rect for when we need something to click on
+        target = PolygonComponent(exp=exp, parentName=rt.name, name="testPolygon")
+        
         saveMouseStateCases = [
             {'val': "final",
-             'want': ["thisExp.addData('testMouse.x', x)"],  # should contain code for adding final value of x
-             'avoid': ["testMouse.x.append(x)"]},  # should not contain code to update testMouse.x in frame loop
+             'want': [f"thisExp.addData('{comp.name}.x', x)"],  # should contain code for adding final value of x
+             'avoid': [f"{comp.name}.x.append(x)"]},  # should not contain code to update testMouse.x in frame loop
             {'val': "on click",
-             'want': ["thisExp.addData('testMouse.x', testMouse.x)",  # should add testMouse.x at the end
-                      "testMouse.x.append(x)"],  # should contain code to update testMouse.x in frame loop
-             'avoid': ["thisExp.addData('testMouse.x', x)"]},  # should not add final value of x
+             'want': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should add testMouse.x at the end
+                      f"{comp.name}.x.append(x)"],  # should contain code to update testMouse.x in frame loop
+             'avoid': [f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x
             {'val': "on valid click",
-             'want': ["thisExp.addData('testMouse.x', testMouse.x)",  # should add testMouse.x at the end
-                      "testMouse.x.append(x)",  # should contain code to update testMouse.x in frame loop
+             'want': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should add testMouse.x at the end
+                      f"{comp.name}.x.append(x)",  # should contain code to update testMouse.x in frame loop
                       "if gotValidClick:"],  # should check for valid clicks
-             'avoid': ["thisExp.addData('testMouse.x', x)"]},  # should not add final value of x
+             'avoid': [f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x
             {'val': "every frame",
-             'want': ["thisExp.addData('testMouse.x', testMouse.x)",  # should add testMouse.x at the end
-                      "testMouse.x.append(x)"],  # should contain code to update testMouse.x in frame loop
-             'avoid': ["thisExp.addData('testMouse.x', x)"]},  # should not add final value of x
+             'want': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should add testMouse.x at the end
+                      f"{comp.name}.x.append(x)"],  # should contain code to update testMouse.x in frame loop
+             'avoid': [f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x
             {'val': "never",
              'want': [],
-             'avoid': ["thisExp.addData('testMouse.x', testMouse.x)",  # should not add testMouse.x at the end
-                       "testMouse.x.append(x)",  # should not contain code to update testMouse.x in frame loop
-                       "thisExp.addData('testMouse.x', x)"]},  # should not add final value of x]},
+             'avoid': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should not add testMouse.x at the end
+                       f"{comp.name}.x.append(x)",  # should not contain code to update testMouse.x in frame loop
+                       f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x]},
         ]
         forceEndRoutineOnPressCases = [
             {'val':  "never",
@@ -85,54 +72,54 @@ class TestMouseComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
         # Iterate through saveMouseState cases
         for SMScase in saveMouseStateCases:
             # Set saveMouseState
-            self.comp.params['saveMouseState'].val = SMScase['val']
+            comp.params['saveMouseState'].val = SMScase['val']
             for FEROPcase in forceEndRoutineOnPressCases:
                 # Set forceEndRoutineOnPress
-                self.comp.params['forceEndRoutineOnPress'].val = FEROPcase['val']
+                comp.params['forceEndRoutineOnPress'].val = FEROPcase['val']
                 for Ccase in clickableCases:
                     # Set clickable
-                    self.comp.params['clickable'].val = Ccase['val']
+                    comp.params['clickable'].val = Ccase['val']
 
                     # Compile script
-                    script = self.exp.writeScript(target="PsychoPy")
+                    script = exp.writeScript(target="PsychoPy")
                     try:
                         # Look for wanted phrases
                         for phrase in SMScase['want']:
                             assert phrase in script, (
-                                f"{phrase} not found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} not found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                         for phrase in FEROPcase['want']:
                             assert phrase in script, (
-                                f"{phrase} not found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} not found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                         for phrase in Ccase['want']:
                             assert phrase in script, (
-                                f"{phrase} not found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} not found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                         # Check there's no avoid phrases
                         for phrase in SMScase['avoid']:
                             assert phrase not in script, (
-                                f"{phrase} found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                         for phrase in FEROPcase['avoid']:
                             assert phrase not in script, (
-                                f"{phrase} found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                         for phrase in Ccase['avoid']:
                             assert phrase not in script, (
-                                f"{phrase} found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                     except AssertionError as err:
                         # If any assertion fails, save script to view

psychopy/tests/test_experiment/test_components/{test_Polygon.py → test_PolygonComponent.py}

@@ -1,37 +1,21 @@
-from pathlib import Path
-
-from . import _TestDisabledMixin, _TestBaseComponentsMixin
-from psychopy.experiment import Experiment
-from psychopy.experiment.loops import TrialHandler
-from psychopy.experiment.routines import Routine
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests, _TestLibraryClassMixin
 from psychopy.experiment.components.polygon import PolygonComponent
 from psychopy.visual.polygon import Polygon
 
 
-class TestPolygonComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
+class TestPolygonComponent(BaseComponentTests, _TestLibraryClassMixin):
     """
     Test that Polygon coponents have the correct params and write as expected.
     """
+    comp = PolygonComponent
     libraryClass = Polygon
 
-    def setup_method(self):
-        # Make blank experiment
-        self.exp = Experiment()
-        # Make blank routine
-        self.routine = Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # Add loop around routine
-        self.loop = TrialHandler(exp=self.exp, name="testLoop")
-        self.exp.flow.addLoop(self.loop, 0, -1)
-        # Make a rect for when we need something to click on
-        self.comp = PolygonComponent(exp=self.exp, parentName="testRoutine", name="testPolygon")
-        self.routine.addComponent(self.comp)
-
     def test_vertices_usage(self):
         """
         Test that vertices values are used only under the correct conditions
         """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
         # Define values to look for and avoid in code according to value of shape
         cases = [
             # Shape is a line
@@ -61,14 +45,14 @@ class TestPolygonComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
              'avoid': ["___nVertices___"]},
         ]
         # Setup component with markers for nVertices and vertices
-        self.comp.params['nVertices'].val = "___nVertices___"
-        self.comp.params['vertices'].val = "___vertices___"
+        comp.params['nVertices'].val = "___nVertices___"
+        comp.params['vertices'].val = "___vertices___"
         # Test each case
         for case in cases:
             # Set shape
-            self.comp.params['shape'].val = case['val']
+            comp.params['shape'].val = case['val']
             # Write experiment
-            pyScript = self.exp.writeScript(target="PsychoPy")
+            pyScript = exp.writeScript(target="PsychoPy")
             # Look for sought values in experiment script
             for seekVal in case['seek']:
                 assert seekVal in pyScript, (

psychopy/tests/test_experiment/test_components/{test_ResourceManager.py → test_ResourceManagerComponent.py}

@@ -1,23 +1,13 @@
 from pathlib import Path
 
-from . import _TestBaseComponentsMixin, _TestDisabledMixin
-from .test_base_components import _find_global_resource_in_js_experiment
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests, _find_global_resource_in_js_experiment
 from psychopy.experiment.components.resourceManager import ResourceManagerComponent
 from psychopy import experiment
 from ...utils import TESTS_DATA_PATH
 
 
-class TestResourceManagerComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
-    def setup_method(self):
-        # Make blank experiment
-        self.exp = experiment.Experiment()
-        # Make blank routine
-        self.routine = experiment.routines.Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # Make Resource Manager component
-        self.comp = ResourceManagerComponent(exp=self.exp, parentName="testRoutine", name="testResourceManager")
-        self.routine.addComponent(self.comp)
+class TestResourceManagerComponent(BaseComponentTests):
+    comp = ResourceManagerComponent
 
     def test_handled_resources_removed(self):
         """

psychopy/tests/test_experiment/test_components/{test_Settings.py → test_SettingsComponent.py}

@@ -1,13 +1,11 @@
 from pathlib import Path
 
-from . import _TestBaseComponentsMixin, _TestDisabledMixin
 from .test_base_components import _find_global_resource_in_js_experiment
-from psychopy.experiment.components.settings import SettingsComponent
 from psychopy import experiment
 from ...utils import TESTS_DATA_PATH
 
 
-class TestSettingsComponent(_TestBaseComponentsMixin):
+class TestSettingsComponent:
     def test_unhandled_resources_js(self):
         """
         Check that resources not otherwise handled are present at the start of the experiment

psychopy/tests/test_experiment/test_components/{test_Static.py → test_StaticComponent.py}

@@ -1,23 +1,14 @@
 from pathlib import Path
 
-from . import _TestBaseComponentsMixin, _TestDisabledMixin
+from . import BaseComponentTests
 from .test_base_components import _find_global_resource_in_js_experiment
 from psychopy.experiment.components.static import StaticComponent
 from psychopy import experiment, data
 from ...utils import TESTS_DATA_PATH
 
 
-class TestStaticComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
-    def setup_method(self):
-        # Make blank experiment
-        self.exp = experiment.Experiment()
-        # Make blank routine
-        self.routine = experiment.routines.Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # Make Static component
-        self.comp = StaticComponent(exp=self.exp, parentName="testRoutine", name="testStatic")
-        self.routine.addComponent(self.comp)
+class TestStaticComponent(BaseComponentTests):
+    comp = StaticComponent
 
     def test_handled_resources_removed(self):
         """

psychopy/tests/test_experiment/test_components/test_all_components.py

@@ -1,10 +1,10 @@
 from psychopy.experiment.exports import IndentingBuffer
-from . import _TestBaseComponentsMixin, _TestDisabledMixin
+from . import BaseComponentTests
 from psychopy import experiment
 import inspect
 
 
-class _Generic(_TestBaseComponentsMixin, _TestDisabledMixin):
+class _Generic(BaseComponentTests):
     def __init__(self, compClass):
         self.exp = experiment.Experiment()
         self.rt = experiment.routines.Routine(exp=self.exp, name="testRoutine")
@@ -18,14 +18,12 @@ def test_all_components():
     for compName, compClass in experiment.getAllComponents().items():
         if compName == "SettingsComponent":
             continue
-        # Make a generic testing object for this component
-        tester = _Generic(compClass)
-        # Run each method from _TestBaseComponentsMixin on tester
-        for attr, meth in _TestBaseComponentsMixin.__dict__.items():
-            if inspect.ismethod(meth):
-                meth(tester)
-        # Run each method from _TestBaseComponentsMixin on tester
-        for attr, meth in _TestDisabledMixin.__dict__.items():
+        # make a generic testing object for this component
+        tester = BaseComponentTests()
+        # make sure it has a comp class assigned
+        tester.comp = compClass
+        # Run each method from BaseComponentTests on tester
+        for attr, meth in BaseComponentTests.__dict__.items():
             if inspect.ismethod(meth):
                 meth(tester)
 
@@ -104,59 +102,3 @@ def test_visual_set_autodraw():
             f"{compName} does not set autoDraw in its Each Frame code. If this is acceptable, add the component name "
             f"to `skipComponents`."
         )
-
-def test_indentation_consistency():
-    """
-    No component should exit any of its write methods at a different indent level as it entered, as this would break
-    subsequent components / routines.
-    """
-    for compName, compClass in experiment.getAllComponents().items():
-        if compName == "SettingsComponent":
-            continue
-        # Make a generic testing object for this component
-        tester = _Generic(compClass)
-        # Skip if component doesn't have a start/stop time
-        if "startVal" not in tester.comp.params or "stopVal" not in tester.comp.params:
-            continue
-        # Check that each write method exits at the same indent level as it entered
-        buff = IndentingBuffer(target="PsychoPy")
-        msg = "Writing {} code for {} changes indent level by {} when start is `{}` and stop is `{}`."
-        # Setup flow for writing
-        tester.exp.flow.writeStartCode(buff)
-        # Try combinations of start/stop being set/unset
-        cases = [
-            {"startVal": "0", "stopVal": "1"},
-            {"startVal": "", "stopVal": "1"},
-            {"startVal": "0", "stopVal": ""},
-            {"startVal": "", "stopVal": ""},
-        ]
-        for case in cases:
-            tester.comp.params["startType"].val = "time (s)"
-            tester.comp.params["stopType"].val = "time (s)"
-            for param, val in case.items():
-                tester.comp.params[param].val = val
-            # Init
-            tester.comp.writeInitCode(buff)
-            assert buff.indentLevel == 0, msg.format(
-                "init", type(tester.comp).__name__, buff.indentLevel, case['startVal'], case['stopVal']
-            )
-            # Start routine
-            tester.comp.writeRoutineStartCode(buff)
-            assert buff.indentLevel == 0, msg.format(
-                "routine start", type(tester.comp).__name__, buff.indentLevel, case['startVal'], case['stopVal']
-            )
-            # Each frame
-            tester.comp.writeFrameCode(buff)
-            assert buff.indentLevel == 0, msg.format(
-                "each frame", type(tester.comp).__name__, buff.indentLevel, case['startVal'], case['stopVal']
-            )
-            # End routine
-            tester.comp.writeRoutineEndCode(buff)
-            assert buff.indentLevel == 0, msg.format(
-                "routine end", type(tester.comp).__name__, buff.indentLevel, case['startVal'], case['stopVal']
-            )
-            # End experiment
-            tester.comp.writeExperimentEndCode(buff)
-            assert buff.indentLevel == 0, msg.format(
-                "experiment end", type(tester.comp).__name__, buff.indentLevel, case['startVal'], case['stopVal']
-            )