Ignore:
Timestamp:
Oct 3, 2016, 8:49:10 AM (3 years ago)
Author:
Ralph Meijer <ralphm@…>
Branch:
default
rebase_source:
d1e5d6827b59ba96688a5a8724fb63277a13dbf5
Message:

imported patch py3-compat.patch

File:
1 edited

Legend:

Unmodified
Added
Removed
  • wokkel/test/test_compat.py

    r165 r200  
    77"""
    88
    9 from zope.interface import implements
     9from __future__ import division, absolute_import
     10
     11from zope.interface import implementer
    1012from twisted.internet import task
    1113from twisted.internet.interfaces import IReactorTime
     
    1416
    1517from wokkel.compat import IQ
    16 from wokkel.compat import NamedConstant, Names, ValueConstant, Values
    1718
    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)
    6220class FakeReactor(object):
    6321
    64     implements(IReactorTime)
    6522    def __init__(self):
    6623        self.clock = task.Clock()
     
    9855        self.assertFalse(xs.iqDeferreds)
    9956        return d
    100 
    101 
    102 
    103 class NamedConstantTests(unittest.TestCase):
    104     """
    105     Tests for the L{twisted.python.constants.NamedConstant} class which is used
    106     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             pass
    114         self.container = foo
    115 
    116 
    117     def test_name(self):
    118         """
    119         The C{name} attribute of a L{NamedConstant} refers to the value passed
    120         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} includes
    130         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 each
    150         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 equal
    163         to each other, they also have different hashes to avoid collisions when
    164         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 constants
    177     collections.
    178     """
    179     def _notInstantiableTest(self, name, cls):
    180         """
    181         Assert that an attempt to instantiate the constants class raises
    182         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 of
    195     related constaints.
    196     """
    197     def setUp(self):
    198         """
    199         Create a fresh new L{Names} subclass for each unit test to use.  Since
    200         L{Names} is stateful, re-using the same subclass across test methods
    201         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 for
    206             L{Names}.
    207             """
    208             GET = NamedConstant()
    209             PUT = NamedConstant()
    210             POST = NamedConstant()
    211             DELETE = NamedConstant()
    212 
    213         self.METHOD = METHOD
    214 
    215 
    216     def test_notInstantiable(self):
    217         """
    218         A subclass of L{Names} raises C{TypeError} if an attempt is made to
    219         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 definition
    227         of a L{Names} subclass is available as an attribute on the resulting
    228         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 includes
    247         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 up
    263         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 that
    273         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} value
    281         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 constants
    289         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 the
    301         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 each
    313         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 on
    326         subsequent access.
    327         """
    328         first = self.METHOD._enumerants
    329         self.METHOD.GET # Side-effects!
    330         second = self.METHOD._enumerants
    331         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 of
    338     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.  Since
    343         L{Values} is stateful, re-using the same subclass across test methods
    344         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 = STATUS
    351 
    352 
    353     def test_notInstantiable(self):
    354         """
    355         A subclass of L{Values} raises C{TypeError} if an attempt is made to
    356         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 definition
    364         of a L{Values} subclass is available as an attribute on the resulting
    365         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 includes
    382         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 up
    398         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 the
    408         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 value
    434         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's
    444         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} value
    452         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 constants
    460         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 the
    471         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 on
    481         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 on
    492         subsequent access.
    493         """
    494         first = self.STATUS._enumerants
    495         self.STATUS.OK # Side-effects!
    496         second = self.STATUS._enumerants
    497         self.assertIdentical(first, second)
Note: See TracChangeset for help on using the changeset viewer.