cms.test_utils.util.mock << index >> cms.toolbar.base

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