Ejemplo n.º 1
0
    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)
Ejemplo n.º 2
0
 def setUp(self):
     self.elm = WebElement("tag")
     self.c1 = WebElement()
     self.c2 = WebElement()
     self.js_mock = MagicMock()
     self.js_mock1 = MagicMock()
     self.js_mock2 = MagicMock()
     self.elm.js_exec = self.js_mock
     self.c1.js_exec = self.js_mock1
     self.c2.js_exec = self.js_mock2
Ejemplo n.º 3
0
 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
Ejemplo n.º 4
0
 def setUp(self):
     super().setUp()
     set_server_type("tornado")
     _tornado.connections.append(MagicMock())
     self.elm = WebElement("tag")
     self.elm.js_exec = MagicMock()
     self.msg = {"type": "response", "id": self.elm.rimo_id}
Ejemplo n.º 5
0
 def setUp(self):
     self.elm = WebElement("tag")
     self.elm.js_exec = MagicMock()
     self.mock = MagicMock(_is_coroutine=False)
     self.elm.addEventListener("click", self.mock)
     self.msg = {"type": "event", "id": self.elm.rimo_id, "event": {"type": "click"}}
     self.event = Event(**self.msg.get("event"))
Ejemplo n.º 6
0
    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)
Ejemplo n.º 7
0
    def get_elements(self):
        self.root = WebElement('div')
        self.tag = WebElement('span', parent=self.root)

        self.click_event_mock = MagicMock()
        self.click_event_mock._is_coroutine = False

        self.btn = WebElement('button')
        self.btn.textContent = 'click'
        self.btn.addEventListener('click', self.click_event_mock)

        self.input_event_mock = MagicMock()
        self.input_event_mock._is_coroutine = False

        self.input = WebElement('input', type='text')
        self.input.addEventListener('input', self.input_event_mock)

        self.root.appendChild(self.btn)
        self.root.appendChild(self.input)
        return self.root
Ejemplo n.º 8
0
class TestQuery(TestCase):
    def setUp(self):
        super().setUp()
        set_server_type("tornado")
        _tornado.connections.append(MagicMock())
        self.elm = WebElement("tag")
        self.elm.js_exec = MagicMock()
        self.msg = {"type": "response", "id": self.elm.rimo_id}

    def test_query(self):
        fut = self.elm.js_query("test")
        self.elm.js_exec.assert_called_once_with("test", 0)
        self.msg["reqid"] = 0
        self.msg["data"] = 1
        self.elm.on_response(self.msg)
        self.assertEqual(fut.result(), 1)

    @sync
    @asyncio.coroutine
    def test_scroll(self):
        fut = self.elm.scrollX()
        self.assertFalse(fut.done())
        self.msg["reqid"] = 0
        self.msg["data"] = {"x": 1}
        self.elm.on_response(self.msg)
        x = yield from fut
        self.assertEqual(x, {"x": 1})
Ejemplo n.º 9
0
class TestEventMessage(TestCase):
    def setUp(self):
        self.elm = WebElement("tag")
        self.elm.js_exec = MagicMock()
        self.mock = MagicMock(_is_coroutine=False)
        self.elm.addEventListener("click", self.mock)
        self.msg = {"type": "event", "id": self.elm.rimo_id, "event": {"type": "click"}}
        self.event = Event(**self.msg.get("event"))

    def test_handle_event(self):
        self.elm.js_exec.assert_called_once_with("addEventListener", "click")
        self.elm.dispatchEvent(self.event)
        self.assertTrue(self.mock.called)

    def test_remove_event(self):
        self.elm.removeEventListener("click", self.mock)
        self.elm.js_exec.assert_called_with("removeEventListener", "click")
        self.elm.dispatchEvent(self.event)
        self.mock.assert_not_called()
Ejemplo n.º 10
0
    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)
Ejemplo n.º 11
0
class TestEvent(ElementTestCase, TestCase):
    def get_elements(self):
        self.root = WebElement('div')
        self.tag = WebElement('span', parent=self.root)

        self.click_event_mock = MagicMock()
        self.click_event_mock._is_coroutine = False

        self.btn = WebElement('button')
        self.btn.textContent = 'click'
        self.btn.addEventListener('click', self.click_event_mock)

        self.input_event_mock = MagicMock()
        self.input_event_mock._is_coroutine = False

        self.input = WebElement('input', type='text')
        self.input.addEventListener('input', self.input_event_mock)

        self.root.appendChild(self.btn)
        self.root.appendChild(self.input)
        return self.root

    @unittest.skipIf(os.environ.get('TRAVIS', False),
                     reason='This test not pass only on travis')
    def test_click(self):
        # need to wait some times
        self.wait(times=10)
        self.set_element(self.btn)
        self.wait(times=10)
        self.element.click()
        self.wait(times=10)
        self.wait_until(lambda: self.click_event_mock.call_count == 1)
        self.assertEqual(self.click_event_mock.call_count, 1)

    def test_input(self):
        self.set_element(self.input)
        self.element.send_keys('abc')
        self.wait_until(lambda: self.input_event_mock.call_count == 3)
        self.assertEqual(self.input_event_mock.call_count, 3)
Ejemplo n.º 12
0
class TestWebElement(TestCase):
    def setUp(self):
        self.elm = WebElement("tag")
        self.c1 = WebElement()
        self.c2 = WebElement()
        self.js_mock = MagicMock()
        self.js_mock1 = MagicMock()
        self.js_mock2 = MagicMock()
        self.elm.js_exec = self.js_mock
        self.c1.js_exec = self.js_mock1
        self.c2.js_exec = self.js_mock2

    def test_id(self):
        self.assertRegex(self.elm.html, r'<tag rimo_id="\d+"></tag>')
        self.assertRegex(self.elm.rimo_id, r"\d+")

    def test_noid(self):
        self.assertEqual("<tag></tag>", self.elm.html_noid)

        self.c1.tag = "c1"
        appended_child1 = self.elm.appendChild(self.c1)
        self.assertIs(appended_child1, self.c1)
        self.assertEqual("<tag><c1></c1></tag>", self.elm.html_noid)

        self.c2.tag = "c2"
        appended_child2 = self.c1.appendChild(self.c2)
        self.assertIs(appended_child2, self.c2)
        self.assertEqual("<tag><c1><c2></c2></c1></tag>", self.elm.html_noid)

    def test_id_init(self):
        elm = WebElement("tag", rimo_id="myid")
        self.assertEqual('<tag rimo_id="myid"></tag>', elm.html)

    def test_not_connected(self):
        self.assertFalse(self.elm.connected)

    def test_parent(self):
        self.assertIsNone(self.elm.parentNode)
        self.assertIsNone(self.c1.parentNode)
        self.elm.appendChild(self.c1)
        self.assertIs(self.elm, self.c1.parentNode)
        self.js_mock1.assert_not_called()
        self.assertEqual(self.js_mock.call_count, 1)
        self.js_mock.assert_called_once_with("insertAdjacentHTML", "beforeend", self.c1.html)

        removed_child1 = self.elm.removeChild(self.c1)
        self.assertIs(removed_child1, self.c1)
        self.assertIsNone(self.c1.parentNode)
        self.assertEqual(self.js_mock.call_count, 2)
        self.js_mock1.assert_not_called()
        self.js_mock.assert_called_with("removeChildById", self.c1.rimo_id)

    def test_addremove_child(self):
        self.assertFalse(self.elm.hasChildNodes())
        self.elm.appendChild(self.c1)
        self.assertTrue(self.elm.hasChildNodes())
        self.assertIn(self.c1, self.elm)
        self.assertNotIn(self.c2, self.elm)
        self.assertEqual(self.elm.length, 1)

        self.elm.insertBefore(self.c2, self.c1)
        self.assertIn(self.c1, self.elm)
        self.assertIn(self.c2, self.elm)
        self.assertEqual(self.elm.length, 2)
        self.c2.remove()
        self.assertEqual(self.elm.length, 1)
        self.assertIn(self.c1, self.elm)
        self.assertNotIn(self.c2, self.elm)
        self.assertIsNone(self.c2.parentNode)
        self.js_mock2.assert_called_once_with("remove")

        self.elm.removeChild(self.c1)
        self.assertFalse(self.elm.hasChildNodes())
        self.assertEqual(self.elm.length, 0)
        self.assertNotIn(self.c1, self.elm)
        self.assertNotIn(self.c2, self.elm)
        self.js_mock1.assert_called_once_with("insertAdjacentHTML", "beforebegin", self.c2.html)
        self.assertEqual(self.js_mock.call_count, 3)

        with self.assertRaises(ValueError):
            self.elm.removeChild(self.c1)

    def test_addremove_attr(self):
        self.elm.setAttribute("src", "a")
        self.js_mock.assert_called_with("setAttribute", "src", "a")
        self.elm.removeAttribute("src")
        self.js_mock.assert_called_with("removeAttribute", "src")

    def test_style(self):
        self.elm.style = "color: red;"
        self.js_mock.assert_called_once_with("setAttribute", "style", "color: red;")
        self.elm.removeAttribute("style")
        self.js_mock.assert_called_with("removeAttribute", "style")
        self.elm.style.color = "black"
        self.js_mock.assert_called_with("setAttribute", "style", "color: black;")

    def test_style_init(self):
        _js_exec = WebElement.js_exec
        WebElement.js_exec = self.js_mock
        WebElement("elm", style="color: red;")
        _call = call("setAttribute", "style", "color: red;")
        _call_remove = call("removeAttribute", "style")
        self.js_mock.assert_has_calls([_call])
        count = 0
        for c in self.js_mock.call_args_list:
            if c == _call:
                count += 1
            elif c == _call_remove:
                raise AssertionError("Unexpeted remove style")
        self.assertEqual(count, 1)
        WebElement.js_exec = _js_exec

    def test_set_text_content(self):
        self.elm.textContent = "text"
        self.js_mock.assert_called_once_with("textContent", "text")

    def test_set_inner_html(self):
        self.elm.innerHTML = "html"
        self.js_mock.assert_called_once_with("innerHTML", "html")

    def test_shallow_copy(self):
        from copy import copy

        clone = copy(self.elm)
        self.assertNotEqual(clone.rimo_id, self.elm.rimo_id)

        clone = self.elm.cloneNode()
        self.assertNotEqual(clone.rimo_id, self.elm.rimo_id)

    def test_deep_copy(self):
        from copy import deepcopy

        clone = deepcopy(self.elm)
        self.assertNotEqual(clone.rimo_id, self.elm.rimo_id)

        clone = self.elm.cloneNode(deep=True)
        self.assertNotEqual(clone.rimo_id, self.elm.rimo_id)

    def test_click(self):
        mock = MagicMock(_is_coroutine=False)
        self.elm.addEventListener("click", mock)
        self.elm.click()
        self.js_mock.assert_called_once_with("addEventListener", "click")
        self.assertEqual(mock.call_count, 1)
Ejemplo n.º 13
0
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')