def testDebugger(self):
"""Test Debugger
Test Debugger
"""
manager = Manager()
debugger = Debugger()
foo = Foo()
manager += debugger
manager += foo
debugger.events = True
e = Event()
manager.send(e, "foo")
sys.stderr.seek(0)
s = sys.stderr.read().strip()
self.assertEquals(s, str(e))
sys.stderr.seek(0)
sys.stderr.truncate()
debugger.events = False
e = Event()
manager.send(e, "foo")
sys.stderr.seek(0)
s = sys.stderr.read().strip()
self.assertEquals(s, "")
sys.stderr.seek(0)
sys.stderr.truncate()
def testIgnoreEvents(self):
"""Test Debugger's IgnoreEvents
Test Debugger's IgnoreEvents
"""
manager = Manager()
debugger = Debugger()
foo = Foo()
manager += debugger
manager += foo
debugger.IgnoreEvents.extend([Test])
debugger.events = True
e = Event()
manager.send(e, "foo")
sys.stderr.seek(0)
s = sys.stderr.read().strip()
self.assertEquals(s, str(e))
sys.stderr.seek(0)
sys.stderr.truncate()
e = Test()
manager.send(e, "foo")
sys.stderr.seek(0)
s = sys.stderr.read().strip()
self.assertEquals(s, "")
sys.stderr.seek(0)
sys.stderr.truncate()
foo.unregister()
def main(self):
self.startup()
config = settings.settings()
m = Manager()
m += directory_monitor(config)
m += git_monitor()
m += cmd_runner(config)
m += gtk_status_icon(config)
m += notifications()
if self.options.verbose:
m += Debugger()
print inspect(m)
m.run()
def runTest(self):
x = Manager()
a = Foo()
x += a
a.push(Test(), "test")
a.flush()
self.assertTrue(a.flag)
def runTest(self):
class A(Component):
channel = "A"
flag = False
@handler("foo")
def onFOO(self, event, *args, **kwargs):
self.flag = True
class B(Component):
channel = "B"
flag = False
@handler("foo")
def onFOO(self, event, *args, **kwargs):
self.flag = True
class C(Component):
flag = False
@handler("foo")
def onFOO(self, event, *args, **kwargs):
self.flag = True
x = Manager()
a = A()
b = B()
c = C()
x += a
x += b
x += c
x.send(Event(), "*")
self.assertFalse(a.flag)
self.assertFalse(b.flag)
self.assertTrue(c.flag)
x -= a
x -= b
x -= c
def runTest(self):
class Foo(Component):
flag = False
channel = "foo"
@handler("foo")
def onFOO(self):
self.flag = True
class Bar(Component):
flag = False
channel = "bar"
@handler("foo", target="*")
def onFOO2(self):
self.flag = True
class FooBar(Component):
foo = False
@handler("foo", target="*")
def onFOO(self):
self.foo = True
manager = Manager()
foo = Foo()
bar = Bar()
foobar = FooBar()
manager += foo
manager += bar
manager += foobar
manager.send(Event(), "foo", "foo")
self.assertTrue(foo.flag)
self.assertTrue(bar.flag)
self.assertTrue(foobar.foo)
foo.unregister()
bar.unregister()
foobar.unregister()
def testTimer(self):
"""Test Timer
Test Timer
"""
x = Manager()
x.start()
a = Foo()
x += a
x += Timer(0.01, Test(), "timer")
sleep(0.1)
self.assertTrue(a.flag)
a.unregister()
x.stop()
def testPersistentTimer(self):
"""Test Persistent Timers
Test Persistent Timers
"""
x = Manager()
x.start()
a = Foo()
x += a
x += Timer(0.01, Test(), "timer", persist=True)
for i in xrange(5):
sleep(0.1)
self.assertTrue(a.flag)
a.flag = False
a.unregister()
x.stop()
def testDebugger(self):
"""Test Debugger
Test Debugger
"""
manager = Manager()
debugger = Debugger()
foo = Foo()
manager += debugger
manager += foo
debugger.events = True
e = Event()
manager.send(e, "foo")
sys.stderr.seek(0)
s = sys.stderr.read().strip()
self.assertEquals(s, str(e))
sys.stderr.seek(0)
sys.stderr.truncate()
debugger.events = False
e = Event()
manager.send(e, "foo")
sys.stderr.seek(0)
s = sys.stderr.read().strip()
self.assertEquals(s, "")
sys.stderr.seek(0)
sys.stderr.truncate()
def testIgnoreEvents(self):
"""Test Debugger's IgnoreEvents
Test Debugger's IgnoreEvents
"""
manager = Manager()
debugger = Debugger()
foo = Foo()
manager += debugger
manager += foo
debugger.IgnoreEvents.extend([Test])
debugger.events = True
e = Event()
manager.send(e, "foo")
sys.stderr.seek(0)
s = sys.stderr.read().strip()
self.assertEquals(s, str(e))
sys.stderr.seek(0)
sys.stderr.truncate()
e = Test()
manager.send(e, "foo")
sys.stderr.seek(0)
s = sys.stderr.read().strip()
self.assertEquals(s, "")
sys.stderr.seek(0)
sys.stderr.truncate()
foo.unregister()
def testLogger(self):
"""Test Debugger Logger
Test Debugger using dummy Logger-like
object (normally logging.Logger)
"""
manager = Manager()
logger = Logger()
foo = Foo()
debugger = Debugger(logger=logger)
manager += debugger
manager += foo
e = Event()
manager.push(e, "foo")
manager.flush()
manager.flush()
self.assertEquals(logger.msg, repr(e))
foo.unregister()
def testThread(self):
"""Test Thread
Test Thread
"""
x = Manager()
w = Foo()
x += w
w.start()
x.push(Test(), "foo")
while w.alive:
pass
x.flush()
self.assertEquals(w.count, 5)
self.assertTrue(w.done)
self.assertTrue(w.flag)
x -= w
def runTest(self):
manager = Manager()
filter = FilterComponent()
manager += filter
listener = ListenerComponent()
manager += listener
self.assertTrue(filter.onFOO in manager.channels[("*", "foo")])
self.assertTrue(listener.foo in manager.channels[("*", "foo")])
self.assertTrue(filter.onBAR in manager.channels[("*", "bar")])
self.assertTrue(listener.bar in manager.channels[("*", "bar")])
filter.unregister()
listener.unregister()
self.assertEquals(len(manager._handlers), 0)
def runTest(self):
x = Manager()
self.assertEquals(repr(x), "<Manager (q: 0 c: 0 h: 0) [S]>")
a = Foo()
x += a
self.assertEquals(repr(x), "<Manager (q: 1 c: 3 h: 3) [S]>")
x.flush()
self.assertEquals(repr(x), "<Manager (q: 0 c: 3 h: 3) [S]>")
x.push(Test(), "foo")
self.assertEquals(repr(x), "<Manager (q: 1 c: 3 h: 3) [S]>")
x.flush()
self.assertEquals(repr(x), "<Manager (q: 0 c: 3 h: 3) [S]>")
x -= a
self.assertEquals(repr(x), "<Manager (q: 1 c: 0 h: 0) [S]>")
def runTest(self):
class A(Component):
a = None
b = None
c = None
varargs = None
kwargs = None
@handler("args")
def onARGS(self, a, b, c):
self.a = a
self.b = b
self.c = c
@handler("varargs")
def onVARARGS(self, *varargs):
self.varargs = varargs
@handler("kwargs")
def onKWARGS(self, **kwargs):
self.kwargs = kwargs
x = Manager()
a = A()
x += a
a.send(Test(1, 2, 3), "args")
self.assertEquals(a.a, 1)
self.assertEquals(a.b, 2)
self.assertEquals(a.c, 3)
a.send(Test(1, 2, 3), "varargs")
self.assertEquals(a.varargs[0], 1)
self.assertEquals(a.varargs[1], 2)
self.assertEquals(a.varargs[2], 3)
a.send(Test(a=1, b=2, c=3), "kwargs")
self.assertEquals(a.kwargs["a"], 1)
self.assertEquals(a.kwargs["b"], 2)
self.assertEquals(a.kwargs["c"], 3)
def testTimer(self):
"""Test Timer
Test Timer
"""
x = Manager()
x.start()
a = Foo()
x += a
x += Timer(0.01, Test(), "timer")
sleep(0.1)
self.assertTrue(a.flag)
a.unregister()
x.stop()
def testPersistentTimer(self):
"""Test Persistent Timers
Test Persistent Timers
"""
x = Manager()
x.start()
a = Foo()
x += a
x += Timer(0.01, Test(), "timer", persist=True)
for i in xrange(5):
sleep(0.1)
self.assertTrue(a.flag)
a.flag = False
a.unregister()
x.stop()
def testLogger(self):
"""Test Debugger Logger
Test Debugger using dummy Logger-like
object (normally logging.Logger)
"""
manager = Manager()
logger = Logger()
foo = Foo()
debugger = Debugger(logger=logger)
manager += debugger
manager += foo
e = Event()
manager.push(e, "foo")
manager.flush()
manager.flush()
self.assertEquals(logger.msg, repr(e))
foo.unregister()
def runTest(self):
class Foo(Component):
flag = False
@handler("foo", "bar")
def onFOOBAR(self, event, *args, **kwargs):
self.flag = True
manager = Manager()
foo = Foo()
manager += foo
manager.send(Event(), "foo")
self.assertTrue(foo.flag)
foo.flag = False
manager.send(Event(), "bar")
self.assertTrue(foo.flag)
foo.flag = False
foo.unregister()
def testThread(self):
"""Test Thread
Test Thread
"""
x = Manager()
w = Foo()
x += w
w.start()
x.push(Test(), "foo")
while w.alive:
pass
x.flush()
self.assertEquals(w.count, 5)
self.assertTrue(w.done)
self.assertTrue(w.flag)
x -= w
def runTest(self):
class Foo(Component):
channel = "foo"
flag = False
@handler(filter=True)
def onALL(self, event, *args, **kwargs):
self.flag = True
return True
@handler("foo")
def onFOO(self):
self.flag = False
class Bar(Component):
flag = False
@handler("bar")
def onBAR(self):
self.flag = True
manager = Manager()
foo = Foo()
bar = Bar()
manager += foo
manager += bar
manager.send(Event(), "foo", foo.channel)
self.assertTrue(foo.flag)
manager.send(Event(), "bar")
self.assertFalse(bar.flag) ### (NEW) Behavioural Change
foo.unregister()
bar.unregister()
def testBridge(self):
"""Test Bridge
Test Bridge
"""
m1 = Manager()
b1 = Bridge(bind=8000, nodes=[("127.0.0.1", 8001)])
b1.IgnoreChannels.extend(["dummy"])
foo = Foo()
m1 += b1
m1 += foo
m1.start()
m2 = Manager()
b2 = Bridge(bind=8001, nodes=[("127.0.0.1", 8000)])
b2.IgnoreChannels.extend(["dummy"])
bar = Bar()
m2 += b2
m2 += bar
m2.start()
m1.push(Event(), "bar")
m1.push(Event(), "dummy")
wait()
self.assertFalse(foo.flag)
self.assertTrue(bar.flag)
m2.push(Event(), "foo")
m2.push(Event(), "dummy")
wait()
self.assertTrue(foo.flag)
self.assertTrue(bar.flag)
m1.stop()
m2.stop()
bar.unregister()
b2.unregister()
foo.unregister()
b1.unregister()
def __init__(self):
Manager.__init__(self)
self += GtkDriver()
self += Debugger()
def runTest(self):
import time
self.flag = False
self.foo = False
@handler("test")
def onTEST(test, time, stop=False):
test.flag = True
@handler("test")
def onFOO(test, time, stop=False):
test.foo = True
@handler("bar")
def onBAR(test, time):
pass
@handler(filter=True)
def onSTOP(*args, **kwargs):
return kwargs.get("stop", False)
manager = Manager()
manager.add(onSTOP)
manager.add(onTEST, ("*", "test"))
manager.add(onFOO, ("*", "test"))
manager.add(onBAR, ("*", "bar"))
self.assertTrue(onSTOP in manager._globals)
self.assertTrue(onTEST in manager.channels[("*", "test")])
self.assertTrue(onFOO in manager.channels[("*", "test")])
self.assertTrue(onBAR in manager.channels[("*", "bar")])
self.assertEquals(len(manager._handlers), 3)
manager.push(Test(self, time.time()), "test")
manager.flush()
self.assertTrue(self.flag == True)
self.flag = False
self.assertTrue(self.foo == True)
self.foo = False
self.assertEquals(len(manager), 0)
manager.send(Test(self, time.time()), "test")
self.assertTrue(self.flag == True)
self.flag = False
manager.send(Test(self, time.time()), "test")
self.assertTrue(self.flag == True)
self.flag = False
manager.send(Test(self, time.time(), stop=True), "test")
self.assertTrue(self.flag == False)
manager.remove(onSTOP)
manager.remove(onTEST, ("*", "test"))
manager.remove(onFOO, ("*", "test"))
manager.remove(onBAR, ("*", "bar"))
self.assertEquals(len(manager._handlers), 0)
def runTest(self):
@handler("foo", filter=True)
def onFOO():
pass
@handler("bar")
def onBAR():
pass
def onTEST():
pass
manager = Manager()
manager.add(onFOO)
manager.add(onBAR)
self.assertTrue(onFOO in manager._globals)
self.assertTrue(onBAR in manager._globals)
manager.add(onFOO, ("*", "foo"))
manager.add(onBAR, ("*", "bar"))
self.assertTrue(onFOO in manager.channels[("*", "foo")])
self.assertTrue(onBAR in manager.channels[("*", "bar")])
self.assertFalse(onTEST in manager._globals)
manager.remove(onFOO)
self.assertTrue(onFOO not in manager._handlers)
manager.remove(onBAR, ("*", "bar"))
self.assertTrue(("*", "bar") not in manager.channels)
self.assertTrue(onBAR in manager._globals)
manager.remove(onBAR)
self.assertTrue(onBAR not in manager._handlers)
self.assertEquals(len(manager._handlers), 0)
def testBridge(self):
"""Test Bridge
Test Bridge
"""
m1 = Manager()
b1 = Bridge(bind=8000, nodes=[("127.0.0.1", 8001)])
b1.IgnoreChannels.extend(["dummy"])
foo = Foo()
m1 += b1
m1 += foo
m1.start()
m2 = Manager()
b2 = Bridge(bind=8001, nodes=[("127.0.0.1", 8000)])
b2.IgnoreChannels.extend(["dummy"])
bar = Bar()
m2 += b2
m2 += bar
m2.start()
m1.push(Event(), "bar")
m1.push(Event(), "dummy")
wait()
self.assertFalse(foo.flag)
self.assertTrue(bar.flag)
m2.push(Event(), "foo")
m2.push(Event(), "dummy")
wait()
self.assertTrue(foo.flag)
self.assertTrue(bar.flag)
m1.stop()
m2.stop()
bar.unregister()
b2.unregister()
foo.unregister()
b1.unregister()
def runTest(self):
manager = Manager()
self.assertEquals(len(manager), 0)
self.assertEquals(len(manager._handlers), 0)
def runTest(self):
class ErrorHandler(Component):
def __init__(self):
super(ErrorHandler, self).__init__()
self.type = None
self.value = None
self.traceback = None
def exception(self, type, value, traceback, handler=None):
self.type = type
self.value = value
self.traceback = traceback
self.handler = handler
class TestError(Component):
def test1(self):
return x
def test2(self):
return self.x
def test3(self):
raise RuntimeError()
m = Manager()
e = ErrorHandler()
m += e
t = TestError()
m += t
m.push(Event(), "test1")
m.flush(); m.flush()
self.assertTrue(e.type is NameError)
self.assertTrue(isinstance(e.value, NameError))
self.assertEquals(e.handler, t.test1)
m.push(Event(), "test2")
m.flush(); m.flush()
self.assertTrue(e.type is AttributeError)
self.assertTrue(isinstance(e.value, AttributeError))
self.assertEquals(e.handler, t.test2)
m.push(Event(), "test3")
m.flush(); m.flush()
self.assertTrue(e.type is RuntimeError)
self.assertTrue(isinstance(e.value, RuntimeError))
self.assertEquals(e.handler, t.test3)
