psychopy 2024.1.2__py3-none-any.whl → 2024.1.4__py3-none-any.whl

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']
-            )

psychopy/tests/test_experiment/test_components/test_base_components.py

@@ -6,27 +6,9 @@ from pathlib import Path
 import pytest
 
 from psychopy import experiment
+from psychopy.experiment.loops import TrialHandler
 from psychopy.experiment.components import BaseComponent
-
-
-def _make_minimal_experiment(obj):
-    """
-    Make a minimal experiment with just one routine containing just one component, of the same class as the current
-    component but with all default params.
-    """
-    # Skip whole test if required attributes aren't present
-    if not hasattr(obj, "comp"):
-        pytest.skip()
-    # Make blank experiment
-    exp = experiment.Experiment()
-    rt = exp.addRoutine(routineName='TestRoutine')
-    exp.flow.addRoutine(rt, 0)
-    # Create instance of this component with all default params
-    compClass = type(obj.comp)
-    comp = compClass(exp=exp, parentName='TestRoutine', name=f"test{compClass.__name__}")
-    rt.append(comp)
-    # Return experiment, routine and component
-    return comp, rt, exp
+from psychopy.experiment.exports import IndentingBuffer
 
 
 def _find_global_resource_in_js_experiment(script, resource):
@@ -48,34 +30,228 @@ def _find_global_resource_in_js_experiment(script, resource):
     return resource in resourcesStr
 
 
-class _TestBaseComponentsMixin:
-    # Class in the PsychoPy libraries (visual, sound, hardware, etc.) corresponding to this component
-    libraryClass = None
+class BaseComponentTests:
+    # component class to test
+    comp = None
 
-    def test_icons(self):
-        """Check that component has icons for each app theme"""
-        # Skip whole test if required attributes aren't present
-        if not hasattr(self, "comp"):
+    # --- Utility methods ---
+    def make_minimal_experiment(self):
+        """
+        Make a minimal experiment with just one routine containing just one component, of the same class as the current component but with all default params.
+        """
+        # make blank experiment
+        exp = experiment.Experiment()
+        # add a Routine
+        rt = exp.addRoutine(routineName='TestRoutine')
+        exp.flow.addRoutine(rt, 0)
+        # add a loop around the Routine
+        loop = TrialHandler(exp=exp, name="testLoop")
+        exp.flow.addLoop(loop, 0, -1)
+        # create instance of this test's Component with all default params
+        comp = self.comp(exp=exp, parentName='TestRoutine', name=f"test{self.comp.__name__}")
+        rt.append(comp)
+        # return experiment, Routine and Component
+        return comp, rt, exp
+    
+    @pytest.fixture(autouse=True)
+    def assert_comp_class(self):
+        """
+        Make sure this test object has an associated Component class - and skip the test if not. This is run before each test by default.
+        """
+        # skip whole test if there is no Component connected to test class
+        if self.comp is None:
             pytest.skip()
-        # Pathify icon file path
+        # continue with the test as normal
+        yield
+    
+    # --- Heritable tests ---
+
+    def test_icons(self):
+        """
+        Check that Component has icons for each app theme and that these point to real files
+        """
+        # pathify icon file path
         icon = Path(self.comp.iconFile)
-        # Get paths for each theme
+        # get paths for each theme
         files = [
             icon.parent / "light" / icon.name,
             icon.parent / "dark" / icon.name,
             icon.parent / "classic" / icon.name,
         ]
-        # Check that each path is a file
+        # check that each path is a file
         for file in files:
-            assert file.is_file()
+            assert file.is_file(), (
+                f"Could not find file: {file}"
+            )
+    
+    def test_indentation_consistency(self):
+        """
+        No component should exit any of its write methods at a different indent level as it entered, as this would break subsequent components / routines.
+        """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # skip if component doesn't have a start/stop time
+        if "startVal" not in comp.params or "stopVal" not in comp.params:
+            pytest.skip()
+        # create a text buffer to write to
+        buff = IndentingBuffer(target="PsychoPy")
+        # template message for if test fails
+        errMsgTemplate = "Writing {} code for {} changes indent level by {} when start is `{}` and stop is `{}`."
+        # setup flow for writing
+        exp.flow.writeStartCode(buff)
+        # combinations of start/stop being set/unset to try
+        cases = [
+            {"startVal": "0", "stopVal": "1"},
+            {"startVal": "", "stopVal": "1"},
+            {"startVal": "0", "stopVal": ""},
+            {"startVal": "", "stopVal": ""},
+        ]
+        for case in cases:
+            # update error message for this case
+            errMsg = errMsgTemplate.format(
+                "{}", type(comp).__name__, "{}", case['startVal'], case['stopVal']
+            )
+            # set start/stop types
+            comp.params["startType"].val = "time (s)"
+            comp.params["stopType"].val = "time (s)"
+            # set start/stop values
+            for param, val in case.items():
+                comp.params[param].val = val
+            # write init code
+            comp.writeInitCode(buff)
+            # check indent
+            assert buff.indentLevel == 0, errMsg.format(
+                "init", buff.indentLevel
+            )
+            # write routine start code
+            comp.writeRoutineStartCode(buff)
+            # check indent
+            assert buff.indentLevel == 0, errMsg.format(
+                "routine start", buff.indentLevel
+            )
+            # write each frame code
+            comp.writeFrameCode(buff)
+            # check indent
+            assert buff.indentLevel == 0, errMsg.format(
+                "each frame", buff.indentLevel
+            )
+            # write end routine code
+            comp.writeRoutineEndCode(buff)
+            # check indent
+            assert buff.indentLevel == 0, errMsg.format(
+                "routine end", buff.indentLevel
+            )
+            # write end experiment code
+            comp.writeExperimentEndCode(buff)
+            # check indent
+            assert buff.indentLevel == 0, errMsg.format(
+                "experiment end", buff.indentLevel
+            )
+
+    def test_disabled_default_val(self):
+        """
+        Test that components created with default params are not disabled
+        """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # check whether it can be disabled
+        assert 'disabled' in comp.params, (
+            f"{type(comp).__name__} does not have a 'disabled' attribute."
+        )
+        # check that disabled defaults to False
+        assert comp.params['disabled'].val is False, f"{type(comp).__name__} is defaulting to disabled."
+
+    def test_disabled_code_muting(self):
+        """
+        Test that components are only written when enabled and targets match.
+        """
+        # Code Component is never referenced by name, so skip it for this test
+        if self.comp.__name__ == "CodeComponent":
+            pytest.skip()
+        # Make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # Write experiment and check that component is written
+        pyScript = exp.writeScript(target="PsychoPy")
+        if "PsychoPy" in type(comp).targets:
+            assert comp.name in pyScript, (
+                f"{type(comp).__name__} not found in compiled Python script when enabled and PsychoPy in targets."
+            )
+        else:
+            assert comp.name not in pyScript, (
+                f"{type(comp).__name__} found in compiled Python script when enabled but PsychoPy not in targets."
+            )
+        # ## disabled until js can compile without saving
+        # jsScript = exp.writeScript(target="PsychoJS")
+        # if "PsychoJS" in type(comp).targets:
+        #     assert comp.name in jsScript, (
+        #         f"{type(comp).__name__} not found in compiled Python script when enabled and PsychoJS in targets."
+        #     )
+        # else:
+        #     assert comp.name not in jsScript, (
+        #         f"{type(comp).__name__} found in compiled Python script when enabled but PsychoJS not in targets."
+        #     )
+
+        # disable component then do same tests but assert not present
+        comp.params['disabled'].val = True
+
+        pyScript = exp.writeScript(target="PsychoPy")
+        if "PsychoPy" in type(comp).targets:
+            assert comp.name not in pyScript, (
+                f"{type(comp).__name__} found in compiled Python script when disabled but PsychoPy in targets."
+            )
+        else:
+            assert comp.name not in pyScript, (
+                f"{type(comp).__name__} found in compiled Python script when disabled and PsychoPy not in targets."
+            )
+        # ## disabled until js can compile without saving
+        # jsScript = exp.writeScript(target="PsychoJS")
+        # if "PsychoJS" in type(comp).targets:
+        #     assert comp.name not in jsScript, (
+        #         f"{type(comp).__name__} found in compiled Python script when disabled but PsychoJS in targets."
+        #     )
+        # else:
+        #     assert comp.name not in jsScript, (
+        #         f"{type(comp).__name__} found in compiled Python script when disabled and PsychoJS not in targets."
+        #     )
 
-    def testDeviceClassRefs(self):
+    def test_disabled_components_stay_in_routine(self):
+        """
+        Test that disabled components aren't removed from their routine when experiment is written.
+        """
+        comp, rt, exp = self.make_minimal_experiment()
+        # Disable component
+        comp.params['disabled'].val = True
+        # Writing the script drops the component but, if working properly, only from a copy of the routine, not the
+        # original!
+        exp.writeScript()
+
+        assert comp in rt, f"Disabling {type(comp).name} appears to remove it from its routine on compile."
+class _TestLibraryClassMixin:
+    # class in the PsychoPy libraries (visual, sound, hardware, etc.) corresponding to this component
+    libraryClass = None
+
+    # --- Utility methods ---
+
+    @pytest.fixture(autouse=True)
+    def assert_lib_class(self):
+        """
+        Make sure this test object has an associated library class - and skip the test if not. This is run before each test by default.
+        """
+        # skip whole test if there is no Component connected to test class
+        if self.libraryClass is None:
+            pytest.skip()
+        # continue with the test as normal
+        yield
+    
+    # --- Heritable tests ---
+
+    def test_device_class_refs(self):
         """
         Check that any references to device classes in this Routine object point to classes which
         exist.
         """
         # make minimal experiment just for this test
-        comp, rt, exp = _make_minimal_experiment(self)
+        comp, rt, exp = self.make_minimal_experiment()
         # skip test if this element doesn't point to any hardware class
         if not hasattr(comp, "deviceClasses"):
             pytest.skip()
@@ -91,13 +267,7 @@ class _TestBaseComponentsMixin:
 
     def test_params_used(self):
         # Make minimal experiment just for this test
-        comp, rt, exp = _make_minimal_experiment(self)
-        # Skip if component shouldn't use all of its params
-        if type(comp).__name__ in ["SettingsComponent", "CodeComponent"]:
-            pytest.skip()
-        # Skip if component is deprecated
-        if type(comp).__name__ in ['RatingScaleComponent', 'PatchComponent']:
-            pytest.skip()
+        comp, rt, exp = self.make_minimal_experiment()
         # Try with PsychoPy and PsychoJS
         for target in ("PsychoPy", "PsychoJS"):
             ## Skip PsychoJS until can write script without saving
@@ -134,11 +304,8 @@ class _TestBaseComponentsMixin:
         """
         Check that all params which are settable each frame/repeat have a set method in the corresponding class.
         """
-        # Skip if there's no corresponding library class
-        if self.libraryClass is None:
-            return
         # Make minimal experiment just for this test
-        comp, rt, exp = _make_minimal_experiment(self)
+        comp, rt, exp = self.make_minimal_experiment()
         # Check each param
         for paramName, param in comp.params.items():
             if not param.direct:
@@ -167,91 +334,11 @@ class _TestBaseComponentsMixin:
                 )
 
 
-class _TestDisabledMixin:
-    def test_disabled_default_val(self):
-        """
-        Test that components created with default params are not disabled
-        """
-        # Make minimal experiment just for this test
-        comp, rt, exp = _make_minimal_experiment(self)
-        # Check whether it can be disabled
-        assert 'disabled' in comp.params, (
-            f"{type(comp).__name__} does not have a 'disabled' attribute."
-        )
-        # Check that disabled defaults to False
-        assert comp.params['disabled'].val is False, f"{type(comp).__name__} is defaulting to disabled."
-
-    def test_code_muting(self):
-        """
-        Test that components are only written when enabled and targets match.
-        """
-        # Make minimal experiment just for this test
-        comp, rt, exp = _make_minimal_experiment(self)
-        # Skip for Code components as these purely inject code, name isn't used
-        if type(comp).__name__ in ("CodeComponent"):
-            pytest.skip()
-        # Write experiment and check that component is written
-        pyScript = exp.writeScript(target="PsychoPy")
-        if "PsychoPy" in type(comp).targets:
-            assert comp.name in pyScript, (
-                f"{type(comp).__name__} not found in compiled Python script when enabled and PsychoPy in targets."
-            )
-        else:
-            assert comp.name not in pyScript, (
-                f"{type(comp).__name__} found in compiled Python script when enabled but PsychoPy not in targets."
-            )
-        # ## disabled until js can compile without saving
-        # jsScript = exp.writeScript(target="PsychoJS")
-        # if "PsychoJS" in type(comp).targets:
-        #     assert comp.name in jsScript, (
-        #         f"{type(comp).__name__} not found in compiled Python script when enabled and PsychoJS in targets."
-        #     )
-        # else:
-        #     assert comp.name not in jsScript, (
-        #         f"{type(comp).__name__} found in compiled Python script when enabled but PsychoJS not in targets."
-        #     )
-
-        # Disable component then do same tests but assert not present
-        comp.params['disabled'].val = True
-
-        pyScript = exp.writeScript(target="PsychoPy")
-        if "PsychoPy" in type(comp).targets:
-            assert comp.name not in pyScript, (
-                f"{type(comp).__name__} found in compiled Python script when disabled but PsychoPy in targets."
-            )
-        else:
-            assert comp.name not in pyScript, (
-                f"{type(comp).__name__} found in compiled Python script when disabled and PsychoPy not in targets."
-            )
-        # ## disabled until js can compile without saving
-        # jsScript = exp.writeScript(target="PsychoJS")
-        # if "PsychoJS" in type(comp).targets:
-        #     assert comp.name not in jsScript, (
-        #         f"{type(comp).__name__} found in compiled Python script when disabled but PsychoJS in targets."
-        #     )
-        # else:
-        #     assert comp.name not in jsScript, (
-        #         f"{type(comp).__name__} found in compiled Python script when disabled and PsychoJS not in targets."
-        #     )
-
-    def test_disabled_components_stay_in_routine(self):
-        """
-        Test that disabled components aren't removed from their routine when experiment is written.
-        """
-        comp, rt, exp = _make_minimal_experiment(self)
-        # Disable component
-        comp.params['disabled'].val = True
-        # Writing the script drops the component but, if working properly, only from a copy of the routine, not the
-        # original!
-        exp.writeScript()
-
-        assert comp in rt, f"Disabling {type(comp).name} appears to remove it from its routine on compile."
-
 
 class _TestDepthMixin:
     def test_depth(self):
         # Make minimal experiment
-        comp, rt, exp = _make_minimal_experiment(self)
+        comp, rt, exp = self.make_minimal_experiment()
         # Get class we're currently working with
         compClass = type(comp)
         # Add index to component name