def testShouldCallPreviouslyRegisteredSignalHandlersAfterHandleShutdown(
self):
reactor = Reactor()
called = []
def handleShutdown():
called.append('handleShutdown')
testCoName = currentframe().f_code.co_name
def prevIntHandler(signum, frame):
self.assertEqual(SIGINT, signum)
self.assertEqual(testCoName, frame.f_code.co_name)
called.append('prevIntHandler')
trace = CallTrace('Observer',
methods={'handleShutdown': handleShutdown})
top = be((
Observable(),
(
Observable(), # Only once calls walk the observer tree.
(trace, ),
),
))
origIntHandler = signal(SIGINT, prevIntHandler)
try:
shutdownHandler = registerShutdownHandler(statePath=self.tempdir,
server=top,
reactor=reactor)
reactor.addTimer(0.01, lambda: None)
with stdout_replaced() as output:
try:
kill(getpid(), SIGINT)
reactor.loop()
self.fail('should terminate')
except KeyboardInterrupt:
pass
self.assertTrue(
'Scheduled for immediate shutdown.\n' in output.getvalue(),
output.getvalue())
self.assertTrue('Shutdown completed.\n' in output.getvalue(),
output.getvalue())
finally:
shutdownHandler.unregister()
signal(SIGINT, origIntHandler)
self.assertEqual(['handleShutdown'], trace.calledMethodNames())
self.assertEqual(
((), {}),
(trace.calledMethods[0].args, trace.calledMethods[0].kwargs))
self.assertEqual(['handleShutdown', 'prevIntHandler'], called)
def _buildDna(self, defaultRecordSchema="rdf", **kwargs):
jsonSearch = JsonSearch(defaultRecordSchema=defaultRecordSchema,
**kwargs)
jsonSearch._timeNow = self._timeNow
self.dna = be(
(Observable(), (LogCollector(), (jsonSearch, (self.observer, )))))
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 testCountOne(self):
self.report = CallTrace(returnValues={'report': None},
onlySpecifiedMethods=True)
self.top = be((Observable(), (LogCollector(), (
GustosLogWriter(),
(CountReport(gustosGroup='gustosGroup',
scopeNames=(),
curveName='calls'), ),
(CountReport(gustosGroup='gustosGroup',
scopeNames=(),
curveName='collectTimes',
keys=('collectResponse', 'some')), ),
(self.report, ),
), (CollectMeALog(), ))))
self.top.do.callMe(times=3)
self.assertEqual(['report'], self.report.calledMethodNames())
countReport = self.report.calledMethods[0].kwargs['values'][
'gustosGroup']['Counts']
self.assertEqual({
'collectTimes': {
'count': 3
},
'calls': {
'count': 1
}
}, countReport)
def testUpdateRecordWhileSendingData(self):
batchSize = 3
oaiJazz = OaiJazz(join(self.tempdir, 'oai'))
oaiJazz.updateMetadataFormat(prefix="prefix", schema="", namespace="")
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",
metadataPrefixes=["prefix"])
result = XML(buf.getvalue().split(CRLF * 2)[-1].encode())
resumptionToken = xpathFirst(
result,
'/oai:OAI-PMH/oai:ListIdentifiers/oai:resumptionToken/text()')
self.assertFalse(resumptionToken is None)
def testNamespaces(self):
xmlXPath = XmlXPath(['/a:aNode/b:bNode'],
fromKwarg='lxmlNode',
namespaces={
'a': 'aNamespace',
'b': 'bNamespace'
})
lxmlNode = parse(
StringIO(
'<aNode xmlns="aNamespace"><bNode xmlns="bNamespace">ccc</bNode></aNode>'
))
observer = CallTrace('Observer')
observable = Observable()
observable.addObserver(xmlXPath)
xmlXPath.addObserver(observer)
observable.do.message(lxmlNode=lxmlNode)
message = observer.calledMethods[0]
self.assertEqual('message', message.name)
newNode = message.kwargs['lxmlNode']
self.assertEqualsWS('<bNode xmlns="bNamespace">ccc</bNode>',
lxmltostring(newNode))
newNamespaces = newNode.getroot().nsmap
nameSpacesAfterParsing = parse(StringIO(
lxmltostring(newNode))).getroot().nsmap
self.assertEqual(nameSpacesAfterParsing, newNamespaces)
def testProvenance(self):
observable = Observable()
provenance = OaiProvenance(
nsMap={'oai_dc': "http://www.openarchives.org/OAI/2.0/"},
baseURL=('meta', '/meta/repository/baseurl/text()'),
harvestDate=('meta', '/meta/repository/harvestDate/text()'),
metadataNamespace=('meta',
'/meta/repository/metadataNamespace/text()'),
identifier=('header', '/oai_dc:header/oai_dc:identifier/text()'),
datestamp=('header', '/oai_dc:header/oai_dc:datestamp/text()'))
observable.addObserver(provenance)
observer = MockStorage()
provenance.addObserver(observer)
result = asString(observable.any.provenance("recordId"))
self.assertEqualsWS(
"""<provenance xmlns="http://www.openarchives.org/OAI/2.0/provenance"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.openarchives.org/OAI/2.0/provenance
http://www.openarchives.org/OAI/2.0/provenance.xsd">
<originDescription harvestDate="HARVESTDATE" altered="true">
<baseURL>BASEURL</baseURL>
<identifier>recordId</identifier>
<datestamp>DATESTAMP</datestamp>
<metadataNamespace>METADATANAMESPACE</metadataNamespace>
</originDescription>
</provenance>""", result)
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 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 __init__(self, reactor, oaiPath, **kwargs):
Observable.__init__(self, **kwargs)
self._outside = Transparent()
oaiJsonInfo = OaiJsonInfo()
self._dynamicHtml = DynamicHtml(
[dynamicPath],
reactor=reactor,
notFoundPage='notFound',
additionalGlobals={
'VERSION': VERSION,
'oaiPath': oaiPath,
'strftime': strftime,
'localtime': localtime,
})
self._internalTree = be((
Observable(),
(PathFilter('/', excluding=['/static', '/version', '/json']), (
self._dynamicHtml,
(
oaiJsonInfo,
(self._outside, ),
),
)),
(PathFilter('/json'), (
oaiJsonInfo,
(self._outside, ),
)),
(PathFilter('/static'),
(PathRename(lambda path: path[len('/static'):]),
(FileServer(staticPath), ))),
(PathFilter('/version'),
(StringServer("Meresco Oai version %s" % VERSION,
ContentTypePlainText), )),
))
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.assertEqual(['addOaiRecord'], [m.name for m in intercept.calledMethods])
method = intercept.calledMethods[0]
self.assertEqual(((), {'identifier': 'an:identifier', 'metadataFormats': set([('prefix', 'schema', 'namespace')]), 'sets': set([('setSpec', 'setName')])}), (method.args, method.kwargs))
def testRemoteExecuteQuery(self):
http = CallTrace('http')
def httppost(*args, **kwargs):
raise StopIteration('HTTP/1.0 200 Ok\r\n\r\n%s' %
LuceneResponse(total=5,
hits=[
Hit("1"),
Hit("2"),
Hit("3", duplicateCount=2),
Hit("4"),
Hit("5")
]).asJson())
yield
http.methods['httppost'] = httppost
remote = LuceneRemote(host='host', port=1234, path='/path')
observable = Observable()
observable.addObserver(remote)
remote._httppost = http.httppost
cq = ComposedQuery('coreA')
cq.setCoreQuery(
core='coreA',
query=parseString('query AND field=value'),
filterQueries=[parseString('query=fiets')],
facets=[{
'fieldname': 'field',
'maxTerms': 5
}],
)
cq.setCoreQuery(core='coreB', query=parseString('query=test'))
cq.addMatch(dict(core='coreA', uniqueKey='keyA'),
dict(core='coreB', key='keyB'))
result = returnValueFromGenerator(
observable.any.executeComposedQuery(query=cq))
self.assertEquals(5, result.total)
self.assertEquals([
Hit("1"),
Hit("2"),
Hit("3", duplicateCount=2),
Hit("4"),
Hit("5")
], result.hits)
self.assertEquals(['httppost'], http.calledMethodNames())
m = http.calledMethods[0]
self.assertEquals('host', m.kwargs['host'])
self.assertEquals(1234, m.kwargs['port'])
self.assertEquals('/path/__lucene_remote__', m.kwargs['request'])
self.assertEquals('application/json',
m.kwargs['headers']['Content-Type'])
message, kwargs = jsonLoadMessage(m.kwargs['body'])
query = kwargs['query']
self.assertEquals('executeComposedQuery', message)
self.assertEquals('coreA', query.resultsFrom)
self.assertEquals([{
'fieldname': 'field',
'maxTerms': 5
}], query.facetsFor('coreA'))
def testRemotePrefixSearch(self):
http = CallTrace('http')
def httppost(*args, **kwargs):
raise StopIteration('HTTP/1.0 200 Ok\r\n\r\n%s' % LuceneResponse(
total=5, hits=["1", "2", "3", "4", "5"]).asJson())
yield
http.methods['httppost'] = httppost
remote = LuceneRemote(host='host', port=1234, path='/path')
observable = Observable()
observable.addObserver(remote)
remote._httppost = http.httppost
result = returnValueFromGenerator(
observable.any.prefixSearch(prefix='aap',
fieldname='field',
limit=10))
self.assertEquals(5, result.total)
self.assertEquals(['httppost'], http.calledMethodNames())
m = http.calledMethods[0]
self.assertEquals('host', m.kwargs['host'])
self.assertEquals(
{
'message': 'prefixSearch',
'kwargs': {
'prefix': 'aap',
'fieldname': 'field',
'limit': 10,
}
}, loads(m.kwargs['body']))
def setUp(self):
SeecrTestCase.setUp(self)
self.observer1 = CallTrace('observer1',
emptyGeneratorMethods=['message'],
returnValues={
'function': 41,
'gen': (i for i in [41]),
'noop': None
})
self.observer2 = object()
self.observer3 = CallTrace('observer3',
emptyGeneratorMethods=['message'],
returnValues={
'function': 42,
'gen': (i for i in [42]),
'noop': None
})
self.dna = be(
(Observable(), (FilterMessages(
disallowed=['message', 'function', 'gen', 'noop']),
(self.observer1, )),
(FilterMessages(allowed=['message', 'function', 'gen', 'noop']),
(self.observer2, )),
(FilterMessages(allowed=['message', 'function', 'gen', 'noop']),
(self.observer3, ))))
def testIntervalledReportAfterInterval(self):
self.top = be((
Observable(),
(ResponseTime(type="TYPE", interval=0.1), (self.observer, )),
))
msg = lambda nr: dict(index=Decimal("%s.000" % nr),
sru=Decimal("1.500"),
queryTime=Decimal("2.000"))
self.top.do.handleQueryTimes(**msg(1))
self.assertAlmostEqual(1.0, self.indexTimeFromLastMethod())
self.assertEqual(['report'] * 1, self.observer.calledMethodNames())
self.top.do.handleQueryTimes(**msg(2))
self.top.do.handleQueryTimes(**msg(3))
self.top.do.handleQueryTimes(**msg(4))
self.top.do.handleQueryTimes(**msg(5))
self.assertEqual(['report'] * 1, self.observer.calledMethodNames())
sleep(0.1)
self.top.do.handleQueryTimes(**msg(6))
self.assertEqual(['report'] * 2, self.observer.calledMethodNames())
self.assertAlmostEqual(6.0, self.indexTimeFromLastMethod())
self.top.do.handleQueryTimes(**msg(7))
self.top.do.handleQueryTimes(**msg(8))
self.top.do.handleQueryTimes(**msg(9))
self.top.do.handleQueryTimes(**msg(10))
self.assertEqual(['report'] * 2, self.observer.calledMethodNames())
sleep(0.1)
self.top.do.handleQueryTimes(**msg(11))
self.assertEqual(['report'] * 3, self.observer.calledMethodNames())
self.assertAlmostEqual(11.0, self.indexTimeFromLastMethod())
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 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 list(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.assertEqual(['key0=value0'], result0)
self.assertEqual(['key1=value1'], result1)
def testLogRequestInCaseOfExceptionAfterStatusCode(self):
requestHandler = CallTrace('handler', ignoredAttributes=['writeLog', 'do_unknown'])
def handleRequestRaisesException(**kwargs):
yield Yield
yield okPlainText
yield 'text'
raise ValueError('doesntreallymatter')
yield
requestHandler.methods['handleRequest'] = handleRequestRaisesException
stream = StringIO()
handleRequestLog = HandleRequestLog()
handleRequestLog._time = lambda: 1395409143.0
observable = be((Observable(),
(LogCollector(),
(handleRequestLog,
(requestHandler,)
),
(ApacheLogWriter(stream),),
)
))
result = []
g = compose(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'))
try:
for x in g:
result.append(x)
except Exception:
pass
self.assertEqual([Yield, bytes(okPlainText, encoding='utf-8'), b'text'], result)
self.assertEqual(['handleRequest'], requestHandler.calledMethodNames())
logline = stream.getvalue()
self.assertEqual('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" Exception raised:\n ValueError(\'doesntreallymatter\')\n', logline)
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 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 testAllQueryHelpersForSRU(self):
index = CallTrace('index')
def executeQuery(**kwargs):
return Response(total=3201, hits=[])
yield
index.methods['executeQuery'] = executeQuery
index.ignoredAttributes.extend(
['echoedExtraRequestData', 'extraResponseData', 'all_unknown'])
server = be((
Observable(),
(self.queryLog, (SruParser(),
(QueryLogHelperForSru(),
(SruHandler(extraRecordDataNewStyle=True),
(QueryLogHelperForExecuteCQL(), (index, )))))),
))
''.join(
compose(
server.all.handleRequest(
path='/path/sru',
Client=('11.22.33.44', 8080),
arguments={
'operation': ['searchRetrieve'],
'version': ['1.2'],
'maximumRecords': ['0'],
'query': ['field=value'],
},
)))
with open(join(self.tempdir, '2009-11-02-query.log')) as fp:
self.assertEqual(
'2009-11-02T11:25:37Z 11.22.33.44 0.7K 1.000s 3201hits /path/sru maximumRecords=0&operation=searchRetrieve&query=field%3Dvalue&recordPacking=xml&recordSchema=dc&startRecord=1&version=1.2\n',
fp.read())
def setUp(self):
SeecrTestCase.setUp(self)
self.observer = CallTrace('observer')
self.top = be((Observable(), (
LogComponent('x'),
(self.observer, ),
)))
def testShouldUnregister(self):
# ... for testing purposes.
def getRelevantHandlers():
return [getsignal(sh)
for sh in SHUTDOWN_SIGNALS] # SIGTERM, SIGINT
persistable = CallTrace('Observer',
emptyGeneratorMethods=['handleShutdown'])
top = be((
Observable(),
(persistable, ),
))
reactor = CallTrace('reactor')
pre = getRelevantHandlers()
handler = registerShutdownHandler(statePath=self.tempdir,
server=top,
reactor=reactor)
_with = getRelevantHandlers()
handler.unregister()
post = getRelevantHandlers()
# shutdownHandler set
ourHandlerSet = set(_with).difference(set(pre))
self.assertEqual(1, len(ourHandlerSet))
ourHandler = ourHandlerSet.pop()
# shutdownHandler removed on .unregister()
self.assertEqual(pre, post)
# shutdownHandler is who he's supposed to be.
self.assertEqual('_handleShutdown', ourHandler.__func__.__name__)
self.assertEqual(handler, ourHandler.__self__)
def testOne(self):
observable = Observable()
bitMatrixRow = CallTrace('BitMatrixRow')
multi = MultiLevelDrilldown({'date': [('datelevel1', 10, False)]})
drilldown = CallTrace('Drilldown')
def dd(*args, **kwargs):
return iter([('datelevel1', iter([('2008', 13), ('2007', 10)]))])
yield
drilldown.methods['drilldown'] = dd
multi.addObserver(drilldown)
observable.addObserver(multi)
result = list(
compose(observable.call.multiLevelDrilldown(
bitMatrixRow, ['date'])))
self.assertEqual(1, len(drilldown.calledMethods))
drilldownMethod = drilldown.calledMethods[0]
self.assertEqual('drilldown', drilldownMethod.name)
self.assertEqual((bitMatrixRow, [('datelevel1', 10, False)]),
drilldownMethod.args)
self.assertEqual(1, len(result))
(inputFieldName, realFieldName), termCounts = result[0]
self.assertEqual('date', inputFieldName)
self.assertEqual('datelevel1', realFieldName)
self.assertEqual([('2008', 13), ('2007', 10)], list(termCounts))
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 testAddPartname(self):
@asyncnoreturnvalue
def add(**kwargs):
pass
observable = Observable()
observer = CallTrace('observer', methods={'add': add})
rewrite = RewritePartname('newPartname')
rewrite.addObserver(observer)
observable.addObserver(rewrite)
result = list(
compose(
observable.all.add(identifier='identifier',
partname='oldPartname',
data='data')))
self.assertEqual(['add'], [m.name for m in observer.calledMethods])
self.assertEqual(
{
'identifier': 'identifier',
'partname': 'newPartname',
'data': 'data'
}, observer.calledMethods[0].kwargs)
self.assertEqual([], result)
def testCountOne(self):
self.report = CallTrace(returnValues={'report': {
"packet": "data"
}},
onlySpecifiedMethods=True)
self.top = be((Observable(), (LogCollector(), (
GustosLogWriter(),
(ResponseTimeReport(gustosGroup='gustosGroup',
scopeNames=(),
curveName='http'), ),
(ResponseTimeReport(gustosGroup='gustosGroup',
scopeNames=(),
curveName='other',
keys=('otherResponse', 'duration')), ),
(self.report, ),
), (CollectMeALog(), ))))
self.top.do.callMe(times=3)
self.assertEqual(['report'], self.report.calledMethodNames())
theReport = self.report.calledMethods[0].kwargs['values'][
'gustosGroup']['ResponseTime']
self.assertEqual({
'other': {
'time': 0.3
},
'http': {
'time': 0.0
}
}, theReport)
def setUp(self):
SeecrTestCase.setUp(self)
self.observer = CallTrace('gustos for time')
self.top = be((
Observable(),
(ResponseTime(type="TYPE"), (self.observer, )),
))
def testQuery(self):
def executeQuery(**kwargs):
return 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')))
with open(join(self.tempdir, '2009-11-02-query.log')) as fp:
self.assertEqual('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', fp.read())
def setUp(self):
SeecrTestCase.setUp(self)
self.observer = CallTrace()
self.dna = be((Observable(), (OaiSetMask(['set1', 'set2'],
name="set1|set2 mask"),
(self.observer, ))))
