[extensions-web] extensions: Support 'shell_version' in the download view, add tests

[Jasper St. Pierre <jstpierre src gnome org>]

commit b151b6182f8dc6a57f09db19923c1c1466b6a333
Author: Jasper St. Pierre <jstpierre mecheye net>
Date:   Thu Mar 29 10:03:03 2012 -0400

    extensions: Support 'shell_version' in the download view, add tests
    
    This makes it easier for API clients to use, without having to parse the
    shell version map themselves. The 'version_tag' use for general extension
    downloading should be considered legacy, and only be used if a user wants
    to download a specific extension version.

 sweettooth/extensions/tests.py |   85 ++++++++++++++++++++++++++++++++++++++++
 sweettooth/extensions/urls.py  |    2 +-
 sweettooth/extensions/views.py |   72 +++++++++++++++++++---------------
 3 files changed, 126 insertions(+), 33 deletions(-)
---
diff --git a/sweettooth/extensions/tests.py b/sweettooth/extensions/tests.py
index 9315df6..aa87b38 100644
--- a/sweettooth/extensions/tests.py
+++ b/sweettooth/extensions/tests.py
@@ -374,6 +374,91 @@ class ShellVersionTest(TestCase):
         self.assertEquals(minor, 3)
         self.assertEquals(point, 2)
 
+class DownloadExtensionTest(BasicUserTestCase, TestCase):
+    def download(self, uuid, shell_version):
+        url = reverse('extensions-shell-download', kwargs=dict(uuid=uuid))
+        return self.client.get(url, dict(shell_version=shell_version), follow=True)
+
+    def test_basic(self):
+        zipfile = get_test_zipfile("SimpleExtension")
+
+        metadata = {"name": "Test Metadata 6",
+                    "uuid": "test-6 gnome org",
+                    "description": "Simple test metadata",
+                    "url": "http://test-metadata.gnome.org"}
+
+        extension = models.Extension.objects.create_from_metadata(metadata, creator=self.user)
+
+        v1 = models.ExtensionVersion.objects.create(extension=extension,
+                                                    status=models.STATUS_ACTIVE,
+                                                    source=File(zipfile, "version1.zip"))
+        v1.parse_metadata_json({"shell-version": ['3.2']})
+
+        v2 = models.ExtensionVersion.objects.create(extension=extension,
+                                                    status=models.STATUS_ACTIVE,
+                                                    source=File(zipfile, "version1.zip"))
+        v2.parse_metadata_json({"shell-version": ['3.4']})
+
+        self.assertRedirects(self.download(metadata['uuid'], '3.2'), v1.source.url)
+        self.assertRedirects(self.download(metadata['uuid'], '3.4'), v2.source.url)
+
+    def test_bare_versions(self):
+        zipfile = get_test_zipfile("SimpleExtension")
+
+        metadata = {"name": "Test Metadata 7",
+                    "uuid": "test-7 gnome org",
+                    "description": "Simple test metadata",
+                    "url": "http://test-metadata.gnome.org"}
+
+        extension = models.Extension.objects.create_from_metadata(metadata, creator=self.user)
+
+        v1 = models.ExtensionVersion.objects.create(extension=extension,
+                                                    status=models.STATUS_ACTIVE,
+                                                    source=File(zipfile, "version1.zip"))
+        v1.parse_metadata_json({"shell-version": ['3.2']})
+
+        v2 = models.ExtensionVersion.objects.create(extension=extension,
+                                                    status=models.STATUS_ACTIVE,
+                                                    source=File(zipfile, "version2.zip"))
+        v2.parse_metadata_json({"shell-version": ['3.2.1']})
+
+        self.assertRedirects(self.download(metadata['uuid'], '3.2.0'), v1.source.url)
+        self.assertRedirects(self.download(metadata['uuid'], '3.2.1'), v2.source.url)
+        self.assertRedirects(self.download(metadata['uuid'], '3.2.2'), v1.source.url)
+
+        v3 = models.ExtensionVersion.objects.create(extension=extension,
+                                                    status=models.STATUS_ACTIVE,
+                                                    source=File(zipfile, "version3.zip"))
+        v3.parse_metadata_json({"shell-version": ['3.2']})
+
+        self.assertRedirects(self.download(metadata['uuid'], '3.2.0'), v3.source.url)
+        self.assertRedirects(self.download(metadata['uuid'], '3.2.1'), v3.source.url)
+        self.assertRedirects(self.download(metadata['uuid'], '3.2.2'), v3.source.url)
+
+    def test_multiple_versions(self):
+        zipfile = get_test_zipfile("SimpleExtension")
+
+        metadata = {"name": "Test Metadata 8",
+                    "uuid": "test-8 gnome org",
+                    "description": "Simple test metadata",
+                    "url": "http://test-metadata.gnome.org"}
+
+        extension = models.Extension.objects.create_from_metadata(metadata, creator=self.user)
+
+        v1 = models.ExtensionVersion.objects.create(extension=extension,
+                                                    status=models.STATUS_ACTIVE,
+                                                    source=File(zipfile, "version1.zip"))
+        v1.parse_metadata_json({"shell-version": ['3.2.0', '3.2.1', '3.2.2']})
+
+        v2 = models.ExtensionVersion.objects.create(extension=extension,
+                                                    status=models.STATUS_ACTIVE,
+                                                    source=File(zipfile, "version2.zip"))
+        v2.parse_metadata_json({"shell-version": ['3.2.2']})
+
+        self.assertRedirects(self.download(metadata['uuid'], '3.2.0'), v1.source.url)
+        self.assertRedirects(self.download(metadata['uuid'], '3.2.1'), v1.source.url)
+        self.assertRedirects(self.download(metadata['uuid'], '3.2.2'), v2.source.url)
+
 class UpdateVersionTest(TestCase):
     fixtures = [os.path.join(testdata_dir, 'test_upgrade_data.json')]
 
diff --git a/sweettooth/extensions/urls.py b/sweettooth/extensions/urls.py
index 865744d..a0a7c1c 100644
--- a/sweettooth/extensions/urls.py
+++ b/sweettooth/extensions/urls.py
@@ -25,7 +25,7 @@ shell_patterns = patterns('',
     url(r'^extension-info/', views.ajax_details_view),
 
     url(r'^download-extension/(?P<uuid>.+)\.shell-extension\.zip$',
-        views.shell_download),
+        views.shell_download, name='extensions-shell-download'),
 
     url(r'^update-info/', views.shell_update, name='extensions-shell-update'),
 )
diff --git a/sweettooth/extensions/views.py b/sweettooth/extensions/views.py
index 53ee0c3..7d11584 100644
--- a/sweettooth/extensions/views.py
+++ b/sweettooth/extensions/views.py
@@ -21,16 +21,49 @@ from extensions.forms import UploadForm
 from decorators import ajax_view, model_view
 from utils import render
 
+def get_versions_for_version_strings(version_strings):
+    def get_version(major, minor, point):
+        try:
+            return models.ShellVersion.objects.get(major=major, minor=minor, point=point)
+        except models.ShellVersion.DoesNotExist:
+            return None
+
+    for version_string in version_strings:
+        try:
+            major, minor, point = models.parse_version_string(version_string, ignore_micro=True)
+        except models.InvalidShellVersion:
+            continue
+
+        version = get_version(major, minor, point)
+        if version:
+            yield version
+
+        # If we already have a base version, don't bother querying it again...
+        if point == -1:
+            continue
+
+        base_version = get_version(major, minor, -1)
+        if base_version:
+            yield base_version
+
 def shell_download(request, uuid):
-    pk = request.GET['version_tag']
-    version = get_object_or_404(models.ExtensionVersion, pk=pk)
-    extension = version.extension
+    extension = get_object_or_404(models.Extension, uuid=uuid)
 
-    if version.extension.uuid != uuid:
-        raise Http404()
+    if request.GET.get('version_tag', -1) >= 0:
+        try:
+            version = extension.visible_versions.get(pk=request.GET['version_tag'])
+        except models.ExtensionVersion.DoesNotExist:
+            raise Http404()
+    else:
+        shell_version = request.GET['shell_version']
+        shell_versions = set(get_versions_for_version_strings([shell_version]))
+        if not shell_versions:
+            raise Http404()
 
-    if version.status != models.STATUS_ACTIVE:
-        return HttpResponseForbidden()
+        try:
+            version = extension.visible_versions.filter(shell_versions__in=shell_versions).order_by('-version')[0]
+        except models.ExtensionVersion.DoesNotExist:
+            raise Http404()
 
     extension.downloads += 1
     extension.save(replace_metadata_json=False)
@@ -70,31 +103,6 @@ def shell_update(request):
 
     return operations
 
-def get_versions_for_version_strings(version_strings):
-    def get_version(major, minor, point):
-        try:
-            return models.ShellVersion.objects.get(major=major, minor=minor, point=point)
-        except models.ShellVersion.DoesNotExist:
-            return None
-
-    for version_string in version_strings:
-        try:
-            major, minor, point = models.parse_version_string(version_string, ignore_micro=True)
-        except models.InvalidShellVersion:
-            continue
-
-        version = get_version(major, minor, point)
-        if version:
-            yield version
-
-        # If we already have a base version, don't bother querying it again...
-        if point == -1:
-            continue
-
-        base_version = get_version(major, minor, -1)
-        if base_version:
-            yield base_version
-
 def ajax_query_params_query(request, n_per_page=10):
     version_qs = models.ExtensionVersion.objects.visible()