change tests to use new pyscript.web namespace

pyscript · fpliger · Jul 3, 2024 · Jun 4, 2024 · Jun 4, 2024 · Jun 4, 2024
commit 12f161958674a5ee5dae4ce19313bd92b31ea624
diff --git a/pyscript.core/test/pyscript_dom/tests/test_dom.py b/pyscript.core/test/pyscript_dom/tests/test_dom.py
@@ -2,19 +2,20 @@
 
 import pytest
 from pyscript import document, when
-from pyweb import pydom
+# from pyweb import pydom
+from pyscript.web import dom
 
 
 class TestDocument:
     def test__element(self):
-        assert pydom._js == document
+        assert dom._js == document
 
     def test_no_parent(self):
-        assert pydom.parent is None
+        assert dom.parent is None
 
     def test_create_element(self):
-        new_el = pydom.create("div")
-        assert isinstance(new_el, pydom.BaseElement)
+        new_el = dom.create("div")
+        assert isinstance(new_el, dom.BaseElement)
         assert new_el._js.tagName == "DIV"
         # EXPECT the new element to be associated with the document
         assert new_el.parent == None
@@ -26,14 +27,14 @@ def test_getitem_by_id():
     txt = "You found test_id_selector"
     selector = f"#{id_}"
     # EXPECT the element to be found by id
-    result = pydom[selector]
+    result = dom[selector]
     div = result[0]
     # EXPECT the element text value to match what we expect and what
     # the JS document.querySelector API would return
     assert document.querySelector(selector).innerHTML == div.html == txt
     # EXPECT the results to be of the right types
-    assert isinstance(div, pydom.BaseElement)
-    assert isinstance(result, pydom.ElementCollection)
+    assert isinstance(div, dom.BaseElement)
+    assert isinstance(result, dom.ElementCollection)
 
 
 def test_getitem_by_class():
@@ -43,7 +44,7 @@ def test_getitem_by_class():
         "test_selector_w_children_child_1",
     ]
     expected_class = "a-test-class"
-    result = pydom[f".{expected_class}"]
+    result = dom[f".{expected_class}"]
     div = result[0]
 
     # EXPECT to find exact number of elements with the class in the page (== 3)
@@ -54,7 +55,7 @@ def test_getitem_by_class():
 
 
 def test_read_n_write_collection_elements():
-    elements = pydom[".multi-elems"]
+    elements = dom[".multi-elems"]
 
     for element in elements:
         assert element.html == f"Content {element.id.replace('#', '')}"
@@ -69,15 +70,15 @@ class TestElement:
     def test_query(self):
         # GIVEN an existing element on the page, with at least 1 child element
         id_ = "test_selector_w_children"
-        parent_div = pydom[f"#{id_}"][0]
+        parent_div = dom[f"#{id_}"][0]
 
         # EXPECT it to be able to query for the first child element
         div = parent_div.find("div")[0]
 
         # EXPECT the new element to be associated with the parent
         assert div.parent == parent_div
         # EXPECT the new element to be a BaseElement
-        assert isinstance(div, pydom.BaseElement)
+        assert isinstance(div, dom.BaseElement)
         # EXPECT the div attributes to be == to how they are configured in the page
         assert div.html == "Child 1"
         assert div.id == "test_selector_w_children_child_1"
@@ -86,8 +87,8 @@ def test_equality(self):
         # GIVEN 2 different Elements pointing to the same underlying element
         id_ = "test_id_selector"
         selector = f"#{id_}"
-        div = pydom[selector][0]
-        div2 = pydom[selector][0]
+        div = dom[selector][0]
+        div2 = dom[selector][0]
 
         # EXPECT them to be equal
         assert div == div2
@@ -102,7 +103,7 @@ def test_equality(self):
 
     def test_append_element(self):
         id_ = "element-append-tests"
-        div = pydom[f"#{id_}"][0]
+        div = dom[f"#{id_}"][0]
         len_children_before = len(div.children)
         new_el = div.create("p")
         div.append(new_el)
@@ -111,7 +112,7 @@ def test_append_element(self):
 
     def test_append_js_element(self):
         id_ = "element-append-tests"
-        div = pydom[f"#{id_}"][0]
+        div = dom[f"#{id_}"][0]
         len_children_before = len(div.children)
         new_el = div.create("p")
         div.append(new_el._js)
@@ -120,9 +121,9 @@ def test_append_js_element(self):
 
     def test_append_collection(self):
         id_ = "element-append-tests"
-        div = pydom[f"#{id_}"][0]
+        div = dom[f"#{id_}"][0]
         len_children_before = len(div.children)
-        collection = pydom[".collection"]
+        collection = dom[".collection"]
         div.append(collection)
         assert len(div.children) == len_children_before + len(collection)
 
@@ -132,40 +133,40 @@ def test_append_collection(self):
     def test_read_classes(self):
         id_ = "test_class_selector"
         expected_class = "a-test-class"
-        div = pydom[f"#{id_}"][0]
+        div = dom[f"#{id_}"][0]
         assert div.classes == [expected_class]
 
     def test_add_remove_class(self):
         id_ = "div-no-classes"
         classname = "tester-class"
-        div = pydom[f"#{id_}"][0]
+        div = dom[f"#{id_}"][0]
         assert not div.classes
         div.add_class(classname)
-        same_div = pydom[f"#{id_}"][0]
+        same_div = dom[f"#{id_}"][0]
         assert div.classes == [classname] == same_div.classes
         div.remove_class(classname)
         assert div.classes == [] == same_div.classes
 
     def test_when_decorator(self):
         called = False
 
-        just_a_button = pydom["#a-test-button"][0]
+        just_a_button = dom["#a-test-button"][0]
 
         @when("click", just_a_button)
         def on_click(event):
             nonlocal called
             called = True
 
         # Now let's simulate a click on the button (using the low level JS API)
-        # so we don't risk pydom getting in the way
+        # so we don't risk dom getting in the way
         assert not called
         just_a_button._js.click()
 
         assert called
 
     def test_html_attribute(self):
         # GIVEN an existing element on the page with a known empty text content
-        div = pydom["#element_attribute_tests"][0]
+        div = dom["#element_attribute_tests"][0]
 
         # WHEN we set the html attribute
         div.html = "<b>New Content</b>"
@@ -177,7 +178,7 @@ def test_html_attribute(self):
 
     def test_text_attribute(self):
         # GIVEN an existing element on the page with a known empty text content
-        div = pydom["#element_attribute_tests"][0]
+        div = dom["#element_attribute_tests"][0]
 
         # WHEN we set the html attribute
         div.text = "<b>New Content</b>"
@@ -190,12 +191,12 @@ def test_text_attribute(self):
 
 class TestCollection:
     def test_iter_eq_children(self):
-        elements = pydom[".multi-elems"]
+        elements = dom[".multi-elems"]
         assert [el for el in elements] == [el for el in elements.children]
         assert len(elements) == 3
 
     def test_slices(self):
-        elements = pydom[".multi-elems"]
+        elements = dom[".multi-elems"]
         assert elements[0]
         _slice = elements[:2]
         assert len(_slice) == 2
@@ -205,34 +206,34 @@ def test_slices(self):
 
     def test_style_rule(self):
         selector = ".multi-elems"
-        elements = pydom[selector]
+        elements = dom[selector]
         for el in elements:
             assert el.style["background-color"] != "red"
 
         elements.style["background-color"] = "red"
 
-        for i, el in enumerate(pydom[selector]):
+        for i, el in enumerate(dom[selector]):
             assert elements[i].style["background-color"] == "red"
             assert el.style["background-color"] == "red"
 
         elements.style.remove("background-color")
 
-        for i, el in enumerate(pydom[selector]):
+        for i, el in enumerate(dom[selector]):
             assert el.style["background-color"] != "red"
             assert elements[i].style["background-color"] != "red"
 
     def test_when_decorator(self):
         called = False
 
-        buttons_collection = pydom["button"]
+        buttons_collection = dom["button"]
 
         @when("click", buttons_collection)
         def on_click(event):
             nonlocal called
             called = True
 
         # Now let's simulate a click on the button (using the low level JS API)
-        # so we don't risk pydom getting in the way
+        # so we don't risk dom getting in the way
         assert not called
         for button in buttons_collection:
             button._js.click()
@@ -242,32 +243,32 @@ def on_click(event):
 
 class TestCreation:
     def test_create_document_element(self):
-        new_el = pydom.create("div")
+        new_el = dom.create("div")
         new_el.id = "new_el_id"
-        assert isinstance(new_el, pydom.BaseElement)
+        assert isinstance(new_el, dom.BaseElement)
         assert new_el._js.tagName == "DIV"
         # EXPECT the new element to be associated with the document
         assert new_el.parent == None
-        pydom.body.append(new_el)
+        dom.body.append(new_el)
 
-        assert pydom["#new_el_id"][0].parent == pydom.body
+        assert dom["#new_el_id"][0].parent == dom.body
 
     def test_create_element_child(self):
         selector = "#element-creation-test"
-        parent_div = pydom[selector][0]
+        parent_div = dom[selector][0]
 
         # Creating an element from another element automatically creates that element
         # as a child of the original element
         new_el = parent_div.create(
             "p", classes=["code-description"], html="Ciao PyScripters!"
         )
 
-        assert isinstance(new_el, pydom.BaseElement)
+        assert isinstance(new_el, dom.BaseElement)
         assert new_el._js.tagName == "P"
         # EXPECT the new element to be associated with the document
         assert new_el.parent == parent_div
 
-        assert pydom[selector][0].children[0] == new_el
+        assert dom[selector][0].children[0] == new_el
 
 
 class TestInput:
@@ -281,7 +282,7 @@ class TestInput:
     def test_value(self):
         for id_ in self.input_ids:
             expected_type = id_.split("_")[-1]
-            result = pydom[f"#{id_}"]
+            result = dom[f"#{id_}"]
             input_el = result[0]
             assert input_el._js.type == expected_type
             assert input_el.value == f"Content {id_}" == input_el._js.value
@@ -299,7 +300,7 @@ def test_value(self):
 
     def test_set_value_collection(self):
         for id_ in self.input_ids:
-            input_el = pydom[f"#{id_}"]
+            input_el = dom[f"#{id_}"]
 
             assert input_el.value[0] == f"Content {id_}" == input_el[0].value
 
@@ -308,35 +309,35 @@ def test_set_value_collection(self):
             assert input_el.value[0] == new_value == input_el[0].value
 
     def test_element_without_value(self):
-        result = pydom[f"#tests-terminal"][0]
+        result = dom[f"#tests-terminal"][0]
         with pytest.raises(AttributeError):
             result.value = "some value"
 
     def test_element_without_collection(self):
-        result = pydom[f"#tests-terminal"]
+        result = dom[f"#tests-terminal"]
         with pytest.raises(AttributeError):
             result.value = "some value"
 
     def test_element_without_collection(self):
-        result = pydom[f"#tests-terminal"]
+        result = dom[f"#tests-terminal"]
         with pytest.raises(AttributeError):
             result.value = "some value"
 
 
 class TestSelect:
     def test_select_options_iter(self):
-        select = pydom[f"#test_select_element_w_options"][0]
+        select = dom[f"#test_select_element_w_options"][0]
 
         for i, option in enumerate(select.options, 1):
             assert option.value == f"{i}"
             assert option.html == f"Option {i}"
 
     def test_select_options_len(self):
-        select = pydom[f"#test_select_element_w_options"][0]
+        select = dom[f"#test_select_element_w_options"][0]
         assert len(select.options) == 2
 
     def test_select_options_clear(self):
-        select = pydom[f"#test_select_element_to_clear"][0]
+        select = dom[f"#test_select_element_to_clear"][0]
         assert len(select.options) == 3
 
         select.options.clear()
@@ -345,7 +346,7 @@ def test_select_options_clear(self):
 
     def test_select_element_add(self):
         # GIVEN the existing select element with no options
-        select = pydom[f"#test_select_element"][0]
+        select = dom[f"#test_select_element"][0]
 
         # EXPECT the select element to have no options
         assert len(select.options) == 0
@@ -426,7 +427,7 @@ def test_select_element_add(self):
 
     def test_select_options_remove(self):
         # GIVEN the existing select element with 3 options
-        select = pydom[f"#test_select_element_to_remove"][0]
+        select = dom[f"#test_select_element_to_remove"][0]
 
         # EXPECT the select element to have 3 options
         assert len(select.options) == 4
@@ -448,7 +449,7 @@ def test_select_options_remove(self):
 
     def test_select_get_selected_option(self):
         # GIVEN the existing select element with one selected option
-        select = pydom[f"#test_select_element_w_options"][0]
+        select = dom[f"#test_select_element_w_options"][0]
 
         # WHEN we get the selected option
         selected_option = select.options.selected

diff --git a/pyscript.core/tests/integration/test_pyweb.py b/pyscript.core/tests/integration/test_pyweb.py
@@ -101,8 +101,9 @@ def parse_value(v):
         code_ = f"""
                 from pyscript import when
             <script type="{interpreter}">
-                from pyweb import pydom
-                from pyweb.ui.elements import {el_type}
+                from pyscript.web import dom
+                from pyscript.web.elements import {el_type}
+
                 el = {el_type}({attributes})
                 pydom.body.append(el)
             </script>