def testStdOutReplaced(self): idStdout = id(sys.stdout) idStderr = id(sys.stderr) with stdout_replaced() as s: self.assertNotEqual(idStdout, id(sys.stdout)) self.assertEquals(idStderr, id(sys.stderr)) print 'output_as_contextmanager' self.assertEquals('output_as_contextmanager\n', s.getvalue()) self.assertEquals(idStdout, id(sys.stdout)) called = [] @stdout_replaced def decoratedFunction(arg1, *args, **kwargs): self.assertNotEqual(idStdout, id(sys.stdout)) called.append((arg1, args, kwargs)) print 'output_as_decorator' return 'retval' with stdout_replaced() as s: outerMockId = id(sys.stdout) self.assertNotEqual(idStdout, outerMockId) result = decoratedFunction('arg1', 'anotherarg', key='wordedArg') self.assertEquals('retval', result) self.assertEquals(outerMockId, id(sys.stdout)) self.assertEquals('', s.getvalue()) self.assertEquals(idStdout, id(sys.stdout)) self.assertEquals([('arg1', ('anotherarg',), {'key': 'wordedArg'})], called)
def testUsage(self): # default parser = ParseArguments() with stdout_replaced() as out: parser.print_help() s = out.getvalue() self.assertEqual(['Usage: _alltests.py [options]', ''], s.splitlines()[:2]) # explicit default: "%prog [options]" usage = "%prog [options]" parser = ParseArguments(usage=usage) with stdout_replaced() as out: parser.print_help() s = out.getvalue() self.assertEqual(['Usage: _alltests.py [options]', ''], s.splitlines()[:2]) # decidedly different usage = "|before| %prog [options] [more-stuff]" parser = ParseArguments(usage=usage) with stdout_replaced() as out: parser.print_help() s = out.getvalue() self.assertEqual( ['Usage: |before| _alltests.py [options] [more-stuff]', ''], s.splitlines()[:2])
def testShouldAbortInitWithExceptionIfRunningMarkerStillThere(self): # Subclassed SystemExit for ShutdownFailedException to ensure a service quits when left in an inconsistent state, # even if it needs to traverse "except (SystemExit, KeyboardInterrupt, AssertionError)" catch-statements. self.assertTrue(issubclass(ShutdownFailedException, SystemExit)) with open(join(self.tempdir, 'running.marker'), 'w') as fp: fp.write('already there') with stdout_replaced() as output: try: self._createShutdownHandler(statePath=self.tempdir, server=CallTrace('server'), reactor=CallTrace('reactor')) self.fail('should terminate') except ShutdownFailedException: pass self.assertTrue( "process was not previously shutdown to a consistent persistent state." in output.getvalue(), output.getvalue()) self.assertTrue( "NOT starting from an unknown state." in output.getvalue(), output.getvalue()) with stdout_replaced() as output: try: self._createShutdownHandler(statePath=self.tempdir, server=CallTrace('server'), reactor=CallTrace('reactor')) self.fail('should terminate') except SystemExit: pass
def testStdOutReplaced(self): idStdout = id(sys.stdout) idStderr = id(sys.stderr) with stdout_replaced() as s: self.assertNotEqual(idStdout, id(sys.stdout)) self.assertEqual(idStderr, id(sys.stderr)) print('output_as_contextmanager') self.assertEqual('output_as_contextmanager\n', s.getvalue()) self.assertEqual(idStdout, id(sys.stdout)) called = [] @stdout_replaced def decoratedFunction(arg1, *args, **kwargs): self.assertNotEqual(idStdout, id(sys.stdout)) called.append((arg1, args, kwargs)) print('output_as_decorator') return 'retval' with stdout_replaced() as s: outerMockId = id(sys.stdout) self.assertNotEqual(idStdout, outerMockId) result = decoratedFunction('arg1', 'anotherarg', key='wordedArg') self.assertEqual('retval', result) self.assertEqual(outerMockId, id(sys.stdout)) self.assertEqual('', s.getvalue()) self.assertEqual(idStdout, id(sys.stdout)) self.assertEqual([('arg1', ('anotherarg', ), { 'key': 'wordedArg' })], called)
def testLogCall(self): args, kwargs = ('a', ), {'b': 'c'} with stdout_replaced() as out: self.top.call.aMessage('a', b='c') self.assertCall('aMessage', args, kwargs, out) with stdout_replaced() as out: self.top.call.aMessage(*args, **kwargs) self.assertCall('aMessage', args, kwargs, out) # "message" is the only keyword-argument that cannot be handled by anything implementing *_unknown. try: self.top.call.aMessage(message='m') except TypeError as e: self.assertTrue( "got multiple values for argument 'message'" in str(e), str(e)) # ... and "method" does work (broken in previous version). with stdout_replaced() as out: self.top.call.notherMessage(method='f') self.assertCall('notherMessage', tuple(), {'method': 'f'}, out) # retval roundtrip self.observer.methods['f'] = lambda: 42 with stdout_replaced() as out: result = self.top.call.f() self.assertEqual(42, result) self.assertCall('f', tuple(), {}, out)
def testLogCall(self): args, kwargs = ('a',), {'b': 'c'} with stdout_replaced() as out: self.top.call.aMessage('a', b='c') self.assertCall('aMessage', args, kwargs, out) with stdout_replaced() as out: self.top.call.aMessage(*args, **kwargs) self.assertCall('aMessage', args, kwargs, out) # "message" is the only keyword-argument that cannot be handled by anything implementing *_unknown. try: self.top.call.aMessage(message='m') except TypeError, e: self.assertTrue("got multiple values for keyword argument 'message'" in str(e), str(e))
def testMetaVars(self): parser = ParseArguments() parser.addOption('', '--option') parser.addOption('', '--defaultValue', default='default') parser.addOption('', '--noneValue', default=None) parser.addOption('', '--port', help='Port', type='int') parser.addOption('', '--otherPort', help='Port', type='int', default=10000) parser.addOption('', '--quiet', action='store_false', default=True, dest='verbose') with stdout_replaced() as out: parser.print_help() self.assertTrue("--option=<string>" in out.getvalue(), out.getvalue()) self.assertTrue("--defaultValue='default'" in out.getvalue(), out.getvalue()) self.assertTrue("--noneValue=<string>" in out.getvalue(), out.getvalue()) self.assertTrue("--port=<int>" in out.getvalue(), out.getvalue()) self.assertTrue("--otherPort=10000" in out.getvalue(), out.getvalue())
def testPutMethodReadsBody(self): self.requestData = None def handler(**kwargs): self.requestData = kwargs return yield with stdout_replaced(): with Reactor() as reactor: server = HttpServer(reactor, self.port, handler, timeout=0.01) server.listen() sok = socket() sok.connect(('localhost', self.port)) sok.send('PUT / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 8\r\n\r\nbodydata') while not self.requestData: reactor.step() self.assertEquals(dict, type(self.requestData)) self.assertTrue('Headers' in self.requestData) headers = self.requestData['Headers'] self.assertEquals('PUT', self.requestData['Method']) self.assertEquals('application/x-www-form-urlencoded', headers['Content-Type']) self.assertEquals(8, int(headers['Content-Length'])) self.assertTrue('Body' in self.requestData) self.assertEquals('bodydata', self.requestData['Body']) # cleanup sok.close() server.shutdown()
def testPostMethodDeCompressesDeflatedBody_deflate(self): self.requestData = None def handler(**kwargs): self.requestData = kwargs return yield with stdout_replaced(): with Reactor() as reactor: server = HttpServer(reactor, self.port, handler, timeout=0.01) server.listen() sok = socket() sok.connect(('localhost', self.port)) bodyData = 'bodydatabodydata' bodyDataCompressed = compress(bodyData) contentLengthCompressed = len(bodyDataCompressed) sok.send(('POST / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: %d\r\nContent-Encoding: deflate\r\n\r\n' % contentLengthCompressed) + bodyDataCompressed) while not self.requestData: reactor.step() self.assertEquals(dict, type(self.requestData)) self.assertTrue('Headers' in self.requestData) headers = self.requestData['Headers'] self.assertEquals('POST', self.requestData['Method']) self.assertEquals('application/x-www-form-urlencoded', headers['Content-Type']) self.assertEquals(contentLengthCompressed, int(headers['Content-Length'])) # TS: is this correct?, maybe decompressed length? self.assertTrue('Body' in self.requestData) self.assertEquals('bodydatabodydata', self.requestData['Body']) # cleanup sok.close() server.shutdown()
def testReadChunkedAndCompressedPost(self): postData = 'AhjBeehCeehAhjBeehCeehAhjBeehCeehAhjBeehCeeh' postDataCompressed = compress(postData) self.assertEquals(20, len(postDataCompressed)) self.assertEquals(15, len(postDataCompressed[:15])) self.assertEquals(5, len(postDataCompressed[15:])) self.requestData = {} def handler(**kwargs): self.requestData = kwargs return yield with stdout_replaced(): with Reactor() as reactor: server = HttpServer(reactor, self.port, handler, timeout=0.01, recvSize=3) server.listen() sok = socket() sok.connect(('localhost', self.port)) postString = 'POST / HTTP/1.1\r\nContent-Type: application/x-www-form-urlencoded\r\nTransfer-Encoding: chunked\r\nContent-Encoding: deflate\r\n\r\nf\r\n%s\r\n5\r\n%s\r\n0\r\n' % (postDataCompressed[:15], postDataCompressed[15:]) sok.send(postString) reactor.addTimer(0.2, lambda: self.fail("Test Stuck")) while self.requestData.get('Body', None) != postData: reactor.step() # cleanup sok.close() server.shutdown()
def testWindowsPostMultipartForm(self): httpRequest = open(inmydir('data/multipart-data-02')).read() self.requestData = {} def handler(**kwargs): self.requestData = kwargs return yield with stdout_replaced(): with Reactor() as reactor: server = HttpServer(reactor, self.port, handler) server.listen() sok = socket() sok.connect(('localhost', self.port)) sok.send(httpRequest) reactor.addTimer(2, lambda: self.fail("Test Stuck")) while self.requestData.get('Form', None) == None: reactor.step() form = self.requestData['Form'] self.assertEquals(4, len(form)) self.assertEquals(['SOME ID'], form['id']) self.assertEquals(1, len(form['somename'])) filename, mimetype, data = form['somename'][0] self.assertEquals('Bank Gothic Medium BT.ttf', filename) self.assertEquals('application/octet-stream', mimetype) # cleanup sok.close() server.shutdown()
def testReactorSuspend(self): handle = ['initial value'] with stdout_replaced() as out: with Reactor() as reactor: def callback(): handle[0] = reactor.suspend() sok1 = MockSocket() reactor.addReader(sok1, callback) self.assertTrue(sok1.fileno() in reactor._fds) reactor.step() self.assertTrue(sok1.fileno() not in reactor._fds) sok2 = MockSocket() reactor.addWriter(sok2, callback) self.assertTrue(sok2.fileno() in reactor._fds) reactor.step() self.assertTrue(sok2.fileno() not in reactor._fds) self.assertTrue(handle[0] != None) self.assertTrue(handle[0] != 'initial value') # cleanup fd's sok1.close() sok2.close() self.assertEquals(2, out.getvalue().count('closing'), out.getvalue())
def testReadMultipartFormEndBoundary(self): httpRequest = open(inmydir('data/multipart-data-04')).read() self.requestData = {} def handler(**kwargs): self.requestData = kwargs return yield with stdout_replaced(): with Reactor() as reactor: server = HttpServer(reactor, self.port, handler) server.listen() sok = socket() sok.connect(('localhost', self.port)) sok.send(httpRequest) reactor.addTimer(2, lambda: self.fail("Test Stuck")) while self.requestData.get('Form', None) == None: reactor.step() form = self.requestData['Form'] self.assertEquals(1, len(form)) self.assertEquals(3521*'X', form['id'][0]) # cleanup sok.close() server.shutdown()
def testYieldInHttpServer(self): bucket = [] def handler(RequestURI, **kwargs): yield 'A' while 'continue' not in bucket: yield Yield yield 'B' with stdout_replaced(): with Reactor() as reactor: server = HttpServer(reactor, self.port, handler) server.listen() sok = socket() sok.connect(('localhost', self.port)) sok.send('GET /path/here HTTP/1.0\r\n\r\n') for i in xrange(500): reactor.step() self.assertEquals('A', sok.recv(100)) bucket.append('continue') reactor.step() self.assertEquals('B', sok.recv(100)) # cleanup sok.close() server.shutdown()
def testDefaultValueInHelp(self): parser = ParseArguments() parser.addOption('', '--option', help='Option with a default value of {default}', default=42) with stdout_replaced() as out: parser.print_help() self.assertTrue("Option with a default value of 42" in out.getvalue(), out.getvalue())
def testWrongUseAfterSuspending(self): with stdout_replaced(): with Reactor() as reactor: handle = ['initial value'] def callback(): handle[0] = reactor.suspend() sok = MockSocket() reactor.addWriter(sok, callback) reactor.step() self.assertEquals(sok.fileno(), handle[0]) try: reactor.addWriter(sok, callback) self.fail("Exception not raised") except ValueError, e: self.assertEquals('Socket is suspended', str(e)) try: reactor.addReader(sok, callback) self.fail("Exception not raised") except ValueError, e: self.assertEquals('Socket is suspended', str(e)) # cleanup fd's sok.close()
def testTextFileSeenAsFile(self): httpRequest = open(inmydir('data/multipart-data-03')).read() self.requestData = {} def handler(**kwargs): self.requestData = kwargs return yield with stdout_replaced(): with Reactor() as reactor: server = HttpServer(reactor, self.port, handler) server.listen() sok = socket() sok.connect(('localhost', self.port)) sok.send(httpRequest) reactor.addTimer(2, lambda: self.fail("Test Stuck")) while self.requestData.get('Form', None) == None: reactor.step() form = self.requestData['Form'] self.assertEquals(4, len(form)) self.assertEquals(['SOME ID'], form['id']) self.assertEquals(1, len(form['somename'])) filename, mimetype, data = form['somename'][0] self.assertEquals('hello.bas', filename) self.assertEquals('text/plain', mimetype) # cleanup sok.close() server.shutdown()
def testSleepWheelNoCallback(self): t0 = time() with stdout_replaced(): retval = sleepWheel(0.01, interval=0.001) t1 = time() delta = t1 - t0 self.assertTrue(0.01 < delta < max(0.02, (0.02 * T_ADJUSTMENT * T)), delta) self.assertEquals(False, retval)
def testEpilog(self): epilog = 'And this is how they lived happily ever after.' parser = ParseArguments(epilog=epilog) parser.addOption('', '--option') with stdout_replaced() as out: parser.print_help() s = out.getvalue() self.assertTrue(s.endswith('--option=<string> \n\n{}\n'.format(epilog)), s)
def testSleepWheelNoCallback(self): t0 = time() with stdout_replaced(): retval = sleepWheel(0.01, interval=0.001) t1 = time() delta = t1 - t0 self.assertTrue(0.01 < delta < max(0.02, (0.02 * T_ADJUSTMENT * T)), delta) self.assertEqual(False, retval)
def testLogCall(self): args, kwargs = ('a', ), {'b': 'c'} with stdout_replaced() as out: self.top.call.aMessage('a', b='c') self.assertCall('aMessage', args, kwargs, out) with stdout_replaced() as out: self.top.call.aMessage(*args, **kwargs) self.assertCall('aMessage', args, kwargs, out) # "message" is the only keyword-argument that cannot be handled by anything implementing *_unknown. try: self.top.call.aMessage(message='m') except TypeError, e: self.assertTrue( "got multiple values for keyword argument 'message'" in str(e), str(e))
def testDescription(self): description = "Very nice program." parser = ParseArguments(description=description) parser.addOption('', '--option') with stdout_replaced() as out: parser.print_help() s = out.getvalue() self.assertEquals(['Usage: _alltests.py [options]', '', description, '', 'Options:'], s.splitlines()[:5])
def testEmptyPath(self): with stdout_replaced(): with Reactor() as reactor: request = "GET / HTTP/1.1\r\nHost: localhost\r\nUser-Agent: Weightless/v%s\r\n\r\n" % WlVersion serverThread = server(self.port, "HTTP/1.1 200 OK\r\n\r\n", request) reader = HttpReaderFacade(reactor, "http://localhost:%s" % self.port, lambda data: 'a') reactor.step() reactor.step() serverThread.join()
def testEpilog(self): epilog = 'And this is how they lived happily ever after.' parser = ParseArguments(epilog=epilog) parser.addOption('', '--option') with stdout_replaced() as out: parser.print_help() s = out.getvalue() self.assertTrue( s.endswith('--option=<string> \n\n{}\n'.format(epilog)), s)
def testTriples(self): with stdout_replaced(): g = GraphComponent(rdfSources=[]) g = g.makeGraph(parseXml(RDF_XML)) self.assertEquals([('uri:uri', namespaces.dcterms + 'title', Literal('The title'))], list(g.triples(subject='uri:uri', predicate=namespaces.dcterms + 'title'))) self.assertEquals([('uri:uri', namespaces.dcterms + 'title', Literal('The title'))], list(g.triples(subject=None, predicate=namespaces.dcterms + 'title', object=Literal('The title')))) self.assertEquals([('uri:uri', namespaces.rdf + 'type', Uri('type:type#'))], list(g.triples(object=Uri('type:type#')))) self.assertEquals(1, len(list(g.triples(object=Uri('type:type#'))))) self.assertEquals(1, len(list(g.triples(subject='uri:uri', predicate=namespaces.rdf+'type', object=Uri('type:type#')))))
def testFindLabelUsingRealOntology(self): subdir = join(self.tempdir, 'subdir') makedirs(subdir) copy(join(rdfDir, 'nl_property_labels.rdf'), subdir) with stdout_replaced(): g = GraphComponent(rdfSources=[self.tempdir]) self.assertEquals(Literal('Titel', lang='nl'), g.findLabel(namespaces.dcterms + 'title')) self.assertEquals(Literal('Maker', lang='nl'), g.findLabel(namespaces.dcterms + 'creator')) self.assertEquals(Literal('Tijd', lang='nl'), g.findLabel("http://purl.org/NET/c4dm/event.owl#time"))
def testMakeGraph(self): with stdout_replaced(): g = GraphComponent(rdfSources=[]) g = g.makeGraph(parseXml(RDF_XML)) self.assertEquals(set([ ('uri:uri', namespaces.dcterms + 'title', Literal('The title')), ('uri:uri', namespaces.rdf + 'type', Uri('type:type#')) ]), set(list(g.triples(None, None, None))) )
def testDefaultValueInHelp(self): parser = ParseArguments() parser.addOption('', '--option', help='Option with a default value of {default}', default=42) with stdout_replaced() as out: parser.print_help() self.assertTrue( "Option with a default value of 42" in out.getvalue(), out.getvalue())
def testDescription(self): description = "Very nice program." parser = ParseArguments(description=description) parser.addOption('', '--option') with stdout_replaced() as out: parser.print_help() s = out.getvalue() self.assertEqual([ 'Usage: _alltests.py [options]', '', description, '', 'Options:' ], s.splitlines()[:5])
def test_replace_stdout_of_children(self): import multiprocessing def child_process(): print("Here I am", file=sys.stdout, flush=True) with stdout_replaced() as out: ps = multiprocessing.Process(target=child_process) ps.start() ps.join() self.assertEqual("Here I am\n", out.getvalue())
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 testSleepWheelCallbackFalsy(self): calls = [] def callback(): calls.append(True) t0 = time() with stdout_replaced() as out: retval = sleepWheel(0.01, interval=0.001, callback=callback) t1 = time() self.assertEqual('\\\x08|\x08/\x08-\x08\\\x08|\x08/\x08-\x08\\\x08|\x08', out.getvalue()) delta = t1 - t0 self.assertTrue(0.01 < delta < max(0.02, (0.02 * T_ADJUSTMENT * T)), delta) self.assertEqual(10, len(calls)) self.assertEqual(False, retval)
def testSleepWheelCallbackFalsy(self): calls = [] def callback(): calls.append(True) t0 = time() with stdout_replaced() as out: retval = sleepWheel(0.01, interval=0.001, callback=callback) t1 = time() self.assertEquals('\\\x08|\x08/\x08-\x08\\\x08|\x08/\x08-\x08\\\x08|\x08', out.getvalue()) delta = t1 - t0 self.assertTrue(0.01 < delta < max(0.02, (0.02 * T_ADJUSTMENT * T)), delta) self.assertEquals(10, len(calls)) self.assertEquals(False, retval)
def testUsage(self): # default parser = ParseArguments() with stdout_replaced() as out: parser.print_help() s = out.getvalue() self.assertEquals(['Usage: _alltests.py [options]', ''], s.splitlines()[:2]) # explicit default: "%prog [options]" usage = "%prog [options]" parser = ParseArguments(usage=usage) with stdout_replaced() as out: parser.print_help() s = out.getvalue() self.assertEquals(['Usage: _alltests.py [options]', ''], s.splitlines()[:2]) # decidedly different usage = "|before| %prog [options] [more-stuff]" parser = ParseArguments(usage=usage) with stdout_replaced() as out: parser.print_help() s = out.getvalue() self.assertEquals(['Usage: |before| _alltests.py [options] [more-stuff]', ''], s.splitlines()[:2])
def testUnfinishedBusinessInReactorLogs(self): neverCalled = [] def timeAfterFinished(): assert local('__reactor__') is reactor() # Code explaining code :-) currentReactor = reactor() currentReactor.addTimer(1.0, lambda: neverCalled.append(True)) yield 'async work...' currentReactor.addProcess(lambda: neverCalled.append(True)) raise StopIteration(42) with stdout_replaced() as out: result = asProcess(timeAfterFinished()) self.assertEquals(42, result) self.assertEquals(1, out.getvalue().count('Reactor shutdown:'), out.getvalue())
def testGraphNavigationByTriples(self): with stdout_replaced(): gc = GraphComponent(rdfSources=[]) g = gc.makeGraph(lxmlNode=parseXml(RDF_XML_NAVIGATION)) result = list(g.triples(subject='uri:nav', predicate=namespaces.dcterms+'publisher')) self.assertEquals(1, len(result)) self.assertEquals( ('uri:nav', namespaces.dcterms+'publisher'), result[0][:2]) bnode = result[0][2] self.assertTrue(isinstance(bnode, BNode)) result = list(g.triples(subject=bnode.value)) self.assertEquals( [(bnode.value, namespaces.rdfs+'label', Literal('Pub'))], result)
def testTriplesUsingRealOntology(self): subdir = join(self.tempdir, 'subdir') makedirs(subdir) copy(join(rdfDir, 'nl_property_labels.rdf'), subdir) with stdout_replaced(): g = GraphComponent(rdfSources=[self.tempdir]) self.assertTrue(10 < len(list(g.triples())), list(g.triples())) self.assertEquals([ (namespaces.curieToUri('dcterms:title'), namespaces.curieToUri('rdfs:label'), Literal('Titel', lang='nl') ) ], list(g.triples( subject=namespaces.curieToUri('dcterms:title'), predicate=namespaces.curieToUri('rdfs:label'))), )
def testUnfinishedBusinessInReactorLogs(self): neverCalled = [] def timeAfterFinished(): assert local( '__reactor__') is reactor() # Code explaining code :-) currentReactor = reactor() currentReactor.addTimer(1.0, lambda: neverCalled.append(True)) yield 'async work...' currentReactor.addProcess(lambda: neverCalled.append(True)) raise StopIteration(42) with stdout_replaced() as out: result = asProcess(timeAfterFinished()) self.assertEquals(42, result) self.assertEquals(1, out.getvalue().count('Reactor shutdown:'), out.getvalue())
def testShouldContinueAfterCrashIfShutdownMustSucceedFlagFalse(self): with open(join(self.tempdir, 'running.marker'), 'w') as fp: fp.write('already there') with stdout_replaced() as output: try: self._createShutdownHandler(statePath=self.tempdir, server=CallTrace('server'), reactor=CallTrace('reactor'), shutdownMustSucceed=False) except SystemExit: self.fail('should not happen') self.assertTrue( "process was not previously shutdown to a consistent persistent state." in output.getvalue(), output.getvalue()) self.assertFalse( "NOT starting from an unknown state." in output.getvalue(), output.getvalue())
def testShouldReportToClientOnHandle(self): self.client.returnValues['listServices'] = { 'joe-joe-aiyedee': { 'ipAddress': "127.0.0.1", 'fqdn': "name.example.org", 'number': 42, 'lastseen': 1234567890.123456, 'active': True, 'type': "typeName", 'port': 4321, 'data': {'errors': 1, 'warnings': 1}}, 'other': { 'ipAddress': "127.0.0.2", 'fqdn': "other.example.org", 'number': 2, 'lastseen': 1.1, 'active': False, # False active 'type': "typeName", 'port': 4321}, } with stdout_replaced() as out: consume(self.dna.all.handle()) self.assertEqual('''\ AdminServicesReport: Error Services: type: typeName, identifier: joe-joe-aiyedee AdminServicesReport: Inactive Services: type: typeName, identifier: other ''', out.getvalue()) self.assertEqual(['listServices', 'report'], self.client.calledMethodNames()) self.assertEqual({'Admin Information': {'Services': {'active': {'count': 1}, 'inactive': {'count': 1} } ,'Errors': {'errors': {'count': 1}, 'warnings': {'count': 1} } } }, self.client.calledMethods[-1].kwargs['values'])
def testLargeBuffers(self): with stdout_replaced(): with Reactor() as reactor: lhs, rhs = socketpair() messages = [] messageSize = 1024*128 def peter(channel): with channel: while True: messages.append((yield)) def jack(channel): with channel: yield 'X' * messageSize Gio(reactor, jack(SocketContext(lhs))) Gio(reactor, peter(SocketContext(rhs))) while sum(len(message) for message in messages) < messageSize: reactor.step() self.assertTrue(len(messages) > 1) # test is only sensible when multiple parts are sent self.assertEquals(messageSize, len(''.join(messages)))
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 testReactorResumeProcess(self): with stdout_replaced() as out: with Reactor() as reactor: def callback(): handle[0] = reactor.suspend() yield yield handle = [callback().next] sok = MockSocket() reactor.addProcess(handle[0]) reactor.step() reactor.resumeProcess(handle[0]) reactor.step() self.assertFalse(handle[0] in reactor._fds) self.assertTrue(handle[0] in reactor._processes) self.assertRaises(KeyError, reactor.resumeProcess, handle[0]) # cleanup sok.close()
def testInitializeGraphComponentFromRdfObjects(self): class A(object): @property def context(self): return 'uri:context' def asRdfXml(self): yield '''\ <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"> <rdf:Description rdf:about="uri:someUri"> <rdfs:label xml:lang="nl">Some resource</rdfs:label> </rdf:Description> </rdf:RDF>''' with stdout_replaced(): gc = GraphComponent(rdfSources=[A()]) self.assertEquals([("uri:someUri", curieToUri("rdfs:label"), Literal("Some resource", lang="nl"))], list(gc.triples()))
def test_prewalk_example(self): def f(e): if isinstance(e, dict): return {} return e self.assertEquals([1, {}], prewalk(f, [1, {"k": "v"}])) with stdout_replaced() as out: prewalk_demo([1, {"k": "v"}]) res = out.getvalue() self.assertEquals( '''Walked: [1, {'k': 'v'}] Walked: 1 Walked: {'k': 'v'} Walked: ('k', 'v') Walked: k Walked: v\n''', res)
def testSendHeader(self): self.kwargs = None def response(**kwargs): self.kwargs = kwargs yield 'nosense' with stdout_replaced(): with Reactor() as reactor: server = HttpServer(reactor, self.port, response) server.listen() sok = socket() sok.connect(('localhost', self.port)) sok.send('GET /path/here HTTP/1.0\r\nConnection: close\r\nApe-Nut: Mies\r\n\r\n') while not self.kwargs: reactor.step() self.assertEquals({'Body': '', 'RequestURI': '/path/here', 'HTTPVersion': '1.0', 'Method': 'GET', 'Headers': {'Connection': 'close', 'Ape-Nut': 'Mies'}, 'Client': ('127.0.0.1', MATCHALL)}, self.kwargs) # cleanup sok.close() server.shutdown()
def testConnect(self): self.req = False def onRequest(**kwargs): self.req = True yield 'nosens' with stdout_replaced(): with Reactor() as reactor: server = HttpServer(reactor, self.port, onRequest) server.listen() sok = socket() sok.connect(('localhost', self.port)) sok.send('GET / HTTP/1.0\r\n\r\n') reactor.step() # connect/accept reactor.step() # read GET request reactor.step() # call onRequest for response data self.assertEquals(True, self.req) # cleanup server.shutdown() sok.close()
def testRequestAndHeaders(self): v = 'vx.y.z' expectedrequest = "GET /aap/noot/mies HTTP/1.1\r\nHost: localhost\r\nUser-Agent: Weightless/%s\r\n\r\n" % v dataReceived = [] serverThread = server(self.port, "HTTP/1.1 200 OK\r\ncOnteNt-type: text/html\r\n\r\nHello World!", expectedrequest) class Generator(object): def __init__(self): self.throw = None self.next = None def send(self, data): dataReceived.append(data) with stdout_replaced(): with Reactor() as reactor: connection = Connector(reactor, 'localhost', self.port) reader = HttpReader(reactor, connection, Generator(), 'GET', 'localhost', '/aap/noot/mies', recvSize=7) reactor.addTimer(0.1, lambda: self.fail("Test Stuck")) while 'Hello World!' != "".join((x for x in dataReceived[1:] if x)): reactor.step() serverThread.join() self.assertEquals({'HTTPVersion': '1.1', 'StatusCode': '200', 'ReasonPhrase': 'OK', 'Headers': {'Content-Type': 'text/html'}, 'Client': ('127.0.0.1', MATCHALL)}, dataReceived[0])
def testReadChunkedPost(self): self.requestData = {} def handler(**kwargs): self.requestData = kwargs return yield with stdout_replaced(): with Reactor() as reactor: server = HttpServer(reactor, self.port, handler, timeout=0.01, recvSize=3) server.listen() sok = socket() sok.connect(('localhost', self.port)) sok.send('POST / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nabcde\r\n5\r\nfghij\r\n0\r\n') reactor.addTimer(0.2, lambda: self.fail("Test Stuck")) while self.requestData.get('Body', None) != 'abcdefghij': reactor.step() # cleanup sok.close() server.shutdown()
def testLargeBuffers(self): with stdout_replaced(): with Reactor() as reactor: lhs, rhs = socketpair() messages = [] messageSize = 1024 * 128 def peter(channel): with channel: while True: messages.append((yield)) def jack(channel): with channel: yield 'X' * messageSize Gio(reactor, jack(SocketContext(lhs))) Gio(reactor, peter(SocketContext(rhs))) while sum(len(message) for message in messages) < messageSize: reactor.step() self.assertTrue( len(messages) > 1) # test is only sensible when multiple parts are sent self.assertEquals(messageSize, len(''.join(messages)))
def setUp(self): SeecrTestCase.setUp(self) self.filename = join(self.tempdir, 'passwd') with stdout_replaced() as self.stdout: self.pwd = PasswordFile(filename=self.filename, hashMethod=poorHash)
def f(): with stdout_replaced() as s: raise Exception()
responses = [] def gethandler(*args, **kwargs): try: response = yield httpget('localhost', port, '/path', maxResponseSize=1024) responses.append(response) except Exception, e: responses.append(e) self.handler = gethandler clientget('localhost', self.port, '/') with stderr_replaced(): with stdout_replaced(): self._loopReactorUntilDone() self.assertEquals([TooBigResponseException], [type(r) for r in responses]) self.assertEquals(1024, responses[0].args[0]) self.assertEquals(1, len(get_requests)) self.assertEquals('GET', get_requests[0]['command']) def testHttpAndHttpsGetStreaming(self): for useSsl in [False, True]: get_request = [] port = PortNumberGenerator.next() streamingData = StreamingData( data=[c for c in "STREAMING GET RESPONSE"]) self.referenceHttpServer(port,
def setUp(self): SeecrTestCase.setUp(self) harvesterData = CallTrace(returnValues={'getDomainIds':['d1', 'd2', 'd3', 'd4', 'd5']}) with stdout_replaced() as out: self.result = initializeUserGroupManagement(self.tempdir, harvesterData) self.sysout = out.getvalue()
def testParseHtmlAsXml(self): with stdout_replaced(): self.assertRaises(XMLSyntaxError, parseHtmlAsXml, b'<not xml>') result = parseHtmlAsXml(b'<html><body>‘to the left ←’</body></html>') self.assertEqual(['‘to the left <-’'], result.xpath('/html/body/text()'))