diff --git a/swh/web/tests/browse/views/test_content.py b/swh/web/tests/browse/views/test_content.py
index 435c64f9..9b599de7 100644
--- a/swh/web/tests/browse/views/test_content.py
+++ b/swh/web/tests/browse/views/test_content.py
@@ -1,362 +1,363 @@
 # Copyright (C) 2017-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from unittest.mock import patch
 
 from django.utils.html import escape
 
 from hypothesis import given
 
 from swh.web.browse.utils import (
     get_mimetype_and_encoding_for_content, prepare_content_for_display,
     _reencode_content
 )
 from swh.web.common.exc import NotFoundExc
 from swh.web.common.utils import reverse, get_swh_persistent_id
 from swh.web.common.utils import gen_path_info
 from swh.web.tests.strategies import (
     content, content_text_non_utf8, content_text_no_highlight,
     content_image_type, content_text, invalid_sha1, unknown_content
 )
 from swh.web.tests.testcase import WebTestCase
 
 
 class SwhBrowseContentTest(WebTestCase):
 
     @given(content())
     def test_content_view_text(self, content):
 
         sha1_git = content['sha1_git']
 
         url = reverse('browse-content',
                       url_args={'query_string': content['sha1']},
                       query_params={'path': content['path']})
 
         url_raw = reverse('browse-content-raw',
                           url_args={'query_string': content['sha1']})
 
         resp = self.client.get(url)
 
         content_display = self._process_content_for_display(content)
         mimetype = content_display['mimetype']
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('browse/content.html')
 
         if mimetype.startswith('text/'):
             self.assertContains(resp, '<code class="%s">' %
                                       content_display['language'])
             self.assertContains(resp, escape(content_display['content_data']))
         self.assertContains(resp, url_raw)
 
         swh_cnt_id = get_swh_persistent_id('content', sha1_git)
         swh_cnt_id_url = reverse('browse-swh-id',
                                  url_args={'swh_id': swh_cnt_id})
         self.assertContains(resp, swh_cnt_id)
         self.assertContains(resp, swh_cnt_id_url)
 
     @given(content_text_no_highlight())
     def test_content_view_text_no_highlight(self, content):
 
         sha1_git = content['sha1_git']
 
         url = reverse('browse-content',
                       url_args={'query_string': content['sha1']})
 
         url_raw = reverse('browse-content-raw',
                           url_args={'query_string': content['sha1']})
 
         resp = self.client.get(url)
 
         content_display = self._process_content_for_display(content)
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('browse/content.html')
 
         self.assertContains(resp, '<code class="nohighlight">')
         self.assertContains(resp, escape(content_display['content_data'])) # noqa
         self.assertContains(resp, url_raw)
 
         swh_cnt_id = get_swh_persistent_id('content', sha1_git)
         swh_cnt_id_url = reverse('browse-swh-id',
                                  url_args={'swh_id': swh_cnt_id})
 
         self.assertContains(resp, swh_cnt_id)
         self.assertContains(resp, swh_cnt_id_url)
 
     @given(content_text_non_utf8())
     def test_content_view_no_utf8_text(self, content):
 
         sha1_git = content['sha1_git']
 
         url = reverse('browse-content',
                       url_args={'query_string': content['sha1']})
 
         resp = self.client.get(url)
 
         content_display = self._process_content_for_display(content)
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('browse/content.html')
         swh_cnt_id = get_swh_persistent_id('content', sha1_git)
         swh_cnt_id_url = reverse('browse-swh-id',
                                  url_args={'swh_id': swh_cnt_id})
         self.assertContains(resp, swh_cnt_id_url)
         self.assertContains(resp, escape(content_display['content_data']))
 
     @given(content_image_type())
     def test_content_view_image(self, content):
 
         url = reverse('browse-content',
                       url_args={'query_string': content['sha1']})
 
         url_raw = reverse('browse-content-raw',
                           url_args={'query_string': content['sha1']})
 
         resp = self.client.get(url)
 
         content_display = self._process_content_for_display(content)
         mimetype = content_display['mimetype']
         content_data = content_display['content_data']
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('browse/content.html')
 
         self.assertContains(resp, '<img src="data:%s;base64,%s"/>'
                                   % (mimetype, content_data.decode('utf-8')))
         self.assertContains(resp, url_raw)
 
     @given(content())
     def test_content_view_with_path(self, content):
 
         path = content['path']
 
         url = reverse('browse-content',
                       url_args={'query_string': content['sha1']},
                       query_params={'path': path})
 
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('browse/content.html')
 
         self.assertContains(resp, '<nav class="bread-crumbs')
 
         content_display = self._process_content_for_display(content)
         mimetype = content_display['mimetype']
 
         if mimetype.startswith('text/'):
             hljs_language = content['hljs_language']
             self.assertContains(resp, '<code class="%s">' % hljs_language)
             self.assertContains(resp, escape(content_display['content_data']))
 
         split_path = path.split('/')
 
         root_dir_sha1 = split_path[0]
         filename = split_path[-1]
         path = path.replace(root_dir_sha1 + '/', '').replace(filename, '')
 
         path_info = gen_path_info(path)
 
         root_dir_url = reverse('browse-directory',
                                url_args={'sha1_git': root_dir_sha1})
 
         self.assertContains(resp, '<li class="swh-path">',
                             count=len(path_info)+1)
 
         self.assertContains(resp, '<a href="' + root_dir_url + '">' +
                             root_dir_sha1[:7] + '</a>')
 
         for p in path_info:
             dir_url = reverse('browse-directory',
                               url_args={'sha1_git': root_dir_sha1,
                                         'path': p['path']})
             self.assertContains(resp, '<a href="' + dir_url + '">' +
                                 p['name'] + '</a>')
 
         self.assertContains(resp, '<li>' + filename + '</li>')
 
         url_raw = reverse('browse-content-raw',
                           url_args={'query_string': content['sha1']},
                           query_params={'filename': filename})
         self.assertContains(resp, url_raw)
 
         url = reverse('browse-content',
                       url_args={'query_string': content['sha1']},
                       query_params={'path': filename})
 
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('browse/content.html')
 
         self.assertNotContains(resp, '<nav class="bread-crumbs')
 
     @given(content_text())
     def test_content_raw_text(self, content):
 
         url = reverse('browse-content-raw',
                       url_args={'query_string': content['sha1']})
 
         resp = self.client.get(url)
 
         content_data = self.content_get(content['sha1'])['data']
 
         self.assertEqual(resp.status_code, 200)
         self.assertEqual(resp['Content-Type'], 'text/plain')
         self.assertEqual(resp['Content-disposition'],
                          'filename=%s_%s' % ('sha1', content['sha1']))
         self.assertEqual(resp.content, content_data)
 
         filename = content['path'].split('/')[-1]
 
         url = reverse('browse-content-raw',
                       url_args={'query_string': content['sha1']}, # noqa
                       query_params={'filename': filename})
 
         resp = self.client.get(url)
 
         self.assertEqual(resp.status_code, 200)
         self.assertEqual(resp['Content-Type'], 'text/plain')
         self.assertEqual(resp['Content-disposition'],
                          'filename=%s' % filename)
         self.assertEqual(resp.content, content_data)
 
     @given(content_text_non_utf8())
     def test_content_raw_no_utf8_text(self, content):
 
         url = reverse('browse-content-raw',
                       url_args={'query_string': content['sha1']})
 
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 200)
         _, encoding = get_mimetype_and_encoding_for_content(resp.content)
         self.assertEqual(encoding, content['encoding'])
 
     @given(content_image_type())
     def test_content_raw_bin(self, content):
 
         url = reverse('browse-content-raw',
                       url_args={'query_string': content['sha1']})
 
         resp = self.client.get(url)
 
         filename = content['path'].split('/')[-1]
         content_data = self.content_get(content['sha1'])['data']
 
         self.assertEqual(resp.status_code, 200)
         self.assertEqual(resp['Content-Type'], 'application/octet-stream')
         self.assertEqual(resp['Content-disposition'],
                          'attachment; filename=%s_%s' %
                          ('sha1', content['sha1']))
         self.assertEqual(resp.content, content_data)
 
         url = reverse('browse-content-raw',
                       url_args={'query_string': content['sha1']},
                       query_params={'filename': filename})
 
         resp = self.client.get(url)
 
         self.assertEqual(resp.status_code, 200)
         self.assertEqual(resp['Content-Type'], 'application/octet-stream')
         self.assertEqual(resp['Content-disposition'],
                          'attachment; filename=%s' % filename)
         self.assertEqual(resp.content, content_data)
 
     @given(invalid_sha1(), unknown_content())
     def test_content_request_errors(self, invalid_sha1, unknown_content):
 
         url = reverse('browse-content',
                       url_args={'query_string': invalid_sha1})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 400)
         self.assertTemplateUsed('error.html')
 
         url = reverse('browse-content',
                       url_args={'query_string': unknown_content['sha1']})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
 
     @patch('swh.web.browse.utils.service')
     @given(content())
     def test_content_bytes_missing(self, mock_service, content):
 
         content_data = self.content_get_metadata(content['sha1'])
         content_data['data'] = None
 
         mock_service.lookup_content.return_value = content_data
+        mock_service.lookup_content_filetype.side_effect = Exception()
         mock_service.lookup_content_raw.side_effect = NotFoundExc(
             'Content bytes not available!')
 
         url = reverse('browse-content',
                       url_args={'query_string': content['sha1']})
 
         resp = self.client.get(url)
 
         self.assertEqual(resp.status_code, 404)
         self.assertTemplateUsed('browse/content.html')
 
     @patch('swh.web.browse.views.content.request_content')
     def test_content_too_large(self, mock_request_content):
         stub_content_too_large_data = {
             'checksums': {
                 'sha1': '8624bcdae55baeef00cd11d5dfcfa60f68710a02',
                 'sha1_git': '94a9ed024d3859793618152ea559a168bbcbb5e2',
                 'sha256': ('8ceb4b9ee5adedde47b31e975c1d90c73ad27b6b16'
                            '5a1dcd80c7c545eb65b903'),
                 'blake2s256': ('38702b7168c7785bfe748b51b45d9856070ba90'
                                'f9dc6d90f2ea75d4356411ffe')
             },
             'length': 30000000,
             'raw_data': None,
             'mimetype': 'text/plain',
             'encoding': 'us-ascii',
             'language': 'not detected',
             'licenses': 'GPL',
             'error_code': 200,
             'error_message': '',
             'error_description': ''
         }
 
         content_sha1 = stub_content_too_large_data['checksums']['sha1']
 
         mock_request_content.return_value = stub_content_too_large_data
 
         url = reverse('browse-content',
                       url_args={'query_string': content_sha1})
 
         url_raw = reverse('browse-content-raw',
                           url_args={'query_string': content_sha1})
 
         resp = self.client.get(url)
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('browse/content.html')
 
         self.assertContains(resp, 'Content is too large to be displayed')
         self.assertContains(resp, url_raw)
 
     def _process_content_for_display(self, content):
         content_data = self.content_get(content['sha1'])
 
         mime_type, encoding = get_mimetype_and_encoding_for_content(
             content_data['data'])
 
         mime_type, content_data = _reencode_content(mime_type, encoding,
                                                     content_data['data'])
 
         return prepare_content_for_display(content_data, mime_type,
                                            content['path'])
 
     @given(content())
     def test_content_uppercase(self, content):
         url = reverse('browse-content-uppercase-checksum',
                       url_args={'query_string': content['sha1'].upper()})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 302)
 
         redirect_url = reverse('browse-content',
                                url_args={'query_string': content['sha1']})
 
         self.assertEqual(resp['location'], redirect_url)
diff --git a/swh/web/tests/browse/views/test_origin.py b/swh/web/tests/browse/views/test_origin.py
index a4b65b95..78df2e3b 100644
--- a/swh/web/tests/browse/views/test_origin.py
+++ b/swh/web/tests/browse/views/test_origin.py
@@ -1,896 +1,901 @@
 # Copyright (C) 2017-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import random
 
 from unittest.mock import patch
 
 from django.utils.html import escape
 
 from hypothesis import given
 
 from swh.model.hashutil import hash_to_bytes
 from swh.web.browse.utils import process_snapshot_branches
 from swh.web.common.exc import NotFoundExc
 from swh.web.common.utils import (
     reverse, gen_path_info, format_utc_iso_date,
     parse_timestamp, get_swh_persistent_id
 )
 from swh.web.tests.data import get_content
 from swh.web.tests.strategies import (
     origin, origin_with_multiple_visits, new_origin,
     new_snapshot, visit_dates, revisions
 )
 from swh.web.tests.testcase import WebTestCase
 
 
 class SwhBrowseOriginTest(WebTestCase):
 
     @given(origin_with_multiple_visits())
     def test_origin_visits_browse(self, origin):
 
         url = reverse('browse-origin-visits',
                       url_args={'origin_type': origin['type'],
                                 'origin_url': origin['url']})
         resp = self.client.get(url)
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('origin-visits.html')
 
         url = reverse('browse-origin-visits',
                       url_args={'origin_url': origin['url']})
         resp = self.client.get(url)
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('origin-visits.html')
 
         visits = self.origin_visit_get(origin['id'])
 
         for v in visits:
             vdate = format_utc_iso_date(v['date'], '%Y-%m-%dT%H:%M:%SZ')
             browse_dir_url = reverse('browse-origin-directory',
                                      url_args={'origin_url': origin['url'],
                                                'timestamp': vdate})
             self.assertContains(resp, browse_dir_url)
 
     def origin_content_view_helper(self, origin_info, origin_visits,
                                    origin_branches, origin_releases,
                                    root_dir_sha1, content,
                                    visit_id=None, timestamp=None):
 
         content_path = '/'.join(content['path'].split('/')[1:])
 
         url_args = {'origin_type': origin_info['type'],
                     'origin_url': origin_info['url'],
                     'path': content_path}
 
         if not visit_id:
             visit_id = origin_visits[-1]['visit']
 
         query_params = {}
 
         if timestamp:
             url_args['timestamp'] = timestamp
 
         if visit_id:
             query_params['visit_id'] = visit_id
 
         url = reverse('browse-origin-content',
                       url_args=url_args,
                       query_params=query_params)
 
         resp = self.client.get(url)
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('content.html')
 
         self.assertContains(resp, '<code class="%s">' %
                                   content['hljs_language'])
         self.assertContains(resp, escape(content['data']))
 
         split_path = content_path.split('/')
 
         filename = split_path[-1]
         path = content_path.replace(filename, '')[:-1]
 
         path_info = gen_path_info(path)
 
         del url_args['path']
 
         if timestamp:
             url_args['timestamp'] = \
                 format_utc_iso_date(parse_timestamp(timestamp).isoformat(),
                                     '%Y-%m-%dT%H:%M:%S')
 
         root_dir_url = reverse('browse-origin-directory',
                                url_args=url_args,
                                query_params=query_params)
 
         self.assertContains(resp, '<li class="swh-path">',
                             count=len(path_info)+1)
 
         self.assertContains(resp, '<a href="%s">%s</a>' %
                             (root_dir_url, root_dir_sha1[:7]))
 
         for p in path_info:
             url_args['path'] = p['path']
             dir_url = reverse('browse-origin-directory',
                               url_args=url_args,
                               query_params=query_params)
             self.assertContains(resp, '<a href="%s">%s</a>' %
                                 (dir_url, p['name']))
 
         self.assertContains(resp, '<li>%s</li>' % filename)
 
         query_string = 'sha1_git:' + content['sha1_git']
 
         url_raw = reverse('browse-content-raw',
                           url_args={'query_string': query_string},
                           query_params={'filename': filename})
         self.assertContains(resp, url_raw)
 
         if 'args' in url_args:
             del url_args['path']
 
         origin_branches_url = reverse('browse-origin-branches',
                                       url_args=url_args,
                                       query_params=query_params)
 
         self.assertContains(resp, '<a href="%s">Branches (%s)</a>' %
                                   (origin_branches_url, len(origin_branches)))
 
         origin_releases_url = reverse('browse-origin-releases',
                                       url_args=url_args,
                                       query_params=query_params)
 
         self.assertContains(resp, '<a href="%s">Releases (%s)</a>' %
                                   (origin_releases_url, len(origin_releases)))
 
         self.assertContains(resp, '<li class="swh-branch">',
                             count=len(origin_branches))
 
         url_args['path'] = content_path
 
         for branch in origin_branches:
             query_params['branch'] = branch['name']
             root_dir_branch_url = reverse('browse-origin-content',
                                           url_args=url_args,
                                           query_params=query_params)
 
         self.assertContains(resp, '<a href="%s">' % root_dir_branch_url)
 
         self.assertContains(resp, '<li class="swh-release">',
                             count=len(origin_releases))
 
         query_params['branch'] = None
         for release in origin_releases:
             query_params['release'] = release['name']
             root_dir_release_url = reverse('browse-origin-content',
                                            url_args=url_args,
                                            query_params=query_params)
 
             self.assertContains(resp, '<a href="%s">' % root_dir_release_url)
 
         del url_args['origin_type']
 
         url = reverse('browse-origin-content',
                       url_args=url_args,
                       query_params=query_params)
 
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('content.html')
 
         swh_cnt_id = get_swh_persistent_id('content', content['sha1_git'])
         swh_cnt_id_url = reverse('browse-swh-id',
                                  url_args={'swh_id': swh_cnt_id})
         self.assertContains(resp, swh_cnt_id)
         self.assertContains(resp, swh_cnt_id_url)
 
         self.assertContains(resp, 'swh-take-new-snapshot')
 
     @given(origin_with_multiple_visits())
     def test_origin_content_view(self, origin):
 
         origin_visits = self.origin_visit_get(origin['id'])
 
         def _get_test_data(visit_idx):
             snapshot = self.snapshot_get(origin_visits[visit_idx]['snapshot'])
             head_rev_id = snapshot['branches']['HEAD']['target']
             head_rev = self.revision_get(head_rev_id)
             dir_content = self.directory_ls(head_rev['directory'])
             dir_files = [e for e in dir_content if e['type'] == 'file']
             dir_file = random.choice(dir_files)
             branches, releases = process_snapshot_branches(snapshot)
             return {
                 'branches': branches,
                 'releases': releases,
                 'root_dir_sha1': head_rev['directory'],
                 'content': get_content(dir_file['checksums']['sha1']),
                 'visit': origin_visits[visit_idx]
             }
 
         test_data = _get_test_data(-1)
 
         self.origin_content_view_helper(origin,
                                         origin_visits,
                                         test_data['branches'],
                                         test_data['releases'],
                                         test_data['root_dir_sha1'],
                                         test_data['content'])
 
         self.origin_content_view_helper(origin,
                                         origin_visits,
                                         test_data['branches'],
                                         test_data['releases'],
                                         test_data['root_dir_sha1'],
                                         test_data['content'],
                                         timestamp=test_data['visit']['date'])
 
         visit_unix_ts = parse_timestamp(test_data['visit']['date']).timestamp()
         visit_unix_ts = int(visit_unix_ts)
 
         self.origin_content_view_helper(origin,
                                         origin_visits,
                                         test_data['branches'],
                                         test_data['releases'],
                                         test_data['root_dir_sha1'],
                                         test_data['content'],
                                         timestamp=visit_unix_ts)
 
         test_data = _get_test_data(0)
 
         self.origin_content_view_helper(origin,
                                         origin_visits,
                                         test_data['branches'],
                                         test_data['releases'],
                                         test_data['root_dir_sha1'],
                                         test_data['content'],
                                         visit_id=test_data['visit']['visit'])
 
     def origin_directory_view_helper(self, origin_info, origin_visits,
                                      origin_branches, origin_releases,
                                      root_directory_sha1, directory_entries,
                                      visit_id=None, timestamp=None, path=None):
 
         dirs = [e for e in directory_entries
                 if e['type'] in ('dir', 'rev')]
         files = [e for e in directory_entries
                  if e['type'] == 'file']
 
         if not visit_id:
             visit_id = origin_visits[-1]['visit']
 
         url_args = {'origin_url': origin_info['url']}
 
         query_params = {}
 
         if timestamp:
             url_args['timestamp'] = timestamp
         else:
             query_params['visit_id'] = visit_id
 
         if path:
             url_args['path'] = path
 
         url = reverse('browse-origin-directory',
                       url_args=url_args,
                       query_params=query_params)
 
         resp = self.client.get(url)
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('directory.html')
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('directory.html')
 
         self.assertContains(resp, '<td class="swh-directory">',
                             count=len(dirs))
         self.assertContains(resp, '<td class="swh-content">',
                             count=len(files))
 
         if timestamp:
             url_args['timestamp'] = \
                 format_utc_iso_date(parse_timestamp(timestamp).isoformat(),
                                     '%Y-%m-%dT%H:%M:%S')
 
         for d in dirs:
             if d['type'] == 'rev':
                 dir_url = reverse('browse-revision',
                                   url_args={'sha1_git': d['target']})
             else:
                 dir_path = d['name']
                 if path:
                     dir_path = "%s/%s" % (path, d['name'])
                 dir_url_args = dict(url_args)
                 dir_url_args['path'] = dir_path
                 dir_url = reverse('browse-origin-directory',
                                   url_args=dir_url_args,
                                   query_params=query_params)
             self.assertContains(resp, dir_url)
 
         for f in files:
             file_path = f['name']
             if path:
                 file_path = "%s/%s" % (path, f['name'])
             file_url_args = dict(url_args)
             file_url_args['path'] = file_path
             file_url = reverse('browse-origin-content',
                                url_args=file_url_args,
                                query_params=query_params)
             self.assertContains(resp, file_url)
 
         if 'path' in url_args:
             del url_args['path']
 
         root_dir_branch_url = \
             reverse('browse-origin-directory',
                     url_args=url_args,
                     query_params=query_params)
 
         nb_bc_paths = 1
         if path:
             nb_bc_paths = len(path.split('/')) + 1
 
         self.assertContains(resp, '<li class="swh-path">', count=nb_bc_paths)
         self.assertContains(resp, '<a href="%s">%s</a>' %
                                   (root_dir_branch_url,
                                    root_directory_sha1[:7]))
 
         origin_branches_url = reverse('browse-origin-branches',
                                       url_args=url_args,
                                       query_params=query_params)
 
         self.assertContains(resp, '<a href="%s">Branches (%s)</a>' %
                                   (origin_branches_url, len(origin_branches)))
 
         origin_releases_url = reverse('browse-origin-releases',
                                       url_args=url_args,
                                       query_params=query_params)
 
         nb_releases = len(origin_releases)
         if nb_releases > 0:
             self.assertContains(resp, '<a href="%s">Releases (%s)</a>' %
                                       (origin_releases_url, nb_releases))
 
         if path:
             url_args['path'] = path
 
         self.assertContains(resp, '<li class="swh-branch">',
                             count=len(origin_branches))
 
         for branch in origin_branches:
             query_params['branch'] = branch['name']
             root_dir_branch_url = \
                 reverse('browse-origin-directory',
                         url_args=url_args,
                         query_params=query_params)
 
             self.assertContains(resp, '<a href="%s">' % root_dir_branch_url)
 
         self.assertContains(resp, '<li class="swh-release">',
                             count=len(origin_releases))
 
         query_params['branch'] = None
         for release in origin_releases:
             query_params['release'] = release['name']
             root_dir_release_url = \
                 reverse('browse-origin-directory',
                         url_args=url_args,
                         query_params=query_params)
 
             self.assertContains(resp, '<a href="%s">' % root_dir_release_url)
 
         self.assertContains(resp, 'vault-cook-directory')
         self.assertContains(resp, 'vault-cook-revision')
 
         swh_dir_id = get_swh_persistent_id('directory', directory_entries[0]['dir_id']) # noqa
         swh_dir_id_url = reverse('browse-swh-id',
                                  url_args={'swh_id': swh_dir_id})
         self.assertContains(resp, swh_dir_id)
         self.assertContains(resp, swh_dir_id_url)
 
         self.assertContains(resp, 'swh-take-new-snapshot')
 
     @given(origin())
     def test_origin_root_directory_view(self, origin):
 
         origin_visits = self.origin_visit_get(origin['id'])
 
         visit = origin_visits[-1]
         snapshot = self.snapshot_get(visit['snapshot'])
         head_rev_id = snapshot['branches']['HEAD']['target']
         head_rev = self.revision_get(head_rev_id)
         root_dir_sha1 = head_rev['directory']
         dir_content = self.directory_ls(root_dir_sha1)
         branches, releases = process_snapshot_branches(snapshot)
         visit_unix_ts = parse_timestamp(visit['date']).timestamp()
         visit_unix_ts = int(visit_unix_ts)
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           dir_content)
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           dir_content,
                                           visit_id=visit['visit'])
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           dir_content,
                                           timestamp=visit_unix_ts)
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           dir_content,
                                           timestamp=visit['date'])
 
         origin = dict(origin)
         del origin['type']
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           dir_content)
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           dir_content,
                                           visit_id=visit['visit'])
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           dir_content,
                                           timestamp=visit_unix_ts)
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           dir_content,
                                           timestamp=visit['date'])
 
     @given(origin())
     def test_origin_sub_directory_view(self, origin):
 
         origin_visits = self.origin_visit_get(origin['id'])
 
         visit = origin_visits[-1]
         snapshot = self.snapshot_get(visit['snapshot'])
         head_rev_id = snapshot['branches']['HEAD']['target']
         head_rev = self.revision_get(head_rev_id)
         root_dir_sha1 = head_rev['directory']
         subdirs = [e for e in self.directory_ls(root_dir_sha1)
                    if e['type'] == 'dir']
         branches, releases = process_snapshot_branches(snapshot)
         visit_unix_ts = parse_timestamp(visit['date']).timestamp()
         visit_unix_ts = int(visit_unix_ts)
 
         if len(subdirs) == 0:
             return
 
         subdir = random.choice(subdirs)
         subdir_content = self.directory_ls(subdir['target'])
         subdir_path = subdir['name']
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           subdir_content,
                                           path=subdir_path)
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           subdir_content,
                                           path=subdir_path,
                                           visit_id=visit['visit'])
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           subdir_content,
                                           path=subdir_path,
                                           timestamp=visit_unix_ts)
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           subdir_content,
                                           path=subdir_path,
                                           timestamp=visit['date'])
 
         origin = dict(origin)
         del origin['type']
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           subdir_content,
                                           path=subdir_path)
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           subdir_content,
                                           path=subdir_path,
                                           visit_id=visit['visit'])
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           subdir_content,
                                           path=subdir_path,
                                           timestamp=visit_unix_ts)
 
         self.origin_directory_view_helper(origin, origin_visits,
                                           branches,
                                           releases,
                                           root_dir_sha1,
                                           subdir_content,
                                           path=subdir_path,
                                           timestamp=visit['date'])
 
     def origin_branches_helper(self, origin_info, origin_snapshot):
         url_args = {'origin_type': origin_info['type'],
                     'origin_url': origin_info['url']}
 
         url = reverse('browse-origin-branches',
                       url_args=url_args)
 
         resp = self.client.get(url)
 
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('branches.html')
 
         origin_branches = origin_snapshot[0]
         origin_releases = origin_snapshot[1]
 
         origin_branches_url = reverse('browse-origin-branches',
                                       url_args=url_args)
 
         self.assertContains(resp, '<a href="%s">Branches (%s)</a>' %
                                   (origin_branches_url, len(origin_branches)))
 
         origin_releases_url = reverse('browse-origin-releases',
                                       url_args=url_args)
 
         nb_releases = len(origin_releases)
         if nb_releases > 0:
             self.assertContains(resp, '<a href="%s">Releases (%s)</a>' %
                                       (origin_releases_url, nb_releases))
 
         self.assertContains(resp, '<tr class="swh-branch-entry',
                             count=len(origin_branches))
 
         for branch in origin_branches:
             browse_branch_url = reverse(
                 'browse-origin-directory',
                 url_args={'origin_type': origin_info['type'],
                           'origin_url': origin_info['url']},
                 query_params={'branch': branch['name']})
             self.assertContains(resp, '<a href="%s">' %
                                       escape(browse_branch_url))
 
             browse_revision_url = reverse(
                 'browse-revision',
                 url_args={'sha1_git': branch['revision']},
                 query_params={'origin_type': origin_info['type'],
                               'origin': origin_info['url']})
             self.assertContains(resp, '<a href="%s">' %
                                       escape(browse_revision_url))
 
     @given(origin())
     def test_origin_branches(self, origin):
 
         origin_visits = self.origin_visit_get(origin['id'])
 
         visit = origin_visits[-1]
         snapshot = self.snapshot_get(visit['snapshot'])
         snapshot_content = process_snapshot_branches(snapshot)
 
         self.origin_branches_helper(origin, snapshot_content)
 
         origin = dict(origin)
         origin['type'] = None
 
         self.origin_branches_helper(origin, snapshot_content)
 
     def origin_releases_helper(self, origin_info, origin_snapshot):
         url_args = {'origin_type': origin_info['type'],
                     'origin_url': origin_info['url']}
 
         url = reverse('browse-origin-releases',
                       url_args=url_args)
 
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('releases.html')
 
         origin_branches = origin_snapshot[0]
         origin_releases = origin_snapshot[1]
 
         origin_branches_url = reverse('browse-origin-branches',
                                       url_args=url_args)
 
         self.assertContains(resp, '<a href="%s">Branches (%s)</a>' %
                                   (origin_branches_url, len(origin_branches)))
 
         origin_releases_url = reverse('browse-origin-releases',
                                       url_args=url_args)
 
         nb_releases = len(origin_releases)
         if nb_releases > 0:
             self.assertContains(resp, '<a href="%s">Releases (%s)</a>' %
                                       (origin_releases_url, nb_releases))
 
         self.assertContains(resp, '<tr class="swh-release-entry',
                             count=nb_releases)
 
         for release in origin_releases:
             browse_release_url = reverse(
                 'browse-release',
                 url_args={'sha1_git': release['id']},
                 query_params={'origin': origin_info['url']})
             browse_revision_url = reverse(
                 'browse-revision',
                 url_args={'sha1_git': release['target']},
                 query_params={'origin': origin_info['url']})
 
             self.assertContains(resp, '<a href="%s">' %
                                       escape(browse_release_url))
             self.assertContains(resp, '<a href="%s">' %
                                       escape(browse_revision_url))
 
     @given(origin())
     def test_origin_releases(self, origin):
 
         origin_visits = self.origin_visit_get(origin['id'])
 
         visit = origin_visits[-1]
         snapshot = self.snapshot_get(visit['snapshot'])
         snapshot_content = process_snapshot_branches(snapshot)
 
         self.origin_releases_helper(origin, snapshot_content)
 
         origin = dict(origin)
         origin['type'] = None
 
         self.origin_releases_helper(origin, snapshot_content)
 
     @given(new_origin(), new_snapshot(min_size=4, max_size=4), visit_dates(),
            revisions(min_size=3, max_size=3))
     def test_origin_snapshot_null_branch(self, new_origin, new_snapshot,
                                          visit_dates, revisions):
         snp_dict = new_snapshot.to_dict()
         new_origin = self.storage.origin_add([new_origin])[0]
         for i, branch in enumerate(snp_dict['branches'].keys()):
             if i == 0:
                 snp_dict['branches'][branch] = None
             else:
                 snp_dict['branches'][branch]['target_type'] = 'revision'
                 snp_dict['branches'][branch]['target'] = hash_to_bytes(
                     revisions[i-1])
         self.storage.snapshot_add([snp_dict])
         visit = self.storage.origin_visit_add(new_origin['id'], visit_dates[0])
         self.storage.origin_visit_update(new_origin['id'], visit['visit'],
                                          status='partial',
                                          snapshot=snp_dict['id'])
 
         url = reverse('browse-origin-directory',
                       url_args={'origin_url': new_origin['url']})
         rv = self.client.get(url)
         self.assertEqual(rv.status_code, 200)
 
     @patch('swh.web.browse.views.utils.snapshot_context.request_content')
     @patch('swh.web.common.origin_visits.get_origin_visits')
     @patch('swh.web.browse.utils.get_origin_visit_snapshot')
     @patch('swh.web.browse.utils.service')
     @patch('swh.web.browse.views.origin.service')
     @patch('swh.web.browse.views.utils.snapshot_context.service')
     @patch('swh.web.browse.views.origin.get_origin_info')
     def test_origin_request_errors(self, mock_get_origin_info,
                                    mock_snapshot_service,
                                    mock_origin_service,
                                    mock_utils_service,
                                    mock_get_origin_visit_snapshot,
                                    mock_get_origin_visits,
                                    mock_request_content):
 
         mock_get_origin_info.side_effect = \
             NotFoundExc('origin not found')
         url = reverse('browse-origin-visits',
                       url_args={'origin_type': 'foo',
                                 'origin_url': 'bar'})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, 'origin not found', status_code=404)
 
         mock_utils_service.lookup_origin.side_effect = None
         mock_utils_service.lookup_origin.return_value = {'type': 'foo',
                                                          'url': 'bar',
                                                          'id': 457}
         mock_get_origin_visits.return_value = []
         url = reverse('browse-origin-directory',
                       url_args={'origin_type': 'foo',
                                 'origin_url': 'bar'})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, "No visit", status_code=404)
 
         mock_get_origin_visits.return_value = [{'visit': 1}]
         mock_get_origin_visit_snapshot.side_effect = \
             NotFoundExc('visit not found')
         url = reverse('browse-origin-directory',
                       url_args={'origin_type': 'foo',
                                 'origin_url': 'bar'},
                       query_params={'visit_id': 2})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertRegex(resp.content.decode('utf-8'), 'Visit.*not found')
 
         mock_get_origin_visits.return_value = [{
             'date': '2015-09-26T09:30:52.373449+00:00',
             'metadata': {},
             'origin': 457,
             'snapshot': 'bdaf9ac436488a8c6cda927a0f44e172934d3f65',
             'status': 'full',
             'visit': 1
         }]
         mock_get_origin_visit_snapshot.side_effect = None
         mock_get_origin_visit_snapshot.return_value = (
             [{'directory': 'ae59ceecf46367e8e4ad800e231fc76adc3afffb',
               'name': 'HEAD',
               'revision': '7bc08e1aa0b08cb23e18715a32aa38517ad34672',
               'date': '04 May 2017, 13:27 UTC',
               'message': ''}],
             []
         )
         mock_utils_service.lookup_snapshot_size.return_value = {
             'revision': 1,
             'release': 0
         }
         mock_utils_service.lookup_directory.side_effect = \
             NotFoundExc('Directory not found')
         url = reverse('browse-origin-directory',
                       url_args={'origin_type': 'foo',
                                 'origin_url': 'bar'})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, 'Directory not found', status_code=404)
 
         with patch('swh.web.browse.views.utils.snapshot_context.'
                    'get_snapshot_context') as mock_get_snapshot_context:
             mock_get_snapshot_context.side_effect = \
                 NotFoundExc('Snapshot not found')
             url = reverse('browse-origin-directory',
                           url_args={'origin_type': 'foo',
                                     'origin_url': 'bar'})
             resp = self.client.get(url)
             self.assertEqual(resp.status_code, 404)
             self.assertTemplateUsed('error.html')
             self.assertContains(resp, 'Snapshot not found', status_code=404)
 
         mock_origin_service.lookup_origin.side_effect = None
         mock_origin_service.lookup_origin.return_value = {'type': 'foo',
                                                           'url': 'bar',
                                                           'id': 457}
         mock_get_origin_visits.return_value = []
         url = reverse('browse-origin-content',
                       url_args={'origin_type': 'foo',
                                 'origin_url': 'bar',
                                 'path': 'foo'})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, "No visit", status_code=404)
 
         mock_get_origin_visits.return_value = [{'visit': 1}]
         mock_get_origin_visit_snapshot.side_effect = \
             NotFoundExc('visit not found')
         url = reverse('browse-origin-content',
                       url_args={'origin_type': 'foo',
                                 'origin_url': 'bar',
                                 'path': 'foo'},
                       query_params={'visit_id': 2})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertRegex(resp.content.decode('utf-8'), 'Visit.*not found')
 
         mock_get_origin_visits.return_value = [{
             'date': '2015-09-26T09:30:52.373449+00:00',
             'metadata': {},
             'origin': 457,
             'snapshot': 'bdaf9ac436488a8c6cda927a0f44e172934d3f65',
             'status': 'full',
             'visit': 1
         }]
         mock_get_origin_visit_snapshot.side_effect = None
         mock_get_origin_visit_snapshot.return_value = ([], [])
         url = reverse('browse-origin-content',
                       url_args={'origin_type': 'foo',
                                 'origin_url': 'bar',
                                 'path': 'baz'})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertRegex(resp.content.decode('utf-8'),
                          'Origin.*has an empty list of branches')
 
         mock_get_origin_visit_snapshot.return_value = (
             [{'directory': 'ae59ceecf46367e8e4ad800e231fc76adc3afffb',
               'name': 'HEAD',
               'revision': '7bc08e1aa0b08cb23e18715a32aa38517ad34672',
               'date': '04 May 2017, 13:27 UTC',
               'message': ''}],
             []
         )
         mock_snapshot_service.lookup_directory_with_path.return_value = \
             {'target': '5ecd9f37b7a2d2e9980d201acd6286116f2ba1f1'}
         mock_request_content.side_effect = \
             NotFoundExc('Content not found')
         url = reverse('browse-origin-content',
                       url_args={'origin_type': 'foo',
                                 'origin_url': 'bar',
                                 'path': 'baz'})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, 'Content not found', status_code=404)
 
     @patch('swh.web.common.origin_visits.get_origin_visits')
     @patch('swh.web.browse.utils.get_origin_visit_snapshot')
     @patch('swh.web.browse.utils.service')
     def test_origin_empty_snapshot(self, mock_utils_service,
                                    mock_get_origin_visit_snapshot,
                                    mock_get_origin_visits):
 
         mock_get_origin_visits.return_value = [{
             'date': '2015-09-26T09:30:52.373449+00:00',
             'metadata': {},
             'origin': 457,
             'snapshot': 'bdaf9ac436488a8c6cda927a0f44e172934d3f65',
             'status': 'full',
             'visit': 1
         }]
         mock_get_origin_visit_snapshot.return_value = ([], [])
         mock_utils_service.lookup_snapshot_size.return_value = {
             'revision': 0,
             'release': 0
         }
+        mock_utils_service.lookup_origin.return_value = {
+            'id': 457,
+            'type': 'git',
+            'url': 'https://github.com/foo/bar'
+        }
         url = reverse('browse-origin-directory',
                       url_args={'origin_type': 'foo',
                                 'origin_url': 'bar'})
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 200)
         self.assertTemplateUsed('content.html')
         self.assertRegex(resp.content.decode('utf-8'), 'snapshot.*is empty')