cms.test_utils.util.request_factory: 70 total statements, 0.0% covered

Generated: Wed 2013-03-13 10:33 CET

Source file: /media/Envs/Envs/filer-gallery/lib/python2.7/site-packages/cms/test_utils/util/request_factory.py

Stats: 0 executed, 61 missed, 9 excluded, 105 ignored

  1. from StringIO import StringIO
  2. from django.conf import settings
  3. from django.core.handlers.wsgi import WSGIRequest
  4. from django.http import SimpleCookie
  5. from django.test.client import (FakePayload, MULTIPART_CONTENT, encode_multipart,
  6. BOUNDARY, CONTENT_TYPE_RE)
  7. from django.utils.encoding import smart_str
  8. from urllib import urlencode
  9. from urlparse import urlparse
  10. import urllib
  11. class RequestFactory(object):
  12. """
  13. Class that lets you create mock Request objects for use in testing.
  14. Usage:
  15. rf = RequestFactory()
  16. get_request = rf.get('/hello/')
  17. post_request = rf.post('/submit/', {'foo': 'bar'})
  18. Once you have a request object you can pass it to any view function,
  19. just as if that view had been hooked up using a URLconf.
  20. """
  21. def __init__(self, **defaults):
  22. self.defaults = defaults
  23. self.cookies = SimpleCookie()
  24. self.errors = StringIO()
  25. def _base_environ(self, **request):
  26. """
  27. The base environment for a request.
  28. """
  29. environ = {
  30. 'HTTP_COOKIE': self.cookies.output(header='', sep='; '),
  31. 'PATH_INFO': '/',
  32. 'QUERY_STRING': '',
  33. 'REMOTE_ADDR': '127.0.0.1',
  34. 'REQUEST_METHOD': 'GET',
  35. 'SCRIPT_NAME': '',
  36. 'SERVER_NAME': 'testserver',
  37. 'SERVER_PORT': '80',
  38. 'SERVER_PROTOCOL': 'HTTP/1.1',
  39. 'wsgi.version': (1,0),
  40. 'wsgi.url_scheme': 'http',
  41. 'wsgi.errors': self.errors,
  42. 'wsgi.multiprocess': True,
  43. 'wsgi.multithread': False,
  44. 'wsgi.run_once': False,
  45. }
  46. environ.update(self.defaults)
  47. environ.update(request)
  48. return environ
  49. def request(self, **request):
  50. "Construct a generic request object."
  51. req = WSGIRequest(self._base_environ(**request))
  52. req.session = {}
  53. return req
  54. def _get_path(self, parsed):
  55. # If there are parameters, add them
  56. if parsed[3]:
  57. return urllib.unquote(parsed[2] + ";" + parsed[3])
  58. else:
  59. return urllib.unquote(parsed[2])
  60. def get(self, path, data={}, **extra):
  61. "Construct a GET request"
  62. parsed = urlparse(path)
  63. r = {
  64. 'CONTENT_TYPE': 'text/html; charset=utf-8',
  65. 'PATH_INFO': self._get_path(parsed),
  66. 'QUERY_STRING': urlencode(data, doseq=True) or parsed[4],
  67. 'REQUEST_METHOD': 'GET',
  68. 'wsgi.input': FakePayload('')
  69. }
  70. r.update(extra)
  71. return self.request(**r)
  72. def post(self, path, data={}, content_type=MULTIPART_CONTENT,
  73. **extra):
  74. "Construct a POST request."
  75. if content_type is MULTIPART_CONTENT:
  76. post_data = encode_multipart(BOUNDARY, data)
  77. else:
  78. # Encode the content so that the byte representation is correct.
  79. match = CONTENT_TYPE_RE.match(content_type)
  80. if match:
  81. charset = match.group(1)
  82. else:
  83. charset = settings.DEFAULT_CHARSET
  84. post_data = smart_str(data, encoding=charset)
  85. parsed = urlparse(path)
  86. r = {
  87. 'CONTENT_LENGTH': len(post_data),
  88. 'CONTENT_TYPE': content_type,
  89. 'PATH_INFO': self._get_path(parsed),
  90. 'QUERY_STRING': parsed[4],
  91. 'REQUEST_METHOD': 'POST',
  92. 'wsgi.input': FakePayload(post_data),
  93. }
  94. r.update(extra)
  95. return self.request(**r)
  96. def head(self, path, data={}, **extra):
  97. "Construct a HEAD request."
  98. parsed = urlparse(path)
  99. r = {
  100. 'CONTENT_TYPE': 'text/html; charset=utf-8',
  101. 'PATH_INFO': self._get_path(parsed),
  102. 'QUERY_STRING': urlencode(data, doseq=True) or parsed[4],
  103. 'REQUEST_METHOD': 'HEAD',
  104. 'wsgi.input': FakePayload('')
  105. }
  106. r.update(extra)
  107. return self.request(**r)
  108. def options(self, path, data={}, **extra):
  109. "Constrict an OPTIONS request"
  110. parsed = urlparse(path)
  111. r = {
  112. 'PATH_INFO': self._get_path(parsed),
  113. 'QUERY_STRING': urlencode(data, doseq=True) or parsed[4],
  114. 'REQUEST_METHOD': 'OPTIONS',
  115. 'wsgi.input': FakePayload('')
  116. }
  117. r.update(extra)
  118. return self.request(**r)
  119. def put(self, path, data={}, content_type=MULTIPART_CONTENT,
  120. **extra):
  121. "Construct a PUT request."
  122. if content_type is MULTIPART_CONTENT:
  123. post_data = encode_multipart(BOUNDARY, data)
  124. else:
  125. post_data = data
  126. # Make `data` into a querystring only if it's not already a string. If
  127. # it is a string, we'll assume that the caller has already encoded it.
  128. query_string = None
  129. if not isinstance(data, basestring):
  130. query_string = urlencode(data, doseq=True)
  131. parsed = urlparse(path)
  132. r = {
  133. 'CONTENT_LENGTH': len(post_data),
  134. 'CONTENT_TYPE': content_type,
  135. 'PATH_INFO': self._get_path(parsed),
  136. 'QUERY_STRING': query_string or parsed[4],
  137. 'REQUEST_METHOD': 'PUT',
  138. 'wsgi.input': FakePayload(post_data),
  139. }
  140. r.update(extra)
  141. return self.request(**r)
  142. def delete(self, path, data={}, **extra):
  143. "Construct a DELETE request."
  144. parsed = urlparse(path)
  145. r = {
  146. 'PATH_INFO': self._get_path(parsed),
  147. 'QUERY_STRING': urlencode(data, doseq=True) or parsed[4],
  148. 'REQUEST_METHOD': 'DELETE',
  149. 'wsgi.input': FakePayload('')
  150. }
  151. r.update(extra)
  152. return self.request(**r)