diff --git a/swh/web/browse/utils.py b/swh/web/browse/utils.py
index b834565d..bc587ec2 100644
--- a/swh/web/browse/utils.py
+++ b/swh/web/browse/utils.py
@@ -1,452 +1,458 @@
 # 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_for_content(content):
     """Function that returns the mime type associated to
     a content buffer using the magic module under the hood.
 
     Args:
         content (bytes): a content buffer
 
     Returns:
         The mime type (e.g. text/plain) associated to the provided content.
 
     """
-    return magic.detect_from_content(content).mime_type
+    if hasattr(magic, 'detect_from_content'):
+        return magic.detect_from_content(content).mime_type
+    # for old api version of magic module (debian jessie)
+    else:
+        m = magic.open(magic.MAGIC_MIME_TYPE)
+        m.load()
+        return m.buffer(content)
 
 
 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']
     mimetype = service.lookup_content_filetype(query_string)
     language = service.lookup_content_language(query_string)
     license = service.lookup_content_license(query_string)
     if mimetype:
         mimetype = mimetype['mimetype']
     else:
         mimetype = get_mimetype_for_content(content_data['raw_data'])
     content_data['mimetype'] = mimetype
     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_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::
 
             [{'name': <branch name>,
               'revision': <sha1_git of the associated revision>,
               'directory': <sha1_git of the associated root directory>
              },
              ...
             ]
 
     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))
 
     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/templates/browse.html b/swh/web/templates/browse.html
index 325cf9eb..2b57f9b6 100644
--- a/swh/web/templates/browse.html
+++ b/swh/web/templates/browse.html
@@ -1,52 +1,52 @@
 {% extends "layout.html" %}
 {% load swh_templatetags %}
 
 {% block content %}
 
 <div class="panel-group" id="accordion">
   {% if top_panel_visible %}
   <div class="panel panel-default">
       <div class="panel-heading">
         {% if top_panel_collapsible %}
         <a data-toggle="collapse" data-parent="#accordion" href="#swh-browse-top-collapse" style="outline:none;">
         {% endif %}
           <div class="panel-title pull-left">
               <h4>{{ top_panel_text_left }}</h4> 
           </div>
           <div class="panel-title pull-right">
             <h4>{{ top_panel_text_right }}</h4>
           </div>
           <div class="clearfix"></div>
         {% if top_panel_collapsible %}  
         </a>
         {% endif %}
           
       </div>
       {% if top_panel_collapsible %}
       <div id="swh-browse-top-collapse" class="panel-collapse collapse">
       {% endif %}
         <table class="table">
           <tbody>
-            {% for key, val in swh_object_metadata.items|dictsort:0 %}  
+            {% for key, val in swh_object_metadata.items|dictsort:"0.lower" %}  
               <tr>
                 <th class="swh-metadata-table-row">{{ key }}</th>
                 <td class="swh-metadata-table-row">{{ val | safe | urlize_links_and_mails | safe }}</td>
               </tr>
             {% endfor %}
           </tbody>
         </table>
       {% if top_panel_collapsible %}
       </div>
       {% endif %}
   </div>
   {% endif %}
   {% if main_panel_visible %}
   <div class="panel panel-default">
     {% block swh-browse-main-panel-content %}{% endblock %}
   </div>
   {% endif %}
 </div>
 
 {% block swh-browse-after-panels %}{% endblock %}
 
 {% endblock %}
diff --git a/swh/web/templates/revision.html b/swh/web/templates/revision.html
index 27d1f700..6746532d 100644
--- a/swh/web/templates/revision.html
+++ b/swh/web/templates/revision.html
@@ -1,25 +1,25 @@
 {% extends "browse.html" %}
 {% block title %}Revision{% endblock %}
 
 {% block swh-browse-main-panel-content %}
 <div class="panel-heading">
   <div class="panel-title pull-left">
       <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>
 
 <table class="table">
-  {% for key, val in revision.items|dictsort:0 %}
+  {% for key, val in revision.items|dictsort:"0.lower" %}
     <tr>
       <th class="swh-metadata-table-row">{{ key }}</th>
       <td class="swh-metadata-table-row">{{ val }}</td>
     </tr>
   {% endfor %}
 </table>
 
 {% endblock %}
\ No newline at end of file
diff --git a/swh/web/tests/browse/views/test_origin.py b/swh/web/tests/browse/views/test_origin.py
index 483d5880..54edf6c9 100644
--- a/swh/web/tests/browse/views/test_origin.py
+++ b/swh/web/tests/browse/views/test_origin.py
@@ -1,384 +1,387 @@
 # 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.utils import reverse
 
 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(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):
         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, '>%s</td>' % origin_info_test_data['type']) # noqa
         self.assertContains(resp, '><a href="%s">%s</a></td>' %
                                   (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_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_service,
+    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.return_value = stub_origin_visits
         mock_get_origin_visit_branches.return_value = stub_origin_branches
-        mock_service.lookup_directory.return_value = \
+        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_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.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)
diff --git a/swh/web/urls.py b/swh/web/urls.py
index 3cda50e7..b98fd2f5 100644
--- a/swh/web/urls.py
+++ b/swh/web/urls.py
@@ -1,27 +1,38 @@
 # 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 django
+
 from django.conf.urls import url, include
 from django.contrib.staticfiles.urls import staticfiles_urlpatterns
 from django.shortcuts import redirect
 from django.views.generic.base import RedirectView
 
 favicon_view = RedirectView.as_view(url='/static/img/icons/swh-logo-32x32.png',
                                     permanent=True)
 
 
 def default_view(request):
     return redirect('api_homepage')
 
 
 urlpatterns = [
     url(r'^favicon\.ico$', favicon_view),
     url(r'^api/', include('swh.web.api.urls')),
     url(r'^browse/', include('swh.web.browse.urls')),
     url(r'^$', default_view),
 ]
 
 
 urlpatterns += staticfiles_urlpatterns()
+
+# hack in order for our custom template tag library
+# to load on django 1.7 (debian jessie version)
+if django.VERSION < (1, 8):
+    from django.template.base import templatetags_modules # noqa
+    templatetags_modules += ['django.templatetags',
+                             'django.contrib.admin.templatetags',
+                             'django.contrib.staticfiles.templatetags',
+                             'rest_framework.templatetags', 'swh.web.common']