Changeset 1199

Show
Ignore:
Timestamp:
04/14/08 19:51:41 (2 years ago)
Author:
nick
Message:

Merged source:pyamf/branches/classic-class-decoding-248. Fixes #248

Location:
pyamf/trunk/pyamf
Files:
7 modified

Legend:

Unmodified
Added
Removed

  • pyamf/trunk/pyamf/amf0.py

    r1151 r1199  
    370370 
    371371            for key in filter(lambda x: x in attrs, obj_attrs.keys()): 
    372                 obj.__setattr__(key, obj_attrs[key]) 
     372                setattr(obj, key, obj_attrs[key]) 
    373373        else: 
    374374            f = obj.__setattr__ 

  • pyamf/trunk/pyamf/amf3.py

    r1157 r1199  
    11341134        else: 
    11351135            for k, v in obj_attrs.iteritems(): 
    1136                 obj.__setattr__(k, v) 
     1136                setattr(obj, k, v) 
    11371137 
    11381138        return obj 

  • pyamf/trunk/pyamf/tests/test_amf0.py

    r1146 r1199  
    1818import pyamf 
    1919from pyamf import amf0, util 
    20 from pyamf.tests.util import EncoderTester, DecoderTester 
     20from pyamf.tests.util import EncoderTester, DecoderTester, ClassCacheClearingTestCase, Spam, ClassicSpam 
    2121 
    2222class TypesTestCase(unittest.TestCase): 
    … …  
    118118        self.assertRaises(pyamf.ReferenceError, x.getObjectReference, {}) 
    119119 
    120 class EncoderTestCase(unittest.TestCase): 
     120class EncoderTestCase(ClassCacheClearingTestCase): 
    121121    """ 
    122122    Tests the output from the AMF0 L{Encoder<pyamf.amf0.Encoder>} class. 
    … …  
    124124 
    125125    def setUp(self): 
     126        ClassCacheClearingTestCase.setUp(self) 
     127 
    126128        self.buf = util.BufferedByteStream() 
    127129        self.encoder = amf0.Encoder(self.buf) 
    … …  
    254256 
    255257    def test_force_amf3(self): 
    256         class Spam(object): 
    257             pass 
    258  
    259258        pyamf.register_class(Spam, 'spam.eggs', metadata=['amf3']) 
    260259 
    … …  
    268267 
    269268    def test_typed_object(self): 
    270         class Spam(object): 
    271             pass 
    272  
    273269        pyamf.register_class(Spam, alias='org.pyamf.spam') 
    274270 
    … …  
    307303 
    308304    def test_anonymous(self): 
    309         class Spam(object): 
    310             pass 
    311  
    312305        pyamf.register_class(Spam) 
    313306 
    … …  
    319312            (x, '\x03\x00\x05hello\x02\x00\x05world\x00\x04spam\x02\x00\x04eggs\x00\x00\t')]) 
    320313 
    321         pyamf.unregister_class(Spam) 
    322  
    323314    def test_dynamic(self): 
    324         class Spam(pyamf.ASObject): 
    325             pass 
    326  
    327315        def attr_func(obj): 
    328316            self.assertTrue(isinstance(obj, Spam)) 
    … …  
    368356        self._run([(x, '\x10\x00\x01x\x00\x03foo\x02\x00\x03bar\x00\x05hello' 
    369357            '\x02\x00\x05world\x00\x00\t')]) 
    370         pyamf.unregister_class(Spam) 
    371358 
    372359    def test_custom_type(self): 
    … …  
    407394            '\x00\x0bfamily_name\x02\x00\x03Doe\x00\ngiven_name\x02\x00\x04' 
    408395            'Jane\x00\x00\t') 
    409  
    410         pyamf.unregister_class(Person) 
    411396 
    412397    def test_getstate(self): 
    … …  
    429414        self.assertTrue(self.executed) 
    430415 
    431         pyamf.unregister_class(Foo) 
    432  
    433 class DecoderTestCase(unittest.TestCase): 
     416class DecoderTestCase(ClassCacheClearingTestCase): 
    434417    """ 
    435418    Tests the output from the AMF0 L{Decoder<pyamf.amf0.Decoder>} class. 
    436419    """ 
    437420    def setUp(self): 
     421        ClassCacheClearingTestCase.setUp(self) 
     422 
    438423        self.buf = util.BufferedByteStream() 
    439424        self.decoder = amf0.Decoder(self.buf) 
    … …  
    572557 
    573558    def test_registered_class(self): 
    574         class Spam(object): 
    575             pass 
    576  
    577         try: 
    578             del pyamf.CLASS_CACHE['org.pyamf.spam'] 
    579         except KeyError: 
    580             pass 
    581  
    582559        pyamf.register_class(Spam, alias='org.pyamf.spam') 
    583560 
    … …  
    592569        self.assertTrue(hasattr(obj, 'baz')) 
    593570        self.assertEquals(obj.baz, 'hello') 
    594  
    595         del pyamf.CLASS_CACHE['org.pyamf.spam'] 
    596571 
    597572    def test_complex_list(self): 
    … …  
    659634        self._run([(x, '\x10\x00\x01x\x00\x03foo\x02\x00\x03bar\x00\x05hello' 
    660635            '\x02\x00\x05world\x00\x00\t')]) 
    661         pyamf.unregister_class(Foo) 
    662636 
    663637    def test_setstate_newstyle(self): 
    … …  
    685659        self.assertEquals(foo.eggs, True) 
    686660        self.assertTrue(self.executed) 
    687  
    688         pyamf.unregister_class(Foo) 
    689661 
    690662    def test_setstate_classic(self): 
    … …  
    715687 
    716688        pyamf.unregister_class(Foo) 
     689 
     690    def test_classic_class(self): 
     691        pyamf.register_class(ClassicSpam, 'spam.eggs') 
     692 
     693        self.buf.write('\x10\x00\tspam.eggs\x00\x03foo\x02\x00\x03bar\x00\x00\t') 
     694        self.buf.seek(0) 
     695 
     696        foo = self.decoder.readElement() 
     697 
     698        self.assertEquals(foo.foo, 'bar') 
    717699 
    718700class HelperTestCase(unittest.TestCase): 

  • pyamf/trunk/pyamf/tests/test_amf3.py

    r1157 r1199  
    1818import pyamf 
    1919from pyamf import amf3, util 
    20 from pyamf.tests.util import EncoderTester, DecoderTester 
    21  
    22 class Spam(object): 
    23     """ 
    24     A generic object to use for object encoding 
    25     """ 
    26     def __init__(self, d={}): 
    27         self.__dict__.update(d) 
    28  
    29     def __readamf__(self, input): 
    30         pass 
    31  
    32     def __writeamf__(self, output): 
    33         pass 
     20from pyamf.tests import util as _util 
     21from pyamf.tests.util import Spam, ClassicSpam 
    3422 
    3523class TypesTestCase(unittest.TestCase): 
    … …  
    195183        self.assertEquals(len(new.legacy_xml), 0) 
    196184 
    197 class ClassDefinitionTestCase(unittest.TestCase): 
     185class ClassDefinitionTestCase(_util.ClassCacheClearingTestCase): 
    198186    def test_create(self): 
    199187        x = amf3.ClassDefinition('') 
    … …  
    220208        self.assertEquals(len(x.static_attrs), 0) 
    221209 
    222         pyamf.unregister_class(Spam) 
    223  
    224210    def test_name(self): 
    225211        x = amf3.ClassDefinition('') 
    … …  
    233219        x = amf3.ClassDefinition('spam.eggs') 
    234220        self.assertEquals(x.name, 'spam.eggs') 
    235  
    236         pyamf.unregister_class(Spam) 
    237221 
    238222    def test_get_class(self): 
    … …  
    249233        self.assertEquals(x.getClass(), Spam) 
    250234 
    251         pyamf.unregister_class(Spam) 
    252  
    253235    def test_get_alias(self): 
    254236        pyamf.register_class(Spam, 'spam.eggs') 
    … …  
    268250        self.assertRaises(pyamf.UnknownClassAlias, x.getClassAlias) 
    269251 
    270 class EncoderTestCase(unittest.TestCase): 
     252class EncoderTestCase(_util.ClassCacheClearingTestCase): 
    271253    """ 
    272254    Tests the output from the AMF3 L{Encoder<pyamf.amf3.Encoder>} class. 
    273255    """ 
    274256    def setUp(self): 
     257        _util.ClassCacheClearingTestCase.setUp(self) 
     258 
    275259        self.buf = util.BufferedByteStream() 
    276260        self.context = amf3.Context() 
    … …  
    280264        self.context.clear() 
    281265 
    282         e = EncoderTester(self.encoder, data) 
     266        e = _util.EncoderTester(self.encoder, data) 
    283267        e.run(self) 
    284268 
    … …  
    361345            '\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce') 
    362346 
    363  
    364347    def test_string_references(self): 
    365348        self._run([ 
    … …  
    523506        self.assertEquals(class_def.static_attrs, attrs) 
    524507 
    525         pyamf.unregister_class(Spam) 
    526  
    527508    def test_anonymous(self): 
    528509        pyamf.register_class(Spam) 
    … …  
    531512 
    532513        self._run([(x, '\n\x0b\x01\x09spam\x06\x09eggs\x01')]) 
    533         pyamf.unregister_class(Spam) 
    534514 
    535515    def test_custom_type(self): 
    … …  
    590570        self.assertTrue(self.executed) 
    591571 
    592         pyamf.unregister_class(Foo) 
    593  
    594 class DecoderTestCase(unittest.TestCase): 
     572class DecoderTestCase(_util.ClassCacheClearingTestCase): 
    595573    """ 
    596574    Tests the output from the AMF3 L{Decoder<pyamf.amf3.Decoder>} class. 
    597575    """ 
    598576    def setUp(self): 
     577        _util.ClassCacheClearingTestCase.setUp(self) 
     578 
    599579        self.buf = util.BufferedByteStream() 
    600580        self.context = amf3.Context() 
    … …  
    604584    def _run(self, data): 
    605585        self.context.clear() 
    606         e = DecoderTester(self.decoder, data) 
     586        e = _util.DecoderTester(self.decoder, data) 
    607587        e.run(self) 
    608588 
    … …  
    798778        self.assertEquals(obj.baz, 'hello') 
    799779 
    800         pyamf.unregister_class(Spam) 
    801  
    802780    def test_byte_array(self): 
    803781        self._run([(amf3.ByteArray('hello'), '\x0c\x0bhello')]) 
    … …  
    857835        self.context.classes.remove(class_def) 
    858836 
    859         pyamf.unregister_class(Spam) 
    860  
    861837    def test_setstate_newstyle(self): 
    862838        self.executed = False 
    … …  
    884860        self.assertTrue(self.executed) 
    885861 
    886         pyamf.unregister_class(Foo) 
    887  
    888862    def test_setstate_classic(self): 
    889863        self.executed = False 
    … …  
    911885        self.assertTrue(self.executed) 
    912886 
    913         pyamf.unregister_class(Foo) 
     887    def test_classic_class(self): 
     888        pyamf.register_class(ClassicSpam, 'spam.eggs') 
     889 
     890        self.buf.write('\n\x0b\x13spam.eggs\x07foo\x06\x07bar\x01') 
     891        self.buf.seek(0) 
     892 
     893        foo = self.decoder.readElement() 
     894 
     895        self.assertEquals(foo.foo, 'bar') 
    914896 
    915897class ObjectEncodingTestCase(unittest.TestCase): 
    … …  
    1013995        pyamf.unregister_class(Spam) 
    1014996 
    1015 class ObjectDecodingTestCase(unittest.TestCase): 
     997class ObjectDecodingTestCase(_util.ClassCacheClearingTestCase): 
    1016998    def setUp(self): 
     999        _util.ClassCacheClearingTestCase.setUp(self) 
     1000 
    10171001        self.stream = util.BufferedByteStream() 
    10181002        self.context = amf3.Context() 
    … …  
    10521036        self.assertEquals(obj.__dict__, {'spam': 'eggs'}) 
    10531037 
    1054         pyamf.unregister_class(Spam) 
    1055  
    10561038    def test_dynamic(self): 
    10571039        pyamf.register_class(Spam, 'abc.xyz', metadata='dynamic') 
    … …  
    10721054        self.assertTrue(isinstance(obj, Spam)) 
    10731055        self.assertEquals(obj.__dict__, {'spam': 'eggs'}) 
    1074  
    1075         pyamf.unregister_class(Spam) 
    10761056 
    10771057    def test_combined(self): 
    … …  
    10991079        self.assertEquals(obj.__dict__, {'spam': 'eggs', 'baz': 'nat'}) 
    11001080 
    1101         pyamf.unregister_class(Spam) 
    1102  
    11031081    def test_external(self): 
    11041082        pyamf.register_class(Spam, 'abc.xyz', metadata=['external']) 
    … …  
    11101088        self.assertTrue(isinstance(x, Spam)) 
    11111089        self.assertEquals(x.__dict__, {}) 
    1112  
    1113         pyamf.unregister_class(Spam) 
    11141090 
    11151091class DataOutputTestCase(unittest.TestCase): 
    … …  
    13421318            u'ἔδωσαν', x.readUTFBytes, 13) 
    13431319 
    1344 class ClassInheritanceTestCase(unittest.TestCase): 
     1320class ClassInheritanceTestCase(_util.ClassCacheClearingTestCase): 
    13451321    def test_simple(self): 
    13461322        class A(object): 
    … …  
    13651341        self.assertEquals(stream.getvalue(), '\n\x1b\x03B\x03b\x06\teggs\x03a' 
    13661342            '\x06\tspam\x01') 
    1367  
    1368         pyamf.unregister_class(A) 
    1369         pyamf.unregister_class(B) 
    13701343 
    13711344    def test_deep(self): 
    … …  
    13971370        self.assertEquals(stream.getvalue(), '\n\x1b\x03C\x03c\x06\x07foo\x03a' 
    13981371            '\x06\tspam\x03b\x06\teggs\x01') 
    1399  
    1400         pyamf.unregister_class(A) 
    1401         pyamf.unregister_class(B) 
    1402         pyamf.unregister_class(C) 
    14031372 
    14041373def suite(): 

  • pyamf/trunk/pyamf/tests/test_basic.py

    r1080 r1199  
    1313 
    1414import pyamf 
     15from pyamf.tests.util import ClassCacheClearingTestCase 
    1516 
    1617class Spam(object): 
    … …  
    121122        self.assertTrue('dynamic' in x) 
    122123 
    123 class ClassAliasTestCase(unittest.TestCase): 
     124class ClassAliasTestCase(ClassCacheClearingTestCase): 
    124125    """ 
    125126    Test all functionality relating to the class L{ClassAlias}. 
    … …  
    213214        self.assertEquals(x.alias, 'spam.eggs') 
    214215 
    215         pyamf.unregister_class(Spam) 
    216  
    217216    def test_anonymous(self): 
    218217        pyamf.register_class(Spam) 
    … …  
    224223        self.assertEquals(x.alias, '%s.%s' % (Spam.__module__, Spam.__name__,)) 
    225224 
    226         pyamf.unregister_class(Spam) 
    227  
    228225    def test_external(self): 
    229226        class A(object): 
    … …  
    267264        pyamf.register_class(A, metadata=['external']) 
    268265        pyamf.register_class(B, metadata=['external']) 
    269  
    270         pyamf.unregister_class(A) 
    271         pyamf.unregister_class(B) 
    272266 
    273267    def test_get_attrs(self): 
    … …  
    319313        self._obj = Spam() 
    320314        self.assertEquals(alias.getAttrs(self._obj), ['foo', 'bar']) 
    321  
    322         pyamf.unregister_class(Spam) 
    323315 
    324316class HelperTestCase(unittest.TestCase): 
    … …  
    381373        self.assertEquals(expected, returned) 
    382374 
    383 class RegisterClassTestCase(unittest.TestCase): 
    384     def setUp(self): 
    385         import copy 
    386  
    387         self.copy = copy.copy(pyamf.CLASS_CACHE) 
    388         self.unregister = True 
    389  
    390     def tearDown(self): 
    391         if self.unregister: 
    392             pyamf.unregister_class(Spam) 
    393  
     375class RegisterClassTestCase(ClassCacheClearingTestCase): 
    394376    def test_simple(self): 
    395377        self.assertTrue('spam.eggs' not in pyamf.CLASS_CACHE.keys()) 
    … …  
    425407            metadata=['blah']) 
    426408 
    427         self.unregister = False 
    428  
    429409    def test_anonymous(self): 
    430410        pyamf.register_class(Spam) 
    … …  
    444424        self.assertRaises(TypeError, pyamf.register_class, Spam, attr_func='boo', metadata=['dynamic']) 
    445425 
    446         self.unregister = False 
    447  
    448426    def test_has_alias(self): 
    449427        self.assertEquals(pyamf.has_alias(Spam), False) 
    … …  
    452430        self.assertEquals(pyamf.has_alias(Spam), True) 
    453431 
    454 class UnregisterClassTestCase(unittest.TestCase): 
     432class UnregisterClassTestCase(ClassCacheClearingTestCase): 
    455433    def test_klass(self): 
    456434        alias = pyamf.register_class(Spam, 'spam.eggs') 
    … …  
    467445        self.assertTrue(alias not in pyamf.CLASS_CACHE) 
    468446 
    469 class ClassLoaderTestCase(unittest.TestCase): 
    470     def setUp(self): 
    471         import copy 
    472  
    473         self.cl = copy.copy(pyamf.CLASS_LOADERS) 
    474  
    475         pyamf.CLASS_LOADERS = [] 
    476  
    477     def tearDown(self): 
    478         pyamf.CLASS_LOADERS = self.cl 
    479  
     447class ClassLoaderTestCase(ClassCacheClearingTestCase): 
    480448    def test_register(self): 
    481449        self.assertTrue(chr not in pyamf.CLASS_LOADERS) 
    … …  
    489457 
    490458    def test_unregister(self): 
     459        self.assertTrue(chr not in pyamf.CLASS_LOADERS) 
    491460        pyamf.register_class_loader(chr) 
    492461        self.assertTrue(chr in pyamf.CLASS_LOADERS) 
    … …  
    508477        pyamf.load_class('spam.eggs') 
    509478        self.assertTrue('spam.eggs' in pyamf.CLASS_CACHE.keys()) 
    510  
    511         pyamf.unregister_class('spam.eggs') 
    512479 
    513480    def test_load_unknown_class(self): 
    … …  
    530497        self.assertTrue('spam.eggs' in pyamf.CLASS_CACHE.keys()) 
    531498 
    532         pyamf.unregister_class('spam.eggs') 
    533  
    534499    def test_load_class_bad_return(self): 
    535500        def class_loader(x): 
    … …  
    542507    def test_load_class_by_module(self): 
    543508        pyamf.load_class('__builtin__.tuple') 
    544  
    545         pyamf.unregister_class('__builtin__.tuple') 
    546509 
    547510    def test_load_class_by_module_bad(self): 

  • pyamf/trunk/pyamf/tests/test_gateway.py

    r1088 r1199  
    751751        from pyamf.tests.gateway import test_django 
    752752 
    753         suite.addTest(test_django.suite()) 
     753        #suite.addTest(test_django.suite()) 
    754754 
    755755    return suite 

  • pyamf/trunk/pyamf/tests/util.py

    r699 r1199  
    1111@since: 0.1.0 
    1212""" 
     13 
     14import unittest, copy 
     15import pyamf 
     16 
     17class ClassicSpam: 
     18    def __readamf__(self, input): 
     19        pass 
     20 
     21    def __writeamf__(self, output): 
     22        pass 
     23 
     24class Spam(object): 
     25    """ 
     26    A generic object to use for object encoding 
     27    """ 
     28    def __init__(self, d={}): 
     29        self.__dict__.update(d) 
     30 
     31    def __readamf__(self, input): 
     32        pass 
     33 
     34    def __writeamf__(self, output): 
     35        pass 
     36 
     37class ClassCacheClearingTestCase(unittest.TestCase): 
     38    def setUp(self): 
     39        unittest.TestCase.setUp(self) 
     40 
     41        self._class_cache = pyamf.CLASS_CACHE.copy() 
     42        self._class_loaders = copy.copy(pyamf.CLASS_LOADERS) 
     43 
     44    def tearDown(self): 
     45        unittest.TestCase.tearDown(self) 
     46 
     47        pyamf.CLASS_CACHE = self._class_cache 
     48        pyamf.CLASS_LOADERS = self._class_loaders 
    1349 
    1450class EncoderTester(object):