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 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 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 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 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()'))
