Ticket #20034: 1148.diff

AUTHORS

@@ -293 +293 @@
     Baurzhan Ismagulov <ibr@radix50.net>
     Stephan Jaekel <steph@rdev.info>
     james_027@yahoo.com
+    Tom Jaskowski <tadeck@gmail.com>
     jcrasta@gmail.com
     jdetaeye
     Dmitry Jemerov <intelliyole@gmail.com>

django/core/files/uploadhandler.py

@@ -113 +113 @@
         """
         raise NotImplementedError()
 
+    def variable_complete(self, variable_name, variable_value):
+        """
+        Signal that a new variable has been parsed from the multipart request.
+
+        :param variable_name: name of the variable
+        :param variable_value: value of the multipart variable
+        """
+        pass
+
     def upload_complete(self):
         """
         Signal that the upload is complete. Subclasses should perform cleanup

django/http/multipartparser.py

@@ -167 +167 @@
                     else:
                         data = field_stream.read()
 
-                    self._post.appendlist(field_name,
-                                          force_text(data, encoding, errors='replace'))
+                    field_text = force_text(data, encoding, errors='replace')
+                    self._post.appendlist(field_name, field_text)
+                    
+                    for handler in handlers:
+                        try:
+                            handler.variable_complete(field_name, field_text)
+                        except StopFutureHandlers:
+                            break
+
                 elif item_type == FILE:
                     # This is a file, use the handler...
                     file_name = disposition.get('filename')

docs/topics/http/file-uploads.txt

@@ -425 +425 @@
 ``FileUploadHandler.upload_complete(self)``
     Callback signaling that the entire upload (all files) has completed.
 
+``FileUploadHandler.variable_complete(self, variable_name, variable_value)``
+    Callback signaling that a new variable has been parsed. This is called
+    before new file is parsed.
+
+    ``variable_name`` is a string name of the non-file ``<input>`` field.
+
+    ``variable_value`` is the value (text) provided in the field by browser.
+
+    This method may raise a ``StopFutureHandlers`` exception to prevent
+    future handlers from handling this variable.
+
+.. versionadded:: 1.6
+
+    The ``variable_complete`` method was added in Django 1.6.
+
 ``FileUploadHandler.handle_raw_input(self, input_data, META, content_length, boundary, encoding)``
     Allows the handler to completely override the parsing of the raw
     HTTP input.

tests/requests/tests.py

@@ -1 +1 @@
 # -*- encoding: utf-8 -*-
 from __future__ import unicode_literals
 
+from contextlib import contextmanager
 import time
 import warnings
 from datetime import datetime, timedelta
@@ -659 +660 @@
         with self.assertRaises(UnreadablePostError):
             request.body
 
+    def test_POST_new_variable_signal_in_multipart(self):
+        """
+        Multi part POST requests should allow reading variables even before
+        parsing whole files. This can be done by overloading file upload
+        handlers' ``new_variable`` method.
+        """
+        collected_variables_memory_handler = []
+        collected_variables_temporary_handler = []
+
+        def get_var_collector(handler):
+            """Retrieve variable collector for specific handler"""
+            def _collect_variable(self, variable_name, variable_value):
+                """Store variable in external list, to check it later"""
+                if handler == 'memory':
+                    collected_variables_memory_handler.append(
+                        (variable_name, variable_value),
+                    )
+                elif handler == 'temporary':
+                    collected_variables_temporary_handler.append(
+                        (variable_name, variable_value),
+                    )
+                else:
+                    raise NotImplementedError(
+                        'Collector for %s not implemented' % (handler,),
+                    )
+            return _collect_variable
+
+        @contextmanager
+        def override_upload_handler_methods():
+            """Override parser method temporarily"""
+            from django.core.files.uploadhandler import (
+                MemoryFileUploadHandler, TemporaryFileUploadHandler,
+            )
+            old_method_memory = MemoryFileUploadHandler.variable_complete
+            old_method_temporary = TemporaryFileUploadHandler.variable_complete
+
+            # Override handler method:
+            MemoryFileUploadHandler.variable_complete = get_var_collector(
+                'memory',
+            )
+            TemporaryFileUploadHandler.variable_complete = get_var_collector(
+                'temporary',
+            )
+            yield
+            # Recover previous state:
+            MemoryFileUploadHandler.new_variable = old_method_memory
+            TemporaryFileUploadHandler.new_variable = old_method_temporary
+
+        payload = FakePayload(
+            "\r\n".join([
+                '--boundary',
+                'Content-Disposition: form-data; name="n1"',
+                '',
+                'value',
+                '--boundary',
+                'Content-Disposition: form-data; name="n2"; filename="f.txt"',
+                'Content-Type: text/plain',
+                '',
+                '... contents of file1.txt ...',
+                'value',
+                '--boundary--',
+                'Content-Disposition: form-data; name="n3"',
+                '',
+                'value',
+                '--boundary--',
+                '']))
+        request = WSGIRequest({
+            'REQUEST_METHOD': 'POST',
+            'CONTENT_TYPE': 'multipart/form-data; boundary=boundary',
+            'CONTENT_LENGTH': len(payload),
+            'wsgi.input': payload})
+
+        # Use specific upload handlers
+        upload_handlers = (
+            'django.core.files.uploadhandler.MemoryFileUploadHandler',
+            'django.core.files.uploadhandler.TemporaryFileUploadHandler',
+        )
+        with override_upload_handler_methods(), self.settings(
+                FILE_UPLOAD_HANDLERS=upload_handlers,
+        ):
+            self.assertEqual(
+                request.POST,
+                {
+                    'n1': ['value'],
+                    'n3': ['value'],
+                },
+            )
+            self.assertEqual(len(request.FILES), 1)
+            self.assertIn('n2', request.FILES)
+
+            # Confirm the variables have been collected:
+            self.assertEqual(
+                collected_variables_memory_handler,
+                [('n1', 'value'), ('n3', 'value')],
+            )
+            self.assertEqual(
+                collected_variables_temporary_handler,
+                [('n1', 'value'), ('n3', 'value')],
+            )
+
 
 @skipIf(connection.vendor == 'sqlite'
         and connection.settings_dict['NAME'] in ('', ':memory:'),