Converted test_webelem to pytest

test/browser/test_webelem.py

@@ -21,15 +21,14 @@
 
 """Tests for the webelement utils."""
 
-import unittest
 from unittest import mock
 import collections.abc
 
 from PyQt5.QtCore import QRect, QPoint
 from PyQt5.QtWebKit import QWebElement
+import pytest
 
 from qutebrowser.browser import webelem
-from qutebrowser.test import stubs
 
 
 def get_webelem(geometry=None, frame=None, null=False, visibility='',
@@ -87,17 +86,17 @@ def get_webelem(geometry=None, frame=None, null=False, visibility='',
     return wrapped
 
 
-class WebElementWrapperTests(unittest.TestCase):
+class TestWebElementWrapper(object):
 
     """Test WebElementWrapper."""
 
     def test_nullelem(self):
         """Test __init__ with a null element."""
-        with self.assertRaises(webelem.IsNullError):
+        with pytest.raises(webelem.IsNullError):
             get_webelem(null=True)
 
 
-class IsVisibleInvalidTests(unittest.TestCase):
+class TestIsVisibleInvalid(object):
 
     """Tests for is_visible with invalid elements.
 
@@ -105,7 +104,8 @@ class IsVisibleInvalidTests(unittest.TestCase):
         frame: The FakeWebFrame we're using to test.
     """
 
-    def setUp(self):
+    @pytest.fixture(autouse=True)
+    def setup(self, stubs):
         self.frame = stubs.FakeWebFrame(QRect(0, 0, 100, 100))
 
     def test_nullelem(self):
@@ -116,15 +116,15 @@ class IsVisibleInvalidTests(unittest.TestCase):
         """
         elem = get_webelem()
         elem._elem.isNull.return_value = True
-        with self.assertRaises(webelem.IsNullError):
+        with pytest.raises(webelem.IsNullError):
             elem.is_visible(self.frame)
 
     def test_invalid_invisible(self):
         """Test elements with an invalid geometry which are invisible."""
         elem = get_webelem(QRect(0, 0, 0, 0), self.frame)
-        self.assertFalse(elem.geometry().isValid())
+        assert not elem.geometry().isValid()
-        self.assertEqual(elem.geometry().x(), 0)
+        assert elem.geometry().x() == 0
-        self.assertFalse(elem.is_visible(self.frame))
+        assert not elem.is_visible(self.frame)
 
     def test_invalid_visible(self):
         """Test elements with an invalid geometry which are visible.
@@ -133,11 +133,11 @@ class IsVisibleInvalidTests(unittest.TestCase):
         which *are* visible, but don't have a valid geometry.
         """
         elem = get_webelem(QRect(10, 10, 0, 0), self.frame)
-        self.assertFalse(elem.geometry().isValid())
+        assert not elem.geometry().isValid()
-        self.assertTrue(elem.is_visible(self.frame))
+        assert elem.is_visible(self.frame)
 
 
-class IsVisibleScrollTests(unittest.TestCase):
+class TestIsVisibleScroll(object):
 
     """Tests for is_visible when the frame is scrolled.
 
@@ -145,22 +145,23 @@ class IsVisibleScrollTests(unittest.TestCase):
         frame: The FakeWebFrame we're using to test.
     """
 
-    def setUp(self):
+    @pytest.fixture(autouse=True)
+    def setup(self, stubs):
         self.frame = stubs.FakeWebFrame(QRect(0, 0, 100, 100),
                                         scroll=QPoint(10, 10))
 
     def test_invisible(self):
         """Test elements which should be invisible due to scrolling."""
         elem = get_webelem(QRect(5, 5, 4, 4), self.frame)
-        self.assertFalse(elem.is_visible(self.frame))
+        assert not elem.is_visible(self.frame)
 
     def test_visible(self):
         """Test elements which still should be visible after scrolling."""
         elem = get_webelem(QRect(10, 10, 1, 1), self.frame)
-        self.assertTrue(elem.is_visible(self.frame))
+        assert elem.is_visible(self.frame)
 
 
-class IsVisibleCssTests(unittest.TestCase):
+class TestIsVisibleCss(object):
 
     """Tests for is_visible with CSS attributes.
 
@@ -168,33 +169,34 @@ class IsVisibleCssTests(unittest.TestCase):
         frame: The FakeWebFrame we're using to test.
     """
 
-    def setUp(self):
+    @pytest.fixture(autouse=True)
+    def setup(self, stubs):
         self.frame = stubs.FakeWebFrame(QRect(0, 0, 100, 100))
 
     def test_visibility_visible(self):
         """Check that elements with "visibility = visible" are visible."""
         elem = get_webelem(QRect(0, 0, 10, 10), self.frame,
                            visibility='visible')
-        self.assertTrue(elem.is_visible(self.frame))
+        assert elem.is_visible(self.frame)
 
     def test_visibility_hidden(self):
         """Check that elements with "visibility = hidden" are not visible."""
         elem = get_webelem(QRect(0, 0, 10, 10), self.frame,
                            visibility='hidden')
-        self.assertFalse(elem.is_visible(self.frame))
+        assert not elem.is_visible(self.frame)
 
     def test_display_inline(self):
         """Check that elements with "display = inline" are visible."""
         elem = get_webelem(QRect(0, 0, 10, 10), self.frame, display='inline')
-        self.assertTrue(elem.is_visible(self.frame))
+        assert elem.is_visible(self.frame)
 
     def test_display_none(self):
         """Check that elements with "display = none" are not visible."""
         elem = get_webelem(QRect(0, 0, 10, 10), self.frame, display='none')
-        self.assertFalse(elem.is_visible(self.frame))
+        assert not elem.is_visible(self.frame)
 
 
-class IsVisibleIframeTests(unittest.TestCase):
+class TestIsVisibleIframe(object):
 
     """Tests for is_visible with a child frame.
 
@@ -204,7 +206,8 @@ class IsVisibleIframeTests(unittest.TestCase):
         elem1-elem4: FakeWebElements to test.
     """
 
-    def setUp(self):
+    @pytest.fixture(autouse=True)
+    def setup(self, stubs):
         """Set up the following base situation.
 
              0, 0                         300, 0
@@ -236,64 +239,64 @@ class IsVisibleIframeTests(unittest.TestCase):
 
     def test_not_scrolled(self):
         """Test base situation."""
-        self.assertTrue(self.frame.geometry().contains(self.iframe.geometry()))
+        assert self.frame.geometry().contains(self.iframe.geometry())
-        self.assertTrue(self.elem1.is_visible(self.frame))
+        assert self.elem1.is_visible(self.frame)
-        self.assertTrue(self.elem2.is_visible(self.frame))
+        assert self.elem2.is_visible(self.frame)
-        self.assertFalse(self.elem3.is_visible(self.frame))
+        assert not self.elem3.is_visible(self.frame)
-        self.assertTrue(self.elem4.is_visible(self.frame))
+        assert self.elem4.is_visible(self.frame)
 
     def test_iframe_scrolled(self):
         """Scroll iframe down so elem3 gets visible and elem1/elem2 not."""
         self.iframe.scrollPosition.return_value = QPoint(0, 100)
-        self.assertFalse(self.elem1.is_visible(self.frame))
+        assert not self.elem1.is_visible(self.frame)
-        self.assertFalse(self.elem2.is_visible(self.frame))
+        assert not self.elem2.is_visible(self.frame)
-        self.assertTrue(self.elem3.is_visible(self.frame))
+        assert self.elem3.is_visible(self.frame)
-        self.assertTrue(self.elem4.is_visible(self.frame))
+        assert self.elem4.is_visible(self.frame)
 
     def test_mainframe_scrolled_iframe_visible(self):
         """Scroll mainframe down so iframe is partly visible but elem1 not."""
         self.frame.scrollPosition.return_value = QPoint(0, 50)
         geom = self.frame.geometry().translated(self.frame.scrollPosition())
-        self.assertFalse(geom.contains(self.iframe.geometry()))
+        assert not geom.contains(self.iframe.geometry())
-        self.assertTrue(geom.intersects(self.iframe.geometry()))
+        assert geom.intersects(self.iframe.geometry())
-        self.assertFalse(self.elem1.is_visible(self.frame))
+        assert not self.elem1.is_visible(self.frame)
-        self.assertTrue(self.elem2.is_visible(self.frame))
+        assert self.elem2.is_visible(self.frame)
-        self.assertFalse(self.elem3.is_visible(self.frame))
+        assert not self.elem3.is_visible(self.frame)
-        self.assertTrue(self.elem4.is_visible(self.frame))
+        assert self.elem4.is_visible(self.frame)
 
     def test_mainframe_scrolled_iframe_invisible(self):
         """Scroll mainframe down so iframe is invisible."""
         self.frame.scrollPosition.return_value = QPoint(0, 110)
         geom = self.frame.geometry().translated(self.frame.scrollPosition())
-        self.assertFalse(geom.contains(self.iframe.geometry()))
+        assert not geom.contains(self.iframe.geometry())
-        self.assertFalse(geom.intersects(self.iframe.geometry()))
+        assert not geom.intersects(self.iframe.geometry())
-        self.assertFalse(self.elem1.is_visible(self.frame))
+        assert not self.elem1.is_visible(self.frame)
-        self.assertFalse(self.elem2.is_visible(self.frame))
+        assert not self.elem2.is_visible(self.frame)
-        self.assertFalse(self.elem3.is_visible(self.frame))
+        assert not self.elem3.is_visible(self.frame)
-        self.assertTrue(self.elem4.is_visible(self.frame))
+        assert self.elem4.is_visible(self.frame)
 
 
-class IsWritableTests(unittest.TestCase):
+class TestIsWritable(object):
 
     """Check is_writable."""
 
     def test_writable(self):
         """Test a normal element."""
         elem = get_webelem()
-        self.assertTrue(elem.is_writable())
+        assert elem.is_writable()
 
     def test_disabled(self):
         """Test a disabled element."""
         elem = get_webelem(attributes=['disabled'])
-        self.assertFalse(elem.is_writable())
+        assert not elem.is_writable()
 
     def test_readonly(self):
         """Test a readonly element."""
         elem = get_webelem(attributes=['readonly'])
-        self.assertFalse(elem.is_writable())
+        assert not elem.is_writable()
 
 
-class JavascriptEscapeTests(unittest.TestCase):
+class TestJavascriptEscape(object):
 
     """Check javascript_escape.
 
@@ -301,33 +304,30 @@ class JavascriptEscapeTests(unittest.TestCase):
         STRINGS: A list of (input, output) tuples.
     """
 
-    STRINGS = (
+    @pytest.mark.parametrize('before, after', [
         ('foo\\bar', r'foo\\bar'),
         ('foo\nbar', r'foo\nbar'),
         ("foo'bar", r"foo\'bar"),
         ('foo"bar', r'foo\"bar'),
-    )
+    ])
-
+    def test_fake_escape(self, before, after):
-    def test_fake_escape(self):
         """Test javascript escaping."""
-        for before, after in self.STRINGS:
+        assert webelem.javascript_escape(before) == after
-            with self.subTest(before=before):
-                self.assertEqual(webelem.javascript_escape(before), after)
 
 
-class GetChildFramesTests(unittest.TestCase):
+class TestGetChildFrames(object):
 
     """Check get_child_frames."""
 
-    def test_single_frame(self):
+    def test_single_frame(self, stubs):
         """Test get_child_frames with a single frame without children."""
         frame = stubs.FakeChildrenFrame()
         children = webelem.get_child_frames(frame)
-        self.assertEqual(len(children), 1)
+        assert len(children) == 1
-        self.assertIs(children[0], frame)
+        assert children[0] is frame
         frame.childFrames.assert_called_once_with()
 
-    def test_one_level(self):
+    def test_one_level(self, stubs):
         r"""Test get_child_frames with one level of children.
 
                   o   parent
@@ -338,15 +338,15 @@ class GetChildFramesTests(unittest.TestCase):
         child2 = stubs.FakeChildrenFrame()
         parent = stubs.FakeChildrenFrame([child1, child2])
         children = webelem.get_child_frames(parent)
-        self.assertEqual(len(children), 3)
+        assert len(children) == 3
-        self.assertIs(children[0], parent)
+        assert children[0] is parent
-        self.assertIs(children[1], child1)
+        assert children[1] is child1
-        self.assertIs(children[2], child2)
+        assert children[2] is child2
         parent.childFrames.assert_called_once_with()
         child1.childFrames.assert_called_once_with()
         child2.childFrames.assert_called_once_with()
 
-    def test_multiple_levels(self):
+    def test_multiple_levels(self, stubs):
         r"""Test get_child_frames with multiple levels of children.
 
             o      root
@@ -360,189 +360,190 @@ class GetChildFramesTests(unittest.TestCase):
                  stubs.FakeChildrenFrame(second[2:4])]
         root = stubs.FakeChildrenFrame(first)
         children = webelem.get_child_frames(root)
-        self.assertEqual(len(children), 7)
+        assert len(children) == 7
-        self.assertIs(children[0], root)
+        assert children[0] is root
         for frame in [root] + first + second:
-            with self.subTest(frame=frame):
             frame.childFrames.assert_called_once_with()
 
 
-class IsEditableTests(unittest.TestCase):
+class TestIsEditable(object):
 
     """Tests for is_editable."""
 
-    def setUp(self):
+    @pytest.yield_fixture(autouse=True)
+    def setup(self):
+        old_config = webelem.config
         webelem.config = None
+        yield
+        webelem.config = old_config
+
+    @pytest.yield_fixture
+    def stub_config(self, stubs):
+        config = stubs.ConfigStub({'input': {'insert-mode-on-plugins': True}})
+        with mock.patch('qutebrowser.browser.webelem.config', new=config):
+            yield config
 
     def test_input_plain(self):
         """Test with plain input element."""
         elem = get_webelem(tagname='input')
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_input_text(self):
         """Test with text input element."""
         elem = get_webelem(tagname='input', attributes={'type': 'text'})
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_input_text_caps(self):
         """Test with text input element with caps attributes."""
         elem = get_webelem(tagname='INPUT', attributes={'TYPE': 'TEXT'})
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_input_email(self):
         """Test with email input element."""
         elem = get_webelem(tagname='input', attributes={'type': 'email'})
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_input_url(self):
         """Test with url input element."""
         elem = get_webelem(tagname='input', attributes={'type': 'url'})
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_input_tel(self):
         """Test with tel input element."""
         elem = get_webelem(tagname='input', attributes={'type': 'tel'})
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_input_number(self):
         """Test with number input element."""
         elem = get_webelem(tagname='input', attributes={'type': 'number'})
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_input_password(self):
         """Test with password input element."""
         elem = get_webelem(tagname='input', attributes={'type': 'password'})
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_input_search(self):
         """Test with search input element."""
         elem = get_webelem(tagname='input', attributes={'type': 'search'})
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_input_button(self):
         """Button should not be editable."""
         elem = get_webelem(tagname='input', attributes={'type': 'button'})
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_input_checkbox(self):
         """Checkbox should not be editable."""
         elem = get_webelem(tagname='input', attributes={'type': 'checkbox'})
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_textarea(self):
         """Test textarea element."""
         elem = get_webelem(tagname='textarea')
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_select(self):
         """Test selectbox."""
         elem = get_webelem(tagname='select')
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_input_disabled(self):
         """Test disabled input element."""
         elem = get_webelem(tagname='input', attributes={'disabled': None})
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_input_readonly(self):
         """Test readonly input element."""
         elem = get_webelem(tagname='input', attributes={'readonly': None})
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_textarea_disabled(self):
         """Test disabled textarea element."""
         elem = get_webelem(tagname='textarea', attributes={'disabled': None})
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_textarea_readonly(self):
         """Test readonly textarea element."""
         elem = get_webelem(tagname='textarea', attributes={'readonly': None})
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
-    @mock.patch('qutebrowser.browser.webelem.config', new=stubs.ConfigStub(
+    def test_embed_true(self, stub_config):
-        {'input': {'insert-mode-on-plugins': True}}))
-    def test_embed_true(self):
         """Test embed-element with insert-mode-on-plugins true."""
+        stub_config.data['input']['insert-mode-on-plugins'] = True
         elem = get_webelem(tagname='embed')
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
-    @mock.patch('qutebrowser.browser.webelem.config', new=stubs.ConfigStub(
+    def test_applet_true(self, stub_config):
-        {'input': {'insert-mode-on-plugins': True}}))
-    def test_applet_true(self):
         """Test applet-element with insert-mode-on-plugins true."""
+        stub_config.data['input']['insert-mode-on-plugins'] = True
         elem = get_webelem(tagname='applet')
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
-    @mock.patch('qutebrowser.browser.webelem.config', new=stubs.ConfigStub(
+    def test_embed_false(self, stub_config):
-        {'input': {'insert-mode-on-plugins': False}}))
-    def test_embed_false(self):
         """Test embed-element with insert-mode-on-plugins false."""
+        stub_config.data['input']['insert-mode-on-plugins'] = False
         elem = get_webelem(tagname='embed')
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
-    @mock.patch('qutebrowser.browser.webelem.config', new=stubs.ConfigStub(
+    def test_applet_false(self, stub_config):
-        {'input': {'insert-mode-on-plugins': False}}))
-    def test_applet_false(self):
         """Test applet-element with insert-mode-on-plugins false."""
+        stub_config.data['input']['insert-mode-on-plugins'] = False
         elem = get_webelem(tagname='applet')
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_object_no_type(self):
         """Test object-element without type."""
         elem = get_webelem(tagname='object')
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_object_image(self):
         """Test object-element with image type."""
         elem = get_webelem(tagname='object', attributes={'type': 'image/gif'})
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
-    @mock.patch('qutebrowser.browser.webelem.config', new=stubs.ConfigStub(
+    def test_object_application(self, stub_config):
-        {'input': {'insert-mode-on-plugins': True}}))
-    def test_object_application(self):
         """Test object-element with application type."""
+        stub_config.data['input']['insert-mode-on-plugins'] = True
         elem = get_webelem(tagname='object',
                            attributes={'type': 'application/foo'})
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
-    @mock.patch('qutebrowser.browser.webelem.config', new=stubs.ConfigStub(
+    def test_object_application_false(self, stub_config):
-        {'input': {'insert-mode-on-plugins': False}}))
-    def test_object_application_false(self):
         """Test object-element with application type but not ...-on-plugins."""
+        stub_config.data['input']['insert-mode-on-plugins'] = False
         elem = get_webelem(tagname='object',
                            attributes={'type': 'application/foo'})
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
-    @mock.patch('qutebrowser.browser.webelem.config', new=stubs.ConfigStub(
+    def test_object_classid(self, stub_config):
-        {'input': {'insert-mode-on-plugins': True}}))
-    def test_object_classid(self):
         """Test object-element with classid."""
+        stub_config.data['input']['insert-mode-on-plugins'] = True
         elem = get_webelem(tagname='object',
                            attributes={'type': 'foo', 'classid': 'foo'})
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
-    @mock.patch('qutebrowser.browser.webelem.config', new=stubs.ConfigStub(
+    def test_object_classid_false(self, stub_config):
-        {'input': {'insert-mode-on-plugins': False}}))
-    def test_object_classid_false(self):
         """Test object-element with classid but not insert-mode-on-plugins."""
+        stub_config.data['input']['insert-mode-on-plugins'] = False
         elem = get_webelem(tagname='object',
                            attributes={'type': 'foo', 'classid': 'foo'})
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_div_empty(self):
         """Test div-element without class."""
         elem = get_webelem(tagname='div')
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_div_noneditable(self):
         """Test div-element with non-editableclass."""
         elem = get_webelem(tagname='div', classes='foo-kix-bar')
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_div_xik(self):
         """Test div-element with xik class."""
         elem = get_webelem(tagname='div', classes='foo kix-foo')
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
     def test_div_xik_caps(self):
         """Test div-element with xik class in caps.
@@ -550,13 +551,11 @@ class IsEditableTests(unittest.TestCase):
         This tests if classes are case sensitive as they should.
         """
         elem = get_webelem(tagname='div', classes='KIX-FOO')
-        self.assertFalse(elem.is_editable())
+        assert not elem.is_editable()
 
     def test_div_codemirror(self):
         """Test div-element with codemirror class."""
         elem = get_webelem(tagname='div', classes='foo CodeMirror-foo')
-        self.assertTrue(elem.is_editable())
+        assert elem.is_editable()
 
 
-if __name__ == '__main__':
-    unittest.main()