def test_warningToFile(self): """ L{twisted.python.log.showwarning} passes warnings with an explicit file target on to the underlying Python warning system. """ message = "another unique message" category = FakeWarning filename = "warning-filename.py" lineno = 31 output = StringIO() log.showwarning(message, category, filename, lineno, file=output) self.assertEqual( output.getvalue(), warnings.formatwarning(message, category, filename, lineno)) # In Python 2.6 and higher, warnings.showwarning accepts # a "line" argument which gives the source line the warning # message is to include. line = "hello world" output = StringIO() log.showwarning(message, category, filename, lineno, file=output, line=line) self.assertEqual( output.getvalue(), warnings.formatwarning(message, category, filename, lineno, line))
def test_reporter(self): """ Test for LimitedReporter. Use test file of indentation to test whether limited messages are returned when using LimitedReporter. Complete run on the test file will return two warnings: W0311 and W0312, but with limited report it returns only one. """ moduleTestIndentation = "twistedchecker.functionaltests.indentation" pathTestIndentation = os.path.join(twistedchecker.abspath, "functionaltests", "indentation.py") # assert the test file exists self.assertTrue(os.path.exists(pathTestIndentation)) streamTestResult = NativeStringIO() runner = Runner() runner.setOutput(streamTestResult) # defaultly, runner will use LimitedReporter as its output reporter # set allowed messages for it runner.linter.reporter.messagesAllowed = set(["W0311"]) exitResult = self.assertRaises( SystemExit, runner.run, [moduleTestIndentation]) # check the results to see only W0311 is reported resultTest = streamTestResult.getvalue() self.assertTrue("W0311" in resultTest) self.assertTrue("W0312" not in resultTest) self.assertEqual(4, exitResult.code)
def test_warningToFile(self): """ L{twisted.python.log.showwarning} passes warnings with an explicit file target on to the underlying Python warning system. """ # log.showwarning depends on _oldshowwarning being set, which only # happens in startLogging(), which doesn't happen if you're not # running under trial. So this test only passes by accident of runner # environment. if log._oldshowwarning is None: raise unittest.SkipTest("Currently this test only runs under trial.") message = "another unique message" category = FakeWarning filename = "warning-filename.py" lineno = 31 output = StringIO() log.showwarning(message, category, filename, lineno, file=output) self.assertEqual( output.getvalue(), warnings.formatwarning(message, category, filename, lineno)) # In Python 2.6, warnings.showwarning accepts a "line" argument which # gives the source line the warning message is to include. if sys.version_info >= (2, 6): line = "hello world" output = StringIO() log.showwarning(message, category, filename, lineno, file=output, line=line) self.assertEqual( output.getvalue(), warnings.formatwarning(message, category, filename, lineno, line))
def test_emitPrefix(self): """ FileLogObserver.emit() will add a timestamp and system prefix to its file output. """ output = StringIO() flo = log.FileLogObserver(output) events = [] def observer(event): # Capture the event for reference and pass it along to flo events.append(event) flo.emit(event) publisher = log.LogPublisher() publisher.addObserver(observer) publisher.msg("Hello!") self.assertEqual(len(events), 1) event = events[0] result = output.getvalue() prefix = "{time} [{system}] ".format( time=flo.formatTime(event["time"]), system=event["system"], ) self.assertTrue( result.startswith(prefix), "{0!r} does not start with {1!r}".format(result, prefix) )
def test_startLogging(self): """ startLogging() installs FileLogObserver and overrides sys.stdout and sys.stderr. """ origStdout, origStderr = sys.stdout, sys.stderr self._startLoggingCleanup() # When done with test, reset stdout and stderr to current values: fakeFile = StringIO() observer = log.startLogging(fakeFile) self.addCleanup(observer.stop) log.msg("Hello!") self.assertIn("Hello!", fakeFile.getvalue()) self.assertIsInstance(sys.stdout, LoggingFile) self.assertEqual(sys.stdout.level, NewLogLevel.info) encoding = getattr(origStdout, "encoding", None) if not encoding: encoding = sys.getdefaultencoding() self.assertEqual(sys.stdout.encoding.upper(), encoding.upper()) self.assertIsInstance(sys.stderr, LoggingFile) self.assertEqual(sys.stderr.level, NewLogLevel.error) encoding = getattr(origStderr, "encoding", None) if not encoding: encoding = sys.getdefaultencoding() self.assertEqual(sys.stderr.encoding.upper(), encoding.upper())
def test_removeSafelyRemoveFailsMoveSucceeds(self): """ If an L{OSError} is raised while removing a path in L{util._removeSafely}, an attempt is made to move the path to a new name. """ def dummyRemove(): """ Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path removal fails. """ raise OSError() # Patch stdout so we can check the print statements in _removeSafely out = NativeStringIO() self.patch(sys, 'stdout', out) # Set up a trial directory with a _trial_marker directory = self.mktemp().encode("utf-8") os.mkdir(directory) dirPath = filepath.FilePath(directory) dirPath.child(b'_trial_marker').touch() # Ensure that path.remove() raises an OSError dirPath.remove = dummyRemove util._removeSafely(dirPath) self.assertIn("could not remove FilePath", out.getvalue())
def render(self, request): """ Render me to a web client. Load my file, execute it in a special namespace (with 'request' and '__file__' global vars) and finish the request. Output to the web-page will NOT be handled with print - standard output goes to the log - but with request.write. """ request.setHeader(b"x-powered-by", networkString("Twisted/%s" % copyright.version)) namespace = {'request': request, '__file__': _coerceToFilesystemEncoding("", self.filename), 'registry': self.registry} try: execfile(self.filename, namespace, namespace) except IOError as e: if e.errno == 2: #file not found request.setResponseCode(http.NOT_FOUND) request.write(resource.NoResource("File not found.").render(request)) except: io = NativeStringIO() traceback.print_exc(file=io) output = util._PRE(io.getvalue()) if _PY3: output = output.encode("utf8") request.write(output) request.finish() return server.NOT_DONE_YET
def setUp(self): """ Add our example directory to the path and record which modules are currently loaded. """ self.originalPath = sys.path[:] self.originalModules = sys.modules.copy() # Python usually expects native strs to be written to sys.stdout/stderr self.fakeErr = NativeStringIO() self.patch(sys, 'stderr', self.fakeErr) self.fakeOut = NativeStringIO() self.patch(sys, 'stdout', self.fakeOut) # Get documentation root here = ( FilePath(__file__) .parent().parent().parent().parent() .child('docs') ) # Find the example script within this branch for childName in self.exampleRelativePath.split('/'): here = here.child(childName) if not here.exists(): raise SkipTest( "Examples (%s) not found - cannot test" % (here.path,)) self.examplePath = here # Add the example parent folder to the Python path sys.path.append(self.examplePath.parent().path) # Import the example as a module moduleName = self.examplePath.basename().split('.')[0] self.example = __import__(moduleName)
def test_insufficient_args(self): """ Calling run() with no args will cause it to print help. """ stringio = NativeStringIO() self.patch(sys, 'stdout', stringio) self.patch(os, 'getcwd', self.getcwd) self.patch(datetime, 'date', self.date) with self.assertRaises(SystemExit) as e: run(["inctestpkg", "--rc"]) self.assertEqual(e.exception.args[0], 0) self.assertIn("Updating codebase", stringio.getvalue()) self.assertEqual(self.packagedir.child("_version.py").getContent(), b'''""" Provides inctestpkg version information. """ # This file is auto-generated! Do not edit! # Use `python -m incremental.update inctestpkg` to change this file. from incremental import Version __version__ = Version('inctestpkg', 16, 8, 0, release_candidate=1) __all__ = ["__version__"] ''') self.assertEqual(self.packagedir.child("__init__.py").getContent(), b""" from incremental import Version introduced_in = Version('inctestpkg', 16, 8, 0, release_candidate=1).short() next_released_version = "inctestpkg 16.8.0rc1" """)
def test_startLogging(self): """ startLogging() installs FileLogObserver and overrides sys.stdout and sys.stderr. """ origStdout, origStderr = sys.stdout, sys.stderr self._startLoggingCleanup() # When done with test, reset stdout and stderr to current values: fakeFile = StringIO() observer = log.startLogging(fakeFile) self.addCleanup(observer.stop) log.msg("Hello!") self.assertIn("Hello!", fakeFile.getvalue()) self.assertIsInstance(sys.stdout, log.StdioOnnaStick) self.assertEqual(sys.stdout.isError, False) encoding = getattr(origStdout, "encoding", None) if not encoding: encoding = sys.getdefaultencoding() self.assertEqual(sys.stdout.encoding, encoding) self.assertIsInstance(sys.stderr, log.StdioOnnaStick) self.assertEqual(sys.stderr.isError, True) encoding = getattr(origStderr, "encoding", None) if not encoding: encoding = sys.getdefaultencoding() self.assertEqual(sys.stderr.encoding, encoding)
def setUp(self): """ Redirect stdout to a temp C{StringIO} stream. """ self.outputStream = NativeStringIO() self.patch(sys, "stdout", self.outputStream) self.errorStream = NativeStringIO() self.patch(sys, "stderr", self.errorStream)
def test_writeResults(self): """ L{DistTrialRunner.writeResults} writes to the stream specified in the init. """ stringIO = StringIO() result = DistReporter(Reporter(stringIO)) self.runner.writeResults(result) self.assertTrue(stringIO.tell() > 0)
def dump(): if not self._passed: dump = NativeStringIO() print("FAILED! dumping build db for debug", file=dump) builds = yield self.master.data.get(("builds",)) for build in builds: yield self.printBuild(build, dump, withLogs=True) raise self.failureException(dump.getvalue())
def test_suppresses(self): """ Any warnings emitted by a call to a function passed to L{_collectWarnings} are not actually emitted to the warning system. """ output = StringIO() self.patch(sys, 'stdout', output) _collectWarnings(lambda x: None, warnings.warn, "text") self.assertEqual(output.getvalue(), "")
def mocked_open(*args, **kwargs): """ Mock for the open call to prevent actually opening a log file. """ open_calls.append((args, kwargs)) io = NativeStringIO() io.name = args[0] open_rvalues.append(io) return io
def test_twisted_import(self): """Importing twisted.__main__ does not execute twist.""" output = StringIO() monkey = self.patch(sys, 'stdout', output) import twisted.__main__ self.assertTrue(twisted.__main__) # Appease pyflakes monkey.restore() self.assertEqual(output.getvalue(), "")
def test_run_bad(self): self.patch(sys, 'argv', ['buildbot', 'my', '-l']) stdout = NativeStringIO() self.patch(sys, 'stdout', stdout) try: runner.run() except SystemExit as e: self.assertEqual(e.args[0], 1) else: self.fail("didn't exit") self.assertIn('THIS IS ME', stdout.getvalue())
def test_exitMessageZero(self): """ L{exit} given a status code of zero (C{0}) writes the given message to standard output. """ out = NativeStringIO() self.patch(_exit, "stdout", out) message = "Hello, world." exit(0, message) self.assertEqual(out.getvalue(), message + "\n")
def test_printingCapturedVarsCleanedSmokeTest(self): """ C{printDetailedTraceback} includes information about local variables on the stack after C{cleanFailure} has been called. """ exampleLocalVar = 'xyzzy' f = getDivisionFailure(captureVars=True) f.cleanFailure() out = NativeStringIO() f.printDetailedTraceback(out) self.assertNotEqual(None, re.search('exampleLocalVar.*xyzzy', out.getvalue()))
def test_exitMessageNonZero(self): """ L{exit} given a non-zero status code writes the given message to standard error. """ out = NativeStringIO() self.patch(_exit, "stderr", out) message = "Hello, world." exit(64, message) self.assertEqual(out.getvalue(), message + "\n")
def test_run(self): """ Calling run() with no args will cause it to print help. """ stringio = NativeStringIO() self.patch(sys, 'stdout', stringio) with self.assertRaises(SystemExit) as e: run(["--help"]) self.assertEqual(e.exception.args[0], 0) self.assertIn("Show this message and exit", stringio.getvalue())
def test_flushed(self): """ Any warnings emitted by a test which are flushed are not emitted to the Python warning system. """ result = TestResult() case = Mask.MockTests('test_flushed') output = StringIO() monkey = self.patch(sys, 'stdout', output) case.run(result) monkey.restore() self.assertEqual(output.getvalue(), "")
def runTrial(*args): from twisted.trial import reporter config = trial.Options() config.parseOptions(args) output = NativeStringIO() myRunner = runner.TrialRunner( reporter.VerboseTextReporter, stream=output, workingDirectory=config['temp-directory']) suite = trial._getSuite(config) myRunner.run(suite) return output.getvalue()
def test_printingCaptureVars(self): """ Calling C{Failure(captureVars=True)} captures the locals and globals for its stack frames, so L{printDetailedTraceback} will show them in its output. """ out = NativeStringIO() f = getDivisionFailure(captureVars=True) f.printDetailedTraceback(out) # Variables are printed on lines with 2 leading spaces. linesWithVars = [line for line in out.getvalue().splitlines() if line.startswith(' ')] self.assertNotEqual([], linesWithVars)
def _safeFormat(formatter, o): """ Helper function for L{safe_repr} and L{safe_str}. """ try: return formatter(o) except: io = NativeStringIO() traceback.print_exc(file=io) className = _determineClassName(o) tbValue = io.getvalue() return "<%s instance at 0x%x with %s error:\n %s>" % ( className, id(o), formatter.__name__, tbValue)
def test_startLoggingOverridesWarning(self): """ startLogging() overrides global C{warnings.showwarning} such that warnings go to Twisted log observers. """ self._startLoggingCleanup() # Ugggh, pretend we're starting from newly imported module: log._oldshowwarning = None fakeFile = StringIO() observer = log.startLogging(fakeFile) self.addCleanup(observer.stop) warnings.warn("hello!") output = fakeFile.getvalue() self.assertIn("UserWarning: hello!", output)
def UL(lst): io = StringIO() io.write("<ul>\n") for el in lst: io.write("<li> %s</li>\n" % el) io.write("</ul>") return io.getvalue()
def linkList(lst): io = StringIO() io.write("<ul>\n") for hr, el in lst: io.write('<li> <a href="%s">%s</a></li>\n' % (hr, el)) io.write("</ul>") return io.getvalue()
def test_startLoggingOverridesWarning(self): """ startLogging() overrides global C{warnings.showwarning} such that warnings go to Twisted log observers. """ self._startLoggingCleanup() newPublisher = NewLogPublisher() class SysModule(object): stdout = object() stderr = object() tempLogPublisher = LogPublisher( newPublisher, newPublisher, logBeginner=LogBeginner(newPublisher, StringIO(), SysModule, warnings) ) # Trial reports warnings in two ways. First, it intercepts the global # 'showwarning' function *itself*, after starting logging (by way of # the '_collectWarnings' function which collects all warnings as a # around the test's 'run' method). Second, it has a log observer which # immediately reports warnings when they're propagated into the log # system (which, in normal operation, happens only at the end of the # test case). In order to avoid printing a spurious warning in this # test, we first replace the global log publisher's 'showwarning' in # the module with our own. self.patch(log, "theLogPublisher", tempLogPublisher) # And, one last thing, pretend we're starting from a fresh import, or # warnings.warn won't be patched at all. log._oldshowwarning = None # Global mutable state is bad, kids. Stay in school. fakeFile = StringIO() # We didn't previously save log messages, so let's make sure we don't # save them any more. evt = {"pre-start": "event"} received = [] def preStartObserver(x): if 'pre-start' in x.keys(): received.append(x) newPublisher(evt) newPublisher.addObserver(preStartObserver) log.startLogging(fakeFile, setStdout=False) self.addCleanup(tempLogPublisher._stopLogging) self.assertEqual(received, []) warnings.warn("hello!") output = fakeFile.getvalue() self.assertIn("UserWarning: hello!", output)
def test_testmoduleOnModuleName(self): """ Check that --testmodule does *not* support module names as arguments and that it displays a meaningful error message. """ buffy = NativeStringIO() stderr, sys.stderr = sys.stderr, buffy moduleName = 'twisted.trial.test.test_script' try: self.config.opt_testmodule(moduleName) self.assertEqual(0, len(self.config['tests'])) self.assertEqual("File %r doesn't exist\n" % (moduleName,), buffy.getvalue()) finally: sys.stderr = stderr
def parseOptions(argv): o = Options() o.to = [e for e in argv if not e.startswith('-')] o.sender = getlogin() # Just be very stupid # Skip -bm -- it is the default # Add a non-standard option for querying the version of this tool. if '--version' in argv: print('mailmail version:', version) raise SystemExit() # -bp lists queue information. Screw that. if '-bp' in argv: raise _unsupportedOption # -bs makes sendmail use stdin/stdout as its transport. Screw that. if '-bs' in argv: raise _unsupportedOption # -F sets who the mail is from, but is overridable by the From header if '-F' in argv: o.sender = argv[argv.index('-F') + 1] o.to.remove(o.sender) # -i and -oi makes us ignore lone "." if ('-i' in argv) or ('-oi' in argv): raise _unsupportedOption # -odb is background delivery if '-odb' in argv: o.background = True else: o.background = False # -odf is foreground delivery if '-odf' in argv: o.background = False else: o.background = True # -oem and -em cause errors to be mailed back to the sender. # It is also the default. # -oep and -ep cause errors to be printed to stderr if ('-oep' in argv) or ('-ep' in argv): o.printErrors = True else: o.printErrors = False # -om causes a copy of the message to be sent to the sender if the sender # appears in an alias expansion. We do not support aliases. if '-om' in argv: raise _unsupportedOption # -t causes us to pick the recipients of the message from # the To, Cc, and Bcc headers, and to remove the Bcc header # if present. if '-t' in argv: o.recipientsFromHeaders = True o.excludeAddresses = o.to o.to = [] else: o.recipientsFromHeaders = False o.exludeAddresses = [] requiredHeaders = { 'from': [], 'to': [], 'cc': [], 'bcc': [], 'date': [], } buffer = NativeStringIO() while 1: write = 1 line = sys.stdin.readline() if not line.strip(): break hdrs = line.split(': ', 1) hdr = hdrs[0].lower() if o.recipientsFromHeaders and hdr in ('to', 'cc', 'bcc'): o.to.extend([email.utils.parseaddr(hdrs[1])[1]]) if hdr == 'bcc': write = 0 elif hdr == 'from': o.sender = email.utils.parseaddr(hdrs[1])[1] if hdr in requiredHeaders: requiredHeaders[hdr].append(hdrs[1]) if write: buffer.write(line) if not requiredHeaders['from']: buffer.write('From: {}\r\n'.format(o.sender)) if not requiredHeaders['to']: if not o.to: raise SystemExit("No recipients specified.") buffer.write('To: {}\r\n'.format(', '.join(o.to))) if not requiredHeaders['date']: buffer.write('Date: {}\r\n'.format(smtp.rfc822date())) buffer.write(line) if o.recipientsFromHeaders: for a in o.excludeAddresses: try: o.to.remove(a) except: pass buffer.seek(0, 0) o.body = NativeStringIO(buffer.getvalue() + sys.stdin.read()) return o
def createSummary(self, log): for line in NativeStringIO(log.getText()): # what we do with the line isn't important to the test assert line in ('some\n', 'output\n')
def _fork(self, path, uid, gid, executable, args, environment, **kwargs): """ Fork and then exec sub-process. @param path: the path where to run the new process. @type path: C{str} @param uid: if defined, the uid used to run the new process. @type uid: C{int} @param gid: if defined, the gid used to run the new process. @type gid: C{int} @param executable: the executable to run in a new process. @type executable: C{str} @param args: arguments used to create the new process. @type args: C{list}. @param environment: environment used for the new process. @type environment: C{dict}. @param kwargs: keyword arguments to L{_setupChild} method. """ collectorEnabled = gc.isenabled() gc.disable() try: self.pid = os.fork() except: # Still in the parent process if collectorEnabled: gc.enable() raise else: if self.pid == 0: # pid is 0 in the child process # do not put *ANY* code outside the try block. The child process # must either exec or _exit. If it gets outside this block (due # to an exception that is not handled here, but which might be # handled higher up), there will be two copies of the parent # running in parallel, doing all kinds of damage. # After each change to this code, review it to make sure there # are no exit paths. try: # Stop debugging. If I am, I don't care anymore. sys.settrace(None) self._setupChild(**kwargs) self._execChild( path, uid, gid, executable, args, environment) except: # If there are errors, bail and try to write something # descriptive to stderr. # XXX: The parent's stderr isn't necessarily fd 2 anymore, or # even still available # XXXX: however even libc assumes write(2, err) is a useful # thing to attempt try: stderr = os.fdopen(2, 'wb') msg = ("Upon execvpe {0} {1} in environment id {2}" "\n:").format(executable, str(args), id(environment)) tb = NativeStringIO() traceback.print_exc(file=tb) tb = tb.getvalue() if _PY3: msg = msg.encode(sys.getfilesystemencoding()) tb = tb.encode(sys.getfilesystemencoding()) stderr.write(msg) stderr.write(tb) stderr.flush() for fd in xrange(3): os.close(fd) except: pass # make *sure* the child terminates # Did you read the comment about not adding code here? os._exit(1) # we are now in parent process if collectorEnabled: gc.enable() self.status = -1 # this records the exit status of the child
def setUp(self): """ Setup our test case """ self.result = reporter.Reporter(NativeStringIO()) self.loader = runner.TestLoader()
def getHTMLOf(ob): wr = templatewriter.TemplateWriter('') wr.system = ob.system f = NativeStringIO() wr.writeDocsForOne(ob, f) return f.getvalue()
class ExampleTestBase(object): """ This is a mixin which adds an example to the path, tests it, and then removes it from the path and unimports the modules which the test loaded. Test cases which test example code and documentation listings should use this. This is done this way so that examples can live in isolated path entries, next to the documentation, replete with their own plugin packages and whatever other metadata they need. Also, example code is a rare instance of it being valid to have multiple versions of the same code in the repository at once, rather than relying on version control, because documentation will often show the progression of a single piece of code as features are added to it, and we want to test each one. """ def setUp(self): """ Add our example directory to the path and record which modules are currently loaded. """ self.originalPath = sys.path[:] self.originalModules = sys.modules.copy() # Python usually expects native strs to be written to sys.stdout/stderr self.fakeErr = NativeStringIO() self.patch(sys, 'stderr', self.fakeErr) self.fakeOut = NativeStringIO() self.patch(sys, 'stdout', self.fakeOut) # Get documentation root here = (FilePath(__file__).parent().parent().parent().parent().child( 'docs')) # Find the example script within this branch for childName in self.exampleRelativePath.split('/'): here = here.child(childName) if not here.exists(): raise SkipTest("Examples (%s) not found - cannot test" % (here.path, )) self.examplePath = here # Add the example parent folder to the Python path sys.path.append(self.examplePath.parent().path) # Import the example as a module moduleName = self.examplePath.basename().split('.')[0] self.example = __import__(moduleName) def tearDown(self): """ Remove the example directory from the path and remove all modules loaded by the test from sys.modules. """ sys.modules.clear() sys.modules.update(self.originalModules) sys.path[:] = self.originalPath def test_shebang(self): """ The example scripts start with the standard shebang line. """ self.assertEqual(self.examplePath.open().readline().rstrip(), b'#!/usr/bin/env python') def test_usageConsistency(self): """ The example script prints a usage message to stdout if it is passed a --help option and then exits. The first line should contain a USAGE summary, explaining the accepted command arguments. """ # Pass None as first parameter - the reactor - it shouldn't # get as far as calling it. self.assertRaises(SystemExit, self.example.main, None, '--help') out = self.fakeOut.getvalue().splitlines() self.assertTrue( out[0].startswith('Usage:'), 'Usage message first line should start with "Usage:". ' 'Actual: %r' % (out[0], )) def test_usageConsistencyOnError(self): """ The example script prints a usage message to stderr if it is passed unrecognized command line arguments. The first line should contain a USAGE summary, explaining the accepted command arguments. The last line should contain an ERROR summary, explaining that incorrect arguments were supplied. """ # Pass None as first parameter - the reactor - it shouldn't # get as far as calling it. self.assertRaises(SystemExit, self.example.main, None, '--unexpected_argument') err = self.fakeErr.getvalue().splitlines() self.assertTrue( err[0].startswith('Usage:'), 'Usage message first line should start with "Usage:". ' 'Actual: %r' % (err[0], )) self.assertTrue( err[-1].startswith('ERROR:'), 'Usage message last line should start with "ERROR:" ' 'Actual: %r' % (err[-1], ))
def mocked_open(*args, **kwargs): """ Mock for the open call to prevent actually opening /proc/net/tcp. """ open_calls.append((args, kwargs)) return NativeStringIO(self.sampleFile)
def setUpStdoutAssertions(self): self.stdout = NativeStringIO() self.patch(sys, 'stdout', self.stdout)
def test_parseJob_empty(self): sched = trysched.Try_Jobdir(name='tsched', builderNames=['a'], jobdir='foo') with self.assertRaises(trysched.BadJobfile): sched.parseJob(NativeStringIO(''))
def setUp(self): self.output = NativeStringIO() self.reporter = reporter.TestResult() self.loader = runner.TestLoader()
def readlines(self): alltext = "".join(self.getChunks([self.STDOUT], onlyText=True)) io = NativeStringIO(alltext) return io.readlines()
def setUp(self): self.stream = NativeStringIO() self.runner = runner.TrialRunner(CapturingReporter, stream=self.stream, uncleanWarnings=True) self.test = TrialRunnerTests('test_empty')
def setUp(self): UntilFailureTests.FailAfter.count = [] self.test = UntilFailureTests.FailAfter('test_foo') self.stream = NativeStringIO() self.runner = runner.TrialRunner(reporter.Reporter, stream=self.stream)
def setUp(self): self.result = reporter.Reporter(NativeStringIO()) self.loader = runner.TestLoader()
def flatten(t): io = NativeStringIO() writer.flattenToFile(io, t) return io.getvalue()
class OptionsTests(TestCase): """ Tests for L{parseOptions} which parses command line arguments and reads message text from stdin to produce an L{Options} instance which can be used to send a message. """ memoryReactor = MemoryReactor() def setUp(self): """ Override some things in mailmail, so that we capture C{stdout}, and do not call L{reactor.stop}. """ self.out = NativeStringIO() # Override the mailmail logger, so we capture stderr output from twisted.logger import textFileLogObserver, Logger logObserver = textFileLogObserver(self.out) self.patch(mailmail, '_log', Logger(observer=logObserver)) self.host = None self.options = None self.ident = None # Override mailmail.sendmail, so we don't call reactor.stop() def sendmail(host, options, ident): self.host = host self.options = options self.ident = ident return smtp.sendmail(host, options.sender, options.to, options.body, reactor=self.memoryReactor) self.patch(mailmail, 'sendmail', sendmail) def test_unspecifiedRecipients(self): """ If no recipients are given in the argument list and there is no recipient header in the message text, L{parseOptions} raises L{SystemExit} with a string describing the problem. """ self.patch(sys, 'stdin', NativeStringIO('Subject: foo\n' '\n' 'Hello, goodbye.\n')) exc = self.assertRaises(SystemExit, parseOptions, []) self.assertEqual(exc.args, ('No recipients specified.', )) def test_listQueueInformation(self): """ The I{-bp} option for listing queue information is unsupported and if it is passed to L{parseOptions}, L{SystemExit} is raised. """ exc = self.assertRaises(SystemExit, parseOptions, ['-bp']) self.assertEqual(exc.args, ("Unsupported option.", )) def test_stdioTransport(self): """ The I{-bs} option for using stdin and stdout as the SMTP transport is unsupported and if it is passed to L{parseOptions}, L{SystemExit} is raised. """ exc = self.assertRaises(SystemExit, parseOptions, ['-bs']) self.assertEqual(exc.args, ("Unsupported option.", )) def test_ignoreFullStop(self): """ The I{-i} and I{-oi} options for ignoring C{"."} by itself on a line are unsupported and if either is passed to L{parseOptions}, L{SystemExit} is raised. """ exc = self.assertRaises(SystemExit, parseOptions, ['-i']) self.assertEqual(exc.args, ("Unsupported option.", )) exc = self.assertRaises(SystemExit, parseOptions, ['-oi']) self.assertEqual(exc.args, ("Unsupported option.", )) def test_copyAliasedSender(self): """ The I{-om} option for copying the sender if they appear in an alias expansion is unsupported and if it is passed to L{parseOptions}, L{SystemExit} is raised. """ exc = self.assertRaises(SystemExit, parseOptions, ['-om']) self.assertEqual(exc.args, ("Unsupported option.", )) def test_version(self): """ The I{--version} option displays the version and raises L{SystemExit} with L{None} as the exit code. """ out = NativeStringIO() self.patch(sys, 'stdout', out) systemExitCode = self.assertRaises(SystemExit, parseOptions, '--version') # SystemExit.code is None on success self.assertEqual(systemExitCode.code, None) data = out.getvalue() self.assertEqual(data, "mailmail version: {}\n".format(version)) def test_backgroundDelivery(self): """ The I{-odb} flag specifies background delivery. """ stdin = NativeStringIO('\n') self.patch(sys, 'stdin', stdin) o = parseOptions("-odb") self.assertTrue(o.background) def test_foregroundDelivery(self): """ The I{-odf} flags specifies foreground delivery. """ stdin = NativeStringIO('\n') self.patch(sys, 'stdin', stdin) o = parseOptions("-odf") self.assertFalse(o.background) def test_recipientsFromHeaders(self): """ The I{-t} flags specifies that recipients should be obtained from headers. """ stdin = NativeStringIO('To: Curly <*****@*****.**>\n' 'Cc: Larry <*****@*****.**>\n' 'Bcc: Moe <*****@*****.**>\n' '\n' 'Oh, a wise guy?\n') self.patch(sys, 'stdin', stdin) o = parseOptions("-t") self.assertEqual(len(o.to), 3) def test_setFrom(self): """ When a message has no I{From:} header, a I{From:} value can be specified with the I{-F} flag. """ stdin = NativeStringIO('To: [email protected]\n' 'Subject: A wise guy?\n\n') self.patch(sys, 'stdin', stdin) o = parseOptions(["-F", "Larry <*****@*****.**>", "-t"]) self.assertEqual(o.sender, "Larry <*****@*****.**>") def test_overrideFromFlagByFromHeader(self): """ The I{-F} flag specifies the From: value. However, I{-F} flag is overriden by the value of From: in the e-mail header. """ stdin = NativeStringIO('To: Curly <*****@*****.**>\n' 'From: Shemp <*****@*****.**>\n') self.patch(sys, 'stdin', stdin) o = parseOptions(["-F", "Groucho <*****@*****.**>", "-t"]) self.assertEqual(o.sender, "*****@*****.**") @skipIf(platformType == "win32", "mailmail.run() does not work on win32 due to lack of support for" " getuid()") def test_runErrorsToStderr(self): """ Call L{mailmail.run}, and specify I{-oep} to print errors to stderr. The sender, to, and printErrors options should be set and there should be no failure. """ argv = ("test_mailmail.py", "*****@*****.**", "-oep") stdin = NativeStringIO('\n') self.patch(sys, 'argv', argv) self.patch(sys, 'stdin', stdin) mailmail.run() self.assertEqual(self.options.sender, mailmail.getlogin()) self.assertEqual(self.options.to, ["*****@*****.**"]) # We should have printErrors set because we specified "-oep" self.assertTrue(self.options.printErrors) # We should not have any failures. self.assertIsNone(mailmail.failed) @skipIf(platformType == "win32", "mailmail.run() does not work on win32 due to lack of support for" " getuid()") def test_readInvalidConfig(self): """ Error messages for illegal UID value, illegal GID value, and illegal identity entry will be sent to stderr. """ stdin = NativeStringIO('\n') self.patch(sys, 'stdin', stdin) filename = self.mktemp() myUid = os.getuid() myGid = os.getgid() with open(filename, "w") as f: # Create a config file with some invalid values f.write("[useraccess]\n" "allow=invaliduser2,invaliduser1\n" "deny=invaliduser3,invaliduser4,{}\n" "order=allow,deny\n" "[groupaccess]\n" "allow=invalidgid1,invalidgid2\n" "deny=invalidgid1,invalidgid2,{}\n" "order=deny,allow\n" "[identity]\n" "localhost=funny\n" "[addresses]\n" "smarthost=localhost\n" "default_domain=example.com\n".format(myUid, myGid)) # The mailmail script looks in # the twisted.mail.scripts.GLOBAL_CFG variable # and then the twisted.mail.scripts.LOCAL_CFG # variable for the path to it's config file. # # Override twisted.mail.scripts.LOCAL_CFG with the file we just # created. self.patch(mailmail, "LOCAL_CFG", filename) argv = ("test_mailmail.py", "*****@*****.**", "-oep") self.patch(sys, 'argv', argv) mailmail.run() self.assertRegex( self.out.getvalue(), "Illegal UID in \\[useraccess\\] section: " "invaliduser1") self.assertRegex( self.out.getvalue(), "Illegal GID in \\[groupaccess\\] section: " "invalidgid1") self.assertRegex(self.out.getvalue(), 'Illegal entry in \\[identity\\] section: funny') def getConfigFromFile(self, config): """ Read a mailmail configuration file. The mailmail script checks the twisted.mail.scripts.mailmail.GLOBAL_CFG variable and then the twisted.mail.scripts.mailmail.LOCAL_CFG variable for the path to its config file. @param config: path to config file @type config: L{str} @return: A parsed config. @rtype: L{twisted.mail.scripts.mailmail.Configuration} """ from twisted.mail.scripts.mailmail import loadConfig filename = self.mktemp() with open(filename, "w") as f: f.write(config) return loadConfig(filename) def test_loadConfig(self): """ L{twisted.mail.scripts.mailmail.loadConfig} parses the config file for mailmail. """ config = self.getConfigFromFile(""" [addresses] smarthost=localhost""") self.assertEqual(config.smarthost, "localhost") config = self.getConfigFromFile(""" [addresses] default_domain=example.com""") self.assertEqual(config.domain, "example.com") config = self.getConfigFromFile(""" [addresses] smarthost=localhost default_domain=example.com""") self.assertEqual(config.smarthost, "localhost") self.assertEqual(config.domain, "example.com") config = self.getConfigFromFile(""" [identity] host1=invalid host2=username:password""") self.assertNotIn("host1", config.identities) self.assertEqual(config.identities["host2"], ["username", "password"]) config = self.getConfigFromFile(""" [useraccess] allow=invalid1,35 order=allow""") self.assertEqual(config.allowUIDs, [35]) config = self.getConfigFromFile(""" [useraccess] deny=35,36 order=deny""") self.assertEqual(config.denyUIDs, [35, 36]) config = self.getConfigFromFile(""" [useraccess] allow=35,36 deny=37,38 order=deny""") self.assertEqual(config.allowUIDs, [35, 36]) self.assertEqual(config.denyUIDs, [37, 38]) config = self.getConfigFromFile(""" [groupaccess] allow=gid1,41 order=allow""") self.assertEqual(config.allowGIDs, [41]) config = self.getConfigFromFile(""" [groupaccess] deny=41 order=deny""") self.assertEqual(config.denyGIDs, [41]) config = self.getConfigFromFile(""" [groupaccess] allow=41,42 deny=43,44 order=allow,deny""") self.assertEqual(config.allowGIDs, [41, 42]) self.assertEqual(config.denyGIDs, [43, 44]) def test_senderror(self): """ L{twisted.mail.scripts.mailmail.senderror} sends mail back to the sender if an error occurs while sending mail to the recipient. """ def sendmail(host, sender, recipient, body): self.assertRegex(sender, "postmaster@") self.assertEqual(recipient, ["testsender"]) self.assertRegex(body.getvalue(), "ValueError") return Deferred() self.patch(smtp, "sendmail", sendmail) opts = mailmail.Options() opts.sender = "testsender" fail = Failure(ValueError()) mailmail.senderror(fail, opts)
def __repr__(self): from pprint import pprint sio = NativeStringIO() pprint(self._adapterCache, sio) return sio.getvalue()
def setUp(self): self.stream = StringIO() self.distReporter = DistReporter(TreeReporter(self.stream)) self.test = TestCase()
def __init__(self): self.s = NativeStringIO()
def test_parseJob_v5_invalid_json(self): sched = trysched.Try_Jobdir( name='tsched', builderNames=['buildera', 'builderb'], jobdir='foo') jobstr = self.makeNetstring('5', '{"comment": "com}') with self.assertRaises(trysched.BadJobfile): sched.parseJob(NativeStringIO(jobstr))
class SourceWriter(object): _i = 0 def __init__(self): self.s = NativeStringIO() def w(self, s): self.s.write(s) def nl(self): self.s.write('\n') self.s.write(' ' * 4 * self._i) def indent(self): self._i += 1 self.nl() def dedent(self): self._i -= 1 self.nl() def visitModule(self, node): if node.doc is not None: self.wl(repr(node.doc)) walk(node.node, self) def visitStmt(self, node): for n in node.getChildren(): walk(n, self) def _functionSignature(self, node, fmt): if node.defaults: nargs = len(node.argnames) ndefs = len(node.defaults) noDefaults = node.argnames[:nargs - ndefs] s = ', '.join(node.argnames[:noDefaults]) if ndefs < nargs: argdefs = zip(node.argnames[noDefaults:], node.defaults) s = s + ', ' + ', '.join(['='.join(x) for x in argdefs]) else: s = ', '.join(node.argnames) self.w(fmt % (s, )) def visitLambda(self, node): self._functionSignature(node, 'lambda %s: ') walk(node.code, self) def visitFunction(self, node): self._functionSignature(node, 'def %s(%%s):' % node.name) self.indent() try: walk(node.code, self) finally: self.dedent() def visitAssign(self, node): walk(node.nodes[0], self) self.w(' = ') walk(node.expr, self) self.nl() def visitAssName(self, node): self.w(node.name) def visitCallFunc(self, node): walk(node.node, self) self.w('(') for a in node.args[:-1]: walk(a, self) self.w(', ') for a in node.args[-1:]: walk(a, self) self.w(')') def visitListComp(self, node): self.w('[') walk(node.expr, self) for q in node.quals: walk(q, self) self.w(']') def visitList(self, node): self.w('[') for a in node.nodes[:-1]: walk(a, self) self.w(', ') for a in node.nodes[-1:]: walk(a, self) self.w(']') def visitSet(self, node): self.w('{') for a in node.nodes[:-1]: walk(a, self) self.w(', ') for a in node.nodes[-1:]: walk(a, self) self.w('}') def visitListCompFor(self, node): self.w(' for ') walk(node.assign, self) self.w(' in ') walk(node.list, self) for expr in node.ifs: self.w(' if ') walk(expr, self) def visitName(self, node): self.w(node.name) def visitDiscard(self, node): walk(node.expr, self) self.nl() def visitPrintnl(self, node): self.w('print ') if node.dest: self.w('>>') walk(node.dest, self) self.w(', ') for e in node.nodes: walk(e, self) self.nl() def visitGetattr(self, node): walk(node.expr, self) self.w('.') self.w(node.attrname) def visitImport(self, node): self.w('import ') for (mod, as_) in node.names: self.w(mod) if as_ is not None: self.w(' as ') self.w(as_) self.w(', ') self.nl() def visitFrom(self, node): self.w('from ') self.w(node.modname) self.w(' import ') for (mod, as_) in node.names: self.w(mod) if as_ is not None: self.w(' as ') self.w(as_) self.w(', ') self.nl() def visitConst(self, node): self.w(repr(node.value)) def visitReturn(self, node): self.w('return ') walk(node.value, self) self.nl() def visitClass(self, node): self.w('class ') self.w(node.name) if node.bases: self.w('(') for b in node.bases: walk(b, self) self.w(', ') self.w('):') self.indent() try: if node.doc is not None: self.w(repr(node.doc)) walk(node.code, self) finally: self.dedent() def visitAssAttr(self, node): walk(node.expr, self) self.w('.') self.w(node.attrname) def visitMul(self, node): walk(node.left, self) self.w(' * ') walk(node.right, self) def visitSub(self, node): walk(node.left, self) self.w(' - ') walk(node.right, self) def visitAdd(self, node): walk(node.left, self) self.w(' + ') walk(node.right, self) def visitPower(self, node): walk(node.left, self) self.w('**') walk(node.right, self) def visitMod(self, node): walk(node.left, self) self.w(' % ') walk(node.right, self) def visitAugAssign(self, node): walk(node.node, self) self.w(' ') self.w(node.op) self.w(' ') walk(node.expr, self) self.nl() def visitIf(self, node): keyword = 'if' for (cond, body) in node.tests: self.w(keyword) self.w(' ') walk(cond, self) self.w(':') self.indent() try: walk(body, self) finally: self.dedent() keyword = 'elif' if node.else_: self.w('else:') self.indent() try: walk(node.else_, self) finally: self.dedent() def visitCompare(self, node): walk(node.expr, self) for (op, arg) in node.ops: self.w(' ') self.w(op) self.w(' ') walk(arg, self) def visitFor(self, node): self.w('for ') walk(node.assign, self) self.w(' in ') walk(node.list, self) self.w(':') self.indent() try: walk(node.body, self) finally: self.dedent() if node.else_: self.w('else:') self.indent() try: walk(node.else_, self) finally: self.dedent() def visitSlice(self, node): walk(node.expr, self) self.w('[') if node.lower: walk(node.lower, self) self.w(':') if node.upper: walk(node.upper, self) self.w(']') def visitTuple(self, node): self.w('(') if len(node.nodes) == 0: pass elif len(node.nodes) == 1: walk(node.nodes[0], self) self.w(',') else: for expr in node.nodes[:-1]: walk(expr, self) self.w(', ') walk(node.nodes[-1], self) self.w(')') def visitTryFinally(self, node): self.w('try:') self.indent() try: walk(node.body, self) finally: self.dedent() self.w('finally:') self.indent() try: walk(node.final, self) finally: self.dedent() def visitSubscript(self, node): walk(node.expr, self) self.w('[') walk(node.subs[0], self) self.w(']') def visitUnarySub(self, node): self.w('-') walk(node.expr, self) def visitAssTuple(self, node): self.w('(') for expr in node.nodes: walk(expr, self) self.w(', ') self.w(')') def visitRaise(self, node): self.w('raise ') walk(node.expr1, self) if node.expr2: self.w(', ') walk(node.expr2, self) if node.expr3: self.w(', ') walk(node.expr3, self) self.nl() def visitDict(self, node): self.w('{') for (k, v) in node.items[:-1]: walk(k, self) self.w(':') walk(v, self) self.w(', ') for (k, v) in node.items[-1:]: walk(k, self) self.w(':') walk(v, self) self.w('}') def __str__(self): return self.s.getvalue()
def getTraceback(self, elideFrameworkCode=0, detail='default'): io = StringIO() self.printTraceback(file=io, elideFrameworkCode=elideFrameworkCode, detail=detail) return io.getvalue()
def assertDetailedTraceback(self, captureVars=False, cleanFailure=False): """ Assert that L{printDetailedTraceback} produces and prints a detailed traceback. The detailed traceback consists of a header:: *--- Failure #20 --- The body contains the stacktrace:: /twisted/trial/_synctest.py:1180: _run(...) /twisted/python/util.py:1076: runWithWarningsSuppressed(...) --- <exception caught here> --- /twisted/test/test_failure.py:39: getDivisionFailure(...) If C{captureVars} is enabled the body also includes a list of globals and locals:: [ Locals ] exampleLocalVar : 'xyz' ... ( Globals ) ... Or when C{captureVars} is disabled:: [Capture of Locals and Globals disabled (use captureVars=True)] When C{cleanFailure} is enabled references to other objects are removed and replaced with strings. And finally the footer with the L{Failure}'s value:: exceptions.ZeroDivisionError: float division *--- End of Failure #20 --- @param captureVars: Enables L{Failure.captureVars}. @type captureVars: C{bool} @param cleanFailure: Enables L{Failure.cleanFailure}. @type cleanFailure: C{bool} """ if captureVars: exampleLocalVar = 'xyz' f = getDivisionFailure(captureVars=captureVars) out = NativeStringIO() if cleanFailure: f.cleanFailure() f.printDetailedTraceback(out) tb = out.getvalue() start = "*--- Failure #%d%s---\n" % (f.count, (f.pickled and ' (pickled) ') or ' ') end = "%s: %s\n*--- End of Failure #%s ---\n" % (reflect.qual( f.type), reflect.safe_str(f.value), f.count) self.assertTracebackFormat(tb, start, end) # Variables are printed on lines with 2 leading spaces. linesWithVars = [ line for line in tb.splitlines() if line.startswith(' ') ] if captureVars: self.assertNotEqual([], linesWithVars) if cleanFailure: line = ' exampleLocalVar : "\'xyz\'"' else: line = " exampleLocalVar : 'xyz'" self.assertIn(line, linesWithVars) else: self.assertEqual([], linesWithVars) self.assertIn( ' [Capture of Locals and Globals disabled (use ' 'captureVars=True)]\n', tb)
def open(self, name): assert self.openFile is None, "open() called too many times" self.openFile = NativeStringIO() return self.openFile
class PythonLoggingObserverTestCase(unittest.SynchronousTestCase): """ Test the bridge with python logging module. """ def setUp(self): self.out = StringIO() rootLogger = logging.getLogger("") self.originalLevel = rootLogger.getEffectiveLevel() rootLogger.setLevel(logging.DEBUG) self.hdlr = logging.StreamHandler(self.out) fmt = logging.Formatter(logging.BASIC_FORMAT) self.hdlr.setFormatter(fmt) rootLogger.addHandler(self.hdlr) self.lp = log.LogPublisher() self.obs = log.PythonLoggingObserver() self.lp.addObserver(self.obs.emit) def tearDown(self): rootLogger = logging.getLogger("") rootLogger.removeHandler(self.hdlr) rootLogger.setLevel(self.originalLevel) logging.shutdown() def test_singleString(self): """ Test simple output, and default log level. """ self.lp.msg("Hello, world.") self.assertIn("Hello, world.", self.out.getvalue()) self.assertIn("INFO", self.out.getvalue()) def test_errorString(self): """ Test error output. """ self.lp.msg(failure=failure.Failure(ValueError("That is bad.")), isError=True) self.assertIn("ERROR", self.out.getvalue()) def test_formatString(self): """ Test logging with a format. """ self.lp.msg(format="%(bar)s oo %(foo)s", bar="Hello", foo="world") self.assertIn("Hello oo world", self.out.getvalue()) def test_customLevel(self): """ Test the logLevel keyword for customizing level used. """ self.lp.msg("Spam egg.", logLevel=logging.DEBUG) self.assertIn("Spam egg.", self.out.getvalue()) self.assertIn("DEBUG", self.out.getvalue()) self.out.seek(0, 0) self.out.truncate() self.lp.msg("Foo bar.", logLevel=logging.WARNING) self.assertIn("Foo bar.", self.out.getvalue()) self.assertIn("WARNING", self.out.getvalue()) def test_strangeEventDict(self): """ Verify that an event dictionary which is not an error and has an empty message isn't recorded. """ self.lp.msg(message='', isError=False) self.assertEqual(self.out.getvalue(), '')
def test_parseJob_invalid(self): sched = trysched.Try_Jobdir(name='tsched', builderNames=['a'], jobdir='foo') self.assertRaises(trysched.BadJobfile, sched.parseJob, NativeStringIO('this is not a netstring'))
class MainTests(TestCase): """ Tests for L{main}. """ def setUp(self): self.readStream = StringIO() self.writeStream = StringIO() self.patch(workertrial, 'startLoggingWithObserver', self.startLoggingWithObserver) self.addCleanup(setattr, sys, "argv", sys.argv) sys.argv = ["trial"] def fdopen(self, fd, mode=None): """ Fake C{os.fdopen} implementation which returns C{self.readStream} for the stdin fd and C{self.writeStream} for the stdout fd. """ if fd == _WORKER_AMP_STDIN: self.assertIdentical(None, mode) return self.readStream elif fd == _WORKER_AMP_STDOUT: self.assertEqual('w', mode) return self.writeStream else: raise AssertionError("Unexpected fd %r" % (fd, )) def startLoggingWithObserver(self, emit, setStdout): """ Override C{startLoggingWithObserver} for not starting logging. """ self.assertFalse(setStdout) def test_empty(self): """ If no data is ever written, L{main} exits without writing data out. """ main(self.fdopen) self.assertEqual('', self.writeStream.getvalue()) def test_forwardCommand(self): """ L{main} forwards data from its input stream to a L{WorkerProtocol} instance which writes data to the output stream. """ client = FakeAMP() clientTransport = StringTransport() client.makeConnection(clientTransport) client.callRemote(workercommands.Run, testCase=b"doesntexist") self.readStream = clientTransport.io self.readStream.seek(0, 0) main(self.fdopen) self.assertIn("No module named 'doesntexist'", self.writeStream.getvalue()) if _PY3: test_forwardCommand.skip = "Does not work on Python 3 (https://tm.tl/8944)" def test_readInterrupted(self): """ If reading the input stream fails with a C{IOError} with errno C{EINTR}, L{main} ignores it and continues reading. """ excInfos = [] class FakeStream(object): count = 0 def read(oself, size): oself.count += 1 if oself.count == 1: raise IOError(errno.EINTR) else: excInfos.append(sys.exc_info()) return '' self.readStream = FakeStream() main(self.fdopen) self.assertEqual('', self.writeStream.getvalue()) self.assertEqual([(None, None, None)], excInfos) def test_otherReadError(self): """ L{main} only ignores C{IOError} with C{EINTR} errno: otherwise, the error pops out. """ class FakeStream(object): count = 0 def read(oself, size): oself.count += 1 if oself.count == 1: raise IOError("Something else") return '' self.readStream = FakeStream() self.assertRaises(IOError, main, self.fdopen)
def test_parseJob_invalid_version(self): sched = trysched.Try_Jobdir(name='tsched', builderNames=['a'], jobdir='foo') self.assertRaises(trysched.BadJobfile, sched.parseJob, NativeStringIO('1:9,'))
def setUp(self): self.setUpDirs('test') self.stdout = NativeStringIO() self.setUpStdoutAssertions()
def getBriefTraceback(self): io = StringIO() self.printBriefTraceback(file=io) return io.getvalue()