def runner(ix, testQueue, resultQueue, shouldStop,
loaderClass, resultClass, config):
config = pickle.loads(config)
config.plugins.begin()
log.debug("Worker %s executing", ix)
log.debug("Active plugins worker %s: %s", ix, config.plugins._plugins)
loader = loaderClass(config=config)
loader.suiteClass.suiteClass = NoSharedFixtureContextSuite
def get():
case = testQueue.get(timeout=config.multiprocess_timeout)
return case
def makeResult():
stream = _WritelnDecorator(StringIO())
result = resultClass(stream, descriptions=1,
verbosity=config.verbosity,
config=config)
plug_result = config.plugins.prepareTestResult(result)
if plug_result:
return plug_result
return result
def batch(result):
failures = [(TestLet(c), err) for c, err in result.failures]
errors = [(TestLet(c), err) for c, err in result.errors]
errorClasses = {}
for key, (storage, label, isfail) in result.errorClasses.items():
errorClasses[key] = ([(TestLet(c), err) for c, err in storage],
label, isfail)
return (
result.stream.getvalue(),
result.testsRun,
failures,
errors,
errorClasses)
try:
try:
for test_addr in iter(get, 'STOP'):
if shouldStop.is_set():
break
result = makeResult()
test = loader.loadTestsFromNames([test_addr])
log.debug("Worker %s Test is %s (%s)", ix, test_addr, test)
try:
test(result)
resultQueue.put((test_addr, batch(result)))
except KeyboardInterrupt, SystemExit:
raise
except:
log.exception("Error running test or returning results")
failure.Failure(*sys.exc_info())(result)
resultQueue.put((test_addr, batch(result)))
except Empty:
log.debug("Worker %s timed out waiting for tasks", ix)
def run_tests( test_config ):
loader = nose.loader.TestLoader( config=test_config )
plug_loader = test_config.plugins.prepareTestLoader( loader )
if plug_loader is not None:
loader = plug_loader
tests = loader.loadTestsFromNames( test_config.testNames )
test_runner = nose.core.TextTestRunner( stream=test_config.stream,
verbosity=test_config.verbosity,
config=test_config )
plug_runner = test_config.plugins.prepareTestRunner( test_runner )
if plug_runner is not None:
test_runner = plug_runner
return test_runner.run( tests )
def run_tests(test_config):
loader = nose.loader.TestLoader(config=test_config)
plug_loader = test_config.plugins.prepareTestLoader(loader)
if plug_loader is not None:
loader = plug_loader
tests = loader.loadTestsFromNames(test_config.testNames)
test_runner = nose.core.TextTestRunner(stream=test_config.stream,
verbosity=test_config.verbosity,
config=test_config)
plug_runner = test_config.plugins.prepareTestRunner(test_runner)
if plug_runner is not None:
test_runner = plug_runner
return test_runner.run(tests)
def __runner(
ix, testQueue, resultQueue, currentaddr, currentstart, keyboardCaught, shouldStop, loaderClass, resultClass, config
):
config = pickle.loads(config)
dummy_parser = config.parserClass()
if _instantiate_plugins is not None:
for pluginclass in _instantiate_plugins:
plugin = pluginclass()
plugin.addOptions(dummy_parser, {})
config.plugins.addPlugin(plugin)
config.plugins.configure(config.options, config)
config.plugins.begin()
log.debug("Worker %s executing, pid=%d", ix, os.getpid())
loader = loaderClass(config=config)
loader.suiteClass.suiteClass = NoSharedFixtureContextSuite
def get():
return testQueue.get(timeout=config.multiprocess_timeout)
def makeResult():
stream = _WritelnDecorator(StringIO())
result = resultClass(stream, descriptions=1, verbosity=config.verbosity, config=config)
plug_result = config.plugins.prepareTestResult(result)
if plug_result:
return plug_result
return result
def batch(result):
failures = [(TestLet(c), err) for c, err in result.failures]
errors = [(TestLet(c), err) for c, err in result.errors]
errorClasses = {}
for key, (storage, label, isfail) in result.errorClasses.items():
errorClasses[key] = ([(TestLet(c), err) for c, err in storage], label, isfail)
return (result.stream.getvalue(), result.testsRun, failures, errors, errorClasses)
for test_addr, arg in iter(get, "STOP"):
if shouldStop.is_set():
log.exception("Worker %d STOPPED", ix)
break
result = makeResult()
test = loader.loadTestsFromNames([test_addr])
test.testQueue = testQueue
test.tasks = []
test.arg = arg
log.debug("Worker %s Test is %s (%s)", ix, test_addr, test)
try:
if arg is not None:
test_addr = test_addr + str(arg)
currentaddr.value = bytes_(test_addr)
currentstart.value = time.time()
test(result)
currentaddr.value = bytes_("")
resultQueue.put((ix, test_addr, test.tasks, batch(result)))
except KeyboardInterrupt:
keyboardCaught.set()
if len(currentaddr.value) > 0:
log.debug("Worker %s keyboard interrupt, failing current test %s", ix, test_addr)
currentaddr.value = bytes_("")
failure.Failure(*sys.exc_info())(result)
resultQueue.put((ix, test_addr, test.tasks, batch(result)))
else:
log.debug("Worker %s test %s timed out", ix, test_addr)
resultQueue.put((ix, test_addr, test.tasks, batch(result)))
except SystemExit:
currentaddr.value = bytes_("")
log.exception("Worker %s system exit", ix)
raise
except:
currentaddr.value = bytes_("")
log.exception("Worker %s error running test or returning " "results", ix)
failure.Failure(*sys.exc_info())(result)
resultQueue.put((ix, test_addr, test.tasks, batch(result)))
if config.multiprocess_restartworker:
break
log.debug("Worker %s ending", ix)
def __runner(ix, testQueue, resultQueue, currentaddr, currentstart,
keyboardCaught, shouldStop, loaderClass, resultClass, config):
config = pickle.loads(config)
dummy_parser = config.parserClass()
if _instantiate_plugins is not None:
for pluginclass in _instantiate_plugins:
plugin = pluginclass()
plugin.addOptions(dummy_parser, {})
config.plugins.addPlugin(plugin)
config.plugins.configure(config.options, config)
config.plugins.begin()
log.debug("Worker %s executing, pid=%d", ix, os.getpid())
loader = loaderClass(config=config)
loader.suiteClass.suiteClass = NoSharedFixtureContextSuite
def get():
return testQueue.get(timeout=config.multiprocess_timeout)
def makeResult():
stream = _WritelnDecorator(StringIO())
result = resultClass(stream,
descriptions=1,
verbosity=config.verbosity,
config=config)
plug_result = config.plugins.prepareTestResult(result)
if plug_result:
return plug_result
return result
def batch(result):
failures = [(TestLet(c), err) for c, err in result.failures]
errors = [(TestLet(c), err) for c, err in result.errors]
errorClasses = {}
for key, (storage, label, isfail) in result.errorClasses.items():
errorClasses[key] = ([(TestLet(c), err)
for c, err in storage], label, isfail)
return (result.stream.getvalue(), result.testsRun, failures, errors,
errorClasses)
for test_addr, arg in iter(get, 'STOP'):
if shouldStop.is_set():
log.exception('Worker %d STOPPED', ix)
break
result = makeResult()
test = loader.loadTestsFromNames([test_addr])
test.testQueue = testQueue
test.tasks = []
test.arg = arg
log.debug("Worker %s Test is %s (%s)", ix, test_addr, test)
try:
if arg is not None:
test_addr = test_addr + str(arg)
currentaddr.value = bytes_(test_addr)
currentstart.value = time.time()
test(result)
currentaddr.value = bytes_('')
resultQueue.put((ix, test_addr, test.tasks, batch(result)))
except KeyboardInterrupt:
keyboardCaught.set()
if len(currentaddr.value) > 0:
log.exception(
'Worker %s keyboard interrupt, failing '
'current test %s', ix, test_addr)
currentaddr.value = bytes_('')
failure.Failure(*sys.exc_info())(result)
resultQueue.put((ix, test_addr, test.tasks, batch(result)))
else:
log.debug('Worker %s test %s timed out', ix, test_addr)
resultQueue.put((ix, test_addr, test.tasks, batch(result)))
except SystemExit:
currentaddr.value = bytes_('')
log.exception('Worker %s system exit', ix)
raise
except:
currentaddr.value = bytes_('')
log.exception(
"Worker %s error running test or returning "
"results", ix)
failure.Failure(*sys.exc_info())(result)
resultQueue.put((ix, test_addr, test.tasks, batch(result)))
if config.multiprocess_restartworker:
break
log.debug("Worker %s ending", ix)
failures = [(TestLet(c), err) for c, err in result.failures]
errors = [(TestLet(c), err) for c, err in result.errors]
errorClasses = {}
for key, (storage, label, isfail) in result.errorClasses.items():
errorClasses[key] = ([(TestLet(c), err)
for c, err in storage], label, isfail)
return (result.stream.getvalue(), result.testsRun, failures, errors,
errorClasses)
try:
try:
for test_addr in iter(get, 'STOP'):
if shouldStop.is_set():
break
result = makeResult()
test = loader.loadTestsFromNames([test_addr])
log.debug("Worker %s Test is %s (%s)", ix, test_addr, test)
try:
test(result)
resultQueue.put((test_addr, batch(result)))
except KeyboardInterrupt, SystemExit:
raise
except:
log.exception("Error running test or returning results")
failure.Failure(*sys.exc_info())(result)
resultQueue.put((test_addr, batch(result)))
except Empty:
log.debug("Worker %s timed out waiting for tasks", ix)
finally:
testQueue.close()
import nose.core
import nose.config
import nose.loader
import nose.plugins.manager
test_config = nose.config.Config( env = os.environ, plugins=nose.plugins.manager.DefaultPluginManager() )
test_config.configure( sys.argv )
loader = nose.loader.TestLoader( config = test_config )
plug_loader = test_config.plugins.prepareTestLoader( loader )
if plug_loader is not None:
loader = plug_loader
tests = loader.loadTestsFromNames( test_config.testNames )
test_runner = nose.core.TextTestRunner(
stream = test_config.stream,
verbosity = test_config.verbosity,
config = test_config)
plug_runner = test_config.plugins.prepareTestRunner( test_runner )
if plug_runner is not None:
test_runner = plug_runner
result = test_runner.run( tests )
success = result.wasSuccessful()
except:
import nose.config
import nose.loader
import nose.plugins.manager
test_config = nose.config.Config(
env=os.environ,
plugins=nose.plugins.manager.DefaultPluginManager())
test_config.configure(sys.argv)
loader = nose.loader.TestLoader(config=test_config)
plug_loader = test_config.plugins.prepareTestLoader(loader)
if plug_loader is not None:
loader = plug_loader
tests = loader.loadTestsFromNames(test_config.testNames)
test_runner = nose.core.TextTestRunner(stream=test_config.stream,
verbosity=test_config.verbosity,
config=test_config)
plug_runner = test_config.plugins.prepareTestRunner(test_runner)
if plug_runner is not None:
test_runner = plug_runner
result = test_runner.run(tests)
success = result.wasSuccessful()
except:
log.exception("Failure running tests")
