Write more tests for dirbrowser.

tests/browser/test_dirbrowser.py

@@ -20,10 +20,14 @@
 """Tests for qutebrowser.browser.network.filescheme."""
 
 import os
+import collections
 
 import pytest
+import bs4
+from PyQt5.QtCore import QUrl
+from PyQt5.QtNetwork import QNetworkRequest
 
-from qutebrowser.browser.network.filescheme import get_file_list
+from qutebrowser.browser.network import filescheme
 
 
 @pytest.mark.parametrize('create_file, create_dir, filterfunc, expected', [
@@ -44,6 +48,154 @@ def test_get_file_list(tmpdir, create_file, create_dir, filterfunc, expected):
 
     all_files = os.listdir(str(tmpdir))
 
-    result = get_file_list(str(tmpdir), all_files, filterfunc)
+    result = filescheme.get_file_list(str(tmpdir), all_files, filterfunc)
     item = {'name': 'foo', 'absname': str(path)}
     assert (item in result) == expected
+
+
+class TestIsRoot:
+
+    @pytest.mark.windows
+    @pytest.mark.parametrize('directory, is_root', [
+        ('C:\\foo', False),
+        ('C:\\', True)
+    ])
+    def test_windows(self, directory, is_root):
+        assert filescheme.is_root(directory) == is_root
+
+    @pytest.mark.posix
+    @pytest.mark.parametrize('directory, is_root', [
+        ('/foo', False),
+        ('/', True)
+    ])
+    def test_posix(self, directory, is_root):
+        assert filescheme.is_root(directory) == is_root
+
+
+class TestDirbrowserHtml:
+
+    Parsed = collections.namedtuple('Parsed', 'parent, folders, files')
+    Item = collections.namedtuple('Item', 'link, text')
+
+    @pytest.fixture
+    def parser(self):
+        """Provide a function to get a parsed dirbrowser document."""
+        def parse(path):
+            html = filescheme.dirbrowser_html(path)
+            soup = bs4.BeautifulSoup(html, 'html.parser')
+            print(soup.prettify())
+            container = soup('div', id='dirbrowserContainer')[0]
+
+            parent_elem = container('ul', class_='parent')[0].li
+            if parent_elem is None:
+                parent = None
+            else:
+                parent = parent_elem.a.string
+
+            folders = []
+            files = []
+
+            for li in container('ul', class_='folders')[0]('li'):
+                item = self.Item(link=li.a['href'], text=str(li.a.string))
+                folders.append(item)
+
+            for li in container('ul', class_='files')[0]('li'):
+                item = self.Item(link=li.a['href'], text=str(li.a.string))
+                files.append(item)
+
+            return self.Parsed(parent=parent, folders=folders, files=files)
+
+        return parse
+
+    def test_basic(self):
+        html = filescheme.dirbrowser_html(os.getcwd())
+        soup = bs4.BeautifulSoup(html, 'html.parser')
+        print(soup.prettify())
+        container = soup.div
+        assert container['id'] == 'dirbrowserContainer'
+        title_elem = container('div', id='dirbrowserTitle')[0]
+        title_text = title_elem('p', id='dirbrowserTitleText')[0].text
+        assert title_text == 'Browse directory: {}'.format(os.getcwd())
+
+    def test_empty(self, tmpdir, parser):
+        parsed = parser(str(tmpdir))
+        assert parsed.parent
+        assert not parsed.folders
+        assert not parsed.files
+
+    def test_files(self, tmpdir, parser):
+        foo_file = tmpdir / 'foo'
+        bar_file = tmpdir / 'bar'
+        foo_file.ensure()
+        bar_file.ensure()
+
+        parsed = parser(str(tmpdir))
+        assert parsed.parent
+        assert not parsed.folders
+        foo_item = self.Item('file://' + str(foo_file), foo_file.relto(tmpdir))
+        bar_item = self.Item('file://' + str(bar_file), bar_file.relto(tmpdir))
+        assert parsed.files == [bar_item, foo_item]
+
+    def test_dirs(self, tmpdir, parser):
+        foo_dir = tmpdir / 'foo'
+        bar_dir = tmpdir / 'bar'
+        foo_dir.ensure(dir=True)
+        bar_dir.ensure(dir=True)
+
+        parsed = parser(str(tmpdir))
+        assert parsed.parent
+        assert not parsed.files
+        foo_item = self.Item('file://' + str(foo_dir), foo_dir.relto(tmpdir))
+        bar_item = self.Item('file://' + str(bar_dir), bar_dir.relto(tmpdir))
+        assert parsed.folders == [bar_item, foo_item]
+
+    def test_mixed(self, tmpdir, parser):
+        foo_file = tmpdir / 'foo'
+        bar_dir = tmpdir / 'bar'
+        foo_file.ensure()
+        bar_dir.ensure(dir=True)
+
+        parsed = parser(str(tmpdir))
+        foo_item = self.Item('file://' + str(foo_file), foo_file.relto(tmpdir))
+        bar_item = self.Item('file://' + str(bar_dir), bar_dir.relto(tmpdir))
+        assert parsed.parent
+        assert parsed.files == [foo_item]
+        assert parsed.folders == [bar_item]
+
+    def test_root_dir(self, tmpdir, parser):
+        if os.name == 'nt':
+            root_dir = 'C:\\'
+        else:
+            root_dir = '/'
+        parsed = parser(root_dir)
+        assert not parsed.parent
+
+    def test_oserror(self, mocker):
+        m = mocker.patch('qutebrowser.browser.network.filescheme.os.listdir')
+        m.side_effect = OSError('Error message')
+        html = filescheme.dirbrowser_html('')
+        soup = bs4.BeautifulSoup(html, 'html.parser')
+        print(soup.prettify())
+        error_title = soup('p', id='errorTitleText')[0].string
+        error_msg = soup('p', id='errorMessageText')[0].string
+        assert error_title == 'Unable to load page'
+        assert error_msg == 'Error message'
+
+
+class TestFileSchemeHandler:
+
+    def test_dir(self, tmpdir):
+        url = QUrl.fromLocalFile(str(tmpdir))
+        req = QNetworkRequest(url)
+        handler = filescheme.FileSchemeHandler(win_id=0)
+        reply = handler.createRequest(None, req, None)
+        assert reply.readAll() == filescheme.dirbrowser_html(str(tmpdir))
+
+    def test_file(self, tmpdir):
+        filename = tmpdir / 'foo'
+        filename.ensure()
+        url = QUrl.fromLocalFile(str(filename))
+        req = QNetworkRequest(url)
+        handler = filescheme.FileSchemeHandler(win_id=0)
+        reply = handler.createRequest(None, req, None)
+        assert reply is None