def testHandleErrorOnCallback(self, monkeypatch):
self.called = 0
def After(*args, **kwargs):
self.called += 1
raise RuntimeError('test')
def After2(*args, **kwargs):
self.called += 1
raise RuntimeError('test2')
c = callback.Callback(handle_errors=True)
c.Register(After)
c.Register(After2)
error_handled_on = []
def MyHandleException(msg):
error_handled_on.append(msg)
monkeypatch.setattr(handle_exception, 'HandleException', MyHandleException)
c()
assert len(error_handled_on) == 2
assert self.called == 2
c(1, a=2)
assert len(error_handled_on) == 4
assert self.called == 4
# test the default behaviour: errors are not handled and stop execution as usual
self.called = 0
c = callback.Callback()
c.Register(After)
c.Register(After2)
with pytest.raises(RuntimeError):
c()
assert self.called == 1
def testCallbackReceiverDies(self):
class A:
def on_foo(dummy, *args): # @NoSelf
self.args = args
self.args = None
a = A()
weak_a = weakref.ref(a)
foo = callback.Callback()
foo.Register(a.on_foo)
foo(1, 2)
assert self.args == (1, 2)
assert weak_a() is a
foo(3, 4)
assert self.args == (3, 4)
assert weak_a() is a
del a
assert weak_a() is None
foo(5, 6)
assert self.args == (3, 4)
def testExtraArgs(self):
'''
Tests the extra-args parameter in Callback.Register method.
'''
self.zulu_calls = []
def zulu_one(*args):
self.zulu_calls.append(args)
def zulu_too(*args):
self.zulu_calls.append(args)
alpha = callback.Callback()
alpha.Register(zulu_one, [1, 2])
assert self.zulu_calls == []
alpha('a')
assert self.zulu_calls == [(1, 2, 'a')]
alpha('a', 'b', 'c')
assert self.zulu_calls, [(1, 2, 'a'), (1, 2, 'a', 'b', 'c')]
# Test a second method with extra-args
alpha.Register(zulu_too, [9])
alpha('a')
assert self.zulu_calls == [(1, 2, 'a'), (1, 2, 'a', 'b', 'c'), (1, 2, 'a'), (9, 'a'), ]
def testCallback(self):
self.args = [None, None]
def f1(*args):
self.args[0] = args
def f2(*args):
'Never called!'
my_callback = callback.Callback()
assert len(my_callback) == 0
my_callback.Register(f1)
assert len(my_callback) == 1
my_callback(1, 2)
assert self.args[0] == (1, 2)
my_callback.Unregister(f1)
self.args[0] = None
my_callback(10, 20)
assert self.args[0] is None
def foo(): pass
my_callback.Unregister(foo) # Not raises
def testNeedsUnregister(self):
c = callback.Callback()
# Even when the function isn't registered, we not raise an error.
def Func():
'Never called!'
# self.assertNotRaises(RuntimeError,
c.Unregister(Func)
def testRegisterTwice(self):
self.called = 0
def After(*args):
self.called += 1
c = callback.Callback()
c.Register(After)
c.Register(After)
c.Register(After)
c()
assert self.called == 1
def testContains(self):
def foo(x):
'Never called!'
c = callback.Callback()
assert not c.Contains(foo)
c.Register(foo)
assert c.Contains(foo)
c.Unregister(foo)
assert not c.Contains(foo)
def testErrorNotHandledInCallback(self, monkeypatch):
class MyError(ErrorNotHandledInCallback):
pass
def After(*args, **kwargs):
raise MyError()
c = callback.Callback(handle_errors=True)
c.Register(After)
with pytest.raises(MyError):
c()
def testUnregisterAll(self):
c = callback.Callback()
# self.assertNotRaises(AttributeError,
c.UnregisterAll()
self.called = 0
def Func():
self.called += 1
c.Register(Func)
c()
assert self.called == 1
c.UnregisterAll()
c()
assert self.called == 1
def testAfterRemoveCallback(self):
my_object = _MyClass()
my_object.SetAlpha(0)
my_object.SetBravo(0)
# Test After/Remove with a callback
event = callback.Callback()
callback.After(my_object.SetAlpha, event)
event.Register(my_object.SetBravo)
my_object.SetAlpha(3)
assert my_object.bravo == 3
callback.Remove(my_object.SetAlpha, event)
my_object.SetAlpha(4)
assert my_object.bravo == 3
def testRemoveCallback(self):
class C(object):
def __init__(self, name):
self.name = name
def OnCallback(self):
'Never called!'
def __eq__(self, other):
return self.name == other.name
def __ne__(self, other):
'''
Never called!
return not self == other
'''
instance1 = C('instance')
instance2 = C('instance')
assert instance1 == instance2
c = callback.Callback()
c.Register(instance1.OnCallback)
c.Register(instance2.OnCallback)
# removing first callback, and checking that it was actually removed as expected
c.Unregister(instance1.OnCallback)
assert c.Contains(instance1.OnCallback) == False
# self.assertNotRaises(RuntimeError,
c.Unregister(instance1.OnCallback)
# removing second callback, and checking that it was actually removed as expected
c.Unregister(instance2.OnCallback)
assert c.Contains(instance2.OnCallback) == False
# self.assertNotRaises(RuntimeError
c.Unregister(instance2.OnCallback)
def testKeyReusedAfterDead(self, monkeypatch):
self._gotten_key = False
def GetKey(*args, **kwargs):
self._gotten_key = True
return 1
monkeypatch.setattr(callback.Callback, '_GetKey', GetKey)
def AfterMethod(*args):
'Not called!'
def AfterMethodB(*args):
'Not called!'
c = callback.Callback()
c.Register(AfterMethod)
self._gotten_key = False
assert not c.Contains(AfterMethodB)
assert c.Contains(AfterMethod)
assert self._gotten_key
# As we made _GetKey return always the same, this will make it remove one and add the
# other one, so, the contains will have to check if they're actually the same or not.
c.Register(AfterMethodB)
self._gotten_key = False
assert c.Contains(AfterMethodB)
assert not c.Contains(AfterMethod)
assert self._gotten_key
class A(object):
def __init__(self):
self._a = 0
def GetA(self):
return self._a
def SetA(self, value):
self._a = value
a = property(GetA, SetA)
a = A()
# Coverage exercise
assert a.a == 0
a.a = 10
assert a.a == 10
# If registering a bound, it doesn't contain the unbound
c.Register(a.SetA)
assert not c.Contains(AfterMethodB)
assert not c.Contains(A.SetA)
assert c.Contains(a.SetA)
# But if registering an unbound, it contains the bound
c.Register(A.SetA)
assert not c.Contains(AfterMethodB)
assert c.Contains(A.SetA)
assert c.Contains(a.SetA)
c.Register(a.SetA)
assert len(c) == 1
del a
assert not c.Contains(AfterMethodB)
assert len(c) == 0
a = A()
c.Register(_CallbackWrapper(WeakMethodRef(a.SetA)))
assert len(c) == 1
del a
assert not c.Contains(AfterMethodB)
assert len(c) == 0
