From d0c435bca047cd71a956c7efbd813ff007d934b4 Mon Sep 17 00:00:00 2001
From: Christopher Grebs <cg@webshox.org>
Date: Tue, 19 Feb 2019 08:01:14 +0100
Subject: [PATCH] Remove Legacy API (#10705)

Fixes #9274

* Part 1: Remove legacy api
* Smaller cleanups
* Restore opensearch
* Remove CompatOverride.is_hosted
* Remove one more test
* Fix AuthenticationMiddlewareWithoutAPI middleware
---
 src/olympia/addons/models.py                  |    4 -
 src/olympia/addons/tests/test_models.py       |    8 -
 src/olympia/amo/middleware.py                 |    8 +-
 src/olympia/amo/tests/test_middleware.py      |    8 -
 src/olympia/amo/tests/test_redirects.py       |    7 -
 src/olympia/amo/tests/test_url_prefix.py      |   12 -
 src/olympia/amo/tests/test_views.py           |    6 -
 src/olympia/amo/urls.py                       |    8 +-
 src/olympia/amo/utils.py                      |   32 +
 src/olympia/amo/views.py                      |   17 +-
 src/olympia/bandwagon/urls.py                 |    2 -
 src/olympia/bandwagon/views.py                |   21 +-
 src/olympia/legacy_api/__init__.py            |    3 -
 src/olympia/legacy_api/models.py              |    0
 .../templates/legacy_api/addon_detail.xml     |    2 -
 .../templates/legacy_api/compat.xml           |   27 -
 .../templates/legacy_api/includes/addon.xml   |  130 --
 .../legacy_api/templates/legacy_api/list.xml  |    6 -
 .../templates/legacy_api/message.xml          |   11 -
 .../templates/legacy_api/search.xml           |   13 -
 src/olympia/legacy_api/tests/__init__.py      |    0
 src/olympia/legacy_api/tests/test_utils.py    |   13 -
 src/olympia/legacy_api/tests/test_views.py    | 1253 -----------------
 src/olympia/legacy_api/urls.py                |   74 -
 src/olympia/legacy_api/utils.py               |  221 ---
 src/olympia/legacy_api/views.py               |  493 -------
 src/olympia/legacy_discovery/modules.py       |   88 +-
 src/olympia/lib/settings_base.py              |    1 -
 .../search/tests/test_search_ranking.py       |   10 +-
 src/olympia/urls.py                           |    3 -
 30 files changed, 126 insertions(+), 2355 deletions(-)
 delete mode 100644 src/olympia/legacy_api/__init__.py
 delete mode 100644 src/olympia/legacy_api/models.py
 delete mode 100644 src/olympia/legacy_api/templates/legacy_api/addon_detail.xml
 delete mode 100644 src/olympia/legacy_api/templates/legacy_api/compat.xml
 delete mode 100644 src/olympia/legacy_api/templates/legacy_api/includes/addon.xml
 delete mode 100644 src/olympia/legacy_api/templates/legacy_api/list.xml
 delete mode 100644 src/olympia/legacy_api/templates/legacy_api/message.xml
 delete mode 100644 src/olympia/legacy_api/templates/legacy_api/search.xml
 delete mode 100644 src/olympia/legacy_api/tests/__init__.py
 delete mode 100644 src/olympia/legacy_api/tests/test_utils.py
 delete mode 100644 src/olympia/legacy_api/tests/test_views.py
 delete mode 100644 src/olympia/legacy_api/urls.py
 delete mode 100644 src/olympia/legacy_api/utils.py
 delete mode 100644 src/olympia/legacy_api/views.py

diff --git a/src/olympia/addons/models.py b/src/olympia/addons/models.py
index 396195fc00..b30b6c2ec8 100644
--- a/src/olympia/addons/models.py
+++ b/src/olympia/addons/models.py
@@ -2054,10 +2054,6 @@ class CompatOverride(ModelBase):
         else:
             return self.guid
 
-    def is_hosted(self):
-        """Am I talking about an add-on on AMO?"""
-        return bool(self.addon_id)
-
     @staticmethod
     def transformer(overrides):
         if not overrides:
diff --git a/src/olympia/addons/tests/test_models.py b/src/olympia/addons/tests/test_models.py
index afb8247326..b96ee4a482 100644
--- a/src/olympia/addons/tests/test_models.py
+++ b/src/olympia/addons/tests/test_models.py
@@ -2765,14 +2765,6 @@ class TestCompatOverride(TestCase):
             actual = getattr(obj, key)
             assert actual == expected
 
-    def test_is_hosted(self):
-        c = CompatOverride.objects.create(guid='a')
-        assert not c.is_hosted()
-
-        Addon.objects.create(type=1, guid='b')
-        c = CompatOverride.objects.create(guid='b')
-        assert c.is_hosted()
-
     def test_override_type(self):
         one = CompatOverride.objects.get(guid='one')
 
diff --git a/src/olympia/amo/middleware.py b/src/olympia/amo/middleware.py
index 14029cd44a..cd4b20aec2 100644
--- a/src/olympia/amo/middleware.py
+++ b/src/olympia/amo/middleware.py
@@ -97,11 +97,6 @@ class LocaleAndAppURLMiddleware(MiddlewareMixin):
         activate(request.LANG)
         request.APP = amo.APPS.get(prefixer.app, amo.FIREFOX)
 
-        # Match legacy api requests too - IdentifyAPIRequestMiddleware is v3+
-        # TODO - remove this when legacy_api goes away
-        # https://github.com/mozilla/addons-server/issues/9274
-        request.is_legacy_api = request.path_info.startswith('/api/')
-
 
 class AuthenticationMiddlewareWithoutAPI(AuthenticationMiddleware):
     """
@@ -109,8 +104,7 @@ class AuthenticationMiddlewareWithoutAPI(AuthenticationMiddleware):
     own authentication mechanism.
     """
     def process_request(self, request):
-        legacy_or_drf_api = request.is_api or request.is_legacy_api
-        if legacy_or_drf_api and not auth_path.match(request.path):
+        if request.is_api and not auth_path.match(request.path):
             request.user = AnonymousUser()
         else:
             return super(
diff --git a/src/olympia/amo/tests/test_middleware.py b/src/olympia/amo/tests/test_middleware.py
index 14118a769c..a09372d735 100644
--- a/src/olympia/amo/tests/test_middleware.py
+++ b/src/olympia/amo/tests/test_middleware.py
@@ -37,7 +37,6 @@ class TestMiddleware(TestCase):
     def test_authentication_used_outside_the_api(self, process_request):
         req = RequestFactory().get('/')
         req.is_api = False
-        req.is_legacy_api = False
         AuthenticationMiddlewareWithoutAPI().process_request(req)
         assert process_request.called
 
@@ -46,13 +45,6 @@ class TestMiddleware(TestCase):
     def test_authentication_not_used_with_the_api(self, process_request):
         req = RequestFactory().get('/')
         req.is_api = True
-        req.is_legacy_api = False
-        AuthenticationMiddlewareWithoutAPI().process_request(req)
-        assert not process_request.called
-
-        req = RequestFactory().get('/')
-        req.is_api = False
-        req.is_legacy_api = True
         AuthenticationMiddlewareWithoutAPI().process_request(req)
         assert not process_request.called
 
diff --git a/src/olympia/amo/tests/test_redirects.py b/src/olympia/amo/tests/test_redirects.py
index 13549b8ae0..53ff7ab6a4 100644
--- a/src/olympia/amo/tests/test_redirects.py
+++ b/src/olympia/amo/tests/test_redirects.py
@@ -30,13 +30,6 @@ class TestRedirects(TestCase):
         redirect = response.redirect_chain[-1][0]
         assert redirect.endswith('/en-US/firefox/addon/5326/')
 
-    def test_utf8(self):
-        """Without proper unicode handling this will fail."""
-        response = self.client.get(u'/api/1.5/search/ツールバー',
-                                   follow=True)
-        # Sphinx will be off so let's just test that it redirects.
-        assert response.redirect_chain[0][1] == 302
-
     def test_reviews(self):
         response = self.client.get('/reviews/display/4', follow=True)
         self.assert3xx(response, '/en-US/firefox/addon/a4/reviews/',
diff --git a/src/olympia/amo/tests/test_url_prefix.py b/src/olympia/amo/tests/test_url_prefix.py
index 85a58999ab..d680764708 100644
--- a/src/olympia/amo/tests/test_url_prefix.py
+++ b/src/olympia/amo/tests/test_url_prefix.py
@@ -81,18 +81,6 @@ class MiddlewareTest(TestCase):
         response = self.process('/api/v4/some/endpoint/')
         assert response is None
 
-    def test_v1_api_is_identified_as_api_request(self):
-        response = self.process('/en-US/firefox/api/')
-        assert response is None
-        assert self.request.LANG == 'en-US'
-        assert self.request.is_legacy_api
-
-        # double-check _only_ /api/ is marked as .is_api
-        response = self.process('/en-US/firefox/apii/')
-        assert response is None
-        assert self.request.LANG == 'en-US'
-        assert not self.request.is_legacy_api
-
     def test_vary(self):
         response = self.process('/')
         assert response['Vary'] == 'Accept-Language, User-Agent'
diff --git a/src/olympia/amo/tests/test_views.py b/src/olympia/amo/tests/test_views.py
index 9dd95fa0f9..6c308a86e2 100644
--- a/src/olympia/amo/tests/test_views.py
+++ b/src/olympia/amo/tests/test_views.py
@@ -384,12 +384,6 @@ class TestCORS(TestCase):
         assert not response.has_header('Access-Control-Allow-Origin')
         assert not response.has_header('Access-Control-Allow-Credentials')
 
-    def test_no_cors_legacy_api(self):
-        response = self.get('/en-US/firefox/api/1.5/search/test')
-        assert response.status_code == 200
-        assert not response.has_header('Access-Control-Allow-Origin')
-        assert not response.has_header('Access-Control-Allow-Credentials')
-
     def test_cors_api_v3(self):
         url = reverse_ns('addon-detail', api_version='v3', args=(3615,))
         assert '/api/v3/' in url
diff --git a/src/olympia/amo/urls.py b/src/olympia/amo/urls.py
index 1a96377041..2c0d55cb75 100644
--- a/src/olympia/amo/urls.py
+++ b/src/olympia/amo/urls.py
@@ -1,9 +1,8 @@
 from django.conf.urls import include, url
 from django.views.decorators.cache import never_cache
 
-from olympia.legacy_api import views as legacy_views
-
 from . import views
+from .utils import render_xml
 
 
 services_patterns = [
@@ -20,8 +19,7 @@ urlpatterns = [
     url(r'^contribute\.json$', views.contribute, name='contribute.json'),
     url(r'^services/', include(services_patterns)),
     url(r'^__version__$', views.version, name='version.json'),
-
-    url(r'^opensearch\.xml$', legacy_views.render_xml,
-        {'template': 'amo/opensearch.xml'},
+    url(r'^opensearch\.xml$', render_xml, {'template': 'amo/opensearch.xml'},
         name='amo.opensearch'),
+
 ]
diff --git a/src/olympia/amo/utils.py b/src/olympia/amo/utils.py
index 2cc3ec06bf..93369bfc76 100644
--- a/src/olympia/amo/utils.py
+++ b/src/olympia/amo/utils.py
@@ -49,6 +49,8 @@ from html5lib.serializer import HTMLSerializer
 from PIL import Image
 from rest_framework.utils.encoders import JSONEncoder
 
+from django.db.transaction import non_atomic_requests
+
 from olympia.core.logger import getLogger
 from olympia.amo import ADDON_ICON_SIZES, search
 from olympia.amo.pagination import ESPaginator
@@ -71,6 +73,36 @@ def from_string(string):
     return engines['jinja2'].from_string(string)
 
 
+def render_xml_to_string(request, template, context=None):
+    from olympia.amo.templatetags.jinja_helpers import strip_controls
+
+    if context is None:
+        context = {}
+
+    xml_env = engines['jinja2'].env.overlay()
+    old_finalize = xml_env.finalize
+    xml_env.finalize = lambda x: strip_controls(old_finalize(x))
+
+    for processor in engines['jinja2'].context_processors:
+        context.update(processor(request))
+
+    template = xml_env.get_template(template)
+    return template.render(context)
+
+
+@non_atomic_requests
+def render_xml(request, template, context=None, **kwargs):
+    """Safely renders xml, stripping out nasty control characters."""
+    if context is None:
+        context = {}
+    rendered = render_xml_to_string(request, template, context)
+
+    if 'content_type' not in kwargs:
+        kwargs['content_type'] = 'text/xml'
+
+    return HttpResponse(rendered, **kwargs)
+
+
 def days_ago(n):
     return datetime.datetime.now() - datetime.timedelta(days=n)
 
diff --git a/src/olympia/amo/views.py b/src/olympia/amo/views.py
index cd17d53097..ca5130f027 100644
--- a/src/olympia/amo/views.py
+++ b/src/olympia/amo/views.py
@@ -13,7 +13,7 @@ import six
 from django_statsd.clients import statsd
 from rest_framework.exceptions import NotFound
 
-from olympia import amo, legacy_api
+from olympia import amo
 from olympia.amo.utils import render
 
 from . import monitors
@@ -68,11 +68,7 @@ def contribute(request):
 
 @non_atomic_requests
 def handler403(request, **kwargs):
-    if request.is_legacy_api:
-        # Pass over to handler403 view in api if api was targeted.
-        return legacy_api.views.handler403(request)
-    else:
-        return render(request, 'amo/403.html', status=403)
+    return render(request, 'amo/403.html', status=403)
 
 
 @non_atomic_requests
@@ -81,9 +77,6 @@ def handler404(request, **kwargs):
         # It's a v3+ api request
         return JsonResponse(
             {'detail': six.text_type(NotFound.default_detail)}, status=404)
-    elif request.is_legacy_api:
-        # It's a legacy api request - pass over to legacy api handler404.
-        return legacy_api.views.handler404(request)
     # X_IS_MOBILE_AGENTS is set by nginx as an env variable when it detects
     # a mobile User Agent or when the mamo cookie is present.
     if request.META.get('X_IS_MOBILE_AGENTS') == '1':
@@ -94,11 +87,7 @@ def handler404(request, **kwargs):
 
 @non_atomic_requests
 def handler500(request, **kwargs):
-    if getattr(request, 'is_legacy_api', False):
-        # Pass over to handler500 view in api if api was targeted.
-        return legacy_api.views.handler500(request)
-    else:
-        return render(request, 'amo/500.html', status=500)
+    return render(request, 'amo/500.html', status=500)
 
 
 @non_atomic_requests
diff --git a/src/olympia/bandwagon/urls.py b/src/olympia/bandwagon/urls.py
index 4bcffba7b2..e66b9227fb 100644
--- a/src/olympia/bandwagon/urls.py
+++ b/src/olympia/bandwagon/urls.py
@@ -11,8 +11,6 @@ edit_urls = [
 
 detail_urls = [
     url(r'^$', views.collection_detail, name='collections.detail'),
-    url(r'^format:json$', views.collection_detail_json,
-        name='collections.detail.json'),
     url(r'^edit/', include(edit_urls)),
     url(r'^delete$', views.delete, name='collections.delete'),
     url(r'^(?P<action>add|remove)$', views.collection_alter,
diff --git a/src/olympia/bandwagon/views.py b/src/olympia/bandwagon/views.py
index 828b194844..8b4fd93e92 100644
--- a/src/olympia/bandwagon/views.py
+++ b/src/olympia/bandwagon/views.py
@@ -24,13 +24,12 @@ from olympia.addons.models import Addon
 from olympia.addons.views import BaseFilter
 from olympia.amo import messages
 from olympia.amo.decorators import (
-    allow_mine, json_view, login_required, post_required, use_primary_db)
+    allow_mine, login_required, post_required, use_primary_db)
 from olympia.amo.urlresolvers import reverse
 from olympia.amo.utils import paginate, render, urlparams
 from olympia.api.filters import OrderingAliasFilter
 from olympia.api.permissions import (
     AllOf, AllowReadOnlyIfPublic, AnyOf, PreventActionPermission)
-from olympia.legacy_api.utils import addon_to_dict
 from olympia.translations.query import order_by_translation
 from olympia.users.decorators import process_user_id
 from olympia.users.models import UserProfile
@@ -194,24 +193,6 @@ def collection_detail(request, user_id, slug):
                        'user_perms': user_perms})
 
 
-@json_view(has_trans=True)
-@allow_mine
-@process_user_id
-@non_atomic_requests
-def collection_detail_json(request, user_id, slug):
-    collection = get_collection(request, user_id, slug)
-    if not (collection.listed or acl.check_collection_ownership(
-            request, collection)):
-        raise PermissionDenied
-    # We evaluate the QuerySet with `list` to work around bug 866454.
-    addons_dict = [addon_to_dict(a) for a in list(collection.addons.valid())]
-    return {
-        'name': collection.name,
-        'url': collection.get_abs_url(),
-        'addons': addons_dict
-    }
-
-
 def get_notes(collection, raw=False):
     # This might hurt in a big collection with lots of notes.
     # It's a generator so we don't evaluate anything by default.
diff --git a/src/olympia/legacy_api/__init__.py b/src/olympia/legacy_api/__init__.py
deleted file mode 100644
index c77f97f73d..0000000000
--- a/src/olympia/legacy_api/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-MIN_VERSION = 1.0
-CURRENT_VERSION = 1.5
-MAX_VERSION = CURRENT_VERSION
diff --git a/src/olympia/legacy_api/models.py b/src/olympia/legacy_api/models.py
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/src/olympia/legacy_api/templates/legacy_api/addon_detail.xml b/src/olympia/legacy_api/templates/legacy_api/addon_detail.xml
deleted file mode 100644
index aba3012b04..0000000000
--- a/src/olympia/legacy_api/templates/legacy_api/addon_detail.xml
+++ /dev/null
@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-{% include 'legacy_api/includes/addon.xml' %}
diff --git a/src/olympia/legacy_api/templates/legacy_api/compat.xml b/src/olympia/legacy_api/templates/legacy_api/compat.xml
deleted file mode 100644
index d72317b094..0000000000
--- a/src/olympia/legacy_api/templates/legacy_api/compat.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-{% for c in compat %}
-<addon_compatibility
-    hosted="{{ c.is_hosted()|json }}"
-    {% if c.addon_id %}id="{{ c.addon_id }}"{% endif %}>
-    <guid>{{ c.guid }}</guid>
-    <name>{{ c.name }}</name>
-    <version_ranges>
-      {% for vr in c.collapsed_ranges() %}
-        <version_range type="{{ vr.type }}">
-          <min_version>{{ vr.min }}</min_version>
-          <max_version>{{ vr.max }}</max_version>
-          <compatible_applications>
-            {% for app in vr.apps %}
-              <application>
-                <name>{{ app.app.pretty }}</name>
-                <application_id>{{ app.app.id }}</application_id>
-                <min_version>{{ app.min }}</min_version>
-                <max_version>{{ app.max }}</max_version>
-                <appID>{{ app.app.guid }}</appID>
-              </application>
-            {% endfor %}
-          </compatible_applications>
-        </version_range>
-      {% endfor %}
-    </version_ranges>
-</addon_compatibility>
-{% endfor %}
diff --git a/src/olympia/legacy_api/templates/legacy_api/includes/addon.xml b/src/olympia/legacy_api/templates/legacy_api/includes/addon.xml
deleted file mode 100644
index 34c460710c..0000000000
--- a/src/olympia/legacy_api/templates/legacy_api/includes/addon.xml
+++ /dev/null
@@ -1,130 +0,0 @@
-{% set new_api = (api_version >= 1.5) %}
-{% if addon.compat_version %}
-  {% set version = addon.compat_version %}
-{% else %}
-  {% set version = addon.current_version %}
-{% endif %}
-<addon id="{{ addon.id }}">
-  <name>{{ addon.name }}</name>
-  <type id="{{ addon.type }}">{{ amo.ADDON_TYPE[addon.type] }}</type>
-  <guid>{{ addon.guid }}</guid>
-  <slug>{{ addon.slug }}</slug>
-  <version>{{ version.version }}</version>
-  <status id="{{ addon.status }}">{{ addon.STATUS_CHOICES[addon.status] }}</status>
-  <authors>
-    {% if not addon.is_persona() %}
-    {% for author in addon.listed_authors -%}
-    {%- if new_api -%}
-    <author id="{{ author.id }}">
-      <name>{{ author.name }}</name>
-      <link>{{ author.get_url_path()|absolutify|urlparams(src='api') }}</link>
-    </author>
-    {%- else -%}
-    <author>{{ author.name }}</author>
-    {%- endif -%}
-    {%- endfor %}
-    {% endif %}
-  </authors>
-  <summary>{%- if new_api -%}{{ addon.summary }}{% else %}{{ addon.summary|clean(true) }}{% endif -%}</summary>
-  <description>{%- if new_api %}{{ addon.description }}{% else -%}{{ addon.description|clean(true) }}{% endif %}</description>
-  {%- if version and version.license -%}
-  <license>
-    <name>{{ version.license.name }}</name>
-    <url>
-      {%- if not version.license.url -%}
-      {{ version.license_url()|absolutify }}
-      {%- else -%}
-      {{ version.license.url|absolutify }}
-      {%- endif -%}
-    </url>
-  </license>
-  {%- endif -%}
-  {# The 32px icon must be the last icon specified. #}
-  <icon size="64">{{ addon.get_icon_url(64, use_default=False) }}</icon>
-  <icon size="32">{{ addon.get_icon_url(32, use_default=False) }}</icon>
-  <compatible_applications>
-    {%- if version -%}
-    {%- for app in version.compatible_apps.values() %}
-    {%- if amo.APP_IDS.get(app.application) -%}
-    <application>
-      <name>{{ amo.APP_IDS[app.application].pretty }}</name>
-      <application_id>{{ app.application }}</application_id>
-      <min_version>{{ app.min }}</min_version>
-      <max_version>{{ app.max }}</max_version>
-      <appID>{{ amo.APP_IDS[app.application].guid }}</appID>
-    </application>
-    {%- endif -%}
-    {%- endfor -%}
-    {%- endif -%}
-  </compatible_applications>
-  <all_compatible_os>
-    {%- if version -%}
-    {% for os in version.supported_platforms -%}
-    <os>{{ os.api_name }}</os>
-    {%- endfor -%}
-    {%- endif -%}
-  </all_compatible_os>
-  <eula>{%- if new_api %}{{ addon.eula }}{% else %}{{ addon.eula|clean(true) }}{% endif -%}</eula>
-  {%- if new_api -%}
-  <previews>
-    {%- for preview in addon.current_previews -%}
-    <preview position="{{ preview.position|int }}">
-      <full type="image/png"{% with sizes=preview.image_size -%}{% if sizes %} width="{{ sizes[0] }}" height="{{ sizes[1] }}"{% endif %}{% endwith -%}>
-        {{ preview.image_url|urlparams(src='api') }}
-      </full>
-      <thumbnail type="image/png"{% with sizes=preview.thumbnail_size -%}{% if sizes %} width="{{ sizes[0] }}" height="{{ sizes[1] }}"{% endif %}{% endwith -%}>
-        {{ preview.thumbnail_url|urlparams(src='api') }}
-      </thumbnail>
-      {%- if preview.caption -%}
-        <caption>{{ preview.caption }}</caption>
-      {%- endif -%}
-    </preview>
-    {%- endfor -%}
-  </previews>
-  {%- else -%}
-  <thumbnail>{{ addon.thumbnail_url }}</thumbnail>
-  {%- endif -%}
-  <rating>{{ addon.average_rating|round|int }}</rating>
-  <learnmore>{{ addon.get_url_path()|absolutify|urlparams(src='api') }}</learnmore>
-  {%- if version -%}
-  {%- for file in version.all_files -%}
-  <install hash="{{ file.hash }}"
-    os="{{ amo.PLATFORMS[file.platform].api_name }}"
-    size="{{ file.size }}">{{ file.get_url_path('api') }}</install>
-  {% endfor -%}
-  {%- endif -%}
-  {%- if new_api %}
-    {%- if addon.contributions -%}
-    <contribution_data>
-      <meet_developers>
-        {{ addon.contributions }}
-      </meet_developers>
-    </contribution_data>
-    {%- endif -%}
-    <developer_comments>{{ addon.developer_comments }}</developer_comments>
-    <reviews num="{{ addon.total_ratings }}">
-      {{ addon.ratings_url|absolutify|urlparams(src='api') }}
-    </reviews>
-    <total_downloads>{{ addon.total_downloads }}</total_downloads>
-    <weekly_downloads>{{ addon.weekly_downloads }}</weekly_downloads>
-    <daily_users>{{ addon.average_daily_users }}</daily_users>
-    <created epoch="{{ addon.created|epoch }}">
-      {{ addon.created|isotime }}
-    </created>
-    <last_updated epoch="{{ addon.last_updated|epoch }}">
-      {{ addon.last_updated|isotime }}
-    </last_updated>
-    <homepage>{{ addon.homepage }}</homepage>
-    <support>{{ addon.support_url }}</support>
-    <featured>{{ addon.is_featured(request.APP, request.LANG)|int }}</featured>
-    {# Only kept for backwards compatibility of the API #}
-    <performance>
-    </performance>
-
-    {% if show_localepicker -%}
-    <strings><![CDATA[
-{{ addon.get_localepicker() }}
-    ]]></strings>
-    {% endif %}
-  {%- endif -%}
-</addon>
diff --git a/src/olympia/legacy_api/templates/legacy_api/list.xml b/src/olympia/legacy_api/templates/legacy_api/list.xml
deleted file mode 100644
index 0569785cd9..0000000000
--- a/src/olympia/legacy_api/templates/legacy_api/list.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<addons>
-  {% for addon in addons %}
-    {% include 'legacy_api/includes/addon.xml' %}
-  {% endfor %}
-</addons>
diff --git a/src/olympia/legacy_api/templates/legacy_api/message.xml b/src/olympia/legacy_api/templates/legacy_api/message.xml
deleted file mode 100644
index 7f42224c3e..0000000000
--- a/src/olympia/legacy_api/templates/legacy_api/message.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-{# Compatibility across both Piston and DRF on error messages/vars. #}
-{% if detail %}
-  <error>{{_(detail)}}</error>
-{% else %}
-  {% if error_level %}
-    <error>{{_(msg)}}</error>
-  {% else %}
-    <msg>{{_(msg)}}</msg>
-  {% endif %}
-{% endif %}
diff --git a/src/olympia/legacy_api/templates/legacy_api/search.xml b/src/olympia/legacy_api/templates/legacy_api/search.xml
deleted file mode 100644
index 686c43a205..0000000000
--- a/src/olympia/legacy_api/templates/legacy_api/search.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<searchresults total_results="{{ total }}">
-  {% if addons_xml %}
-      {% for xml in addons_xml %}
-          {{ xml|xssafe }}
-      {% endfor %}
-  {% else %}
-      {% for addon in results -%}
-          {% include 'legacy_api/includes/addon.xml' -%}
-      {% endfor %}
-  {% endif %}
-  {% if compat %}{% include 'legacy_api/compat.xml' %}{% endif %}
-</searchresults>
diff --git a/src/olympia/legacy_api/tests/__init__.py b/src/olympia/legacy_api/tests/__init__.py
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/src/olympia/legacy_api/tests/test_utils.py b/src/olympia/legacy_api/tests/test_utils.py
deleted file mode 100644
index 91da050ebc..0000000000
--- a/src/olympia/legacy_api/tests/test_utils.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from olympia import amo
-from olympia.amo.tests import TestCase, addon_factory, version_factory
-from olympia.legacy_api.utils import find_compatible_version
-
-
-class TestCompatibleVersion(TestCase):
-    def test_compatible_version(self):
-        addon = addon_factory()
-        version = version_factory(addon=addon, version='99')
-        version_factory(
-            addon=addon, version='100',
-            channel=amo.RELEASE_CHANNEL_UNLISTED)
-        assert find_compatible_version(addon, amo.FIREFOX.id) == version
diff --git a/src/olympia/legacy_api/tests/test_views.py b/src/olympia/legacy_api/tests/test_views.py
deleted file mode 100644
index a711d24ea6..0000000000
--- a/src/olympia/legacy_api/tests/test_views.py
+++ /dev/null
@@ -1,1253 +0,0 @@
-# -*- coding: utf-8 -*-
-import json
-
-from textwrap import dedent
-
-from django.conf import settings
-from django.test.client import Client
-from django.utils import translation
-from django.utils.encoding import force_text
-
-import jinja2
-import pytest
-import six
-
-from mock import patch
-from pyquery import PyQuery as pq
-
-from olympia import amo, legacy_api
-from olympia.addons.models import (
-    Addon, AppSupport, CompatOverride, CompatOverrideRange, Persona, Preview)
-from olympia.amo.templatetags import jinja_helpers
-from olympia.amo.tests import ESTestCase, TestCase, addon_factory
-from olympia.amo.urlresolvers import reverse
-from olympia.amo.views import handler500
-from olympia.applications.models import AppVersion
-from olympia.bandwagon.models import (
-    Collection, CollectionAddon, FeaturedCollection)
-from olympia.files.models import File
-from olympia.files.tests.test_models import UploadTest
-from olympia.legacy_api.utils import addon_to_dict
-from olympia.legacy_api.views import addon_filter
-from olympia.tags.models import AddonTag, Tag
-
-
-pytestmark = pytest.mark.django_db
-
-
-def api_url(x, app='firefox', lang='en-US', version=1.5):
-    return '/%s/%s/api/%s/%s' % (lang, app, version, x)
-
-
-client = Client()
-
-
-def make_call(*args, **kwargs):
-    return client.get(api_url(*args, **kwargs))
-
-
-def test_json_not_implemented():
-    assert legacy_api.views.APIView().render_json({}) == (
-        '{"msg": "Not implemented yet."}')
-
-
-class UtilsTest(TestCase):
-    fixtures = ['base/addon_3615']
-
-    def setUp(self):
-        super(UtilsTest, self).setUp()
-        self.a = Addon.objects.get(pk=3615)
-
-    def test_dict(self):
-        """Verify that we're getting dict."""
-        d = addon_to_dict(self.a)
-        assert d, 'Add-on dictionary not found'
-        assert d['learnmore'].endswith('/addon/a3615/?src=api'), (
-            'Add-on details URL does not end with "?src=api"')
-
-    def test_sanitize(self):
-        """Check that tags are stripped for summary and description."""
-        self.a.summary = self.a.description = 'i <3 <a href="">amo</a>!'
-        self.a.save()
-        d = addon_to_dict(self.a)
-        assert d['summary'] == 'i &lt;3 amo!'
-        assert d['description'] == 'i &lt;3 amo!'
-
-    def test_simple_contributions(self):
-        self.a.update(contributions='https://paypal.me/blah')
-        d = addon_to_dict(self.a)
-        assert d['contribution']['meet_developers'] == self.a.contributions
-        assert 'link' not in d['contribution']
-
-
-class No500ErrorsTest(TestCase):
-    """
-    A series of unfortunate urls that have caused 500 errors in the past.
-    """
-    def test_search_bad_type(self):
-        """
-        For search/:term/:addon_type <-- addon_type should be an integer.
-        """
-        response = make_call('/search/foo/theme')
-        # We'll likely get a 503 since Sphinx is off and that
-        # is good.  We just don't want 500 errors.
-        assert response.status_code != 500, "We received a 500 error, wtf?"
-
-    def test_list_bad_type(self):
-        """
-        For list/new/:addon_type <-- addon_type should be an integer.
-        """
-        response = make_call('/list/new/extension')
-        assert response.status_code != 500, "We received a 500 error, wtf?"
-
-    def test_utf_redirect(self):
-        """Test that urls with unicode redirect properly."""
-        response = make_call(u'search/ツールバー', version=1.5)
-        assert response.status_code != 500, "Unicode failed to redirect."
-
-    def test_manual_utf_search(self):
-        """If someone searches for non doubly encoded data using an old API we
-        should not try to decode it."""
-        response = make_call(u'search/für', version=1.2)
-        assert response.status_code != 500, "ZOMG Unicode fails."
-
-    def test_broken_guid(self):
-        response = make_call(u'search/guid:+972"e4c6-}', version=1.5)
-        assert response.status_code != 500, "Failed to cope with guid"
-
-
-class ControlCharacterTest(TestCase):
-    """This test is to assure we aren't showing control characters."""
-
-    fixtures = ('base/addon_3615',)
-
-    def test(self):
-        addon = Addon.objects.get(pk=3615)
-        char = chr(12)
-        addon.name = "I %sove You" % char
-        addon.save()
-        response = make_call('addon/3615')
-        self.assertNotContains(response, char)
-
-
-class StripHTMLTest(TestCase):
-    fixtures = ('base/addon_3615',)
-
-    def test(self):
-        """For API < 1.5 we remove HTML."""
-        addon = Addon.objects.get(pk=3615)
-        addon.eula = '<i>free</i> stock tips'
-        addon.summary = '<i>xxx video</i>s'
-        addon.description = 'FFFF<b>UUUU</b>'
-        addon.save()
-
-        response = make_call('addon/3615', version=1.5)
-        doc = pq(response.content)
-        assert doc('eula').html() == '<i>free</i> stock tips'
-        assert doc('summary').html() == '&lt;i&gt;xxx video&lt;/i&gt;s'
-        assert doc('description').html() == 'FFFF<b>UUUU</b>'
-
-        response = make_call('addon/3615', version=1.2)
-        doc = pq(response.content)
-        assert doc('eula').html() == 'free stock tips'
-        assert doc('summary').html() == 'xxx videos'
-        assert doc('description').html() == 'FFFFUUUU'
-
-
-class APITest(TestCase):
-    fixtures = ['base/addon_3615', 'base/addon_4664_twitterbar',
-                'base/addon_5299_gcal']
-
-    def test_api_caching(self):
-        response = self.client.get('/en-US/firefox/api/1.5/addon/3615')
-        assert response.status_code == 200
-        self.assertContains(response, '<author id="')
-
-        # Make sure we don't cache the 1.5 response for 1.2.
-        response = self.client.get('/en-US/firefox/api/1.2/addon/3615')
-        assert response.status_code == 200
-        self.assertContains(response, '<author>')
-
-    def test_redirection(self):
-        """
-        Test that /api/addon is redirected to /api/LATEST_API_VERSION/addon
-        """
-        response = self.client.get('/en-US/firefox/api/addon/12', follow=True)
-        last_link = response.redirect_chain[-1]
-        assert last_link[0].endswith(
-            'en-US/firefox/api/%.1f/addon/12' % legacy_api.CURRENT_VERSION)
-
-    def test_forbidden_api(self):
-        """
-        APIs older than api.MIN_VERSION are deprecated, and we send a 403.
-        We suggest people to use api.CURRENT_VERSION.
-        """
-
-        response = self.client.get('/en-US/firefox/api/0.9/addon/12')
-        self.assertContains(
-            response,
-            'The API version, %.1f, you are using is not valid. Please upgrade'
-            ' to the current version %.1f API.' % (
-                0.9, legacy_api.CURRENT_VERSION),
-            status_code=403)
-
-    def test_addon_detail_missing(self):
-        """
-        Check missing addons.
-        """
-        response = self.client.get(
-            '/en-US/firefox/api/%.1f/addon/999' % legacy_api.CURRENT_VERSION)
-
-        self.assertContains(response, 'Add-on not found!', status_code=404)
-
-    def test_handler404(self):
-        """
-        Check separate handler404 response for API.
-        """
-        response = self.client.get('/en-US/firefox/api/nonsense')
-        doc = pq(response.content)
-        assert response.status_code == 404
-        d = doc('error')
-        self.assertTemplateUsed(response, 'legacy_api/message.xml')
-        assert d.length == 1
-        assert d.text() == 'Not Found'
-
-    def test_handler500(self):
-        """
-        Check separate handler500 response for API.
-        """
-        req = self.client.get('/en-US/firefox/api/').context['request']
-        try:
-            raise NameError('an error')
-        except NameError:
-            r = handler500(req)
-            assert r.status_code == 500
-            doc = pq(r.content)
-            d = doc('error')
-            assert d.length == 1
-            assert d.text() == 'Server Error'
-
-    def test_addon_detail_appid(self):
-        """
-        Make sure we serve an appid.  See
-        https://bugzilla.mozilla.org/show_bug.cgi?id=546542.
-        """
-        response = self.client.get('/en-US/firefox/api/%.1f/addon/3615' %
-                                   legacy_api.CURRENT_VERSION)
-        self.assertContains(
-            response, '<appID>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</appID>')
-
-    def test_addon_detail_empty_eula(self):
-        """
-        Empty EULA should show up as '' not None.  See
-        https://bugzilla.mozilla.org/show_bug.cgi?id=546542.
-        """
-        response = self.client.get('/en-US/firefox/api/%.1f/addon/4664' %
-                                   legacy_api.CURRENT_VERSION)
-        self.assertContains(response, '<eula></eula>')
-
-    def test_addon_detail_rating(self):
-        a = Addon.objects.get(pk=4664)
-        response = self.client.get('/en-US/firefox/api/%.1f/addon/4664' %
-                                   legacy_api.CURRENT_VERSION)
-        self.assertContains(response, '<rating>%d</rating>' %
-                            int(round(a.average_rating)))
-
-    def test_addon_detail_xml(self):
-        response = self.client.get('/en-US/firefox/api/%.1f/addon/3615' % 1.2)
-
-        self.assertContains(response, "<name>Delicious Bookmarks</name>")
-        self.assertContains(response, """id="1">Extension</type>""")
-        self.assertContains(
-            response, "<guid>{2fa4ed95-0317-4c6a-a74c-5f3e3912c1f9}</guid>")
-        self.assertContains(response, "<version>2.1.072</version>")
-        self.assertContains(response, '<status id="4">Approved</status>')
-        self.assertContains(
-            response, u'<author>55021 \u0627\u0644\u062a\u0637\u0628</author>')
-        self.assertContains(response, "<summary>Delicious Bookmarks is the")
-        self.assertContains(response, "<description>This extension integrates")
-
-        icon_url = "%s3/3615-32.png" % jinja_helpers.user_media_url(
-            'addon_icons')
-        self.assertContains(response, '<icon size="32">' + icon_url)
-        self.assertContains(response, "<application>")
-        self.assertContains(response, "<name>Firefox</name>")
-        self.assertContains(response, "<application_id>1</application_id>")
-        self.assertContains(response, "<min_version>2.0</min_version>")
-        self.assertContains(response, "<max_version>4.0</max_version>")
-        self.assertContains(response, "<os>ALL</os>")
-        self.assertContains(response, "<eula>")
-        self.assertContains(response, "/icons/no-preview.png</thumbnail>")
-        self.assertContains(response, "<rating>3</rating>")
-        self.assertContains(
-            response, "/en-US/firefox/addon/a3615/?src=api</learnmore>")
-        self.assertContains(
-            response,
-            'hash="sha256:3808b13ef8341378b9c8305ca648200954ee7dcd8dce09fef55f'
-            '2673458bc31f"')
-
-    def test_addon_detail_json(self):
-        addon = Addon.objects.get(id=3615)
-        response = self.client.get(
-            '/en-US/firefox/api/%.1f/addon/3615?format=json' % 1.2)
-        data = json.loads(force_text(response.content))
-        assert data['name'] == six.text_type(addon.name)
-        assert data['type'] == 'extension'
-        assert data['guid'] == addon.guid
-        assert data['version'] == '2.1.072'
-        assert data['status'] == 'public'
-        assert data['authors'] == (
-            [{
-                'id': 55021,
-                'name': u'55021 \u0627\u0644\u062a\u0637\u0628',
-                'link': jinja_helpers.absolutify(
-                    u'/en-US/firefox/user/55021/?src=api')}])
-        assert data['summary'] == six.text_type(addon.summary)
-        assert data['description'] == (
-            'This extension integrates your browser with Delicious '
-            '(http://delicious.com), the leading social bookmarking '
-            'service on the Web.')
-        assert data['icon'] == (
-            '%s3/3615-32.png?modified=1275037317' %
-            jinja_helpers.user_media_url('addon_icons'))
-        assert data['compatible_apps'] == (
-            [{'Firefox': {'max': '4.0', 'min': '2.0'}}])
-        assert data['eula'] == six.text_type(addon.eula)
-        assert data['learnmore'] == (
-            jinja_helpers.absolutify('/en-US/firefox/addon/a3615/?src=api'))
-        assert 'theme' not in data
-
-    def test_theme_detail(self):
-        addon = Addon.objects.get(id=3615)
-        addon.update(type=amo.ADDON_PERSONA)
-        Persona.objects.create(persona_id=3, addon=addon)
-        response = self.client.get(
-            '/en-US/firefox/api/%.1f/addon/3615?format=json' % 1.2)
-        data = json.loads(force_text(response.content))
-        assert data['id'] == 3615
-        # `id` should be `addon_id`, not `persona_id`
-        assert data['theme']['id'] == '3615'
-
-    def test_addon_license(self):
-        """Test for license information in response."""
-        addon = Addon.objects.get(id=3615)
-        license = addon.current_version.license
-        license.name = 'My License'
-        license.url = 'someurl'
-        license.save()
-        api_url = (
-            '/en-US/firefox/api/%.1f/addon/3615' % legacy_api.CURRENT_VERSION)
-        response = self.client.get(api_url)
-        doc = pq(response.content)
-        assert doc('license').length == 1
-        assert doc('license name').length == 1
-        assert doc('license url').length == 1
-        assert doc('license name').text() == six.text_type(license.name)
-        assert (
-            doc('license url').text() == jinja_helpers.absolutify(license.url))
-
-        license.url = ''
-        license.save()
-        addon.save()
-        response = self.client.get(api_url)
-        doc = pq(response.content)
-        license_url = addon.current_version.license_url()
-        assert (
-            doc('license url').text() == jinja_helpers.absolutify(license_url))
-
-        license.delete()
-        response = self.client.get(api_url)
-        doc = pq(response.content)
-        assert doc('license').length == 0
-
-    def test_whitespace(self):
-        """Whitespace is apparently evil for learnmore and install."""
-        r = make_call('addon/3615')
-        doc = pq(r.content)
-        learnmore = doc('learnmore')[0].text
-        assert learnmore == learnmore.strip()
-
-        install = doc('install')[0].text
-        assert install == install.strip()
-
-    def test_absolute_install_url(self):
-        response = make_call('addon/4664', version=1.2)
-        doc = pq(response.content)
-        url = doc('install').text()
-        expected = '%s/firefox/downloads/file' % settings.SITE_URL
-        assert url.startswith(expected), url
-
-    def test_15_addon_detail(self):
-        """
-        For an api>1.5 we need to verify we have:
-        # Contributions information, which is now just the contributions url,
-        # sent as the link to Meet the Developers
-        # Number of user reviews and link to view them
-        # Total downloads, weekly downloads, and latest daily user counts
-        # Add-on creation date
-        # Link to the developer's profile
-        # File size
-        """
-        def urlparams(x, *args, **kwargs):
-            return jinja2.escape(jinja_helpers.urlparams(x, *args, **kwargs))
-
-        needles = (
-            '<addon id="4664">',
-            '<contribution_data>',
-            '<meet_developers>',
-            'https://patreon.com/blah',
-            '</meet_developers>',
-            '<reviews num="131">',
-            '%s/en-US/firefox/addon/4664/reviews/?src=api' % settings.SITE_URL,
-            '<total_downloads>1352192</total_downloads>',
-            '<weekly_downloads>13849</weekly_downloads>',
-            '<daily_users>67075</daily_users>',
-            '<author id="2519"',
-            '%s/en-US/firefox/user/2519/?src=api</link>' % settings.SITE_URL,
-            '<previews>',
-            'preview position="0">',
-            '<caption>TwitterBar places an icon in the address bar.</caption>',
-            'full type="image/png">',
-            '<thumbnail type="image/png">',
-            ('<developer_comments>Embrace hug love hug meow meow'
-             '</developer_comments>'),
-            'size="100352"',
-            ('<homepage>http://www.chrisfinke.com/addons/twitterbar/'
-             '</homepage>'),
-            '<support>http://www.chrisfinke.com/addons/twitterbar/</support>')
-
-        # For urls with several parameters, we need to use self.assertUrlEqual,
-        # as the parameters could be in random order. Dicts aren't ordered!
-        # We need to subtract 7 hours from the modified time since May 3, 2008
-        # is during daylight savings time.
-        url_needles = {
-            "full": urlparams(
-                '{previews}full/20/20397.png'.format(
-                    previews=jinja_helpers.user_media_url('previews')),
-                src='api', modified=1209834208 - 7 * 3600),
-            "thumbnail": urlparams(
-                '{previews}thumbs/20/20397.png'.format(
-                    previews=jinja_helpers.user_media_url('previews')),
-                src='api', modified=1209834208 - 7 * 3600),
-        }
-
-        response = make_call('addon/4664', version=1.5)
-        doc = pq(response.content)
-
-        tags = {
-            'created': ({'epoch': '1174109035'}, '2007-03-17T05:23:55Z'),
-            'last_updated': ({'epoch': '1272301783'}, '2010-04-26T17:09:43Z')}
-
-        for tag, v in tags.items():
-            attrs, text = v
-            el = doc(tag)
-            for attr, val in attrs.items():
-                assert el.attr(attr) == val
-
-            assert el.text() == text
-
-        for needle in needles:
-            self.assertContains(response, needle)
-
-        for tag, needle in six.iteritems(url_needles):
-            url = doc(tag).text()
-            self.assertUrlEqual(url, needle)
-
-    def test_slug(self):
-        Addon.objects.get(pk=5299).update(type=amo.ADDON_EXTENSION)
-        self.assertContains(make_call('addon/5299', version=1.5),
-                            '<slug>%s</slug>' %
-                            Addon.objects.get(pk=5299).slug)
-
-    def test_is_featured(self):
-        self.assertContains(make_call('addon/5299', version=1.5),
-                            '<featured>0</featured>')
-        c = CollectionAddon.objects.create(
-            addon=Addon.objects.get(id=5299),
-            collection=Collection.objects.create())
-        FeaturedCollection.objects.create(
-            locale='ja', application=amo.FIREFOX.id, collection=c.collection)
-        for lang, app, result in [('ja', 'firefox', 1),
-                                  ('en-US', 'firefox', 0),
-                                  ('ja', 'android', 0)]:
-            self.assertContains(make_call('addon/5299', version=1.5,
-                                          lang=lang, app=app),
-                                '<featured>%s</featured>' % result)
-
-    def test_default_icon(self):
-        addon = Addon.objects.get(pk=5299)
-        addon.update(icon_type='')
-        self.assertContains(make_call('addon/5299'), '<icon size="32"></icon>')
-
-    def test_thumbnail_size(self):
-        addon = Addon.objects.get(pk=5299)
-        preview = Preview.objects.create(addon=addon)
-        preview.sizes = {'thumbnail': [200, 150]}
-        preview.save()
-        result = make_call('addon/5299', version=1.5)
-        self.assertContains(result, '<full type="image/png">')
-        self.assertContains(
-            result, '<thumbnail type="image/png" width="200" height="150">')
-
-    def test_disabled_addon(self):
-        Addon.objects.get(pk=3615).update(disabled_by_user=True)
-        response = self.client.get('/en-US/firefox/api/%.1f/addon/3615' %
-                                   legacy_api.CURRENT_VERSION)
-        doc = pq(response.content)
-        assert doc[0].tag == 'error'
-        assert response.status_code == 404
-
-    def test_addon_with_no_listed_versions(self):
-        self.make_addon_unlisted(Addon.objects.get(pk=3615))
-        response = self.client.get('/en-US/firefox/api/%.1f/addon/3615' %
-                                   legacy_api.CURRENT_VERSION)
-        doc = pq(response.content)
-        assert doc[0].tag == 'error'
-        assert response.status_code == 404
-
-    def test_cross_origin(self):
-        # Add-on details should allow cross-origin requests.
-        response = self.client.get('/en-US/firefox/api/%.1f/addon/3615' %
-                                   legacy_api.CURRENT_VERSION)
-
-        assert response['Access-Control-Allow-Origin'] == '*'
-        assert response['Access-Control-Allow-Methods'] == 'GET'
-
-        # Even those that are not found.
-        response = self.client.get('/en-US/firefox/api/%.1f/addon/999' %
-                                   legacy_api.CURRENT_VERSION)
-
-        assert response['Access-Control-Allow-Origin'] == '*'
-        assert response['Access-Control-Allow-Methods'] == 'GET'
-
-
-class ListTest(TestCase):
-    """Tests the list view with various urls."""
-    fixtures = ['base/users', 'base/addon_3615', 'base/featured',
-                'addons/featured', 'bandwagon/featured_collections',
-                'base/collections']
-
-    def test_defaults(self):
-        """
-        This tests the default settings for /list.
-        i.e. We should get 3 items by default.
-        """
-        response = make_call('list')
-        self.assertContains(response, '<addon id', 3)
-
-    def test_type_filter(self):
-        """
-        This tests that list filtering works.
-        E.g. /list/recommended/theme gets only shows themes
-        """
-        response = make_call('list/recommended/9/1')
-        self.assertContains(response, """<type id="9">Theme</type>""", 1)
-
-    def test_persona_search_15(self):
-        response = make_call('list/recommended/9/1', version=1.5)
-        self.assertContains(response, """<type id="9">Theme</type>""", 1)
-
-    def test_limits(self):
-        """
-        Assert /list/recommended/all/1 gets one item only.
-        """
-        response = make_call('list/recommended/all/1')
-        self.assertContains(response, "<addon id", 1)
-
-    def test_version_filter(self):
-        """
-        Assert that filtering by application version works.
-
-        E.g.
-        /list/new/all/1/mac/4.0 gives us nothing
-        """
-        response = make_call('list/new/1/1/all/4.0')
-        self.assertNotContains(response, "<addon id")
-
-    def test_backfill(self):
-        """
-        The /list/recommended should first populate itself with addons in its
-        locale.  If it doesn't reach the desired limit, it should backfill from
-        the general population of featured addons.
-        """
-        response = make_call('list', lang='fr')
-        self.assertContains(response, "<addon id", 3)
-
-        response = make_call('list', lang='he')
-
-        self.assertContains(response, "<addon id", 3)
-
-    def test_browser_featured_list(self):
-        """
-        This is a query that a browser would use to show it's featured list.
-
-        c.f.: https://bugzilla.mozilla.org/show_bug.cgi?id=548114
-        """
-        response = make_call('list/featured/all/10/Linux/3.7a2pre',
-                             version=1.3)
-        self.assertContains(response, "<addons>")
-
-    def test_average_daily_users(self):
-        """Verify that average daily users returns data in order."""
-        r = make_call('list/by_adu', version=1.5)
-        doc = pq(r.content)
-        vals = [int(a.text) for a in doc("average_daily_users")]
-        sorted_vals = sorted(vals, reverse=True)
-        assert vals == sorted_vals
-
-    def test_adu_no_personas(self):
-        """Verify that average daily users does not return Themes."""
-        response = make_call('list/by_adu')
-        self.assertNotContains(response, """<type id="9">Theme</type>""")
-
-    def test_featured_no_personas(self):
-        """Verify that featured does not return Themes."""
-        response = make_call('list/featured')
-        self.assertNotContains(response, """<type id="9">Theme</type>""")
-
-    def test_json(self):
-        """Verify that we get some json."""
-        response = make_call('list/by_adu?format=json', version=1.5)
-        assert json.loads(force_text(response.content))
-
-    def test_unicode(self):
-        make_call(u'list/featured/all/10/Linux/3.7a2prexec\xb6\u0153\xec\xb2')
-
-
-class AddonFilterTest(TestCase):
-    """Tests the addon_filter, including the various d2c cases."""
-    fixtures = ['base/appversion']
-
-    def setUp(self):
-        super(AddonFilterTest, self).setUp()
-        # Start with 2 compatible add-ons.
-        self.addon1 = addon_factory(version_kw={'max_app_version': '5.0'})
-        self.addon2 = addon_factory(version_kw={'max_app_version': '6.0'})
-        self.addons = [self.addon1, self.addon2]
-
-    def _defaults(self, **kwargs):
-        # Default args for addon_filter.
-        defaults = {
-            'addons': self.addons,
-            'addon_type': 'ALL',
-            'limit': 0,
-            'app': amo.FIREFOX,
-            'platform': 'all',
-            'version': '5.0',
-            'compat_mode': 'strict',
-            'shuffle': False,
-        }
-        defaults.update(kwargs)
-        return defaults
-
-    def test_basic(self):
-        addons = addon_filter(**self._defaults())
-        assert addons == self.addons
-
-    def test_limit(self):
-        addons = addon_filter(**self._defaults(limit=1))
-        assert addons == [self.addon1]
-
-    def test_app_filter(self):
-        self.addon1.update(type=amo.ADDON_DICT)
-        addons = addon_filter(
-            **self._defaults(addon_type=str(amo.ADDON_EXTENSION)))
-        assert addons == [self.addon2]
-
-    def test_platform_filter(self):
-        file = self.addon1.current_version.files.all()[0]
-        file.update(platform=amo.PLATFORM_WIN.id)
-        # Transformers don't know 'bout my files.
-        self.addons[0] = Addon.objects.get(pk=self.addons[0].pk)
-        addons = addon_filter(
-            **self._defaults(platform=amo.PLATFORM_LINUX.shortname))
-        assert addons == [self.addon2]
-
-    def test_version_filter_strict(self):
-        addons = addon_filter(**self._defaults(version='6.0'))
-        assert addons == [self.addon2]
-
-    def test_version_filter_ignore(self):
-        addons = addon_filter(**self._defaults(version='6.0',
-                                               compat_mode='ignore'))
-        assert addons == self.addons
-
-    def test_version_version_less_than_min(self):
-        # Ensure we filter out addons with a higher min than our app.
-        addon3 = addon_factory(version_kw={
-            'min_app_version': '12.0', 'max_app_version': '14.0'})
-        addons = self.addons + [addon3]
-        addons = addon_filter(**self._defaults(addons=addons, version='11.0',
-                                               compat_mode='ignore'))
-        assert addons == self.addons
-
-    def test_version_filter_normal_strict_opt_in(self):
-        # Ensure we filter out strict opt-in addons in normal mode.
-        addon3 = addon_factory(version_kw={'max_app_version': '7.0'},
-                               file_kw={'strict_compatibility': True})
-        addons = self.addons + [addon3]
-        addons = addon_filter(**self._defaults(addons=addons, version='11.0',
-                                               compat_mode='normal'))
-        assert addons == self.addons
-
-    def test_version_filter_normal_binary_components(self):
-        # Ensure we filter out strict opt-in addons in normal mode.
-        addon3 = addon_factory(version_kw={'max_app_version': '7.0'},
-                               file_kw={'binary_components': True})
-        addons = self.addons + [addon3]
-        addons = addon_filter(**self._defaults(addons=addons, version='11.0',
-                                               compat_mode='normal'))
-        assert addons == self.addons
-
-    def test_version_filter_normal_compat_override(self):
-        # Ensure we filter out strict opt-in addons in normal mode.
-        addon3 = addon_factory()
-        addons = self.addons + [addon3]
-
-        # Add override for this add-on.
-        compat = CompatOverride.objects.create(guid='three', addon=addon3)
-        CompatOverrideRange.objects.create(
-            compat=compat, app=1,
-            min_version=addon3.current_version.version, max_version='*')
-
-        addons = addon_filter(**self._defaults(addons=addons, version='11.0',
-                                               compat_mode='normal'))
-        assert addons == self.addons
-
-    def test_locale_preferencing(self):
-        # Add-ons matching the current locale get prioritized.
-        addon3 = addon_factory()
-        addon3.description = {'de': 'Unst Unst'}
-        addon3.save()
-
-        addons = self.addons + [addon3]
-
-        translation.activate('de')
-        addons = addon_filter(**self._defaults(addons=addons))
-        assert addons == [addon3] + self.addons
-        translation.deactivate()
-
-
-class TestGuidSearch(TestCase):
-    fixtures = ('base/addon_6113', 'base/addon_3615')
-    # These are the guids for addon 6113 and 3615.
-    good = ('search/guid:{22870005-adef-4c9d-ae36-d0e1f2f27e5a},'
-            '{2fa4ed95-0317-4c6a-a74c-5f3e3912c1f9}')
-
-    def setUp(self):
-        super(TestGuidSearch, self).setUp()
-        addon = Addon.objects.get(id=3615)
-        compat_override = CompatOverride.objects.create(guid=addon.guid)
-        app = list(addon.compatible_apps.keys())[0]
-        CompatOverrideRange.objects.create(compat=compat_override, app=app.id)
-
-    def test_success(self):
-        response = make_call(self.good)
-        dom = pq(response.content)
-        assert set(['3615', '6113']) == (
-            set([a.attrib['id'] for a in dom('addon')]))
-
-        # Make sure the <addon_compatibility> blocks are there.
-        assert ['3615'] == [a.attrib['id'] for a in dom('addon_compatibility')]
-
-    @patch('waffle.switch_is_active', lambda x: True)
-    def test_api_caching_locale(self):
-        addon = Addon.objects.get(pk=3615)
-        addon.summary = {'en-US': 'Delicious', 'fr': 'Francais'}
-        addon.save()
-
-        # This will prime the cache with the en-US version.
-        response = make_call(self.good)
-        self.assertContains(response, '<summary>Delicious')
-
-        # We should get back the fr version, not the en-US one.
-        response = make_call(self.good, lang='fr')
-        self.assertContains(response, '<summary>Francais')
-
-    def test_api_caching_app(self):
-        response = make_call(self.good)
-        assert b'en-US/firefox/addon/None/reviews/?src=api' in response.content
-        assert b'en-US/android/addon/None/reviews/' not in response.content
-
-        response = make_call(self.good, app='android')
-        assert b'en-US/android/addon/None/reviews/?src=api' in response.content
-        assert b'en-US/firefox/addon/None/reviews/' not in response.content
-
-    def test_xss(self):
-        addon_factory(guid='test@xss', name='<script>alert("test");</script>')
-        response = make_call('search/guid:test@xss')
-        assert b'<script>alert' not in response.content
-        assert b'&lt;script&gt;alert' in response.content
-
-    def test_block_inactive(self):
-        Addon.objects.filter(id=6113).update(disabled_by_user=True)
-        response = make_call(self.good)
-        assert set(['3615']) == (
-            set([a.attrib['id'] for a in pq(response.content)('addon')]))
-
-    def test_block_nonpublic(self):
-        Addon.objects.filter(id=6113).update(status=amo.STATUS_NOMINATED)
-        response = make_call(self.good)
-        assert set(['3615']) == (
-            set([a.attrib['id'] for a in pq(response.content)('addon')]))
-
-    def test_empty(self):
-        """
-        Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=607044
-        guid:foo, should search for just 'foo' and not empty guids.
-        """
-        response = make_call('search/guid:koberger,')
-        doc = pq(response.content)
-        # No addons should exist with guid koberger and the , should not
-        # indicate that we are searching for null guid.
-        assert len(doc('addon')) == 0
-
-    def test_addon_compatibility(self):
-        addon = Addon.objects.get(id=3615)
-        response = make_call('search/guid:%s' % addon.guid)
-        dom = pq(response.content, parser='xml')
-        assert len(dom('addon_compatibility')) == 1
-        assert dom('addon_compatibility')[0].attrib['id'] == '3615'
-        assert dom('addon_compatibility')[0].attrib['hosted'] == 'true'
-
-        assert dom('addon_compatibility guid').text() == addon.guid
-        assert dom('addon_compatibility > name').text() == ''
-
-        assert dom('addon_compatibility version_ranges version_range '
-                   'compatible_applications application appID').text() == (
-            amo.FIREFOX.guid)
-
-    def test_addon_compatibility_not_hosted(self):
-        compat_override = CompatOverride.objects.create(guid='yeah', name='ok')
-        CompatOverrideRange.objects.create(app=1, compat=compat_override,
-                                           min_version='1', max_version='2',
-                                           min_app_version='3',
-                                           max_app_version='4')
-
-        response = make_call('search/guid:%s' % compat_override.guid)
-        dom = pq(response.content, parser='xml')
-        assert len(dom('addon_compatibility')) == 1
-        assert dom('addon_compatibility')[0].attrib['hosted'] == 'false'
-        assert 'id' not in dom('addon_compatibility')[0].attrib
-
-        assert dom('addon_compatibility guid').text() == compat_override.guid
-        assert dom('addon_compatibility > name').text() == compat_override.name
-
-        cr = compat_override.compat_ranges[0]
-        assert dom('version_range')[0].attrib['type'] == cr.override_type()
-        assert dom('version_range > min_version').text() == cr.min_version
-        assert dom('version_range > max_version').text() == cr.max_version
-        assert dom('application name').text() == amo.FIREFOX.pretty
-        assert dom('application application_id').text() == str(amo.FIREFOX.id)
-        assert dom('application appID').text() == amo.FIREFOX.guid
-        assert dom('application min_version').text() == cr.min_app_version
-        assert dom('application max_version').text() == cr.max_app_version
-
-
-class SearchTest(ESTestCase):
-    fixtures = ('base/appversion',
-                'base/addon_6113', 'base/addon_40', 'base/addon_3615',
-                'base/addon_6704_grapple', 'base/addon_4664_twitterbar',
-                'base/addon_10423_youtubesearch', 'base/featured')
-
-    no_results = """<searchresults total_results="0">"""
-
-    def setUp(self):
-        super(SearchTest, self).setUp()
-        self.addons = Addon.objects.filter(status=amo.STATUS_PUBLIC,
-                                           disabled_by_user=False)
-        tag = Tag.objects.create(tag_text='ballin')
-        addon = Addon.objects.get(pk=3615)
-        AddonTag.objects.create(tag=tag, addon=addon)
-
-        [a.save() for a in self.addons]
-        self.refresh()
-
-        self.url = ('/en-US/firefox/api/%(api_version)s/search/%(query)s/'
-                    '%(type)s/%(limit)s/%(platform)s/%(app_version)s/'
-                    '%(compat_mode)s')
-        self.defaults = {
-            'api_version': '1.5',
-            'type': 'all',
-            'limit': '30',
-            'platform': 'Linux',
-            'app_version': '4.0',
-            'compat_mode': 'strict',
-        }
-
-    def test_zero_results(self):
-        """
-        Tests that the search API correctly gives us zero results found.
-        """
-        # The following URLs should yield zero results.
-        zeros = (
-            'yslow',
-            'jsonview',
-            'firebug/3',
-            'grapple/all/10/Linux',
-            'jsonview/all/10/Darwin/1.0',
-        )
-
-        for url in zeros:
-            if not url.startswith('/'):
-                url = '/en-US/firefox/api/1.2/search/' + url
-
-            response = self.client.get(url)
-            self.assertContains(response, self.no_results, msg_prefix=url)
-
-        for url in zeros:
-            if not url.startswith('/'):
-                url = '/en-US/firefox/api/1.5/search/' + url
-
-            response = self.client.get(url)
-            self.assertContains(response, self.no_results, msg_prefix=url)
-
-    def test_search_for_specifics(self):
-        """
-        Tests that the search API correctly returns specific results.
-        """
-        expect = {
-            'delicious': 'Delicious Bookmarks',
-            'delicious/1': 'Delicious Bookmarks',
-            'grapple/all/10/Darwin': 'GrApple',
-            'delicious/all/10/Darwin/3.5': 'Delicious Bookmarks',
-            '/en-US/firefox/api/1.2/search/twitter/all/10/Linux/3.5':
-                'TwitterBar',
-        }
-
-        for url, text in six.iteritems(expect):
-            if not url.startswith('/'):
-                url = '/en-US/firefox/api/1.2/search/' + url
-
-            response = self.client.get(url)
-            self.assertContains(response, text, msg_prefix=url)
-
-    def test_search_limits(self):
-        """
-        Test that we limit our results correctly.
-        """
-        response = self.client.get(
-            "/en-US/firefox/api/1.2/search/delicious/all/1")
-        assert force_text(response.content).count("<addon id") == 1
-
-    def test_total_results(self):
-        """
-        The search for firefox should result in 2 total addons, even though we
-        limit (and therefore show) only 1.
-        """
-        response = self.client.get(
-            "/en-US/firefox/api/1.2/search/fox/all/1")
-        self.assertContains(response, """<searchresults total_results="2">""")
-        self.assertContains(response, "</addon>", 1)
-
-    def test_unlisted_are_ignored(self):
-        """
-        Test that unlisted add-ons are not shown.
-        """
-        addon = Addon.objects.get(pk=3615)
-        self.make_addon_unlisted(addon)
-        addon.reload()
-        self.refresh()
-        response = self.client.get(
-            "/en-US/firefox/api/1.2/search/delicious")
-        self.assertContains(response, """<searchresults total_results="0">""")
-        self.assertContains(response, "</addon>", 0)
-
-    def test_experimental_are_ignored(self):
-        """
-        Test that experimental add-ons are not shown.
-        """
-        addon = Addon.objects.get(pk=3615)
-        addon.update(is_experimental=True)
-        self.refresh()
-        response = self.client.get(
-            "/en-US/firefox/api/1.2/search/delicious")
-        self.assertContains(response, """<searchresults total_results="0">""")
-        self.assertContains(response, "</addon>", 0)
-
-    def test_compat_mode_url(self):
-        """
-        Test the compatMode paramenter in the URL is optional and only accepts
-        values of: strict, normal, and ignore.
-        """
-        base = '/en-US/firefox/api/1.5/search/firefox/all/1/Linux/3.0'
-        assert self.client.head(base).status_code == 200
-        assert self.client.head(base + '/strict').status_code == 200
-        assert self.client.head(base + '/normal').status_code == 200
-        assert self.client.head(base + '/ignore').status_code == 200
-        assert self.client.head(base + '/junk').status_code == 404
-
-    def test_compat_mode_ignore(self):
-        # Delicious currently supports Firefox 2.0 - 3.7a1pre. Strict mode will
-        # not find it. Ignore mode should include it if the appversion is
-        # specified as higher.
-        self.defaults.update(query='delicious',
-                             app_version='5.0')  # Defaults to strict.
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-        self.defaults.update(query='delicious', compat_mode='ignore')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Delicious Bookmarks')
-
-    def test_compat_mode_normal_and_strict_opt_in(self):
-        # Under normal compat mode we ignore max version unless the add-on has
-        # opted into strict mode. Test before and after search queries.
-        addon = Addon.objects.get(pk=3615)
-        self.defaults.update(query='delicious', app_version='5.0')
-
-        self.defaults.update(compat_mode='normal')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Delicious Bookmarks')
-
-        # Make add-on opt into strict compatibility.
-        file = addon.current_version.files.all()[0]
-        file.update(strict_compatibility=True)
-        assert File.objects.get(pk=file.id).strict_compatibility
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-
-        # Make sure compat_mode=strict also doesn't find it.
-        self.defaults.update(compat_mode='strict')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-
-        # Make sure we find it with compat_mode=ignore
-        self.defaults.update(compat_mode='ignore')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Delicious Bookmarks')
-
-    def test_compat_mode_normal_and_binary_components(self):
-        # We ignore max version as long as the add-on has no binary components.
-        # Test before and after search queries.
-        addon = Addon.objects.get(pk=3615)
-        self.defaults.update(query='delicious', app_version='5.0')
-
-        self.defaults.update(compat_mode='normal')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Delicious Bookmarks')
-
-        # Make add-on contain binary components.
-        file = addon.current_version.files.all()[0]
-        file.update(binary_components=True)
-        assert File.objects.get(pk=file.id).binary_components
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-
-        # Make sure compat_mode=strict also doesn't find it.
-        self.defaults.update(compat_mode='strict')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-
-        # Make sure we find it with compat_mode=ignore
-        self.defaults.update(compat_mode='ignore')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Delicious Bookmarks')
-
-    def test_compat_mode_normal_and_binary_components_multi_file(self):
-        # This checks that versions with multiple files uses the platform to
-        # pick the right file for checking binary_components.
-        addon = Addon.objects.get(pk=3615)
-
-        file1 = addon.current_version.files.all()[0]
-        file1.update(platform=amo.PLATFORM_LINUX.id)
-
-        # Make a 2nd file just like the 1st, but with a different platform that
-        # uses binary_components.
-        file2 = file1
-        file2.id = None
-        file2.platform = amo.PLATFORM_WIN.id
-        file2.binary_components = True
-        file2.save()
-
-        self.defaults.update(query='delicious', app_version='5.0')
-
-        # Linux doesn't use binary components.
-        self.defaults.update(compat_mode='normal')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Delicious Bookmarks')
-
-        # Windows does use binary components, so it should find no results.
-        self.defaults.update(platform='WINNT')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-
-        # Make sure compat_mode=strict also doesn't find it.
-        self.defaults.update(compat_mode='strict')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-
-        # Make sure we find it with compat_mode=ignore
-        self.defaults.update(compat_mode='ignore')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Delicious Bookmarks')
-
-    def test_compat_mode_normal_max_version(self):
-        # We ignore versions that don't qualify for d2c by not having the
-        # minimum maxVersion support (e.g. Firefox >= 4.0).
-        fx30 = AppVersion.objects.get(application=1, version="3.0")
-        fx35 = AppVersion.objects.get(application=1, version="3.5")
-        addon = Addon.objects.get(pk=3615)
-        av = addon.current_version.apps.filter(application=1)[0]
-        av.min = fx30
-        av.max = fx35
-        av.save()
-        addon.save()
-
-        # Make sure compat_mode=strict doesn't find it. This won't find it
-        # because app version doesn't fall within supported app range.
-        self.defaults.update(query='delicious')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-
-        # Make sure compat_mode=normal doesn't find it. This shouldn't find it
-        # because the min maxVersion isn't >= 4.0 so it's not deemed
-        # compatible.
-        self.defaults.update(compat_mode='normal')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-
-        # Make sure compat_mode=normal finds it since 3.0 <= 4.0.
-        self.defaults.update(compat_mode='ignore')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Delicious Bookmarks')
-
-    def test_compat_override(self):
-        # Under normal compat mode we ignore add-ons with a compat override.
-        addon = Addon.objects.get(pk=3615)
-        self.defaults.update(query='delicious', app_version='5.0')
-
-        self.defaults.update(compat_mode='normal')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Delicious Bookmarks')
-
-        # Make add-on have a compat override.
-        co = CompatOverride.objects.create(name='test', guid=addon.guid,
-                                           addon=addon)
-        CompatOverrideRange.objects.create(compat=co, app=1,
-                                           min_version='0',
-                                           max_version='*',
-                                           min_app_version='0',
-                                           max_app_version='*')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-
-        # Make sure compat_mode=strict also doesn't find it.
-        self.defaults.update(compat_mode='strict')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, self.no_results)
-
-        # Make sure we find it with compat_mode=ignore
-        self.defaults.update(compat_mode='ignore')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Delicious Bookmarks')
-
-    def test_cross_origin(self):
-        # The search view doesn't allow cross-origin requests.
-        # First we check for a search without results.
-        response = self.client.get('/en-US/firefox/api/%.1f/search/firebug/3' %
-                                   legacy_api.CURRENT_VERSION)
-
-        assert not response.has_header('Access-Control-Allow-Origin')
-        assert not response.has_header('Access-Control-Allow-Methods')
-
-        # Now a search with results.
-        response = self.client.get('/en-US/firefox/api/%.1f/search/delicious' %
-                                   legacy_api.CURRENT_VERSION)
-
-        assert not response.has_header('Access-Control-Allow-Origin')
-        assert not response.has_header('Access-Control-Allow-Methods')
-
-    def test_persona_search(self):
-        self.defaults.update(query='lady')
-        # Personas aren't returned in a standard API search.
-        response = self.client.get(self.url % self.defaults)
-        self.assertNotContains(response, 'Lady Gaga')
-
-        # But they are if you specifically ask for Personas (type=9).
-        self.defaults.update(type='9')
-        response = self.client.get(self.url % self.defaults)
-        self.assertContains(response, 'Lady Gaga')
-
-    def test_suggestions(self):
-        response = self.client.get(
-            '/en-US/firefox/api/%.1f/search_suggestions/?q=delicious' %
-            legacy_api.CURRENT_VERSION)
-        data = json.loads(force_text(response.content))['suggestions'][0]
-        addon = Addon.objects.get(pk=3615)
-        assert data['id'] == str(addon.pk)
-        assert data['name'] == addon.name
-        assert data['rating'] == addon.average_rating
-
-    def test_no_category_suggestions(self):
-        response = self.client.get(
-            '/en-US/firefox/api/%.1f/search_suggestions/?q=Feed' %
-            legacy_api.CURRENT_VERSION)
-        assert json.loads(force_text(response.content))['suggestions'] == []
-
-    def test_suggestions_throttle(self):
-        self.create_sample('autosuggest-throttle')
-        response = self.client.get(
-            '/en-US/firefox/api/%.1f/search_suggestions/?q=delicious' %
-            legacy_api.CURRENT_VERSION)
-        assert response.status_code == 503
-
-
-class LanguagePacksTest(UploadTest):
-    fixtures = ['addons/listed']
-
-    def setUp(self):
-        super(LanguagePacksTest, self).setUp()
-        self.url = reverse('legacy_api.language', args=['1.5'])
-        self.tb_url = self.url.replace('firefox', 'android')
-        self.addon = Addon.objects.get(pk=3723)
-
-    def test_search_language_pack(self):
-        self.addon.update(type=amo.ADDON_LPAPP, status=amo.STATUS_PUBLIC)
-        res = self.client.get(self.url)
-        self.assertContains(res, "<guid>{835A3F80-DF39")
-
-    def test_search_no_language_pack(self):
-        res = self.client.get(self.url)
-        self.assertNotContains(res, "<guid>{835A3F80-DF39")
-
-    def test_search_app(self):
-        self.addon.update(type=amo.ADDON_LPAPP, status=amo.STATUS_PUBLIC)
-        AppSupport.objects.create(addon=self.addon, app=amo.ANDROID.id)
-        res = self.client.get(self.tb_url)
-        self.assertContains(res, "<guid>{835A3F80-DF39")
-
-    def test_search_no_app(self):
-        self.addon.update(type=amo.ADDON_LPAPP, status=amo.STATUS_PUBLIC)
-        res = self.client.get(self.tb_url)
-        self.assertNotContains(res, "<guid>{835A3F80-DF39")
-
-    def test_search_no_localepicker(self):
-        self.addon.update(type=amo.ADDON_LPAPP, status=amo.STATUS_PUBLIC)
-        res = self.client.get(self.tb_url)
-        self.assertNotContains(res, "<strings><![CDATA[")
-
-    def setup_localepicker(self, platform):
-        self.addon.update(type=amo.ADDON_LPAPP, status=amo.STATUS_PUBLIC)
-        version = self.addon.versions.all()[0]
-        File.objects.create(version=version, platform=platform,
-                            status=amo.STATUS_PUBLIC)
-
-    def test_search_wrong_platform(self):
-        self.setup_localepicker(amo.PLATFORM_MAC.id)
-        assert self.addon.get_localepicker() == ''
-
-    @patch('olympia.files.models.File.get_localepicker')
-    def test_search_right_platform(self, get_localepicker):
-        get_localepicker.return_value = 'some data'
-        self.setup_localepicker(amo.PLATFORM_ANDROID.id)
-        assert self.addon.get_localepicker() == 'some data'
-
-    @patch('olympia.addons.models.Addon.get_localepicker')
-    def test_localepicker(self, get_localepicker):
-        get_localepicker.return_value = u'title=اختر لغة'
-        self.addon.update(type=amo.ADDON_LPAPP, status=amo.STATUS_PUBLIC)
-        res = self.client.get(self.url)
-        self.assertContains(res, dedent(u"""
-                                                <strings><![CDATA[
-                                            title=اختر لغة
-                                                ]]></strings>"""))
diff --git a/src/olympia/legacy_api/urls.py b/src/olympia/legacy_api/urls.py
deleted file mode 100644
index d18205da76..0000000000
--- a/src/olympia/legacy_api/urls.py
+++ /dev/null
@@ -1,74 +0,0 @@
-from django.conf.urls import include, url
-from django.db.transaction import non_atomic_requests
-
-from olympia.addons.urls import ADDON_ID
-from olympia.legacy_api import views
-
-
-# Wrap class views in a lambda call so we get an fresh instance of the class
-# for thread-safety.
-@non_atomic_requests
-def api_view(cls):
-    return lambda *args, **kw: cls()(*args, **kw)
-
-
-def build_urls(base, appendages):
-    """
-    Many of our urls build off each other:
-    e.g.
-    /search/:query
-    /search/:query/:type
-    .
-    .
-    /search/:query/:type/:limit/:platform/:version
-    /search/:query/:type/:limit/:platform/:version/:compatMode
-    """
-    urls = [base]
-    for i in range(len(appendages)):
-        urls.append(base + ''.join(appendages[:i + 1]))
-
-    return urls
-
-
-base_search_regexp = r'search/(?P<query>[^/]+)'
-appendages = [
-    # Regular expressions that we use in our urls.
-    r'/(?P<addon_type>[^/]*)',
-    r'/(?P<limit>\d*)',
-    r'/(?P<platform>\w*)',
-    r'/(?P<version>[^/]*)',
-    r'(?:/(?P<compat_mode>(?:strict|normal|ignore)))?',
-]
-search_regexps = build_urls(base_search_regexp, appendages)
-
-appendages.insert(0, r'/(?P<list_type>[^/]+)')
-list_regexps = build_urls(r'list', appendages)
-
-legacy_api_patterns = [
-    # Addon_details
-    url(r'addon/%s$' % ADDON_ID, api_view(views.AddonDetailView),
-        name='legacy_api.addon_detail'),
-    url(r'^get_language_packs$', api_view(views.LanguageView),
-        name='legacy_api.language'),
-]
-
-for regexp in search_regexps:
-    legacy_api_patterns.append(
-        url(regexp + r'/?$', api_view(views.SearchView),
-            name='legacy_api.search'))
-
-for regexp in list_regexps:
-    legacy_api_patterns.append(
-        url(regexp + r'/?$', api_view(views.ListView),
-            name='legacy_api.list'))
-
-urlpatterns = [
-    # Redirect api requests without versions
-    url(r'^((?:addon|search|list)/.*)$', views.redirect_view),
-
-    # Endpoints.
-    url(r'^1.5/search_suggestions/', views.search_suggestions),
-    url(r'^(?P<api_version>\d+|\d+.\d+)/search/guid:(?P<guids>.*)',
-        views.guid_search),
-    url(r'^(?P<api_version>\d+|\d+.\d+)/', include(legacy_api_patterns)),
-]
diff --git a/src/olympia/legacy_api/utils.py b/src/olympia/legacy_api/utils.py
deleted file mode 100644
index c3ef86e182..0000000000
--- a/src/olympia/legacy_api/utils.py
+++ /dev/null
@@ -1,221 +0,0 @@
-from django.conf import settings
-from django.core.cache import cache
-from django.utils.html import strip_tags
-
-import six
-
-import olympia.core.logger
-
-from olympia import amo
-from olympia.amo.templatetags.jinja_helpers import absolutify
-from olympia.amo.urlresolvers import reverse
-from olympia.amo.utils import cache_ns_key, epoch, urlparams
-from olympia.versions.compare import version_int
-from olympia.versions.models import Version
-
-
-log = olympia.core.logger.getLogger('z.api')
-
-
-def addon_to_dict(addon, disco=False, src='api'):
-    """
-    Renders an addon into a dict for the legacy API.
-    """
-    def url(u, **kwargs):
-        return settings.SITE_URL + urlparams(u, **kwargs)
-
-    v = addon.current_version
-
-    if disco:
-        learnmore = settings.SERVICES_URL + reverse('discovery.addons.detail',
-                                                    args=[addon.slug])
-        learnmore = urlparams(learnmore, src='discovery-personalrec')
-    else:
-        learnmore = url(addon.get_url_path(), src=src)
-
-    d = {
-        'id': addon.id,
-        'name': six.text_type(addon.name) if addon.name else None,
-        'guid': addon.guid,
-        'status': amo.STATUS_CHOICES_API[addon.status],
-        'type': amo.ADDON_SLUGS_UPDATE[addon.type],
-        'authors': [{'id': a.id, 'name': six.text_type(a.name),
-                     'link': absolutify(a.get_url_path(src=src))}
-                    for a in addon.listed_authors],
-        'summary': (
-            strip_tags(six.text_type(addon.summary)) if addon.summary
-            else None),
-        'description': strip_tags(six.text_type(addon.description)),
-        'icon': addon.get_icon_url(32),
-        'learnmore': learnmore,
-        'reviews': url(addon.ratings_url),
-        'total_dls': addon.total_downloads,
-        'weekly_dls': addon.weekly_downloads,
-        'adu': addon.average_daily_users,
-        'created': epoch(addon.created),
-        'last_updated': epoch(addon.last_updated),
-        'homepage': six.text_type(addon.homepage) if addon.homepage else None,
-        'support': (
-            six.text_type(addon.support_url) if addon.support_url else None),
-    }
-    if addon.is_persona():
-        d['theme'] = addon.persona.theme_data
-
-    if v:
-        d['version'] = v.version
-        d['platforms'] = [six.text_type(a.name) for a in v.supported_platforms]
-        d['compatible_apps'] = [{
-            six.text_type(amo.APP_IDS[appver.application].pretty): {
-                'min': six.text_type(appver.min) if appver else (
-                    amo.D2C_MIN_VERSIONS.get(app.id, '1.0')),
-                'max': (
-                    six.text_type(appver.max) if appver
-                    else amo.FAKE_MAX_VERSION),
-            }} for app, appver in v.compatible_apps.items() if appver]
-    if addon.eula:
-        d['eula'] = six.text_type(addon.eula)
-
-    if addon.developer_comments:
-        d['dev_comments'] = six.text_type(addon.developer_comments)
-
-    if addon.contributions:
-        d['contribution'] = {
-            'meet_developers': addon.contributions,
-        }
-
-    if addon.type == amo.ADDON_PERSONA:
-        d['previews'] = [addon.persona.preview_url]
-    else:
-        def preview_as_dict(preview, src):
-            d = {'full': urlparams(preview.image_url, src=src),
-                 'thumbnail': urlparams(preview.thumbnail_url, src=src),
-                 'caption': six.text_type(preview.caption)}
-            return d
-
-        d['previews'] = [
-            preview_as_dict(p, src) for p in addon.current_previews]
-
-    return d
-
-
-def find_compatible_version(addon, app_id, app_version=None, platform=None,
-                            compat_mode='strict'):
-    """Returns the newest compatible version (ordered by version id desc)
-    for the given addon."""
-    if not app_id:
-        return None
-
-    if platform:
-        # We include platform_id=1 always in the SQL so we skip it here.
-        platform = platform.lower()
-        if platform != 'all' and platform in amo.PLATFORM_DICT:
-            platform = amo.PLATFORM_DICT[platform].id
-        else:
-            platform = None
-
-    log.debug(u'Checking compatibility for add-on ID:%s, APP:%s, V:%s, '
-              u'OS:%s, Mode:%s' % (addon.id, app_id, app_version, platform,
-                                   compat_mode))
-    valid_file_statuses = ','.join(map(str, addon.valid_file_statuses))
-    data = {
-        'id': addon.id,
-        'app_id': app_id,
-        'platform': platform,
-        'valid_file_statuses': valid_file_statuses,
-        'channel': amo.RELEASE_CHANNEL_LISTED,
-    }
-    if app_version:
-        data.update(version_int=version_int(app_version))
-    else:
-        # We can't perform the search queries for strict or normal without
-        # an app version.
-        compat_mode = 'ignore'
-
-    ns_key = cache_ns_key('d2c-versions:%s' % addon.id)
-    cache_key = '%s:%s:%s:%s:%s' % (ns_key, app_id, app_version, platform,
-                                    compat_mode)
-    version_id = cache.get(cache_key)
-    if version_id is not None:
-        log.debug(u'Found compatible version in cache: %s => %s' % (
-                  cache_key, version_id))
-        if version_id == 0:
-            return None
-        else:
-            try:
-                return Version.objects.get(pk=version_id)
-            except Version.DoesNotExist:
-                pass
-
-    raw_sql = ["""
-        SELECT versions.*
-        FROM versions
-        INNER JOIN addons
-            ON addons.id = versions.addon_id AND addons.id = %(id)s
-        INNER JOIN applications_versions
-            ON applications_versions.version_id = versions.id
-        INNER JOIN appversions appmin
-            ON appmin.id = applications_versions.min
-            AND appmin.application_id = %(app_id)s
-        INNER JOIN appversions appmax
-            ON appmax.id = applications_versions.max
-            AND appmax.application_id = %(app_id)s
-        INNER JOIN files
-            ON files.version_id = versions.id AND
-               (files.platform_id = 1"""]
-
-    if platform:
-        raw_sql.append(' OR files.platform_id = %(platform)s')
-
-    raw_sql.append(') WHERE files.status IN (%(valid_file_statuses)s) ')
-
-    raw_sql.append(' AND versions.channel = %(channel)s ')
-
-    if app_version:
-        raw_sql.append('AND appmin.version_int <= %(version_int)s ')
-
-    if compat_mode == 'ignore':
-        pass  # No further SQL modification required.
-
-    elif compat_mode == 'normal':
-        raw_sql.append("""AND
-            CASE WHEN files.strict_compatibility = 1 OR
-                      files.binary_components = 1
-            THEN appmax.version_int >= %(version_int)s ELSE 1 END
-        """)
-        # Filter out versions that don't have the minimum maxVersion
-        # requirement to qualify for default-to-compatible.
-        d2c_max = amo.D2C_MIN_VERSIONS.get(app_id)
-        if d2c_max:
-            data['d2c_max_version'] = version_int(d2c_max)
-            raw_sql.append(
-                "AND appmax.version_int >= %(d2c_max_version)s ")
-
-        # Filter out versions found in compat overrides
-        raw_sql.append("""AND
-            NOT versions.id IN (
-            SELECT version_id FROM incompatible_versions
-            WHERE app_id=%(app_id)s AND
-              (min_app_version='0' AND
-                   max_app_version_int >= %(version_int)s) OR
-              (min_app_version_int <= %(version_int)s AND
-                   max_app_version='*') OR
-              (min_app_version_int <= %(version_int)s AND
-                   max_app_version_int >= %(version_int)s)) """)
-
-    else:  # Not defined or 'strict'.
-        raw_sql.append('AND appmax.version_int >= %(version_int)s ')
-
-    raw_sql.append('ORDER BY versions.id DESC LIMIT 1;')
-
-    version = list(Version.objects.raw(''.join(raw_sql) % data))
-    if version:
-        version = version[0]
-        version_id = version.id
-    else:
-        version = None
-        version_id = 0
-
-    log.debug(u'Caching compat version %s => %s' % (cache_key, version_id))
-    cache.set(cache_key, version_id, None)
-
-    return version
diff --git a/src/olympia/legacy_api/views.py b/src/olympia/legacy_api/views.py
deleted file mode 100644
index 24d5be647b..0000000000
--- a/src/olympia/legacy_api/views.py
+++ /dev/null
@@ -1,493 +0,0 @@
-import hashlib
-import itertools
-import json
-import random
-
-from datetime import date, timedelta
-
-from django.core.cache import cache
-from django.db.transaction import non_atomic_requests
-from django.http import HttpResponse, HttpResponsePermanentRedirect
-from django.template import engines
-from django.utils.decorators import method_decorator
-from django.utils.encoding import force_bytes
-from django.utils.translation import get_language, ugettext, ugettext_lazy as _
-
-import six
-import waffle
-
-from six.moves.urllib_parse import quote
-
-import olympia.core.logger
-
-from olympia import amo, legacy_api
-from olympia.addons.models import Addon, CompatOverride
-from olympia.amo.decorators import allow_cross_site_request, json_view
-from olympia.amo.models import manual_order
-from olympia.amo.urlresolvers import get_url_prefix
-from olympia.amo.utils import AMOJSONEncoder
-from olympia.legacy_api.utils import addon_to_dict, find_compatible_version
-from olympia.search.views import AddonSuggestionsAjax, PersonaSuggestionsAjax
-from olympia.versions.compare import version_int
-
-
-ERROR = 'error'
-OUT_OF_DATE = _(
-    u'The API version, {0:.1f}, you are using is not valid. '
-    u'Please upgrade to the current version {1:.1f} API.')
-
-xml_env = engines['jinja2'].env.overlay()
-old_finalize = xml_env.finalize
-xml_env.finalize = lambda x: amo.templatetags.jinja_helpers.strip_controls(
-    old_finalize(x))
-
-
-# Hard limit of 30.  The buffer is to try for locale-specific add-ons.
-MAX_LIMIT, BUFFER = 30, 10
-
-# "New" is arbitrarily defined as 10 days old.
-NEW_DAYS = 10
-
-log = olympia.core.logger.getLogger('z.api')
-
-
-def partition(seq, key):
-    """Group a sequence based into buckets by key(x)."""
-    groups = itertools.groupby(sorted(seq, key=key), key=key)
-    return ((k, list(v)) for k, v in groups)
-
-
-def render_xml_to_string(request, template, context=None):
-    if context is None:
-        context = {}
-
-    for processor in engines['jinja2'].context_processors:
-        context.update(processor(request))
-
-    template = xml_env.get_template(template)
-    return template.render(context)
-
-
-@non_atomic_requests
-def render_xml(request, template, context=None, **kwargs):
-    """Safely renders xml, stripping out nasty control characters."""
-    if context is None:
-        context = {}
-    rendered = render_xml_to_string(request, template, context)
-
-    if 'content_type' not in kwargs:
-        kwargs['content_type'] = 'text/xml'
-
-    return HttpResponse(rendered, **kwargs)
-
-
-@non_atomic_requests
-def handler403(request):
-    context = {'error_level': ERROR, 'msg': 'Not allowed'}
-    return render_xml(request, 'legacy_api/message.xml', context, status=403)
-
-
-@non_atomic_requests
-def handler404(request):
-    context = {'error_level': ERROR, 'msg': 'Not Found'}
-    return render_xml(request, 'legacy_api/message.xml', context, status=404)
-
-
-@non_atomic_requests
-def handler500(request):
-    context = {'error_level': ERROR, 'msg': 'Server Error'}
-    return render_xml(request, 'legacy_api/message.xml', context, status=500)
-
-
-def validate_api_version(version):
-    """
-    We want to be able to deprecate old versions of the API, therefore we check
-    for a minimum API version before continuing.
-    """
-    if float(version) < legacy_api.MIN_VERSION:
-        return False
-
-    if float(version) > legacy_api.MAX_VERSION:
-        return False
-
-    return True
-
-
-def addon_filter(addons, addon_type, limit, app, platform, version,
-                 compat_mode='strict', shuffle=True):
-    """
-    Filter addons by type, application, app version, and platform.
-
-    Add-ons that support the current locale will be sorted to front of list.
-    Shuffling will be applied to the add-ons supporting the locale and the
-    others separately.
-
-    Doing this in the database takes too long, so we do it in code and wrap
-    it in generous caching.
-    """
-    APP = app
-
-    if addon_type.upper() != 'ALL':
-        try:
-            addon_type = int(addon_type)
-            if addon_type:
-                addons = [a for a in addons if a.type == addon_type]
-        except ValueError:
-            # `addon_type` is ALL or a type id.  Otherwise we ignore it.
-            pass
-
-    # Take out personas since they don't have versions.
-    groups = dict(partition(addons,
-                            lambda x: x.type == amo.ADDON_PERSONA))
-    personas, addons = groups.get(True, []), groups.get(False, [])
-
-    platform = platform.lower()
-    if platform != 'all' and platform in amo.PLATFORM_DICT:
-        def f(ps):
-            return pid in ps or amo.PLATFORM_ALL in ps
-
-        pid = amo.PLATFORM_DICT[platform]
-        addons = [a for a in addons
-                  if f(a.current_version.supported_platforms)]
-
-    if version is not None:
-        vint = version_int(version)
-
-        def f_strict(app):
-            return app.min.version_int <= vint <= app.max.version_int
-
-        def f_ignore(app):
-            return app.min.version_int <= vint
-
-        xs = [(a, a.compatible_apps) for a in addons]
-
-        # Iterate over addons, checking compatibility depending on compat_mode.
-        addons = []
-        for addon, apps in xs:
-            app = apps.get(APP)
-            if compat_mode == 'strict':
-                if app and f_strict(app):
-                    addons.append(addon)
-            elif compat_mode == 'ignore':
-                if app and f_ignore(app):
-                    addons.append(addon)
-            elif compat_mode == 'normal':
-                # This does a db hit but it's cached. This handles the cases
-                # for strict opt-in, binary components, and compat overrides.
-                v = find_compatible_version(addon, APP.id, version, platform,
-                                            compat_mode)
-                if v:  # There's a compatible version.
-                    addons.append(addon)
-
-    # Put personas back in.
-    addons.extend(personas)
-
-    # We prefer add-ons that support the current locale.
-    lang = get_language()
-
-    def partitioner(x):
-        return x.description is not None and (x.description.locale == lang)
-
-    groups = dict(partition(addons, partitioner))
-    good, others = groups.get(True, []), groups.get(False, [])
-
-    if shuffle:
-        random.shuffle(good)
-        random.shuffle(others)
-
-    # If limit=0, we return all addons with `good` coming before `others`.
-    # Otherwise pad `good` if less than the limit and return the limit.
-    if limit > 0:
-        if len(good) < limit:
-            good.extend(others[:limit - len(good)])
-        return good[:limit]
-    else:
-        good.extend(others)
-        return good
-
-
-class APIView(object):
-    """
-    Base view class for all API views.
-    """
-
-    @method_decorator(non_atomic_requests)
-    def __call__(self, request, api_version, *args, **kwargs):
-
-        self.version = float(api_version)
-        self.format = request.GET.get('format', 'xml')
-        self.content_type = ('text/xml' if self.format == 'xml'
-                             else 'application/json')
-        self.request = request
-        if not validate_api_version(api_version):
-            msg = OUT_OF_DATE.format(self.version, legacy_api.CURRENT_VERSION)
-            return self.render_msg(msg, ERROR, status=403,
-                                   content_type=self.content_type)
-
-        return self.process_request(*args, **kwargs)
-
-    def render_msg(self, msg, error_level=None, *args, **kwargs):
-        """
-        Renders a simple message.
-        """
-
-        if self.format == 'xml':
-            return render_xml(
-                self.request, 'legacy_api/message.xml',
-                {'error_level': error_level, 'msg': msg}, *args, **kwargs)
-        else:
-            return HttpResponse(json.dumps({'msg': _(msg)}), *args, **kwargs)
-
-    def render(self, template, context):
-        context['api_version'] = self.version
-        context['api'] = legacy_api
-
-        if self.format == 'xml':
-            return render_xml(self.request, template, context,
-                              content_type=self.content_type)
-        else:
-            return HttpResponse(self.render_json(context),
-                                content_type=self.content_type)
-
-    def render_json(self, context):
-        return json.dumps({'msg': ugettext('Not implemented yet.')})
-
-
-class AddonDetailView(APIView):
-
-    @allow_cross_site_request
-    def process_request(self, addon_id):
-        try:
-            # Nominated or public add-ons should be viewable using the legacy
-            # API detail endpoint.
-            addon = Addon.objects.valid().id_or_slug(addon_id).get()
-        except Addon.DoesNotExist:
-            # Add-on is either inexistent or not public/nominated.
-            return self.render_msg(
-                'Add-on not found!', ERROR, status=404,
-                content_type=self.content_type
-            )
-        return self.render_addon(addon)
-
-    def render_addon(self, addon):
-        return self.render('legacy_api/addon_detail.xml', {'addon': addon})
-
-    def render_json(self, context):
-        return json.dumps(addon_to_dict(context['addon']), cls=AMOJSONEncoder)
-
-
-@non_atomic_requests
-def guid_search(request, api_version, guids):
-    lang = request.LANG
-    app_id = request.APP.id
-    api_version = float(api_version)
-
-    def guid_search_cache_key(guid):
-        key = 'guid_search:%s:%s:%s:%s' % (api_version, lang, app_id, guid)
-        return hashlib.sha256(force_bytes(key)).hexdigest()
-
-    guids = [guid.strip() for guid in guids.split(',')] if guids else []
-
-    addons_xml = cache.get_many(
-        [guid_search_cache_key(guid) for guid in guids])
-    dirty_keys = set()
-
-    for guid in guids:
-        key = guid_search_cache_key(guid)
-        if key not in addons_xml:
-            dirty_keys.add(key)
-            try:
-                # Only search through public (and not disabled) add-ons.
-                addon = Addon.objects.public().get(guid=guid)
-            except Addon.DoesNotExist:
-                addons_xml[key] = ''
-
-            else:
-                addon_xml = render_xml_to_string(
-                    request, 'legacy_api/includes/addon.xml', {
-                        'addon': addon,
-                        'api_version': api_version,
-                        'api': legacy_api
-                    })
-                addons_xml[key] = addon_xml
-
-    if dirty_keys:
-        cache.set_many({k: v for k, v in six.iteritems(addons_xml)
-                        if k in dirty_keys})
-
-    compat = (CompatOverride.objects.filter(guid__in=guids)
-              .transform(CompatOverride.transformer))
-
-    addons_xml = [v for v in addons_xml.values() if v]
-    return render_xml(request, 'legacy_api/search.xml', {
-        'addons_xml': addons_xml,
-        'total': len(addons_xml),
-        'compat': compat,
-        'api_version': api_version, 'api': legacy_api
-    })
-
-
-class SearchView(APIView):
-
-    def process_request(self, query, addon_type='ALL', limit=10,
-                        platform='ALL', version=None, compat_mode='strict'):
-        """
-        Query the search backend and serve up the XML.
-        """
-        limit = min(MAX_LIMIT, int(limit))
-        app_id = self.request.APP.id
-
-        # We currently filter for status=PUBLIC for all versions. If
-        # that changes, the contract for API version 1.5 requires
-        # that we continue filtering for it there.
-        filters = {
-            'app': app_id,
-            'status': amo.STATUS_PUBLIC,
-            'is_experimental': False,
-            'is_disabled': False,
-            'current_version__exists': True,
-        }
-
-        params = {'version': version, 'platform': None}
-
-        # Specific case for Personas (bug 990768): if we search providing the
-        # Persona addon type (9), don't filter on the platform as Personas
-        # don't have compatible platforms to filter on.
-        if addon_type != '9':
-            params['platform'] = platform
-
-        # Type filters.
-        if addon_type:
-            try:
-                atype = int(addon_type)
-                if atype in amo.ADDON_SEARCH_TYPES:
-                    filters['type'] = atype
-            except ValueError:
-                atype = amo.ADDON_SEARCH_SLUGS.get(addon_type.lower())
-                if atype:
-                    filters['type'] = atype
-
-        if 'type' not in filters:
-            # Filter by ALL types, which is really all types except for apps.
-            filters['type__in'] = list(amo.ADDON_SEARCH_TYPES)
-
-        qs = (
-            Addon.search()
-            .filter(**filters)
-            .filter_query_string(query)
-            [:limit])
-
-        results = []
-
-        total = qs.count()
-
-        for addon in qs:
-            compat_version = find_compatible_version(
-                addon, app_id, params['version'], params['platform'],
-                compat_mode)
-            # Specific case for Personas (bug 990768): if we search
-            # providing the Persona addon type (9), then don't look for a
-            # compatible version.
-            if compat_version or addon_type == '9':
-                addon.compat_version = compat_version
-                results.append(addon)
-                if len(results) == limit:
-                    break
-            else:
-                # We're excluding this addon because there are no
-                # compatible versions. Decrement the total.
-                total -= 1
-
-        return self.render('legacy_api/search.xml', {
-            'results': results,
-            'total': total,
-            # For caching
-            'version': version,
-            'compat_mode': compat_mode,
-        })
-
-
-@json_view
-@non_atomic_requests
-def search_suggestions(request):
-    if waffle.sample_is_active('autosuggest-throttle'):
-        return HttpResponse(status=503)
-    cat = request.GET.get('cat', 'all')
-    suggesterClass = {
-        'all': AddonSuggestionsAjax,
-        'themes': PersonaSuggestionsAjax,
-    }.get(cat, AddonSuggestionsAjax)
-    items = suggesterClass(request, ratings=True).items
-    for s in items:
-        s['rating'] = float(s['rating'])
-    return {'suggestions': items}
-
-
-class ListView(APIView):
-
-    def process_request(self, list_type='recommended', addon_type='ALL',
-                        limit=10, platform='ALL', version=None,
-                        compat_mode='strict'):
-        """
-        Find a list of new or featured add-ons. Filtering is done in Python
-        to avoid heavy queries.
-        """
-        limit = min(MAX_LIMIT, int(limit))
-        APP, platform = self.request.APP, platform.lower()
-        qs = Addon.objects.listed(APP)
-        shuffle = True
-
-        if list_type in ('by_adu', 'featured'):
-            qs = qs.exclude(type=amo.ADDON_PERSONA)
-
-        if list_type == 'newest':
-            new = date.today() - timedelta(days=NEW_DAYS)
-            addons = (qs.filter(created__gte=new)
-                      .order_by('-created'))[:limit + BUFFER]
-        elif list_type == 'by_adu':
-            addons = qs.order_by('-average_daily_users')[:limit + BUFFER]
-            shuffle = False  # By_adu is an ordered list.
-        elif list_type == 'hotness':
-            # Filter to type=1 so we hit visible_idx. Only extensions have a
-            # hotness index right now so this is not incorrect.
-            addons = (qs.filter(type=amo.ADDON_EXTENSION)
-                      .order_by('-hotness'))[:limit + BUFFER]
-            shuffle = False
-        else:
-            ids = Addon.featured_random(APP, self.request.LANG)
-            addons = manual_order(qs, ids[:limit + BUFFER], 'addons.id')
-            shuffle = False
-
-        args = (addon_type, limit, APP, platform, version, compat_mode,
-                shuffle)
-
-        return self.render('legacy_api/list.xml',
-                           {'addons': addon_filter(addons.all(), *args)})
-
-    def render_json(self, context):
-        return json.dumps([addon_to_dict(a) for a in context['addons']],
-                          cls=AMOJSONEncoder)
-
-
-class LanguageView(APIView):
-
-    def process_request(self):
-        addons = (Addon.objects.public()
-                               .filter(type=amo.ADDON_LPAPP,
-                                       appsupport__app=self.request.APP.id)
-                               .order_by('pk'))
-        return self.render('legacy_api/list.xml', {'addons': addons,
-                                                   'show_localepicker': True})
-
-
-# pylint: disable-msg=W0613
-@non_atomic_requests
-def redirect_view(request, url):
-    """
-    Redirect all requests that come here to an API call with a view parameter.
-    """
-    dest = '/api/%.1f/%s' % (legacy_api.CURRENT_VERSION,
-                             quote(url.encode('utf-8')))
-    dest = get_url_prefix().fix(dest)
-
-    return HttpResponsePermanentRedirect(dest)
diff --git a/src/olympia/legacy_discovery/modules.py b/src/olympia/legacy_discovery/modules.py
index add6c427ec..260d37b6cd 100644
--- a/src/olympia/legacy_discovery/modules.py
+++ b/src/olympia/legacy_discovery/modules.py
@@ -1,14 +1,18 @@
 # -*- coding: utf-8 -*-
+import itertools
+import random
+
 from django.template.loader import render_to_string
 from django.utils.translation import ugettext_lazy as _
+from django.utils.translation import get_language
 
 import jinja2
 import six
 
+from olympia import amo
 from olympia.addons.models import Addon
 from olympia.bandwagon.models import (
     Collection, MonthlyPick as MonthlyPickModel)
-from olympia.legacy_api.views import addon_filter
 from olympia.versions.compare import version_int
 from olympia.lib.cache import cache_get_or_set, make_key
 
@@ -17,6 +21,84 @@ from olympia.lib.cache import cache_get_or_set, make_key
 registry = {}
 
 
+# Temporarily here as part of the legacy-api removal
+# Simplified a bit by stuff that isn't used
+def addon_filter(addons, addon_type, limit, app, platform, version,
+                 compat_mode='strict'):
+    """
+    Filter addons by type, application, app version, and platform.
+    Add-ons that support the current locale will be sorted to front of list.
+    Shuffling will be applied to the add-ons supporting the locale and the
+    others separately.
+    Doing this in the database takes too long, so we do it in code and wrap
+    it in generous caching.
+    """
+    APP = app
+
+    def partition(seq, key):
+        """Group a sequence based into buckets by key(x)."""
+        groups = itertools.groupby(sorted(seq, key=key), key=key)
+        return ((k, list(v)) for k, v in groups)
+
+    # Take out personas since they don't have versions.
+    groups = dict(partition(addons,
+                            lambda x: x.type == amo.ADDON_PERSONA))
+    personas, addons = groups.get(True, []), groups.get(False, [])
+
+    platform = platform.lower()
+    if platform != 'all' and platform in amo.PLATFORM_DICT:
+        def f(ps):
+            return pid in ps or amo.PLATFORM_ALL in ps
+
+        pid = amo.PLATFORM_DICT[platform]
+        addons = [a for a in addons
+                  if f(a.current_version.supported_platforms)]
+
+    if version is not None:
+        vint = version_int(version)
+
+        def f_strict(app):
+            return app.min.version_int <= vint <= app.max.version_int
+
+        def f_ignore(app):
+            return app.min.version_int <= vint
+
+        xs = [(a, a.compatible_apps) for a in addons]
+
+        # Iterate over addons, checking compatibility depending on compat_mode.
+        addons = []
+        for addon, apps in xs:
+            app = apps.get(APP)
+            if compat_mode == 'ignore':
+                if app and f_ignore(app):
+                    addons.append(addon)
+
+    # Put personas back in.
+    addons.extend(personas)
+
+    # We prefer add-ons that support the current locale.
+    lang = get_language()
+
+    def partitioner(x):
+        return x.description is not None and (x.description.locale == lang)
+
+    groups = dict(partition(addons, partitioner))
+    good, others = groups.get(True, []), groups.get(False, [])
+
+    random.shuffle(good)
+    random.shuffle(others)
+
+    # If limit=0, we return all addons with `good` coming before `others`.
+    # Otherwise pad `good` if less than the limit and return the limit.
+    if limit > 0:
+        if len(good) < limit:
+            good.extend(others[:limit - len(good)])
+        return good[:limit]
+    else:
+        good.extend(others)
+    return good
+
+
 class PromoModuleMeta(type):
     """Adds new PromoModules to the module registry."""
 
@@ -41,9 +123,7 @@ class PromoModule(six.with_metaclass(PromoModuleMeta, object)):
         self.request = request
         self.platform = platform
         self.version = version
-        self.compat_mode = 'strict'
-        if version_int(self.version) >= version_int('10.0'):
-            self.compat_mode = 'ignore'
+        self.compat_mode = 'ignore'
 
     def render(self):
         raise NotImplementedError
diff --git a/src/olympia/lib/settings_base.py b/src/olympia/lib/settings_base.py
index 2ac6b8ca67..4eff87a15f 100644
--- a/src/olympia/lib/settings_base.py
+++ b/src/olympia/lib/settings_base.py
@@ -457,7 +457,6 @@ INSTALLED_APPS = (
     'olympia.devhub',
     'olympia.discovery',
     'olympia.files',
-    'olympia.legacy_api',
     'olympia.legacy_discovery',
     'olympia.lib.es',
     'olympia.lib.akismet',
diff --git a/src/olympia/search/tests/test_search_ranking.py b/src/olympia/search/tests/test_search_ranking.py
index 8c86416ecc..a5e99878a3 100644
--- a/src/olympia/search/tests/test_search_ranking.py
+++ b/src/olympia/search/tests/test_search_ranking.py
@@ -701,19 +701,13 @@ class TestRankingScenarios(ESTestCase):
         ))
 
     def test_scenario_grapple(self):
-        """Making sure this scenario works via the API,
-
-        see `legacy_api.SearchTest` for various examples.
-        """
+        """Making sure this scenario works via the API"""
         self._check_scenario('grapple', (
             ['GrApple Yummy', 0.69091946],
         ))
 
     def test_scenario_delicious(self):
-        """Making sure this scenario works via the API,
-
-        see `legacy_api.SearchTest` for various examples.
-        """
+        """Making sure this scenario works via the API"""
         self._check_scenario('delicious', (
             ['Delicious Bookmarks', 0.8113203],
         ))
diff --git a/src/olympia/urls.py b/src/olympia/urls.py
index 3ff5a9a43c..582f92b8cd 100644
--- a/src/olympia/urls.py
+++ b/src/olympia/urls.py
@@ -81,9 +81,6 @@ urlpatterns = [
         cache_page(60 * 60 * 24 * 365)(JavaScriptCatalog.as_view()),
         {'domain': 'djangojs', 'packages': []}, name='jsi18n'),
 
-    # SAMO (Legacy API)
-    url(r'^api/', include('olympia.legacy_api.urls')),
-
     # API v3+.
     url(r'^api/', include('olympia.api.urls')),