Changeset 200:ab43d6940b65 for wokkel/test/test_compat.py
- Timestamp:
- Oct 3, 2016, 8:49:10 AM (6 years ago)
- Branch:
- default
- rebase_source:
- d1e5d6827b59ba96688a5a8724fb63277a13dbf5
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
wokkel/test/test_compat.py
r165 r200 7 7 """ 8 8 9 from zope.interface import implements 9 from __future__ import division, absolute_import 10 11 from zope.interface import implementer 10 12 from twisted.internet import task 11 13 from twisted.internet.interfaces import IReactorTime … … 14 16 15 17 from wokkel.compat import IQ 16 from wokkel.compat import NamedConstant, Names, ValueConstant, Values17 18 18 class DeprecationTest(unittest.TestCase): 19 """ 20 Deprecation tests for L{wokkel.compat}. 21 """ 22 23 def lookForDeprecationWarning(self, testmethod, attributeName, newName): 24 """ 25 Importing C{testmethod} emits a deprecation warning. 26 """ 27 warningsShown = self.flushWarnings([testmethod]) 28 self.assertEqual(len(warningsShown), 1) 29 self.assertIdentical(warningsShown[0]['category'], DeprecationWarning) 30 self.assertEqual( 31 warningsShown[0]['message'], 32 "wokkel.compat." + attributeName + " " 33 "was deprecated in Wokkel 0.7.0: Use " + newName + " instead.") 34 35 36 def test_bootstrapMixinTest(self): 37 """ 38 L{compat.BootstrapMixin} is deprecated. 39 """ 40 from wokkel.compat import BootstrapMixin 41 BootstrapMixin 42 self.lookForDeprecationWarning( 43 self.test_bootstrapMixinTest, 44 "BootstrapMixin", 45 "twisted.words.xish.xmlstream.BootstrapMixin") 46 47 48 def test_xmlStreamServerFactory(self): 49 """ 50 L{compat.XmlStreamServerFactory} is deprecated. 51 """ 52 from wokkel.compat import XmlStreamServerFactory 53 XmlStreamServerFactory 54 self.lookForDeprecationWarning( 55 self.test_xmlStreamServerFactory, 56 "XmlStreamServerFactory", 57 "twisted.words.protocols.jabber.xmlstream." 58 "XmlStreamServerFactory") 59 60 61 19 @implementer(IReactorTime) 62 20 class FakeReactor(object): 63 21 64 implements(IReactorTime)65 22 def __init__(self): 66 23 self.clock = task.Clock() … … 98 55 self.assertFalse(xs.iqDeferreds) 99 56 return d 100 101 102 103 class NamedConstantTests(unittest.TestCase):104 """105 Tests for the L{twisted.python.constants.NamedConstant} class which is used106 to represent individual values.107 """108 def setUp(self):109 """110 Create a dummy container into which constants can be placed.111 """112 class foo(Names):113 pass114 self.container = foo115 116 117 def test_name(self):118 """119 The C{name} attribute of a L{NamedConstant} refers to the value passed120 for the C{name} parameter to C{_realize}.121 """122 name = NamedConstant()123 name._realize(self.container, "bar", None)124 self.assertEqual("bar", name.name)125 126 127 def test_representation(self):128 """129 The string representation of an instance of L{NamedConstant} includes130 the container the instances belongs to as well as the instance's name.131 """132 name = NamedConstant()133 name._realize(self.container, "bar", None)134 self.assertEqual("<foo=bar>", repr(name))135 136 137 def test_equality(self):138 """139 A L{NamedConstant} instance compares equal to itself.140 """141 name = NamedConstant()142 name._realize(self.container, "bar", None)143 self.assertTrue(name == name)144 self.assertFalse(name != name)145 146 147 def test_nonequality(self):148 """149 Two different L{NamedConstant} instances do not compare equal to each150 other.151 """152 first = NamedConstant()153 first._realize(self.container, "bar", None)154 second = NamedConstant()155 second._realize(self.container, "bar", None)156 self.assertFalse(first == second)157 self.assertTrue(first != second)158 159 160 def test_hash(self):161 """162 Because two different L{NamedConstant} instances do not compare as equal163 to each other, they also have different hashes to avoid collisions when164 added to a C{dict} or C{set}.165 """166 first = NamedConstant()167 first._realize(self.container, "bar", None)168 second = NamedConstant()169 second._realize(self.container, "bar", None)170 self.assertNotEqual(hash(first), hash(second))171 172 173 174 class _ConstantsTestsMixin(object):175 """176 Mixin defining test helpers common to multiple types of constants177 collections.178 """179 def _notInstantiableTest(self, name, cls):180 """181 Assert that an attempt to instantiate the constants class raises182 C{TypeError}.183 184 @param name: A C{str} giving the name of the constants collection.185 @param cls: The constants class to test.186 """187 exc = self.assertRaises(TypeError, cls)188 self.assertEqual(name + " may not be instantiated.", str(exc))189 190 191 192 class NamesTests(unittest.TestCase, _ConstantsTestsMixin):193 """194 Tests for L{twisted.python.constants.Names}, a base class for containers of195 related constaints.196 """197 def setUp(self):198 """199 Create a fresh new L{Names} subclass for each unit test to use. Since200 L{Names} is stateful, re-using the same subclass across test methods201 makes exercising all of the implementation code paths difficult.202 """203 class METHOD(Names):204 """205 A container for some named constants to use in unit tests for206 L{Names}.207 """208 GET = NamedConstant()209 PUT = NamedConstant()210 POST = NamedConstant()211 DELETE = NamedConstant()212 213 self.METHOD = METHOD214 215 216 def test_notInstantiable(self):217 """218 A subclass of L{Names} raises C{TypeError} if an attempt is made to219 instantiate it.220 """221 self._notInstantiableTest("METHOD", self.METHOD)222 223 224 def test_symbolicAttributes(self):225 """226 Each name associated with a L{NamedConstant} instance in the definition227 of a L{Names} subclass is available as an attribute on the resulting228 class.229 """230 self.assertTrue(hasattr(self.METHOD, "GET"))231 self.assertTrue(hasattr(self.METHOD, "PUT"))232 self.assertTrue(hasattr(self.METHOD, "POST"))233 self.assertTrue(hasattr(self.METHOD, "DELETE"))234 235 236 def test_withoutOtherAttributes(self):237 """238 As usual, names not defined in the class scope of a L{Names}239 subclass are not available as attributes on the resulting class.240 """241 self.assertFalse(hasattr(self.METHOD, "foo"))242 243 244 def test_representation(self):245 """246 The string representation of a constant on a L{Names} subclass includes247 the name of the L{Names} subclass and the name of the constant itself.248 """249 self.assertEqual("<METHOD=GET>", repr(self.METHOD.GET))250 251 252 def test_lookupByName(self):253 """254 Constants can be looked up by name using L{Names.lookupByName}.255 """256 method = self.METHOD.lookupByName("GET")257 self.assertIdentical(self.METHOD.GET, method)258 259 260 def test_notLookupMissingByName(self):261 """262 Names not defined with a L{NamedConstant} instance cannot be looked up263 using L{Names.lookupByName}.264 """265 self.assertRaises(ValueError, self.METHOD.lookupByName, "lookupByName")266 self.assertRaises(ValueError, self.METHOD.lookupByName, "__init__")267 self.assertRaises(ValueError, self.METHOD.lookupByName, "foo")268 269 270 def test_name(self):271 """272 The C{name} attribute of one of the named constants gives that273 constant's name.274 """275 self.assertEqual("GET", self.METHOD.GET.name)276 277 278 def test_attributeIdentity(self):279 """280 Repeated access of an attribute associated with a L{NamedConstant} value281 in a L{Names} subclass results in the same object.282 """283 self.assertIdentical(self.METHOD.GET, self.METHOD.GET)284 285 286 def test_iterconstants(self):287 """288 L{Names.iterconstants} returns an iterator over all of the constants289 defined in the class, in the order they were defined.290 """291 constants = list(self.METHOD.iterconstants())292 self.assertEqual(293 [self.METHOD.GET, self.METHOD.PUT,294 self.METHOD.POST, self.METHOD.DELETE],295 constants)296 297 298 def test_attributeIterconstantsIdentity(self):299 """300 The constants returned from L{Names.iterconstants} are identical to the301 constants accessible using attributes.302 """303 constants = list(self.METHOD.iterconstants())304 self.assertIdentical(self.METHOD.GET, constants[0])305 self.assertIdentical(self.METHOD.PUT, constants[1])306 self.assertIdentical(self.METHOD.POST, constants[2])307 self.assertIdentical(self.METHOD.DELETE, constants[3])308 309 310 def test_iterconstantsIdentity(self):311 """312 The constants returned from L{Names.iterconstants} are identical on each313 call to that method.314 """315 constants = list(self.METHOD.iterconstants())316 again = list(self.METHOD.iterconstants())317 self.assertIdentical(again[0], constants[0])318 self.assertIdentical(again[1], constants[1])319 self.assertIdentical(again[2], constants[2])320 self.assertIdentical(again[3], constants[3])321 322 323 def test_initializedOnce(self):324 """325 L{Names._enumerants} is initialized once and its value re-used on326 subsequent access.327 """328 first = self.METHOD._enumerants329 self.METHOD.GET # Side-effects!330 second = self.METHOD._enumerants331 self.assertIdentical(first, second)332 333 334 335 class ValuesTests(unittest.TestCase, _ConstantsTestsMixin):336 """337 Tests for L{twisted.python.constants.Names}, a base class for containers of338 related constaints with arbitrary values.339 """340 def setUp(self):341 """342 Create a fresh new L{Values} subclass for each unit test to use. Since343 L{Values} is stateful, re-using the same subclass across test methods344 makes exercising all of the implementation code paths difficult.345 """346 class STATUS(Values):347 OK = ValueConstant("200")348 NOT_FOUND = ValueConstant("404")349 350 self.STATUS = STATUS351 352 353 def test_notInstantiable(self):354 """355 A subclass of L{Values} raises C{TypeError} if an attempt is made to356 instantiate it.357 """358 self._notInstantiableTest("STATUS", self.STATUS)359 360 361 def test_symbolicAttributes(self):362 """363 Each name associated with a L{ValueConstant} instance in the definition364 of a L{Values} subclass is available as an attribute on the resulting365 class.366 """367 self.assertTrue(hasattr(self.STATUS, "OK"))368 self.assertTrue(hasattr(self.STATUS, "NOT_FOUND"))369 370 371 def test_withoutOtherAttributes(self):372 """373 As usual, names not defined in the class scope of a L{Values}374 subclass are not available as attributes on the resulting class.375 """376 self.assertFalse(hasattr(self.STATUS, "foo"))377 378 379 def test_representation(self):380 """381 The string representation of a constant on a L{Values} subclass includes382 the name of the L{Values} subclass and the name of the constant itself.383 """384 self.assertEqual("<STATUS=OK>", repr(self.STATUS.OK))385 386 387 def test_lookupByName(self):388 """389 Constants can be looked up by name using L{Values.lookupByName}.390 """391 method = self.STATUS.lookupByName("OK")392 self.assertIdentical(self.STATUS.OK, method)393 394 395 def test_notLookupMissingByName(self):396 """397 Names not defined with a L{ValueConstant} instance cannot be looked up398 using L{Values.lookupByName}.399 """400 self.assertRaises(ValueError, self.STATUS.lookupByName, "lookupByName")401 self.assertRaises(ValueError, self.STATUS.lookupByName, "__init__")402 self.assertRaises(ValueError, self.STATUS.lookupByName, "foo")403 404 405 def test_lookupByValue(self):406 """407 Constants can be looked up by their associated value, defined by the408 argument passed to L{ValueConstant}, using L{Values.lookupByValue}.409 """410 status = self.STATUS.lookupByValue("200")411 self.assertIdentical(self.STATUS.OK, status)412 413 414 def test_lookupDuplicateByValue(self):415 """416 If more than one constant is associated with a particular value,417 L{Values.lookupByValue} returns whichever of them is defined first.418 """419 class TRANSPORT_MESSAGE(Values):420 """421 Message types supported by an SSH transport.422 """423 KEX_DH_GEX_REQUEST_OLD = ValueConstant(30)424 KEXDH_INIT = ValueConstant(30)425 426 self.assertIdentical(427 TRANSPORT_MESSAGE.lookupByValue(30),428 TRANSPORT_MESSAGE.KEX_DH_GEX_REQUEST_OLD)429 430 431 def test_notLookupMissingByValue(self):432 """433 L{Values.lookupByValue} raises L{ValueError} when called with a value434 with which no constant is associated.435 """436 self.assertRaises(ValueError, self.STATUS.lookupByValue, "OK")437 self.assertRaises(ValueError, self.STATUS.lookupByValue, 200)438 self.assertRaises(ValueError, self.STATUS.lookupByValue, "200.1")439 440 441 def test_name(self):442 """443 The C{name} attribute of one of the constants gives that constant's444 name.445 """446 self.assertEqual("OK", self.STATUS.OK.name)447 448 449 def test_attributeIdentity(self):450 """451 Repeated access of an attribute associated with a L{ValueConstant} value452 in a L{Values} subclass results in the same object.453 """454 self.assertIdentical(self.STATUS.OK, self.STATUS.OK)455 456 457 def test_iterconstants(self):458 """459 L{Values.iterconstants} returns an iterator over all of the constants460 defined in the class, in the order they were defined.461 """462 constants = list(self.STATUS.iterconstants())463 self.assertEqual(464 [self.STATUS.OK, self.STATUS.NOT_FOUND],465 constants)466 467 468 def test_attributeIterconstantsIdentity(self):469 """470 The constants returned from L{Values.iterconstants} are identical to the471 constants accessible using attributes.472 """473 constants = list(self.STATUS.iterconstants())474 self.assertIdentical(self.STATUS.OK, constants[0])475 self.assertIdentical(self.STATUS.NOT_FOUND, constants[1])476 477 478 def test_iterconstantsIdentity(self):479 """480 The constants returned from L{Values.iterconstants} are identical on481 each call to that method.482 """483 constants = list(self.STATUS.iterconstants())484 again = list(self.STATUS.iterconstants())485 self.assertIdentical(again[0], constants[0])486 self.assertIdentical(again[1], constants[1])487 488 489 def test_initializedOnce(self):490 """491 L{Values._enumerants} is initialized once and its value re-used on492 subsequent access.493 """494 first = self.STATUS._enumerants495 self.STATUS.OK # Side-effects!496 second = self.STATUS._enumerants497 self.assertIdentical(first, second)
Note: See TracChangeset
for help on using the changeset viewer.