@pyscript/core 0.1.22 → 0.2.0

package/tests/integration/test_03_element.py

@@ -1,303 +0,0 @@
-import pytest
-
-from .support import PyScriptTest
-
-
-class TestElement(PyScriptTest):
-    """Test the Element api"""
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_id(self):
-        """Test the element id"""
-        self.pyscript_run(
-            """
-            <div id="foo"></div>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            print(el.id)
-            </py-script>
-            """
-        )
-        assert self.console.log.lines[-1] == "foo"
-
-        py_terminal = self.page.wait_for_selector("py-terminal")
-        assert "foo" in py_terminal.inner_text()
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_value(self):
-        """Test the element value"""
-        self.pyscript_run(
-            """
-            <input id="foo" value="bar">
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            print(el.value)
-            </py-script>
-            """
-        )
-        assert self.console.log.lines[-1] == "bar"
-
-        py_terminal = self.page.wait_for_selector("py-terminal")
-        assert "bar" in py_terminal.inner_text()
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_innerHtml(self):
-        """Test the element innerHtml"""
-        self.pyscript_run(
-            """
-            <div id="foo"><b>bar</b></div>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            print(el.innerHtml)
-            </py-script>
-            """
-        )
-        assert self.console.log.lines[-1] == "<b>bar</b>"
-
-        py_terminal = self.page.wait_for_selector("py-terminal")
-        assert "bar" in py_terminal.inner_text()
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_write_no_append(self):
-        """Test the element write"""
-        self.pyscript_run(
-            """
-            <div id="foo"></div>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            el.write("Hello!")
-            el.write("World!")
-            </py-script>
-            """
-        )
-        div = self.page.wait_for_selector("#foo")
-        assert "World!" in div.inner_text()
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_write_append(self):
-        """Test the element write"""
-        self.pyscript_run(
-            """
-            <div id="foo"></div>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            el.write("Hello!")
-            el.write("World!", append=True)
-            </py-script>
-            """
-        )
-        parent_div = self.page.wait_for_selector("#foo")
-
-        assert "Hello!" in parent_div.inner_text()
-        # confirm that the second write was appended
-        assert "Hello!<div>World!</div>" in parent_div.inner_html()
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_clear_div(self):
-        """Test the element clear"""
-        self.pyscript_run(
-            """
-            <div id="foo">Hello!</div>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            el.clear()
-            </py-script>
-            """
-        )
-        div = self.page.locator("#foo")
-        assert div.inner_text() == ""
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_clear_input(self):
-        """Test the element clear"""
-        self.pyscript_run(
-            """
-            <input id="foo" value="bar">
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            el.clear()
-            </py-script>
-            """
-        )
-        input = self.page.wait_for_selector("#foo")
-        assert input.input_value() == ""
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_select(self):
-        """Test the element select"""
-        self.pyscript_run(
-            """
-            <select id="foo">
-                <option value="bar">Bar</option>
-            </select>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            js.console.log(el.select("option").value)
-            </py-script>
-            """
-        )
-        assert self.console.log.lines[-1] == "bar"
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_select_content(self):
-        """Test the element select"""
-        self.pyscript_run(
-            """
-            <template id="foo">
-                <div>Bar</div>
-            </template>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            js.console.log(el.select("div", from_content=True).innerHtml)
-            </py-script>
-            """
-        )
-        assert self.console.log.lines[-1] == "Bar"
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_clone_no_id(self):
-        """Test the element clone"""
-        self.pyscript_run(
-            """
-            <div id="foo">Hello!</div>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            el.clone()
-            </py-script>
-            """
-        )
-        divs = self.page.locator("#foo")
-        assert divs.count() == 2
-        assert divs.first.inner_text() == "Hello!"
-        assert divs.last.inner_text() == "Hello!"
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_clone_with_id(self):
-        """Test the element clone"""
-        self.pyscript_run(
-            """
-            <div id="foo">Hello!</div>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            el.clone(new_id="bar")
-            </py-script>
-            """
-        )
-        divs = self.page.locator("#foo")
-        assert divs.count() == 1
-        assert divs.inner_text() == "Hello!"
-
-        clone = self.page.locator("#bar")
-        assert clone.inner_text() == "Hello!"
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_clone_to_other_element(self):
-        """Test the element clone"""
-        self.pyscript_run(
-            """
-            <div id="container">
-                <div id="bond">
-                    Bond
-                </div>
-                <div id="james">
-                    James
-                </div>
-            </div>
-            <py-script>
-                from pyscript import Element
-
-                bond_div = Element("bond")
-                james_div = Element("james")
-
-                bond_div.clone(new_id="bond-2", to=james_div)
-            </py-script>
-            """
-        )
-        bond_divs = self.page.locator("#bond")
-        james_divs = self.page.locator("#james")
-        bond_2_divs = self.page.locator("#bond-2")
-
-        assert bond_divs.count() == 1
-        assert james_divs.count() == 1
-        assert bond_2_divs.count() == 1
-
-        container_div = self.page.locator("#container")
-        # Make sure that the clones are rendered in the right order
-        assert container_div.inner_text() == "Bond\nJames\nBond"
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_remove_single_class(self):
-        """Test the element remove_class"""
-        self.pyscript_run(
-            """
-            <div id="foo" class="bar baz"></div>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            el.remove_class("bar")
-            </py-script>
-            """
-        )
-        div = self.page.locator("#foo")
-        assert div.get_attribute("class") == "baz"
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_remove_multiple_classes(self):
-        """Test the element remove_class"""
-        self.pyscript_run(
-            """
-            <div id="foo" class="foo bar baz"></div>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            el.remove_class(["foo", "baz", "bar"])
-            </py-script>
-            """
-        )
-        div = self.page.locator("#foo")
-        assert div.get_attribute("class") == ""
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_add_single_class(self):
-        """Test the element add_class"""
-        self.pyscript_run(
-            """
-            <style> .red { color: red; } </style>
-            <div id="foo">Hi!</div>
-            <py-script>
-            from pyscript import Element
-            el = Element("foo")
-            el.add_class("red")
-            </py-script>
-            """
-        )
-        div = self.page.locator("#foo")
-        assert div.get_attribute("class") == "red"
-
-    @pytest.mark.skip("FIXME: Element interface is gone. Replace with PyDom")
-    def test_element_add_multiple_class(self):
-        """Test the element add_class"""
-        self.pyscript_run(
-            """
-            <style> .red { color: red; } .bold { font-weight: bold; } </style>
-            <div id="foo">Hi!</div>
-            <py-script>
-                from pyscript import Element
-                el = Element("foo")
-                el.add_class(["red", "bold"])
-            </py-script>
-            """
-        )
-        div = self.page.locator("#foo")
-        assert div.get_attribute("class") == "red bold"

package/tests/integration/test_async.py

@@ -1,197 +0,0 @@
-from .support import PyScriptTest, filter_inner_text
-
-
-class TestAsync(PyScriptTest):
-    # ensure_future() and create_task() should behave similarly;
-    # we'll use the same source code to test both
-    coroutine_script = """
-        <py-script>
-        import js
-        import asyncio
-        js.console.log("first")
-        async def main():
-            await asyncio.sleep(1)
-            js.console.log("third")
-        asyncio.{func}(main())
-        js.console.log("second")
-        </py-script>
-        """
-
-    def test_asyncio_ensure_future(self):
-        self.pyscript_run(self.coroutine_script.format(func="ensure_future"))
-        self.wait_for_console("third")
-        assert self.console.log.lines[-3:] == ["first", "second", "third"]
-
-    def test_asyncio_create_task(self):
-        self.pyscript_run(self.coroutine_script.format(func="create_task"))
-        self.wait_for_console("third")
-        assert self.console.log.lines[-3:] == ["first", "second", "third"]
-
-    def test_asyncio_gather(self):
-        self.pyscript_run(
-            """
-            <py-script id="pys">
-            import asyncio
-            import js
-            from pyodide.ffi import to_js
-
-            async def coro(delay):
-                await asyncio.sleep(delay)
-                return(delay)
-
-            async def get_results():
-                results = await asyncio.gather(*[coro(d) for d in range(3,0,-1)])
-                js.console.log(str(results)) #Compare to string representation, not Proxy
-                js.console.log("DONE")
-
-            asyncio.ensure_future(get_results())
-            </py-script>
-            """
-        )
-        self.wait_for_console("DONE")
-        assert self.console.log.lines[-2:] == ["[3, 2, 1]", "DONE"]
-
-    def test_multiple_async(self):
-        self.pyscript_run(
-            """
-        <py-script>
-            import js
-            import asyncio
-            async def a_func():
-                for i in range(3):
-                    js.console.log('A', i)
-                    await asyncio.sleep(0.1)
-            asyncio.ensure_future(a_func())
-        </py-script>
-
-        <py-script>
-            import js
-            import asyncio
-            async def b_func():
-                for i in range(3):
-                    js.console.log('B', i)
-                    await asyncio.sleep(0.1)
-                js.console.log('b func done')
-            asyncio.ensure_future(b_func())
-        </py-script>
-        """
-        )
-        self.wait_for_console("b func done")
-        assert self.console.log.lines == [
-            "A 0",
-            "B 0",
-            "A 1",
-            "B 1",
-            "A 2",
-            "B 2",
-            "b func done",
-        ]
-
-    def test_multiple_async_multiple_display_targeted(self):
-        self.pyscript_run(
-            """
-                <py-script id='pyA'>
-                    from pyscript import display
-                    import js
-                    import asyncio
-
-                    async def a_func():
-                        for i in range(2):
-                            display(f'A{i}', target='pyA', append=True)
-                            await asyncio.sleep(0.1)
-                    asyncio.ensure_future(a_func())
-
-                </py-script>
-                <py-script id='pyB'>
-                    from pyscript import display
-                    import js
-                    import asyncio
-
-                    async def a_func():
-                        for i in range(2):
-                            display(f'B{i}', target='pyB', append=True)
-                            await asyncio.sleep(0.1)
-                        js.console.log("B DONE")
-
-                    asyncio.ensure_future(a_func())
-                </py-script>
-            """
-        )
-        self.wait_for_console("B DONE")
-        inner_text = self.page.inner_text("html")
-        assert "A0\nA1\nB0\nB1" in filter_inner_text(inner_text)
-
-    def test_async_display_untargeted(self):
-        self.pyscript_run(
-            """
-                <py-script>
-                    from pyscript import display
-                    import asyncio
-                    import js
-
-                    async def a_func():
-                        display('A')
-                        await asyncio.sleep(1)
-                        js.console.log("DONE")
-
-                    asyncio.ensure_future(a_func())
-                </py-script>
-            """
-        )
-        self.wait_for_console("DONE")
-        assert self.page.locator("py-script").inner_text() == "A"
-
-    def test_sync_and_async_order(self):
-        """
-        The order of execution is defined as follows:
-          1. first, we execute all the py-script tag in order
-          2. then, we start all the tasks which were scheduled with create_task
-
-        Note that tasks are started *AFTER* all py-script tags have been
-        executed. That's why the console.log() inside mytask1 and mytask2 are
-        executed after e.g. js.console.log("6").
-        """
-        src = """
-                <py-script>
-                    import js
-                    js.console.log("1")
-                </py-script>
-
-                <py-script>
-                    import asyncio
-                    import js
-
-                    async def mytask1():
-                        js.console.log("7")
-                        await asyncio.sleep(0)
-                        js.console.log("9")
-
-                    js.console.log("2")
-                    asyncio.create_task(mytask1())
-                    js.console.log("3")
-                </py-script>
-
-                <py-script>
-                    import js
-                    js.console.log("4")
-                </py-script>
-
-                <py-script>
-                    import asyncio
-                    import js
-
-                    async def mytask2():
-                        js.console.log("8")
-                        await asyncio.sleep(0)
-                        js.console.log("10")
-                        js.console.log("DONE")
-
-                    js.console.log("5")
-                    asyncio.create_task(mytask2())
-                    js.console.log("6")
-                </py-script>
-            """
-        self.pyscript_run(src, wait_for_pyscript=False)
-        self.wait_for_console("DONE")
-        lines = self.console.log.lines[-11:]
-        assert lines == ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "DONE"]

package/tests/integration/test_event_handling.py

@@ -1,193 +0,0 @@
-import pytest
-
-from .support import PyScriptTest
-
-pytest.skip(
-    reason="FIXME: @when decorator missing from pyscript", allow_module_level=True
-)
-
-
-class TestEventHandler(PyScriptTest):
-    def test_when_decorator_with_event(self):
-        """When the decorated function takes a single parameter,
-        it should be passed the event object
-        """
-        self.pyscript_run(
-            """
-            <button id="foo_id">foo_button</button>
-            <py-script>
-                from pyscript import when
-                @when("click", selector="#foo_id")
-                def foo(evt):
-                    print(f"I've clicked {evt.target} with id {evt.target.id}")
-            </py-script>
-        """
-        )
-        self.page.locator("text=foo_button").click()
-        console_text = self.console.all.lines
-        self.wait_for_console("I've clicked [object HTMLButtonElement] with id foo_id")
-        assert "I've clicked [object HTMLButtonElement] with id foo_id" in console_text
-        self.assert_no_banners()
-
-    def test_when_decorator_without_event(self):
-        """When the decorated function takes no parameters (not including 'self'),
-        it should be called without the event object
-        """
-        self.pyscript_run(
-            """
-            <button id="foo_id">foo_button</button>
-            <py-script>
-                from pyscript import when
-                @when("click", selector="#foo_id")
-                def foo():
-                    print("The button was clicked")
-            </py-script>
-        """
-        )
-        self.page.locator("text=foo_button").click()
-        self.wait_for_console("The button was clicked")
-        assert "The button was clicked" in self.console.log.lines
-        self.assert_no_banners()
-
-    def test_multiple_when_decorators_with_event(self):
-        self.pyscript_run(
-            """
-            <button id="foo_id">foo_button</button>
-            <button id="bar_id">bar_button</button>
-            <py-script>
-                from pyscript import when
-                @when("click", selector="#foo_id")
-                def foo(evt):
-                    print(f"I've clicked {evt.target} with id {evt.target.id}")
-                @when("click", selector="#bar_id")
-                def foo(evt):
-                    print(f"I've clicked {evt.target} with id {evt.target.id}")
-            </py-script>
-        """
-        )
-        self.page.locator("text=foo_button").click()
-        console_text = self.console.all.lines
-        self.wait_for_console("I've clicked [object HTMLButtonElement] with id foo_id")
-        assert "I've clicked [object HTMLButtonElement] with id foo_id" in console_text
-
-        self.page.locator("text=bar_button").click()
-        console_text = self.console.all.lines
-        self.wait_for_console("I've clicked [object HTMLButtonElement] with id bar_id")
-        assert "I've clicked [object HTMLButtonElement] with id bar_id" in console_text
-        self.assert_no_banners()
-
-    def test_two_when_decorators(self):
-        """When decorating a function twice, both should function"""
-        self.pyscript_run(
-            """
-            <button id="foo_id">foo_button</button>
-            <button class="bar_class">bar_button</button>
-            <py-script>
-                from pyscript import when
-                @when("click", selector="#foo_id")
-                @when("mouseover", selector=".bar_class")
-                def foo(evt):
-                    print(f"An event of type {evt.type} happened")
-            </py-script>
-        """
-        )
-        self.page.locator("text=bar_button").hover()
-        self.page.locator("text=foo_button").click()
-        self.wait_for_console("An event of type click happened")
-        assert "An event of type mouseover happened" in self.console.log.lines
-        assert "An event of type click happened" in self.console.log.lines
-        self.assert_no_banners()
-
-    def test_two_when_decorators_same_element(self):
-        """When decorating a function twice *on the same DOM element*, both should function"""
-        self.pyscript_run(
-            """
-            <button id="foo_id">foo_button</button>
-            <py-script>
-                from pyscript import when
-                @when("click", selector="#foo_id")
-                @when("mouseover", selector="#foo_id")
-                def foo(evt):
-                    print(f"An event of type {evt.type} happened")
-            </py-script>
-        """
-        )
-        self.page.locator("text=foo_button").hover()
-        self.page.locator("text=foo_button").click()
-        self.wait_for_console("An event of type click happened")
-        assert "An event of type mouseover happened" in self.console.log.lines
-        assert "An event of type click happened" in self.console.log.lines
-        self.assert_no_banners()
-
-    def test_when_decorator_multiple_elements(self):
-        """The @when decorator's selector should successfully select multiple
-        DOM elements
-        """
-        self.pyscript_run(
-            """
-            <button class="bar_class">button1</button>
-            <button class="bar_class">button2</button>
-            <py-script>
-                from pyscript import when
-                @when("click", selector=".bar_class")
-                def foo(evt):
-                    print(f"{evt.target.innerText} was clicked")
-            </py-script>
-        """
-        )
-        self.page.locator("text=button1").click()
-        self.page.locator("text=button2").click()
-        self.wait_for_console("button2 was clicked")
-        assert "button1 was clicked" in self.console.log.lines
-        assert "button2 was clicked" in self.console.log.lines
-        self.assert_no_banners()
-
-    def test_when_decorator_duplicate_selectors(self):
-        """ """
-        self.pyscript_run(
-            """
-            <button id="foo_id">foo_button</button>
-            <py-script>
-                from pyscript import when
-                @when("click", selector="#foo_id")
-                @when("click", selector="#foo_id")
-                def foo(evt):
-                    print(f"I've clicked {evt.target} with id {evt.target.id}")
-            </py-script>
-        """
-        )
-        self.page.locator("text=foo_button").click()
-        console_text = self.console.all.lines
-        self.wait_for_console("I've clicked [object HTMLButtonElement] with id foo_id")
-        assert (
-            console_text.count("I've clicked [object HTMLButtonElement] with id foo_id")
-            == 2
-        )
-        self.assert_no_banners()
-
-    def test_when_decorator_invalid_selector(self):
-        """When the selector parameter of @when is invalid, it should show an error"""
-        self.pyscript_run(
-            """
-            <button id="foo_id">foo_button</button>
-            <py-script>
-                from pyscript import when
-                @when("click", selector="#.bad")
-                def foo(evt):
-                    ...
-            </py-script>
-        """
-        )
-        self.page.locator("text=foo_button").click()
-        msg = "Failed to execute 'querySelectorAll' on 'Document': '#.bad' is not a valid selector."
-        error = self.page.wait_for_selector(".py-error")
-        banner_text = error.inner_text()
-
-        if msg not in banner_text:
-            raise AssertionError(
-                f"Expected message '{msg}' does not "
-                f"match banner text '{banner_text}'"
-            )
-
-        assert msg in self.console.error.lines[-1]
-        self.check_py_errors(msg)