Merge "API tests: move to own module"

3 files changed, 334 insertions, 376 deletions

diff --git a/license_protected_downloads/tests/__init__.py b/license_protected_downloads/tests/__init__.py
index 77dd780..8d28529 100644
--- a/license_protected_downloads/tests/__init__.py
+++ b/license_protected_downloads/tests/__init__.py
@@ -13,6 +13,9 @@ from license_protected_downloads.tests.test_views import (
     ViewTests,
     ViewHelpersTests,
     )
+from license_protected_downloads.tests.test_api_v1 import (
+    APITests,
+)
 from license_protected_downloads.tests.test_openid_auth import TestOpenIDAuth
 from license_protected_downloads.tests.test_custom_commands \
  import SetsuperuserCommandTest
@@ -21,6 +24,7 @@ from license_protected_downloads.tests.test_render_text_files \
 
 #starts the test suite
 __test__ = {
+    'APITests': APITests,
     'BuildInfoTests': BuildInfoTests,
     'SpliceBuildInfosTests': SpliceBuildInfosTests,
     'FileNameMatchingTests': FileNameMatchingTests,
diff --git a/license_protected_downloads/tests/test_api_v1.py b/license_protected_downloads/tests/test_api_v1.py
new file mode 100644
index 0000000..6b0cb24
--- /dev/null
+++ b/license_protected_downloads/tests/test_api_v1.py
@@ -0,0 +1,328 @@
+import os
+import urlparse
+import json
+import random
+import shutil
+import StringIO
+import tempfile
+
+import mock
+
+from django.conf import settings
+from django.test import Client, TestCase
+
+from license_protected_downloads.models import APIKeyStore
+from license_protected_downloads.tests.test_views import ViewTests
+
+THIS_DIRECTORY = os.path.dirname(os.path.abspath(__file__))
+TESTSERVER_ROOT = os.path.join(THIS_DIRECTORY, "testserver_root")
+
+
+class APITests(TestCase):
+    def setUp(self):
+        self.client = Client()
+
+        path = os.path.join(os.path.dirname(__file__), 'testserver_root')
+        m = mock.patch('django.conf.settings.SERVED_PATHS',
+                       new_callable=lambda: [path])
+        self.addCleanup(m.stop)
+        m.start()
+
+        path = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, path)
+        m = mock.patch('django.conf.settings.UPLOAD_PATH',
+                       new_callable=lambda: path)
+        self.addCleanup(m.stop)
+        m.start()
+
+        m = mock.patch('django.conf.settings.MASTER_API_KEY',
+                       new_callable=lambda: '1234abcd')
+        self.addCleanup(m.stop)
+        m.start()
+
+        self.tmpdir = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, self.tmpdir)
+
+    def test_api_get_license_list(self):
+        target_file = "build-info/snowball-blob.txt"
+        digest = ViewTests.set_up_license(target_file)
+
+        license_url = "/api/license/" + target_file
+
+        # Download JSON containing license information
+        response = self.client.get(license_url)
+        data = json.loads(response.content)["licenses"]
+
+        # Extract digests
+        digests = [d["digest"] for d in data]
+
+        # Make sure digests match what is in the database
+        self.assertIn(digest, digests)
+        self.assertEqual(len(digests), 1)
+
+    def test_api_get_license_list_multi_license(self):
+        target_file = "build-info/multi-license.txt"
+        digest_1 = ViewTests.set_up_license(target_file)
+        digest_2 = ViewTests.set_up_license(target_file, 1)
+
+        license_url = "/api/license/" + target_file
+
+        # Download JSON containing license information
+        response = self.client.get(license_url)
+        data = json.loads(response.content)["licenses"]
+
+        # Extract digests
+        digests = [d["digest"] for d in data]
+
+        # Make sure digests match what is in the database
+        self.assertIn(digest_1, digests)
+        self.assertIn(digest_2, digests)
+        self.assertEqual(len(digests), 2)
+
+    def test_api_get_license_list_404(self):
+        target_file = "build-info/snowball-b"
+        license_url = "/api/license/" + target_file
+
+        # Download JSON containing license information
+        response = self.client.get(license_url)
+        self.assertEqual(response.status_code, 404)
+
+    def test_api_download_file(self):
+        target_file = "build-info/snowball-blob.txt"
+        digest = ViewTests.set_up_license(target_file)
+
+        url = urlparse.urljoin("http://testserver/", target_file)
+        response = self.client.get(url, follow=True,
+                                   HTTP_LICENSE_ACCEPTED=digest)
+        self.assertEqual(response.status_code, 200)
+        file_path = os.path.join(TESTSERVER_ROOT, target_file)
+        self.assertEqual(response['X-Sendfile'], file_path)
+
+    def test_api_download_file_multi_license(self):
+        target_file = "build-info/multi-license.txt"
+        digest_1 = ViewTests.set_up_license(target_file)
+        digest_2 = ViewTests.set_up_license(target_file, 1)
+
+        url = urlparse.urljoin("http://testserver/", target_file)
+        response = self.client.get(
+            url, follow=True,
+            HTTP_LICENSE_ACCEPTED=" ".join([digest_1, digest_2]))
+        self.assertEqual(response.status_code, 200)
+        file_path = os.path.join(TESTSERVER_ROOT, target_file)
+        self.assertEqual(response['X-Sendfile'], file_path)
+
+    def test_api_download_file_404(self):
+        target_file = "build-info/snowball-blob.txt"
+        digest = ViewTests.set_up_license(target_file)
+
+        url = urlparse.urljoin("http://testserver/", target_file[:-2])
+        response = self.client.get(url, follow=True,
+                                   HTTP_LICENSE_ACCEPTED=digest)
+        self.assertEqual(response.status_code, 404)
+
+    def test_api_get_listing(self):
+        url = "/api/ls/build-info"
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+
+        data = json.loads(response.content)["files"]
+
+        # For each file listed, check some key attributes
+        for file_info in data:
+            file_path = os.path.join(TESTSERVER_ROOT,
+                                     file_info["url"].lstrip("/"))
+            if file_info["type"] == "folder":
+                self.assertTrue(os.path.isdir(file_path))
+            else:
+                self.assertTrue(os.path.isfile(file_path))
+
+            mtime = os.path.getmtime(file_path)
+
+            self.assertEqual(mtime, file_info["mtime"])
+
+    def test_api_get_listing_single_file(self):
+        url = "/api/ls/build-info/snowball-blob.txt"
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+
+        data = json.loads(response.content)["files"]
+
+        # Should be a listing for a single file
+        self.assertEqual(len(data), 1)
+
+        # For each file listed, check some key attributes
+        for file_info in data:
+            file_path = os.path.join(TESTSERVER_ROOT,
+                                     file_info["url"].lstrip("/"))
+            if file_info["type"] == "folder":
+                self.assertTrue(os.path.isdir(file_path))
+            else:
+                self.assertTrue(os.path.isfile(file_path))
+
+            mtime = os.path.getmtime(file_path)
+
+            self.assertEqual(mtime, file_info["mtime"])
+
+    def test_api_get_listing_404(self):
+        url = "/api/ls/buld-info"
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 404)
+
+    def test_get_key(self):
+        response = self.client.get("http://testserver/api/request_key",
+                                   data={"key": settings.MASTER_API_KEY})
+
+        self.assertEqual(response.status_code, 200)
+        # Don't care what the key is, as long as it isn't blank
+        self.assertRegexpMatches(response.content, "\S+")
+
+    def test_get_key_api_disabled(self):
+        settings.MASTER_API_KEY = ""
+        response = self.client.get("http://testserver/api/request_key",
+                                   data={"key": settings.MASTER_API_KEY})
+
+        self.assertEqual(response.status_code, 403)
+
+    def _send_file(self, url, apikey, content, resp_code=200):
+        f = StringIO.StringIO(content)
+        f.name = 'name'   # to fool django's client.post
+        response = self.client.post(url, data={"key": apikey, "file": f})
+        self.assertEqual(response.status_code, resp_code)
+
+    def test_get_key_post_and_get_file(self):
+        response = self.client.get("http://testserver/api/request_key",
+                                   data={"key": settings.MASTER_API_KEY})
+
+        self.assertEqual(response.status_code, 200)
+        # Don't care what the key is, as long as it isn't blank
+        self.assertRegexpMatches(response.content, "\S+")
+        key = response.content
+        last_used = APIKeyStore.objects.get(key=key).last_used
+
+        file_content = "test_get_key_post_and_get_file"
+        self._send_file('http://testserver/file_name', key, file_content)
+
+        # Check the upload worked by reading the file back from its
+        # uploaded location
+        uploaded_file_path = os.path.join(
+            settings.UPLOAD_PATH, key, "file_name")
+        with open(uploaded_file_path) as f:
+            self.assertEqual(f.read(), file_content)
+
+        # Test we can fetch the newly uploaded file if we present the key
+        response = self.client.get("http://testserver/file_name",
+                                   data={"key": key})
+        self.assertEqual(response.status_code, 200)
+        with open(response.get('X-Sendfile', None)) as f:
+            self.assertEqual(file_content, f.read())
+
+        response = self.client.get("http://testserver/file_name")
+        self.assertEqual(response.status_code, 404)
+
+        self.assertNotEqual(
+            APIKeyStore.objects.get(key=key).last_used, last_used)
+
+    def test_get_public_key_post_and_get_file(self):
+        response = self.client.get("http://testserver/api/request_key",
+                                   data={"key": settings.MASTER_API_KEY,
+                                         "public": ""})
+
+        self.assertEqual(response.status_code, 200)
+        # Don't care what the key is, as long as it isn't blank
+        self.assertRegexpMatches(response.content, "\S+")
+        key = response.content
+
+        # Now write a file so we can upload it
+        file_content = "test_get_key_post_and_get_file"
+        buildinfo_content = "\n".join([
+            "Format-Version: 0.1",
+            "Files-Pattern: *",
+            "Build-Name: test",
+            "License-Type: open"])
+
+        self._send_file('http://testserver/pub/file_name', key, file_content)
+        self._send_file(
+            'http://testserver/pub/BUILD-INFO.txt', key, buildinfo_content)
+
+        # Check the upload worked by reading the file back from its
+        # uploaded location
+        uploaded_file_path = os.path.join(
+            settings.SERVED_PATHS[0], 'pub/file_name')
+
+        with open(uploaded_file_path) as f:
+            self.assertEqual(f.read(), file_content)
+
+        # Test we can fetch the newly uploaded file
+        response = self.client.get("http://testserver/pub/file_name")
+        self.assertEqual(response.status_code, 200)
+
+    def test_post_empty_file(self):
+        '''Ensure we accept zero byte files'''
+        response = self.client.get("http://testserver/api/request_key",
+                                   data={"key": settings.MASTER_API_KEY})
+
+        self.assertEqual(response.status_code, 200)
+        # Don't care what the key is, as long as it isn't blank
+        self.assertRegexpMatches(response.content, "\S+")
+        key = response.content
+
+        file_content = ""
+        self._send_file('http://testserver/file_name', key, file_content)
+
+        # Check the upload worked by reading the file back from its
+        # uploaded location
+        uploaded_file_path = os.path.join(
+            settings.UPLOAD_PATH, key, "file_name")
+        with open(uploaded_file_path) as f:
+            self.assertEqual(f.read(), file_content)
+
+        response = self.client.get("http://testserver/file_name")
+        self.assertNotEqual(response.status_code, 200)
+
+    def test_post_no_file(self):
+        response = self.client.get("http://testserver/api/request_key",
+                                   data={"key": settings.MASTER_API_KEY})
+
+        self.assertEqual(response.status_code, 200)
+        # Don't care what the key is, as long as it isn't blank
+        self.assertRegexpMatches(response.content, "\S+")
+        key = response.content
+
+        response = self.client.post(
+            "http://testserver/file_name", data={"key": key})
+        self.assertEqual(response.status_code, 500)
+
+    def test_post_file_no_key(self):
+        file_content = "test_post_file_no_key"
+        self._send_file("http://testserver/file_name", None, file_content, 500)
+        self.assertFalse(os.path.isfile(
+            os.path.join(settings.UPLOAD_PATH, "file_name")))
+
+    def test_post_file_random_key(self):
+        key = "%030x" % random.randrange(256 ** 15)
+        file_content = "test_post_file_random_key"
+        self._send_file("http://testserver/file_name", key, file_content, 500)
+
+    def test_api_delete_key(self):
+        response = self.client.get("http://testserver/api/request_key",
+                                   data={"key": settings.MASTER_API_KEY})
+
+        self.assertEqual(response.status_code, 200)
+        # Don't care what the key is, as long as it isn't blank
+        self.assertRegexpMatches(response.content, "\S+")
+        key = response.content
+
+        file_content = "test_api_delete_key"
+        self._send_file("http://testserver/file_name", key, file_content)
+
+        # Release the key, the files should be deleted
+        response = self.client.get("http://testserver/api/delete_key",
+                                   data={"key": key})
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(os.path.isfile(
+            os.path.join(settings.UPLOAD_PATH, key, "file_name")))
+
+        # Key shouldn't work after released
+        response = self.client.get("http://testserver/file_name",
+                                   data={"key": key})
+        self.assertNotEqual(response.status_code, 200)
diff --git a/license_protected_downloads/tests/test_views.py b/license_protected_downloads/tests/test_views.py
index c84d652..41958fd 100644
--- a/license_protected_downloads/tests/test_views.py
+++ b/license_protected_downloads/tests/test_views.py
@@ -6,8 +6,6 @@ import tempfile
 import unittest
 import urllib2
 import urlparse
-import json
-import random
 import shutil
 
 import mock
@@ -18,7 +16,6 @@ from django.http import HttpResponse
 
 from license_protected_downloads.buildinfo import BuildInfo
 from license_protected_downloads.config import INTERNAL_HOSTS
-from license_protected_downloads.models import APIKeyStore
 from license_protected_downloads.tests.helpers import temporary_directory
 from license_protected_downloads.tests.helpers import TestHttpServer
 from license_protected_downloads.views import _insert_license_into_db
@@ -130,7 +127,8 @@ class ViewTests(BaseServeViewTest):
         # Test that we use the "linaro" theme. This contains linaro.png
         self.assertContains(response, "linaro.png")
 
-    def set_up_license(self, target_file, index=0):
+    @staticmethod
+    def set_up_license(target_file, index=0):
         # Get BuildInfo for target file
         file_path = os.path.join(TESTSERVER_ROOT, target_file)
         build_info = BuildInfo(file_path)
@@ -209,131 +207,6 @@ class ViewTests(BaseServeViewTest):
         file_path = os.path.join(TESTSERVER_ROOT, target_file)
         self.assertEqual(response['X-Sendfile'], file_path)
 
-    def test_api_get_license_list(self):
-        target_file = "build-info/snowball-blob.txt"
-        digest = self.set_up_license(target_file)
-
-        license_url = "/api/license/" + target_file
-
-        # Download JSON containing license information
-        response = self.client.get(license_url)
-        data = json.loads(response.content)["licenses"]
-
-        # Extract digests
-        digests = [d["digest"] for d in data]
-
-        # Make sure digests match what is in the database
-        self.assertIn(digest, digests)
-        self.assertEqual(len(digests), 1)
-
-    def test_api_get_license_list_multi_license(self):
-        target_file = "build-info/multi-license.txt"
-        digest_1 = self.set_up_license(target_file)
-        digest_2 = self.set_up_license(target_file, 1)
-
-        license_url = "/api/license/" + target_file
-
-        # Download JSON containing license information
-        response = self.client.get(license_url)
-        data = json.loads(response.content)["licenses"]
-
-        # Extract digests
-        digests = [d["digest"] for d in data]
-
-        # Make sure digests match what is in the database
-        self.assertIn(digest_1, digests)
-        self.assertIn(digest_2, digests)
-        self.assertEqual(len(digests), 2)
-
-    def test_api_get_license_list_404(self):
-        target_file = "build-info/snowball-b"
-        license_url = "/api/license/" + target_file
-
-        # Download JSON containing license information
-        response = self.client.get(license_url)
-        self.assertEqual(response.status_code, 404)
-
-    def test_api_download_file(self):
-        target_file = "build-info/snowball-blob.txt"
-        digest = self.set_up_license(target_file)
-
-        url = urlparse.urljoin("http://testserver/", target_file)
-        response = self.client.get(url, follow=True,
-                                   HTTP_LICENSE_ACCEPTED=digest)
-        self.assertEqual(response.status_code, 200)
-        file_path = os.path.join(TESTSERVER_ROOT, target_file)
-        self.assertEqual(response['X-Sendfile'], file_path)
-
-    def test_api_download_file_multi_license(self):
-        target_file = "build-info/multi-license.txt"
-        digest_1 = self.set_up_license(target_file)
-        digest_2 = self.set_up_license(target_file, 1)
-
-        url = urlparse.urljoin("http://testserver/", target_file)
-        response = self.client.get(
-            url, follow=True,
-            HTTP_LICENSE_ACCEPTED=" ".join([digest_1, digest_2]))
-        self.assertEqual(response.status_code, 200)
-        file_path = os.path.join(TESTSERVER_ROOT, target_file)
-        self.assertEqual(response['X-Sendfile'], file_path)
-
-    def test_api_download_file_404(self):
-        target_file = "build-info/snowball-blob.txt"
-        digest = self.set_up_license(target_file)
-
-        url = urlparse.urljoin("http://testserver/", target_file[:-2])
-        response = self.client.get(url, follow=True,
-                                   HTTP_LICENSE_ACCEPTED=digest)
-        self.assertEqual(response.status_code, 404)
-
-    def test_api_get_listing(self):
-        url = "/api/ls/build-info"
-        response = self.client.get(url)
-        self.assertEqual(response.status_code, 200)
-
-        data = json.loads(response.content)["files"]
-
-        # For each file listed, check some key attributes
-        for file_info in data:
-            file_path = os.path.join(TESTSERVER_ROOT,
-                                     file_info["url"].lstrip("/"))
-            if file_info["type"] == "folder":
-                self.assertTrue(os.path.isdir(file_path))
-            else:
-                self.assertTrue(os.path.isfile(file_path))
-
-            mtime = os.path.getmtime(file_path)
-
-            self.assertEqual(mtime, file_info["mtime"])
-
-    def test_api_get_listing_single_file(self):
-        url = "/api/ls/build-info/snowball-blob.txt"
-        response = self.client.get(url)
-        self.assertEqual(response.status_code, 200)
-
-        data = json.loads(response.content)["files"]
-
-        # Should be a listing for a single file
-        self.assertEqual(len(data), 1)
-
-        # For each file listed, check some key attributes
-        for file_info in data:
-            file_path = os.path.join(TESTSERVER_ROOT,
-                                     file_info["url"].lstrip("/"))
-            if file_info["type"] == "folder":
-                self.assertTrue(os.path.isdir(file_path))
-            else:
-                self.assertTrue(os.path.isfile(file_path))
-
-            mtime = os.path.getmtime(file_path)
-
-            self.assertEqual(mtime, file_info["mtime"])
-
-    def test_api_get_listing_404(self):
-        url = "/api/ls/buld-info"
-        response = self.client.get(url)
-        self.assertEqual(response.status_code, 404)
-
     def test_OPEN_EULA_txt(self):
         target_file = '~linaro-android/staging-vexpress-a9/test.txt'
         url = urlparse.urljoin("http://testserver/", target_file)
@@ -865,253 +738,6 @@ class ViewTests(BaseServeViewTest):
         # Shouldn't be able to escape served paths...
         self.assertEqual(response.status_code, 404)
 
-    def test_get_key(self):
-        response = self.client.get("http://testserver/api/request_key",
-                                   data={"key": settings.MASTER_API_KEY})
-
-        self.assertEqual(response.status_code, 200)
-        # Don't care what the key is, as long as it isn't blank
-        self.assertRegexpMatches(response.content, "\S+")
-
-    def test_get_key_api_disabled(self):
-        settings.MASTER_API_KEY = ""
-        response = self.client.get("http://testserver/api/request_key",
-                                   data={"key": settings.MASTER_API_KEY})
-
-        self.assertEqual(response.status_code, 403)
-
-    def test_get_key_post_and_get_file(self):
-        response = self.client.get("http://testserver/api/request_key",
-                                   data={"key": settings.MASTER_API_KEY})
-
-        self.assertEqual(response.status_code, 200)
-        # Don't care what the key is, as long as it isn't blank
-        self.assertRegexpMatches(response.content, "\S+")
-        key = response.content
-        last_used = APIKeyStore.objects.get(key=key).last_used
-
-        # Now write a file so we can upload it
-        file_content = "test_get_key_post_and_get_file"
-        file_root = "/tmp"
-
-        tmp_file_name = os.path.join(
-            file_root,
-            self.make_temporary_file(file_content))
-
-        try:
-            # Send the file
-            with open(tmp_file_name) as f:
-                response = self.client.post(
-                    "http://testserver/file_name",
-                    data={"key": key, "file": f})
-                self.assertEqual(response.status_code, 200)
-
-            # Check the upload worked by reading the file back from its
-            # uploaded location
-            uploaded_file_path = os.path.join(
-                settings.UPLOAD_PATH, key, "file_name")
-            with open(uploaded_file_path) as f:
-                self.assertEqual(f.read(), file_content)
-
-            # Test we can fetch the newly uploaded file if we present the key
-            response = self.client.get("http://testserver/file_name",
-                                       data={"key": key})
-            self.assertEqual(response.status_code, 200)
-
-            response = self.client.get("http://testserver/file_name")
-            self.assertNotEqual(response.status_code, 200)
-            self.assertNotEqual(
-                APIKeyStore.objects.get(key=key).last_used, last_used)
-        finally:
-            # Delete the files generated by the test
-            shutil.rmtree(os.path.join(settings.UPLOAD_PATH, key))
-
-    def test_get_public_key_post_and_get_file(self):
-        response = self.client.get("http://testserver/api/request_key",
-                                   data={"key": settings.MASTER_API_KEY,
-                                         "public": ""})
-
-        self.assertEqual(response.status_code, 200)
-        # Don't care what the key is, as long as it isn't blank
-        self.assertRegexpMatches(response.content, "\S+")
-        key = response.content
-
-        # Now write a file so we can upload it
-        file_content = "test_get_key_post_and_get_file"
-        file_root = "/tmp"
-
-        tmp_file_name = os.path.join(
-            file_root,
-            self.make_temporary_file(file_content))
-
-        buildinfo_content = "\n".join([
-            "Format-Version: 0.1",
-            "Files-Pattern: *",
-            "Build-Name: test",
-            "License-Type: open"])
-        tmp_build_info = os.path.join(
-            file_root,
-            self.make_temporary_file(buildinfo_content))
-
-        try:
-            # Send the files
-            with open(tmp_file_name) as f:
-                response = self.client.post(
-                    "http://testserver/pub/file_name",
-                    data={"key": key, "file": f})
-                self.assertEqual(response.status_code, 200)
-
-            with open(tmp_build_info) as f:
-                response = self.client.post(
-                    "http://testserver/pub/BUILD-INFO.txt",
-                    data={"key": key, "file": f})
-                self.assertEqual(response.status_code, 200)
-
-            # Check the upload worked by reading the file back from its
-            # uploaded location
-            uploaded_file_path = os.path.join(
-                settings.SERVED_PATHS[0], 'pub/file_name')
-
-            with open(uploaded_file_path) as f:
-                self.assertEqual(f.read(), file_content)
-
-            # Test we can fetch the newly uploaded file
-            response = self.client.get("http://testserver/pub/file_name")
-            self.assertEqual(response.status_code, 200)
-        finally:
-            # Delete the files generated by the test
-            shutil.rmtree(os.path.join(settings.SERVED_PATHS[0], "pub"))
-
-    def test_post_empty_file(self):
-        '''Ensure we accept zero byte files'''
-        response = self.client.get("http://testserver/api/request_key",
-                                   data={"key": settings.MASTER_API_KEY})
-
-        self.assertEqual(response.status_code, 200)
-        # Don't care what the key is, as long as it isn't blank
-        self.assertRegexpMatches(response.content, "\S+")
-        key = response.content
-
-        # Now write a file so we can upload it
-        file_content = ""
-        file_root = "/tmp"
-
-        tmp_file_name = os.path.join(
-            file_root,
-            self.make_temporary_file(file_content))
-
-        try:
-            # Send the file
-            with open(tmp_file_name) as f:
-                response = self.client.post(
-                    "http://testserver/file_name",
-                    data={"key": key, "file": f})
-                self.assertEqual(response.status_code, 200)
-
-            # Check the upload worked by reading the file back from its
-            # uploaded location
-            uploaded_file_path = os.path.join(
-                settings.UPLOAD_PATH, key, "file_name")
-            with open(uploaded_file_path) as f:
-                self.assertEqual(f.read(), file_content)
-
-            # Test we can fetch the newly uploaded file if we present the key
-            response = self.client.get("http://testserver/file_name",
-                                       data={"key": key})
-            self.assertEqual(response.status_code, 200)
-
-            response = self.client.get("http://testserver/file_name")
-            self.assertNotEqual(response.status_code, 200)
-        finally:
-            # Delete the files generated by the test
-            shutil.rmtree(os.path.join(settings.UPLOAD_PATH, key))
-
-    def test_post_no_file(self):
-        response = self.client.get("http://testserver/api/request_key",
-                                   data={"key": settings.MASTER_API_KEY})
-
-        self.assertEqual(response.status_code, 200)
-        # Don't care what the key is, as long as it isn't blank
-        self.assertRegexpMatches(response.content, "\S+")
-        key = response.content
-
-        response = self.client.post(
-            "http://testserver/file_name", data={"key": key})
-        self.assertEqual(response.status_code, 500)
-
-    def test_post_file_no_key(self):
-        file_content = "test_post_file_no_key"
-        file_root = "/tmp"
-
-        tmp_file_name = os.path.join(
-            file_root,
-            self.make_temporary_file(file_content))
-
-        # Try to upload a file without a key.
-        with open(tmp_file_name) as f:
-            response = self.client.post(
-                "http://testserver/file_name", data={"file": f})
-            self.assertEqual(response.status_code, 500)
-
-        # Make sure the file didn't get created.
-        self.assertFalse(os.path.isfile(
-            os.path.join(settings.UPLOAD_PATH, "file_name")))
-
-    def test_post_file_random_key(self):
-        key = "%030x" % random.randrange(256 ** 15)
-        file_content = "test_post_file_random_key"
-        file_root = "/tmp"
-
-        tmp_file_name = os.path.join(
-            file_root,
-            self.make_temporary_file(file_content))
-
-        # Try to upload a file with a randomly generated key.
-        with open(tmp_file_name) as f:
-            response = self.client.post(
-                "http://testserver/file_name", data={"key": key, "file": f})
-            self.assertEqual(response.status_code, 500)
-
-        # Make sure the file didn't get created.
-        self.assertFalse(os.path.isfile(
-            os.path.join(settings.UPLOAD_PATH, key, "file_name")))
-
-    def test_api_delete_key(self):
-        response = self.client.get("http://testserver/api/request_key",
-                                   data={"key": settings.MASTER_API_KEY})
-
-        self.assertEqual(response.status_code, 200)
-        # Don't care what the key is, as long as it isn't blank
-        self.assertRegexpMatches(response.content, "\S+")
-        key = response.content
-        file_content = "test_api_delete_key"
-        file_root = "/tmp"
-
-        tmp_file_name = os.path.join(
-            file_root,
-            self.make_temporary_file(file_content))
-
-        with open(tmp_file_name) as f:
-            response = self.client.post(
-                "http://testserver/file_name", data={"key": key, "file": f})
-            self.assertEqual(response.status_code, 200)
-
-        self.assertTrue(os.path.isfile(os.path.join(settings.UPLOAD_PATH,
-                                                    key,
-                                                    "file_name")))
-
-        # Release the key, the files should be deleted
-        response = self.client.get("http://testserver/api/delete_key",
-                                   data={"key": key})
-        self.assertEqual(response.status_code, 200)
-        self.assertFalse(os.path.isfile(
-            os.path.join(settings.UPLOAD_PATH, key, "file_name")))
-
-        # Key shouldn't work after released
-        response = self.client.get("http://testserver/file_name",
-                                   data={"key": key})
-        self.assertNotEqual(response.status_code, 200)
-
 
 class HowtoViewTests(BaseServeViewTest):
     def test_no_howtos(self):