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