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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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()
