diff --git a/swh/web/tests/browse/views/test_content.py b/swh/web/tests/browse/views/test_content.py
index b69f824f..1904a2c6 100644
--- a/swh/web/tests/browse/views/test_content.py
+++ b/swh/web/tests/browse/views/test_content.py
@@ -1,382 +1,382 @@
 # 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 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,
     _re_encode_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.django_asserts import (
     assert_contains, assert_not_contains, assert_template_used
 )
 from swh.web.tests.strategies import (
     content, content_text_non_utf8, content_text_no_highlight,
     content_image_type, content_text, invalid_sha1, unknown_content,
     content_utf8_detected_as_binary
 )
 
 
 @given(content_text())
 def test_content_view_text(client, archive_data, 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 = client.get(url)
 
     content_display = _process_content_for_display(archive_data, content)
     mimetype = content_display['mimetype']
 
     assert resp.status_code == 200
-    assert_template_used('browse/content.html')
+    assert_template_used(resp, 'browse/content.html')
 
     if mimetype.startswith('text/'):
         assert_contains(resp, '<code class="%s">' %
                         content_display['language'])
         assert_contains(resp, escape(content_display['content_data']))
     assert_contains(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})
     assert_contains(resp, swh_cnt_id)
     assert_contains(resp, swh_cnt_id_url)
 
 
 @given(content_text_no_highlight())
 def test_content_view_text_no_highlight(client, archive_data, 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 = client.get(url)
 
     content_display = _process_content_for_display(archive_data, content)
 
     assert resp.status_code == 200
-    assert_template_used('browse/content.html')
+    assert_template_used(resp, 'browse/content.html')
 
     assert_contains(resp, '<code class="nohighlight">')
     assert_contains(resp, escape(content_display['content_data']))
     assert_contains(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})
 
     assert_contains(resp, swh_cnt_id)
     assert_contains(resp, swh_cnt_id_url)
 
 
 @given(content_text_non_utf8())
 def test_content_view_no_utf8_text(client, archive_data, content):
     sha1_git = content['sha1_git']
 
     url = reverse('browse-content',
                   url_args={'query_string': content['sha1']})
 
     resp = client.get(url)
 
     content_display = _process_content_for_display(archive_data, content)
 
     assert resp.status_code == 200
-    assert_template_used('browse/content.html')
+    assert_template_used(resp, '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})
     assert_contains(resp, swh_cnt_id_url)
     assert_contains(resp, escape(content_display['content_data']))
 
 
 @given(content_image_type())
 def test_content_view_image(client, archive_data, content):
     url = reverse('browse-content',
                   url_args={'query_string': content['sha1']})
 
     url_raw = reverse('browse-content-raw',
                       url_args={'query_string': content['sha1']})
 
     resp = client.get(url)
 
     content_display = _process_content_for_display(archive_data, content)
     mimetype = content_display['mimetype']
     content_data = content_display['content_data']
 
     assert resp.status_code == 200
-    assert_template_used('browse/content.html')
+    assert_template_used(resp, 'browse/content.html')
     assert_contains(resp, '<img src="data:%s;base64,%s"/>'
                     % (mimetype, content_data))
     assert_contains(resp, url_raw)
 
 
 @given(content_text())
 def test_content_view_text_with_path(client, archive_data, content):
     path = content['path']
 
     url = reverse('browse-content',
                   url_args={'query_string': content['sha1']},
                   query_params={'path': path})
 
     resp = client.get(url)
     assert resp.status_code == 200
-    assert_template_used('browse/content.html')
+    assert_template_used(resp, 'browse/content.html')
 
     assert_contains(resp, '<nav class="bread-crumbs')
 
     content_display = _process_content_for_display(archive_data, content)
     mimetype = content_display['mimetype']
 
     if mimetype.startswith('text/'):
         hljs_language = content['hljs_language']
         assert_contains(resp, '<code class="%s">' % hljs_language)
         assert_contains(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})
 
     assert_contains(resp, '<li class="swh-path">',
                     count=len(path_info)+1)
 
     assert_contains(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']})
         assert_contains(resp, '<a href="' + dir_url + '">' +
                         p['name'] + '</a>')
 
     assert_contains(resp, '<li>' + filename + '</li>')
 
     url_raw = reverse('browse-content-raw',
                       url_args={'query_string': content['sha1']},
                       query_params={'filename': filename})
     assert_contains(resp, url_raw)
 
     url = reverse('browse-content',
                   url_args={'query_string': content['sha1']},
                   query_params={'path': filename})
 
     resp = client.get(url)
     assert resp.status_code == 200
-    assert_template_used('browse/content.html')
+    assert_template_used(resp, 'browse/content.html')
 
     assert_not_contains(resp, '<nav class="bread-crumbs')
 
     invalid_path = '%s/foo/bar/baz' % root_dir_sha1
     url = reverse('browse-content',
                   url_args={'query_string': content['sha1']},
                   query_params={'path': invalid_path})
     resp = client.get(url)
     assert resp.status_code == 404
 
 
 @given(content_text())
 def test_content_raw_text(client, archive_data, content):
     url = reverse('browse-content-raw',
                   url_args={'query_string': content['sha1']})
 
     resp = client.get(url)
 
     content_data = archive_data.content_get(content['sha1'])['data']
 
     assert resp.status_code == 200
     assert resp['Content-Type'] == 'text/plain'
     assert resp['Content-disposition'] == ('filename=%s_%s' %
                                            ('sha1', content['sha1']))
     assert resp.content == content_data
 
     filename = content['path'].split('/')[-1]
 
     url = reverse('browse-content-raw',
                   url_args={'query_string': content['sha1']},
                   query_params={'filename': filename})
 
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert resp['Content-Type'] == 'text/plain'
     assert resp['Content-disposition'] == 'filename=%s' % filename
     assert resp.content == content_data
 
 
 @given(content_text_non_utf8())
 def test_content_raw_no_utf8_text(client, content):
     url = reverse('browse-content-raw',
                   url_args={'query_string': content['sha1']})
 
     resp = client.get(url)
     assert resp.status_code == 200
     _, encoding = get_mimetype_and_encoding_for_content(resp.content)
     assert encoding == content['encoding']
 
 
 @given(content_image_type())
 def test_content_raw_bin(client, archive_data, content):
     url = reverse('browse-content-raw',
                   url_args={'query_string': content['sha1']})
 
     resp = client.get(url)
 
     filename = content['path'].split('/')[-1]
     content_data = archive_data.content_get(content['sha1'])['data']
 
     assert resp.status_code == 200
     assert resp['Content-Type'] == 'application/octet-stream'
     assert resp['Content-disposition'] == \
         'attachment; filename=%s_%s' % \
         ('sha1', content['sha1'])
     assert resp.content == content_data
 
     url = reverse('browse-content-raw',
                   url_args={'query_string': content['sha1']},
                   query_params={'filename': filename})
 
     resp = client.get(url)
 
     assert resp.status_code == 200
     assert resp['Content-Type'] == 'application/octet-stream'
     assert resp['Content-disposition'] == \
         'attachment; filename=%s' % filename
     assert resp.content == content_data
 
 
 @given(invalid_sha1(), unknown_content())
 def test_content_request_errors(client, invalid_sha1, unknown_content):
     url = reverse('browse-content',
                   url_args={'query_string': invalid_sha1})
     resp = client.get(url)
     assert resp.status_code == 400
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
 
     url = reverse('browse-content',
                   url_args={'query_string': unknown_content['sha1']})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
 
 
 @given(content())
 def test_content_bytes_missing(client, archive_data, mocker, content):
     mock_service = mocker.patch('swh.web.browse.utils.service')
     content_data = archive_data.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 = client.get(url)
 
     assert resp.status_code == 404
-    assert_template_used('browse/content.html')
+    assert_template_used(resp, 'browse/content.html')
 
 
 def test_content_too_large(client, mocker):
     mock_request_content = mocker.patch(
         'swh.web.browse.views.content.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 = client.get(url)
 
     assert resp.status_code == 200
-    assert_template_used('browse/content.html')
+    assert_template_used(resp, 'browse/content.html')
 
     assert_contains(resp, 'Content is too large to be displayed')
     assert_contains(resp, url_raw)
 
 
 @given(content())
 def test_content_uppercase(client, content):
     url = reverse('browse-content-uppercase-checksum',
                   url_args={'query_string': content['sha1'].upper()})
     resp = client.get(url)
     assert resp.status_code == 302
 
     redirect_url = reverse('browse-content',
                            url_args={'query_string': content['sha1']})
 
     assert resp['location'] == redirect_url
 
 
 @given(content_utf8_detected_as_binary())
 def test_content_utf8_detected_as_binary_display(client, archive_data,
                                                  content):
     url = reverse('browse-content',
                   url_args={'query_string': content['sha1']})
     resp = client.get(url)
 
     content_display = _process_content_for_display(archive_data, content)
 
     assert_contains(resp, escape(content_display['content_data']))
 
 
 def _process_content_for_display(archive_data, content):
     content_data = archive_data.content_get(content['sha1'])
 
     mime_type, encoding = get_mimetype_and_encoding_for_content(
         content_data['data'])
 
     mime_type, encoding, content_data = _re_encode_content(
         mime_type, encoding, content_data['data'])
 
     return prepare_content_for_display(content_data, mime_type,
                                        content['path'])
diff --git a/swh/web/tests/browse/views/test_directory.py b/swh/web/tests/browse/views/test_directory.py
index 6ab283f7..05e478a3 100644
--- a/swh/web/tests/browse/views/test_directory.py
+++ b/swh/web/tests/browse/views/test_directory.py
@@ -1,133 +1,133 @@
 # 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 hypothesis import given
 
 from swh.web.common.utils import reverse, get_swh_persistent_id
 from swh.web.common.utils import gen_path_info
 from swh.web.tests.django_asserts import assert_contains, assert_template_used
 from swh.web.tests.strategies import (
     directory, directory_with_subdirs, invalid_sha1,
     unknown_directory
 )
 
 
 @given(directory())
 def test_root_directory_view(client, archive_data, directory):
     _directory_view(client, directory, archive_data.directory_ls(directory))
 
 
 @given(directory_with_subdirs())
 def test_sub_directory_view(client, archive_data, directory):
     dir_content = archive_data.directory_ls(directory)
     subdir = random.choice([e for e in dir_content if e['type'] == 'dir'])
     subdir_content = archive_data.directory_ls(subdir['target'])
     _directory_view(client, directory, subdir_content, subdir['name'])
 
 
 @given(invalid_sha1(), unknown_directory())
 def test_directory_request_errors(client, invalid_sha1, unknown_directory):
     dir_url = reverse('browse-directory',
                       url_args={'sha1_git': invalid_sha1})
 
     resp = client.get(dir_url)
     assert resp.status_code == 400
-    assert_template_used('browse/error.html')
+    assert_template_used(resp, 'error.html')
 
     dir_url = reverse('browse-directory',
                       url_args={'sha1_git': unknown_directory})
 
     resp = client.get(dir_url)
     assert resp.status_code == 404
-    assert_template_used('browse/error.html')
+    assert_template_used(resp, 'error.html')
 
 
 @given(directory())
 def test_directory_uppercase(client, directory):
     url = reverse('browse-directory-uppercase-checksum',
                   url_args={'sha1_git': directory.upper()})
 
     resp = client.get(url)
     assert resp.status_code == 302
 
     redirect_url = reverse('browse-directory',
                            url_args={'sha1_git': directory})
 
     assert resp['location'] == redirect_url
 
 
 def _directory_view(client, root_directory_sha1, directory_entries,
                     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']
 
     url_args = {'sha1_git': root_directory_sha1}
     if path:
         url_args['path'] = path
 
     url = reverse('browse-directory',
                   url_args=url_args)
 
     root_dir_url = reverse('browse-directory',
                            url_args={'sha1_git': root_directory_sha1})
 
     resp = client.get(url)
 
     assert resp.status_code == 200
-    assert_template_used('browse/directory.html')
+    assert_template_used(resp, 'browse/directory.html')
     assert_contains(resp, '<a href="' + root_dir_url + '">' +
                     root_directory_sha1[:7] + '</a>')
     assert_contains(resp, '<td class="swh-directory">',
                     count=len(dirs))
     assert_contains(resp, '<td class="swh-content">',
                     count=len(files))
 
     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 = reverse('browse-directory',
                               url_args={'sha1_git': root_directory_sha1,
                                         'path': dir_path})
         assert_contains(resp, dir_url)
 
     for f in files:
         file_path = "%s/%s" % (root_directory_sha1, f['name'])
         if path:
             file_path = "%s/%s/%s" % (root_directory_sha1, path, f['name'])
         query_string = 'sha1_git:' + f['target']
         file_url = reverse('browse-content',
                            url_args={'query_string': query_string},
                            query_params={'path': file_path})
         assert_contains(resp, file_url)
 
     path_info = gen_path_info(path)
 
     assert_contains(resp, '<li class="swh-path">',
                     count=len(path_info)+1)
     assert_contains(resp, '<a href="%s">%s</a>' %
                     (root_dir_url, root_directory_sha1[:7]))
 
     for p in path_info:
         dir_url = reverse('browse-directory',
                           url_args={'sha1_git': root_directory_sha1,
                                     'path': p['path']})
         assert_contains(resp, '<a href="%s">%s</a>' %
                         (dir_url, p['name']))
 
     assert_contains(resp, 'vault-cook-directory')
 
     swh_dir_id = get_swh_persistent_id(
         'directory', directory_entries[0]['dir_id'])
     swh_dir_id_url = reverse('browse-swh-id',
                              url_args={'swh_id': swh_dir_id})
     assert_contains(resp, swh_dir_id)
     assert_contains(resp, swh_dir_id_url)
diff --git a/swh/web/tests/browse/views/test_origin.py b/swh/web/tests/browse/views/test_origin.py
index d7520c0b..cad9b292 100644
--- a/swh/web/tests/browse/views/test_origin.py
+++ b/swh/web/tests/browse/views/test_origin.py
@@ -1,900 +1,900 @@
 # 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
 import re
 
 import swh.web.browse.utils
 
 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.django_asserts import assert_contains, assert_template_used
 from swh.web.tests.strategies import (
     origin, origin_with_multiple_visits, new_origin,
     new_snapshot, visit_dates, revisions, origin_with_releases
 )
 
 
 @given(origin_with_multiple_visits())
 def test_origin_visits_browse(client, archive_data, origin):
     url = reverse('browse-origin-visits',
                   url_args={'origin_url': origin['url']})
     resp = client.get(url)
 
     assert resp.status_code == 200
-    assert_template_used('origin-visits.html')
+    assert_template_used(resp, 'browse/origin-visits.html')
 
     url = reverse('browse-origin-visits',
                   url_args={'origin_url': origin['url']})
     resp = client.get(url)
 
     assert resp.status_code == 200
-    assert_template_used('origin-visits.html')
+    assert_template_used(resp, 'browse/origin-visits.html')
 
     visits = archive_data.origin_visit_get(origin['url'])
 
     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})
         assert_contains(resp, browse_dir_url)
 
 
 @given(origin_with_multiple_visits())
 def test_origin_content_view(client, archive_data, origin):
     origin_visits = archive_data.origin_visit_get(origin['url'])
 
     def _get_archive_data(visit_idx):
         snapshot = archive_data.snapshot_get(
             origin_visits[visit_idx]['snapshot'])
         head_rev_id = archive_data.snapshot_get_head(snapshot)
         head_rev = archive_data.revision_get(head_rev_id)
         dir_content = archive_data.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]
         }
 
     tdata = _get_archive_data(-1)
 
     _origin_content_view_test_helper(client, origin, origin_visits,
                                      tdata['branches'],
                                      tdata['releases'],
                                      tdata['root_dir_sha1'],
                                      tdata['content'])
 
     _origin_content_view_test_helper(client, origin, origin_visits,
                                      tdata['branches'],
                                      tdata['releases'],
                                      tdata['root_dir_sha1'],
                                      tdata['content'],
                                      timestamp=tdata['visit']['date'])
 
     visit_unix_ts = parse_timestamp(tdata['visit']['date']).timestamp()
     visit_unix_ts = int(visit_unix_ts)
 
     _origin_content_view_test_helper(client, origin, origin_visits,
                                      tdata['branches'],
                                      tdata['releases'],
                                      tdata['root_dir_sha1'],
                                      tdata['content'],
                                      timestamp=visit_unix_ts)
 
     tdata = _get_archive_data(0)
 
     _origin_content_view_test_helper(client, origin, origin_visits,
                                      tdata['branches'],
                                      tdata['releases'],
                                      tdata['root_dir_sha1'],
                                      tdata['content'],
                                      visit_id=tdata['visit']['visit'])
 
 
 @given(origin())
 def test_origin_root_directory_view(client, archive_data, origin):
     origin_visits = archive_data.origin_visit_get(origin['url'])
 
     visit = origin_visits[-1]
     snapshot = archive_data.snapshot_get(visit['snapshot'])
     head_rev_id = archive_data.snapshot_get_head(snapshot)
     head_rev = archive_data.revision_get(head_rev_id)
     root_dir_sha1 = head_rev['directory']
     dir_content = archive_data.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)
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, dir_content)
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, dir_content,
                                        visit_id=visit['visit'])
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, dir_content,
                                        timestamp=visit_unix_ts)
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, dir_content,
                                        timestamp=visit['date'])
 
     origin = dict(origin)
     del origin['type']
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, dir_content)
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, dir_content,
                                        visit_id=visit['visit'])
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, dir_content,
                                        timestamp=visit_unix_ts)
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, dir_content,
                                        timestamp=visit['date'])
 
 
 @given(origin())
 def test_origin_sub_directory_view(client, archive_data, origin):
     origin_visits = archive_data.origin_visit_get(origin['url'])
 
     visit = origin_visits[-1]
     snapshot = archive_data.snapshot_get(visit['snapshot'])
     head_rev_id = archive_data.snapshot_get_head(snapshot)
     head_rev = archive_data.revision_get(head_rev_id)
     root_dir_sha1 = head_rev['directory']
     subdirs = [e for e in archive_data.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 = archive_data.directory_ls(subdir['target'])
     subdir_path = subdir['name']
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, subdir_content,
                                        path=subdir_path)
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, subdir_content,
                                        path=subdir_path,
                                        visit_id=visit['visit'])
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, subdir_content,
                                        path=subdir_path,
                                        timestamp=visit_unix_ts)
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, subdir_content,
                                        path=subdir_path,
                                        timestamp=visit['date'])
 
     origin = dict(origin)
     del origin['type']
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, subdir_content,
                                        path=subdir_path)
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, subdir_content,
                                        path=subdir_path,
                                        visit_id=visit['visit'])
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, subdir_content,
                                        path=subdir_path,
                                        timestamp=visit_unix_ts)
 
     _origin_directory_view_test_helper(client, origin, origin_visits, branches,
                                        releases, root_dir_sha1, subdir_content,
                                        path=subdir_path,
                                        timestamp=visit['date'])
 
 
 @given(origin())
 def test_origin_branches(client, archive_data, origin):
     origin_visits = archive_data.origin_visit_get(origin['url'])
 
     visit = origin_visits[-1]
     snapshot = archive_data.snapshot_get(visit['snapshot'])
     snapshot_content = process_snapshot_branches(snapshot)
 
     _origin_branches_test_helper(client, origin, snapshot_content)
 
     origin = dict(origin)
     origin['type'] = None
 
     _origin_branches_test_helper(client, origin, snapshot_content)
 
 
 @given(origin())
 def test_origin_releases(client, archive_data, origin):
     origin_visits = archive_data.origin_visit_get(origin['url'])
 
     visit = origin_visits[-1]
     snapshot = archive_data.snapshot_get(visit['snapshot'])
     snapshot_content = process_snapshot_branches(snapshot)
 
     _origin_releases_test_helper(client, origin, snapshot_content)
 
     origin = dict(origin)
     origin['type'] = None
 
     _origin_releases_test_helper(client, 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(client, archive_data, new_origin,
                                      new_snapshot, visit_dates, revisions):
     snp_dict = new_snapshot.to_dict()
     new_origin = archive_data.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',
                 'target': hash_to_bytes(revisions[i-1]),
             }
 
     archive_data.snapshot_add([snp_dict])
     visit = archive_data.origin_visit_add(
         new_origin['url'], visit_dates[0], type='git')
     archive_data.origin_visit_update(new_origin['url'], visit['visit'],
                                      status='partial',
                                      snapshot=snp_dict['id'])
 
     url = reverse('browse-origin-directory',
                   url_args={'origin_url': new_origin['url']})
     rv = client.get(url)
     assert rv.status_code == 200
 
 
 @given(new_origin(), new_snapshot(min_size=4, max_size=4), visit_dates(),
        revisions(min_size=4, max_size=4))
 def test_origin_snapshot_invalid_branch(client, archive_data, new_origin,
                                         new_snapshot, visit_dates, revisions):
     snp_dict = new_snapshot.to_dict()
     new_origin = archive_data.origin_add([new_origin])[0]
     for i, branch in enumerate(snp_dict['branches'].keys()):
         snp_dict['branches'][branch] = {
             'target_type': 'revision',
             'target': hash_to_bytes(revisions[i]),
         }
 
     archive_data.snapshot_add([snp_dict])
     visit = archive_data.origin_visit_add(
         new_origin['url'], visit_dates[0], type='git')
     archive_data.origin_visit_update(new_origin['url'], visit['visit'],
                                      status='full',
                                      snapshot=snp_dict['id'])
 
     url = reverse('browse-origin-directory',
                   url_args={'origin_url': new_origin['url']},
                   query_params={'branch': 'invalid_branch'})
     rv = client.get(url)
     assert rv.status_code == 404
 
 
 def test_origin_request_errors(client, archive_data, mocker):
     mock_snapshot_service = mocker.patch(
         'swh.web.browse.views.utils.snapshot_context.service')
     mock_origin_service = mocker.patch('swh.web.browse.views.origin.service')
     mock_utils_service = mocker.patch('swh.web.browse.utils.service')
     mock_get_origin_visit_snapshot = mocker.patch(
         'swh.web.browse.utils.get_origin_visit_snapshot')
     mock_get_origin_visits = mocker.patch(
         'swh.web.common.origin_visits.get_origin_visits')
     mock_request_content = mocker.patch(
         'swh.web.browse.views.utils.snapshot_context.request_content')
     mock_origin_service.lookup_origin.side_effect = NotFoundExc(
         'origin not found')
     url = reverse('browse-origin-visits',
                   url_args={'origin_url': 'bar'})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     assert_contains(resp, 'origin 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-directory',
                   url_args={'origin_url': 'bar'})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     assert_contains(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_url': 'bar'},
                   query_params={'visit_id': 2})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     assert re.search('Visit.*not found', resp.content.decode('utf-8'))
 
     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_sizes.return_value = {
         'revision': 1,
         'release': 0
     }
     mock_lookup_directory = mock_utils_service.lookup_directory
     mock_lookup_directory.side_effect = NotFoundExc('Directory not found')
     url = reverse('browse-origin-directory',
                   url_args={'origin_url': 'bar'})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     assert_contains(resp, 'Directory 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_url': 'bar',
                             'path': 'foo'})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     assert_contains(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_url': 'bar',
                             'path': 'foo'},
                   query_params={'visit_id': 2})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     assert re.search('Visit.*not found', resp.content.decode('utf-8'))
 
     mock_get_origin_visits.return_value = [{
         'date': '2015-09-26T09:30:52.373449+00:00',
         'metadata': {},
         'origin': 457,
         'snapshot': 'bdaf9ac436488a8c6cda927a0f44e172934d3f65',
         'status': 'full',
         'type': 'git',
         'visit': 1
     }]
     mock_get_origin_visit_snapshot.side_effect = None
     mock_get_origin_visit_snapshot.return_value = ([], [])
     mock_utils_service.lookup_snapshot_sizes.return_value = {
         'revision': 0,
         'release': 0
     }
     mock_utils_service.lookup_origin.return_value = {'type': 'foo',
                                                      'url': 'bar',
                                                      'id': 457}
     url = reverse('browse-origin-content',
                   url_args={'origin_url': 'bar',
                             'path': 'baz'})
     resp = client.get(url)
     assert resp.status_code == 200
-    assert_template_used('error.html')
+    assert_template_used(resp, 'browse/content.html')
     assert re.search('snapshot.*is empty', resp.content.decode('utf-8'))
 
     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_sizes.return_value = {
         'revision': 1,
         'release': 0
     }
     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_url': 'bar',
                             'path': 'baz'})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     assert_contains(resp, 'Content not found', status_code=404)
 
     mock_get_snapshot_context = mocker.patch(
         'swh.web.browse.views.utils.snapshot_context.get_snapshot_context')
 
     mock_get_snapshot_context.side_effect = NotFoundExc('Snapshot not found')
     url = reverse('browse-origin-directory',
                   url_args={'origin_url': 'bar'})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     assert_contains(resp, 'Snapshot not found', status_code=404)
 
 
 def test_origin_empty_snapshot(client, mocker):
     mock_utils_service = mocker.patch('swh.web.browse.utils.service')
     mock_get_origin_visit_snapshot = mocker.patch(
         'swh.web.browse.utils.get_origin_visit_snapshot')
     mock_get_origin_visits = mocker.patch(
         'swh.web.common.origin_visits.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',
         'type': 'git',
         'visit': 1
     }]
     mock_get_origin_visit_snapshot.return_value = ([], [])
     mock_utils_service.lookup_snapshot_sizes.return_value = {
         'revision': 0,
         'release': 0
     }
     mock_utils_service.lookup_origin.return_value = {
         'id': 457,
         'url': 'https://github.com/foo/bar'
     }
     url = reverse('browse-origin-directory',
                   url_args={'origin_url': 'bar'})
     resp = client.get(url)
     assert resp.status_code == 200
-    assert_template_used('content.html')
+    assert_template_used(resp, 'browse/directory.html')
     assert re.search('snapshot.*is empty', resp.content.decode('utf-8'))
 
 
 @given(origin_with_releases())
 def test_origin_release_browse(client, archive_data, origin):
     # for swh.web.browse.utils.get_snapshot_content to only return one branch
     snapshot_max_size = swh.web.browse.utils.snapshot_content_max_size
     swh.web.browse.utils.snapshot_content_max_size = 1
     try:
         snapshot = archive_data.snapshot_get_latest(origin['url'])
         release = [b for b in snapshot['branches'].values()
                    if b['target_type'] == 'release'][-1]
         release_data = archive_data.release_get(release['target'])
         url = reverse('browse-origin-directory',
                       url_args={'origin_url': origin['url']},
                       query_params={'release': release_data['name']})
 
         resp = client.get(url)
         assert resp.status_code == 200
         assert_contains(resp, release_data['name'])
         assert_contains(resp, release['target'])
     finally:
         swh.web.browse.utils.snapshot_content_max_size = snapshot_max_size
 
 
 @given(origin_with_releases())
 def test_origin_release_browse_not_found(client, archive_data, origin):
 
     invalid_release_name = 'swh-foo-bar'
     url = reverse('browse-origin-directory',
                   url_args={'origin_url': origin['url']},
                   query_params={'release': invalid_release_name})
 
     resp = client.get(url)
     assert resp.status_code == 404
     assert re.search(f'Release {invalid_release_name}.*not found',
                      resp.content.decode('utf-8'))
 
 
 def _origin_content_view_test_helper(client, 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_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 = client.get(url)
 
     assert resp.status_code == 200
-    assert_template_used('content.html')
+    assert_template_used(resp, 'browse/content.html')
 
     assert_contains(resp, '<code class="%s">' %
                     content['hljs_language'])
     assert_contains(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)
 
     assert_contains(resp, '<li class="swh-path">',
                     count=len(path_info)+1)
 
     assert_contains(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)
         assert_contains(resp, '<a href="%s">%s</a>' %
                         (dir_url, p['name']))
 
     assert_contains(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})
     assert_contains(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)
 
     assert_contains(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)
 
     assert_contains(resp, '<a href="%s">Releases (%s)</a>' %
                     (origin_releases_url, len(origin_releases)))
 
     assert_contains(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)
 
         assert_contains(resp, '<a href="%s">' % root_dir_branch_url)
 
     assert_contains(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)
 
         assert_contains(resp, '<a href="%s">' % root_dir_release_url)
 
     url = reverse('browse-origin-content',
                   url_args=url_args,
                   query_params=query_params)
 
     resp = client.get(url)
     assert resp.status_code == 200
-    assert_template_used('content.html')
+    assert_template_used(resp, 'browse/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})
     assert_contains(resp, swh_cnt_id)
     assert_contains(resp, swh_cnt_id_url)
 
     assert_contains(resp, 'swh-take-new-snapshot')
 
 
 def _origin_directory_view_test_helper(client, 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 = client.get(url)
 
     assert resp.status_code == 200
-    assert_template_used('directory.html')
+    assert_template_used(resp, 'browse/directory.html')
 
     assert resp.status_code == 200
-    assert_template_used('directory.html')
+    assert_template_used(resp, 'browse/directory.html')
 
     assert_contains(resp, '<td class="swh-directory">',
                     count=len(dirs))
     assert_contains(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)
         assert_contains(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)
         assert_contains(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
 
     assert_contains(resp, '<li class="swh-path">', count=nb_bc_paths)
     assert_contains(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)
 
     assert_contains(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:
         assert_contains(resp, '<a href="%s">Releases (%s)</a>' %
                         (origin_releases_url, nb_releases))
 
     if path:
         url_args['path'] = path
 
     assert_contains(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)
 
         assert_contains(resp, '<a href="%s">' % root_dir_branch_url)
 
     assert_contains(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)
 
         assert_contains(resp, '<a href="%s">' % root_dir_release_url)
 
     assert_contains(resp, 'vault-cook-directory')
     assert_contains(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})
     assert_contains(resp, swh_dir_id)
     assert_contains(resp, swh_dir_id_url)
 
     assert_contains(resp, 'swh-take-new-snapshot')
 
 
 def _origin_branches_test_helper(client, origin_info, origin_snapshot):
     url_args = {'origin_url': origin_info['url']}
 
     url = reverse('browse-origin-branches',
                   url_args=url_args)
 
     resp = client.get(url)
 
     assert resp.status_code == 200
-    assert_template_used('branches.html')
+    assert_template_used(resp, 'browse/branches.html')
 
     origin_branches = origin_snapshot[0]
     origin_releases = origin_snapshot[1]
 
     origin_branches_url = reverse('browse-origin-branches',
                                   url_args=url_args)
 
     assert_contains(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:
         assert_contains(resp, '<a href="%s">Releases (%s)</a>' %
                         (origin_releases_url, nb_releases))
 
     assert_contains(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_url': origin_info['url']},
             query_params={'branch': branch['name']})
         assert_contains(resp, '<a href="%s">' %
                         escape(browse_branch_url))
 
         browse_revision_url = reverse(
             'browse-revision',
             url_args={'sha1_git': branch['revision']},
             query_params={'origin': origin_info['url']})
         assert_contains(resp, '<a href="%s">' %
                         escape(browse_revision_url))
 
 
 def _origin_releases_test_helper(client, origin_info, origin_snapshot):
     url_args = {'origin_url': origin_info['url']}
 
     url = reverse('browse-origin-releases',
                   url_args=url_args)
 
     resp = client.get(url)
     assert resp.status_code == 200
-    assert_template_used('releases.html')
+    assert_template_used(resp, 'browse/releases.html')
 
     origin_branches = origin_snapshot[0]
     origin_releases = origin_snapshot[1]
 
     origin_branches_url = reverse('browse-origin-branches',
                                   url_args=url_args)
 
     assert_contains(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:
         assert_contains(resp, '<a href="%s">Releases (%s)</a>' %
                         (origin_releases_url, nb_releases))
 
     assert_contains(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']})
 
         assert_contains(resp, '<a href="%s">' %
                         escape(browse_release_url))
         assert_contains(resp, '<a href="%s">' %
                         escape(browse_revision_url))
diff --git a/swh/web/tests/browse/views/test_release.py b/swh/web/tests/browse/views/test_release.py
index 13871e56..7f33c2b3 100644
--- a/swh/web/tests/browse/views/test_release.py
+++ b/swh/web/tests/browse/views/test_release.py
@@ -1,104 +1,104 @@
 # Copyright (C) 2018-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 hypothesis import given
 
 from swh.web.common.utils import (
     reverse, format_utc_iso_date, get_swh_persistent_id
 )
 from swh.web.tests.django_asserts import assert_contains, assert_template_used
 from swh.web.tests.strategies import (
     release, origin_with_releases, unknown_release
 )
 
 
 @given(release())
 def test_release_browse(client, archive_data, release):
     url = reverse('browse-release',
                   url_args={'sha1_git': release})
 
     release_data = archive_data.release_get(release)
 
     resp = client.get(url)
 
     _release_browse_checks(resp, release_data)
 
 
 @given(origin_with_releases())
 def test_release_browse_with_origin(client, archive_data, origin):
     snapshot = archive_data.snapshot_get_latest(origin['url'])
     release = random.choice([b for b in snapshot['branches'].values()
                              if b['target_type'] == 'release'])
     url = reverse('browse-release',
                   url_args={'sha1_git': release['target']},
                   query_params={'origin': origin['url']})
 
     release_data = archive_data.release_get(release['target'])
 
     resp = client.get(url)
 
     _release_browse_checks(resp, release_data, origin)
 
 
 @given(unknown_release())
 def test_release_browse_not_found(client, archive_data, unknown_release):
     url = reverse('browse-release',
                   url_args={'sha1_git': unknown_release})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     err_msg = 'Release with sha1_git %s not found' % unknown_release
     assert_contains(resp, err_msg, status_code=404)
 
 
 @given(release())
 def test_release_uppercase(client, release):
     url = reverse('browse-release-uppercase-checksum',
                   url_args={'sha1_git': release.upper()})
 
     resp = client.get(url)
     assert resp.status_code == 302
 
     redirect_url = reverse('browse-release',
                            url_args={'sha1_git': release})
 
     assert resp['location'] == redirect_url
 
 
 def _release_browse_checks(resp, release_data, origin_info=None):
     query_params = {}
     if origin_info:
         query_params['origin'] = origin_info['url']
 
     release_id = release_data['id']
     release_name = release_data['name']
     author_name = release_data['author']['name']
 
     release_date = release_data['date']
     message = release_data['message']
     target_type = release_data['target_type']
     target = release_data['target']
 
     target_url = reverse('browse-revision', url_args={'sha1_git': target},
                          query_params=query_params)
     message_lines = message.split('\n')
 
     assert resp.status_code == 200
-    assert_template_used('browse/release.html')
+    assert_template_used(resp, 'browse/release.html')
     assert_contains(resp, author_name)
     assert_contains(resp, format_utc_iso_date(release_date))
     assert_contains(resp, '<h6>%s</h6>%s' % (message_lines[0] or 'None',
                                              '\n'.join(message_lines[1:])))
     assert_contains(resp, release_id)
     assert_contains(resp, release_name)
     assert_contains(resp, target_type)
     assert_contains(resp, '<a href="%s">%s</a>' % (target_url, target))
 
     swh_rel_id = get_swh_persistent_id('release', release_id)
     swh_rel_id_url = reverse('browse-swh-id', url_args={'swh_id': swh_rel_id})
     assert_contains(resp, swh_rel_id)
     assert_contains(resp, swh_rel_id_url)
diff --git a/swh/web/tests/browse/views/test_revision.py b/swh/web/tests/browse/views/test_revision.py
index f16a084c..2084a2b6 100644
--- a/swh/web/tests/browse/views/test_revision.py
+++ b/swh/web/tests/browse/views/test_revision.py
@@ -1,245 +1,245 @@
 # 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 django.utils.html import escape
 from hypothesis import given
 
 from swh.web.common.utils import (
     reverse, format_utc_iso_date, get_swh_persistent_id,
     parse_timestamp
 )
 from swh.web.tests.django_asserts import assert_contains, assert_template_used
 from swh.web.tests.strategies import (
     origin, revision, unknown_revision, new_origin
 )
 
 
 @given(revision())
 def test_revision_browse(client, archive_data, revision):
     url = reverse('browse-revision',
                   url_args={'sha1_git': revision})
 
     revision_data = archive_data.revision_get(revision)
 
     author_name = revision_data['author']['name']
     committer_name = revision_data['committer']['name']
     dir_id = revision_data['directory']
 
     directory_url = reverse('browse-directory',
                             url_args={'sha1_git': dir_id})
 
     history_url = reverse('browse-revision-log',
                           url_args={'sha1_git': revision})
 
     resp = client.get(url)
 
     assert resp.status_code == 200
-    assert_template_used('browse/revision.html')
+    assert_template_used(resp, 'browse/revision.html')
     assert_contains(resp, author_name)
     assert_contains(resp, committer_name)
     assert_contains(resp, directory_url)
     assert_contains(resp, history_url)
 
     for parent in revision_data['parents']:
         parent_url = reverse('browse-revision',
                              url_args={'sha1_git': parent})
         assert_contains(resp, '<a href="%s">%s</a>' %
                         (parent_url, parent))
 
     author_date = revision_data['date']
     committer_date = revision_data['committer_date']
 
     message_lines = revision_data['message'].split('\n')
 
     assert_contains(resp, format_utc_iso_date(author_date))
     assert_contains(resp, format_utc_iso_date(committer_date))
     assert_contains(resp, escape(message_lines[0]))
     assert_contains(resp, escape('\n'.join(message_lines[1:])))
 
 
 @given(origin())
 def test_revision_origin_browse(client, archive_data, origin):
     snapshot = archive_data.snapshot_get_latest(origin['url'])
     revision = archive_data.snapshot_get_head(snapshot)
     revision_data = archive_data.revision_get(revision)
     dir_id = revision_data['directory']
 
     origin_revision_log_url = reverse('browse-origin-log',
                                         url_args={'origin_url': origin['url']},  # noqa
                                         query_params={'revision': revision})
 
     url = reverse('browse-revision',
                   url_args={'sha1_git': revision},
                   query_params={'origin': origin['url']})
 
     resp = client.get(url)
 
     assert_contains(resp, origin_revision_log_url)
 
     for parent in revision_data['parents']:
         parent_url = reverse('browse-revision',
                              url_args={'sha1_git': parent},
                              query_params={'origin': origin['url']})
         assert_contains(resp, '<a href="%s">%s</a>' %
                         (parent_url, parent))
 
     assert_contains(resp, 'vault-cook-directory')
     assert_contains(resp, 'vault-cook-revision')
 
     swh_rev_id = get_swh_persistent_id('revision', revision)
     swh_rev_id_url = reverse('browse-swh-id',
                              url_args={'swh_id': swh_rev_id})
     assert_contains(resp, swh_rev_id)
     assert_contains(resp, swh_rev_id_url)
 
     swh_dir_id = get_swh_persistent_id('directory', dir_id)
     swh_dir_id_url = reverse('browse-swh-id',
                              url_args={'swh_id': swh_dir_id})
     assert_contains(resp, swh_dir_id)
     assert_contains(resp, swh_dir_id_url)
 
     assert_contains(resp, 'swh-take-new-snapshot')
 
 
 @given(revision())
 def test_revision_log_browse(client, archive_data, revision):
     per_page = 10
 
     revision_log = archive_data.revision_log(revision)
 
     revision_log_sorted = \
         sorted(revision_log,
                key=lambda rev: -parse_timestamp(
                    rev['committer_date']).timestamp())
 
     url = reverse('browse-revision-log',
                   url_args={'sha1_git': revision},
                   query_params={'per_page': per_page})
 
     resp = client.get(url)
 
     next_page_url = reverse('browse-revision-log',
                             url_args={'sha1_git': revision},
                             query_params={'offset': per_page,
                                           'per_page': per_page})
 
     nb_log_entries = per_page
     if len(revision_log_sorted) < per_page:
         nb_log_entries = len(revision_log_sorted)
 
     assert resp.status_code == 200
-    assert_template_used('browse/revision-log.html')
+    assert_template_used(resp, 'browse/revision-log.html')
     assert_contains(resp, '<tr class="swh-revision-log-entry',
                     count=nb_log_entries)
     assert_contains(resp, '<a class="page-link">Newer</a>')
 
     if len(revision_log_sorted) > per_page:
         assert_contains(resp, '<a class="page-link" href="%s">Older</a>' %  # noqa
                             escape(next_page_url))
 
     for log in revision_log_sorted[:per_page]:
         revision_url = reverse('browse-revision',
                                url_args={'sha1_git': log['id']})
         assert_contains(resp, log['id'][:7])
         assert_contains(resp, log['author']['name'])
         assert_contains(resp, format_utc_iso_date(log['date']))
         assert_contains(resp, escape(log['message']))
         assert_contains(resp, format_utc_iso_date(log['committer_date']))  # noqa
         assert_contains(resp, revision_url)
 
     if len(revision_log_sorted) <= per_page:
         return
 
     resp = client.get(next_page_url)
 
     prev_page_url = reverse('browse-revision-log',
                             url_args={'sha1_git': revision},
                             query_params={'per_page': per_page})
     next_page_url = reverse('browse-revision-log',
                             url_args={'sha1_git': revision},
                             query_params={'offset': 2 * per_page,
                                           'per_page': per_page})
 
     nb_log_entries = len(revision_log_sorted) - per_page
     if nb_log_entries > per_page:
         nb_log_entries = per_page
 
     assert resp.status_code == 200
-    assert_template_used('browse/revision-log.html')
+    assert_template_used(resp, 'browse/revision-log.html')
     assert_contains(resp, '<tr class="swh-revision-log-entry',
                     count=nb_log_entries)
 
     assert_contains(resp, '<a class="page-link" href="%s">Newer</a>' %
                     escape(prev_page_url))
 
     if len(revision_log_sorted) > 2 * per_page:
         assert_contains(resp, '<a class="page-link" href="%s">Older</a>' %  # noqa
                             escape(next_page_url))
 
     if len(revision_log_sorted) <= 2 * per_page:
         return
 
     resp = client.get(next_page_url)
 
     prev_page_url = reverse('browse-revision-log',
                             url_args={'sha1_git': revision},
                             query_params={'offset': per_page,
                                           'per_page': per_page})
     next_page_url = reverse('browse-revision-log',
                             url_args={'sha1_git': revision},
                             query_params={'offset': 3 * per_page,
                                           'per_page': per_page})
 
     nb_log_entries = len(revision_log_sorted) - 2 * per_page
     if nb_log_entries > per_page:
         nb_log_entries = per_page
 
     assert resp.status_code == 200
-    assert_template_used('browse/revision-log.html')
+    assert_template_used(resp, 'browse/revision-log.html')
     assert_contains(resp, '<tr class="swh-revision-log-entry',
                     count=nb_log_entries)
     assert_contains(resp, '<a class="page-link" href="%s">Newer</a>' %
                     escape(prev_page_url))
 
     if len(revision_log_sorted) > 3 * per_page:
         assert_contains(resp, '<a class="page-link" href="%s">Older</a>' %  # noqa
                             escape(next_page_url))
 
 
 @given(revision(), unknown_revision(), new_origin())
 def test_revision_request_errors(client, revision, unknown_revision,
                                  new_origin):
     url = reverse('browse-revision',
                   url_args={'sha1_git': unknown_revision})
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     assert_contains(resp,
                     'Revision with sha1_git %s not found' %
                     unknown_revision, status_code=404)
 
     url = reverse('browse-revision',
                   url_args={'sha1_git': revision},
                   query_params={'origin': new_origin['url']})
 
     resp = client.get(url)
     assert resp.status_code == 404
-    assert_template_used('error.html')
+    assert_template_used(resp, 'error.html')
     assert_contains(resp, 'the origin mentioned in your request'
                     ' appears broken', status_code=404)
 
 
 @given(revision())
 def test_revision_uppercase(client, revision):
     url = reverse('browse-revision-uppercase-checksum',
                   url_args={'sha1_git': revision.upper()})
 
     resp = client.get(url)
     assert resp.status_code == 302
 
     redirect_url = reverse('browse-revision',
                            url_args={'sha1_git': revision})
 
     assert resp['location'] == redirect_url