def test_update(self): """Test if update method calls the handlers in order.""" registry = version_registry.registry # First an elementary test. c = Classic() state = state_pickler.get_state(c) h = Handler() registry.register('Classic', '__main__', h.upgrade) c1 = state_pickler.create_instance(state) state_pickler.set_state(c1, state) self.assertEqual(h.calls, [('upgrade', state, 0)]) # Remove the handler. registry.unregister('Classic', '__main__') # Now check to see if this works for inheritance trees. t = Test() state = state_pickler.get_state(t) h = Handler() registry.register('Classic', '__main__', h.upgrade) registry.register('New', '__main__', h.upgrade) registry.register('Test', '__main__', h.upgrade1) t1 = state_pickler.create_instance(state) state_pickler.set_state(t1, state) # This should call New handler, then the Test and then # Classic. self.assertEqual(h.calls, [('upgrade', state, 0), ('upgrade1', state, 1), ('upgrade', state.a, 0)])
def test_state_setter(self): """Test some of the features of the set_state method.""" t = TestClassic() self.set_object(t) # Get the saved state. res = state_pickler.get_state(t) # Now create a new instance and test the setter. t1 = state_pickler.create_instance(res) keys = ['c', 'b', 'f', 'i', 'tuple', 'list', 'l', 'numeric', 'n', 's', 'u', 'pure_list', 'inst', 'ref', 'dict'] ignore = list(keys) ignore.remove('b') first = ['b'] last = [] state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last) # Only 'b' should have been set. self.assertEqual(t1.b, True) # Rest are unchanged. self.assertEqual(t1.i, 7) self.assertEqual(t1.s, 'String') self.assertEqual(t1.u, u'Unicode') self.assertEqual(t1.inst.a, 'a') self.assertEqual(t1.list[0], 1) self.assertEqual(t1.tuple[-1].a, 'a') self.assertEqual(t1.dict['a'], 1) # Check if last works. last = ignore ignore = [] first = [] state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last) # Check everything. self.verify_unpickled(t1, res)
def test_state_is_saveable(self): """Test if the state can be saved like the object itself.""" t = TestClassic() self.set_object(t) state = state_pickler.get_state(t) # Now get the state of the state itself. state1 = state_pickler.get_state(state) self.verify_state(state1, state) # Same thing for the traited class. t = TestTraits() self.set_object(t) state = state_pickler.get_state(t) # Now get the state of the state itself. state1 = state_pickler.get_state(state) self.verify_state(state1, state)
def test_unpickle_classic(self): """Test if classic classes can be unpickled.""" t = TestClassic() self.set_object(t) # Get the pickled state. res = state_pickler.get_state(t) # Check each attribute. self.verify_unpickled(t, res)
def test_get_pure_state(self): """Test if get_pure_state is called first.""" class B: def __init__(self): self.a = 'dict' def __get_pure_state__(self): return {'a':'get_pure_state'} def __getstate__(self): return {'a':'getstate'} b = B() s = state_pickler.get_state(b) self.assertEqual(s.a, 'get_pure_state') del B.__get_pure_state__ s = state_pickler.get_state(b) self.assertEqual(s.a, 'getstate') del B.__getstate__ s = state_pickler.get_state(b) self.assertEqual(s.a, 'dict')
def test_state_setter_classic(self): """Test if classic classes' state can be set.""" t = TestClassic() self.set_object(t) # Get the pickled state. res = state_pickler.get_state(t) # Now create a new instance and set its state. t1 = state_pickler.create_instance(res) state_pickler.set_state(t1, res) # Check each attribute. self.verify_unpickled(t1, res)
def test_get_pure_state(self): """Test if get_pure_state is called first.""" class B: def __init__(self): self.a = 'dict' def __get_pure_state__(self): return {'a': 'get_pure_state'} def __getstate__(self): return {'a': 'getstate'} b = B() s = state_pickler.get_state(b) self.assertEqual(s.a, 'get_pure_state') del B.__get_pure_state__ s = state_pickler.get_state(b) self.assertEqual(s.a, 'getstate') del B.__getstate__ s = state_pickler.get_state(b) self.assertEqual(s.a, 'dict')
def test_reference_cycle(self): """Test if reference cycles are handled when setting the state.""" class A: pass class B: pass a = A() b = B() a.a = b b.b = a state = state_pickler.get_state(a) z = A() z.a = B() z.a.b = z state_pickler.set_state(z, state)
def test_get_version(self): """Test the get_version function.""" c = Classic() v = version_registry.get_version(c) res = [(('Classic', '__main__'), 0)] self.assertEqual(v, res) state = state_pickler.get_state(c) self.assertEqual(state.__metadata__['version'], res) n = New() v = version_registry.get_version(n) res = [(('New', '__main__'), 0)] self.assertEqual(v, res) state = state_pickler.get_state(n) self.assertEqual(state.__metadata__['version'], res) t = TraitClass() v = version_registry.get_version(t) res = [(('HasTraits', 'enthought.traits.has_traits'), -1), (('TraitClass', '__main__'), 0)] self.assertEqual(v, res) state = state_pickler.get_state(t) self.assertEqual(state.__metadata__['version'], res)
def test_has_instance(self): """Test to check has_instance correctness.""" a = A() r = state_pickler.get_state(a) self.assertEqual(r.__metadata__['has_instance'], True) l = [1, a] r = state_pickler.get_state(l) self.assertEqual(r.has_instance, True) self.assertEqual(r[1].__metadata__['has_instance'], True) d = {'a': l, 'b': 1} r = state_pickler.get_state(d) self.assertEqual(r.has_instance, True) self.assertEqual(r['a'].has_instance, True) self.assertEqual(r['a'][1].__metadata__['has_instance'], True) class B: def __init__(self): self.a = [1, A()] b = B() r = state_pickler.get_state(b) self.assertEqual(r.__metadata__['has_instance'], True) self.assertEqual(r.a.has_instance, True) self.assertEqual(r.a[1].__metadata__['has_instance'], True)
def test_has_instance(self): """Test to check has_instance correctness.""" a = A() r = state_pickler.get_state(a) self.assertEqual(r.__metadata__['has_instance'], True) l = [1, a] r = state_pickler.get_state(l) self.assertEqual(r.has_instance, True) self.assertEqual(r[1].__metadata__['has_instance'], True) d = {'a': l, 'b':1} r = state_pickler.get_state(d) self.assertEqual(r.has_instance, True) self.assertEqual(r['a'].has_instance, True) self.assertEqual(r['a'][1].__metadata__['has_instance'], True) class B: def __init__(self): self.a = [1, A()] b = B() r = state_pickler.get_state(b) self.assertEqual(r.__metadata__['has_instance'], True) self.assertEqual(r.a.has_instance, True) self.assertEqual(r.a[1].__metadata__['has_instance'], True)
def __deepcopy__(self, memo): """Method used by copy.deepcopy(). This also uses the state_pickler to work correctly. """ # Create a new instance. new = self.__class__() # If we have a saved state, use it for the new instance. If # not, get our state and save that. saved_state = self._saved_state if len(saved_state) == 0: state = state_pickler.get_state(self) saved_state = cPickle.dumps(state) new._saved_state = saved_state # In the unlikely case that a new instance is running, load # the saved state. if new.running: new._load_saved_state() return new
def test_state_setter(self): """Test some of the features of the set_state method.""" t = TestClassic() self.set_object(t) # Get the saved state. res = state_pickler.get_state(t) # Now create a new instance and test the setter. t1 = state_pickler.create_instance(res) keys = [ 'c', 'b', 'f', 'i', 'tuple', 'list', 'l', 'numeric', 'n', 's', 'u', 'pure_list', 'inst', 'ref', 'dict' ] ignore = list(keys) ignore.remove('b') first = ['b'] last = [] state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last) # Only 'b' should have been set. self.assertEqual(t1.b, True) # Rest are unchanged. self.assertEqual(t1.i, 7) self.assertEqual(t1.s, 'String') self.assertEqual(t1.u, u'Unicode') self.assertEqual(t1.inst.a, 'a') self.assertEqual(t1.list[0], 1) self.assertEqual(t1.tuple[-1].a, 'a') self.assertEqual(t1.dict['a'], 1) # Check if last works. last = ignore ignore = [] first = [] state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last) # Check everything. self.verify_unpickled(t1, res)