diff --git a/swh/web/ui/main.py b/swh/web/ui/main.py
index c631a791..c93692eb 100644
--- a/swh/web/ui/main.py
+++ b/swh/web/ui/main.py
@@ -1,148 +1,149 @@
 # Copyright (C) 2015-2016  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import logging
 import os
 
 from flask import Flask
 from swh.core import config
 
 from swh.web.ui.renderers import urlize_api_links, safe_docstring_display
 from swh.web.ui.renderers import revision_id_from_url, highlight_source
 from swh.web.ui.renderers import SWHMultiResponse, urlize_header_links
+from swh.web.ui.renderers import escape_author_fields
 from swh.storage import get_storage
 
 
 DEFAULT_CONFIG = {
     'storage': ('dict', {
         'cls': 'remote',
         'args': {
             'url': 'http://127.0.0.1:5002/',
         },
     }),
     'log_dir': ('string', '/tmp/swh/log'),
     'debug': ('bool', None),
     'host': ('string', '127.0.0.1'),
     'port': ('int', 6543),
     'secret_key': ('string', 'development key'),
     'max_log_revs': ('int', 25),
 }
 
 class SWHFlask(Flask):
     """SWH's flask application.
 
     """
     response_class = SWHMultiResponse
 
 
 app = SWHFlask(__name__)
 app.add_template_filter(urlize_api_links)
 app.add_template_filter(urlize_header_links)
 app.add_template_filter(safe_docstring_display)
 app.add_template_filter(revision_id_from_url)
 app.add_template_filter(highlight_source)
-
+app.add_template_filter(escape_author_fields)
 
 def read_config(config_file):
     """Read the configuration file `config_file`, update the app with
        parameters (secret_key, conf) and return the parsed configuration as a
        dict"""
 
     conf = config.read(config_file, DEFAULT_CONFIG)
     config.prepare_folders(conf, 'log_dir')
     conf['storage'] = get_storage(**conf['storage'])
 
     return conf
 
 
 def load_controllers():
     """Load the controllers for the application.
 
     """
     from swh.web.ui import views, apidoc  # flake8: noqa
 
 
 def rules():
     """Returns rules from the application in dictionary form.
 
     Beware, must be called after swh.web.ui.main.load_controllers funcall.
 
     Returns:
         Generator of application's rules.
 
     """
     for rule in app.url_map._rules:
         yield {'rule': rule.rule,
                'methods': rule.methods,
                'endpoint': rule.endpoint}
 
 
 def storage():
     """Return the current application's storage.
 
     """
     return app.config['conf']['storage']
 
 
 def run_from_webserver(environ, start_response):
     """Run the WSGI app from the webserver, loading the configuration.
 
     Note: This function is called on a per-request basis so beware the side
     effects here!
     """
 
     load_controllers()
 
     config_path = '/etc/softwareheritage/webapp/webapp.yml'
 
     conf = read_config(config_path)
 
     app.secret_key = conf['secret_key']
     app.config['conf'] = conf
 
     logging.basicConfig(filename=os.path.join(conf['log_dir'], 'web-ui.log'),
                         level=logging.INFO)
 
     return app(environ, start_response)
 
 
 def run_debug_from(config_path, verbose=False):
     """Run the api's server in dev mode.
 
     Note: This is called only once (contrast with the production mode
     in run_from_webserver function)
 
     Args:
         conf is a dictionary of keywords:
         - 'db_url' the db url's access (through psycopg2 format)
         - 'content_storage_dir' revisions/directories/contents storage on disk
         - 'host'   to override the default 127.0.0.1 to open or not the server
         to the world
         - 'port'   to override the default of 5000 (from the underlying layer:
         flask)
         - 'debug'  activate the verbose logs
         - 'secret_key' the flask secret key
 
     Returns:
         Never
 
     """
     load_controllers()
 
     conf = read_config(config_path)
 
     app.secret_key = conf['secret_key']
     app.config['conf'] = conf
 
     host = conf.get('host', '127.0.0.1')
     port = conf.get('port')
     debug = conf.get('debug')
 
     log_file = os.path.join(conf['log_dir'], 'web-ui.log')
     logging.basicConfig(level=logging.DEBUG if verbose else logging.INFO,
                         handlers=[logging.FileHandler(log_file),
                                   logging.StreamHandler()])
 
     app.run(host=host, port=port, debug=debug)
diff --git a/swh/web/ui/renderers.py b/swh/web/ui/renderers.py
index be575c4a..022c368b 100644
--- a/swh/web/ui/renderers.py
+++ b/swh/web/ui/renderers.py
@@ -1,282 +1,288 @@
 # 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
 
 import re
 import yaml
 import json
 
 from docutils.core import publish_parts
 from docutils.writers.html4css1 import Writer, HTMLTranslator
 from inspect import cleandoc
 from jinja2 import Markup
 from flask import request, Response, render_template
 from flask import g
 from pygments import highlight
 from pygments.lexers import guess_lexer
 from pygments.formatters import HtmlFormatter
 
 from swh.web.ui import utils
 
 
 class SWHFilterEnricher():
     """Global filter on fields.
 
     """
     @classmethod
     def filter_by_fields(cls, data):
         """Extract a request parameter 'fields' if it exists to permit the
            filtering on the data dict's keys.
 
            If such field is not provided, returns the data as is.
 
         """
         fields = request.args.get('fields')
         if fields:
             fields = set(fields.split(','))
             data = utils.filter_field_keys(data, fields)
 
         return data
 
 
 class SWHComputeLinkHeader:
     """Add link header to response.
 
     Mixin intended to be used for example in SWHMultiResponse
 
     """
     @classmethod
     def compute_link_header(cls, rv, options):
         """Add Link header in returned value results.
 
         Expects rv to be a dict with 'results' and 'headers' key:
             'results': the returned value expected to be shown
             'headers': dictionary with link-next and link-prev
 
         Args:
             rv (dict): with keys:
                 - 'headers': potential headers with 'link-next'
                   and 'link-prev' keys
                 - 'results': containing the result to return
             options (dict): the initial dict to update with result if any
 
         Returns:
             Dict with optional keys 'link-next' and 'link-prev'.
 
         """
         link_headers = []
 
         if 'headers' not in rv:
             return {}
 
         rv_headers = rv['headers']
 
         if 'link-next' in rv_headers:
             link_headers.append('<%s>; rel="next"' % (
                 rv_headers['link-next']))
         if 'link-prev' in rv_headers:
             link_headers.append('<%s>; rel="previous"' % (
                 rv_headers['link-prev']))
 
         if link_headers:
             link_header_str = ','.join(link_headers)
             headers = options.get('headers', {})
             headers.update({
                 'Link': link_header_str
             })
             return headers
 
         return {}
 
 
 class SWHTransformProcessor:
     """Transform an eventual returned value with multiple layer of
     information with only what's necessary.
 
     If the returned value rv contains the 'results' key, this is the
     associated value which is returned.
 
     Otherwise, return the initial dict without the potential 'headers'
     key.
 
     """
     @classmethod
     def transform(cls, rv):
         if 'results' in rv:
             return rv['results']
 
         if 'headers' in rv:
             rv.pop('headers')
 
         return rv
 
 
 class SWHMultiResponse(Response, SWHFilterEnricher,
                        SWHComputeLinkHeader, SWHTransformProcessor):
     """
     A Flask Response subclass.
     Override force_type to transform dict/list responses into callable Flask
     response objects whose mimetype matches the request's Accept header: HTML
     template render, YAML dump or default to a JSON dump.
     """
 
     @classmethod
     def make_response_from_mimetype(cls, rv, options={}):
         options = options.copy()
         if not (isinstance(rv, list) or isinstance(rv, dict)):
             return rv
 
         def wants_html(best_match):
             return best_match == 'text/html' and \
                 request.accept_mimetypes[best_match] > \
                 request.accept_mimetypes['application/json']
 
         def wants_yaml(best_match):
             return best_match == 'application/yaml' and \
                 request.accept_mimetypes[best_match] > \
                 request.accept_mimetypes['application/json']
 
         rv = cls.filter_by_fields(rv)
         acc_mime = ['application/json', 'application/yaml', 'text/html']
         best_match = request.accept_mimetypes.best_match(acc_mime)
 
         options['headers'] = cls.compute_link_header(rv, options)
 
         rv = cls.transform(rv)
 
         if wants_html(best_match):
             data = json.dumps(rv, sort_keys=True,
                               indent=4, separators=(',', ': '))
             env = g.get('doc_env', {})
             env['response_data'] = data
 
             env['headers_data'] = None
             if options and 'headers' in options:
                 env['headers_data'] = options['headers']
 
             env['request'] = request
             rv = Response(render_template('apidoc.html', **env),
                           content_type='text/html',
                           **options)
         elif wants_yaml(best_match):
             rv = Response(
                 yaml.dump(rv),
                 content_type='application/yaml',
                 **options)
         else:
             # jsonify is unhappy with lists in Flask 0.10.1, use json.dumps
             rv = Response(
                 json.dumps(rv),
                 content_type='application/json',
                 **options)
         return rv
 
     @classmethod
     def force_type(cls, rv, environ=None):
         if isinstance(rv, dict) or isinstance(rv, list):
             rv = cls.make_response_from_mimetype(rv)
         return super().force_type(rv, environ)
 
 
 def error_response(error_code, error):
     """Private function to create a custom error response.
 
     """
     error_opts = {'status': error_code}
     error_data = {'error': str(error)}
 
     return SWHMultiResponse.make_response_from_mimetype(error_data,
                                                         options=error_opts)
 
 
 def urlize_api_links(text):
     """Utility function for decorating api links in browsable api.
 
     Args:
         text: whose content matching links should be transformed into
         contextual API or Browse html links.
 
     Returns
         The text transformed if any link is found.
         The text as is otherwise.
 
     """
-    return re.sub(r'"(/api/.*|/browse/.*)"', r'"<a href="\1">\1</a>"', text)
+    return re.sub(r'(/api/.*/|/browse/.*/)',
+                  r'<a href="\1">\1</a>',
+                  text)
+
+
+def escape_author_fields(text):
+    return re.sub(r'<(.*)>', r'&lt;\1&gt;', text)
 
 
 def urlize_header_links(text):
     """Utility function for decorating headers links in browsable api.
 
     Args
         text: Text whose content contains Link header value
 
     Returns:
         The text transformed with html link if any link is found.
         The text as is otherwise.
 
     """
     return re.sub(r'<(/api/.*|/browse/.*)>', r'<<a href="\1">\1</a>>',
                   text)
 
 
 class NoHeaderHTMLTranslator(HTMLTranslator):
     """
     Docutils translator subclass to customize the generation of HTML
     from reST-formatted docstrings
     """
     def __init__(self, document):
         super().__init__(document)
         self.body_prefix = []
         self.body_suffix = []
 
     def visit_bullet_list(self, node):
         self.context.append((self.compact_simple, self.compact_p))
         self.compact_p = None
         self.compact_simple = self.is_compactable(node)
         self.body.append(self.starttag(node, 'ul', CLASS='docstring'))
 
 
 DOCSTRING_WRITER = Writer()
 DOCSTRING_WRITER.translator_class = NoHeaderHTMLTranslator
 
 
 def safe_docstring_display(docstring):
     """
     Utility function to htmlize reST-formatted documentation in browsable
     api.
     """
     docstring = cleandoc(docstring)
     return publish_parts(docstring, writer=DOCSTRING_WRITER)['html_body']
 
 
 def revision_id_from_url(url):
     """Utility function to obtain a revision's ID from its browsing URL."""
     return re.sub(r'/browse/revision/([0-9a-f]{40}|[0-9a-f]{64})/.*',
                   r'\1', url)
 
 
 def highlight_source(source_code_as_text):
     """Leverage pygments to guess and highlight source code.
 
     Args
         source_code_as_text (str): source code in plain text
 
     Returns:
         Highlighted text if possible or plain text otherwise
 
     """
     try:
         maybe_lexer = guess_lexer(source_code_as_text)
         if maybe_lexer:
             r = highlight(
                 source_code_as_text, maybe_lexer,
                 HtmlFormatter(linenos=True,
                               lineanchors='l',
                               anchorlinenos=True))
         else:
             r = '<pre>%s</pre>' % source_code_as_text
     except:
         r = '<pre>%s</pre>' % source_code_as_text
 
     return Markup(r)
diff --git a/swh/web/ui/templates/apidoc.html b/swh/web/ui/templates/apidoc.html
index eebda78d..7bee1e5b 100644
--- a/swh/web/ui/templates/apidoc.html
+++ b/swh/web/ui/templates/apidoc.html
@@ -1,114 +1,114 @@
 {% extends "layout.html" %}
 {% block title %}Software Heritage API{% endblock %}
 {% block content %}
 
 {% if docstring %}
 <div class="docstring">
   <h2> Overview </h2>
   {{ docstring | safe_docstring_display | safe }}
 </div>
 {% endif %}
 {% if response_data and response_data is not none %}
 <div class="response-data">
   <h2> Request </h2>
   <pre><strong>{{ request.method }}</strong> {{ request.url }}</pre>
   {% if headers_data and headers_data is not none %}
   <h2> Headers </h2>
     {% for header_name, header_value in headers_data.items() %}
       <pre><strong>{{ header_name }}</strong> {{ header_value | urlize_header_links | safe }}</pre>
     {% endfor %}
   {% endif %}
-  <h2> Result </h2>
-  <pre>{{ response_data | urlize_api_links | safe }}</pre>
+    <h2> Result </h2>
+    <pre>{{ response_data | escape_author_fields | urlize_api_links | safe }}</pre>
 </div>
 {% endif %}
 <hr/>
 <div class="doc-urls">
   <table class="m-x-auto table">
     <thead>
       <tr>
 	<th>URL</th>
 	<th>Allowed Methods</th>
       </tr>
     </thead>
     <tbody>
       {% for url in urls %}
       <tr>
 	<td>
 	  {{ url['rule'] }}
 	</td>
 	<td>
 	  {{ url['methods'] | sort | join(', ') }}
 	</td>
       </tr>
       {% endfor %}
     </tbody>
   </table>
 </div>
 <hr/>
 {% if args and args|length > 0 %}
 <div class="doc-args">
   <h2> Args </h2>
   <dl class="doc-argslist dl-horizontal">
     {% for arg in args %}
     <dt> {{ arg['name'] }}: {{ arg['type'] }} </dt>
     <dd> {{ arg['doc'] | safe_docstring_display | safe }} </dd>
     {% endfor %}
   </dl>
  </div>
 {% endif %}
 {% if params and params|length > 0 %}
 <div class="doc-params">
   <h2> Params </h2>
   <dl class="doc-paramslist dl-horizontal">
     {% for param in params %}
     <dt> {{ param['name'] }}: string </dt>
     <dd> {{ param['doc'] | safe_docstring_display | safe }} </dd>
     {% endfor %}
   </dl>
  </div>
 {% endif %}
 {% if excs and excs|length > 0 %}
 <div class="doc-excs">
   <h2> Raises </h2>
   <dl class="doc-excslist dl-horizontal">
     {% for exc in excs %}
     <dt> {{ exc['exc'] }} </dt>
     <dd> {{ exc['doc'] | safe_docstring_display | safe }} </dd>
     {% endfor %}
   </dl>
 </div>
 {% endif %}
 {% if headers %}
 <div class="doc-headers">
   <h2> Headers </h2>
   <dl class="doc-headers dl-horizontal">
     {% for header in headers %}
     <dt> {{ header['name'] }}: string </dt>
     <dd> {{ header['doc'] | safe_docstring_display | safe }} </dd>
     {% endfor %}
   </dl>
 </div>
 {% endif %}
 {% if return %}
 <div class="doc-return">
   <h2> Returns </h2>
   <dl class="doc-return dl-horizontal">
     <dt> {{ return['type'] }} </dt>
     <dd> {{ return['doc'] | safe_docstring_display | safe }} </dd>
   </dl>
 </div>
 {% endif %}
 {% if examples %}
 <div class="doc-example">
   <h2> Examples </h2>
   <dl class="doc-example dl-horizontal">
   {% for example in examples %}
     <dd>
       <a href="{{ example }}">{{ example }}</a>
     </dd>
   {% endfor %}
   </dl>
 </div>
 {% endif %}
 {% endblock %}
diff --git a/swh/web/ui/tests/test_renderers.py b/swh/web/ui/tests/test_renderers.py
index 6eb43d83..5e0a7b5e 100644
--- a/swh/web/ui/tests/test_renderers.py
+++ b/swh/web/ui/tests/test_renderers.py
@@ -1,324 +1,319 @@
 # 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
 
 import json
 import unittest
 import yaml
 
 from flask import Response
 from nose.tools import istest
 from unittest.mock import patch, MagicMock
 
 from swh.web.ui import renderers
 
 
 class SWHComputeLinkHeaderTest(unittest.TestCase):
     @istest
     def compute_link_header(self):
         rv = {
             'headers': {'link-next': 'foo', 'link-prev': 'bar'},
             'results': [1, 2, 3]
         }
         options = {}
 
         # when
         headers = renderers.SWHComputeLinkHeader.compute_link_header(
             rv, options)
 
         self.assertEquals(headers, {
             'Link': '<foo>; rel="next",<bar>; rel="previous"',
         })
 
     @istest
     def compute_link_header_nothing_changed(self):
         rv = {}
         options = {}
 
         # when
         headers = renderers.SWHComputeLinkHeader.compute_link_header(
             rv, options)
 
         self.assertEquals(headers, {})
 
     @istest
     def compute_link_header_nothing_changed_2(self):
         rv = {'headers': {}}
         options = {}
 
         # when
         headers = renderers.SWHComputeLinkHeader.compute_link_header(
             rv, options)
 
         self.assertEquals(headers, {})
 
 
 class SWHTransformProcessorTest(unittest.TestCase):
     @istest
     def transform_only_return_results_1(self):
         rv = {'results': {'some-key': 'some-value'}}
 
         self.assertEquals(renderers.SWHTransformProcessor.transform(rv),
                           {'some-key': 'some-value'})
 
     @istest
     def transform_only_return_results_2(self):
         rv = {'headers': {'something': 'do changes'},
               'results': {'some-key': 'some-value'}}
 
         self.assertEquals(renderers.SWHTransformProcessor.transform(rv),
                           {'some-key': 'some-value'})
 
     @istest
     def transform_do_remove_headers(self):
         rv = {'headers': {'something': 'do changes'},
               'some-key': 'some-value'}
 
         self.assertEquals(renderers.SWHTransformProcessor.transform(rv),
                           {'some-key': 'some-value'})
 
     @istest
     def transform_do_nothing(self):
         rv = {'some-key': 'some-value'}
 
         self.assertEquals(renderers.SWHTransformProcessor.transform(rv),
                           {'some-key': 'some-value'})
 
 
 class RendererTestCase(unittest.TestCase):
 
     @patch('swh.web.ui.renderers.g')
     @patch('swh.web.ui.renderers.json')
     @patch('swh.web.ui.renderers.request')
     @patch('swh.web.ui.renderers.render_template')
     @patch('swh.web.ui.renderers.SWHMultiResponse.filter_by_fields')
     @istest
     def swh_multi_response_mimetype_html(self, mock_filter,
                                          mock_render, mock_request, mock_json,
                                          mock_g):
         # given
         data = {
             'data': [12, 34],
             'id': 'adc83b19e793491b1c6ea0fd8b46cd9f32e592fc'
         }
         mock_g.get.return_value = {'my_key': 'my_display_value'}
         # mock_enricher.return_value = (data, {})
         mock_filter.return_value = data
         expected_env = {
             'my_key': 'my_display_value',
             'response_data': json.dumps(data),
             'request': mock_request,
             'headers_data': {},
         }
 
         def mock_mimetypes(key):
             mimetypes = {
                 'text/html': 10,
                 'application/json': 0.1,
                 'application/yaml': 0.1
             }
             return mimetypes[key]
         accept_mimetypes = MagicMock()
         accept_mimetypes.__getitem__.side_effect = mock_mimetypes
         accept_mimetypes.best_match = MagicMock(return_value='text/html')
         mock_request.accept_mimetypes = accept_mimetypes
         mock_json.dumps.return_value = json.dumps(data)
 
         # when
         rv = renderers.SWHMultiResponse.make_response_from_mimetype(data)
 
         # then
         # mock_enricher.assert_called_once_with(data, {})
         mock_filter.assert_called_once_with(data)
         mock_render.assert_called_with('apidoc.html', **expected_env)
         self.assertEqual(rv.status_code, 200)
         self.assertEqual(rv.mimetype, 'text/html')
 
     @patch('swh.web.ui.renderers.g')
     @patch('swh.web.ui.renderers.yaml')
     @patch('swh.web.ui.renderers.request')
     @patch('swh.web.ui.renderers.SWHMultiResponse.filter_by_fields')
     @istest
     def swh_multi_response_mimetype_yaml(self, mock_filter,
                                          mock_request, mock_yaml, mock_g):
         # given
         data = {'data': [12, 34],
                 'id': 'adc83b19e793491b1c6ea0fd8b46cd9f32e592fc'}
 
         def mock_mimetypes(key):
             mimetypes = {
                 'application/yaml': 10,
                 'application/json': 0.1,
                 'text/html': 0.1
             }
             return mimetypes[key]
         accept_mimetypes = MagicMock()
         accept_mimetypes.__getitem__.side_effect = mock_mimetypes
         accept_mimetypes.best_match = MagicMock(
             return_value='application/yaml')
         mock_request.accept_mimetypes = accept_mimetypes
         mock_yaml.dump.return_value = yaml.dump(data)
         mock_filter.return_value = data
 
         # when
         rv = renderers.SWHMultiResponse.make_response_from_mimetype(data)
 
         # then
         mock_filter.assert_called_once_with(data)
         mock_yaml.dump.assert_called_once_with(data)
         self.assertEqual(rv.status_code, 200)
         self.assertEqual(rv.mimetype, 'application/yaml')
         self.assertEqual(data, yaml.load(rv.data.decode('utf-8')))
 
     @patch('swh.web.ui.renderers.g')
     @patch('swh.web.ui.renderers.json')
     @patch('swh.web.ui.renderers.request')
     @patch('swh.web.ui.renderers.SWHMultiResponse.filter_by_fields')
     @istest
     def swh_multi_response_mimetype_json(self, mock_filter,
                                          mock_request, mock_json, mock_g):
         # given
         data = {'data': [12, 34],
                 'id': 'adc83b19e793491b1c6ea0fd8b46cd9f32e592fc'}
 
         def mock_mimetypes(key):
             mimetypes = {
                 'application/json': 10,
                 'text/html': 0.1,
                 'application/yaml': 0.1
             }
             return mimetypes[key]
         accept_mimetypes = MagicMock()
         accept_mimetypes.__getitem__.side_effect = mock_mimetypes
         accept_mimetypes.best_match = MagicMock(
             return_value='application/json')
         mock_request.accept_mimetypes = accept_mimetypes
         mock_json.dumps.return_value = json.dumps(data)
         mock_filter.return_value = data
 
         # when
         rv = renderers.SWHMultiResponse.make_response_from_mimetype(data)
 
         # then
         mock_filter.assert_called_once_with(data)
         mock_json.dumps.assert_called_once_with(data)
         self.assertEqual(rv.status_code, 200)
         self.assertEqual(rv.mimetype, 'application/json')
         self.assertEqual(data, json.loads(rv.data.decode('utf-8')))
 
     @patch('swh.web.ui.renderers.request')
     @istest
     def swh_multi_response_make_response_not_list_dict(self, mock_request):
         # given
         incoming = Response()
 
         # when
         rv = renderers.SWHMultiResponse.make_response_from_mimetype(incoming)
 
         # then
         self.assertEqual(rv, incoming)
 
     @patch('swh.web.ui.renderers.request')
     @istest
     def swh_filter_renderer_do_nothing(self, mock_request):
         # given
         mock_request.args = {}
 
         swh_filter_renderer = renderers.SWHFilterEnricher()
 
         input_data = {'a': 'some-data'}
 
         # when
         actual_data = swh_filter_renderer.filter_by_fields(input_data)
 
         # then
         self.assertEquals(actual_data, input_data)
 
     @patch('swh.web.ui.renderers.utils')
     @patch('swh.web.ui.renderers.request')
     @istest
     def swh_filter_renderer_do_filter(self, mock_request, mock_utils):
         # given
         mock_request.args = {'fields': 'a,c'}
         mock_utils.filter_field_keys.return_value = {'a': 'some-data'}
 
         swh_filter_user = renderers.SWHMultiResponse()
 
         input_data = {'a': 'some-data',
                       'b': 'some-other-data'}
 
         # when
         actual_data = swh_filter_user.filter_by_fields(input_data)
 
         # then
         self.assertEquals(actual_data, {'a': 'some-data'})
 
         mock_utils.filter_field_keys.assert_called_once_with(input_data,
                                                              {'a', 'c'})
 
     @istest
     def urlize_api_links(self):
         # update api link with html links content with links
         content = '{"url": "/api/1/abc/"}'
         expected_content = '{"url": "<a href=\"/api/1/abc/\">/api/1/abc/</a>"}'
 
         self.assertEquals(renderers.urlize_api_links(content),
                           expected_content)
 
         # update /browse link with html links content with links
         content = '{"url": "/browse/def/"}'
         expected_content = '{"url": "<a href=\"/browse/def/\">' \
                            '/browse/def/</a>"}'
 
         self.assertEquals(renderers.urlize_api_links(content),
                           expected_content)
 
-        # will do nothing since it's not an api url
-        other_content = '{"url": "/something/api/1/other"}'
-        self.assertEquals(renderers.urlize_api_links(other_content),
-                          other_content)
-
     @istest
     def urlize_header_links(self):
         # update api link with html links content with links
         content = """</api/1/abc/>; rel="next"
 </api/1/def/>; rel="prev"
 """
         expected_content = """<<a href="/api/1/abc/">/api/1/abc/</a>>; rel="next"
 <<a href="/api/1/def/">/api/1/def/</a>>; rel="prev"
 """
 
         self.assertEquals(renderers.urlize_header_links(content),
                           expected_content)
 
     @istest
     def revision_id_from_url(self):
         url = ('/browse/revision/9ba4bcb645898d562498ea66a0df958ef0e7a68c/'
                'prev/9ba4bcb645898d562498ea66a0df958ef0e7aaaa/')
 
         expected_id = '9ba4bcb645898d562498ea66a0df958ef0e7a68c'
         self.assertEqual(renderers.revision_id_from_url(url), expected_id)
 
     @istest
     def safe_docstring_display(self):
         # update api link with html links content with links
         docstring = """This is my list header:
 
         - Here is item 1, with a continuation
           line right here
         - Here is item 2
 
         Here is something that is not part of the list"""
 
         expected_docstring = """<p>This is my list header:</p>
 <ul class="docstring">
 <li>Here is item 1, with a continuation
 line right here</li>
 <li>Here is item 2</li>
 </ul>
 <p>Here is something that is not part of the list</p>
 """
 
         self.assertEquals(renderers.safe_docstring_display(docstring),
                           expected_docstring)