def xxtestRelativeSpeedOfAll(self): from time import time class A(Observable): def f(self): raise StopIteration(None) yield root = Observable() connector = Transparent() root.addObserver(connector) connector.addObserver(A()) connector.addObserver(A()) connector.addObserver(A()) connector.addObserver(A()) connector.addObserver(A()) connector.addObserver(A()) connector.addObserver(A()) t = 0.0 for _ in xrange(10000): g = compose(root.all.f()) t0 = time() for _ in g: g.next() t1 = time() t += t1 - t0 print t def f(): for _ in xrange(10000): g = compose(root.all.f()) for _ in g: g.next()
def testUnknownDispatchingNoImplementation(self): observable = Observable() class A(object): pass observable.addObserver(A()) retval = observable.all.unknown('non_existing_method', 'one') self.assertEquals([], list(compose(retval)))
def testBeTree(self): observable = Observable() child0 = Observable() child1 = Observable() root = be((observable, (child0, (child1, )))) self.assertEquals([child0], root._observers) self.assertEquals([child1], child0._observers)
def testDirectedMessagesCanAlsoBeAcceptedByObjects(self): observable = Observable() called = [] class Y(object): def method(this): called.append("Y") return yield def observable_name(this): return 'name' class Z(object): def method(this): called.append("Z") return yield observable.addObserver(Y()) observable.addObserver(Z()) list(compose(observable.all["name"].method())) self.assertEquals(['Y'], called) del called[:] list(compose(observable.all.method())) self.assertEquals(['Y', "Z"], called) del called[:] list(compose(observable.all["other"].method())) self.assertEquals([], called)
def testUndirectedObserverMessagingIsUnaffectedByObserverName(self): observable = Observable() called = [] class A(Observable): def method(this): called.append(("A", this.observable_name())) return yield class B(Observable): def method(this): called.append(("B", this.observable_name())) return yield observable.addObserver(A("name")) observable.addObserver(A().observable_setName("anothername")) observable.addObserver(B("anothername")) observable.addObserver(B()) list(compose(observable.all.method())) self.assertEquals([("A", "name"), ("A", "anothername"), ("B", "anothername"), ("B", None)], called) del called[:] list(compose(observable.all["name"].method())) self.assertEquals([("A", "name")], called)
def testDeferredObjectsAreCached(self): observable = Observable() class A(Observable): pass observable.addObserver(A("name")) d1 = observable.all["name"] d2 = observable.all["name"] self.assertEquals(d1, d2)
def testUnknownDispatching(self): observable = Observable() class Listener(object): def method(inner, one): return one + " another" observable.addObserver(Listener()) retval = observable.call.unknown('method', 'one') self.assertEquals('one another', retval)
def testUnknownDispatchingBackToUnknown(self): observable = Observable() class A(object): def call_unknown(self, message, one): return "via unknown " + one observable.addObserver(A()) retval = observable.call.unknown('non_existing_method', 'one') self.assertEquals("via unknown one", retval)
def testNoLeakingGeneratorsInCycle(self): class Responder(Observable): def message(self): yield 'response' obs = Observable() obs.addObserver(Responder()) result = compose(obs.all.message()).next() self.assertEquals('response',result) del obs
def testDeferredObjectsAreCached(self): class A(object): def a(self): pass observable = Observable() observable.addObserver(A()) f1 = observable.all.f f2 = observable.all.f self.assertEquals(f1, f2)
def testProperErrorMessageWhenArgsDoNotMatch(self): observable = Observable() class YesObserver: def yes(self, oneArg): pass observable.addObserver(YesObserver()) try: answer = observable.call.yes() self.fail('should raise TypeError') except TypeError, e: self.assertEquals('yes() takes exactly 2 arguments (1 given)', str(e))
def testNoLeakingGeneratorsInCycle(self): class Responder(Observable): def message(self): yield 'response' obs = Observable() obs.addObserver(Responder()) result = compose(obs.all.message()).next() self.assertEquals('response', result) del obs
def testFixUpExceptionTraceBack(self): class A: def a(self): raise Exception('A.a') def any_unknown(self, msg, *args, **kwargs): yield self.a() observable = Observable() observable.addObserver(A()) try: list(compose(observable.any.a())) except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "a") else: self.fail('Should not happen.') try: list(compose(observable.all.a())) except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "a") else: self.fail('Should not happen.') try: observable.do.a() except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "a") else: self.fail('Should not happen.') try: observable.call.a() except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "a") else: self.fail('Should not happen.') try: list(compose(observable.any.unknown('a'))) except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "a") else: self.fail('Should not happen.') try: list( compose( observable.any.somethingNotThereButHandledByUnknown('a'))) except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "any_unknown", "a") else: self.fail('Should not happen.')
def testUnknownIsEquivalentToNormalCall(self): observable = Observable() class A(object): def normal(self): return 'normal' def call_unknown(self, message, *args, **kwargs): return 'normal' observable.addObserver(A()) result1 = observable.call.unknown('normal') result2 = observable.call.unknown('other') self.assertEquals(result1, result2)
def __init__(self, reactor, port): Observable.__init__(self) ear = socket() err = ear.getsockopt(SOL_SOCKET, SO_ERROR) if err != 0: # connection created succesfully? raise IOError(err) ear.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) ear.setsockopt(SOL_SOCKET, SO_LINGER, pack("ii", 0, 0)) ear.bind(("0.0.0.0", port)) ear.listen(127) reactor.addReader(ear, self.connect) self._ear = ear self._reactor = reactor
def __init__(self, reactor, port): Observable.__init__(self) ear = socket() err = ear.getsockopt(SOL_SOCKET, SO_ERROR) if err != 0: # connection created succesfully? raise IOError(err) ear.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) ear.setsockopt(SOL_SOCKET, SO_LINGER, pack('ii', 0, 0)) ear.bind(('0.0.0.0', port)) ear.listen(127) reactor.addReader(ear, self.connect) self._ear = ear self._reactor = reactor
def testNoLeakingGeneratorsInMultiTransparents(self): class Responder(Observable): def message(self): return 'response' obs = Observable() t1 = Transparent() t2 = Transparent() obs.addObserver(t1) t1.addObserver(t2) t2.addObserver(Responder()) result = obs.call.message() self.assertEquals('response', result) del obs, t1, t2, result
def testDirectedObserverMessagingDoesNotBreakUndirectedCall(self): observable = Observable() called = [] class A(Observable): def method(this): called.append("A") return yield observable.addObserver(A("name")) list(compose(observable.all["name"].method())) list(compose(observable.all["name"].method())) self.assertEquals(["A", "A"], called)
def __init__(self, reactor, unusedTimeout=None, limits=None, **kwargs): Observable.__init__(self, **kwargs) self._reactor = reactor self._unusedTimeout = unusedTimeout self._limitTotalSize = limits.get(_TOTAL_SIZE) if limits else None self._limitDestinationSize = limits.get(_DESTINATION_SIZE) if limits else None self._pool = {} self._poolSize = 0 if limits and not set(limits.keys()).issubset(_LIMITS): raise TypeError('limits argument options must be one of: ' + ', '.join(_LIMITS)) if unusedTimeout is not None: self._initUnusedTimeout()
def testFixUpExceptionTraceBack(self): class A: def a(self): raise Exception('A.a') def any_unknown(self, msg, *args, **kwargs): yield self.a() observable = Observable() observable.addObserver(A()) try: list(compose(observable.any.a())) except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "a") else: self.fail('Should not happen.') try: list(compose(observable.all.a())) except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "a") else: self.fail('Should not happen.') try: observable.do.a() except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "a") else: self.fail('Should not happen.') try: observable.call.a() except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "a") else: self.fail('Should not happen.') try: list(compose(observable.any.unknown('a'))) except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "a") else: self.fail('Should not happen.') try: list(compose(observable.any.somethingNotThereButHandledByUnknown('a'))) except Exception: self.assertFunctionsOnTraceback("testFixUpExceptionTraceBack", "any_unknown", "a") else: self.fail('Should not happen.')
def testAnyOrCallCallsFirstImplementer(self): class A(object): def f(self): raise StopIteration(A.f) yield def f_sync(self): return A.f class B(object): def f(self): raise StopIteration(B.f) yield def f_sync(self): return B.f def g(self): raise StopIteration(B.g) yield def g_sync(self): return B.g root = be((Observable(), (A(), ), (B(), ))) try: compose(root.any.f()).next() self.fail('Should not happen') except StopIteration, e: self.assertEquals((A.f, ), e.args)
def __init__(self, reactor, unusedTimeout=None, limits=None, **kwargs): Observable.__init__(self, **kwargs) self._reactor = reactor self._unusedTimeout = unusedTimeout self._limitTotalSize = limits.get(_TOTAL_SIZE) if limits else None self._limitDestinationSize = limits.get( _DESTINATION_SIZE) if limits else None self._pool = {} self._poolSize = 0 if limits and not set(limits.keys()).issubset(_LIMITS): raise TypeError('limits argument options must be one of: ' + ', '.join(_LIMITS)) if unusedTimeout is not None: self._initUnusedTimeout()
def testAnalyseLog(self): observer = CallTrace() def handleRequest(**kwargs): yield "We did it!" handleRequestMock = CallTrace(methods={'handleRequest': handleRequest}) dna = be( (Observable(), (LogCollector(), (GustosLogWriter(), (AgentCountReport(gustosGroup="Gustos Group", scopeNames=('mock', )), ), (observer, ) ), (LogCollectorScope("mock"), (HandleRequestLog(), (handleRequestMock, ) ) ) ) ) ) result = list(compose(dna.all.handleRequest(Headers={'User-Agent': GOOGLE_BOT}))) self.assertEqual(b"We did it!", result[0]) valuesKwarg = observer.calledMethods[-1].kwargs['values'] self.assertEqual({'Gustos Group': {'User agents': {'Googlebot/2.1': {'count': 1}}}}, valuesKwarg)
def testOnceAssertsNoneReturnValues(self): # OnceMessage assertion on None: #1a "normal object" class AnObject(object): def f(self): raise StopIteration(1) yield # OnceMessage assertion on None: #1b "Observable" class AnObservable(Observable): def g(self): raise StopIteration(1) yield root = be(( Observable(), (AnObject(), ), (AnObservable(), ), )) composed = compose(root.once.f()) try: composed.next() self.fail("Should not happen") except AssertionError, e: self.assertTrue( "<bound method AnObject.f of <core.observabletest.AnObject object at 0x" in str(e), str(e)) self.assertTrue(">> returned '1'" in str(e), str(e))
def testTransparentUnknownImplementationIsVisibleOnTraceback(self): class Leaf(Observable): def aCall(self): raise RuntimeError('trace') def aAny(self): def lookBusy(): raise RuntimeError('trace') return yield ignored = yield lookBusy() def aAll(self): raise RuntimeError('trace') yield 'ignored' def aDo(self): raise RuntimeError('trace') root = be(( Observable(), ( Transparent(), (Leaf(), ), ), )) try: root.call.aCall() self.fail('Should not happen') except RuntimeError: self.assertFunctionsOnTraceback( 'testTransparentUnknownImplementationIsVisibleOnTraceback', 'call_unknown', 'aCall') try: compose(root.any.aAny()).next() self.fail('Should not happen') except RuntimeError: self.assertFunctionsOnTraceback( 'testTransparentUnknownImplementationIsVisibleOnTraceback', 'any_unknown', 'aAny', 'lookBusy') try: compose(root.all.aAll()).next() self.fail('Should not happen') except RuntimeError: self.assertFunctionsOnTraceback( 'testTransparentUnknownImplementationIsVisibleOnTraceback', 'all_unknown', 'aAll') try: root.do.aDo() self.fail('Should not happen') except RuntimeError: self.assertFunctionsOnTraceback( 'testTransparentUnknownImplementationIsVisibleOnTraceback', 'do_unknown', 'aDo')
def testDirectedObserverMessagingIgnoresNonObservableObservers(self): observable = Observable() called = [] class Z(object): def method(this): called.append("Z") return yield observable.addObserver(Z()) list(compose(observable.all["name"].method())) self.assertEquals([], called) list(compose(observable.all.method())) self.assertEquals(["Z"], called)
def testAllUnknown(self): class A(object): def all_unknown(self, *args, **kwargs): yield args, kwargs root = be((Observable(), (A(), ))) r = compose(root.all.unknownmessage(1, two=2)).next() self.assertEquals((('unknownmessage', 1), {'two': 2}), r)
def testCallViaUnknown(self): class A(object): def call_unknown(self, message, *args, **kwargs): return message, args, kwargs root = be((Observable(), (A(), ))) r = root.call.f(1, a=2) self.assertEquals(('f', (1, ), {'a': 2}), r)
def testProperErrorMessage(self): observable = Observable() try: answer = list(compose(observable.any.gimmeAnswer('please'))) self.fail('should raise NoneOfTheObserversRespond') except NoneOfTheObserversRespond, e: self.assertFunctionsOnTraceback("testProperErrorMessage", "any") self.assertEquals( 'None of the 0 observers respond to gimmeAnswer(...)', str(e))
def testThrow(self): class A(Observable): def f1(self): yield "A:f1-1" yield "A:f1-2" yield "A:f1-3" class B(Observable): def f1(self): yield "B:f1-1" yield "B:f1-2" yield "B:f1-3" root = Observable() root.addObserver(A()) root.addObserver(B()) g = compose(root.all.f1()) g.next() r = g.throw(DeclineMessage) self.assertEquals("B:f1-1", r)
def testAllWithOneImplementer(self): class A(object): def f(self): yield A.f root = be(( Observable(), (A(), ), )) self.assertEquals([A.f], list(compose(root.all.f())))
def testDoViaUnknown(self): called = [] class A(object): def do_unknown(self, message, *args, **kwargs): called.append((message, args, kwargs)) root = be((Observable(), (A(), ))) root.do.f() self.assertEquals([('f', (), {})], called)
def testAllWithOneImplementerButMoreListening(self): class A(object): pass class B(object): def f(self): yield B.f root = be((Observable(), (A(), ), (B(), ))) self.assertEquals([B.f], list(compose(root.all.f())))
def testRebuildDefersAfterAddObserver(self): observable = Observable() called = [] class A(Observable): def method(this): called.append("A") return yield class B(Observable): def method(this): called.append("B") return yield observable.addObserver(A()) list(compose(observable.all.method())) self.assertEquals(['A'], called) del called[:] observable.addObserver(B()) list(compose(observable.all.method())) self.assertEquals(['A', 'B'], called)
def testAnyViaUnknown(self): class A(object): def any_unknown(self, message, *args, **kwargs): raise StopIteration((message, args, kwargs), ) yield root = be((Observable(), (A(), ))) try: compose(root.any.f(1, a=2)).next() except StopIteration, e: r = e.args[0]
def testOnceAndOnlyOnceForMutuallyObservingObservables(self): class MyObserver(Observable): def methodOnlyCalledOnce(self, aList): aList.append(self) return yield ownobserverobserver = MyObserver() dna = \ (Observable(), (ownobserverobserver, (Observable("observer"), (ownobserverobserver,), ) ) ) root = be(dna) collector = [] list(compose(root.once.methodOnlyCalledOnce(collector))) self.assertEquals([ownobserverobserver], collector)
def __init__(self, unqualifiedTermFields, luceneSettings, ignoreStemmingForWords=None): Observable.__init__(self) self._unqualifiedTermFields = unqualifiedTermFields self._analyzer = luceneSettings.createAnalyzer() self._fieldRegistry = luceneSettings.fieldRegistry self._ignoreStemmingForWords = set(ignoreStemmingForWords or [])
def testSetName(self): observable = Observable().observable_setName('name') self.assertEquals('name', observable.observable_name())
def testAddStrandEmptyList(self): observable = Observable() observable.addStrand((), []) self.assertEquals([], observable._observers)
def __init__(self): Observable.__init__(self) self.generatorReturningCallable = partial(lambda arg: (x for x in 'a'), arg='partialed')
def __init__(self, name=None): Observable_orig.__init__(self, name=name) self.ctx = Context()