@pyscript/core 0.1.22 → 0.2.0

package/tests/integration/test_py_terminal.py

@@ -1,270 +0,0 @@
-import time
-
-import pytest
-from playwright.sync_api import expect
-
-from .support import PyScriptTest, skip_worker
-
-pytest.skip(
-    reason="FIX LATER: pyscript NEXT doesn't support the Terminal yet",
-    allow_module_level=True,
-)
-
-
-class TestPyTerminal(PyScriptTest):
-    def test_py_terminal(self):
-        """
-        1. <py-terminal> should redirect stdout and stderr to the DOM
-
-        2. they also go to the console as usual
-        """
-        self.pyscript_run(
-            """
-            <py-terminal></py-terminal>
-
-            <py-script>
-                import sys
-                print('hello world')
-                print('this goes to stderr', file=sys.stderr)
-                print('this goes to stdout')
-            </py-script>
-            """
-        )
-        term = self.page.locator("py-terminal")
-        term_lines = term.inner_text().splitlines()
-        assert term_lines == [
-            "hello world",
-            "this goes to stderr",
-            "this goes to stdout",
-        ]
-        assert self.console.log.lines[-3:] == [
-            "hello world",
-            "this goes to stderr",
-            "this goes to stdout",
-        ]
-
-    @skip_worker("FIXME: js.document")
-    def test_two_terminals(self):
-        """
-        Multiple <py-terminal>s can cohexist.
-        A <py-terminal> receives only output from the moment it is added to
-        the DOM.
-        """
-        self.pyscript_run(
-            """
-            <py-terminal id="term1"></py-terminal>
-
-            <py-script>
-                import js
-                print('one')
-                term2 = js.document.createElement('py-terminal')
-                term2.id = 'term2'
-                js.document.body.append(term2)
-
-                print('two')
-                print('three')
-            </py-script>
-            """
-        )
-        term1 = self.page.locator("#term1")
-        term2 = self.page.locator("#term2")
-        term1_lines = term1.inner_text().splitlines()
-        term2_lines = term2.inner_text().splitlines()
-        assert term1_lines == ["one", "two", "three"]
-        assert term2_lines == ["two", "three"]
-
-    def test_auto_attribute(self):
-        self.pyscript_run(
-            """
-            <py-terminal auto></py-terminal>
-
-            <button id="my-button" py-click="print('hello world')">Click me</button>
-            """
-        )
-        term = self.page.locator("py-terminal")
-        expect(term).to_be_hidden()
-        self.page.locator("button").click()
-        expect(term).to_be_visible()
-        assert term.inner_text() == "hello world\n"
-
-    def test_config_auto(self):
-        """
-        config.terminal == "auto" is the default: a <py-terminal auto> is
-        automatically added to the page
-        """
-        self.pyscript_run(
-            """
-            <button id="my-button" py-click="print('hello world')">Click me</button>
-            """
-        )
-        term = self.page.locator("py-terminal")
-        expect(term).to_be_hidden()
-        assert "No <py-terminal> found, adding one" in self.console.info.text
-        #
-        self.page.locator("button").click()
-        expect(term).to_be_visible()
-        assert term.inner_text() == "hello world\n"
-
-    def test_config_true(self):
-        """
-        If we set config.terminal == true, a <py-terminal> is automatically added
-        """
-        self.pyscript_run(
-            """
-            <py-config>
-                terminal = true
-            </py-config>
-
-            <py-script>
-                print('hello world')
-            </py-script>
-            """
-        )
-        term = self.page.locator("py-terminal")
-        expect(term).to_be_visible()
-        assert term.inner_text() == "hello world\n"
-
-    def test_config_false(self):
-        """
-        If we set config.terminal == false, no <py-terminal> is added
-        """
-        self.pyscript_run(
-            """
-            <py-config>
-                terminal = false
-            </py-config>
-            """
-        )
-        term = self.page.locator("py-terminal")
-        assert term.count() == 0
-
-    def test_config_docked(self):
-        """
-        config.docked == "docked" is also the default: a <py-terminal auto docked> is
-        automatically added to the page
-        """
-        self.pyscript_run(
-            """
-            <button id="my-button" py-click="print('hello world')">Click me</button>
-            """
-        )
-        term = self.page.locator("py-terminal")
-        self.page.locator("button").click()
-        expect(term).to_be_visible()
-        assert term.get_attribute("docked") == ""
-
-    def test_xterm_function(self):
-        """Test a few basic behaviors of the xtermjs terminal.
-
-        This test isn't meant to capture all of the behaviors of an xtermjs terminal;
-        rather, it confirms with a few basic formatting sequences that (1) the xtermjs
-        terminal is functioning/loaded correctly and (2) that output toward that terminal
-        isn't being escaped in a way that prevents it reacting to escape seqeunces. The
-        main goal is preventing regressions.
-        """
-        self.pyscript_run(
-            """
-            <py-config>
-                xterm = true
-            </py-config>
-            <py-script>
-                print("\x1b[33mYellow\x1b[0m")
-                print("\x1b[4mUnderline\x1b[24m")
-                print("\x1b[1mBold\x1b[22m")
-                print("\x1b[3mItalic\x1b[23m")
-                print("done")
-            </py-script>
-            """
-        )
-
-        # Wait for "done" to actually appear in the xterm; may be delayed,
-        # since xtermjs processes its input buffer in chunks
-        last_line = self.page.get_by_text("done")
-        last_line.wait_for()
-
-        # Yes, this is not ideal. However, per http://xtermjs.org/docs/guides/hooks/
-        # "It is not possible to conclude, whether or when a certain chunk of data
-        # will finally appear on the screen," which is what we'd really like to know.
-        # By waiting for the "done" test to appear above, we get close, however it is
-        # possible for the text to appear and not be 'processed' (i.e.) formatted. This
-        # small delay should avoid that.
-        time.sleep(1)
-
-        rows = self.page.locator(".xterm-rows")
-
-        # The following use locator.evaluate() and getComputedStyle to get
-        # the computed CSS values; this tests that the lines are rendering
-        # properly in a better way than just testing whether they
-        # get the right css classes from xtermjs
-
-        # First line should be yellow
-        first_line = rows.locator("div").nth(0)
-        first_char = first_line.locator("span").nth(0)
-        color = first_char.evaluate(
-            "(element) => getComputedStyle(element).getPropertyValue('color')"
-        )
-        assert color == "rgb(196, 160, 0)"
-
-        # Second line should be underlined
-        second_line = rows.locator("div").nth(1)
-        first_char = second_line.locator("span").nth(0)
-        text_decoration = first_char.evaluate(
-            "(element) => getComputedStyle(element).getPropertyValue('text-decoration')"
-        )
-        assert "underline" in text_decoration
-
-        # We'll make sure the 'bold' font weight is more than the
-        # default font weight without specifying a specific value
-        baseline_font_weight = first_char.evaluate(
-            "(element) => getComputedStyle(element).getPropertyValue('font-weight')"
-        )
-
-        # Third line should be bold
-        third_line = rows.locator("div").nth(2)
-        first_char = third_line.locator("span").nth(0)
-        font_weight = first_char.evaluate(
-            "(element) => getComputedStyle(element).getPropertyValue('font-weight')"
-        )
-        assert int(font_weight) > int(baseline_font_weight)
-
-        # Fourth line should be italic
-        fourth_line = rows.locator("div").nth(3)
-        first_char = fourth_line.locator("span").nth(0)
-        font_style = first_char.evaluate(
-            "(element) => getComputedStyle(element).getPropertyValue('font-style')"
-        )
-        assert font_style == "italic"
-
-    def test_xterm_multiple(self):
-        """Test whether multiple x-terms on the page all function"""
-        self.pyscript_run(
-            """
-            <py-config>
-                xterm = true
-            </py-config>
-            <py-script>
-                print("\x1b[33mYellow\x1b[0m")
-                print("done")
-            </py-script>
-            <py-terminal id="a"></py-terminal>
-            <py-terminal id="b" data-testid="b"></py-terminal>
-            """
-        )
-
-        # Wait for "done" to actually appear in the xterm; may be delayed,
-        # since xtermjs processes its input buffer in chunks
-        last_line = self.page.get_by_test_id("b").get_by_text("done")
-        last_line.wait_for()
-
-        # Yes, this is not ideal. See note in `test_xterm_function`
-        time.sleep(1)
-
-        rows = self.page.locator("#a .xterm-rows")
-
-        # First line should be yellow
-        first_line = rows.locator("div").nth(0)
-        first_char = first_line.locator("span").nth(0)
-        color = first_char.evaluate(
-            "(element) => getComputedStyle(element).getPropertyValue('color')"
-        )
-        assert color == "rgb(196, 160, 0)"

package/tests/integration/test_runtime_attributes.py

@@ -1,64 +0,0 @@
-import pytest
-
-from .support import PyScriptTest
-
-
-class TestPyScriptRuntimeAttributes(PyScriptTest):
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_injected_html_with_py_event(self):
-        self.pyscript_run(
-            r"""
-            <div id="py-button-container"></div>
-            <py-script>
-              import js
-
-              py_button = Element("py-button-container")
-              py_button.element.innerHTML = '<button py-click="print_hello()"></button>'
-
-              def print_hello():
-                js.console.log("hello pyscript")
-            </py-script>
-            """
-        )
-        self.page.locator("button").click()
-        assert self.console.log.lines == ["hello pyscript"]
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_added_py_event(self):
-        self.pyscript_run(
-            r"""
-            <button id="py-button"></button>
-            <py-script>
-              import js
-
-              py_button = Element("py-button")
-              py_button.element.setAttribute("py-click", "print_hello()")
-
-              def print_hello():
-                js.console.log("hello pyscript")
-            </py-script>
-            """
-        )
-        self.page.locator("button").click()
-        assert self.console.log.lines == ["hello pyscript"]
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_added_then_removed_py_event(self):
-        self.pyscript_run(
-            r"""
-            <button id="py-button">live content</button>
-            <py-script>
-              import js
-
-              py_button = Element("py-button")
-              py_button.element.setAttribute("py-click", "print_hello()")
-
-              def print_hello():
-                js.console.log("hello pyscript")
-                py_button.element.removeAttribute("py-click")
-            </py-script>
-            """
-        )
-        self.page.locator("button").click()
-        self.page.locator("button").click()
-        assert self.console.log.lines == ["hello pyscript"]

package/tests/integration/test_script_type.py

@@ -1,121 +0,0 @@
-import pytest
-
-from .support import PyScriptTest
-
-
-class TestScriptTypePyScript(PyScriptTest):
-    def test_display_line_break(self):
-        self.pyscript_run(
-            r"""
-            <script type="py">
-                from pyscript import display
-                display('hello\nworld')
-            </script>
-            """
-        )
-        text_content = self.page.locator("script-py").text_content()
-        assert "hello\nworld" == text_content
-
-    def test_amp(self):
-        self.pyscript_run(
-            r"""
-            <script type="py">
-                from pyscript import display
-                display('a &amp; b')
-            </script>
-            """
-        )
-        text_content = self.page.locator("script-py").text_content()
-        assert "a &amp; b" == text_content
-
-    def test_quot(self):
-        self.pyscript_run(
-            r"""
-            <script type="py">
-                from pyscript import display
-                display('a &quot; b')
-            </script>
-            """
-        )
-        text_content = self.page.locator("script-py").text_content()
-        assert "a &quot; b" == text_content
-
-    def test_lt_gt(self):
-        self.pyscript_run(
-            r"""
-            <script type="py">
-                from pyscript import display
-                display('< &lt; &gt; >')
-            </script>
-            """
-        )
-        text_content = self.page.locator("script-py").text_content()
-        assert "< &lt; &gt; >" == text_content
-
-    def test_dynamically_add_script_type_py_tag(self):
-        self.pyscript_run(
-            """
-            <script>
-                function addPyScriptTag() {
-                    let tag = document.createElement('script');
-                    tag.type = 'py';
-                    tag.textContent = "print('hello world')";
-                    document.body.appendChild(tag);
-                }
-                addPyScriptTag();
-            </script>
-            """
-        )
-        # please note the test here was on timeout
-        # incapable of finding a <button> after the script
-        self.page.locator("script-py")
-
-        assert self.console.log.lines[-1] == "hello world"
-
-    def test_script_type_py_src_attribute(self):
-        self.writefile("foo.py", "print('hello from foo')")
-        self.pyscript_run(
-            """
-            <script type="py" src="foo.py"></script>
-            """
-        )
-        assert self.console.log.lines[-1] == "hello from foo"
-
-    @pytest.mark.skip("FIXME: test failure is unrelated")
-    def test_script_type_py_worker_attribute(self):
-        self.writefile("foo.py", "print('hello from foo')")
-        self.pyscript_run(
-            """
-            <script type="py" worker="foo.py"></script>
-            """
-        )
-        assert self.console.log.lines[-1] == "hello from foo"
-
-    @pytest.mark.skip("FIXME: output attribute is not implemented")
-    def test_script_type_py_output_attribute(self):
-        self.pyscript_run(
-            """
-            <div id="first"></div>
-            <script type="py" output="first">
-                print("<p>Hello</p>")
-            </script>
-            """
-        )
-        text = self.page.locator("#first").text_content()
-        assert "<p>Hello</p>" in text
-
-    @pytest.mark.skip("FIXME: stderr attribute is not implemented")
-    def test_script_type_py_stderr_attribute(self):
-        self.pyscript_run(
-            """
-            <div id="stdout-div"></div>
-            <div id="stderr-div"></div>
-            <py-script output="stdout-div" stderr="stderr-div">
-                import sys
-                print("one.", file=sys.stderr)
-                print("two.")
-            </py-script>
-            """
-        )
-        assert self.page.locator("#stdout-div").text_content() == "one.two."
-        assert self.page.locator("#stderr-div").text_content() == "one."

package/tests/integration/test_shadow_root.py

@@ -1,33 +0,0 @@
-import pytest
-
-from .support import PyScriptTest
-
-
-class TestShadowRoot(PyScriptTest):
-    # @skip_worker("FIXME: js.document")
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_reachable_shadow_root(self):
-        self.pyscript_run(
-            r"""
-            <script>
-                // reason to wait for py-script is that it's the entry point for
-                // all patches and the MutationObserver, otherwise being this a synchronous
-                // script the constructor gets instantly invoked at the node before
-                // py-script gets a chance to initialize itself.
-                customElements.whenDefined('py-script').then(() => {
-                    customElements.define('s-r', class extends HTMLElement {
-                      constructor() {
-                        super().attachShadow({mode: 'closed'}).innerHTML =
-                            '<div id="shadowed">OK</div>';
-                      }
-                  });
-                });
-            </script>
-            <s-r></s-r>
-            <py-script>
-                import js
-                js.console.log(Element("shadowed").innerHtml)
-            </py-script>
-            """
-        )
-        assert self.console.log.lines[-1] == "OK"

package/tests/integration/test_splashscreen.py

@@ -1,124 +0,0 @@
-import pytest
-from playwright.sync_api import expect
-
-from .support import PyScriptTest, skip_worker
-
-pytest.skip(
-    reason="DECIDE: Should we remove the splashscreen?", allow_module_level=True
-)
-
-
-class TestSplashscreen(PyScriptTest):
-    def test_autoshow_and_autoclose(self):
-        """
-        By default, we show the splashscreen and we close it when the loading is
-        complete.
-
-        XXX: this test is a bit fragile: now it works reliably because the
-        startup is so slow that when we do expect(div).to_be_visible(), the
-        splashscreen is still there. But in theory, if the startup become very
-        fast, it could happen that by the time we arrive in python lang, it
-        has already been removed.
-        """
-        self.pyscript_run(
-            """
-            <py-script>
-                print('hello pyscript')
-            </py-script>
-            """,
-            wait_for_pyscript=False,
-        )
-        div = self.page.locator("py-splashscreen > div")
-        expect(div).to_be_visible()
-        expect(div).to_contain_text("Python startup...")
-        assert "Python startup..." in self.console.info.text
-        #
-        # now we wait for the startup to complete
-        self.wait_for_pyscript()
-        #
-        # and now the splashscreen should have been removed
-        expect(div).to_be_hidden()
-        assert self.page.locator("py-locator").count() == 0
-
-        assert "hello pyscript" in self.console.log.lines
-
-    def test_autoclose_false(self):
-        self.pyscript_run(
-            """
-            <py-config>
-                [splashscreen]
-                autoclose = false
-            </py-config>
-            <py-script>
-                print('hello pyscript')
-            </py-script>
-            """,
-        )
-        div = self.page.locator("py-splashscreen > div")
-        expect(div).to_be_visible()
-        expect(div).to_contain_text("Python startup...")
-        expect(div).to_contain_text("Startup complete")
-        assert "hello pyscript" in self.console.log.lines
-
-    def test_autoclose_loader_deprecated(self):
-        self.pyscript_run(
-            """
-            <py-config>
-                autoclose_loader = false
-            </py-config>
-            <py-script>
-                print('hello pyscript')
-            </py-script>
-            """,
-        )
-        warning = self.page.locator(".py-warning")
-        inner_text = warning.inner_html()
-        assert "The setting autoclose_loader is deprecated" in inner_text
-
-        div = self.page.locator("py-splashscreen > div")
-        expect(div).to_be_visible()
-        expect(div).to_contain_text("Python startup...")
-        expect(div).to_contain_text("Startup complete")
-        assert "hello pyscript" in self.console.log.lines
-
-    def test_splashscreen_disabled_option(self):
-        self.pyscript_run(
-            """
-            <py-config>
-                [splashscreen]
-                enabled = false
-            </py-config>
-
-            <py-script>
-                def test():
-                    print("Hello pyscript!")
-                test()
-            </py-script>
-            """,
-        )
-        assert self.page.locator("py-splashscreen").count() == 0
-        assert self.console.log.lines[-1] == "Hello pyscript!"
-        py_terminal = self.page.wait_for_selector("py-terminal")
-        assert py_terminal.inner_text() == "Hello pyscript!\n"
-
-    @skip_worker("FIXME: js.document")
-    def test_splashscreen_custom_message(self):
-        self.pyscript_run(
-            """
-            <py-config>
-                [splashscreen]
-                    autoclose = false
-            </py-config>
-
-            <py-script>
-                from js import document
-
-                splashscreen = document.querySelector("py-splashscreen")
-                splashscreen.log("Hello, world!")
-            </py-script>
-            """,
-        )
-
-        splashscreen = self.page.locator("py-splashscreen")
-        assert splashscreen.count() == 1
-        assert "Hello, world!" in splashscreen.inner_text()