def __init__(self,
*args: Any,
element_factory: _T_ElementFactory = None,
**kwargs: Any) -> None:
"""Initialize parser."""
super().__init__(*args, **kwargs) # type: ignore
from wdom.node import DocumentFragment
from wdom.document import create_element
self.elm = DocumentFragment() # type: ParentNode
self.root = self.elm
self.current_tag = ''
self.element_factory = element_factory or create_element
async def test_add_df(self):
self.df.append(self.c1, self.c2, 'text')
self.tag.appendChild(self.df)
await self.wait_for_element(self.c1)
await self.wait_for_element(self.c2)
self.assertEqual(await self.get_text(), 'child1child2text')
df = DocumentFragment()
df.append(self.c3, 'text2')
self.tag.appendChild(df)
await self.wait_for_element(self.c3)
self.assertEqual(await self.get_text(), 'child1child2textchild3text2')
def test_add_df(self):
self.set_element(self.tag)
self.df.append(self.c1, self.c2, 'text')
self.tag.appendChild(self.df)
self.wait_until(lambda: self.element.text == 'child1child2text')
self.assertEqual(self.element.text, 'child1child2text')
df = DocumentFragment()
df.append(self.c3, 'text2')
self.tag.appendChild(df)
self.wait_until(
lambda: self.element.text == 'child1child2textchild3text2')
self.assertEqual(self.element.text, 'child1child2textchild3text2')
def test_add_df(self):
self.set_element(self.tag)
self.df.append(self.c1, self.c2, 'text')
self.tag.appendChild(self.df)
self.wait_until(lambda: self.element.text == 'child1child2text')
self.assertEqual(self.element.text, 'child1child2text')
df = DocumentFragment()
df.append(self.c3, 'text2')
self.tag.appendChild(df)
self.wait_until(
lambda: self.element.text == 'child1child2textchild3text2')
self.assertEqual(self.element.text, 'child1child2textchild3text2')
def get_elements(self):
self.root = WdomElement('div')
self.tag = WdomElement('span', parent=self.root)
self.df = DocumentFragment()
self.c1 = WdomElement('c1')
self.c2 = WdomElement('c2')
self.c3 = WdomElement('c3')
self.c4 = WdomElement('c4')
self.c1.textContent = 'child1'
self.c2.textContent = 'child2'
self.c3.textContent = 'child3'
self.c4.textContent = 'child4'
return self.root
def test_insert_df(self):
self.set_element(self.tag)
self.tag.appendChild(self.c1)
self.df.append(self.c2, self.c3, 'text')
self.tag.insertBefore(self.df, self.c1)
self.wait_until(lambda: self.element.text == 'child2child3textchild1')
self.assertEqual(self.element.text, 'child2child3textchild1')
df = DocumentFragment()
df.append(self.c4, 'text2')
self.tag.insertBefore(df, self.c3)
self.wait_until(
lambda: self.element.text == 'child2child4text2child3textchild1')
self.assertEqual(self.element.text,
'child2child4text2child3textchild1')
async def test_insert_df(self):
self.tag.appendChild(self.c1)
await self.wait_for_element(self.c1)
self.df.append(self.c2, self.c3, 'text')
self.tag.insertBefore(self.df, self.c1)
await self.wait_for_element(self.c2)
await self.wait_for_element(self.c3)
self.assertEqual(await self.get_text(), 'child2child3textchild1')
df = DocumentFragment()
df.append(self.c4, 'text2')
self.tag.insertBefore(df, self.c3)
await self.wait_for_element(self.c4)
self.assertEqual(await self.get_text(),
'child2child4text2child3textchild1') # noqa
def test_insert_df(self):
self.set_element(self.tag)
self.tag.appendChild(self.c1)
self.df.append(self.c2, self.c3, 'text')
self.tag.insertBefore(self.df, self.c1)
self.wait_until(lambda: self.element.text == 'child2child3textchild1')
self.assertEqual(self.element.text, 'child2child3textchild1')
df = DocumentFragment()
df.append(self.c4, 'text2')
self.tag.insertBefore(df, self.c3)
self.wait_until(
lambda: self.element.text == 'child2child4text2child3textchild1')
self.assertEqual(self.element.text,
'child2child4text2child3textchild1')
class Parser(HTMLParser):
def __init__(self, *args, default_class=None, **kwargs):
# Import here
self.default_class = default_class or HTMLElement
super().__init__(*args, **kwargs)
self.elm = DocumentFragment()
self.root = self.elm
def handle_starttag(self, tag, attr):
attrs = dict(attr)
params = dict(parent=self.elm, **attrs)
elm = _create_element(tag, attrs.get('is'), self.default_class, params)
if self.elm:
self.elm.append(elm)
if tag not in HTML_EMPTY:
self.elm = elm
def handle_endtag(self, tag):
self.elm = self.elm.parentNode
def handle_data(self, data):
if data and self.elm:
self.elm.append(data)
def handle_comment(self, comment: str):
self.elm.append(Comment(comment))
def get_elements(self):
self.root = WebElement('div')
self.tag = WebElement('span', parent=self.root)
self.df = DocumentFragment()
self.c1 = WebElement('c1')
self.c2 = WebElement('c2')
self.c3 = WebElement('c3')
self.c4 = WebElement('c4')
self.c1.textContent = 'child1'
self.c2.textContent = 'child2'
self.c3.textContent = 'child3'
self.c4.textContent = 'child4'
return self.root
class TestText(TestCase):
def setUp(self):
self.node = Node()
self.df = DocumentFragment()
self.tnode = Text('text')
def test_nodename(self):
self.assertEqual(self.tnode.nodeName, '#text')
def test_html_escape(self):
self.assertEqual(self.tnode.html, 'text')
self.tnode.textContent = '<'
# not escape it has no parent
self.assertEqual(self.tnode.html, '<')
self.df.appendChild(self.tnode)
# escape its parent is DocumentFragment or Element or...
self.assertEqual(self.tnode.html, '<')
self.assertEqual(Text('<', parent=self.df).html, '<')
self.assertEqual(Text('>', parent=self.df).html, '>')
self.assertEqual(Text('&', parent=self.df).html, '&')
self.assertEqual(Text('"', parent=self.df).html, '"')
self.assertEqual(Text('\'', parent=self.df).html, ''')
def test_appned(self):
self.node.appendChild(self.tnode)
self.assertTrue(self.node.hasChildNodes())
self.assertIs(self.tnode.parentNode, self.node)
node1 = Node()
node2 = Node()
self.node.appendChild(node1)
self.assertIs(self.tnode.nextSibling, node1)
self.assertIs(self.tnode, node1.previousSibling)
self.node.insertBefore(node2, self.tnode)
self.assertIs(self.tnode.previousSibling, node2)
self.assertIs(self.tnode, node2.nextSibling)
class TestText(TestCase):
def setUp(self):
self.node = Node()
self.df = DocumentFragment()
self.tnode = Text('text')
def test_nodename(self):
self.assertEqual(self.tnode.nodeName, '#text')
def test_html_escape(self):
self.assertEqual(self.tnode.html, 'text')
self.tnode.textContent = '<'
# not escape it has no parent
self.assertEqual(self.tnode.html, '<')
self.df.appendChild(self.tnode)
# escape its parent is DocumentFragment or Element or...
self.assertEqual(self.tnode.html, '<')
self.assertEqual(Text('<', parent=self.df).html, '<')
self.assertEqual(Text('>', parent=self.df).html, '>')
self.assertEqual(Text('&', parent=self.df).html, '&')
self.assertEqual(Text('"', parent=self.df).html, '"')
self.assertEqual(Text('\'', parent=self.df).html, ''')
def test_appned(self):
self.node.appendChild(self.tnode)
self.assertTrue(self.node.hasChildNodes())
self.assertIs(self.tnode.parentNode, self.node)
node1 = Node()
node2 = Node()
self.node.appendChild(node1)
self.assertIs(self.tnode.nextSibling, node1)
self.assertIs(self.tnode, node1.previousSibling)
self.node.insertBefore(node2, self.tnode)
self.assertIs(self.tnode.previousSibling, node2)
self.assertIs(self.tnode, node2.nextSibling)
class FragmentParser(HTMLParser):
"""Parser class to parse HTML fragment strings.
If unknown tag is found, ``default_class`` is used to generate noew.
"""
#: Class of unknown tag
default_class = None # type: Optional[type]
def __init__(self,
*args: Any,
element_factory: _T_ElementFactory = None,
**kwargs: Any) -> None:
"""Initialize parser."""
super().__init__(*args, **kwargs) # type: ignore
from wdom.node import DocumentFragment
from wdom.document import create_element
self.elm = DocumentFragment() # type: ParentNode
self.root = self.elm
self.current_tag = ''
self.element_factory = element_factory or create_element
def handle_starttag(self, tag: str,
attr: List[Tuple[str, str]]) -> None: # noqa: D102
self.current_tag = tag
attrs = dict(attr)
elm = self.element_factory(tag, attrs.get('is'), self.default_class,
attrs)
if self.elm:
self.elm.appendChild(elm)
if tag not in HTML_EMPTY:
self.elm = elm
def handle_endtag(self, tag: str) -> None: # noqa: D102
parent = self.elm.parentNode
if parent is None:
if self.elm is not self.root:
raise ValueError('Parse Failed')
else:
self.elm = parent
def handle_data(self, data: str) -> None: # noqa: D102
if data:
self.elm.appendChild(Text(data))
def handle_comment(self, comment: str) -> None: # noqa: D102
from wdom.node import Comment
self.elm.appendChild(Comment(comment))
class FragmentParser(HTMLParser):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.elm = DocumentFragment()
self.root = self.elm
def handle_starttag(self, tag, attrs):
elm = WebElement(tag, parent=self.elm, **dict(attrs))
if self.elm:
self.elm.append(elm)
if tag not in HTML_EMPTY:
self.elm = elm
def handle_endtag(self, tag):
self.elm = self.elm.parentNode
def handle_data(self, data):
if data and self.elm:
self.elm.append(data)
def handle_comment(self, comment:str):
self.elm.append(Comment(comment))
def setUp(self):
self.node = Node()
self.df = DocumentFragment()
self.tnode = Text('text')
class TestDocumentFragment(TestCase):
def setUp(self):
self.df = DocumentFragment()
self.elm = Element('a')
self.c1 = Element('c1')
self.c2 = Element('c2')
self.c3 = Element('c3')
def test_nodename(self):
self.assertEqual(self.df.nodeName, '#document-fragment')
def test_children(self):
self.assertFalse(self.df.hasChildNodes())
appended_child = self.df.appendChild(self.elm)
self.assertEqual(self.df.html, '<a></a>')
self.assertIs(appended_child, self.elm)
def test_append_to_element(self):
appended_child1 = self.df.appendChild(self.c1)
appended_child2 = self.df.appendChild(self.c2)
self.assertIs(self.df, self.c1.parentNode)
self.assertIs(self.df, self.c2.parentNode)
self.assertIs(appended_child1, self.c1)
self.assertIs(appended_child2, self.c2)
appended_df = self.elm.appendChild(self.df)
self.assertIs(appended_df, self.df)
self.assertEqual(self.df.length, 0)
self.assertEqual(self.elm.length, 2)
self.assertFalse(self.df.hasChildNodes())
self.assertIsNone(self.df.parentNode)
self.assertIs(self.elm, self.c1.parentNode)
self.assertIs(self.elm, self.c2.parentNode)
self.assertIsNone(self.df.parentNode)
def test_insert_to_element(self):
self.df.appendChild(self.c1)
self.df.appendChild(self.c2)
self.elm.appendChild(self.c3)
inserted_node = self.elm.insertBefore(self.df, self.c3)
self.assertIs(inserted_node, self.df)
self.assertEqual(self.df.length, 0)
self.assertEqual(self.elm.length, 3)
self.assertFalse(self.df.hasChildNodes())
self.assertIsNone(self.df.parentNode)
self.assertIs(self.elm, self.c1.parentNode)
self.assertIs(self.elm, self.c2.parentNode)
self.assertIsNone(self.c1.previousSibling)
self.assertIs(self.c1.nextSibling, self.c2)
self.assertIs(self.c2.previousSibling, self.c1)
self.assertIs(self.c2.nextSibling, self.c3)
self.assertIs(self.c3.previousSibling, self.c2)
self.assertIsNone(self.c3.nextSibling)
self.assertIs(self.elm.firstChild, self.c1)
self.assertIs(self.elm.lastChild, self.c3)
def test_child(self):
appended_child1 = self.df.appendChild(self.c1)
appended_child2 = self.df.appendChild(self.c2)
self.assertIs(appended_child1, self.c1)
self.assertIs(appended_child2, self.c2)
self.assertEqual(self.c1.html, '<c1></c1>')
self.assertEqual(self.df.html, '<c1></c1><c2></c2>')
def test_clone_node_sharrow(self):
self.df.appendChild(self.c1)
clone = self.df.cloneNode()
self.assertEqual(self.df.length, 1)
self.assertEqual(clone.length, 0)
clone.appendChild(self.c2)
self.assertEqual(self.df.length, 1)
self.assertEqual(clone.length, 1)
def test_clone_node_deep(self):
self.df.appendChild(self.c1)
clone = self.df.cloneNode(deep=True)
self.assertEqual(self.df.length, 1)
self.assertEqual(clone.length, 1)
self.assertEqual(clone.html, '<c1></c1>')
clone.appendChild(self.c2)
self.assertEqual(self.df.length, 1)
self.assertEqual(clone.length, 2)
self.df.removeChild(self.c1)
self.assertEqual(self.df.length, 0)
self.assertEqual(clone.length, 2)
class TestWdomElement(ElementTestCase, TestCase):
def get_elements(self):
self.root = WdomElement('div')
self.tag = WdomElement('span', parent=self.root)
self.df = DocumentFragment()
self.c1 = WdomElement('c1')
self.c2 = WdomElement('c2')
self.c3 = WdomElement('c3')
self.c4 = WdomElement('c4')
self.c1.textContent = 'child1'
self.c2.textContent = 'child2'
self.c3.textContent = 'child3'
self.c4.textContent = 'child4'
return self.root
def test_connection(self):
self.wait_until(lambda: self.root.connected)
self.assertTrue(self.root.connected)
self.browser.get('http://example.com/')
self.assertIsFalse(self.root.connected)
def test_text_content(self):
self.set_element(self.tag)
self.assertEqual(self.element.text, '')
self.tag.textContent = 'text'
self.wait_until(lambda: self.element.text == 'text')
self.assertEqual(self.element.text, 'text')
self.c1.textContent = 'child'
self.tag.appendChild(self.c1)
self.wait_until(lambda: self.element.text == 'textchild')
self.assertEqual(self.element.text, 'textchild')
self.tag.textContent = 'NewText'
self.wait_until(lambda: self.element.text == 'NewText')
self.assertEqual(self.element.text, 'NewText')
with self.assertRaises(NoSuchElementException):
self.set_element(self.c1, self.wait_time * 10)
self.set_element(self.tag)
t_node = Text('TextNode')
self.tag.replaceChild(t_node, self.tag.childNodes[0])
self.wait_until(lambda: self.element.text == 'TextNode')
self.assertEqual(self.element.text, 'TextNode')
self.tag.removeChild(self.tag.childNodes[0])
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == '')
self.assertEqual(self.element.text, '')
def test_attr(self):
self.set_element(self.tag)
self.assertIsNone(self.element.get_attribute('src'))
self.tag.setAttribute('src', 'a')
self.wait_until(lambda: self.element.get_attribute('src') == 'a')
self.assertEqual(self.element.get_attribute('src'), 'a')
self.tag.removeAttribute('src')
self.wait_until(lambda: self.element.get_attribute('src') is None)
self.assertIsNone(self.element.get_attribute('src'))
def test_addremove_child(self):
self.tag.appendChild(self.c1)
self.set_element(self.c1)
self.assertEqual(self.element.text, 'child1')
self.c1.textContent = 'Child'
self.wait_until(lambda: self.element.text == 'Child')
self.assertEqual(self.element.text, 'Child')
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == 'Child')
self.assertEqual(self.element.text, 'Child')
self.tag.removeChild(self.c1)
with self.assertRaises(NoSuchElementException):
self.wait(0.1)
self.set_element(self.c1, self.wait_time * 10)
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == '')
self.assertEqual(self.element.text, '')
def test_insert_child(self):
self.set_element(self.tag)
# test parent in constructor
self.c1 = WdomElement('c1', parent=self.tag)
self.c1.textContent = 'child1'
self.assertIsTrue(self.set_element(self.c1))
with self.assertRaises(NoSuchElementException):
self.wait(0.1)
self.set_element(self.c2, self.wait_time * 10)
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == 'child1')
self.assertEqual(self.element.text, 'child1')
self.tag.insertBefore(self.c2, self.c1)
self.assertIsTrue(self.set_element(self.c2))
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == 'child2child1')
self.assertEqual(self.element.text, 'child2child1')
self.tag.empty()
self.wait_until(lambda: self.element.text == '')
self.assertEqual(self.element.text, '')
with self.assertRaises(NoSuchElementException):
self.set_element(self.c1, self.wait_time * 10)
with self.assertRaises(NoSuchElementException):
self.set_element(self.c2, self.wait_time * 10)
def test_add_df(self):
self.set_element(self.tag)
self.df.append(self.c1, self.c2, 'text')
self.tag.appendChild(self.df)
self.wait_until(lambda: self.element.text == 'child1child2text')
self.assertEqual(self.element.text, 'child1child2text')
df = DocumentFragment()
df.append(self.c3, 'text2')
self.tag.appendChild(df)
self.wait_until(
lambda: self.element.text == 'child1child2textchild3text2')
self.assertEqual(self.element.text, 'child1child2textchild3text2')
def test_insert_df(self):
self.set_element(self.tag)
self.tag.appendChild(self.c1)
self.df.append(self.c2, self.c3, 'text')
self.tag.insertBefore(self.df, self.c1)
self.wait_until(lambda: self.element.text == 'child2child3textchild1')
self.assertEqual(self.element.text, 'child2child3textchild1')
df = DocumentFragment()
df.append(self.c4, 'text2')
self.tag.insertBefore(df, self.c3)
self.wait_until(
lambda: self.element.text == 'child2child4text2child3textchild1')
self.assertEqual(self.element.text,
'child2child4text2child3textchild1')
def test_replace_child(self):
self.set_element(self.tag)
self.tag.appendChild(self.c1)
with self.assertRaises(NoSuchElementException):
self.set_element(self.c2, self.wait_time * 10)
self.assertIsTrue(self.set_element(self.c1))
self.wait_until(lambda: self.element.text == 'child1')
self.assertEqual(self.element.text, 'child1')
self.tag.replaceChild(self.c2, self.c1)
with self.assertRaises(NoSuchElementException):
self.wait(0.1)
self.set_element(self.c1, self.wait_time * 10)
self.assertIsTrue(self.set_element(self.c2))
self.wait_until(lambda: self.element.text == 'child2')
self.assertEqual(self.element.text, 'child2')
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == 'child2')
self.assertEqual(self.element.text, 'child2')
def test_append(self):
self.set_element(self.tag)
self.tag.append(self.c1)
self.wait_until(lambda: self.element.text == 'child1')
self.assertEqual(self.element.text, 'child1')
self.tag.append(self.c2, self.c3)
self.wait_until(lambda: self.element.text == 'child1child2child3')
self.assertEqual(self.element.text, 'child1child2child3')
self.tag.append(self.c4, self.c1)
self.wait_until(
lambda: self.element.text == 'child2child3child4child1')
self.assertEqual(self.element.text, 'child2child3child4child1')
self.tag.append('t1', 't2')
self.wait_until(
lambda: self.element.text == 'child2child3child4child1t1t2')
self.assertEqual(self.element.text, 'child2child3child4child1t1t2')
def test_prepend(self):
self.set_element(self.tag)
self.tag.prepend(self.c1)
self.wait_until(lambda: self.element.text == 'child1')
self.assertEqual(self.element.text, 'child1')
self.tag.prepend(self.c2, self.c3)
self.wait_until(lambda: self.element.text == 'child2child3child1')
self.assertEqual(self.element.text, 'child2child3child1')
self.tag.prepend(self.c4, self.c1)
self.wait_until(
lambda: self.element.text == 'child4child1child2child3')
self.assertEqual(self.element.text, 'child4child1child2child3')
self.tag.prepend('t1', 't2')
self.wait_until(
lambda: self.element.text == 't1t2child4child1child2child3')
self.assertEqual(self.element.text, 't1t2child4child1child2child3')
def test_prepend_append_text(self):
self.set_element(self.tag)
self.tag.append('t1')
self.wait_until(lambda: self.element.text == 't1')
self.assertEqual(self.element.text, 't1')
self.tag.firstChild.remove()
self.wait_until(lambda: self.element.text == '')
self.assertEqual(self.element.text, '')
self.tag.prepend('t2')
self.wait_until(lambda: self.element.text == 't2')
self.assertEqual(self.element.text, 't2')
self.tag.append('t3', 't4')
self.wait_until(lambda: self.element.text == 't2t3t4')
self.assertEqual(self.element.text, 't2t3t4')
self.tag.prepend('t5', 't6')
self.wait_until(lambda: self.element.text == 't5t6t2t3t4')
self.assertEqual(self.element.text, 't5t6t2t3t4')
def test_after(self):
self.set_element(self.tag)
self.tag.append(self.c1)
self.c1.after(self.c2)
self.wait_until(lambda: self.element.text == 'child1child2')
self.assertEqual(self.element.text, 'child1child2')
self.c1.after(self.c3, self.c4)
self.wait_until(
lambda: self.element.text == 'child1child3child4child2')
self.assertEqual(self.element.text, 'child1child3child4child2')
self.c1.after(self.c2, 'text')
self.wait_until(
lambda: self.element.text == 'child1child2textchild3child4')
self.assertEqual(self.element.text, 'child1child2textchild3child4')
def test_before(self):
self.set_element(self.tag)
self.tag.append(self.c1)
self.c1.before(self.c2)
self.wait_until(lambda: self.element.text == 'child2child1')
self.assertEqual(self.element.text, 'child2child1')
self.c1.before(self.c3, self.c4)
self.wait_until(
lambda: self.element.text == 'child2child3child4child1')
self.assertEqual(self.element.text, 'child2child3child4child1')
self.c1.before(self.c2, 'text')
self.wait_until(
lambda: self.element.text == 'child3child4child2textchild1')
self.assertEqual(self.element.text, 'child3child4child2textchild1')
def test_after_before_text(self):
self.set_element(self.tag)
self.tag.append('a')
t = self.tag.firstChild
t.after('b')
self.wait_until(lambda: self.element.text == 'ab')
self.assertEqual(self.element.text, 'ab')
t.after('c', 'd')
self.wait_until(lambda: self.element.text == 'acdb')
self.assertEqual(self.element.text, 'acdb')
t.before('e')
self.wait_until(lambda: self.element.text == 'eacdb')
self.assertEqual(self.element.text, 'eacdb')
t.before('f', 'g')
self.wait_until(lambda: self.element.text == 'efgacdb')
self.assertEqual(self.element.text, 'efgacdb')
def test_inner_html(self):
self.set_element(self.tag)
self.tag.innerHTML = '<div>a</div>'
self.wait_until(lambda: self.element.text == 'a')
self.set_element(self.tag.firstChild)
self.wait_until(lambda: self.element.text == 'a')
self.assertEqual(self.element.text, 'a')
def test_shortcut_attr(self):
self.tag.textContent = 'TAG'
self.set_element(self.tag)
self.wait_until(lambda: self.element.is_displayed())
self.assertIsTrue(self.element.is_displayed())
self.tag.hidden = True
self.wait_until(lambda: not self.element.is_displayed())
self.assertIsFalse(self.element.is_displayed())
self.tag.hidden = False
self.wait_until(lambda: self.element.is_displayed())
self.assertIsTrue(self.element.is_displayed())
def test_style(self):
self.tag.textContent = 'Style'
self.set_element(self.tag)
self.wait_until(lambda: self.element.get_attribute('style') == '')
self.assertEqual(self.element.get_attribute('style'), '')
style = 'color: red;'
self.tag.style = style
self.wait_until(lambda: self.element.get_attribute('style') == style)
self.assertEqual(self.element.get_attribute('style'), style)
self.tag.style.color = 'black'
self.wait_until(
lambda: self.element.get_attribute('style') == 'color: black;')
self.assertEqual(self.element.get_attribute('style'), 'color: black;')
def test_classlist(self):
self.set_element(self.tag)
self.assertEqual(self.element.get_attribute('class'), '')
self.tag.classList.add('a')
self.wait_until(lambda: self.element.get_attribute('class') == 'a')
self.assertEqual(self.element.get_attribute('class'), 'a')
self.tag.classList.add('b', 'c', 'd')
self.wait_until(
lambda: self.element.get_attribute('class') == 'a b c d')
self.assertEqual(self.element.get_attribute('class'), 'a b c d')
self.tag.classList.remove('c')
self.wait_until(lambda: self.element.get_attribute('class') == 'a b d')
self.assertEqual(self.element.get_attribute('class'), 'a b d')
self.tag.classList.remove('a', 'd')
self.wait_until(lambda: self.element.get_attribute('class') == 'b')
self.assertEqual(self.element.get_attribute('class'), 'b')
self.tag.classList.toggle('b')
self.wait_until(lambda: self.element.get_attribute('class') == '')
self.assertEqual(self.element.get_attribute('class'), '')
self.tag.classList.toggle('b')
self.wait_until(lambda: self.element.get_attribute('class') == 'b')
self.assertEqual(self.element.get_attribute('class'), 'b')
def test_click(self):
mock = MagicMock(_is_coroutine=False)
self.tag.addEventListener('click', mock)
self.tag.click()
self.wait_until(lambda: mock.call_count == 1)
self.assertEqual(mock.call_count, 1)
@sync
async def test_get_rect(self):
rect = WdomElement('div', style='width:200px;height:100px;')
self.tag.appendChild(rect)
await asyncio.sleep(self.wait_time)
data = await rect.getBoundingClientRect()
self.assertEqual(data['width'], 200)
self.assertEqual(data['height'], 100)
@sync
async def test_scroll(self):
rect = WdomElement('div', style='width:3000px;height:3000px;background:#eee;') # noqa: #501
self.tag.appendChild(rect)
await asyncio.sleep(self.wait_time)
X = await rect.scrollX()
Y = await rect.scrollY()
self.assertEqual(X['x'], 0)
self.assertEqual(Y['y'], 0)
rect.scrollTo(200, 200)
await asyncio.sleep(self.wait_time)
X = await rect.scrollX()
Y = await rect.scrollY()
self.assertEqual(X['x'], 200)
self.assertEqual(Y['y'], 200)
def test_exec(self):
self.tag.exec('this.style = "color: red;"')
self.set_element(self.tag)
self.wait_until(
lambda: re.search(r'255,\s*0,\s* 0,\s*1\s*',
self.element.value_of_css_property('color')))
self.assertRegex(self.element.value_of_css_property('color'),
r'255,\s*0,\s* 0,\s*1\s*')
self.tag.exec('node.style = "color: blue;"')
self.wait_until(
lambda: re.search(r'0,\s*0,\s* 255,\s*1\s*',
self.element.value_of_css_property('color')))
self.assertRegex(self.element.value_of_css_property('color'),
r'0,\s*0,\s*255,\s*1\s*')
def test_exec_error(self):
with self.assertLogs('wdom.server', 'ERROR') as log:
self.tag.exec('a.b')
self.wait_until(lambda: len(log.output) > 0)
self.assertRegex(log.output[0], r'JS: ReferenceError')
def setUp(self):
self.df = DocumentFragment()
self.elm = Element('a')
self.c1 = Element('c1')
self.c2 = Element('c2')
self.c3 = Element('c3')
def createDocumentFragment(self) -> DocumentFragment:
"""Create empty document fragment."""
return DocumentFragment()
class TestWdomElement(PyppeteerTestCase):
def setUp(self):
super().setUp()
def get_elements(self):
root = WdomElement('div')
self.tag = WdomElement('span', parent=root)
self.df = DocumentFragment()
self.c1 = WdomElement('c1')
self.c2 = WdomElement('c2')
self.c3 = WdomElement('c3')
self.c4 = WdomElement('c4')
self.c1.textContent = 'child1'
self.c2.textContent = 'child2'
self.c3.textContent = 'child3'
self.c4.textContent = 'child4'
return root
@sync
async def test_connection(self):
self.assertTrue(self.root.connected)
await self.page.goto('https://example.com')
await self.wait()
self.assertFalse(self.root.connected)
@sync
async def test_text_content(self):
self.element = await self.get_element_handle(self.tag)
self.assertEqual(await self.get_text(), '')
self.tag.textContent = 'text'
await self.wait()
self.assertEqual(await self.get_text(), 'text')
self.c1.textContent = 'child'
self.tag.appendChild(self.c1)
await self.wait_for_element(self.c1)
self.assertEqual(await self.get_text(), 'textchild')
self.tag.textContent = 'NewText'
await self.wait()
self.assertEqual(await self.get_text(), 'NewText')
self.assertIsNone(await self.get_element_handle(self.c1))
t_node = Text('TextNode')
self.tag.replaceChild(t_node, self.tag.childNodes[0])
await self.wait()
self.assertEqual(await self.get_text(), 'TextNode')
self.tag.removeChild(t_node)
await self.wait()
self.assertEqual(await self.get_text(), '')
@sync
async def test_attr(self):
self.element = await self.get_element_handle(self.tag)
self.assertIsNone(await self.get_attribute('src'))
self.tag.setAttribute('src', 'a')
await self.wait()
self.assertEqual(await self.get_attribute('src'), 'a')
self.tag.removeAttribute('src')
await self.wait()
self.assertIsNone(await self.get_attribute('src'))
@sync
async def test_addremove_child(self):
self.tag.appendChild(self.c1)
await self.wait_for_element(self.c1)
self.assertEqual(await self.get_text(), 'child1')
self.c1.textContent = 'Child'
await self.wait()
self.assertEqual(await self.get_text(), 'Child')
self.tag.removeChild(self.c1)
await self.wait()
self.assertIsNone(await self.get_element_handle(self.c1))
self.assertEqual(await self.get_text(), '')
@sync
async def test_insert_child(self):
# test parent in constructor
self.c1 = WdomElement('c1', parent=self.tag)
await self.wait_for_element(self.c1)
self.c1.textContent = 'child1'
await self.wait()
self.assertTrue(await self.get_element_handle(self.c1))
self.assertIsNone(await self.get_element_handle(self.c2))
self.assertEqual(await self.get_text(), 'child1')
self.tag.insertBefore(self.c2, self.c1)
await self.wait_for_element(self.c2)
self.assertTrue(await self.get_element_handle(self.c2))
self.assertEqual(await self.get_text(), 'child2child1')
self.tag.empty()
await self.wait()
self.assertEqual(await self.get_text(), '')
self.assertIsNone(await self.get_element_handle(self.c1))
self.assertIsNone(await self.get_element_handle(self.c2))
@sync
async def test_add_df(self):
self.df.append(self.c1, self.c2, 'text')
self.tag.appendChild(self.df)
await self.wait_for_element(self.c1)
await self.wait_for_element(self.c2)
self.assertEqual(await self.get_text(), 'child1child2text')
df = DocumentFragment()
df.append(self.c3, 'text2')
self.tag.appendChild(df)
await self.wait_for_element(self.c3)
self.assertEqual(await self.get_text(), 'child1child2textchild3text2')
@sync
async def test_insert_df(self):
self.tag.appendChild(self.c1)
await self.wait_for_element(self.c1)
self.df.append(self.c2, self.c3, 'text')
self.tag.insertBefore(self.df, self.c1)
await self.wait_for_element(self.c2)
await self.wait_for_element(self.c3)
self.assertEqual(await self.get_text(), 'child2child3textchild1')
df = DocumentFragment()
df.append(self.c4, 'text2')
self.tag.insertBefore(df, self.c3)
await self.wait_for_element(self.c4)
self.assertEqual(await self.get_text(),
'child2child4text2child3textchild1') # noqa
@sync
async def test_replace_child(self):
self.tag.appendChild(self.c1)
await self.wait_for_element(self.c1)
self.assertIsNotNone(await self.get_element_handle(self.c1))
self.assertIsNone(await self.get_element_handle(self.c2))
self.assertEqual(await self.get_text(), 'child1')
self.tag.replaceChild(self.c2, self.c1)
await self.wait_for_element(self.c2)
self.assertIsNone(await self.get_element_handle(self.c1))
self.assertIsNotNone(await self.get_element_handle(self.c2))
self.assertEqual(await self.get_text(), 'child2')
@sync
async def test_append(self):
self.tag.append(self.c1)
await self.wait_for_element(self.c1)
self.assertEqual(await self.get_text(), 'child1')
self.tag.append(self.c2, self.c3)
await self.wait_for_element(self.c2)
await self.wait_for_element(self.c3)
self.assertEqual(await self.get_text(), 'child1child2child3')
self.tag.append(self.c4, self.c1)
await self.wait_for_element(self.c4)
self.assertEqual(await self.get_text(), 'child2child3child4child1')
self.tag.append('t1', 't2')
await self.wait()
self.assertEqual(await self.get_text(), 'child2child3child4child1t1t2')
@sync
async def test_prepend(self):
self.tag.prepend(self.c1)
await self.wait_for_element(self.c1)
self.assertEqual(await self.get_text(), 'child1')
self.tag.prepend(self.c2, self.c3)
await self.wait_for_element(self.c2)
await self.wait_for_element(self.c3)
self.assertEqual(await self.get_text(), 'child2child3child1')
self.tag.prepend(self.c4, self.c1)
await self.wait_for_element(self.c4)
self.assertEqual(await self.get_text(), 'child4child1child2child3')
self.tag.prepend('t1', 't2')
await self.wait()
self.assertEqual(await self.get_text(), 't1t2child4child1child2child3')
@sync
async def test_prepend_append_text(self):
self.tag.append('t1')
await self.wait()
self.assertEqual(await self.get_text(), 't1')
self.tag.firstChild.remove()
await self.wait()
self.assertEqual(await self.get_text(), '')
self.tag.prepend('t2')
await self.wait()
self.assertEqual(await self.get_text(), 't2')
self.tag.append('t3', 't4')
await self.wait()
self.assertEqual(await self.get_text(), 't2t3t4')
self.tag.prepend('t5', 't6')
await self.wait()
self.assertEqual(await self.get_text(), 't5t6t2t3t4')
@sync
async def test_after(self):
self.tag.append(self.c1)
await self.wait_for_element(self.c1)
self.c1.after(self.c2)
await self.wait_for_element(self.c2)
self.assertEqual(await self.get_text(), 'child1child2')
self.c1.after(self.c3, self.c4)
await self.wait_for_element(self.c3)
await self.wait_for_element(self.c4)
self.assertEqual(await self.get_text(), 'child1child3child4child2')
self.c1.after(self.c2, 'text')
await self.wait()
self.assertEqual(await self.get_text(), 'child1child2textchild3child4')
@sync
async def test_before(self):
self.tag.append(self.c1)
await self.wait_for_element(self.c1)
self.c1.before(self.c2)
await self.wait_for_element(self.c2)
self.assertEqual(await self.get_text(), 'child2child1')
self.c1.before(self.c3, self.c4)
await self.wait_for_element(self.c3)
await self.wait_for_element(self.c4)
self.assertEqual(await self.get_text(), 'child2child3child4child1')
self.c1.before(self.c2, 'text')
await self.wait()
self.assertEqual(await self.get_text(), 'child3child4child2textchild1')
@sync
async def test_after_before_text(self):
self.tag.append('a')
t = self.tag.firstChild
t.after('b')
await self.wait()
self.assertEqual(await self.get_text(), 'ab')
t.after('c', 'd')
await self.wait()
self.assertEqual(await self.get_text(), 'acdb')
t.before('e')
await self.wait()
self.assertEqual(await self.get_text(), 'eacdb')
t.before('f', 'g')
await self.wait()
self.assertEqual(await self.get_text(), 'efgacdb')
@sync
async def test_inner_html(self):
self.tag.innerHTML = '<div>a</div>'
await self.wait()
self.assertEqual(await self.get_text(), 'a')
@sync
async def test_shortcut_attr(self):
tag = await self.get_element_handle(self.tag)
self.tag.textContent = 'TAG'
await self.wait()
self.assertFalse(await
tag.evaluate('(elm) => elm.hasAttribute("hidden")'))
self.tag.hidden = True
await self.wait()
self.assertTrue(await
tag.evaluate('(elm) => elm.hasAttribute("hidden")'))
self.tag.hidden = False
await self.wait()
self.assertFalse(await
tag.evaluate('(elm) => elm.hasAttribute("hidden")'))
@sync
async def test_style(self):
self.element = await self.get_element_handle(self.tag)
self.tag.textContent = 'Style'
await self.wait()
self.assertIsNone(await self.get_attribute('style'))
style = 'color: red;'
self.tag.style = style
await self.wait()
self.assertEqual(await self.get_attribute('style'), style)
self.tag.style.color = 'black'
await self.wait()
self.assertEqual(await self.get_attribute('style'), 'color: black;')
@sync
async def test_classlist(self):
self.element = await self.get_element_handle(self.tag)
self.assertEqual(await self.get_attribute('class'), None)
self.assertNotIn('class', await
self.element.evaluate('(elm) => elm.outerHTML'))
self.tag.classList.add('a')
await self.wait()
self.assertEqual(await self.get_attribute('class'), 'a')
self.tag.classList.add('b', 'c', 'd')
await self.wait()
self.assertEqual(await self.get_attribute('class'), 'a b c d')
self.tag.classList.remove('c')
await self.wait()
self.assertEqual(await self.get_attribute('class'), 'a b d')
self.tag.classList.remove('a', 'd')
await self.wait()
self.assertEqual(await self.get_attribute('class'), 'b')
self.tag.classList.toggle('b')
await self.wait()
self.assertEqual(await self.get_attribute('class'), None)
self.assertNotIn('class', await
self.element.evaluate('(elm) => elm.outerHTML'))
self.tag.classList.toggle('b')
await self.wait()
self.assertEqual(await self.get_attribute('class'), 'b')
@sync
async def test_click(self):
mock = MagicMock(_is_coroutine=False)
self.tag.addEventListener('click', mock)
self.tag.click()
await self.wait()
self.assertEqual(mock.call_count, 1)
@sync
async def test_get_rect(self):
rect = WdomElement('div', style='width:200px;height:100px;')
self.tag.appendChild(rect)
await self.wait()
data = await rect.getBoundingClientRect()
self.assertEqual(data['width'], 200)
self.assertEqual(data['height'], 100)
@sync
async def test_scroll(self):
rect = WdomElement(
'div',
style='width:3000px;height:3000px;background:#eee;') # noqa: #501
self.tag.appendChild(rect)
await self.wait()
X = await rect.scrollX()
Y = await rect.scrollY()
self.assertEqual(X['x'], 0)
self.assertEqual(Y['y'], 0)
rect.scrollTo(200, 200)
await asyncio.sleep(self.wait_time)
X = await rect.scrollX()
Y = await rect.scrollY()
self.assertEqual(X['x'], 200)
self.assertEqual(Y['y'], 200)
@sync
async def test_exec(self):
self.element = await self.get_element_handle(self.tag)
self.tag.exec('this.style = "color: red;"')
await self.wait()
self.assertEqual(await self.get_attribute('style'), 'color: red;')
self.tag.exec('node.style = "color: blue;"')
await self.wait()
self.assertEqual(await self.get_attribute('style'), 'color: blue;')
@sync
async def test_exec_error(self):
with self.assertLogs('wdom.server', 'ERROR') as log:
self.tag.exec('a.b')
await self.wait()
self.assertRegex(log.output[0], r'JS: ReferenceError')
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.elm = DocumentFragment()
self.root = self.elm
class TestWebElement(ElementTestCase, TestCase):
def get_elements(self):
self.root = WebElement('div')
self.tag = WebElement('span', parent=self.root)
self.df = DocumentFragment()
self.c1 = WebElement('c1')
self.c2 = WebElement('c2')
self.c3 = WebElement('c3')
self.c4 = WebElement('c4')
self.c1.textContent = 'child1'
self.c2.textContent = 'child2'
self.c3.textContent = 'child3'
self.c4.textContent = 'child4'
return self.root
def test_connection(self):
self.wait_until(lambda: self.root.connected)
self.assertTrue(self.root.connected)
self.browser.get('http://example.com/')
self.assertIsFalse(self.root.connected)
def test_text_content(self):
self.set_element(self.tag)
self.assertEqual(self.element.text, '')
self.tag.textContent = 'text'
self.wait_until(lambda: self.element.text == 'text')
self.assertEqual(self.element.text, 'text')
self.c1.textContent = 'child'
self.tag.appendChild(self.c1)
self.wait_until(lambda: self.element.text == 'textchild')
self.assertEqual(self.element.text, 'textchild')
self.tag.textContent = 'NewText'
self.wait_until(lambda: self.element.text == 'NewText')
self.assertEqual(self.element.text, 'NewText')
with self.assertRaises(NoSuchElementException):
self.set_element(self.c1, self.wait_time * 10)
self.set_element(self.tag)
t_node = Text('TextNode')
self.tag.replaceChild(t_node, self.tag.childNodes[0])
self.wait_until(lambda: self.element.text == 'TextNode')
self.assertEqual(self.element.text, 'TextNode')
self.tag.removeChild(self.tag.childNodes[0])
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == '')
self.assertEqual(self.element.text, '')
def test_attr(self):
self.set_element(self.tag)
self.assertIsNone(self.element.get_attribute('src'))
self.tag.setAttribute('src', 'a')
self.wait_until(lambda: self.element.get_attribute('src') == 'a')
self.assertEqual(self.element.get_attribute('src'), 'a')
self.tag.removeAttribute('src')
self.wait_until(lambda: self.element.get_attribute('src') is None)
self.assertIsNone(self.element.get_attribute('src'))
def test_addremove_child(self):
self.tag.appendChild(self.c1)
self.set_element(self.c1)
self.assertEqual(self.element.text, 'child1')
self.c1.textContent = 'Child'
self.wait_until(lambda: self.element.text == 'Child')
self.assertEqual(self.element.text, 'Child')
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == 'Child')
self.assertEqual(self.element.text, 'Child')
self.tag.removeChild(self.c1)
with self.assertRaises(NoSuchElementException):
self.wait(0.1)
self.set_element(self.c1, self.wait_time * 10)
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == '')
self.assertEqual(self.element.text, '')
def test_insert_child(self):
self.set_element(self.tag)
# test parent in constructor
self.c1 = WebElement('c1', parent=self.tag)
self.c1.textContent = 'child1'
self.assertIsTrue(self.set_element(self.c1))
with self.assertRaises(NoSuchElementException):
self.wait(0.1)
self.set_element(self.c2, self.wait_time * 10)
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == 'child1')
self.assertEqual(self.element.text, 'child1')
self.tag.insertBefore(self.c2, self.c1)
self.assertIsTrue(self.set_element(self.c2))
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == 'child2child1')
self.assertEqual(self.element.text, 'child2child1')
self.tag.empty()
self.wait_until(lambda: self.element.text == '')
self.assertEqual(self.element.text, '')
with self.assertRaises(NoSuchElementException):
self.set_element(self.c1, self.wait_time * 10)
with self.assertRaises(NoSuchElementException):
self.set_element(self.c2, self.wait_time * 10)
def test_add_df(self):
self.set_element(self.tag)
self.df.append(self.c1, self.c2, 'text')
self.tag.appendChild(self.df)
self.wait_until(lambda: self.element.text == 'child1child2text')
self.assertEqual(self.element.text, 'child1child2text')
df = DocumentFragment()
df.append(self.c3, 'text2')
self.tag.appendChild(df)
self.wait_until(
lambda: self.element.text == 'child1child2textchild3text2')
self.assertEqual(self.element.text, 'child1child2textchild3text2')
def test_insert_df(self):
self.set_element(self.tag)
self.tag.appendChild(self.c1)
self.df.append(self.c2, self.c3, 'text')
self.tag.insertBefore(self.df, self.c1)
self.wait_until(lambda: self.element.text == 'child2child3textchild1')
self.assertEqual(self.element.text, 'child2child3textchild1')
df = DocumentFragment()
df.append(self.c4, 'text2')
self.tag.insertBefore(df, self.c3)
self.wait_until(
lambda: self.element.text == 'child2child4text2child3textchild1')
self.assertEqual(self.element.text,
'child2child4text2child3textchild1')
def test_replace_child(self):
self.set_element(self.tag)
self.tag.appendChild(self.c1)
with self.assertRaises(NoSuchElementException):
self.set_element(self.c2, self.wait_time * 10)
self.assertIsTrue(self.set_element(self.c1))
self.wait_until(lambda: self.element.text == 'child1')
self.assertEqual(self.element.text, 'child1')
self.tag.replaceChild(self.c2, self.c1)
with self.assertRaises(NoSuchElementException):
self.wait(0.1)
self.set_element(self.c1, self.wait_time * 10)
self.assertIsTrue(self.set_element(self.c2))
self.wait_until(lambda: self.element.text == 'child2')
self.assertEqual(self.element.text, 'child2')
self.set_element(self.tag)
self.wait_until(lambda: self.element.text == 'child2')
self.assertEqual(self.element.text, 'child2')
def test_append(self):
self.set_element(self.tag)
self.tag.append(self.c1)
self.wait_until(lambda: self.element.text == 'child1')
self.assertEqual(self.element.text, 'child1')
self.tag.append(self.c2, self.c3)
self.wait_until(lambda: self.element.text == 'child1child2child3')
self.assertEqual(self.element.text, 'child1child2child3')
self.tag.append(self.c4, self.c1)
self.wait_until(
lambda: self.element.text == 'child2child3child4child1')
self.assertEqual(self.element.text, 'child2child3child4child1')
self.tag.append('t1', 't2')
self.wait_until(
lambda: self.element.text == 'child2child3child4child1t1t2')
self.assertEqual(self.element.text, 'child2child3child4child1t1t2')
def test_prepend(self):
self.set_element(self.tag)
self.tag.prepend(self.c1)
self.wait_until(lambda: self.element.text == 'child1')
self.assertEqual(self.element.text, 'child1')
self.tag.prepend(self.c2, self.c3)
self.wait_until(lambda: self.element.text == 'child2child3child1')
self.assertEqual(self.element.text, 'child2child3child1')
self.tag.prepend(self.c4, self.c1)
self.wait_until(
lambda: self.element.text == 'child4child1child2child3')
self.assertEqual(self.element.text, 'child4child1child2child3')
self.tag.prepend('t1', 't2')
self.wait_until(
lambda: self.element.text == 't1t2child4child1child2child3')
self.assertEqual(self.element.text, 't1t2child4child1child2child3')
def test_prepend_append_text(self):
self.set_element(self.tag)
self.tag.append('t1')
self.wait_until(lambda: self.element.text == 't1')
self.assertEqual(self.element.text, 't1')
self.tag.firstChild.remove()
self.wait_until(lambda: self.element.text == '')
self.assertEqual(self.element.text, '')
self.tag.prepend('t2')
self.wait_until(lambda: self.element.text == 't2')
self.assertEqual(self.element.text, 't2')
self.tag.append('t3', 't4')
self.wait_until(lambda: self.element.text == 't2t3t4')
self.assertEqual(self.element.text, 't2t3t4')
self.tag.prepend('t5', 't6')
self.wait_until(lambda: self.element.text == 't5t6t2t3t4')
self.assertEqual(self.element.text, 't5t6t2t3t4')
def test_after(self):
self.set_element(self.tag)
self.tag.append(self.c1)
self.c1.after(self.c2)
self.wait_until(lambda: self.element.text == 'child1child2')
self.assertEqual(self.element.text, 'child1child2')
self.c1.after(self.c3, self.c4)
self.wait_until(
lambda: self.element.text == 'child1child3child4child2')
self.assertEqual(self.element.text, 'child1child3child4child2')
self.c1.after(self.c2, 'text')
self.wait_until(
lambda: self.element.text == 'child1child2textchild3child4')
self.assertEqual(self.element.text, 'child1child2textchild3child4')
def test_before(self):
self.set_element(self.tag)
self.tag.append(self.c1)
self.c1.before(self.c2)
self.wait_until(lambda: self.element.text == 'child2child1')
self.assertEqual(self.element.text, 'child2child1')
self.c1.before(self.c3, self.c4)
self.wait_until(
lambda: self.element.text == 'child2child3child4child1')
self.assertEqual(self.element.text, 'child2child3child4child1')
self.c1.before(self.c2, 'text')
self.wait_until(
lambda: self.element.text == 'child3child4child2textchild1')
self.assertEqual(self.element.text, 'child3child4child2textchild1')
def test_after_before_text(self):
self.set_element(self.tag)
self.tag.append('a')
t = self.tag.firstChild
t.after('b')
self.wait_until(lambda: self.element.text == 'ab')
self.assertEqual(self.element.text, 'ab')
t.after('c', 'd')
self.wait_until(lambda: self.element.text == 'acdb')
self.assertEqual(self.element.text, 'acdb')
t.before('e')
self.wait_until(lambda: self.element.text == 'eacdb')
self.assertEqual(self.element.text, 'eacdb')
t.before('f', 'g')
self.wait_until(lambda: self.element.text == 'efgacdb')
self.assertEqual(self.element.text, 'efgacdb')
def test_shortcut_attr(self):
self.tag.textContent = 'TAG'
self.set_element(self.tag)
self.wait_until(lambda: self.element.is_displayed())
self.assertIsTrue(self.element.is_displayed())
self.tag.hidden = True
self.wait_until(lambda: not self.element.is_displayed())
self.assertIsFalse(self.element.is_displayed())
self.tag.hidden = False
self.wait_until(lambda: self.element.is_displayed())
self.assertIsTrue(self.element.is_displayed())
def test_style(self):
self.tag.textContent = 'Style'
self.set_element(self.tag)
self.wait_until(lambda: self.element.get_attribute('style') == '')
self.assertEqual(self.element.get_attribute('style'), '')
style = 'color: red;'
self.tag.style = style
self.wait_until(lambda: self.element.get_attribute('style') == style)
self.assertEqual(self.element.get_attribute('style'), style)
self.tag.style.color = 'black'
self.wait_until(
lambda: self.element.get_attribute('style') == 'color: black;')
self.assertEqual(self.element.get_attribute('style'), 'color: black;')
def test_classlist(self):
self.set_element(self.tag)
self.assertEqual(self.element.get_attribute('class'), '')
self.tag.classList.add('a')
self.wait_until(lambda: self.element.get_attribute('class') == 'a')
self.assertEqual(self.element.get_attribute('class'), 'a')
self.tag.classList.add('b', 'c', 'd')
self.wait_until(
lambda: self.element.get_attribute('class') == 'a b c d')
self.assertEqual(self.element.get_attribute('class'), 'a b c d')
self.tag.classList.remove('c')
self.wait_until(lambda: self.element.get_attribute('class') == 'a b d')
self.assertEqual(self.element.get_attribute('class'), 'a b d')
self.tag.classList.remove('a', 'd')
self.wait_until(lambda: self.element.get_attribute('class') == 'b')
self.assertEqual(self.element.get_attribute('class'), 'b')
self.tag.classList.toggle('b')
self.wait_until(lambda: self.element.get_attribute('class') == '')
self.assertEqual(self.element.get_attribute('class'), '')
self.tag.classList.toggle('b')
self.wait_until(lambda: self.element.get_attribute('class') == 'b')
self.assertEqual(self.element.get_attribute('class'), 'b')
def test_click(self):
mock = MagicMock(_is_coroutine=False)
self.tag.addEventListener('click', mock)
self.tag.click()
self.wait_until(lambda: mock.call_count == 1)
self.assertEqual(mock.call_count, 1)
@sync
@asyncio.coroutine
def test_get_rect(self):
rect = WebElement('div', style='width:200px;height:100px;')
self.tag.appendChild(rect)
yield from asyncio.sleep(self.wait_time)
data = yield from rect.getBoundingClientRect()
self.assertEqual(data['width'], 200)
self.assertEqual(data['height'], 100)
@sync
@asyncio.coroutine
def test_scroll(self):
rect = WebElement('div',
style='width:3000px;height:3000px;background:#eee;')
self.tag.appendChild(rect)
yield from asyncio.sleep(self.wait_time)
X = yield from rect.scrollX()
Y = yield from rect.scrollY()
self.assertEqual(X['x'], 0)
self.assertEqual(Y['y'], 0)
rect.scrollTo(200, 200)
yield from asyncio.sleep(self.wait_time)
X = yield from rect.scrollX()
Y = yield from rect.scrollY()
self.assertEqual(X['x'], 200)
self.assertEqual(Y['y'], 200)
def test_exec(self):
self.tag.exec('this.style = "color: red;"')
self.set_element(self.tag)
self.wait_until(
lambda: re.search(r'255,\s*0,\s* 0,\s*1\s*',
self.element.value_of_css_property('color')))
self.assertRegex(self.element.value_of_css_property('color'),
r'255,\s*0,\s* 0,\s*1\s*')
self.tag.exec('node.style = "color: blue;"')
self.wait_until(
lambda: re.search(r'0,\s*0,\s* 255,\s*1\s*',
self.element.value_of_css_property('color')))
self.assertRegex(self.element.value_of_css_property('color'),
r'0,\s*0,\s*255,\s*1\s*')
def test_exec_error(self):
with self.assertLogs('wdom.server', 'ERROR') as log:
self.tag.exec('a.b')
self.wait_until(lambda: len(log.output) > 0)
self.assertRegex(log.output[0], r'JS: ReferenceError')
def setUp(self):
self.node = Node()
self.df = DocumentFragment()
self.tnode = Text('text')
class TestDocumentFragment(TestCase):
def setUp(self):
self.df = DocumentFragment()
self.elm = Element('a')
self.c1 = Element('c1')
self.c2 = Element('c2')
self.c3 = Element('c3')
def test_nodename(self):
self.assertEqual(self.df.nodeName, '#document-fragment')
def test_children(self):
self.assertFalse(self.df.hasChildNodes())
appended_child = self.df.appendChild(self.elm)
self.assertEqual(self.df.html, '<a></a>')
self.assertIs(appended_child, self.elm)
def test_append_to_element(self):
appended_child1 = self.df.appendChild(self.c1)
appended_child2 = self.df.appendChild(self.c2)
self.assertIs(self.df, self.c1.parentNode)
self.assertIs(self.df, self.c2.parentNode)
self.assertIs(appended_child1, self.c1)
self.assertIs(appended_child2, self.c2)
appended_df = self.elm.appendChild(self.df)
self.assertIs(appended_df, self.df)
self.assertEqual(self.df.length, 0)
self.assertEqual(self.elm.length, 2)
self.assertFalse(self.df.hasChildNodes())
self.assertIsNone(self.df.parentNode)
self.assertIs(self.elm, self.c1.parentNode)
self.assertIs(self.elm, self.c2.parentNode)
self.assertIsNone(self.df.parentNode)
def test_insert_to_element(self):
self.df.appendChild(self.c1)
self.df.appendChild(self.c2)
self.elm.appendChild(self.c3)
inserted_node = self.elm.insertBefore(self.df, self.c3)
self.assertIs(inserted_node, self.df)
self.assertEqual(self.df.length, 0)
self.assertEqual(self.elm.length, 3)
self.assertFalse(self.df.hasChildNodes())
self.assertIsNone(self.df.parentNode)
self.assertIs(self.elm, self.c1.parentNode)
self.assertIs(self.elm, self.c2.parentNode)
self.assertIsNone(self.c1.previousSibling)
self.assertIs(self.c1.nextSibling, self.c2)
self.assertIs(self.c2.previousSibling, self.c1)
self.assertIs(self.c2.nextSibling, self.c3)
self.assertIs(self.c3.previousSibling, self.c2)
self.assertIsNone(self.c3.nextSibling)
self.assertIs(self.elm.firstChild, self.c1)
self.assertIs(self.elm.lastChild, self.c3)
def test_child(self):
appended_child1 = self.df.appendChild(self.c1)
appended_child2 = self.df.appendChild(self.c2)
self.assertIs(appended_child1, self.c1)
self.assertIs(appended_child2, self.c2)
self.assertEqual(self.c1.html, '<c1></c1>')
self.assertEqual(self.df.html, '<c1></c1><c2></c2>')
def test_clone_node_sharrow(self):
self.df.appendChild(self.c1)
clone = self.df.cloneNode()
self.assertEqual(self.df.length, 1)
self.assertEqual(clone.length, 0)
clone.appendChild(self.c2)
self.assertEqual(self.df.length, 1)
self.assertEqual(clone.length, 1)
def test_clone_node_deep(self):
self.df.appendChild(self.c1)
clone = self.df.cloneNode(deep=True)
self.assertEqual(self.df.length, 1)
self.assertEqual(clone.length, 1)
self.assertEqual(clone.html, '<c1></c1>')
clone.appendChild(self.c2)
self.assertEqual(self.df.length, 1)
self.assertEqual(clone.length, 2)
self.df.removeChild(self.c1)
self.assertEqual(self.df.length, 0)
self.assertEqual(clone.length, 2)
def setUp(self):
self.df = DocumentFragment()
self.elm = Element('a')
self.c1 = Element('c1')
self.c2 = Element('c2')
self.c3 = Element('c3')
def __init__(self, *args, default_class=None, **kwargs):
# Import here
self.default_class = default_class or HTMLElement
super().__init__(*args, **kwargs)
self.elm = DocumentFragment()
self.root = self.elm
