| commit | author | age | ||
| a0423a | 1 | import unittest |
| e16ab0 | 2 | from pyramid import testing |
| a0423a | 3 | |
| CM | 4 | class NewRequestEventTests(unittest.TestCase): |
| 5 | def _getTargetClass(self): | |
| b60bdb | 6 | from pyramid.events import NewRequest |
| a0423a | 7 | return NewRequest |
| CM | 8 | |
| 9 | def _makeOne(self, request): | |
| 10 | return self._getTargetClass()(request) | |
| 11 | ||
| 02ce7d | 12 | def test_class_conforms_to_INewRequest(self): |
| b60bdb | 13 | from pyramid.interfaces import INewRequest |
| a0423a | 14 | from zope.interface.verify import verifyClass |
| CM | 15 | klass = self._getTargetClass() |
| 16 | verifyClass(INewRequest, klass) | |
| e224ff | 17 | |
| 02ce7d | 18 | def test_instance_conforms_to_INewRequest(self): |
| b60bdb | 19 | from pyramid.interfaces import INewRequest |
| a0423a | 20 | from zope.interface.verify import verifyObject |
| CM | 21 | request = DummyRequest() |
| 22 | inst = self._makeOne(request) | |
| 23 | verifyObject(INewRequest, inst) | |
| 24 | ||
| 25 | def test_ctor(self): | |
| 26 | request = DummyRequest() | |
| 27 | inst = self._makeOne(request) | |
| 28 | self.assertEqual(inst.request, request) | |
| 29 | ||
| 30 | class NewResponseEventTests(unittest.TestCase): | |
| 31 | def _getTargetClass(self): | |
| b60bdb | 32 | from pyramid.events import NewResponse |
| a0423a | 33 | return NewResponse |
| CM | 34 | |
| eb7ea4 | 35 | def _makeOne(self, request, response): |
| CM | 36 | return self._getTargetClass()(request, response) |
| a0423a | 37 | |
| 02ce7d | 38 | def test_class_conforms_to_INewResponse(self): |
| b60bdb | 39 | from pyramid.interfaces import INewResponse |
| a0423a | 40 | from zope.interface.verify import verifyClass |
| CM | 41 | klass = self._getTargetClass() |
| 42 | verifyClass(INewResponse, klass) | |
| e224ff | 43 | |
| 02ce7d | 44 | def test_instance_conforms_to_INewResponse(self): |
| b60bdb | 45 | from pyramid.interfaces import INewResponse |
| a0423a | 46 | from zope.interface.verify import verifyObject |
| eb7ea4 | 47 | request = DummyRequest() |
| a0423a | 48 | response = DummyResponse() |
| eb7ea4 | 49 | inst = self._makeOne(request, response) |
| a0423a | 50 | verifyObject(INewResponse, inst) |
| CM | 51 | |
| 52 | def test_ctor(self): | |
| eb7ea4 | 53 | request = DummyRequest() |
| a0423a | 54 | response = DummyResponse() |
| eb7ea4 | 55 | inst = self._makeOne(request, response) |
| CM | 56 | self.assertEqual(inst.request, request) |
| a0423a | 57 | self.assertEqual(inst.response, response) |
| CM | 58 | |
| 8f45be | 59 | class ApplicationCreatedEventTests(unittest.TestCase): |
| 02ce7d | 60 | def _getTargetClass(self): |
| TS | 61 | from pyramid.events import ApplicationCreated |
| 62 | return ApplicationCreated | |
| fbbe23 | 63 | |
| 02ce7d | 64 | def _makeOne(self, context=object()): |
| TS | 65 | return self._getTargetClass()(context) |
| 66 | ||
| 67 | def test_class_conforms_to_IApplicationCreated(self): | |
| b60bdb | 68 | from pyramid.interfaces import IApplicationCreated |
| 51dcd9 | 69 | from zope.interface.verify import verifyClass |
| 02ce7d | 70 | verifyClass(IApplicationCreated, self._getTargetClass()) |
| fbbe23 | 71 | |
| 02ce7d | 72 | def test_object_conforms_to_IApplicationCreated(self): |
| b60bdb | 73 | from pyramid.interfaces import IApplicationCreated |
| 8f45be | 74 | from zope.interface.verify import verifyObject |
| 02ce7d | 75 | verifyObject(IApplicationCreated, self._makeOne()) |
| 49304c | 76 | |
| 02ce7d | 77 | class WSGIApplicationCreatedEventTests(ApplicationCreatedEventTests): |
| TS | 78 | def _getTargetClass(self): |
| 79 | from pyramid.events import WSGIApplicationCreatedEvent | |
| 80 | return WSGIApplicationCreatedEvent | |
| 81 | ||
| 82 | def test_class_conforms_to_IWSGIApplicationCreatedEvent(self): | |
| 83 | from pyramid.interfaces import IWSGIApplicationCreatedEvent | |
| 49304c | 84 | from zope.interface.verify import verifyClass |
| 02ce7d | 85 | verifyClass(IWSGIApplicationCreatedEvent, self._getTargetClass()) |
| TS | 86 | |
| 87 | def test_object_conforms_to_IWSGIApplicationCreatedEvent(self): | |
| 88 | from pyramid.interfaces import IWSGIApplicationCreatedEvent | |
| 89 | from zope.interface.verify import verifyObject | |
| 90 | verifyObject(IWSGIApplicationCreatedEvent, self._makeOne()) | |
| 8f45be | 91 | |
| CM | 92 | class ContextFoundEventTests(unittest.TestCase): |
| 02ce7d | 93 | def _getTargetClass(self): |
| TS | 94 | from pyramid.events import ContextFound |
| 95 | return ContextFound | |
| 8f45be | 96 | |
| 02ce7d | 97 | def _makeOne(self, request=None): |
| TS | 98 | if request is None: |
| 99 | request = DummyRequest() | |
| 100 | return self._getTargetClass()(request) | |
| 101 | ||
| 102 | def test_class_conforms_to_IContextFound(self): | |
| 8f45be | 103 | from zope.interface.verify import verifyClass |
| b60bdb | 104 | from pyramid.interfaces import IContextFound |
| 02ce7d | 105 | verifyClass(IContextFound, self._getTargetClass()) |
| e224ff | 106 | |
| 02ce7d | 107 | def test_instance_conforms_to_IContextFound(self): |
| 49304c | 108 | from zope.interface.verify import verifyObject |
| b60bdb | 109 | from pyramid.interfaces import IContextFound |
| 02ce7d | 110 | verifyObject(IContextFound, self._makeOne()) |
| TS | 111 | |
| 112 | class AfterTraversalEventTests(ContextFoundEventTests): | |
| 113 | def _getTargetClass(self): | |
| 114 | from pyramid.events import AfterTraversal | |
| 115 | return AfterTraversal | |
| 116 | ||
| 117 | def test_class_conforms_to_IAfterTraversal(self): | |
| 118 | from zope.interface.verify import verifyClass | |
| 119 | from pyramid.interfaces import IAfterTraversal | |
| 120 | verifyClass(IAfterTraversal, self._getTargetClass()) | |
| e224ff | 121 | |
| 02ce7d | 122 | def test_instance_conforms_to_IAfterTraversal(self): |
| TS | 123 | from zope.interface.verify import verifyObject |
| 124 | from pyramid.interfaces import IAfterTraversal | |
| 125 | verifyObject(IAfterTraversal, self._makeOne()) | |
| fbbe23 | 126 | |
| 59428d | 127 | class BeforeTraversalEventTests(unittest.TestCase): |
| BJR | 128 | def _getTargetClass(self): |
| 129 | from pyramid.events import BeforeTraversal | |
| 130 | return BeforeTraversal | |
| 131 | ||
| 132 | def _makeOne(self, request=None): | |
| 133 | if request is None: | |
| 134 | request = DummyRequest() | |
| 135 | return self._getTargetClass()(request) | |
| 136 | ||
| 137 | def test_class_conforms_to_IBeforeTraversal(self): | |
| 138 | from zope.interface.verify import verifyClass | |
| 139 | from pyramid.interfaces import IBeforeTraversal | |
| 140 | verifyClass(IBeforeTraversal, self._getTargetClass()) | |
| 141 | ||
| 142 | def test_instance_conforms_to_IBeforeTraversal(self): | |
| 143 | from zope.interface.verify import verifyObject | |
| 144 | from pyramid.interfaces import IBeforeTraversal | |
| 145 | verifyObject(IBeforeTraversal, self._makeOne()) | |
| 146 | ||
| 147 | ||
| f07765 | 148 | class TestSubscriber(unittest.TestCase): |
| CM | 149 | def setUp(self): |
| e49638 | 150 | self.config = testing.setUp() |
| f07765 | 151 | |
| CM | 152 | def tearDown(self): |
| e49638 | 153 | testing.tearDown() |
| f07765 | 154 | |
| 95f766 | 155 | def _makeOne(self, *ifaces, **predicates): |
| b60bdb | 156 | from pyramid.events import subscriber |
| 95f766 | 157 | return subscriber(*ifaces, **predicates) |
| f07765 | 158 | |
| 2ea5c1 | 159 | def test_register_single(self): |
| CM | 160 | from zope.interface import Interface |
| 161 | class IFoo(Interface): pass | |
| 162 | class IBar(Interface): pass | |
| 163 | dec = self._makeOne(IFoo) | |
| 164 | def foo(): pass | |
| 165 | config = DummyConfigurator() | |
| 166 | scanner = Dummy() | |
| 167 | scanner.config = config | |
| 168 | dec.register(scanner, None, foo) | |
| 169 | self.assertEqual(config.subscribed, [(foo, IFoo)]) | |
| 170 | ||
| 171 | def test_register_multi(self): | |
| f07765 | 172 | from zope.interface import Interface |
| CM | 173 | class IFoo(Interface): pass |
| 174 | class IBar(Interface): pass | |
| 175 | dec = self._makeOne(IFoo, IBar) | |
| 176 | def foo(): pass | |
| 177 | config = DummyConfigurator() | |
| 178 | scanner = Dummy() | |
| 179 | scanner.config = config | |
| 180 | dec.register(scanner, None, foo) | |
| 2ea5c1 | 181 | self.assertEqual(config.subscribed, [(foo, IFoo), (foo, IBar)]) |
| CM | 182 | |
| 52a948 | 183 | def test_register_none_means_all(self): |
| CM | 184 | from zope.interface import Interface |
| 185 | dec = self._makeOne() | |
| 186 | def foo(): pass | |
| 187 | config = DummyConfigurator() | |
| 188 | scanner = Dummy() | |
| 189 | scanner.config = config | |
| 190 | dec.register(scanner, None, foo) | |
| 191 | self.assertEqual(config.subscribed, [(foo, Interface)]) | |
| 192 | ||
| 2ea5c1 | 193 | def test_register_objectevent(self): |
| CM | 194 | from zope.interface import Interface |
| 195 | class IFoo(Interface): pass | |
| 196 | class IBar(Interface): pass | |
| 197 | dec = self._makeOne([IFoo, IBar]) | |
| 198 | def foo(): pass | |
| 199 | config = DummyConfigurator() | |
| 200 | scanner = Dummy() | |
| 201 | scanner.config = config | |
| 202 | dec.register(scanner, None, foo) | |
| 203 | self.assertEqual(config.subscribed, [(foo, [IFoo, IBar])]) | |
| f07765 | 204 | |
| CM | 205 | def test___call__(self): |
| 206 | dec = self._makeOne() | |
| 207 | dummy_venusian = DummyVenusian() | |
| 208 | dec.venusian = dummy_venusian | |
| 209 | def foo(): pass | |
| 210 | dec(foo) | |
| cba2e1 | 211 | self.assertEqual(dummy_venusian.attached, |
| 010971 | 212 | [(foo, dec.register, 'pyramid', 1)]) |
| MM | 213 | |
| 214 | def test___call___with_venusian_args(self): | |
| 215 | dec = self._makeOne(_category='foo', _depth=1) | |
| 216 | dummy_venusian = DummyVenusian() | |
| 217 | dec.venusian = dummy_venusian | |
| 218 | def foo(): pass | |
| 219 | dec(foo) | |
| 220 | self.assertEqual(dummy_venusian.attached, | |
| 221 | [(foo, dec.register, 'foo', 2)]) | |
| 95f766 | 222 | |
| CM | 223 | def test_regsister_with_predicates(self): |
| 224 | from zope.interface import Interface | |
| 225 | dec = self._makeOne(a=1) | |
| 226 | def foo(): pass | |
| 227 | config = DummyConfigurator() | |
| 228 | scanner = Dummy() | |
| 229 | scanner.config = config | |
| 230 | dec.register(scanner, None, foo) | |
| 231 | self.assertEqual(config.subscribed, [(foo, Interface, {'a':1})]) | |
| f07765 | 232 | |
| a76e99 | 233 | class TestBeforeRender(unittest.TestCase): |
| 9a66aa | 234 | def _makeOne(self, system, val=None): |
| a76e99 | 235 | from pyramid.events import BeforeRender |
| 9a66aa | 236 | return BeforeRender(system, val) |
| a76e99 | 237 | |
| CM | 238 | def test_instance_conforms(self): |
| 239 | from zope.interface.verify import verifyObject | |
| 240 | from pyramid.interfaces import IBeforeRender | |
| 241 | event = self._makeOne({}) | |
| 242 | verifyObject(IBeforeRender, event) | |
| 243 | ||
| 244 | def test_setitem_success(self): | |
| 5c52da | 245 | event = self._makeOne({}) |
| a76e99 | 246 | event['a'] = 1 |
| 5c52da | 247 | self.assertEqual(event, {'a':1}) |
| a76e99 | 248 | |
| 82efa4 | 249 | def test_setdefault_fail(self): |
| 5c52da | 250 | event = self._makeOne({}) |
| 82efa4 | 251 | result = event.setdefault('a', 1) |
| CM | 252 | self.assertEqual(result, 1) |
| 5c52da | 253 | self.assertEqual(event, {'a':1}) |
| e224ff | 254 | |
| 82efa4 | 255 | def test_setdefault_success(self): |
| 5c52da | 256 | event = self._makeOne({}) |
| 82efa4 | 257 | event['a'] = 1 |
| CM | 258 | result = event.setdefault('a', 2) |
| 259 | self.assertEqual(result, 1) | |
| 5c52da | 260 | self.assertEqual(event, {'a':1}) |
| a76e99 | 261 | |
| CM | 262 | def test_update_success(self): |
| 5c52da | 263 | event = self._makeOne({'a':1}) |
| a76e99 | 264 | event.update({'b':2}) |
| 5c52da | 265 | self.assertEqual(event, {'a':1, 'b':2}) |
| a76e99 | 266 | |
| CM | 267 | def test__contains__True(self): |
| 268 | system = {'a':1} | |
| 269 | event = self._makeOne(system) | |
| a1d395 | 270 | self.assertTrue('a' in event) |
| a76e99 | 271 | |
| CM | 272 | def test__contains__False(self): |
| 273 | system = {} | |
| 274 | event = self._makeOne(system) | |
| a1d395 | 275 | self.assertFalse('a' in event) |
| a76e99 | 276 | |
| CM | 277 | def test__getitem__success(self): |
| 278 | system = {'a':1} | |
| 279 | event = self._makeOne(system) | |
| 280 | self.assertEqual(event['a'], 1) | |
| 281 | ||
| 282 | def test__getitem__fail(self): | |
| 283 | system = {} | |
| 284 | event = self._makeOne(system) | |
| 285 | self.assertRaises(KeyError, event.__getitem__, 'a') | |
| 286 | ||
| 287 | def test_get_success(self): | |
| 288 | system = {'a':1} | |
| 289 | event = self._makeOne(system) | |
| 290 | self.assertEqual(event.get('a'), 1) | |
| 291 | ||
| 292 | def test_get_fail(self): | |
| 293 | system = {} | |
| 294 | event = self._makeOne(system) | |
| 295 | self.assertEqual(event.get('a'), None) | |
| 296 | ||
| 9a66aa | 297 | def test_rendering_val(self): |
| CM | 298 | system = {} |
| 299 | val = {} | |
| 300 | event = self._makeOne(system, val) | |
| 301 | self.assertTrue(event.rendering_val is val) | |
| a76e99 | 302 | |
| f07765 | 303 | class DummyConfigurator(object): |
| CM | 304 | def __init__(self): |
| 305 | self.subscribed = [] | |
| 306 | ||
| 95f766 | 307 | def add_subscriber(self, wrapped, ifaces, **predicates): |
| CM | 308 | if not predicates: |
| 309 | self.subscribed.append((wrapped, ifaces)) | |
| 310 | else: | |
| 311 | self.subscribed.append((wrapped, ifaces, predicates)) | |
| f07765 | 312 | |
| CM | 313 | class DummyRegistry(object): |
| 314 | pass | |
| e224ff | 315 | |
| f07765 | 316 | class DummyVenusian(object): |
| CM | 317 | def __init__(self): |
| 318 | self.attached = [] | |
| 319 | ||
| 010971 | 320 | def attach(self, wrapped, fn, category=None, depth=None): |
| MM | 321 | self.attached.append((wrapped, fn, category, depth)) |
| f07765 | 322 | |
| CM | 323 | class Dummy: |
| 324 | pass | |
| e224ff | 325 | |
| a0423a | 326 | class DummyRequest: |
| CM | 327 | pass |
| 328 | ||
| 329 | class DummyResponse: | |
| 330 | pass | |
| 331 | ||
