def testOaiListRequestOnCallstack(self):
listRequests = []
def addMethod(**kwargs):
listRequests.append(local('__callstack_var_oaiListRequest__'))
return
yield
observer = CallTrace(methods={'add': addMethod})
top = be((Observable(),
(OaiDownloadProcessor(path="/oai", metadataPrefix="oai_dc", workingDirectory=self.tempdir, xWait=False),
(observer,)
)
))
consume(top.all.handle(parse(StringIO(LISTRECORDS_RESPONSE % ''))))
self.assertEquals(['startOaiBatch', 'add', 'stopOaiBatch', 'signalHarvestingDone'], [m.name for m in observer.calledMethods])
self.assertEquals([{'set': None, 'metadataPrefix': 'oai_dc'}], listRequests)
listRequests = []
observer.calledMethods.reset()
top = be((Observable(),
(OaiDownloadProcessor(path="/oai", metadataPrefix="other", set='aSet', workingDirectory=self.tempdir, xWait=True),
(observer,)
)
))
consume(top.all.handle(parse(StringIO(LISTRECORDS_RESPONSE % RESUMPTION_TOKEN))))
self.assertEquals(['startOaiBatch', 'add', 'stopOaiBatch'], [m.name for m in observer.calledMethods])
self.assertEquals([{'set': 'aSet', 'metadataPrefix': 'other'}], listRequests)
def testTcpPacketListener(self):
reactor = CallTrace('reactor')
observer = CallTrace('observer', emptyGeneratorMethods=['handlePacket'])
tcpPacketListener = TcpPacketListener(reactor, port=1234)
server = be((Observable(),
(tcpPacketListener,
(observer,)
)
))
list(compose(server.once.observer_init()))
self.assertEquals('addReader', reactor.calledMethods[0].name)
acceptCallback = reactor.calledMethods[0].args[1]
data = "TEST" * 1024
sok = socket()
sok.connect(('localhost', 1234))
bytesSent = sok.send(data)
self.assertEquals(len(data), bytesSent)
sok.close()
acceptCallback()
self.assertEquals('addReader', reactor.calledMethods[1].name)
handleCallback = reactor.calledMethods[1].args[1]
handleCallback()
self.assertEquals('addProcess', reactor.calledMethods[-2].name)
reactor.calledMethods[-2].args[0]()
self.assertEquals(['observer_init', 'handlePacket'], observer.calledMethodNames())
self.assertEquals(data, observer.calledMethods[1].kwargs['data'])
self.assertEquals('removeReader', reactor.calledMethods[-2].name)
self.assertEquals('removeProcess', reactor.calledMethods[-1].name)
def testRewrite(self):
rewrite = MessageRewrite(fromMessage='this_message', toMessage='to_message')
observer = CallTrace(emptyGeneratorMethods=['to_message'])
tree = be((Observable(),
(rewrite,
(observer,),
)
))
consume(tree.all.this_message(aap='noot'))
self.assertEqual(['to_message'], observer.calledMethodNames())
self.assertEqual(dict(aap='noot'), observer.calledMethods[0].kwargs)
observer.calledMethods.reset()
consume(tree.any.this_message(aap='noot'))
self.assertEqual(['to_message'], observer.calledMethodNames())
self.assertEqual(dict(aap='noot'), observer.calledMethods[0].kwargs)
del observer.emptyGeneratorMethods[:]
observer.calledMethods.reset()
tree.call.this_message(aap='noot')
self.assertEqual(['to_message'], observer.calledMethodNames())
self.assertEqual(dict(aap='noot'), observer.calledMethods[0].kwargs)
observer.calledMethods.reset()
tree.do.this_message(aap='noot')
self.assertEqual(['to_message'], observer.calledMethodNames())
self.assertEqual(dict(aap='noot'), observer.calledMethods[0].kwargs)
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 testApacheLog(self):
requestHandler = CallTrace("handler", ignoredAttributes=["writeLog", "do_unknown"])
requestHandler.returnValues["handleRequest"] = (f for f in [Yield, okPlainText, "te", callable, "xt"])
stream = StringIO()
handleRequestLog = HandleRequestLog()
handleRequestLog._time = lambda: 1395409143.0
observable = be(
(Observable(), (LogCollector(), (handleRequestLog, (requestHandler,)), (ApacheLogWriter(stream),)))
)
result = asList(
observable.all.handleRequest(
Method="GET",
Client=("127.0.0.1", 1234),
RequestURI="http://example.org/path?key=value",
query="key=value",
path="/path",
Headers={"Referer": "http://meresco.org", "User-Agent": "Meresco-Components Test"},
otherKwarg="value",
)
)
self.assertEquals([Yield, okPlainText, "te", callable, "xt"], result)
self.assertEquals(["handleRequest"], requestHandler.calledMethodNames())
logline = stream.getvalue()
self.assertEquals(
'127.0.0.1 - - [21/Mar/2014:13:39:03 +0000] "GET /path?key=value HTTP/1.0" 200 64 "http://meresco.org" "Meresco-Components Test"\n',
logline,
)
def testRequestScopeIsPerRequest(self):
class MyObserver(Observable):
def handleRequest(self, key, value, *args, **kwargs):
self.do.setArg(key, value)
yield self.call.getArg()
class SetArgObserver(Observable):
def setArg(self, key, value):
self.ctx.requestScope[key] = value
class GetArgObserver(Observable):
def getArg(self):
return ';'.join('%s=%s' % (k,v) for k,v in self.ctx.requestScope.items())
dna = be((Observable(),
(RequestScope(),
(MyObserver(),
(SetArgObserver(),),
(GetArgObserver(),)
)
)
))
result0 = list(compose(dna.all.handleRequest("key0", "value0")))
result1 = list(compose(dna.all.handleRequest("key1", "value1")))
self.assertEquals(['key0=value0'], result0)
self.assertEquals(['key1=value1'], result1)
def testQuery(self):
def executeQuery(**kwargs):
raise StopIteration(Response(total=42))
yield
index = CallTrace('index',
emptyGeneratorMethods=['echoedExtraRequestData', 'extraResponseData'],
methods=dict(executeQuery=executeQuery))
observable = be((Observable(),
(LogCollector(),
(self.handleRequestLog,
(SruParser(),
(SruHandler(enableCollectLog=True),
(index,)
)
)
),
(self.queryLogWriter,),
)
))
result = asString(observable.all.handleRequest(
Method='GET',
Client=('127.0.0.1', 1234),
arguments={
'version': ['1.2'],
'operation': ['searchRetrieve'],
'query': ['query'],
'maximumRecords': ['0'],
},
path='/path/sru',
otherKwarg='value'))
self.assertTrue('<srw:numberOfRecords>42</srw:numberOfRecords>' in result, result)
self.assertTrue(isfile(join(self.tempdir, '2009-11-02-query.log')))
self.assertEquals('2009-11-02T11:25:37Z 127.0.0.1 0.7K 1.000s 42hits /path/sru maximumRecords=0&operation=searchRetrieve&query=query&recordPacking=xml&recordSchema=dc&startRecord=1&version=1.2\n', open(join(self.tempdir, '2009-11-02-query.log')).read())
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 testNonGeneratorMethodMayNeverRaiseGeneratorExceptionsOnMessages(self):
# any, all, do, call and once
class OddObject(object):
def stopIter(self):
raise StopIteration('Stop!')
def genExit(self):
raise GeneratorExit('Exit!')
dna = (Observable(),
(Transparent(),
(OddObject(),),
)
)
root = be(dna)
# Verify traceback's and wrapped-exception text is ok
try: root.call.stopIter()
except AssertionError, e:
self.assertTrue(str(e).startswith('Non-Generator <bound method OddObject.stopIter of <core.observabletest.OddObject object at 0x'), str(e))
expected = ignoreLineNumbers('''>> should not have raised Generator-Exception:
Traceback (most recent call last):
File "%(__file__)s", line [#], in stopIter
raise StopIteration('Stop!')
StopIteration: Stop!
''' % fileDict)
self.assertTrue(ignoreLineNumbers(str(e)).endswith(expected), str(e))
self.assertFunctionsOnTraceback(
'testNonGeneratorMethodMayNeverRaiseGeneratorExceptionsOnMessages',
'call_unknown', # From Transparent, is supposed to be on the stack to aid retracing the path taken for a messages.
'handleNonGeneratorGeneratorExceptions')
def testWorksWithRealTransactionScope(self):
intercept = CallTrace('Intercept', ignoredAttributes=['begin', 'commit', 'rollback'])
class MockVenturi(Observable):
def all_unknown(self, message, *args, **kwargs):
self.ctx.tx.locals['id'] = 'an:identifier'
yield self.all.unknown(message, *args, **kwargs)
class MockMultiFielder(Observable):
def add(self, *args, **kwargs):
self.do.addField('set', ('setSpec', 'setName'))
self.do.addField('metadataFormat', ('prefix', 'schema', 'namespace'))
yield 'ok'
root = be(
(Observable(),
(TransactionScope(transactionName="oaiRecord"),
(MockVenturi(),
(MockMultiFielder(),
(ResourceManager("oaiRecord"),
(Fields2OaiRecord(),
(intercept,),
)
)
)
)
)
)
)
list(compose(root.all.add('some', 'arguments')))
self.assertEquals(['addOaiRecord'], [m.name for m in intercept.calledMethods])
method = intercept.calledMethods[0]
self.assertEquals(((), {'identifier': 'an:identifier', 'metadataFormats': set([('prefix', 'schema', 'namespace')]), 'sets': set([('setSpec', 'setName')])}), (method.args, method.kwargs))
def testTailTakenCareOfWithoutAffectingOriginal(self):
observer = CallTrace('observer', methods={'test': lambda *args, **kwargs: (x for x in [])})
observable = be(
(Observable(),
(XmlXPath(
['/myns:root/myns:path'],
fromKwarg='lxmlNode',
namespaces={'myns': 'http://myns.org/'}
),
(observer, ),
)
)
)
XML = """\
<root xmlns:myns="http://myns.org/" xmlns="http://myns.org/">
<myns:path>
<to>me</to>
</myns:path>\n
</root>"""
lxmlNode = parse(StringIO(XML))
self.assertEquals(XML, lxmltostring(lxmlNode))
list(compose(observable.all.test('een tekst', lxmlNode=lxmlNode)))
self.assertEquals(1, len(observer.calledMethods))
method = observer.calledMethods[0]
self.assertEquals('test', method.name)
self.assertEqualsWS('<myns:path xmlns:myns="http://myns.org/" xmlns="http://myns.org/"><to>me</to></myns:path>', lxmltostring(method.kwargs['lxmlNode']))
self.assertEquals("""\
<myns:path xmlns:myns="http://myns.org/" xmlns="http://myns.org/">
<to>me</to>
</myns:path>""", lxmltostring(method.kwargs['lxmlNode']))
self.assertEquals(XML, lxmltostring(lxmlNode))
def testUpdateRecordWhileSendingData(self):
batchSize = 3
oaiJazz = OaiJazz(join(self.tempdir, 'oai'))
storageComponent = MultiSequentialStorage(join(self.tempdir, 'storage'))
self._addOaiRecords(storageComponent, oaiJazz, count=batchSize + 10)
dna = be((Observable(),
(OaiPmh(repositoryName='test', adminEmail='*****@*****.**', batchSize=batchSize),
(storageComponent,),
(oaiJazz,),
)
))
kwargs = dict(
Method='GET',
Headers={'Host': 'myserver'},
port=1234,
path='/oaipmh.pl',
arguments=dict(verb=['ListIdentifiers'], metadataPrefix=['prefix']),
)
stream = compose(dna.all.handleRequest(**kwargs))
buf = StringIO()
for stuff in stream:
buf.write(stuff)
if 'identifier>id0<' in stuff:
oaiJazz.addOaiRecord(identifier="id1", sets=[], metadataFormats=[("prefix", "", "")])
result = XML(buf.getvalue().split(CRLF*2)[-1])
resumptionToken = xpathFirst(result, '/oai:OAI-PMH/oai:ListIdentifiers/oai:resumptionToken/text()')
self.assertFalse(resumptionToken is None)
def testOpenSearchWithoutHtmlAndPort80(self):
queryTemplate = '/sru?version=1.1&operation=searchRetrieve&query={searchTerms}'
self.auto = be((Autocomplete(
host='localhost',
port=80,
path='/some/path',
templateQuery=queryTemplate,
shortname="Web Search",
description="Use this web search to search something",
defaultLimit=50,
defaultField='lom',
),
(self.observer,),
))
result = asString(self.auto.handleRequest(
path='/path/opensearchdescription.xml',
arguments={}))
header,body = result.split('\r\n'*2)
self.assertTrue("Content-Type: text/xml" in header, header)
self.assertEqualsWS("""<?xml version="1.0" encoding="UTF-8"?>
<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
<ShortName>Web Search</ShortName>
<Description>Use this web search to search something</Description>
<Url type="text/xml" method="get" template="http://localhost/sru?version=1.1&operation=searchRetrieve&query={searchTerms}"/>
<Url type="application/x-suggestions+json" template="http://localhost/some/path?prefix={searchTerms}"/>
</OpenSearchDescription>""", body)
def testLoggedPathsNewStyle(self):
log = CallTrace('log')
def handleRequest(**kwargs):
yield okPlainText
yield 'result'
index = CallTrace('index', methods={'handleRequest':handleRequest})
observable = be((Observable(),
(LogCollector(),
(QueryLogWriter(log=log, scopeNames=('global', 'yesPath')),),
(LogCollectorScope('global'),
(HandleRequestLog(),
(PathFilter('/yes'),
(LogCollectorScope('yesPath'),
(index,),
)
),
(PathFilter('/no'),
(index,),
)
)
)
)
))
result = asString(observable.all.handleRequest(Client=('11.22.33.44', 1234), path='/yes'))
self.assertEquals(okPlainText+'result', result)
result = asString(observable.all.handleRequest(Client=('22.33.44.55', 2345), path='/no'))
self.assertEquals(okPlainText+'result', result)
result = asString(observable.all.handleRequest(Client=('33.44.55.66', 3456), path='/yes'))
self.assertEquals(okPlainText+'result', result)
self.assertEquals(['log', 'log'], log.calledMethodNames())
self.assertEquals(['/yes', '/yes'], [m.kwargs['path'] for m in log.calledMethods])
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 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 testOnceCalledMethodsMustResultInAGeneratorOrComposeOrNone(self):
callLog = []
class MyObserver(Observable):
def __init__(self):
Observable.__init__(self)
self.generatorReturningCallable = partial(lambda arg: (x for x in 'a'), arg='partialed')
def noGeneratorFunction(self):
callLog.append('function called')
def valueReturningFunction(self):
return 42
def composedGenerator(self):
return compose(x for x in 'a')
once = MyObserver()
dna = \
(Observable(),
(once,),
)
root = be(dna)
list(compose(root.once.noGeneratorFunction()))
self.assertEquals(['function called'], callLog)
try:
list(compose(root.once.valueReturningFunction()))
self.fail("Should have gotten AssertionError because of unexpected return value")
except AssertionError, e:
self.assertEquals("<bound method MyObserver.valueReturningFunction of MyObserver(name=None)> returned '42'", str(e))
def testWorksWithRealTransactionScope(self):
intercept = CallTrace('Intercept', ignoredAttributes=['begin', 'commit', 'rollback'], methods={'add': add})
class MockVenturi(Observable):
def all_unknown(self, message, *args, **kwargs):
self.ctx.tx.locals['id'] = 'an:identifier'
yield self.all.unknown(message, *args, **kwargs)
class MockMultiFielder(Observable):
def add(self, *args, **kwargs):
self.do.addField('field.name', 'MyName')
self.do.addField('field.name', 'AnotherName')
self.do.addField('field.title', 'MyDocument')
yield 'ok'
root = be(
(Observable(),
(TransactionScope(transactionName="xmlDocument"),
(MockVenturi(),
(MockMultiFielder(),
(ResourceManager("xmlDocument"),
(Fields2Xml(partName="partname"),
(intercept,),
)
)
)
)
)
)
)
list(compose(root.all.add('some', 'arguments')))
self.assertEquals(['add'], [m.name for m in intercept.calledMethods])
method = intercept.calledMethods[0]
expectedXml = "<partname><field><name>MyName</name></field><field><name>AnotherName</name></field><field><title>MyDocument</title></field></partname>"
self.assertEquals(((), {'identifier': 'an:identifier', 'partname': 'partname', 'data': expectedXml}), (method.args, method.kwargs))
def testUpdateUser(self):
action = UserActions(dataDir=self.tempdir)
dna = be(
(Observable(),
(action, ),
))
users = action.listUsers()
users.append(User(username="******"))
action.saveUsers(users)
self.assertEqual(2, len(action.listUsers()))
self.assertEqual("", action.getUser("johan").organization)
response = asString(dna.call.handleRequest(
Method="POST",
path="/user.action/update",
Body=urlencode(dict(
redirectUri="/go_here_now",
username="******",
organization="Seecr"))))
self.assertEqual(2, len(action.listUsers()))
self.assertEqual("Seecr", action.getUser("johan").organization)
self.assertTrue("Location: /go_here_now?identifier=johan" in response, response)
response = asString(dna.call.handleRequest(
Method="POST",
path="/user.action/update",
Body=urlencode(dict(
redirectUri="/go_here_now",
username="******",
organization=""))))
self.assertEqual("", action.getUser("johan").organization)
def testCreateUser(self):
observer = CallTrace()
action = UserActions(dataDir=self.tempdir)
session = {}
dna = be(
(Observable(),
(action,
(observer, )
),
))
self.assertEqual(1, len(action.listUsers()))
response = asString(dna.call.handleRequest(
Method="POST",
path="/user.action/create",
session=session,
Body=urlencode(dict(
redirectUri="/go_here_now",
username="******",
domain="domein",
password1="password",
password2="password"))))
self.assertEqual(2, len(action.listUsers()))
self.assertTrue("Location: /go_here_now?identifier=johan" in response, response)
self.assertEqual(1, len(observer.calledMethods))
self.assertEqual({}, session)
def startServer(port, stateDir, luceneserverPort, gatewayPort, quickCommit=False, **ignored):
setSignalHandlers()
print 'Firing up Index Server.'
statePath = abspath(stateDir)
writerReactor = Reactor()
writer = writerMain(
writerReactor=writerReactor,
statePath=statePath,
luceneserverPort=luceneserverPort,
gatewayPort=gatewayPort,
quickCommit=quickCommit,
)
writerServer = be(writer)
# Start writer in main (this) thread:
consume(writerServer.once.observer_init())
registerShutdownHandler(statePath=statePath, server=writerServer, reactor=writerReactor, shutdownMustSucceed=False)
print "Ready to rumble at port %s" % port
stdout.flush()
writerReactor.loop()
def prepareOaiPmh(dataDirs, tempDir, storage, batchSize):
print 'DATADIRS', dataDirs
oaiSuspendRegister = SuspendRegister()
oaiJazz = OaiJazz(tempDir)
oaiJazz.addObserver(oaiSuspendRegister)
oaiJazzOperations = {
'ADD': oaiJazz.addOaiRecord,
'DEL': oaiJazz.deleteOaiRecord
}
for dataDir in dataDirs:
for action, filename, setSpecs in iterOaiData(dataDir):
identifier, metadataPrefix = filename.rsplit('.', 1)
oaiJazzOperations[action](
identifier=identifier,
setSpecs=setSpecs,
metadataPrefixes=[metadataPrefix],
)
storage.addFile(filename, join(dataDir, escapeFilename(filename)))
sleep(0.000001)
oaiJazz.commit()
oaiPmh = be(
(IllegalFromFix(),
(OaiPmh(repositoryName='Mock', adminEmail='*****@*****.**', supportXWait=True, batchSize=batchSize),
# (LogComponent('OaiPmh'),),
(oaiJazz,),
(oaiSuspendRegister,),
(storage,),
)
)
)
return oaiPmh
def testNoQueryInCaseOfGeoLatLong(self):
queries = []
def queryErfGeoApi(query, expectedType=None):
queries.append(dict(query=query, expectedType=expectedType))
raise StopIteration(QUERY_RESULTS)
yield
def toAnnotation(pit, targetUri, query, geoCoordinates=None):
return PitToAnnotation().toAnnotation(pit=pit, targetUri=targetUri, query=query, geoCoordinates=geoCoordinates)
observer = CallTrace('observer', methods={'queryErfGeoApi': queryErfGeoApi, 'toAnnotation': toAnnotation})
top = be(
(Observable(),
(ErfGeoEnrichmentFromSummary(),
(observer,)
)
)
)
summary = makeSummary([], geoLatLong=('51.8', '5.0'))
result = retval(top.any.annotationFromSummary(summary))
self.assertEquals([], queries)
annotationUri, annotation = result
self.assertEquals(ERFGEO_ENRICHMENT_PROFILE.uriFor('uri:target'), annotationUri)
self.assertEquals('51.8', xpathFirst(annotation, '/rdf:RDF/oa:Annotation/oa:hasBody/rdf:Description/geo:lat/text()'))
def testUpdateIpFilter(self):
observer = CallTrace(methods={'handleRequest': handleRequest})
ipf = IpFilter(allowedIps=['192.168.1.1'], allowedIpRanges=[('10.0.0.1', '10.0.0.2'), '2001:41c8:10:7b::/64'])
dna = be(
(Observable(),
(ipf,
(observer,)
)
)
)
list(compose(dna.all.handleRequest(Client=('127.0.0.1',), Headers={})))
list(compose(dna.all.handleRequest(Client=('10.0.0.10',), Headers={})))
self.assertEquals(0, len(observer.calledMethods))
list(compose(dna.all.handleRequest(Client=('192.168.1.1',), Headers={})))
self.assertEquals(1, len(observer.calledMethods))
del observer.calledMethods[:]
list(compose(dna.all.handleRequest(Client=('2001:41c8:10:7b:aa:6:0:2', ), Headers={})))
self.assertEquals(1, len(observer.calledMethods))
del observer.calledMethods[:]
ipf.updateIps(ipAddresses=['127.0.0.1'], ipRanges=[('10.0.0.1', '10.0.0.255'), '2001:41c8:10:7c::/64'])
list(compose(dna.all.handleRequest(Client=('192.168.1.1',), Headers={})))
self.assertEquals(0, len(observer.calledMethods))
list(compose(dna.all.handleRequest(Client=('127.0.0.1',), Headers={})))
list(compose(dna.all.handleRequest(Client=('10.0.0.10',), Headers={})))
self.assertEquals(2, len(observer.calledMethods))
list(compose(dna.all.handleRequest(Client=('2001:41c8:10:7b:aa:6:0:2', ), Headers={})))
self.assertEquals(2, len(observer.calledMethods))
list(compose(dna.all.handleRequest(Client=('2001:41c8:10:7c:aa:6:0:2', ), Headers={})))
self.assertEquals(3, len(observer.calledMethods))
def setUp(self):
SeecrTestCase.setUp(self)
self.jazz = jazz = OaiJazz(join(self.tempdir, 'jazz'))
self.storage = MultiSequentialStorage(join(self.tempdir, 'sequential-store'))
self.oaipmh = self.getOaiPmh()
self.root = be((Observable(),
(self.oaipmh,
(jazz, ),
(RetrieveToGetDataAdapter(),
(self.storage,)
)
)
))
for i in xrange(20):
identifier = recordId = 'record:id:%02d' % i
metadataFormats = [('oai_dc', 'http://www.openarchives.org/OAI/2.0/oai_dc.xsd', 'http://www.openarchives.org/OAI/2.0/oai_dc/')]
if i >= 10:
metadataFormats.append(('prefix2', 'http://example.org/prefix2/?format=xsd&prefix=2','http://example.org/prefix2/'))
sets = []
if i >= 5:
sets.append(('setSpec%s' % ((i//5)*5), ('' if ((i//5)*5) == 10 else 'setName'))) # empty string becomes 'set <setSpec>'.
if 5 <= i < 10:
sets.append(('hierarchical:set', 'hierarchical set'))
if 10 <= i < 15:
sets.append(('hierarchical', 'hierarchical toplevel only'))
sleep(0.001) # avoid timestamps being equals on VMs
jazz.addOaiRecord(recordId, sets=sets, metadataFormats=metadataFormats)
if i % 5 == 0:
list(compose(jazz.delete(recordId)))
self.storage.addData(identifier=identifier, name='oai_dc', data='<oai_dc:dc xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/" xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:identifier>%s</dc:identifier></oai_dc:dc>' % recordId)
if i >= 10:
self.storage.addData(identifier=identifier, name='prefix2', data='<oai_dc:dc xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/" xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:subject>%s</dc:subject></oai_dc:dc>' % recordId)
def __init__(self, reactor, conversion=None, **kwargs):
Observable.__init__(self, **kwargs)
self._conversion = Conversion() if conversion is None else conversion
self._dynamicHtml = DynamicHtml([dynamicPath],
reactor=reactor,
notFoundPage='notFound',
additionalGlobals={
'VERSION': version,
'allCoreInfo': self._allCoreInfo,
'parseCql': parseString,
'cqlToExpression': cqlToExpression,
'cql2string': cql2string,
'dumps': dumps,
}
)
self._internalTree = be((Observable(),
(PathFilter('/', excluding=['/static', '/version']),
(self._dynamicHtml,)
),
(PathFilter('/static'),
(PathRename(lambda path: path[len('/static'):]),
(FileServer(staticPath),)
)
),
(PathFilter('/version'),
(StringServer("Meresco Lucene version %s" % version, ContentTypePlainText),)
),
))
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 testRaisingDeclineMessageFromDoMakesNoDifference(self):
class SemiTransparent(Observable):
def do_unknown(self, message, *args, **kwargs):
if message == 'theMessage':
self.do.unknown(message, *args, **kwargs)
raise DeclineMessage
observer1 = CallTrace('observer1')
observer2 = CallTrace('observer2')
root = be((Observable(),
(SemiTransparent(),
(observer1,)
),
(observer2,)
))
root.do.theMessage()
self.assertEquals(['theMessage'], [m.name for m in observer1.calledMethods])
self.assertEquals(['theMessage'], [m.name for m in observer2.calledMethods])
observer1.calledMethods.reset()
observer2.calledMethods.reset()
root.do.message()
self.assertEquals([], [m.name for m in observer1.calledMethods])
self.assertEquals(['message'], [m.name for m in observer2.calledMethods])
def __init__(self, repositoryName, adminEmail, repositoryIdentifier=None, batchSize=DEFAULT_BATCH_SIZE, supportXWait=False, externalUrl=None, preciseDatestamp=False):
self._repository = OaiRepository(
identifier=repositoryIdentifier,
name=repositoryName,
adminEmail=adminEmail,
externalUrl=externalUrl,
)
outside = Transparent()
self.addObserver = outside.addObserver
self.addStrand = outside.addStrand
self._internalObserverTree = be(
(Observable(),
(OaiError(self._repository),
(OaiIdentify(self._repository),
(outside,)
),
(OaiList(repository=self._repository, batchSize=batchSize, supportXWait=supportXWait),
(OaiRecord(self._repository, preciseDatestamp=preciseDatestamp),
(outside,)
)
),
(OaiGetRecord(self._repository),
(OaiRecord(self._repository, preciseDatestamp=preciseDatestamp),
(outside,)
)
),
(OaiListMetadataFormats(self._repository),
(outside,)
),
(OaiListSets(self._repository),
(outside,)
),
)
)
)
def testOne(self):
def fillReport(groups, collectedLog):
if not 'count' in groups:
groups['count'] = 0
groups['count'] += collectedLog['count'][0]
reports = []
def report(values):
reports.append(values.copy())
observer = CallTrace(methods={
'fillReport': fillReport,
'report': report
})
reactor = StoppableReactor()
class SomethingCounter(object):
def something(this):
collectLog(dict(count=1))
def reactorShutdown():
reactor.stop()
reactor.addTimer(2.5, reactorShutdown)
dna = be((Observable(), (LogCollector(),
(GustosContinuousLogWriter(reactor=reactor,
interval=1.0),
(observer, )), (SomethingCounter(), ))))
def job():
dna.do.something()
reactor.addTimer(0.5, job)
job()
reactor.loop()
self.assertEqual([
'analyseLog', 'fillReport', 'analyseLog', 'fillReport', 'report',
'analyseLog', 'fillReport', 'analyseLog', 'fillReport', 'report',
'analyseLog', 'fillReport'
], [m.name for m in observer.calledMethods])
self.assertEqual([{'count': 2}, {'count': 4}], reports)
def startServer(port, stateDir, **kwargs):
setSignalHandlers()
print 'Firing up Gateway Server.'
statePath = abspath(stateDir)
isdir(statePath) or makedirs(statePath)
reactor = Reactor()
dna = main(reactor=reactor, port=port, statePath=statePath, **kwargs)
server = be(dna)
consume(server.once.observer_init())
registerShutdownHandler(statePath=statePath,
server=server,
reactor=reactor,
shutdownMustSucceed=False)
print 'Ready to rumble at %s' % port
stdout.flush()
reactor.loop()
def testIgnoreOtherMethodsWithQueryArgument(self):
def canModify(expression):
return expression.term == 'term'
def modify(expression):
expression.term = 'changed'
observer = CallTrace(emptyGeneratorMethods=['method'])
top = be((Observable(),
(CqlMultiSearchClauseConversion([(canModify, modify)],
fromKwarg='query'),
(observer, ))))
consume(top.any.method(query='index = term'))
self.assertEqual({'query': 'index = term'},
observer.calledMethods[0].kwargs)
observer.calledMethods.reset()
consume(top.any.method(query=cqlToExpression('index = term')))
self.assertEqual({'query': cqlToExpression('index = changed')},
observer.calledMethods[0].kwargs)
def _assertValidIp(self, address, ipranges, ips, headers, passed):
self.observer = CallTrace('Observer',
methods={'handleRequest': handleRequest})
dna = be((Observable(), (IpFilter(allowedIps=ips,
allowedIpRanges=ipranges),
(self.observer, ))))
list(
compose(dna.all.handleRequest(Client=(address, ),
Headers=headers)))
if passed:
self.assertEqual(1, len(self.observer.calledMethods))
self.assertEqual('handleRequest',
self.observer.calledMethods[0].name)
self.assertEqual((address, ),
self.observer.calledMethods[0].kwargs['Client'])
else:
self.assertEqual(0, len(self.observer.calledMethods))
def testAlmostNoData(self):
# No data due to HandleRequestLog is not used.
requestHandler = CallTrace('handler', ignoredAttributes=['writeLog', 'do_unknown'])
def handleRequest(**kwarg):
collectLog(dict(key='value'))
yield okXml
yield '<sru></sru>'
requestHandler.methods['handleRequest'] = handleRequest
observable = be((Observable(),
(LogCollector(),
(requestHandler,),
(self.queryLogWriter,),
)
))
result = asString(observable.all.handleRequest(Method='GET', Client=('127.0.0.1', 1234), arguments={}, path='/path/sru', otherKwarg='value'))
self.assertEqual(okXml+'<sru></sru>', result)
self.assertEqual(0, len(listdir(self.tempdir)))
def _createHarvester(self):
harvesterLog = self._state.getHarvesterLog()
eventlogger = CompositeLogger([(['*'], harvesterLog.eventLogger()),
(['ERROR', 'INFO',
'WARN'], self._generalHarvestLog)])
uploader = self._repository.createUploader(eventlogger)
mapping = self._repository.mapping()
oairequest = self._repository.oairequest()
helix = \
(Harvester(self._repository),
(oairequest,),
(harvesterLog,),
(eventlogger,),
(uploader,),
(mapping,
(eventlogger,)
),
)
return [harvesterLog], be(helix)
def testOldStyleAutocomplete(self):
queryTemplate = '/sru?version=1.1&operation=searchRetrieve&query={searchTerms}'
self.auto = be((Autocomplete(
host='localhost',
port=8000,
path='/some/path',
templateQuery=queryTemplate,
shortname="Web Search",
description="Use this web search to search something",
defaultLimit=50,
defaultField='lom',
),
(self.observer,),
))
response = SolrResponse()
response.hits = ['term0', 'term&/"']
response.total = 2
response.qtime = 5
def prefixSearch(**kwargs):
return response
yield
self.observer.methods['prefixSearch'] = prefixSearch
header, body = generatorToString(self.auto.handleRequest(path='/path', arguments={'prefix':['te'], 'limit': ['5'], 'field': ['field.one']})).split('\r\n'*2)
self.assertTrue("Content-Type: application/x-suggestions+json" in header, header)
self.assertEqual("""["te", ["term0", "term&/\\""]]""", body)
self.assertEqual(['prefixSearch'], [m.name for m in self.observer.calledMethods])
self.assertEqual({'prefix':'te', 'fieldname':'field.one', 'limit':5}, self.observer.calledMethods[0].kwargs)
result = generatorToString(self.auto.handleRequest(
path='/path/opensearchdescription.xml',
arguments={}))
header,body = result.split('\r\n'*2)
self.assertTrue("Content-Type: text/xml" in header, header)
self.assertEqualsWS("""<?xml version="1.0" encoding="UTF-8"?>
<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
<ShortName>Web Search</ShortName>
<Description>Use this web search to search something</Description>
<Url type="text/xml" method="get" template="http://localhost:8000/sru?version=1.1&operation=searchRetrieve&query={searchTerms}"/>
<Url type="application/x-suggestions+json" template="http://localhost:8000/some/path?prefix={searchTerms}"/>
</OpenSearchDescription>""", body)
def testEverythingIsPassed(self):
usedArgsKwargs = []
class MyObserver(Observable):
def handleRequest(innerself, *args, **kwargs):
usedArgsKwargs.append((args, kwargs))
yield 'result'
dna = be((Observable(), (RequestScope(), (MyObserver(), ))))
result = list(
compose(
dna.all.handleRequest(
"an arg", RequestURI='http://www.example.org/path')))
self.assertEqual(['result'], result)
self.assertEqual(
[(("an arg", ), dict(RequestURI='http://www.example.org/path'))],
usedArgsKwargs)
def testTransparency(self):
lxml = CallTrace('lxml')
lxml2 = CallTrace('lxml2')
observable = be((Observable(), (
XmlParseLxml(fromKwarg='data', toKwarg='lxmlNode'),
(XmlPrintLxml(fromKwarg='lxmlNode', toKwarg='data'), (lxml, ),
(XmlParseLxml(fromKwarg='data', toKwarg='lxmlNode'), (
XmlPrintLxml(fromKwarg='lxmlNode', toKwarg='data'),
(lxml2, ),
))),
)))
observable.do.something(identifier='identifier',
partname='partName',
data='<?xml version="1.0"?><a><b>c</b></a>')
self.assertEqualsWS('<a><b>c</b></a>',
lxml.calledMethods[0].kwargs['data'].decode())
self.assertEqualsWS('<a><b>c</b></a>',
lxml2.calledMethods[0].kwargs['data'].decode())
def testDoAssertsIndividualCallsReturnNone(self):
class A(object):
def f(self):
return
yield
def do_unknown(self, message, *args, **kwargs):
return 42
root = be((Observable(), (A(), )))
try:
root.do.f()
self.fail('Should not happen')
except AssertionError, e:
self.assertTrue(
"<bound method A.f of <core.observabletest.A object at 0x"
in str(e), str(e))
self.assertTrue(">> returned '<generator object" in str(e), str(e))
def main(port):
reactor = Reactor()
dna = (Observable(), (ObservableHttpServer(reactor,
int(port)), (DynamicHtml(
[join(mydir, "dynamic")],
reactor=reactor,
indexPage="/index",
additionalGlobals={
'httpget': httpget,
'urlencode': urlencode,
'json_loads': loads,
'namespaces': namespaces
}), )))
server = be(dna)
list(compose(server.once.observer_init()))
reactor.loop()
def testShouldNotRegisteredTwice(self):
reactor = Reactor()
trace = CallTrace('Observer')
top = be((
Observable(),
(
Observable(), # Only once calls walk the observer tree.
(trace, ),
),
))
self._createShutdownHandler(statePath=self.tempdir,
server=top,
reactor=reactor)
try:
registerShutdownHandler(statePath=self.tempdir,
server='ignored',
reactor='ignored')
except AssertionError as e:
self.assertEqual('Handler already registered, aborting.', str(e))
else:
self.fail()
reactor.addTimer(0.01, lambda: None)
with stdout_replaced() as output:
try:
kill(getpid(), SIGTERM)
reactor.loop()
self.fail('should terminate')
except SystemExit as e:
self.assertEqual((0, ), e.args)
self.assertTrue(
'Scheduled for immediate shutdown.\n' in output.getvalue(),
output.getvalue())
self.assertTrue('Shutdown completed.\n' in output.getvalue(),
output.getvalue())
# Only once!
self.assertEqual(['handleShutdown'], trace.calledMethodNames())
self.assertEqual(
((), {}),
(trace.calledMethods[0].args, trace.calledMethods[0].kwargs))
def testOnceAndOnlyOnce(self):
class MyObserver(Observable):
def methodOnlyCalledOnce(self, aList):
aList.append('once')
return
yield
once = MyObserver()
dna = \
(Observable(),
(once,),
(once,)
)
root = be(dna)
collector = []
methodOnlyCalledOnce = root.once.methodOnlyCalledOnce
consume(methodOnlyCalledOnce(collector))
self.assertEquals(['once'], collector)
self.assertTrue(once in methodOnlyCalledOnce.seen)
self.assertTrue(once in methodOnlyCalledOnce.called)
def testUdpPacketListener(self):
reactor = CallTrace('reactor')
observer = CallTrace('observer',
emptyGeneratorMethods=['handlePacket'])
udpPacketListener = UdpPacketListener(reactor, port=1234)
try:
server = be((Observable(), (udpPacketListener, (observer, ))))
list(compose(server.once.observer_init()))
self.assertEqual('addReader', reactor.calledMethods[0].name)
handleCallback = reactor.calledMethods[0].args[1]
with socket(AF_INET, SOCK_DGRAM) as sok:
sok.sendto(b"TEST", ('localhost', 1234))
handleCallback()
reactor.calledMethods[-1].args[0]()
self.assertEqual(['observer_init', 'handlePacket'],
observer.calledMethodNames())
self.assertEqual("TEST", observer.calledMethods[1].kwargs['data'])
finally:
udpPacketListener.close()
def setUp(self):
SeecrTestCase.setUp(self)
self.paths = []
def handleRequest(path, *args, **kwargs):
self.paths.append(path)
yield "RESPONSE"
def validateMethod(cookie):
return dict(
value="USER", header="COOKIE HEADER"
) if cookie == "THIS IS THE REMEMBER ME COOKIE" else None
self.observer = CallTrace(
methods={
'handleRequest': handleRequest,
'validateCookie': validateMethod,
'cookieName': lambda: "CID"
})
self.dna = be((Observable(), (RememberMeCookie(), (self.observer, ))))
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 testAddObserversOnce(self):
class MyObservable(Observable):
pass
o1 = MyObservable(name='O1')
o2 = MyObservable(name='O2')
o3 = MyObservable(name='O3')
o4 = MyObservable(name='O4')
o5 = MyObservable(name='O5')
helix = \
(o1,
(o2, )
)
dna = (o3, helix, (o4, ), (o5, helix))
root = be(dna)
self.assertEquals([o2], o1._observers)
self.assertEquals([], o2._observers)
self.assertEquals([o1, o4, o5], o3._observers)
self.assertEquals([], o4._observers)
self.assertEquals([o1], o5._observers)
def testAllAssertsNoneReturnValues(self):
class A(object):
def f(self):
raise StopIteration(1)
yield
def all_unknown(self, message, *args, **kwargs):
raise StopIteration(2)
yield
root = be((Observable(), (A(), )))
g = compose(root.all.f())
try:
g.next()
self.fail("Should not happen")
except AssertionError, e:
self.assertTrue(
"<bound method A.f of <core.observabletest.A object at 0x"
in str(e), str(e))
self.assertTrue(">> returned '1'" in str(e), str(e))
def testTransparentInCaseNoneOfTheObserversRespond(self):
root = be((
Observable(),
(Transparent(), ),
(
Transparent(),
(Transparent(), (object(), )),
),
(Responder(42), ),
))
self.assertEquals(42, root.call.m())
try:
g = compose(root.any.m())
self.assertEquals(42, g.next())
g.next()
self.fail("Should have raised StopIteration")
except StopIteration, e:
self.assertEquals((42, ), e.args)
def _setUpAuto(self, prefixBasedSearchKwargs=None):
prefixBasedSearchKwargs = {} if prefixBasedSearchKwargs is None else prefixBasedSearchKwargs
queryTemplate = '/sru?version=1.1&operation=searchRetrieve&query={searchTerms}'
htmlQueryTemplate = '/demo?q={searchTerms}'
self.auto = be((
Autocomplete(
host='localhost',
port=8000,
path='/some/path',
templateQuery=queryTemplate,
htmlTemplateQuery=htmlQueryTemplate,
shortname="Web Search",
description="Use this web search to search something"),
(
PrefixBasedSuggest(defaultLimit=50,
defaultField='lom',
**prefixBasedSearchKwargs),
(self.observer, ),
),
))
def testScope(self):
logwriter = CallTrace('logwriter', emptyGeneratorMethods=['someMessage'])
top = be((Observable(),
(LogCollector('default'),
(logwriter,),
(FilterMessages(allowed=['someMessage']),
(LogKeyValue(dict(name='A')),
(LogKeyValue(dict(name='B')),),
(LogCollectorScope('scope_one'),
(LogKeyValue(dict(name='C')),),
),
(LogKeyValue(dict(name='D')),),
(LogCollectorScope('scope_two'),
(LogKeyValue(dict(name='E')),
(LogCollectorScope('scope_two_one'),
(LogKeyValue(dict(name='F')),),
),
),
(LogKeyValue(dict(name='G')),),
),
)
)
)
))
consume(top.all.someMessage())
self.assertEquals(['someMessage', 'writeLog'], logwriter.calledMethodNames())
self.assertEquals({
'name': ['A', 'B', 'D'],
'scope_one': {
'name': ['C'],
},
'scope_two': {
'name': ['E', 'G'],
'scope_two_one': {
'name': ['F']
}
}
}, logwriter.calledMethods[-1].kwargs['collectedLog'])
def testSetRememberMeCookie(self):
observer = CallTrace(
methods={
'validateUser': lambda username, password: True,
'createCookie': lambda user: dict(
cookie='THIS IS THE COOKIE VALUE',
header='Set-Cookie: somevalue',
)
},
onlySpecifiedMethods=True,
returnValues={'hasUser': True})
basicHtmlLoginForm = BasicHtmlLoginForm(
action="/action",
loginPath="/",
home="/index",
rememberMeCookie=True)
basicHtmlLoginForm._now = lambda: 3600
dna = be(
(Observable(),
(basicHtmlLoginForm,
(observer, )
)
)
)
session = {}
header, _ = asString(dna.all.handleRequest(
Method="POST",
path="/",
session=session,
Body=urlencode(dict(username="******", password="******", rememberMe="on"))
)).split('\r\n\r\n', 1)
self.assertTrue('user' in session, session)
headers = headerToDict(header)
self.assertEquals("/index", headers['Location'])
self.assertTrue('Set-Cookie' in headers, headers)
self.assertEquals("somevalue", headers['Set-Cookie'])
def testOnceInDiamondWithTransparent(self):
class MyObserver(Observable):
def methodOnlyCalledOnce(self, aList):
aList.append('once')
return
yield
once = MyObserver()
diamond = \
(Transparent(),
(Transparent(),
(once,)
),
(Transparent(),
(once,)
)
)
root = be(diamond)
collector = []
list(compose(root.once.methodOnlyCalledOnce(collector)))
self.assertEquals(['once'], collector)
def testObserverAttributeErrorNotIgnored(self):
class GetAttr(object):
def __init__(self, attrName):
self.attrName = attrName
def call_unknown(self, message, *args, **kwargs):
return getattr(self, self.attrName)
def any_unknown(self, message, *args, **kwargs):
raise StopIteration(getattr(self, self.attrName))
yield
root = be((Observable(), (Transparent(), (GetAttr('doesnotexist'), )),
(GetAttr('__class__'), )))
try:
result = root.call.someMessage()
self.fail("should not get here: %s" % result)
except AttributeError, e:
self.assertEquals(
"'GetAttr' object has no attribute 'doesnotexist'", str(e))
def testRequestScopeIsAvailable(self):
class MyObserver(Observable):
def handleRequest(self, *args, **kwargs):
self.do.setArg()
yield self.call.getArg()
class SetArgObserver(Observable):
def setArg(self):
self.ctx.requestScope["arg"] = "value"
class GetArgObserver(Observable):
def getArg(self):
return self.ctx.requestScope["arg"]
dna = be((Observable(), (RequestScope(),
(MyObserver(), (SetArgObserver(), ),
(GetArgObserver(), )))))
result = list(compose(dna.all.handleRequest("a request")))
self.assertEqual(['value'], result)
def testLog(self):
class SomeLog(Transparent):
def logMe(self, argument):
collectLog(dict(logArgument=argument))
return self.call.logMe(argument=argument)
observer = createObserver()
observer.methods['doNotLogMe'] = observer.methods['logMe'] = observer.methods['callMessage']
observable = be((Observable(),
(LogCollector(),
(SomeLog(),
(observer,)
),
)
))
self.assertEquals('callresult', observable.call.logMe(argument=0))
self.assertEquals('callresult', observable.call.doNotLogMe(argument=0))
self.assertEquals(['logMe', 'writeLog', 'doNotLogMe'], observer.calledMethodNames())
writeLog = observer.calledMethods[1]
self.assertEquals((), writeLog.args)
self.assertEquals(['collectedLog'], writeLog.kwargs.keys())
self.assertEquals({'logArgument': [0]}, writeLog.kwargs['collectedLog'])
def testProcessRecordsOnCommand(self):
self.inboxDirectory = join(self.tempdir, 'inbox2')
self.doneDirectory = join(self.tempdir, 'done2')
makedirs(self.inboxDirectory)
makedirs(self.doneDirectory)
self.moveInRecord(identifier='repo:ident:1')
self.moveInRecord(identifier='repo:ident:2')
self.moveInRecord(identifier='repo:ident:3')
inbox = Inbox(self.reactor, inboxDirectory=self.inboxDirectory, doneDirectory=self.doneDirectory)
dna = be(
(Transparent(),
(inbox,)
)
)
dna.once.observer_init()
self.assertEquals(set(['repo:ident:1.record', 'repo:ident:2.record', 'repo:ident:3.record']), set(listdir(self.inboxDirectory)))
inbox.processInboxDirectory()
self.assertEquals(set(['repo:ident:1.record', 'repo:ident:2.record', 'repo:ident:3.record']), set(listdir(self.doneDirectory)))
def testIpfilterFakeIpHeaderKwargsUnchanged(self):
observer = CallTrace(methods={'handleRequest': handleRequest})
ipf = IpFilter(allowedIps=['192.168.1.1'])
dna = be((Observable(), (ipf, (observer, ))))
list(
compose(
dna.all.handleRequest(
Client=('127.0.0.1', ),
Headers={'X-Meresco-Ipfilter-Fake-Ip': '192.168.1.1'})))
self.assertEqual(1, len(observer.calledMethods))
self.assertEqual((), observer.calledMethods[0].args)
self.assertEqual(
{
'Client': ('127.0.0.1', ),
'Headers': {
'X-Meresco-Ipfilter-Fake-Ip': '192.168.1.1'
}
}, observer.calledMethods[0].kwargs)
def testGetRecordWithMultiSequentialStorage(self):
oaijazz = OaiJazz(self.tempdir + '/jazz')
oaijazz.updateMetadataFormat(prefix="oai_dc", schema="", namespace="")
storage = MultiSequentialStorage(self.tempdir + "/seq-store")
oairecord = OaiRecord()
oaigetrecord = be(
(OaiGetRecord(repository=OaiRepository()), (oaijazz, ),
(oairecord, (RetrieveToGetDataAdapter(), (storage, )))))
oaijazz.addOaiRecord(identifier="id0", metadataPrefixes=['oai_dc'])
storage.addData(identifier="id0", name="oai_dc", data=b"data01")
response = oaigetrecord.getRecord(arguments=dict(
verb=['GetRecord'],
metadataPrefix=['oai_dc'],
identifier=['id0'],
),
**self.httpkwargs)
_, body = asString(response).split("\r\n\r\n")
self.assertEqual(
"data01",
xpath(parse(BytesIO(body.encode())), '//oai:metadata')[0].text)
def testRequestScopeForEveryMethod(self):
resultByDo = []
class MyObserver(Observable):
def someAnyMethod(self, key, value, *args, **kwargs):
self.do.setArg(key, value)
result = self.call.getArg(key)
raise StopIteration(result)
yield
def someAllMethod(self, key, value, *args, **kwargs):
self.do.setArg(key, value)
yield self.call.getArg(key)
def someCallMethod(self, key, value, *args, **kwargs):
self.do.setArg(key, value)
return self.call.getArg(key)
def someDoMethod(self, key, value, *args, **kwargs):
self.do.setArg(key, value)
resultByDo.append(self.call.getArg(key))
class SetArgObserver(Observable):
def setArg(self, key, value):
self.ctx.requestScope[key] = value
class GetArgObserver(Observable):
def getArg(self, key):
return self.ctx.requestScope[key]
dna = be((Observable(), (RequestScope(),
(MyObserver(), (SetArgObserver(), ),
(GetArgObserver(), )))))
try:
compose(dna.any.someAnyMethod(key='anykey',
value='anyvalue')).next()
self.fail()
except StopIteration, e:
self.assertEquals('anyvalue', e.args[0])
