cms.test_utils.util.context_managers: 111 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/context_managers.py

Stats: 0 executed, 102 missed, 9 excluded, 77 ignored

  1. # -*- coding: utf-8 -*-
  2. from django.conf import settings
  3. from django.core.signals import request_started
  4. from django.db import reset_queries
  5. from django.template import context
  6. from django.utils.translation import get_language, activate
  7. from shutil import rmtree as _rmtree
  8. from tempfile import template, mkdtemp, _exists
  9. import StringIO
  10. import sys
  11. class NULL:
  12. pass
  13. class SettingsOverride(object):
  14. """
  15. Overrides Django settings within a context and resets them to their inital
  16. values on exit.
  17. Example:
  18. with SettingsOverride(DEBUG=True):
  19. # do something
  20. """
  21. def __init__(self, **overrides):
  22. self.overrides = overrides
  23. self.special_handlers = {
  24. 'TEMPLATE_CONTEXT_PROCESSORS': self.template_context_processors,
  25. }
  26. def __enter__(self):
  27. self.old = {}
  28. for key, value in self.overrides.items():
  29. self.old[key] = getattr(settings, key, NULL)
  30. setattr(settings, key, value)
  31. def __exit__(self, type, value, traceback):
  32. for key, value in self.old.items():
  33. if value is not NULL:
  34. setattr(settings, key, value)
  35. else:
  36. delattr(settings,key) # do not pollute the context!
  37. self.special_handlers.get(key, lambda:None)()
  38. def template_context_processors(self):
  39. context._standard_context_processors = None
  40. class StdOverride(object):
  41. def __init__(self, std='out', buffer=None):
  42. self.std = std
  43. self.buffer = buffer or StringIO.StringIO()
  44. def __enter__(self):
  45. setattr(sys, 'std%s' % self.std, self.buffer)
  46. return self.buffer
  47. def __exit__(self, type, value, traceback):
  48. setattr(sys, 'std%s' % self.std, getattr(sys, '__std%s__' % self.std))
  49. class StdoutOverride(StdOverride):
  50. """
  51. This overrides Python's the standard output and redirects it to a StringIO
  52. object, so that on can test the output of the program.
  53. example:
  54. lines = None
  55. with StdoutOverride() as buffer:
  56. # print stuff
  57. lines = buffer.getvalue()
  58. """
  59. def __init__(self, buffer=None):
  60. super(StdoutOverride, self).__init__('out', buffer)
  61. class LanguageOverride(object):
  62. def __init__(self, language):
  63. self.newlang = language
  64. def __enter__(self):
  65. self.oldlang = get_language()
  66. activate(self.newlang)
  67. def __exit__(self, type, value, traceback):
  68. activate(self.oldlang)
  69. class TemporaryDirectory:
  70. """Create and return a temporary directory. This has the same
  71. behavior as mkdtemp but can be used as a context manager. For
  72. example:
  73. with TemporaryDirectory() as tmpdir:
  74. ...
  75. Upon exiting the context, the directory and everthing contained
  76. in it are removed.
  77. """
  78. def __init__(self, suffix="", prefix=template, dir=None):
  79. self.name = mkdtemp(suffix, prefix, dir)
  80. def __enter__(self):
  81. return self.name
  82. def cleanup(self):
  83. if _exists(self.name):
  84. _rmtree(self.name)
  85. def __exit__(self, exc, value, tb):
  86. self.cleanup()
  87. class UserLoginContext(object):
  88. def __init__(self, testcase, user):
  89. self.testcase = testcase
  90. self.user = user
  91. def __enter__(self):
  92. loginok = self.testcase.client.login(username=self.user.username,
  93. password=self.user.username)
  94. self.old_user = getattr(self.testcase, 'user', None)
  95. self.testcase.user = self.user
  96. self.testcase.assertTrue(loginok)
  97. def __exit__(self, exc, value, tb):
  98. self.testcase.user = self.old_user
  99. if not self.testcase.user:
  100. delattr(self.testcase, 'user')
  101. self.testcase.client.logout()
  102. class ChangeModel(object):
  103. """
  104. Changes attributes on a model while within the context.
  105. These changes *ARE* saved to the database for the context!
  106. """
  107. def __init__(self, instance, **overrides):
  108. self.instance = instance
  109. self.overrides = overrides
  110. def __enter__(self):
  111. self.old = {}
  112. for key, value in self.overrides.items():
  113. self.old[key] = getattr(self.instance, key, NULL)
  114. setattr(self.instance, key, value)
  115. self.instance.save()
  116. def __exit__(self, exc, value, tb):
  117. for key in self.overrides.keys():
  118. old_value = self.old[key]
  119. if old_value is NULL:
  120. delattr(self.instance, key)
  121. else:
  122. setattr(self.instance, key, old_value)
  123. self.instance.save()
  124. class _AssertNumQueriesContext(object):
  125. def __init__(self, test_case, num, connection):
  126. self.test_case = test_case
  127. self.num = num
  128. self.connection = connection
  129. def __enter__(self):
  130. self.old_debug = settings.DEBUG
  131. settings.DEBUG = True
  132. self.starting_queries = len(self.connection.queries)
  133. request_started.disconnect(reset_queries)
  134. return self
  135. def __exit__(self, exc_type, exc_value, traceback):
  136. settings.DEBUG = self.old_debug
  137. request_started.connect(reset_queries)
  138. if exc_type is not None:
  139. return
  140. final_queries = len(self.connection.queries)
  141. executed = final_queries - self.starting_queries
  142. queries = '\n'.join([q['sql'] for q in self.connection.queries[self.starting_queries:]])
  143. self.test_case.assertEqual(
  144. executed, self.num, "%d queries executed, %d expected. Queries executed:\n%s" % (
  145. executed, self.num, queries
  146. )
  147. )