blinkster: comparison web/lib/django/test/client.py

equal deleted inserted replaced

-:b758351d191f
+:cc9b7e14412b
 self.load_middleware()
 signals.request_started.send(sender=self.__class__)
 try:
 request = WSGIRequest(environ)
+# sneaky little hack so that we can easily get round
+# CsrfViewMiddleware.  This makes life easier, and is probably
+# required for backwards compatibility with external tests against
+# admin views.
+request._dont_enforce_csrf_checks = True
 response = self.get_response(request)
 # Apply response middleware.
 for middleware_method in self._response_middleware:
 response = middleware_method(request, response)
 and passes to the handler, returning the result of the handler.
 Assumes defaults for the query environment, which can be overridden
 using the arguments to the request.
 """
 environ = {
-'HTTP_COOKIE':      self.cookies,
+'HTTP_COOKIE':       self.cookies.output(header='', sep='; '),
 'PATH_INFO':         '/',
 'QUERY_STRING':      '',
 'REMOTE_ADDR':       '127.0.0.1',
 'REQUEST_METHOD':    'GET',
 'SCRIPT_NAME':       '',
 # Curry a data dictionary into an instance of the template renderer
 # callback function.
 data = {}
 on_template_render = curry(store_rendered_templates, data)
-signals.template_rendered.connect(on_template_render)
+signals.template_rendered.connect(on_template_render, dispatch_uid="template-render")
 # Capture exceptions created by the handler.
-got_request_exception.connect(self.store_exc_info)
+got_request_exception.connect(self.store_exc_info, dispatch_uid="request-exception")
 try:
-response = self.handler(environ)
-except TemplateDoesNotExist, e:
+try:
-# If the view raises an exception, Django will attempt to show
+response = self.handler(environ)
-# the 500.html template. If that template is not available,
+except TemplateDoesNotExist, e:
-# we should ignore the error in favor of re-raising the
+# If the view raises an exception, Django will attempt to show
-# underlying exception that caused the 500 error. Any other
+# the 500.html template. If that template is not available,
-# template found to be missing during view error handling
+# we should ignore the error in favor of re-raising the
-# should be reported as-is.
+# underlying exception that caused the 500 error. Any other
-if e.args != ('500.html',):
+# template found to be missing during view error handling
-raise
+# should be reported as-is.
+if e.args != ('500.html',):
-# Look for a signalled exception, clear the current context
+raise
-# exception data, then re-raise the signalled exception.
-# Also make sure that the signalled exception is cleared from
+# Look for a signalled exception, clear the current context
-# the local cache!
+# exception data, then re-raise the signalled exception.
-if self.exc_info:
+# Also make sure that the signalled exception is cleared from
-exc_info = self.exc_info
+# the local cache!
-self.exc_info = None
+if self.exc_info:
-raise exc_info[1], None, exc_info[2]
+exc_info = self.exc_info
+self.exc_info = None
-# Save the client and request that stimulated the response.
+raise exc_info[1], None, exc_info[2]
-response.client = self
-response.request = request
+# Save the client and request that stimulated the response.
+response.client = self
-# Add any rendered template detail to the response.
+response.request = request
-# If there was only one template rendered (the most likely case),
-# flatten the list to a single element.
+# Add any rendered template detail to the response.
-for detail in ('template', 'context'):
+# If there was only one template rendered (the most likely case),
-if data.get(detail):
+# flatten the list to a single element.
-if len(data[detail]) == 1:
+for detail in ('template', 'context'):
-setattr(response, detail, data[detail][0]);
+if data.get(detail):
+if len(data[detail]) == 1:
+setattr(response, detail, data[detail][0]);
+else:
+setattr(response, detail, data[detail])
 else:
-setattr(response, detail, data[detail])
+setattr(response, detail, None)
-else:
-setattr(response, detail, None)
+# Update persistent cookie data.
+if response.cookies:
-# Update persistent cookie data.
+self.cookies.update(response.cookies)
-if response.cookies:
-self.cookies.update(response.cookies)
+return response
+finally:
-return response
+signals.template_rendered.disconnect(dispatch_uid="template-render")
+got_request_exception.disconnect(dispatch_uid="request-exception")
 def get(self, path, data={}, follow=False, **extra):
 """
 Requests a response from the server using GET.
 """
 if content_type is MULTIPART_CONTENT:
 post_data = encode_multipart(BOUNDARY, data)
 else:
 post_data = data
+# Make `data` into a querystring only if it's not already a string. If
+# it is a string, we'll assume that the caller has already encoded it.
+query_string = None
+if not isinstance(data, basestring):
+query_string = urlencode(data, doseq=True)
 parsed = urlparse(path)
 r = {
 'CONTENT_LENGTH': len(post_data),
 'CONTENT_TYPE':   content_type,
 'PATH_INFO':      urllib.unquote(parsed[2]),
-'QUERY_STRING':   urlencode(data, doseq=True) or parsed[4],
+'QUERY_STRING':   query_string or parsed[4],
 'REQUEST_METHOD': 'PUT',
 'wsgi.input':     FakePayload(post_data),
 }
 r.update(extra)
 if self.session:
 request.session = self.session
 else:
 request.session = engine.SessionStore()
 login(request, user)
+# Save the session values.
+request.session.save()
 # Set the cookie to represent the session.
 session_cookie = settings.SESSION_COOKIE_NAME
 self.cookies[session_cookie] = request.session.session_key
 cookie_data = {
 'secure': settings.SESSION_COOKIE_SECURE or None,
 'expires': None,
 }
 self.cookies[session_cookie].update(cookie_data)
-# Save the session values.
-request.session.save()
 return True
 else:
 return False
 def logout(self):
 scheme, netloc, path, query, fragment = urlsplit(url)
 redirect_chain = response.redirect_chain
 redirect_chain.append((url, response.status_code))
+extra = {}
+if scheme:
+extra['wsgi.url_scheme'] = scheme
 # The test client doesn't handle external links,
 # but since the situation is simulated in test_client,
 # we fake things here by ignoring the netloc portion of the
 # redirected URL.
-response = self.get(path, QueryDict(query), follow=False)
+response = self.get(path, QueryDict(query), follow=False, **extra)
 response.redirect_chain = redirect_chain
 # Prevent loops
 if response.redirect_chain[-1] in response.redirect_chain[0:-1]:
 break

changeset 29	cc9b7e14412b
parent 0	0d40e90630ef