diff --git a/swh/web/browse/utils.py b/swh/web/browse/utils.py
index 8c2df7ff..f3bd59d3 100644
--- a/swh/web/browse/utils.py
+++ b/swh/web/browse/utils.py
@@ -1,464 +1,498 @@
 # Copyright (C) 2017  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import base64
 import magic
 import math
 import stat
 import textwrap
 
 from django.core.cache import cache
 from django.utils.safestring import mark_safe
 
 from swh.web.common import highlightjs, service
 from swh.web.common.exc import NotFoundExc
 from swh.web.common.utils import (
     reverse, format_utc_iso_date, parse_timestamp
 )
 
 
 def get_directory_entries(sha1_git):
     """Function that retrieves the content of a SWH directory
     from the SWH archive.
 
     The directories entries are first sorted in lexicographical order.
     Sub-directories and regular files are then extracted.
 
     Args:
         sha1_git: sha1_git identifier of the directory
 
     Returns:
         A tuple whose first member corresponds to the sub-directories list
         and second member the regular files list
 
     Raises:
         NotFoundExc if the directory is not found
     """
     cache_entry_id = 'directory_entries_%s' % sha1_git
     cache_entry = cache.get(cache_entry_id)
 
     if cache_entry:
         return cache_entry
 
     entries = list(service.lookup_directory(sha1_git))
     entries = sorted(entries, key=lambda e: e['name'])
     for entry in entries:
         entry['perms'] = stat.filemode(entry['perms'])
     dirs = [e for e in entries if e['type'] == 'dir']
     files = [e for e in entries if e['type'] == 'file']
 
     cache.set(cache_entry_id, (dirs, files))
 
     return dirs, files
 
 
 def gen_path_info(path):
     """Function to generate path data navigation for use
     with a breadcrumb in the swh web ui.
 
     For instance, from a path /folder1/folder2/folder3,
     it returns the following list::
 
         [{'name': 'folder1', 'path': 'folder1'},
          {'name': 'folder2', 'path': 'folder1/folder2'},
          {'name': 'folder3', 'path': 'folder1/folder2/folder3'}]
 
     Args:
         path: a filesystem path
 
     Returns:
         A list of path data for navigation as illustrated above.
 
     """
     path_info = []
     if path:
         sub_paths = path.strip('/').split('/')
         path_from_root = ''
         for p in sub_paths:
             path_from_root += '/' + p
             path_info.append({'name': p,
                               'path': path_from_root.strip('/')})
     return path_info
 
 
 def get_mimetype_and_encoding_for_content(content):
     """Function that returns the mime type and the encoding associated to
     a content buffer using the magic module under the hood.
 
     Args:
         content (bytes): a content buffer
 
     Returns:
         A tuple (mimetype, encoding), for instance ('text/plain', 'us-ascii'),
         associated to the provided content.
 
     """
     magic_result = magic.detect_from_content(content)
     return magic_result.mime_type, magic_result.encoding
 
 
 def request_content(query_string):
     """Function that retrieves a SWH content from the SWH archive.
 
     Raw bytes content is first retrieved, then the content mime type.
     If the mime type is not stored in the archive, it will be computed
     using Python magic module.
 
     Args:
         query_string: a string of the form "[ALGO_HASH:]HASH" where
             optional ALGO_HASH can be either *sha1*, *sha1_git*, *sha256*,
             or *blake2s256* (default to *sha1*) and HASH the hexadecimal
             representation of the hash value
 
     Returns:
         A tuple whose first member corresponds to the content raw bytes
         and second member the content mime type
 
     Raises:
         NotFoundExc if the content is not found
     """
     content_data = service.lookup_content(query_string)
     content_raw = service.lookup_content_raw(query_string)
     content_data['raw_data'] = content_raw['data']
     filetype = service.lookup_content_filetype(query_string)
     language = service.lookup_content_language(query_string)
     license = service.lookup_content_license(query_string)
     if filetype:
         mimetype = filetype['mimetype']
         encoding = filetype['encoding']
     else:
         mimetype, encoding = \
             get_mimetype_and_encoding_for_content(content_data['raw_data'])
     content_data['mimetype'] = mimetype
     content_data['encoding'] = encoding
 
     # encode textual content to utf-8 if needed
     if mimetype.startswith('text/') and 'ascii' not in encoding \
        and 'utf-8' not in encoding:
         content_data['raw_data'] = \
             content_data['raw_data'].decode(encoding).encode('utf-8')
 
     if language:
         content_data['language'] = language['lang']
     else:
         content_data['language'] = 'not detected'
     if license:
         content_data['licenses'] = ', '.join(license['licenses'])
     else:
         content_data['licenses'] = 'not detected'
     return content_data
 
 
 _browsers_supported_image_mimes = set(['image/gif', 'image/png',
                                        'image/jpeg', 'image/bmp',
                                        'image/webp'])
 
 
 def prepare_content_for_display(content_data, mime_type, path):
     """Function that prepares a content for HTML display.
 
     The function tries to associate a programming language to a
     content in order to perform syntax highlighting client-side
     using highlightjs. The language is determined using either
     the content filename or its mime type.
     If the mime type corresponds to an image format supported
     by web browsers, the content will be encoded in base64
     for displaying the image.
 
     Args:
         content_data (bytes): raw bytes of the content
         mime_type (string): mime type of the content
         path (string): path of the content including filename
 
     Returns:
         A dict containing the content bytes (possibly different from the one
         provided as parameter if it is an image) under the key 'content_data
         and the corresponding highlightjs language class under the
         key 'language'.
     """
 
     language = highlightjs.get_hljs_language_from_filename(path)
 
     if not language:
         language = highlightjs.get_hljs_language_from_mime_type(mime_type)
 
     if not language:
         language = 'nohighlight-swh'
     elif mime_type.startswith('application/'):
         mime_type = mime_type.replace('application/', 'text/')
 
     if mime_type.startswith('image/'):
         if mime_type in _browsers_supported_image_mimes:
             content_data = base64.b64encode(content_data)
         else:
             content_data = None
 
     return {'content_data': content_data,
             'language': language}
 
 
 def get_origin_visits(origin_id):
     """Function that returns the list of visits for a swh origin.
     That list is put in cache in order to speedup the navigation
     in the swh web browse ui.
 
     Args:
         origin_id (int): the id of the swh origin to fetch visits from
 
     Returns:
         A list of dict describing the origin visits::
 
             [{'date': <UTC visit date in ISO format>,
               'origin': <origin id>,
               'status': <'full' | 'partial'>,
               'visit': <visit id>
              },
              ...
             ]
 
     Raises:
         NotFoundExc if the origin is not found
     """
     cache_entry_id = 'origin_%s_visits' % origin_id
     cache_entry = cache.get(cache_entry_id)
 
     if cache_entry:
         return cache_entry
 
     origin_visits = []
 
     per_page = service.MAX_LIMIT
     last_visit = None
     while 1:
         visits = list(service.lookup_origin_visits(origin_id,
                                                    last_visit=last_visit,
                                                    per_page=per_page))
         origin_visits += visits
         if len(visits) < per_page:
             break
         else:
             if not last_visit:
                 last_visit = per_page
             else:
                 last_visit += per_page
 
     cache.set(cache_entry_id, origin_visits)
 
     return origin_visits
 
 
+def get_origin_visit(origin_id, visit_id=None, visit_ts=None):
+    """Function that returns information about a SWH visit for
+    a given origin.
+    The visit is retrieved from the visits list using either:
+        * a visit id
+        * a provided timestamp, in that case, the closest visit from
+          that timestamp is selected
+
+    Args:
+        origin_id (int): the id of the swh origin to fetch branches from
+        visit_id (int): the id of the origin visit
+        visit_ts (int or str): an ISO date string or Unix timestamp to parse
+
+    Returns:
+        A dict containing the visit info as described below::
+
+            {'origin': 2,
+             'date': '2017-10-08T11:54:25.582463+00:00',
+             'metadata': {},
+             'visit': 25,
+             'status': 'full'}
+
+    """
+    visits = get_origin_visits(origin_id)
+    if not visit_id and visit_ts:
+        parsed_visit_ts = math.floor(parse_timestamp(visit_ts).timestamp())
+        for i, visit in enumerate(visits):
+            ts = math.floor(parse_timestamp(visit['date']).timestamp())
+            if i == 0 and parsed_visit_ts <= ts:
+                return visit
+            elif i == len(visits) - 1:
+                if parsed_visit_ts >= ts:
+                    return visit
+            else:
+                next_ts = math.floor(
+                    parse_timestamp(visits[i+1]['date']).timestamp())
+                if parsed_visit_ts >= ts and parsed_visit_ts < next_ts:
+                    if (parsed_visit_ts - ts) < (next_ts - parsed_visit_ts):
+                        return visit
+                    else:
+                        return visits[i+1]
+        raise NotFoundExc(
+            'Visit with timestamp %s for origin with id %s not found!' %
+            (visit_ts, origin_id))
+
+    visit = [v for v in visits if v['visit'] == int(visit_id)]
+    if len(visit) > 0:
+        return visit[0]
+    else:
+        return None
+
+
 def get_origin_visit_branches(origin_id, visit_id=None, visit_ts=None):
     """Function that returns the list of branches associated to
     a swh origin for a given visit.
     The visit can be expressed by its id or a timestamp. In the latter case,
     the closest visit from the provided timestamp will be used.
     If no visit parameter is provided, it returns the list of branches
     found for the latest visit.
     That list is put in  cache in order to speedup the navigation
     in the swh web browse ui.
 
     Args:
         origin_id (int): the id of the swh origin to fetch branches from
         visit_id (int): the id of the origin visit
         visit_ts (int or str): an ISO date string or Unix timestamp to parse
 
     Returns:
-        A list of dict describing the origin branches for the given visit::
+        A tuple with two members. The first one is a list of dict describing
+        the origin branches for the given visit::
 
             [{'name': <branch name>,
               'revision': <sha1_git of the associated revision>,
               'directory': <sha1_git of the associated root directory>
              },
              ...
             ]
 
+        The second one is the ISO date string corresponding to the associated
+        SWH visit.
+
     Raises:
         NotFoundExc if the origin or its visit are not found
     """
 
-    if not visit_id and visit_ts:
-        parsed_visit_ts = math.floor(parse_timestamp(visit_ts).timestamp())
-        visits = get_origin_visits(origin_id)
-        for i, visit in enumerate(visits):
-            ts = math.floor(parse_timestamp(visit['date']).timestamp())
-            if i == 0:
-                if parsed_visit_ts <= ts:
-                    return get_origin_visit_branches(origin_id, visit['visit'])
-            elif i == len(visits) - 1:
-                if parsed_visit_ts >= ts:
-                    return get_origin_visit_branches(origin_id, visit['visit'])
-            else:
-                next_ts = math.floor(
-                    parse_timestamp(visits[i+1]['date']).timestamp())
-                if parsed_visit_ts >= ts and parsed_visit_ts < next_ts:
-                    if (parsed_visit_ts - ts) < (next_ts - parsed_visit_ts):
-                        return get_origin_visit_branches(origin_id,
-                                                         visit['visit'])
-                    else:
-                        return get_origin_visit_branches(origin_id,
-                                                         visits[i+1]['visit'])
-        raise NotFoundExc(
-            'Visit with timestamp %s for origin with id %s not found!' %
-            (visit_ts, origin_id))
+    visit_info = get_origin_visit(origin_id, visit_id, visit_ts)
+    visit_id = visit_info['visit']
 
     cache_entry_id = 'origin_%s_visit_%s_branches' % (origin_id, visit_id)
     cache_entry = cache.get(cache_entry_id)
 
     if cache_entry:
         return cache_entry
 
     origin_visit_data = service.lookup_origin_visit(origin_id, visit_id)
     branches = []
     revision_ids = []
     occurrences = origin_visit_data['occurrences']
     for key in sorted(occurrences.keys()):
         if occurrences[key]['target_type'] == 'revision':
             branches.append({'name': key,
                              'revision': occurrences[key]['target']})
             revision_ids.append(occurrences[key]['target'])
 
     revisions = service.lookup_revision_multiple(revision_ids)
 
     branches_to_remove = []
 
     for idx, revision in enumerate(revisions):
         if revision:
             branches[idx]['directory'] = revision['directory']
         else:
             branches_to_remove.append(branches[idx])
 
     for b in branches_to_remove:
         branches.remove(b)
 
     cache.set(cache_entry_id, branches)
 
     return branches
 
 
 def gen_link(url, link_text):
     """
     Utility function for generating an HTML link to insert
     in Django templates.
 
     Args:
         url (str): an url
         link_text (str): the text for the produced link
 
     Returns:
         An HTML link in the form '<a href="url">link_text</a>'
 
     """
     link = '<a href="%s">%s</a>' % (url, link_text)
     return mark_safe(link)
 
 
 def gen_person_link(person_id, person_name):
     """
     Utility function for generating a link to a SWH person HTML view
     to insert in Django templates.
 
     Args:
         person_id (int): a SWH person id
         person_name (str): the associated person name
 
     Returns:
         An HTML link in the form '<a href="person_view_url">person_name</a>'
 
     """
     person_url = reverse('browse-person', kwargs={'person_id': person_id})
     return gen_link(person_url, person_name)
 
 
 def gen_revision_link(revision_id, shorten_id=False):
     """
     Utility function for generating a link to a SWH revision HTML view
     to insert in Django templates.
 
     Args:
         revision_id (int): a SWH revision id
         shorten_id (boolean): wheter to shorten the revision id to 7
             characters for the link text
 
     Returns:
         An HTML link in the form '<a href="revision_view_url">revision_id</a>'
 
     """
     revision_url = reverse('browse-revision',
                            kwargs={'sha1_git': revision_id})
     if shorten_id:
         return gen_link(revision_url, revision_id[:7])
     else:
         return gen_link(revision_url, revision_id)
 
 
 def _format_log_entries(revision_log, per_page):
     revision_log_data = []
     for i, log in enumerate(revision_log):
         if i == per_page:
             break
         revision_log_data.append(
             {'author': gen_person_link(log['author']['id'],
                                        log['author']['name']),
              'revision': gen_revision_link(log['id'], True),
              'message': log['message'],
              'message_shorten': textwrap.shorten(log['message'],
                                                  width=80,
                                                  placeholder='...'),
              'date': format_utc_iso_date(log['date']),
              'directory': log['directory']})
     return revision_log_data
 
 
 def prepare_revision_log_for_display(revision_log, per_page, revs_breadcrumb,
                                      origin_context=False):
     """
     Utility functions that process raw revision log data for HTML display.
     Its purpose is to:
 
         * add links to relevant SWH browse views
         * format date in human readable format
         * truncate the message log
 
     It also computes the data needed to generate the links for navigating back
     and forth in the history log.
 
     Args:
         revision_log (list): raw revision log as returned by the SWH web api
         per_page (int): number of log entries per page
         revs_breadcrumb (str): breadcrumbs of revisions navigated so far,
             in the form 'rev1[/rev2/../revN]'. Each revision corresponds to
             the first one displayed in the HTML view for history log.
         origin_context (boolean): wheter or not the revision log is browsed
             from an origin view.
 
 
     """
     current_rev = revision_log[0]['id']
     next_rev = None
     prev_rev = None
     next_revs_breadcrumb = None
     prev_revs_breadcrumb = None
     if len(revision_log) == per_page + 1:
         prev_rev = revision_log[-1]['id']
 
     prev_rev_bc = current_rev
     if origin_context:
         prev_rev_bc = prev_rev
 
     if revs_breadcrumb:
         revs = revs_breadcrumb.split('/')
         next_rev = revs[-1]
         if len(revs) > 1:
             next_revs_breadcrumb = '/'.join(revs[:-1])
         if len(revision_log) == per_page + 1:
             prev_revs_breadcrumb = revs_breadcrumb + '/' + prev_rev_bc
     else:
         prev_revs_breadcrumb = prev_rev_bc
 
     return {'revision_log_data': _format_log_entries(revision_log, per_page),
             'prev_rev': prev_rev,
             'prev_revs_breadcrumb': prev_revs_breadcrumb,
             'next_rev': next_rev,
             'next_revs_breadcrumb': next_revs_breadcrumb}
diff --git a/swh/web/browse/views/origin.py b/swh/web/browse/views/origin.py
index 484fc983..4a24f9a4 100644
--- a/swh/web/browse/views/origin.py
+++ b/swh/web/browse/views/origin.py
@@ -1,583 +1,607 @@
 # Copyright (C) 2017  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import dateutil
 
 from django.shortcuts import render
 from django.template.defaultfilters import filesizeformat
 
 from swh.web.common import service
 from swh.web.common.utils import reverse, format_utc_iso_date
 from swh.web.common.exc import NotFoundExc, handle_view_exception
 from swh.web.browse.utils import (
-    get_origin_visits, get_origin_visit_branches,
+    get_origin_visits, get_origin_visit, get_origin_visit_branches,
     gen_path_info, get_directory_entries, request_content,
     prepare_content_for_display, gen_link,
     prepare_revision_log_for_display
 )
 from swh.web.browse.browseurls import browse_route
 
 
 @browse_route(r'origin/(?P<origin_id>[0-9]+)/',
               r'origin/(?P<origin_type>[a-z]+)/url/(?P<origin_url>.+)/',
               view_name='browse-origin')
 def origin_browse(request, origin_id=None, origin_type=None,
                   origin_url=None):
     """Django view that produces an HTML display of a swh origin identified
     by its id or its url.
 
     The url scheme that points to it is :http:get:`/browse/origin/(origin_id)/`.
 
     Args:
         request: input django http request
         origin_id: a swh origin id
         origin_type: type of origin (git, svn, ...)
         origin_url: url of the origin (e.g. https://github.com/<user>/<repo>)
 
     Returns:
         The HMTL rendering for the metadata of the provided origin.
     """ # noqa
     try:
         if origin_id:
             origin_request_params = {
                 'id': origin_id,
             }
         else:
             origin_request_params = {
                 'type': origin_type,
                 'url': origin_url
             }
         origin_info = service.lookup_origin(origin_request_params)
         origin_id = origin_info['id']
         origin_visits = get_origin_visits(origin_id)
     except Exception as exc:
         return handle_view_exception(request, exc)
 
     origin_info['last swh visit browse url'] = \
         reverse('browse-origin-directory',
                 kwargs={'origin_id': origin_id})
 
     origin_visits_data = []
     for visit in origin_visits:
         visit_date = dateutil.parser.parse(visit['date'])
         visit['date'] = format_utc_iso_date(visit['date'])
         visit['browse_url'] = reverse('browse-origin-directory',
                                       kwargs={'origin_id': origin_id,
                                               'visit_id': visit['visit']})
         origin_visits_data.append(
             {'date': visit_date.timestamp()})
 
     return render(request, 'origin.html',
                   {'top_panel_visible': True,
                    'top_panel_collapsible': True,
                    'top_panel_text_left': 'SWH object: Origin',
                    'top_panel_text_right': 'Url: ' + origin_info['url'],
                    'swh_object_metadata': origin_info,
                    'main_panel_visible': True,
                    'origin_visits_data': origin_visits_data,
                    'visits': list(reversed(origin_visits)),
                    'browse_url_base': '/browse/origin/%s/' %
                    origin_id})
 
 
 def _get_origin_branches_and_url_args(origin_id, visit_id, ts):
     if not visit_id and ts:
         branches = get_origin_visit_branches(origin_id, visit_ts=ts)
         url_args = {'origin_id': origin_id,
                     'timestamp': ts}
     else:
         branches = get_origin_visit_branches(origin_id, visit_id)
         url_args = {'origin_id': origin_id,
                     'visit_id': visit_id}
     return branches, url_args
 
 
 def _raise_exception_if_branch_not_found(origin_id, visit_id, ts, branch):
     if visit_id:
         raise NotFoundExc('Branch %s associated to visit with'
                           ' id %s for origin with id %s'
                           ' not found!' %
                           (branch, visit_id, origin_id))
     else:
         raise NotFoundExc('Branch %s associated to visit with'
                           ' timestamp %s for origin with id %s'
                           ' not found!' %
                           (branch, ts, origin_id))
 
 
 def _get_branch(branches, branch_name):
     """
     Utility function to get a specific branch from an origin branches list.
     Its purpose is to get the default HEAD branch as some SWH origin
     (e.g those with svn type) does not have it. In that latter case, check
     if there is a master branch instead and returns it.
     """
     filtered_branches = [b for b in branches if b['name'].endswith(branch_name)] # noqa
     if len(filtered_branches) > 0:
         return filtered_branches[0]
     elif branch_name == 'HEAD':
         filtered_branches = [b for b in branches if b['name'].endswith('master')] # noqa
         if len(filtered_branches) > 0:
             return filtered_branches[0]
     return None
 
 
+def _gen_origin_link(origin_id, origin_url):
+    origin_browse_url = reverse('browse-origin',
+                                kwargs={'origin_id': origin_id})
+    return gen_link(origin_browse_url,
+                    'Origin: ' + origin_url)
+
+
 @browse_route(r'origin/(?P<origin_id>[0-9]+)/directory/',
               r'origin/(?P<origin_id>[0-9]+)/directory/(?P<path>.+)/',
               r'origin/(?P<origin_id>[0-9]+)/visit/(?P<visit_id>[0-9]+)/directory/', # noqa
               r'origin/(?P<origin_id>[0-9]+)/visit/(?P<visit_id>[0-9]+)/directory/(?P<path>.+)/', # noqa
               r'origin/(?P<origin_id>[0-9]+)/ts/(?P<timestamp>.+)/directory/', # noqa
               r'origin/(?P<origin_id>[0-9]+)/ts/(?P<timestamp>.+)/directory/(?P<path>.+)/', # noqa
               view_name='browse-origin-directory')
 def origin_directory_browse(request, origin_id, visit_id=None,
                             timestamp=None, path=None):
     """Django view for browsing the content of a swh directory associated
     to an origin for a given visit.
 
     The url scheme that points to it is the following:
 
         * :http:get:`/browse/origin/(origin_id)/directory/[(path)/]`
         * :http:get:`/browse/origin/(origin_id)/visit/(visit_id)/directory/[(path)/]`
         * :http:get:`/browse/origin/(origin_id)/ts/(timestamp)/directory/[(path)/]`
 
     Args:
         request: input django http request
         origin_id: a swh origin id
         visit_id: optionnal visit id parameter
             (the last one will be used by default)
         timestamp: optionnal visit timestamp parameter
             (the last one will be used by default)
         path: optionnal path parameter used to navigate in directories
               reachable from the origin root one
         branch: optionnal query parameter that specifies the origin branch
             from which to retrieve the directory
         revision: optional query parameter to specify the origin revision
             from which to retrieve the directory
 
     Returns:
         The HTML rendering for the content of the directory associated
         to the provided origin and visit.
     """ # noqa
     try:
 
         if not visit_id and not timestamp:
             origin_visits = get_origin_visits(origin_id)
             if not origin_visits:
                 raise NotFoundExc('No SWH visit associated to '
                                   'origin with id %s' % origin_id)
             return origin_directory_browse(request, origin_id,
                                            origin_visits[-1]['visit'],
                                            path=path)
 
         origin_info = service.lookup_origin({'id': origin_id})
-        branches, url_args = _get_origin_branches_and_url_args(origin_id,
-                                                               visit_id,
-                                                               timestamp)
+        branches, url_args = \
+            _get_origin_branches_and_url_args(origin_id, visit_id, timestamp)
+        visit_info = get_origin_visit(origin_id, visit_id, timestamp)
 
         for b in branches:
             branch_url_args = dict(url_args)
             if path:
                 b['path'] = path
                 branch_url_args['path'] = path
             b['url'] = reverse('browse-origin-directory',
                                kwargs=branch_url_args,
                                query_params={'branch': b['name']})
 
         revision_id = request.GET.get('revision', None)
 
         if revision_id:
             revision = service.lookup_revision(revision_id)
             root_sha1_git = revision['directory']
             branches.append({'name': revision_id,
                              'revision': revision_id,
                              'directory': root_sha1_git,
                              'url': None})
             branch_name = revision_id
         else:
             branch_name = request.GET.get('branch', 'HEAD')
             branch = _get_branch(branches, branch_name)
             if branch:
                 branch_name = branch['name']
                 root_sha1_git = branch['directory']
             else:
                 _raise_exception_if_branch_not_found(origin_id, visit_id,
                                                      timestamp, branch_name)
 
         sha1_git = root_sha1_git
         if path:
             dir_info = service.lookup_directory_with_path(root_sha1_git, path)
             sha1_git = dir_info['target']
 
         dirs, files = get_directory_entries(sha1_git)
 
     except Exception as exc:
         return handle_view_exception(request, exc)
 
     if revision_id:
         query_params = {'revision': revision_id}
     else:
         query_params = {'branch': branch_name}
 
     path_info = gen_path_info(path)
 
     breadcrumbs = []
     breadcrumbs.append({'name': root_sha1_git[:7],
                         'url': reverse('browse-origin-directory',
                                        kwargs=url_args,
                                        query_params=query_params)})
     for pi in path_info:
         bc_url_args = dict(url_args)
         bc_url_args['path'] = pi['path']
         breadcrumbs.append({'name': pi['name'],
                             'url': reverse('browse-origin-directory',
                                            kwargs=bc_url_args,
                                            query_params=query_params)})
 
     path = '' if path is None else (path + '/')
 
     for d in dirs:
         bc_url_args = dict(url_args)
         bc_url_args['path'] = path + d['name']
         d['url'] = reverse('browse-origin-directory',
                            kwargs=bc_url_args,
                            query_params=query_params)
 
     sum_file_sizes = 0
 
     for f in files:
         bc_url_args = dict(url_args)
         bc_url_args['path'] = path + f['name']
         f['url'] = reverse('browse-origin-content',
                            kwargs=bc_url_args,
                            query_params=query_params)
         sum_file_sizes += f['length']
         f['length'] = filesizeformat(f['length'])
 
     history_url = reverse('browse-origin-log',
                           kwargs=url_args,
                           query_params=query_params)
 
     sum_file_sizes = filesizeformat(sum_file_sizes)
 
     dir_metadata = {'id': sha1_git,
                     'number of regular files': len(files),
                     'number of subdirectories': len(dirs),
                     'sum of regular file sizes': sum_file_sizes,
                     'origin id': origin_info['id'],
                     'origin type': origin_info['type'],
                     'origin url': origin_info['url'],
+                    'origin visit': format_utc_iso_date(visit_info['date']),
                     'path': '/' + path}
 
     return render(request, 'directory.html',
                   {'top_panel_visible': True,
                    'top_panel_collapsible': True,
                    'top_panel_text_left': 'SWH object: Directory',
-                   'top_panel_text_right': 'Origin: ' + origin_info['url'],
+                   'top_panel_text_right': _gen_origin_link(
+                       origin_id, origin_info['url']),
                    'swh_object_metadata': dir_metadata,
                    'main_panel_visible': True,
                    'dirs': dirs,
                    'files': files,
                    'breadcrumbs': breadcrumbs,
                    'branches': branches,
                    'branch': branch_name,
                    'top_right_link': history_url,
                    'top_right_link_text': 'History'})
 
 
 @browse_route(r'origin/(?P<origin_id>[0-9]+)/content/(?P<path>.+)/',
               r'origin/(?P<origin_id>[0-9]+)/visit/(?P<visit_id>[0-9]+)/content/(?P<path>.+)/', # noqa
               r'origin/(?P<origin_id>[0-9]+)/ts/(?P<timestamp>.+)/content/(?P<path>.+)/', # noqa
               view_name='browse-origin-content')
 def origin_content_display(request, origin_id, path,
                            visit_id=None, timestamp=None):
     """Django view that produces an HTML display of a swh content
     associated to an origin for a given visit.
 
     The url scheme that points to it is the following:
 
         * :http:get:`/browse/origin/(origin_id)/content/(path)/`
         * :http:get:`/browse/origin/(origin_id)/visit/(visit_id)/content/(path)/`
         * :http:get:`/browse/origin/(origin_id)/ts/(timestamp)/content/(path)/`
 
     Args:
         request: input django http request
         origin_id: id of a swh origin
         path: path of the content relative to the origin root directory
         visit_id: optionnal visit id parameter
             (the last one will be used by default)
         timestamp: optionnal visit timestamp parameter
             (the last one will be used by default)
         branch: optionnal query parameter that specifies the origin branch
             from which to retrieve the content
         revision: optional query parameter to specify the origin revision
             from which to retrieve the content
 
     Returns:
         The HTML rendering of the requested content associated to
         the provided origin and visit.
 
     """ # noqa
     try:
 
         if not visit_id and not timestamp:
             origin_visits = get_origin_visits(origin_id)
             if not origin_visits:
                 raise NotFoundExc('No SWH visit associated to '
                                   'origin with id %s' % origin_id)
             return origin_content_display(request, origin_id, path,
                                           origin_visits[-1]['visit'])
 
         origin_info = service.lookup_origin({'id': origin_id})
-        branches, url_args = _get_origin_branches_and_url_args(origin_id,
-                                                               visit_id,
-                                                               timestamp)
+        branches, url_args = \
+            _get_origin_branches_and_url_args(origin_id, visit_id, timestamp)
+
+        visit_info = get_origin_visit(origin_id, visit_id, timestamp)
 
         for b in branches:
             bc_url_args = dict(url_args)
             bc_url_args['path'] = path
             b['url'] = reverse('browse-origin-content',
                                kwargs=bc_url_args,
                                query_params={'branch': b['name']})
 
         revision_id = request.GET.get('revision', None)
 
         if revision_id:
             revision = service.lookup_revision(revision_id)
             root_sha1_git = revision['directory']
             branches.append({'name': revision_id,
                              'revision': revision_id,
                              'directory': root_sha1_git,
                              'url': None})
             branch_name = revision_id
         else:
             branch_name = request.GET.get('branch', 'HEAD')
             branch = _get_branch(branches, branch_name)
             if branch:
                 branch_name = branch['name']
                 root_sha1_git = branch['directory']
             else:
                 _raise_exception_if_branch_not_found(origin_id, visit_id,
                                                      timestamp, branch_name)
 
         content_info = service.lookup_directory_with_path(root_sha1_git, path)
         sha1_git = content_info['target']
         query_string = 'sha1_git:' + sha1_git
         content_data = request_content(query_string)
 
     except Exception as exc:
         return handle_view_exception(request, exc)
 
     if revision_id:
         query_params = {'revision': revision_id}
     else:
         query_params = {'branch': branch_name}
 
     content_display_data = prepare_content_for_display(
         content_data['raw_data'], content_data['mimetype'], path)
 
     filename = None
     path_info = None
 
     breadcrumbs = []
 
     split_path = path.split('/')
     filename = split_path[-1]
     path = path.replace(filename, '')
     path_info = gen_path_info(path)
     breadcrumbs.append({'name': root_sha1_git[:7],
                         'url': reverse('browse-origin-directory',
                                        kwargs=url_args,
                                        query_params=query_params)})
     for pi in path_info:
         bc_url_args = dict(url_args)
         bc_url_args['path'] = pi['path']
         breadcrumbs.append({'name': pi['name'],
                             'url': reverse('browse-origin-directory',
                                            kwargs=bc_url_args,
                                            query_params=query_params)})
 
     breadcrumbs.append({'name': filename,
                         'url': None})
 
     content_raw_url = reverse('browse-content-raw',
                               kwargs={'query_string': query_string},
                               query_params={'filename': filename})
 
     content_metadata = {
         'sha1 checksum': content_data['checksums']['sha1'],
         'sha1_git checksum': content_data['checksums']['sha1_git'],
         'sha256 checksum': content_data['checksums']['sha256'],
         'blake2s256 checksum': content_data['checksums']['blake2s256'],
         'mime type': content_data['mimetype'],
         'encoding': content_data['encoding'],
         'size': filesizeformat(content_data['length']),
         'language': content_data['language'],
         'licenses': content_data['licenses'],
         'origin id': origin_info['id'],
         'origin type': origin_info['type'],
         'origin url': origin_info['url'],
+        'origin visit': format_utc_iso_date(visit_info['date']),
         'path': '/' + path,
         'filename': filename
     }
 
     return render(request, 'content.html',
                   {'top_panel_visible': True,
                    'top_panel_collapsible': True,
                    'top_panel_text_left': 'SWH object: Content',
-                   'top_panel_text_right': 'Origin: %s' % origin_info['url'],
+                   'top_panel_text_right': _gen_origin_link(
+                       origin_id, origin_info['url']),
                    'swh_object_metadata': content_metadata,
                    'main_panel_visible': True,
                    'content': content_display_data['content_data'],
                    'mimetype': content_data['mimetype'],
                    'language': content_display_data['language'],
                    'breadcrumbs': breadcrumbs,
                    'branches': branches,
                    'branch': branch_name,
                    'top_right_link': content_raw_url,
                    'top_right_link_text': 'Raw File'})
 
 
 def _gen_directory_link(url_args, revision, link_text):
     directory_url = reverse('browse-origin-directory',
                             kwargs=url_args,
                             query_params={'revision': revision})
     return gen_link(directory_url, link_text)
 
 
 NB_LOG_ENTRIES = 20
 
 
 @browse_route(r'origin/(?P<origin_id>[0-9]+)/log/',
               r'origin/(?P<origin_id>[0-9]+)/visit/(?P<visit_id>[0-9]+)/log/', # noqa
               r'origin/(?P<origin_id>[0-9]+)/ts/(?P<timestamp>.+)/log/',
               view_name='browse-origin-log')
 def origin_log_browse(request, origin_id, visit_id=None, timestamp=None):
     """Django view that produces an HTML display of revisions history (aka
     the commit log) associated to a SWH origin.
 
     The url scheme that points to it is the following:
 
         * :http:get:`/browse/origin/(origin_id)/log/`
         * :http:get:`/browse/origin/(origin_id)/visit/(visit_id)/log/`
         * :http:get:`/browse/origin/(origin_id)/ts/(timestamp)/log/`
 
     Args:
         request: input django http request
         origin_id: id of a swh origin
         visit_id: optionnal visit id parameter
             (the last one will be used by default)
         timestamp: optionnal visit timestamp parameter
             (the last one will be used by default)
         revs_breadcrumb: query parameter used internally to store
             the navigation breadcrumbs (i.e. the list of descendant revisions
             visited so far).
         per_page: optionnal query parameter used to specify the number of
             log entries per page
         branch: optionnal query parameter that specifies the origin branch
             from which to retrieve the content
         revision: optional query parameter to specify the origin revision
             from which to retrieve the directory
 
     Returns:
         The HTML rendering of revisions history for a given SWH visit.
 
     """ # noqa
     try:
 
         if not visit_id and not timestamp:
             origin_visits = get_origin_visits(origin_id)
             if not origin_visits:
                 raise NotFoundExc('No SWH visit associated to '
                                   'origin with id %s' % origin_id)
             return origin_log_browse(request, origin_id,
                                      origin_visits[-1]['visit'])
 
-        branches, url_args = _get_origin_branches_and_url_args(origin_id,
-                                                               visit_id,
-                                                               timestamp)
+        branches, url_args = \
+            _get_origin_branches_and_url_args(origin_id, visit_id, timestamp)
+
+        visit_info = get_origin_visit(origin_id, visit_id, timestamp)
 
         for b in branches:
             b['url'] = reverse('browse-origin-log',
                                kwargs=url_args,
                                query_params={'branch': b['name']})
 
         revision_id = request.GET.get('revision', None)
         revs_breadcrumb = request.GET.get('revs_breadcrumb', None)
         branch_name = request.GET.get('branch', 'HEAD')
 
         if revision_id:
             revision = service.lookup_revision(revision_id)
             branches.append({'name': revision_id,
                              'revision': revision_id,
                              'directory': revision['directory']})
             revision = revision_id
             branch_name = revision_id
         elif revs_breadcrumb:
             revs = revs_breadcrumb.split('/')
             revision = revs[-1]
         else:
             branch = _get_branch(branches, branch_name)
             if branch:
                 branch_name = branch['name']
                 revision = branch['revision']
             else:
                 _raise_exception_if_branch_not_found(origin_id, visit_id,
                                                      timestamp, branch_name)
 
         per_page = int(request.GET.get('per_page', NB_LOG_ENTRIES))
         revision_log = service.lookup_revision_log(revision,
                                                    limit=per_page+1)
         revision_log = list(revision_log)
 
     except Exception as exc:
         return handle_view_exception(request, exc)
 
     revision_log_display_data = prepare_revision_log_for_display(
         revision_log, per_page, revs_breadcrumb, origin_context=True)
 
     prev_rev = revision_log_display_data['prev_rev']
     prev_revs_breadcrumb = revision_log_display_data['prev_revs_breadcrumb']
     prev_log_url = None
     if prev_rev:
         prev_log_url = \
             reverse('browse-origin-log',
                     kwargs=url_args,
                     query_params={'revs_breadcrumb': prev_revs_breadcrumb,
                                   'per_page': per_page,
                                   'branch': branch_name})
 
     next_rev = revision_log_display_data['next_rev']
     next_revs_breadcrumb = revision_log_display_data['next_revs_breadcrumb']
     next_log_url = None
     if next_rev:
         next_log_url = \
             reverse('browse-origin-log',
                     kwargs=url_args,
                     query_params={'revs_breadcrumb': next_revs_breadcrumb,
                                   'per_page': per_page,
                                   'branch': branch_name})
 
     revision_log_data = revision_log_display_data['revision_log_data']
 
     for i, log in enumerate(revision_log_data):
         log['directory'] = _gen_directory_link(url_args, revision_log[i]['id'],
                                                'Tree')
 
+    origin_info = service.lookup_origin({'id': origin_id})
+
+    revision_metadata = {
+        'origin id': origin_info['id'],
+        'origin type': origin_info['type'],
+        'origin url': origin_info['url'],
+        'origin visit': format_utc_iso_date(visit_info['date'])
+    }
+
     return render(request, 'revision-log.html',
-                  {'top_panel_visible': False,
-                   'top_panel_collapsible': False,
+                  {'top_panel_visible': True,
+                   'top_panel_collapsible': True,
                    'top_panel_text_left': 'SWH object: Revision history',
-                   'top_panel_text_right': 'Sha1 git: ' + revision,
-                   'swh_object_metadata': None,
+                   'top_panel_text_right': _gen_origin_link(
+                       origin_id, origin_info['url']),
+                   'swh_object_metadata': revision_metadata,
                    'main_panel_visible': True,
                    'revision_log': revision_log_data,
                    'next_log_url': next_log_url,
                    'prev_log_url': prev_log_url,
                    'breadcrumbs': None,
                    'branches': branches,
                    'branch': branch_name,
                    'top_right_link': None,
                    'top_right_link_text': None,
-                   'include_top_navigation': True})
+                   'include_top_navigation': True,
+                   'no_origin_context': False})
diff --git a/swh/web/browse/views/revision.py b/swh/web/browse/views/revision.py
index c49b8fd4..e1aaa2ea 100644
--- a/swh/web/browse/views/revision.py
+++ b/swh/web/browse/views/revision.py
@@ -1,163 +1,164 @@
 # Copyright (C) 2017  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import json
 
 from django.shortcuts import render
 from django.utils.safestring import mark_safe
 from swh.web.common import service
 from swh.web.common.utils import reverse, format_utc_iso_date
 from swh.web.common.exc import handle_view_exception
 from swh.web.browse.browseurls import browse_route
 from swh.web.browse.utils import (
     gen_link, gen_person_link, gen_revision_link,
     prepare_revision_log_for_display
 )
 
 
 def _gen_directory_link(sha1_git, link_text):
     directory_url = reverse('browse-directory',
                             kwargs={'sha1_git': sha1_git})
     return gen_link(directory_url, link_text)
 
 
 def _gen_revision_log_link(revision_id):
     revision_log_url = reverse('browse-revision-log',
                                kwargs={'sha1_git': revision_id})
     return gen_link(revision_log_url, revision_log_url)
 
 
 @browse_route(r'revision/(?P<sha1_git>[0-9a-f]+)/',
               view_name='browse-revision')
 def revision_browse(request, sha1_git):
     """
     Django view that produces an HTML display of a SWH revision
     identified by its id.
 
     The url that points to it is :http:get:`/browse/revision/(sha1_git)/`.
 
     Args:
         request: input django http request
         sha1_git: a SWH revision id
 
     Returns:
         The HMTL rendering for the metadata of the provided revision.
     """
     try:
         revision = service.lookup_revision(sha1_git)
     except Exception as exc:
         return handle_view_exception(request, exc)
 
     revision_data = {}
 
     revision_data['author'] = gen_person_link(
         revision['author']['id'], revision['author']['name'])
     revision_data['committer'] = gen_person_link(
         revision['committer']['id'], revision['committer']['name'])
     revision_data['committer date'] = format_utc_iso_date(
         revision['committer_date'])
     revision_data['date'] = format_utc_iso_date(revision['date'])
     revision_data['directory'] = _gen_directory_link(revision['directory'],
                                                      revision['directory'])
     revision_data['history log'] = _gen_revision_log_link(sha1_git)
     revision_data['id'] = sha1_git
     revision_data['merge'] = revision['merge']
     revision_data['message'] = revision['message']
     revision_data['metadata'] = json.dumps(revision['metadata'],
                                            sort_keys=True,
                                            indent=4, separators=(',', ': '))
 
     parents = ''
     for p in revision['parents']:
         parent_link = gen_revision_link(p)
         parents += parent_link + '<br/>'
 
     revision_data['parents'] = mark_safe(parents)
     revision_data['synthetic'] = revision['synthetic']
     revision_data['type'] = revision['type']
 
     return render(request, 'revision.html',
                   {'top_panel_visible': False,
                    'top_panel_collapsible': False,
                    'top_panel_text_left': 'SWH object: Revision',
                    'top_panel_text_right': 'Sha1 git: ' + sha1_git,
                    'swh_object_metadata': None,
                    'main_panel_visible': True,
                    'revision': revision_data})
 
 
 NB_LOG_ENTRIES = 20
 
 
 @browse_route(r'revision/(?P<sha1_git>[0-9a-f]+)/log/',
               view_name='browse-revision-log')
 def revision_log_browse(request, sha1_git):
     """
     Django view that produces an HTML display of the history
     log for a SWH revision identified by its id.
 
     The url that points to it is :http:get:`/browse/revision/(sha1_git)/log/`.
 
     Args:
         request: input django http request
         sha1_git: a SWH revision id
 
     Returns:
         The HMTL rendering of the revision history log.
     """ # noqa
     try:
         per_page = int(request.GET.get('per_page', NB_LOG_ENTRIES))
         revision_log = service.lookup_revision_log(sha1_git,
                                                    limit=per_page+1)
         revision_log = list(revision_log)
     except Exception as exc:
         return handle_view_exception(request, exc)
 
     revs_breadcrumb = request.GET.get('revs_breadcrumb', None)
 
     revision_log_display_data = prepare_revision_log_for_display(
         revision_log, per_page, revs_breadcrumb)
 
     prev_rev = revision_log_display_data['prev_rev']
     prev_revs_breadcrumb = revision_log_display_data['prev_revs_breadcrumb']
     prev_log_url = None
     if prev_rev:
         prev_log_url = \
             reverse('browse-revision-log',
                     kwargs={'sha1_git': prev_rev},
                     query_params={'revs_breadcrumb': prev_revs_breadcrumb,
                                   'per_page': per_page})
 
     next_rev = revision_log_display_data['next_rev']
     next_revs_breadcrumb = revision_log_display_data['next_revs_breadcrumb']
     next_log_url = None
     if next_rev:
         next_log_url = \
             reverse('browse-revision-log',
                     kwargs={'sha1_git': next_rev},
                     query_params={'revs_breadcrumb': next_revs_breadcrumb,
                                   'per_page': per_page})
 
     revision_log_data = revision_log_display_data['revision_log_data']
 
     for log in revision_log_data:
         log['directory'] = _gen_directory_link(log['directory'], 'Tree')
 
     return render(request, 'revision-log.html',
                   {'top_panel_visible': False,
                    'top_panel_collapsible': False,
                    'top_panel_text_left': 'SWH object: Revision history',
                    'top_panel_text_right': 'Sha1 git: ' + sha1_git,
                    'swh_object_metadata': None,
                    'main_panel_visible': True,
                    'revision_log': revision_log_data,
                    'next_log_url': next_log_url,
                    'prev_log_url': prev_log_url,
                    'breadcrumbs': None,
                    'branches': None,
                    'branch': None,
                    'top_right_link': None,
                    'top_right_link_text': None,
-                   'include_top_navigation': False})
+                   'include_top_navigation': False,
+                   'no_origin_context': True})
diff --git a/swh/web/templates/revision-log.html b/swh/web/templates/revision-log.html
index 040ac067..d1a3519a 100644
--- a/swh/web/templates/revision-log.html
+++ b/swh/web/templates/revision-log.html
@@ -1,62 +1,63 @@
 {% extends "browse.html" %}
 {% block title %}Revision Log{% endblock %}
 
 {% block swh-browse-main-panel-content %}
 
+{% if no_origin_context %}
 <div class="panel-heading">
   <div class="panel-title pull-left">
-      <h4>{{ top_panel_text_left }}</h4> 
+      <h4>{{ top_panel_text_left }}</h4>
   </div>
   <div class="panel-title pull-right">
     <h4>{{ top_panel_text_right }}</h4>
   </div>
   <div class="clearfix"></div>
-      
 </div>
+{% endif %}
 
 {% if include_top_navigation %}
 {% include "includes/top-navigation.html" %}
 {% endif %}
 
 <div class="table-responsive">
   <table class="table">
     <thead>
       <tr>
         <th>Author</th>
         <th>Revision</th>
         <th>Message</th>
         <th>Date</th>
         <th></th>
       </tr>
     </thead>
     <tbody>
         {% for log in revision_log %}
           <tr class="swh-revision-log-entry">
             <td>{{ log.author }}</td>
             <td>{{ log.revision }}</td>
             <td title="{{ log.message }}">{{ log.message_shorten }}</td>
             <td>{{ log.date }}</td>
             <td>{{ log.directory }}</td>
           </tr>
         {% endfor %}
     </tbody>
   </table>
 </div>
 {% endblock %}
 
 {% block swh-browse-after-panels %}
 
 <ul class="pager">
     {% if next_log_url %}
       <li><a href="{{ next_log_url }}">Newer</a></li>
     {% else %}
       <li class="disabled"><a>Newer</a></li>
     {% endif %}
     {% if prev_log_url %}
       <li><a href="{{ prev_log_url }}">Older</a></li>
     {% else %}
       <li class="disabled"><a>Older</a></li>
     {% endif %}
 </ul>
 
 {% endblock %}
diff --git a/swh/web/tests/api/views/test_content.py b/swh/web/tests/api/views/test_content.py
index 7cdcda51..67358cfe 100644
--- a/swh/web/tests/api/views/test_content.py
+++ b/swh/web/tests/api/views/test_content.py
@@ -1,731 +1,731 @@
 # Copyright (C) 2015-2017  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 nose.tools import istest
 from rest_framework.test import APITestCase
 from unittest.mock import patch, MagicMock
 
 from swh.web.tests.testbase import SWHWebTestBase
 
 
 class ContentApiTestCase(SWHWebTestBase, APITestCase):
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_filetype(self, mock_service):
         stub_filetype = {
             'accepted_media_type': 'application/xml',
             'encoding': 'ascii',
             'id': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
         }
         mock_service.lookup_content_filetype.return_value = stub_filetype
 
         # when
         rv = self.client.get(
             '/api/1/content/'
             'sha1_git:b04caf10e9535160d90e874b45aa426de762f19f/filetype/')
 
         # then
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'accepted_media_type': 'application/xml',
             'encoding': 'ascii',
             'id': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'content_url': '/api/1/content/'
             'sha1:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/',
         })
 
         mock_service.lookup_content_filetype.assert_called_once_with(
             'sha1_git:b04caf10e9535160d90e874b45aa426de762f19f')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_filetype_sha_not_found(self, mock_service):
         # given
         mock_service.lookup_content_filetype.return_value = None
 
         # when
         rv = self.client.get(
             '/api/1/content/sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03/'
             'filetype/')
 
         # then
         self.assertEquals(rv.status_code, 404)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'exception': 'NotFoundExc',
             'reason': 'No filetype information found for content '
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03.'
         })
 
         mock_service.lookup_content_filetype.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_language(self, mock_service):
         stub_language = {
             'lang': 'lisp',
             'id': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
         }
         mock_service.lookup_content_language.return_value = stub_language
 
         # when
         rv = self.client.get(
             '/api/1/content/'
             'sha1_git:b04caf10e9535160d90e874b45aa426de762f19f/language/')
 
         # then
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'lang': 'lisp',
             'id': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'content_url': '/api/1/content/'
             'sha1:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/',
         })
 
         mock_service.lookup_content_language.assert_called_once_with(
             'sha1_git:b04caf10e9535160d90e874b45aa426de762f19f')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_language_sha_not_found(self, mock_service):
         # given
         mock_service.lookup_content_language.return_value = None
 
         # when
         rv = self.client.get(
             '/api/1/content/sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03'
             '/language/')
 
         # then
         self.assertEquals(rv.status_code, 404)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'exception': 'NotFoundExc',
             'reason': 'No language information found for content '
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03.'
         })
 
         mock_service.lookup_content_language.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_symbol(self, mock_service):
         stub_ctag = [{
             'sha1': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'name': 'foobar',
             'kind': 'Haskell',
             'line': 10,
         }]
         mock_service.lookup_expression.return_value = stub_ctag
 
         # when
         rv = self.client.get('/api/1/content/symbol/foo/?last_sha1=sha1')
 
         # then
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, [{
             'sha1': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'name': 'foobar',
             'kind': 'Haskell',
             'line': 10,
             'content_url': '/api/1/content/'
             'sha1:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/',
             'data_url': '/api/1/content/'
             'sha1:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/raw/',
             'license_url': '/api/1/content/'
             'sha1:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/license/',
             'language_url': '/api/1/content/'
             'sha1:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/language/',
             'filetype_url': '/api/1/content/'
             'sha1:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/filetype/',
         }])
         self.assertFalse('Link' in rv)
 
         mock_service.lookup_expression.assert_called_once_with(
             'foo', 'sha1', 10)
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_symbol_2(self, mock_service):
         stub_ctag = [{
             'sha1': '12371b8614fcd89ccd17ca2b1d9e66c5b00a6456',
             'name': 'foobar',
             'kind': 'Haskell',
             'line': 10,
         }, {
             'sha1': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6678',
             'name': 'foo',
             'kind': 'Lisp',
             'line': 10,
         }]
         mock_service.lookup_expression.return_value = stub_ctag
 
         # when
         rv = self.client.get(
             '/api/1/content/symbol/foo/?last_sha1=prev-sha1&per_page=2')
 
         # then
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, stub_ctag)
         self.assertTrue(
             rv['Link'] ==  '</api/1/content/symbol/foo/?last_sha1=34571b8614fcd89ccd17ca2b1d9e66c5b00a6678&per_page=2>; rel="next"' or  # noqa
             rv['Link'] ==  '</api/1/content/symbol/foo/?per_page=2&last_sha1=34571b8614fcd89ccd17ca2b1d9e66c5b00a6678>; rel="next"'    # noqa
         )
         mock_service.lookup_expression.assert_called_once_with(
             'foo', 'prev-sha1', 2)
 
     @patch('swh.web.api.views.content.service')
     # @istest
     def api_content_symbol_3(self, mock_service):
         stub_ctag = [{
             'sha1': '67891b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'name': 'foo',
             'kind': 'variable',
             'line': 100,
         }]
         mock_service.lookup_expression.return_value = stub_ctag
 
         # when
         rv = self.client.get('/api/1/content/symbol/foo/')
 
         # then
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, [{
             'sha1': '67891b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'name': 'foo',
             'kind': 'variable',
             'line': 100,
             'content_url': '/api/1/content/'
             'sha1:67891b8614fcd89ccd17ca2b1d9e66c5b00a6d03/',
             'data_url': '/api/1/content/'
             'sha1:67891b8614fcd89ccd17ca2b1d9e66c5b00a6d03/raw/',
             'license_url': '/api/1/content/'
             'sha1:67891b8614fcd89ccd17ca2b1d9e66c5b00a6d03/license/',
             'language_url': '/api/1/content/'
             'sha1:67891b8614fcd89ccd17ca2b1d9e66c5b00a6d03/language/',
             'filetype_url': '/api/1/content/'
             'sha1:67891b8614fcd89ccd17ca2b1d9e66c5b00a6d03/filetype/',
         }])
         self.assertFalse(rv.has_header('Link'))
 
         mock_service.lookup_expression.assert_called_once_with('foo', None, 10)
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_symbol_not_found(self, mock_service):
         # given
         mock_service.lookup_expression.return_value = []
 
         # when
         rv = self.client.get('/api/1/content/symbol/bar/?last_sha1=hash')
 
         # then
         self.assertEquals(rv.status_code, 404)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'exception': 'NotFoundExc',
             'reason': 'No indexed raw content match expression \'bar\'.'
         })
         self.assertFalse('Link' in rv)
 
         mock_service.lookup_expression.assert_called_once_with(
             'bar', 'hash', 10)
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_ctags(self, mock_service):
         stub_ctags = {
             'id': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'ctags': []
         }
         mock_service.lookup_content_ctags.return_value = stub_ctags
 
         # when
         rv = self.client.get(
             '/api/1/content/'
             'sha1_git:b04caf10e9535160d90e874b45aa426de762f19f/ctags/')
 
         # then
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'id': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'ctags': [],
             'content_url': '/api/1/content/'
             'sha1:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/',
         })
 
         mock_service.lookup_content_ctags.assert_called_once_with(
             'sha1_git:b04caf10e9535160d90e874b45aa426de762f19f')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_license(self, mock_service):
         stub_license = {
             'licenses': ['No_license_found', 'Apache-2.0'],
             'id': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'tool_name': 'nomos',
         }
         mock_service.lookup_content_license.return_value = stub_license
 
         # when
         rv = self.client.get(
             '/api/1/content/'
             'sha1_git:b04caf10e9535160d90e874b45aa426de762f19f/license/')
 
         # then
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'licenses': ['No_license_found', 'Apache-2.0'],
             'id': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'tool_name': 'nomos',
             'content_url': '/api/1/content/'
             'sha1:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/',
         })
 
         mock_service.lookup_content_license.assert_called_once_with(
             'sha1_git:b04caf10e9535160d90e874b45aa426de762f19f')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_license_sha_not_found(self, mock_service):
         # given
         mock_service.lookup_content_license.return_value = None
 
         # when
         rv = self.client.get(
             '/api/1/content/sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03/'
             'license/')
 
         # then
         self.assertEquals(rv.status_code, 404)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'exception': 'NotFoundExc',
             'reason': 'No license information found for content '
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03.'
         })
 
         mock_service.lookup_content_license.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_provenance(self, mock_service):
         stub_provenances = [{
             'origin': 1,
             'visit': 2,
             'revision': 'b04caf10e9535160d90e874b45aa426de762f19f',
             'content': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'path': 'octavio-3.4.0/octave.html/doc_002dS_005fISREG.html'
         }]
         mock_service.lookup_content_provenance.return_value = stub_provenances
 
         # when
         rv = self.client.get(
             '/api/1/content/'
             'sha1_git:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/provenance/')
 
         # then
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, [{
             'origin': 1,
             'visit': 2,
             'origin_url': '/api/1/origin/1/',
             'origin_visits_url': '/api/1/origin/1/visits/',
             'origin_visit_url': '/api/1/origin/1/visit/2/',
             'revision': 'b04caf10e9535160d90e874b45aa426de762f19f',
             'revision_url': '/api/1/revision/'
                             'b04caf10e9535160d90e874b45aa426de762f19f/',
             'content': '34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
             'content_url': '/api/1/content/'
             'sha1_git:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03/',
             'path': 'octavio-3.4.0/octave.html/doc_002dS_005fISREG.html'
         }])
 
         mock_service.lookup_content_provenance.assert_called_once_with(
             'sha1_git:34571b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_provenance_sha_not_found(self, mock_service):
         # given
         mock_service.lookup_content_provenance.return_value = None
 
         # when
         rv = self.client.get(
             '/api/1/content/sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03/'
             'provenance/')
 
         # then
         self.assertEquals(rv.status_code, 404)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'exception': 'NotFoundExc',
             'reason': 'Content with sha1:40e71b8614fcd89ccd17ca2b1d9e6'
             '6c5b00a6d03 not found.'
         })
 
         mock_service.lookup_content_provenance.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
-    def test_api_content_metadata(self, mock_service):
+    def api_content_metadata(self, mock_service):
         # given
         mock_service.lookup_content.return_value = {
             'checksums': {
                 'blake2s256': '685395c5dc57cada459364f0946d3dd45bad5f'
                               'cbabc1048edb44380f1d31d0aa',
                 'sha1': '40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
                 'sha1_git': 'b4e8f472ffcb01a03875b26e462eb568739f6882',
                 'sha256': '83c0e67cc80f60caf1fcbec2d84b0ccd7968b3be47'
                           '35637006560cde9b067a4f',
             },
             'length': 17,
             'status': 'visible'
         }
 
         # when
         rv = self.client.get(
             '/api/1/content/sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03/')
 
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'checksums': {
                 'blake2s256': '685395c5dc57cada459364f0946d3dd45bad5f'
                               'cbabc1048edb44380f1d31d0aa',
                 'sha1': '40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03',
                 'sha1_git': 'b4e8f472ffcb01a03875b26e462eb568739f6882',
                 'sha256': '83c0e67cc80f60caf1fcbec2d84b0ccd7968b3be47'
                           '35637006560cde9b067a4f',
             },
             'data_url': '/api/1/content/'
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03/raw/',
             'filetype_url': '/api/1/content/'
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03/filetype/',
             'language_url': '/api/1/content/'
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03/language/',
             'license_url': '/api/1/content/'
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03/license/',
             'length': 17,
             'status': 'visible'
         })
 
         mock_service.lookup_content.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_not_found_as_json(self, mock_service):
         # given
         mock_service.lookup_content.return_value = None
         mock_service.lookup_content_provenance = MagicMock()
 
         # when
         rv = self.client.get(
             '/api/1/content/sha256:83c0e67cc80f60caf1fcbec2d84b0ccd7968b3'
             'be4735637006560c/')
 
         self.assertEquals(rv.status_code, 404)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'exception': 'NotFoundExc',
             'reason': 'Content with sha256:83c0e67cc80f60caf1fcbec2d84b0ccd79'
             '68b3be4735637006560c not found.'
         })
 
         mock_service.lookup_content.assert_called_once_with(
             'sha256:83c0e67cc80f60caf1fcbec2d84b0ccd7968b3'
             'be4735637006560c')
         mock_service.lookup_content_provenance.called = False
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_not_found_as_yaml(self, mock_service):
         # given
         mock_service.lookup_content.return_value = None
         mock_service.lookup_content_provenance = MagicMock()
 
         # when
         rv = self.client.get(
             '/api/1/content/sha256:83c0e67cc80f60caf1fcbec2d84b0ccd7968b3'
             'be4735637006560c/',
             HTTP_ACCEPT='application/yaml')
 
         self.assertEquals(rv.status_code, 404)
         self.assertTrue('application/yaml' in rv['Content-Type'])
 
         self.assertEquals(rv.data, {
             'exception': 'NotFoundExc',
             'reason': 'Content with sha256:83c0e67cc80f60caf1fcbec2d84b0ccd79'
             '68b3be4735637006560c not found.'
         })
 
         mock_service.lookup_content.assert_called_once_with(
             'sha256:83c0e67cc80f60caf1fcbec2d84b0ccd7968b3'
             'be4735637006560c')
         mock_service.lookup_content_provenance.called = False
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_raw_ko_not_found(self, mock_service):
         # given
         mock_service.lookup_content_raw.return_value = None
 
         # when
         rv = self.client.get(
             '/api/1/content/sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03'
             '/raw/')
 
         self.assertEquals(rv.status_code, 404)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'exception': 'NotFoundExc',
             'reason': 'Content sha1:40e71b8614fcd89ccd17ca2b1d9e6'
             '6c5b00a6d03 is not found.'
         })
 
         mock_service.lookup_content_raw.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_raw_text(self, mock_service):
         # given
         stub_content = {'data': b'some content data'}
         mock_service.lookup_content_raw.return_value = stub_content
         mock_service.lookup_content_filetype.return_value = {
             'mimetype': 'text/html'
         }
 
         # when
         rv = self.client.get(
             '/api/1/content/sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03'
             '/raw/')
 
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/octet-stream')
         self.assertEquals(
             rv['Content-disposition'],
             'attachment; filename=content_sha1_'
             '40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03_raw')
         self.assertEquals(
             rv['Content-Type'], 'application/octet-stream')
         self.assertEquals(rv.content, stub_content['data'])
 
         mock_service.lookup_content_raw.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
         mock_service.lookup_content_filetype.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_raw_text_with_filename(self, mock_service):
         # given
         stub_content = {'data': b'some content data'}
         mock_service.lookup_content_raw.return_value = stub_content
         mock_service.lookup_content_filetype.return_value = {
             'mimetype': 'text/html'
         }
 
         # when
         rv = self.client.get(
             '/api/1/content/sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03'
             '/raw/?filename=filename.txt')
 
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/octet-stream')
         self.assertEquals(
             rv['Content-disposition'],
             'attachment; filename=filename.txt')
         self.assertEquals(
             rv['Content-Type'], 'application/octet-stream')
         self.assertEquals(rv.content, stub_content['data'])
 
         mock_service.lookup_content_raw.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
         mock_service.lookup_content_filetype.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_raw_no_accepted_media_type_text_is_not_available_for_download( # noqa
             self, mock_service):
         # given
         stub_content = {'data': b'some content data'}
         mock_service.lookup_content_raw.return_value = stub_content
         mock_service.lookup_content_filetype.return_value = {
             'mimetype': 'application/octet-stream'
         }
 
         # when
         rv = self.client.get(
             '/api/1/content/sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03'
             '/raw/')
 
         self.assertEquals(rv.status_code, 403)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'exception': 'ForbiddenExc',
             'reason': 'Only textual content is available for download. '
                       'Actual content mimetype is application/octet-stream.'
         })
 
         mock_service.lookup_content_raw.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
         mock_service.lookup_content_filetype.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_content_raw_no_accepted_media_type_found_so_not_available_for_download( # noqa
             self, mock_service):
         # given
         stub_content = {'data': b'some content data'}
         mock_service.lookup_content_raw.return_value = stub_content
         mock_service.lookup_content_filetype.return_value = None
 
         # when
         rv = self.client.get(
             '/api/1/content/sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03'
             '/raw/')
 
         self.assertEquals(rv.status_code, 404)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, {
             'exception': 'NotFoundExc',
             'reason': 'Content sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03 '
                       'is not available for download.'
         })
 
         mock_service.lookup_content_raw.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
         mock_service.lookup_content_filetype.assert_called_once_with(
             'sha1:40e71b8614fcd89ccd17ca2b1d9e66c5b00a6d03')
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_check_content_known(self, mock_service):
         # given
         mock_service.lookup_multiple_hashes.return_value = [
             {'found': True,
              'filename': None,
              'sha1': 'sha1:blah'}
         ]
 
         expected_result = {
             'search_stats': {'nbfiles': 1, 'pct': 100},
             'search_res': [{'sha1': 'sha1:blah',
                             'found': True}]
         }
 
         # when
         rv = self.client.get('/api/1/content/known/sha1:blah/')
 
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, expected_result)
         mock_service.lookup_multiple_hashes.assert_called_once_with(
             [{'filename': None, 'sha1': 'sha1:blah'}])
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_check_content_known_as_yaml(self, mock_service):
         # given
         mock_service.lookup_multiple_hashes.return_value = [
             {'found': True,
              'filename': None,
              'sha1': 'sha1:halb'},
             {'found': False,
              'filename': None,
              'sha1': 'sha1_git:hello'}
         ]
 
         expected_result = {
             'search_stats': {'nbfiles': 2, 'pct': 50},
             'search_res': [{'sha1': 'sha1:halb',
                             'found': True},
                            {'sha1': 'sha1_git:hello',
                             'found': False}]
         }
 
         # when
         rv = self.client.get('/api/1/content/known/sha1:halb,sha1_git:hello/',
                              HTTP_ACCEPT='application/yaml')
 
         self.assertEquals(rv.status_code, 200)
         self.assertTrue('application/yaml' in rv['Content-Type'])
         self.assertEquals(rv.data, expected_result)
 
         mock_service.lookup_multiple_hashes.assert_called_once_with(
             [{'filename': None, 'sha1': 'sha1:halb'},
              {'filename': None, 'sha1': 'sha1_git:hello'}])
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_check_content_known_post_as_yaml(self, mock_service):
         # given
         stub_result = [{'sha1': '7e62b1fe10c88a3eddbba930b156bee2956b2435',
                         'found': True},
                        {'filename': 'filepath',
                         'sha1': '8e62b1fe10c88a3eddbba930b156bee2956b2435',
                         'found': True},
                        {'filename': 'filename',
                         'sha1': '64025b5d1520c615061842a6ce6a456cad962a3f',
                         'found': False}]
         mock_service.lookup_multiple_hashes.return_value = stub_result
 
         expected_result = {
             'search_stats': {'nbfiles': 3, 'pct': 2/3 * 100},
             'search_res': stub_result
         }
 
         # when
         rv = self.client.post(
             '/api/1/content/known/search/',
             data=dict(
                 q='7e62b1fe10c88a3eddbba930b156bee2956b2435',
                 filepath='8e62b1fe10c88a3eddbba930b156bee2956b2435',
                 filename='64025b5d1520c615061842a6ce6a456cad962a3f'),
             HTTP_ACCEPT='application/yaml'
         )
 
         self.assertEquals(rv.status_code, 200)
         self.assertTrue('application/yaml' in rv['Content-Type'])
         self.assertEquals(rv.data, expected_result)
 
     @patch('swh.web.api.views.content.service')
     @istest
     def api_check_content_known_not_found(self, mock_service):
         # given
         stub_result = [{'sha1': 'sha1:halb',
                         'found': False}]
         mock_service.lookup_multiple_hashes.return_value = stub_result
 
         expected_result = {
             'search_stats': {'nbfiles': 1, 'pct': 0.0},
             'search_res': stub_result
         }
 
         # when
         rv = self.client.get('/api/1/content/known/sha1:halb/')
 
         self.assertEquals(rv.status_code, 200)
         self.assertEquals(rv['Content-Type'], 'application/json')
         self.assertEquals(rv.data, expected_result)
 
         mock_service.lookup_multiple_hashes.assert_called_once_with(
             [{'filename': None, 'sha1': 'sha1:halb'}])
diff --git a/swh/web/tests/browse/test_utils.py b/swh/web/tests/browse/test_utils.py
index d6be5690..833956f2 100644
--- a/swh/web/tests/browse/test_utils.py
+++ b/swh/web/tests/browse/test_utils.py
@@ -1,299 +1,373 @@
 # Copyright (C) 2017  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import unittest
 
 from unittest.mock import patch
 from nose.tools import istest
 
 
 from swh.web.browse import utils
 from swh.web.common.utils import reverse
 from swh.web.tests.testbase import SWHWebTestBase
 
 from .views.data.revision_test_data import revision_history_log_test
 
 
 class SwhBrowseUtilsTestCase(SWHWebTestBase, unittest.TestCase):
 
     @istest
     def gen_path_info(self):
         input_path = '/home/user/swh-environment/swh-web/'
         expected_result = [
             {'name': 'home', 'path': 'home'},
             {'name': 'user', 'path': 'home/user'},
             {'name': 'swh-environment', 'path': 'home/user/swh-environment'},
             {'name': 'swh-web', 'path': 'home/user/swh-environment/swh-web'}
         ]
         path_info = utils.gen_path_info(input_path)
         self.assertEquals(path_info, expected_result)
 
         input_path = 'home/user/swh-environment/swh-web'
         path_info = utils.gen_path_info(input_path)
         self.assertEquals(path_info, expected_result)
 
     @istest
     def get_mimetype_and_encoding_for_content(self):
         text = b'Hello world!'
         self.assertEqual(utils.get_mimetype_and_encoding_for_content(text),
                          ('text/plain', 'us-ascii'))
 
     @patch('swh.web.browse.utils.service')
     @istest
     def get_origin_visits(self, mock_service):
         mock_service.MAX_LIMIT = 2
 
         def _lookup_origin_visits(*args, **kwargs):
             if kwargs['last_visit'] is None:
                 return [{'visit': 1}, {'visit': 2}]
             else:
                 return [{'visit': 3}]
 
         mock_service.lookup_origin_visits.side_effect = _lookup_origin_visits
 
         origin_visits = utils.get_origin_visits(1)
 
         self.assertEqual(len(origin_visits), 3)
 
+    @patch('swh.web.browse.utils.get_origin_visits')
+    @istest
+    def get_origin_visit(self, mock_origin_visits):
+        origin_id = 2
+        visits = \
+            [{'status': 'full',
+              'date': '2015-07-09T21:09:24+00:00',
+              'visit': 1,
+              'origin': origin_id
+              },
+             {'status': 'full',
+              'date': '2016-02-23T18:05:23.312045+00:00',
+              'visit': 2,
+              'origin': origin_id
+              },
+             {'status': 'full',
+              'date': '2016-03-28T01:35:06.554111+00:00',
+              'visit': 3,
+              'origin': origin_id
+              },
+             {'status': 'full',
+              'date': '2016-06-18T01:22:24.808485+00:00',
+              'visit': 4,
+              'origin': origin_id
+              },
+             {'status': 'full',
+              'date': '2016-08-14T12:10:00.536702+00:00',
+              'visit': 5,
+              'origin': origin_id
+              }]
+        mock_origin_visits.return_value = visits
+
+        visit = utils.get_origin_visit(origin_id, visit_id=12)
+        self.assertEqual(visit, None)
+
+        visit = utils.get_origin_visit(origin_id, visit_id=2)
+        self.assertEqual(visit, visits[1])
+
+        visit = utils.get_origin_visit(
+            origin_id, visit_ts='2016-02-23T18:05:23.312045+00:00')
+        self.assertEqual(visit, visits[1])
+
+        visit = utils.get_origin_visit(
+            origin_id, visit_ts='2016-02-20')
+        self.assertEqual(visit, visits[1])
+
+        visit = utils.get_origin_visit(
+            origin_id, visit_ts='2016-06-18T01:22')
+        self.assertEqual(visit, visits[3])
+
+        visit = utils.get_origin_visit(
+            origin_id, visit_ts='2016-06-18 01:22')
+        self.assertEqual(visit, visits[3])
+
+        visit = utils.get_origin_visit(
+            origin_id, visit_ts=1466208000)
+        self.assertEqual(visit, visits[3])
+
+        visit = utils.get_origin_visit(
+            origin_id, visit_ts='2014-01-01')
+        self.assertEqual(visit, visits[0])
+
+        visit = utils.get_origin_visit(
+            origin_id, visit_ts='2018-01-01')
+        self.assertEqual(visit, visits[-1])
+
     @patch('swh.web.browse.utils.service')
+    @patch('swh.web.browse.utils.get_origin_visit')
     @istest
-    def test_get_origin_visit_branches(self, mock_service):
+    def get_origin_visit_branches(self, mock_get_origin_visit,
+                                  mock_service):
+
+        mock_get_origin_visit.return_value = \
+            {'status': 'full',
+             'date': '2015-08-04T22:26:14.804009+00:00',
+             'visit': 1,
+             'origin': 1}
 
         mock_service.lookup_origin_visit.return_value = \
             {'date': '2015-08-04T22:26:14.804009+00:00',
              'metadata': {},
              'occurrences': {
                  'refs/heads/master': {
                      'target': '9fbd21adbac36be869514e82e2e98505dc47219c',
                      'target_type': 'revision',
                      'target_url': '/api/1/revision/9fbd21adbac36be869514e82e2e98505dc47219c/' # noqa
                  },
                  'refs/tags/0.10.0': {
                      'target': '6072557b6c10cd9a21145781e26ad1f978ed14b9',
                      'target_type': 'revision',
                      'target_url': '/api/1/revision/6072557b6c10cd9a21145781e26ad1f978ed14b9/' # noqa
                  },
                  'refs/tags/0.10.1': {
                      'target': 'ecc003b43433e5b46511157598e4857a761007bf',
                      'target_type': 'revision',
                      'target_url': '/api/1/revision/ecc003b43433e5b46511157598e4857a761007bf/' # noqa
                  }
              },
              'origin': 1,
              'origin_url': '/api/1/origin/1/',
              'status': 'full',
              'visit': 1}
 
         mock_service.lookup_revision_multiple.return_value = \
             [{'directory': '828da2b80e41aa958b2c98526f4a1d2cc7d298b7'},
              {'directory': '2df4cd84ecc65b50b1d5318d3727e02a39b8a4cf'},
              {'directory': '28ba64f97ef709e54838ae482c2da2619a74a0bd'}]
 
         expected_result = [
             {'name': 'refs/heads/master',
              'revision': '9fbd21adbac36be869514e82e2e98505dc47219c',
              'directory': '828da2b80e41aa958b2c98526f4a1d2cc7d298b7'},
             {'name': 'refs/tags/0.10.0',
              'revision': '6072557b6c10cd9a21145781e26ad1f978ed14b9',
              'directory': '2df4cd84ecc65b50b1d5318d3727e02a39b8a4cf'},
             {'name': 'refs/tags/0.10.1',
              'revision': 'ecc003b43433e5b46511157598e4857a761007bf',
              'directory': '28ba64f97ef709e54838ae482c2da2619a74a0bd'}
         ]
 
         origin_visit_branches = utils.get_origin_visit_branches(1, 1)
 
         self.assertEqual(origin_visit_branches, expected_result)
 
     @istest
     def gen_link(self):
         self.assertEqual(utils.gen_link('https://www.softwareheritage.org/', 'SWH'), # noqa
                          '<a href="https://www.softwareheritage.org/">SWH</a>')
 
     @istest
     def gen_person_link(self):
         person_id = 8221896
         person_name = 'Antoine Lambert'
         person_url = reverse('browse-person', kwargs={'person_id': person_id})
 
         self.assertEqual(utils.gen_person_link(person_id, person_name),
                          '<a href="%s">%s</a>' % (person_url, person_name))
 
     @istest
     def gen_revision_link(self):
         revision_id = '28a0bc4120d38a394499382ba21d6965a67a3703'
         revision_url = reverse('browse-revision',
                                kwargs={'sha1_git': revision_id})
 
         self.assertEqual(utils.gen_revision_link(revision_id),
                          '<a href="%s">%s</a>' % (revision_url, revision_id))
         self.assertEqual(utils.gen_revision_link(revision_id, shorten_id=True),
                          '<a href="%s">%s</a>' % (revision_url, revision_id[:7])) # noqa
 
     @istest
-    def test_prepare_revision_log_for_display_no_contex(self):
+    def prepare_revision_log_for_display_no_contex(self):
         per_page = 10
         first_page_logs_data = revision_history_log_test[:per_page+1]
         second_page_logs_data = revision_history_log_test[per_page:2*per_page+1] # noqa
         third_page_logs_data = revision_history_log_test[2*per_page:3*per_page+1] # noqa
         last_page_logs_data = revision_history_log_test[3*per_page:3*per_page+5] # noqa
 
         revision_log_display_data = utils.prepare_revision_log_for_display(
             first_page_logs_data, per_page, None)
 
         self.assertEqual(revision_log_display_data['revision_log_data'],
                          utils._format_log_entries(first_page_logs_data,
                                                    per_page))
 
         self.assertEqual(revision_log_display_data['prev_rev'],
                          first_page_logs_data[-1]['id'])
 
         self.assertEqual(revision_log_display_data['prev_revs_breadcrumb'],
                          first_page_logs_data[0]['id'])
 
         self.assertEqual(revision_log_display_data['next_rev'], None)
         self.assertEqual(revision_log_display_data['next_revs_breadcrumb'],
                          None)
 
         old_prev_revs_bc = str(revision_log_display_data['prev_revs_breadcrumb']) # noqa
 
         revision_log_display_data = utils.prepare_revision_log_for_display(
             second_page_logs_data, per_page, old_prev_revs_bc)
 
         self.assertEqual(revision_log_display_data['revision_log_data'],
                          utils._format_log_entries(second_page_logs_data,
                                                    per_page))
 
         self.assertEqual(revision_log_display_data['prev_rev'],
                          second_page_logs_data[-1]['id'])
 
         self.assertEqual(revision_log_display_data['prev_revs_breadcrumb'],
                          old_prev_revs_bc + '/' + second_page_logs_data[0]['id']) # noqa
 
         self.assertEqual(revision_log_display_data['next_rev'],
                          old_prev_revs_bc)
         self.assertEqual(revision_log_display_data['next_revs_breadcrumb'],
                          None)
 
         old_prev_revs_bc = str(revision_log_display_data['prev_revs_breadcrumb']) # noqa
 
         revision_log_display_data = utils.prepare_revision_log_for_display(
             third_page_logs_data, per_page, old_prev_revs_bc)
 
         self.assertEqual(revision_log_display_data['revision_log_data'],
                          utils._format_log_entries(third_page_logs_data, per_page)) # noqa
 
         self.assertEqual(revision_log_display_data['prev_rev'],
                          third_page_logs_data[-1]['id'])
 
         self.assertEqual(revision_log_display_data['prev_revs_breadcrumb'],
                          old_prev_revs_bc + '/' + third_page_logs_data[0]['id']) # noqa
 
         self.assertEqual(revision_log_display_data['next_rev'],
                          old_prev_revs_bc.split('/')[-1])
 
         self.assertEqual(revision_log_display_data['next_revs_breadcrumb'],
                          '/'.join(old_prev_revs_bc.split('/')[:-1]))
 
         old_prev_revs_bc = str(revision_log_display_data['prev_revs_breadcrumb']) # noqa
 
         revision_log_display_data = utils.prepare_revision_log_for_display(
             last_page_logs_data, per_page, old_prev_revs_bc)
 
         self.assertEqual(revision_log_display_data['revision_log_data'],
                          utils._format_log_entries(last_page_logs_data, per_page)) # noqa
 
         self.assertEqual(revision_log_display_data['prev_rev'],
                          None)
 
         self.assertEqual(revision_log_display_data['prev_revs_breadcrumb'],
                          None) # noqa
 
         self.assertEqual(revision_log_display_data['next_rev'], old_prev_revs_bc.split('/')[-1]) # noqa
         self.assertEqual(revision_log_display_data['next_revs_breadcrumb'],
                          '/'.join(old_prev_revs_bc.split('/')[:-1]))
 
     @istest
-    def test_prepare_revision_log_for_display_origin_contex(self):
+    def prepare_revision_log_for_display_origin_contex(self):
         per_page = 10
         first_page_logs_data = revision_history_log_test[:per_page+1]
         second_page_logs_data = revision_history_log_test[per_page:2*per_page+1] # noqa
         third_page_logs_data = revision_history_log_test[2*per_page:3*per_page+1] # noqa
         last_page_logs_data = revision_history_log_test[3*per_page:3*per_page+5] # noqa
 
         revision_log_display_data = utils.prepare_revision_log_for_display(
             first_page_logs_data, per_page, None, origin_context=True)
 
         self.assertEqual(revision_log_display_data['revision_log_data'],
                          utils._format_log_entries(first_page_logs_data,
                                                    per_page))
 
         self.assertEqual(revision_log_display_data['prev_rev'],
                          first_page_logs_data[-1]['id'])
 
         self.assertEqual(revision_log_display_data['prev_revs_breadcrumb'],
                          first_page_logs_data[-1]['id'])
 
         self.assertEqual(revision_log_display_data['next_rev'], None)
         self.assertEqual(revision_log_display_data['next_revs_breadcrumb'],
                          None)
 
         old_prev_revs_bc = str(revision_log_display_data['prev_revs_breadcrumb']) # noqa
 
         revision_log_display_data = utils.prepare_revision_log_for_display(
             second_page_logs_data, per_page, old_prev_revs_bc, origin_context=True) # noqa
 
         self.assertEqual(revision_log_display_data['revision_log_data'],
                          utils._format_log_entries(second_page_logs_data,
                                                    per_page))
 
         self.assertEqual(revision_log_display_data['prev_rev'],
                          second_page_logs_data[-1]['id'])
 
         self.assertEqual(revision_log_display_data['prev_revs_breadcrumb'],
                          old_prev_revs_bc + '/' + second_page_logs_data[-1]['id']) # noqa
 
         self.assertEqual(revision_log_display_data['next_rev'],
                          old_prev_revs_bc)
         self.assertEqual(revision_log_display_data['next_revs_breadcrumb'],
                          None)
 
         old_prev_revs_bc = str(revision_log_display_data['prev_revs_breadcrumb']) # noqa
 
         revision_log_display_data = utils.prepare_revision_log_for_display(
             third_page_logs_data, per_page, old_prev_revs_bc, origin_context=True) # noqa
 
         self.assertEqual(revision_log_display_data['revision_log_data'],
                          utils._format_log_entries(third_page_logs_data, per_page)) # noqa
 
         self.assertEqual(revision_log_display_data['prev_rev'],
                          third_page_logs_data[-1]['id'])
 
         self.assertEqual(revision_log_display_data['prev_revs_breadcrumb'],
                          old_prev_revs_bc + '/' + third_page_logs_data[-1]['id']) # noqa
 
         self.assertEqual(revision_log_display_data['next_rev'],
                          old_prev_revs_bc.split('/')[-1])
 
         self.assertEqual(revision_log_display_data['next_revs_breadcrumb'],
                          '/'.join(old_prev_revs_bc.split('/')[:-1]))
 
         old_prev_revs_bc = str(revision_log_display_data['prev_revs_breadcrumb']) # noqa
 
         revision_log_display_data = utils.prepare_revision_log_for_display(
             last_page_logs_data, per_page, old_prev_revs_bc, origin_context=True) # noqa
 
         self.assertEqual(revision_log_display_data['revision_log_data'],
                          utils._format_log_entries(last_page_logs_data, per_page)) # noqa
 
         self.assertEqual(revision_log_display_data['prev_rev'],
                          None)
 
         self.assertEqual(revision_log_display_data['prev_revs_breadcrumb'],
                          None) # noqa
 
         self.assertEqual(revision_log_display_data['next_rev'], old_prev_revs_bc.split('/')[-1]) # noqa
         self.assertEqual(revision_log_display_data['next_revs_breadcrumb'],
                          '/'.join(old_prev_revs_bc.split('/')[:-1]))
diff --git a/swh/web/tests/browse/views/test_content.py b/swh/web/tests/browse/views/test_content.py
index cd6c3aa1..19913fa4 100644
--- a/swh/web/tests/browse/views/test_content.py
+++ b/swh/web/tests/browse/views/test_content.py
@@ -1,246 +1,246 @@
 # Copyright (C) 2017  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import base64
 
 from unittest.mock import patch
 from nose.tools import istest
 
 from django.test import TestCase
 from django.utils.html import escape
 from django.utils.encoding import DjangoUnicodeDecodeError
 
 from swh.web.common.exc import NotFoundExc
 from swh.web.common.utils import reverse
 from swh.web.browse.utils import gen_path_info
 from swh.web.tests.testbase import SWHWebTestBase
 
 from .data.content_test_data import (
     stub_content_text_data,
     stub_content_text_path_with_root_dir,
     stub_content_bin_data,
     stub_content_bin_filename,
     stub_content_text_no_highlight_data,
     non_utf8_encoded_content_data,
     non_utf8_encoded_content,
     non_utf8_encoding
 )
 
 
 class SwhBrowseContentTest(SWHWebTestBase, TestCase):
 
     @patch('swh.web.browse.views.content.request_content')
     @istest
     def content_view_text(self, mock_request_content):
         mock_request_content.return_value = stub_content_text_data
 
         url = reverse('browse-content',
                       kwargs={'query_string': stub_content_text_data['checksums']['sha1']}) # noqa
 
         url_raw = reverse('browse-content-raw',
                           kwargs={'query_string': stub_content_text_data['checksums']['sha1']}) # noqa
 
         resp = self.client.get(url)
 
         self.assertEquals(resp.status_code, 200)
         self.assertTemplateUsed('content.html')
 
         self.assertContains(resp, '<code class="cpp">')
         self.assertContains(resp, escape(stub_content_text_data['raw_data']))
         self.assertContains(resp, url_raw)
 
     @patch('swh.web.browse.views.content.request_content')
     @istest
     def content_view_text_no_highlight(self, mock_request_content):
         mock_request_content.return_value = stub_content_text_no_highlight_data
 
         url = reverse('browse-content',
                       kwargs={'query_string': stub_content_text_no_highlight_data['checksums']['sha1']}) # noqa
 
         url_raw = reverse('browse-content-raw',
                           kwargs={'query_string': stub_content_text_no_highlight_data['checksums']['sha1']}) # noqa
 
         resp = self.client.get(url)
 
         self.assertEquals(resp.status_code, 200)
         self.assertTemplateUsed('content.html')
 
         self.assertContains(resp, '<code class="nohighlight-swh">')
         self.assertContains(resp, escape(stub_content_text_no_highlight_data['raw_data'])) # noqa
         self.assertContains(resp, url_raw)
 
     @patch('swh.web.browse.utils.service')
     @istest
     def content_view_no_utf8_text(self, mock_service):
         mock_service.lookup_content.return_value = \
             non_utf8_encoded_content_data
 
         mock_service.lookup_content_raw.return_value = \
             {'data': non_utf8_encoded_content}
 
         mock_service.lookup_content_filetype.return_value = None
         mock_service.lookup_content_language.return_value = None
         mock_service.lookup_content_license.return_value = None
 
         url = reverse('browse-content',
                       kwargs={'query_string': non_utf8_encoded_content_data['checksums']['sha1']}) # noqa
 
         try:
             resp = self.client.get(url)
             self.assertEquals(resp.status_code, 200)
             self.assertTemplateUsed('content.html')
             self.assertContains(resp, escape(non_utf8_encoded_content.decode(non_utf8_encoding).encode('utf-8'))) # noqa
         except DjangoUnicodeDecodeError:
             self.fail('Textual content is not encoded in utf-8')
 
     @patch('swh.web.browse.views.content.request_content')
     @istest
     def content_view_image(self, mock_request_content):
 
         mime_type = 'image/png'
         mock_request_content.return_value = stub_content_bin_data
 
         url = reverse('browse-content',
                       kwargs={'query_string': stub_content_bin_data['checksums']['sha1']}) # noqa
 
         url_raw = reverse('browse-content-raw',
                           kwargs={'query_string': stub_content_bin_data['checksums']['sha1']}) # noqa
 
         resp = self.client.get(url)
 
         self.assertEquals(resp.status_code, 200)
         self.assertTemplateUsed('content.html')
 
         pngEncoded = base64.b64encode(stub_content_bin_data['raw_data']) \
                            .decode('utf-8')
 
         self.assertContains(resp, '<img src="data:%s;base64,%s"/>'
                                   % (mime_type, pngEncoded))
         self.assertContains(resp, url_raw)
 
     @patch('swh.web.browse.views.content.request_content')
     @istest
     def content_view_with_path(self, mock_request_content):
         mock_request_content.return_value = stub_content_text_data
 
         url = reverse('browse-content',
                       kwargs={'query_string': stub_content_text_data['checksums']['sha1']}, # noqa
                       query_params={'path': stub_content_text_path_with_root_dir}) # noqa
 
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 200)
         self.assertTemplateUsed('content.html')
 
         self.assertContains(resp, '<code class="cpp">')
         self.assertContains(resp, escape(stub_content_text_data['raw_data']))
 
         split_path = stub_content_text_path_with_root_dir.split('/')
 
         root_dir_sha1 = split_path[0]
         filename = split_path[-1]
         path = stub_content_text_path_with_root_dir \
             .replace(root_dir_sha1 + '/', '') \
             .replace(filename, '')
 
         path_info = gen_path_info(path)
 
         root_dir_url = reverse('browse-directory',
                                kwargs={'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',
                               kwargs={'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',
                           kwargs={'query_string': stub_content_text_data['checksums']['sha1']}, # noqa
                           query_params={'filename': filename})
         self.assertContains(resp, url_raw)
 
     @patch('swh.web.browse.views.content.request_content')
     @istest
-    def test_content_raw_text(self, mock_request_content):
+    def content_raw_text(self, mock_request_content):
         mock_request_content.return_value = stub_content_text_data
 
         url = reverse('browse-content-raw',
                       kwargs={'query_string': stub_content_text_data['checksums']['sha1']}) # noqa
 
         resp = self.client.get(url)
 
         self.assertEquals(resp.status_code, 200)
         self.assertEqual(resp['Content-Type'], 'text/plain')
         self.assertEqual(resp['Content-disposition'],
                          'filename=%s_%s' % ('sha1', stub_content_text_data['checksums']['sha1'])) # noqa
         self.assertEqual(resp.content, stub_content_text_data['raw_data'])
 
         filename = stub_content_text_path_with_root_dir.split('/')[-1]
 
         url = reverse('browse-content-raw',
                       kwargs={'query_string': stub_content_text_data['checksums']['sha1']}, # noqa
                       query_params={'filename': filename})
 
         resp = self.client.get(url)
 
         self.assertEquals(resp.status_code, 200)
         self.assertEqual(resp['Content-Type'], 'text/plain')
         self.assertEqual(resp['Content-disposition'],
                          'filename=%s' % filename)
         self.assertEqual(resp.content, stub_content_text_data['raw_data'])
 
     @patch('swh.web.browse.views.content.request_content')
     @istest
     def content_raw_bin(self, mock_request_content):
         mock_request_content.return_value = stub_content_bin_data
 
         url = reverse('browse-content-raw',
                       kwargs={'query_string': stub_content_bin_data['checksums']['sha1']}) # noqa
 
         resp = self.client.get(url)
 
         self.assertEquals(resp.status_code, 200)
         self.assertEqual(resp['Content-Type'], 'application/octet-stream')
         self.assertEqual(resp['Content-disposition'],
                          'attachment; filename=%s_%s' %
                          ('sha1', stub_content_bin_data['checksums']['sha1']))
         self.assertEqual(resp.content, stub_content_bin_data['raw_data'])
 
         url = reverse('browse-content-raw',
                       kwargs={'query_string': stub_content_bin_data['checksums']['sha1']}, # noqa
                       query_params={'filename': stub_content_bin_filename})
 
         resp = self.client.get(url)
 
         self.assertEquals(resp.status_code, 200)
         self.assertEqual(resp['Content-Type'], 'application/octet-stream')
         self.assertEqual(resp['Content-disposition'],
                          'attachment; filename=%s' % stub_content_bin_filename)
         self.assertEqual(resp.content, stub_content_bin_data['raw_data'])
 
     @patch('swh.web.browse.views.content.request_content')
     @istest
     def content_request_errors(self, mock_request_content):
 
         url = reverse('browse-content', kwargs={'query_string': '123456'})
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 400)
         self.assertTemplateUsed('error.html')
 
         mock_request_content.side_effect = NotFoundExc('content not found')
 
         url = reverse('browse-content',
                       kwargs={'query_string': stub_content_text_data['checksums']['sha1']}) # noqa
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
diff --git a/swh/web/tests/browse/views/test_origin.py b/swh/web/tests/browse/views/test_origin.py
index 6f0d749c..a7e0ef20 100644
--- a/swh/web/tests/browse/views/test_origin.py
+++ b/swh/web/tests/browse/views/test_origin.py
@@ -1,500 +1,512 @@
 # Copyright (C) 2017  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from unittest.mock import patch
 from nose.tools import istest, nottest
 
 from django.test import TestCase
 from django.utils.html import escape
 
 from swh.web.common.exc import NotFoundExc
 from swh.web.common.utils import reverse
 from swh.web.tests.testbase import SWHWebTestBase
 
 from .data.origin_test_data import (
     origin_info_test_data,
     origin_visits_test_data,
     stub_content_origin_id, stub_content_origin_visit_id,
     stub_content_origin_visit_unix_ts, stub_content_origin_visit_iso_date,
     stub_content_origin_branch,
     stub_content_origin_visits, stub_content_origin_branches,
     stub_origin_id, stub_visit_id,
     stub_origin_visits, stub_origin_branches,
     stub_origin_root_directory_entries, stub_origin_master_branch,
     stub_origin_root_directory_sha1, stub_origin_sub_directory_path,
     stub_origin_sub_directory_entries, stub_visit_unix_ts, stub_visit_iso_date
 )
 
 from .data.content_test_data import (
     stub_content_root_dir,
     stub_content_text_data,
     stub_content_text_path
 )
 
 from swh.web.browse.utils import (
     gen_path_info
 )
 
 
 class SwhBrowseOriginTest(SWHWebTestBase, TestCase):
 
     @patch('swh.web.browse.views.origin.get_origin_visits')
     @patch('swh.web.browse.views.origin.service')
     @istest
-    def test_origin_browse(self, mock_service, mock_get_origin_visits):
+    def origin_browse(self, mock_service, mock_get_origin_visits):
         mock_service.lookup_origin.return_value = origin_info_test_data
         mock_get_origin_visits.return_value = origin_visits_test_data
 
         url = reverse('browse-origin',
                       kwargs={'origin_id': origin_info_test_data['id']})
         resp = self.client.get(url)
 
         self.assertEquals(resp.status_code, 200)
         self.assertTemplateUsed('origin.html')
         self.assertContains(resp, '<td>%s</td>' % origin_info_test_data['id'])
         self.assertContains(resp, '<pre>%s</pre>' % origin_info_test_data['type']) # noqa
         self.assertContains(resp, '<pre><a href="%s">%s</a></pre>' %
                                   (origin_info_test_data['url'],
                                    origin_info_test_data['url']))
 
         self.assertContains(resp, '<tr class="swh-origin-visit">',
                             count=len(origin_visits_test_data))
 
         for visit in origin_visits_test_data:
             browse_url = reverse('browse-origin-directory',
                                  kwargs={'origin_id': visit['origin'],
                                          'visit_id': visit['visit']})
             self.assertContains(resp, '<td><a href="%s">%s</a></td>' %
                                 (browse_url, browse_url))
 
     @nottest
     def origin_content_view_test(self, origin_id, origin_visits,
                                  origin_branches, origin_branch,
                                  root_dir_sha1, content_sha1,
                                  content_path, content_data,
                                  content_language,
                                  visit_id=None, ts=None):
 
         url_args = {'origin_id': origin_id,
                     'path': content_path}
 
         if not visit_id:
             visit_id = origin_visits[-1]['visit']
 
         if ts:
             url_args['timestamp'] = ts
         else:
             url_args['visit_id'] = visit_id
 
         url = reverse('browse-origin-content',
                       kwargs=url_args)
 
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 200)
         self.assertTemplateUsed('content.html')
 
         self.assertContains(resp, '<code class="%s">' % content_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']
 
         root_dir_url = reverse('browse-origin-directory',
                                kwargs=url_args,
                                query_params={'branch': origin_branch})
 
         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',
                               kwargs=url_args,
                               query_params={'branch': origin_branch})
             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
 
         url_raw = reverse('browse-content-raw',
                           kwargs={'query_string': query_string},
                           query_params={'filename': filename})
         self.assertContains(resp, url_raw)
 
         self.assertContains(resp, '<li class="swh-branch">',
                             count=len(origin_branches))
 
         url_args['path'] = content_path
 
         for branch in origin_branches:
             root_dir_branch_url = \
                 reverse('browse-origin-content',
                         kwargs=url_args,
                         query_params={'branch': branch['name']})
 
             self.assertContains(resp, '<a href="%s">%s</a>' %
                                 (root_dir_branch_url, branch['name']))
 
     @patch('swh.web.browse.views.origin.get_origin_visits')
     @patch('swh.web.browse.views.origin.get_origin_visit_branches')
     @patch('swh.web.browse.views.origin.service')
     @patch('swh.web.browse.views.origin.request_content')
     @istest
     def origin_content_view(self, mock_request_content, mock_service,
                             mock_get_origin_visit_branches,
                             mock_get_origin_visits):
 
         stub_content_text_sha1 = stub_content_text_data['checksums']['sha1']
         mock_get_origin_visits.return_value = stub_content_origin_visits
         mock_get_origin_visit_branches.return_value = stub_content_origin_branches # noqa
         mock_service.lookup_directory_with_path.return_value = \
             {'target': stub_content_text_sha1}
         mock_request_content.return_value = stub_content_text_data
 
         self.origin_content_view_test(stub_content_origin_id,
                                       stub_content_origin_visits,
                                       stub_content_origin_branches,
                                       stub_content_origin_branch,
                                       stub_content_root_dir,
                                       stub_content_text_sha1,
                                       stub_content_text_path,
                                       stub_content_text_data['raw_data'],
                                       'cpp')
 
         self.origin_content_view_test(stub_content_origin_id,
                                       stub_content_origin_visits,
                                       stub_content_origin_branches,
                                       stub_content_origin_branch,
                                       stub_content_root_dir,
                                       stub_content_text_sha1,
                                       stub_content_text_path,
                                       stub_content_text_data['raw_data'],
                                       'cpp',
                                       visit_id=stub_content_origin_visit_id)
 
         self.origin_content_view_test(stub_content_origin_id,
                                       stub_content_origin_visits,
                                       stub_content_origin_branches,
                                       stub_content_origin_branch,
                                       stub_content_root_dir,
                                       stub_content_text_sha1,
                                       stub_content_text_path,
                                       stub_content_text_data['raw_data'],
                                       'cpp',
                                       ts=stub_content_origin_visit_unix_ts)
 
         self.origin_content_view_test(stub_content_origin_id,
                                       stub_content_origin_visits,
                                       stub_content_origin_branches,
                                       stub_content_origin_branch,
                                       stub_content_root_dir,
                                       stub_content_text_sha1,
                                       stub_content_text_path,
                                       stub_content_text_data['raw_data'],
                                       'cpp',
                                       ts=stub_content_origin_visit_iso_date)
 
     @nottest
     def origin_directory_view(self, origin_id, origin_visits,
                               origin_branches, origin_branch,
                               root_directory_sha1, directory_entries,
                               visit_id=None, ts=None, path=None):
 
         dirs = [e for e in directory_entries
                 if e['type'] == 'dir']
         files = [e for e in directory_entries
                  if e['type'] == 'file']
 
         if not visit_id:
             visit_id = origin_visits[-1]['visit']
 
         url_args = {'origin_id': origin_id}
 
         if ts:
             url_args['timestamp'] = ts
         else:
             url_args['visit_id'] = visit_id
 
         if path:
             url_args['path'] = path
 
         url = reverse('browse-origin-directory',
                       kwargs=url_args)
 
         resp = self.client.get(url)
 
         self.assertEquals(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))
 
         for d in dirs:
             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',
                               kwargs=dir_url_args,
                               query_params={'branch': origin_branch}) # noqa
             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',
                                kwargs=file_url_args,
                                query_params={'branch': origin_branch}) # noqa
             self.assertContains(resp, file_url)
 
         if 'path' in url_args:
             del url_args['path']
 
         root_dir_branch_url = \
             reverse('browse-origin-directory',
                     kwargs=url_args,
                     query_params={'branch': origin_branch})
 
         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]))
 
         self.assertContains(resp, '<li class="swh-branch">',
                             count=len(origin_branches))
 
         if path:
             url_args['path'] = path
 
         for branch in origin_branches:
             root_dir_branch_url = \
                 reverse('browse-origin-directory',
                         kwargs=url_args,
                         query_params={'branch': branch['name']})
 
             self.assertContains(resp, '<a href="%s">%s</a>' %
                                 (root_dir_branch_url, branch['name']))
 
+    @patch('swh.web.browse.views.origin.get_origin_visit')
     @patch('swh.web.browse.views.origin.get_origin_visits')
     @patch('swh.web.browse.views.origin.get_origin_visit_branches')
     @patch('swh.web.browse.utils.service')
     @patch('swh.web.browse.views.origin.service')
     @istest
     def origin_root_directory_view(self, mock_origin_service,
                                    mock_utils_service,
                                    mock_get_origin_visit_branches,
-                                   mock_get_origin_visits):
+                                   mock_get_origin_visits,
+                                   mock_get_origin_visit):
+
+        mock_get_origin_visit.return_value = stub_origin_visits[0]
 
         mock_get_origin_visits.return_value = stub_origin_visits
         mock_get_origin_visit_branches.return_value = stub_origin_branches
         mock_utils_service.lookup_directory.return_value = \
             stub_origin_root_directory_entries
         mock_origin_service.lookup_origin.return_value = origin_info_test_data
 
         self.origin_directory_view(stub_origin_id, stub_origin_visits,
                                    stub_origin_branches,
                                    stub_origin_master_branch,
                                    stub_origin_root_directory_sha1,
                                    stub_origin_root_directory_entries)
 
         self.origin_directory_view(stub_origin_id, stub_origin_visits,
                                    stub_origin_branches,
                                    stub_origin_master_branch,
                                    stub_origin_root_directory_sha1,
                                    stub_origin_root_directory_entries,
                                    visit_id=stub_visit_id)
 
         self.origin_directory_view(stub_origin_id, stub_origin_visits,
                                    stub_origin_branches,
                                    stub_origin_master_branch,
                                    stub_origin_root_directory_sha1,
                                    stub_origin_root_directory_entries,
                                    ts=stub_visit_unix_ts)
 
         self.origin_directory_view(stub_origin_id, stub_origin_visits,
                                    stub_origin_branches,
                                    stub_origin_master_branch,
                                    stub_origin_root_directory_sha1,
                                    stub_origin_root_directory_entries,
                                    ts=stub_visit_iso_date)
 
+    @patch('swh.web.browse.views.origin.get_origin_visit')
     @patch('swh.web.browse.views.origin.get_origin_visits')
     @patch('swh.web.browse.views.origin.get_origin_visit_branches')
     @patch('swh.web.browse.utils.service')
     @patch('swh.web.browse.views.origin.service')
     @istest
     def origin_sub_directory_view(self, mock_origin_service,
                                   mock_utils_service,
                                   mock_get_origin_visit_branches,
-                                  mock_get_origin_visits):
+                                  mock_get_origin_visits,
+                                  mock_get_origin_visit):
+
+        mock_get_origin_visit.return_value = stub_origin_visits[0]
 
         mock_get_origin_visits.return_value = stub_origin_visits
         mock_get_origin_visit_branches.return_value = stub_origin_branches
         mock_utils_service.lookup_directory.return_value = \
             stub_origin_sub_directory_entries
         mock_origin_service.lookup_directory_with_path.return_value = \
             {'target': '120c39eeb566c66a77ce0e904d29dfde42228adb'}
 
         self.origin_directory_view(stub_origin_id, stub_origin_visits,
                                    stub_origin_branches,
                                    stub_origin_master_branch,
                                    stub_origin_root_directory_sha1,
                                    stub_origin_sub_directory_entries,
                                    path=stub_origin_sub_directory_path)
 
         self.origin_directory_view(stub_origin_id, stub_origin_visits,
                                    stub_origin_branches,
                                    stub_origin_master_branch,
                                    stub_origin_root_directory_sha1,
                                    stub_origin_sub_directory_entries,
                                    visit_id=stub_visit_id,
                                    path=stub_origin_sub_directory_path)
 
         self.origin_directory_view(stub_origin_id, stub_origin_visits,
                                    stub_origin_branches,
                                    stub_origin_master_branch,
                                    stub_origin_root_directory_sha1,
                                    stub_origin_sub_directory_entries,
                                    ts=stub_visit_unix_ts,
                                    path=stub_origin_sub_directory_path)
 
         self.origin_directory_view(stub_origin_id, stub_origin_visits,
                                    stub_origin_branches,
                                    stub_origin_master_branch,
                                    stub_origin_root_directory_sha1,
                                    stub_origin_sub_directory_entries,
                                    ts=stub_visit_iso_date,
                                    path=stub_origin_sub_directory_path)
 
+    @patch('swh.web.browse.views.origin.get_origin_visit')
     @patch('swh.web.browse.views.origin.request_content')
     @patch('swh.web.browse.views.origin.get_origin_visits')
     @patch('swh.web.browse.views.origin.get_origin_visit_branches')
     @patch('swh.web.browse.utils.service')
     @patch('swh.web.browse.views.origin.service')
     @istest
     def origin_request_errors(self, mock_origin_service,
                               mock_utils_service,
                               mock_get_origin_visit_branches,
                               mock_get_origin_visits,
-                              mock_request_content):
+                              mock_request_content,
+                              mock_get_origin_visit):
+
+        mock_get_origin_visit.return_value = stub_origin_visits[0]
 
         mock_origin_service.lookup_origin.side_effect = \
             NotFoundExc('origin not found')
         url = reverse('browse-origin',
                       kwargs={'origin_id': '1'})
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, "origin not found", status_code=404)
 
         mock_origin_service.lookup_origin.side_effect = None
         mock_origin_service.lookup_origin.return_value = origin_info_test_data
         mock_get_origin_visits.return_value = []
         url = reverse('browse-origin-directory',
                       kwargs={'origin_id': '1'})
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, "No SWH visit", status_code=404)
 
         mock_get_origin_visits.return_value = stub_origin_visits
         mock_get_origin_visit_branches.side_effect = \
             NotFoundExc('visit not found')
         url = reverse('browse-origin-directory',
                       kwargs={'origin_id': '1',
                               'visit_id': len(stub_origin_visits)+1})
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, 'visit not found', status_code=404)
 
         mock_get_origin_visits.return_value = stub_origin_visits
         mock_get_origin_visit_branches.side_effect = None
         mock_get_origin_visit_branches.return_value = []
         url = reverse('browse-origin-directory',
                       kwargs={'origin_id': '1'})
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertRegex(resp.content.decode('utf-8'),
                          'Branch HEAD.*not found')
 
         mock_get_origin_visit_branches.return_value = stub_origin_branches
         mock_utils_service.lookup_directory.side_effect = \
             NotFoundExc('Directory not found')
         url = reverse('browse-origin-directory',
                       kwargs={'origin_id': '1'})
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, 'Directory not found', status_code=404)
 
         mock_origin_service.lookup_origin.side_effect = None
         mock_origin_service.lookup_origin.return_value = origin_info_test_data
         mock_get_origin_visits.return_value = []
         url = reverse('browse-origin-content',
                       kwargs={'origin_id': '1',
                               'path': 'foo'})
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, "No SWH visit", status_code=404)
 
         mock_get_origin_visits.return_value = stub_origin_visits
         mock_get_origin_visit_branches.side_effect = \
             NotFoundExc('visit not found')
         url = reverse('browse-origin-content',
                       kwargs={'origin_id': '1',
                               'visit_id': len(stub_origin_visits)+1,
                               'path': 'foo'})
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, 'visit not found', status_code=404)
 
         mock_get_origin_visits.return_value = stub_origin_visits
         mock_get_origin_visit_branches.side_effect = None
         mock_get_origin_visit_branches.return_value = []
         url = reverse('browse-origin-content',
                       kwargs={'origin_id': '1',
                               'path': 'foo'})
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertRegex(resp.content.decode('utf-8'),
                          'Branch HEAD.*not found')
 
         mock_get_origin_visit_branches.return_value = stub_origin_branches
         mock_origin_service.lookup_directory_with_path.return_value = \
             {'target': stub_content_text_data['checksums']['sha1']}
         mock_request_content.side_effect = \
             NotFoundExc('Content not found')
         url = reverse('browse-origin-content',
                       kwargs={'origin_id': '1',
                               'path': 'foo'})
         resp = self.client.get(url)
         self.assertEquals(resp.status_code, 404)
         self.assertTemplateUsed('error.html')
         self.assertContains(resp, 'Content not found', status_code=404)