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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 testObserverInit(self):
initcalled = [0]
class MyObserver(object):
def observer_init(self):
yield # once is async
initcalled[0] += 1
root = be((Observable(), (MyObserver(), )))
self.assertEquals([0], initcalled)
list(compose(root.once.observer_init()))
self.assertEquals([1], initcalled)
def testSetNameEscaped(self):
repository = CallTrace(returnValues=dict(
requestUrl='http://example.org'))
observer = CallTrace(returnValues=dict(getAllSets=[('123&abc',
'123 & abc')]),
emptyGeneratorMethods=['oaiWatermark'])
top = be((Observable(), (OaiListSets(repository), (observer, ))))
response = asString(
top.all.listSets(arguments=dict(verb=['ListSets'])))
self.assertTrue(
'<ListSets><set><setSpec>123&abc</setSpec><setName>123 & abc</setName></set></ListSets>'
in response, response)
def testRaisingDeclineMessageFromAllMakesNoDifference(self):
class SemiTransparent(Observable):
def all_unknown(self, message, *args, **kwargs):
if message == 'theMessage':
yield self.all.unknown(message, *args, **kwargs)
raise DeclineMessage
root = be((Observable(), (SemiTransparent(), (Responder(41), )),
(Responder(42), )))
self.assertEquals([41, 42], list(compose(root.all.theMessage())))
self.assertEquals([42], list(compose(root.all.message())))
def testNonObservableInTreeWithOnce(self):
class MyObserver(object):
def methodOnNonObservableSubclass(self, aList):
aList.append('once')
return
yield
once = MyObserver()
dna = (Observable(), (once, ))
root = be(dna)
collector = []
list(compose(root.once.methodOnNonObservableSubclass(collector)))
self.assertEquals(['once'], collector)
def testPropagateThroughAllObservablesInDiamondWithNONTransparentObservablesWithoutUnknownMethodDelegatingUnknownCalls(
self):
class MyObserver(Observable):
def methodOnlyCalledOnce(self, aList):
aList.append('once')
return
yield
once = MyObserver()
diamond = \
(Observable(),
(Observable(),
(once,)
),
(Observable(),
(once,)
)
)
root = be(diamond)
collector = []
list(compose(root.once.methodOnlyCalledOnce(collector)))
self.assertEquals(['once'], collector)
def XXXXXXXXXXXXXXXXXXXtestOpenHttpWithTransactionOnConnectionScopeExample(
self):
class Transaction(Observable):
def __init__(self, txmanagers):
super(Transaction, self).__init__()
self._txmanagers = txmanagers
def unknown(self, message, *args, **kwargs):
txs = []
for txmanager in sefl._txmanagers:
tx = txmanager.begin()
txs.append(tx)
try:
for response in self.all.unknown(message, *args, **kwargs):
yield response
except:
for tx in txs:
tx.abort()
else:
for tx in txs:
tx.commit()
class MyDB(object):
def begin(self):
self._preparedData = []
return self
def store(self, data):
self._preparedData.append(data)
def commit(self):
self.commitedData = ''.join(self._preparedData)
self._preparedData = []
class MyHandler(Observable):
def upload(self, ContentLength, *args, **kwargs):
body = yield readBytes(ContentLength)
self.any.store(body)
mydb = MyDB()
reactor = Reactor()
server = Server(reactor, 8080)
pipe = be((
Observable(),
(
server,
(
Transaction(
[mydb]), # Transaction commits when connection closes
(HttpProtocol(), (MyHandler(), (mydb, )))))))
self.fail('continue here')
def testOnceInternalsNotOnTracebackUnlessAssertsAndThenOnlyOnce(self):
class OnceRaiser(object):
def raisesOnCall(self):
raise BaseException('Boom')
def raisesOnCallGenerator(self):
raise BaseException('Ka-Boom')
yield
dna = (
Observable(), # called-from
(
Observable(), # 1
(
Observable(), # 2
(
Observable(), # 3
(OnceRaiser(), ), # target
))))
root = be(dna)
try:
list(compose(root.once.raisesOnCallGenerator()))
except BaseException:
self.assertFunctionsOnTraceback(
'testOnceInternalsNotOnTracebackUnlessAssertsAndThenOnlyOnce',
'raisesOnCallGenerator')
else:
self.fail('Should not happen')
try:
list(compose(root.once.raisesOnCall()))
except BaseException:
self.assertFunctionsOnTraceback(
'testOnceInternalsNotOnTracebackUnlessAssertsAndThenOnlyOnce',
'raisesOnCall')
else:
self.fail('Should not happen')
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))
