@pyscript/core 0.1.19 → 0.1.20

package/tests/integration/test_importmap.py

@@ -0,0 +1,66 @@
+import pytest
+
+from .support import PyScriptTest
+
+
+@pytest.mark.xfail(reason="See PR #938")
+class TestImportmap(PyScriptTest):
+    def test_importmap(self):
+        src = """
+            export function say_hello(who) {
+                console.log("hello from", who);
+            }
+        """
+        self.writefile("mymod.js", src)
+        #
+        self.pyscript_run(
+            """
+            <script type="importmap">
+            {
+              "imports": {
+                "mymod": "/mymod.js"
+              }
+            }
+            </script>
+
+            <script type="module">
+                import { say_hello } from "mymod";
+                say_hello("JS");
+            </script>
+
+            <py-script>
+                import mymod
+                mymod.say_hello("Python")
+            </py-script>
+            """
+        )
+        assert self.console.log.lines == [
+            "hello from JS",
+            "hello from Python",
+        ]
+
+    def test_invalid_json(self):
+        self.pyscript_run(
+            """
+            <script type="importmap">
+            this is not valid JSON
+            </script>
+
+            <py-script>
+                print("hello world")
+            </py-script>
+            """,
+            wait_for_pyscript=False,
+        )
+        # this error is raised by the browser itself, when *it* tries to parse
+        # the import map
+        self.check_js_errors("Failed to parse import map")
+
+        self.wait_for_pyscript()
+        assert self.console.log.lines == [
+            "hello world",
+        ]
+        # this warning is shown by pyscript, when *we* try to parse the import
+        # map
+        banner = self.page.locator(".py-warning")
+        assert "Failed to parse import map" in banner.inner_text()

package/tests/integration/test_interpreter.py

@@ -0,0 +1,98 @@
+import pytest
+
+from .support import PyScriptTest
+
+pytest.skip(
+    reason="FIXME: pyscript API changed doesn't expose pyscript to window anymore",
+    allow_module_level=True,
+)
+
+
+class TestInterpreterAccess(PyScriptTest):
+    """Test accessing Python objects from JS via pyscript.interpreter"""
+
+    def test_interpreter_python_access(self):
+        self.pyscript_run(
+            """
+            <py-script>
+                x = 1
+                def py_func():
+                    return 2
+            </py-script>
+            """
+        )
+
+        self.run_js(
+            """
+            const x = await pyscript.interpreter.globals.get('x');
+            const py_func = await pyscript.interpreter.globals.get('py_func');
+            const py_func_res = await py_func();
+            console.log(`x is ${x}`);
+            console.log(`py_func() returns ${py_func_res}`);
+            """
+        )
+        assert self.console.log.lines[-2:] == [
+            "x is 1",
+            "py_func() returns 2",
+        ]
+
+    def test_interpreter_script_execution(self):
+        """Test running Python code from js via pyscript.interpreter"""
+        self.pyscript_run("")
+
+        self.run_js(
+            """
+            const interface = pyscript.interpreter._remote.interface;
+            await interface.runPython('print("Interpreter Ran This")');
+            """
+        )
+
+        expected_message = "Interpreter Ran This"
+        assert self.console.log.lines[-1] == expected_message
+
+        py_terminal = self.page.wait_for_selector("py-terminal")
+        assert py_terminal.text_content() == expected_message
+
+    def test_backward_compatibility_runtime_script_execution(self):
+        """Test running Python code from js via pyscript.runtime"""
+        self.pyscript_run("")
+
+        self.run_js(
+            """
+            const interface = pyscript.runtime._remote.interpreter;
+            await interface.runPython('print("Interpreter Ran This")');
+            """
+        )
+
+        expected_message = "Interpreter Ran This"
+        assert self.console.log.lines[-1] == expected_message
+
+        py_terminal = self.page.wait_for_selector("py-terminal")
+        assert py_terminal.text_content() == expected_message
+
+    def test_backward_compatibility_runtime_python_access(self):
+        """Test accessing Python objects from JS via pyscript.runtime"""
+        self.pyscript_run(
+            """
+            <py-script>
+                x = 1
+                def py_func():
+                    return 2
+            </py-script>
+            """
+        )
+
+        self.run_js(
+            """
+            const x = await pyscript.interpreter.globals.get('x');
+            const py_func = await pyscript.interpreter.globals.get('py_func');
+            const py_func_res = await py_func();
+            console.log(`x is ${x}`);
+            console.log(`py_func() returns ${py_func_res}`);
+            """
+        )
+
+        assert self.console.log.lines[-2:] == [
+            "x is 1",
+            "py_func() returns 2",
+        ]

package/tests/integration/test_plugins.py

@@ -0,0 +1,419 @@
+import pytest
+
+from .support import PyScriptTest, skip_worker
+
+pytest.skip(
+    reason="FIX LATER: pyscript NEXT doesn't support plugins yet",
+    allow_module_level=True,
+)
+
+# Source code of a simple plugin that creates a Custom Element for testing purposes
+CE_PLUGIN_CODE = """
+from pyscript import Plugin
+from js import console
+
+plugin = Plugin('py-upper')
+
+console.log("py_upper Plugin loaded")
+
+@plugin.register_custom_element('py-up')
+class Upper:
+    def __init__(self, element):
+        self.element = element
+
+    def connect(self):
+        console.log("Upper plugin connected")
+        return self.element.originalInnerHTML.upper()
+"""
+
+# Source of a plugin hooks into the PyScript App lifecycle events
+HOOKS_PLUGIN_CODE = """
+from pyscript import Plugin
+from js import console
+
+class TestLogger(Plugin):
+    def configure(self, config):
+        console.log('configure called')
+
+    def beforeLaunch(self, config):
+        console.log('beforeLaunch called')
+
+    def afterSetup(self, config):
+        console.log('afterSetup called')
+
+    def afterStartup(self, config):
+        console.log('afterStartup called')
+
+    def beforePyScriptExec(self, interpreter, src, pyScriptTag):
+        console.log(f'beforePyScriptExec called')
+        console.log(f'before_src:{src}')
+
+    def afterPyScriptExec(self, interpreter, src, pyScriptTag, result):
+        console.log(f'afterPyScriptExec called')
+        console.log(f'after_src:{src}')
+
+    def onUserError(self, config):
+        console.log('onUserError called')
+
+
+plugin = TestLogger()
+"""
+
+# Source of script that defines a plugin with only beforePyScriptExec and
+# afterPyScriptExec methods
+PYSCRIPT_HOOKS_PLUGIN_CODE = """
+from pyscript import Plugin
+from js import console
+
+class ExecTestLogger(Plugin):
+
+    async def beforePyScriptExec(self, interpreter, src, pyScriptTag):
+        console.log(f'beforePyScriptExec called')
+        console.log(f'before_src:{src}')
+
+    async def afterPyScriptExec(self, interpreter, src, pyScriptTag, result):
+        console.log(f'afterPyScriptExec called')
+        console.log(f'after_src:{src}')
+        console.log(f'result:{result}')
+
+
+plugin = ExecTestLogger()
+"""
+
+# Source of script that defines a plugin with only beforePyScriptExec and
+# afterPyScriptExec methods
+PYREPL_HOOKS_PLUGIN_CODE = """
+from pyscript import Plugin
+from js import console
+
+console.warn("This is in pyrepl hooks file")
+
+class PyReplTestLogger(Plugin):
+
+    def beforePyReplExec(self, interpreter, src, outEl, pyReplTag):
+        console.log(f'beforePyReplExec called')
+        console.log(f'before_src:{src}')
+
+    def afterPyReplExec(self, interpreter, src, outEl, pyReplTag, result):
+        console.log(f'afterPyReplExec called')
+        console.log(f'after_src:{src}')
+        console.log(f'result:{result}')
+
+
+plugin = PyReplTestLogger()
+"""
+
+# Source of a script that doesn't call define a `plugin` attribute
+NO_PLUGIN_CODE = """
+from pyscript import Plugin
+from js import console
+
+class TestLogger(Plugin):
+    pass
+"""
+
+# Source code of a simple plugin that creates a Custom Element for testing purposes
+CODE_CE_PLUGIN_BAD_RETURNS = """
+from pyscript import Plugin
+from js import console
+
+plugin = Plugin('py-broken')
+
+@plugin.register_custom_element('py-up')
+class Upper:
+    def __init__(self, element):
+        self.element = element
+
+    def connect(self):
+        # Just returning something... anything other than a string should be ignore
+        return Plugin
+"""
+HTML_TEMPLATE_WITH_TAG = """
+    <py-config>
+        plugins = [
+            "./{plugin_name}.py"
+        ]
+    </py-config>
+
+    <{tagname}>
+        {html}
+    </{tagname}>
+"""
+HTML_TEMPLATE_NO_TAG = """
+    <py-config>
+        plugins = [
+            "./{plugin_name}.py"
+        ]
+    </py-config>
+"""
+
+
+def prepare_test(
+    plugin_name, code, tagname="", html="", template=HTML_TEMPLATE_WITH_TAG
+):
+    """
+    Prepares the test by writing a new plugin file named `plugin_name`.py, with `code` as its
+    content and run `pyscript_run` on `template` formatted with the above inputs to create the
+    page HTML code.
+
+    For example:
+
+    >> @prepare_test('py-upper', CE_PLUGIN_CODE, tagname='py-up', html="Hello World")
+    >> def my_foo(...):
+    >>     ...
+
+    will:
+
+    * write a new `py-upper.py` file to the FS
+    * the contents of `py-upper.py` is equal to CE_PLUGIN_CODE
+    * call self.pyscript_run with the following string:
+        '''
+            <py-config>
+                plugins = [
+                    "./py-upper.py"
+                ]
+            </py-config>
+
+            <py-up>
+                {html}
+            </py-up>
+        '''
+    * call `my_foo` just like a normal decorator would
+
+    """
+
+    def dec(f):
+        def _inner(self, *args, **kws):
+            self.writefile(f"{plugin_name}.py", code)
+            page_html = template.format(
+                plugin_name=plugin_name, tagname=tagname, html=html
+            )
+            self.pyscript_run(page_html)
+            return f(self, *args, **kws)
+
+        return _inner
+
+    return dec
+
+
+class TestPlugin(PyScriptTest):
+    @skip_worker("FIXME: relative paths")
+    @prepare_test("py-upper", CE_PLUGIN_CODE, tagname="py-up", html="Hello World")
+    def test_py_plugin_inline(self):
+        """Test that a regular plugin that returns new HTML content from connected works"""
+        # GIVEN a plugin that returns the all caps version of the tag innerHTML and logs text
+        # during it's execution/hooks
+
+        # EXPECT the plugin logs to be present in the console logs
+        log_lines = self.console.log.lines
+        for log_line in ["py_upper Plugin loaded", "Upper plugin connected"]:
+            assert log_line in log_lines
+
+        # EXPECT the inner text of the Plugin CustomElement to be all caps
+        rendered_text = self.page.locator("py-up").inner_text()
+        assert rendered_text == "HELLO WORLD"
+
+    @skip_worker("FIXME: relative paths")
+    @prepare_test("hooks_logger", HOOKS_PLUGIN_CODE, template=HTML_TEMPLATE_NO_TAG)
+    def test_execution_hooks(self):
+        """Test that a Plugin that hooks into the PyScript App events, gets called
+        for each one of them"""
+        # GIVEN a plugin that logs specific strings for each app execution event
+        hooks_available = ["afterSetup", "afterStartup"]
+        hooks_unavailable = [
+            "configure",
+            "beforeLaunch",
+            "beforePyScriptExec",
+            "afterPyScriptExec",
+            "beforePyReplExec",
+            "afterPyReplExec",
+        ]
+
+        # EXPECT it to log the correct logs for the events it intercepts
+        log_lines = self.console.log.lines
+        num_calls = {
+            method: log_lines.count(f"{method} called") for method in hooks_available
+        }
+        expected_calls = {method: 1 for method in hooks_available}
+        assert num_calls == expected_calls
+
+        # EXPECT it to NOT be called (hence not log anything) the events that happen
+        # before it's ready, hence is not called
+        unavailable_called = {
+            method: f"{method} called" in log_lines for method in hooks_unavailable
+        }
+        assert unavailable_called == {method: False for method in hooks_unavailable}
+
+        # TODO: It'd be actually better to check that the events get called in order
+
+    @skip_worker("FIXME: relative paths")
+    @prepare_test(
+        "exec_test_logger",
+        PYSCRIPT_HOOKS_PLUGIN_CODE,
+        template=HTML_TEMPLATE_NO_TAG + "\n<py-script id='pyid'>x=2; x</py-script>",
+    )
+    def test_pyscript_exec_hooks(self):
+        """Test that the beforePyScriptExec and afterPyScriptExec hooks work as intended"""
+        assert self.page.locator("py-script") is not None
+
+        log_lines: list[str] = self.console.log.lines
+
+        assert "beforePyScriptExec called" in log_lines
+        assert "afterPyScriptExec called" in log_lines
+
+        # These could be made better with a utility function that found log lines
+        # that match a filter function, or start with something
+        assert "before_src:x=2; x" in log_lines
+        assert "after_src:x=2; x" in log_lines
+        assert "result:2" in log_lines
+
+    @skip_worker("FIXME: relative paths")
+    @prepare_test(
+        "pyrepl_test_logger",
+        PYREPL_HOOKS_PLUGIN_CODE,
+        template=HTML_TEMPLATE_NO_TAG + "\n<py-repl id='pyid'>x=2; x</py-repl>",
+    )
+    def test_pyrepl_exec_hooks(self):
+        py_repl = self.page.locator("py-repl")
+        py_repl.locator("button").click()
+        # allow afterPyReplExec to also finish before the test finishes
+        self.wait_for_console("result:2")
+
+        log_lines: list[str] = self.console.log.lines
+
+        assert "beforePyReplExec called" in log_lines
+        assert "afterPyReplExec called" in log_lines
+
+        # These could be made better with a utility function that found log lines
+        # that match a filter function, or start with something
+        assert "before_src:x=2; x" in log_lines
+        assert "after_src:x=2; x" in log_lines
+        assert "result:2" in log_lines
+
+    @skip_worker("FIXME: relative paths")
+    @prepare_test("no_plugin", NO_PLUGIN_CODE)
+    def test_no_plugin_attribute_error(self):
+        """
+        Test a plugin that do not add the `plugin` attribute to its module
+        """
+        # GIVEN a Plugin NO `plugin` attribute in it's module
+        error_msg = (
+            "[pyscript/main] Cannot find plugin on Python module no_plugin! Python plugins "
+            'modules must contain a "plugin" attribute. For more information check the '
+            "plugins documentation."
+        )
+        # EXPECT an error for the missing attribute
+        assert error_msg in self.console.error.lines
+
+    @skip_worker("FIXME: relative paths")
+    def test_fetch_python_plugin(self):
+        """
+        Test that we can fetch a plugin from a remote URL. Note we need to use
+        the 'raw' URL for the plugin, otherwise the request will be rejected
+        by cors policy.
+        """
+        self.pyscript_run(
+            """
+            <py-config>
+                plugins = [
+                    "https://raw.githubusercontent.com/FabioRosado/pyscript-plugins/main/python/hello-world.py"
+                ]
+
+            </py-config>
+            <py-hello-world></py-hello-world>
+            """
+        )
+
+        hello_element = self.page.locator("py-hello-world")
+        assert hello_element.inner_html() == '<div id="hello">Hello World!</div>'
+
+    def test_fetch_js_plugin(self):
+        self.pyscript_run(
+            """
+            <py-config>
+                plugins = [
+                    "https://raw.githubusercontent.com/FabioRosado/pyscript-plugins/main/js/hello-world.js"
+                ]
+            </py-config>
+            """
+        )
+
+        hello_element = self.page.locator("py-hello-world")
+        assert hello_element.inner_html() == "<h1>Hello, world!</h1>"
+
+    def test_fetch_js_plugin_bare(self):
+        self.pyscript_run(
+            """
+            <py-config>
+                plugins = [
+                    "https://raw.githubusercontent.com/FabioRosado/pyscript-plugins/main/js/hello-world-base.js"
+                ]
+            </py-config>
+            """
+        )
+
+        hello_element = self.page.locator("py-hello-world")
+        assert hello_element.inner_html() == "<h1>Hello, world!</h1>"
+
+    def test_fetch_plugin_no_file_extension(self):
+        self.pyscript_run(
+            """
+            <py-config>
+                plugins = [
+                    "https://non-existent.blah/hello-world"
+                ]
+            </py-config>
+            """,
+            wait_for_pyscript=False,
+        )
+
+        expected_msg = (
+            "(PY2000): Unable to load plugin from "
+            "'https://non-existent.blah/hello-world'. Plugins "
+            "need to contain a file extension and be either a "
+            "python or javascript file."
+        )
+
+        assert self.assert_banner_message(expected_msg)
+
+    def test_fetch_js_plugin_non_existent(self):
+        self.pyscript_run(
+            """
+            <py-config>
+                plugins = [
+                    "http://non-existent.example.com/hello-world.js"
+                ]
+            </py-config>
+            """,
+            wait_for_pyscript=False,
+        )
+
+        expected_msg = (
+            "(PY0001): Fetching from URL "
+            "http://non-existent.example.com/hello-world.js failed "
+            "with error 'Failed to fetch'. Are your filename and "
+            "path correct?"
+        )
+
+        assert self.assert_banner_message(expected_msg)
+
+    def test_fetch_js_no_export(self):
+        self.pyscript_run(
+            """
+            <py-config>
+                plugins = [
+                    "https://raw.githubusercontent.com/FabioRosado/pyscript-plugins/main/js/hello-world-no-export.js"
+                ]
+            </py-config>
+            """,
+            wait_for_pyscript=False,
+        )
+
+        expected_message = (
+            "(PY2001): Unable to load plugin from "
+            "'https://raw.githubusercontent.com/FabioRosado/pyscript-plugins"
+            "/main/js/hello-world-no-export.js'. "
+            "Plugins need to contain a default export."
+        )
+
+        assert self.assert_banner_message(expected_message)