def run_tests_from_stream(input_stream, result, passthrough_stream=None,
forward_stream=None, protocol_version=1, passthrough_subunit=True):
"""Run tests from a subunit input stream through 'result'.
Non-test events - top level file attachments - are expected to be
dropped by v2 StreamResults at the present time (as all the analysis code
is in ExtendedTestResult API's), so to implement passthrough_stream they
are diverted and copied directly when that is set.
:param input_stream: A stream containing subunit input.
:param result: A TestResult that will receive the test events.
NB: This should be an ExtendedTestResult for v1 and a StreamResult for
v2.
:param passthrough_stream: All non-subunit input received will be
sent to this stream. If not provided, uses the ``TestProtocolServer``
default, which is ``sys.stdout``.
:param forward_stream: All subunit input received will be forwarded
to this stream. If not provided, uses the ``TestProtocolServer``
default, which is to not forward any input. Do not set this when
transforming the stream - items would be double-reported.
:param protocol_version: What version of the subunit protocol to expect.
:param passthrough_subunit: If True, passthrough should be as subunit
otherwise unwrap it. Only has effect when forward_stream is None.
(when forwarding as subunit non-subunit input is always turned into
subunit)
"""
if 1==protocol_version:
test = ProtocolTestCase(
input_stream, passthrough=passthrough_stream,
forward=forward_stream)
elif 2==protocol_version:
# In all cases we encapsulate unknown inputs.
if forward_stream is not None:
# Send events to forward_stream as subunit.
forward_result = StreamResultToBytes(forward_stream)
# If we're passing non-subunit through, copy:
if passthrough_stream is None:
# Not passing non-test events - split them off to nothing.
router = StreamResultRouter(forward_result)
router.add_rule(StreamResult(), 'test_id', test_id=None)
result = CopyStreamResult([router, result])
else:
# otherwise, copy all events to forward_result
result = CopyStreamResult([forward_result, result])
elif passthrough_stream is not None:
if not passthrough_subunit:
# Route non-test events to passthrough_stream, unwrapping them for
# display.
passthrough_result = CatFiles(passthrough_stream)
else:
passthrough_result = StreamResultToBytes(passthrough_stream)
result = StreamResultRouter(result)
result.add_rule(passthrough_result, 'test_id', test_id=None)
test = ByteStreamToStreamResult(input_stream,
non_subunit_name='stdout')
else:
raise Exception("Unknown protocol version.")
result.startTestRun()
test.run(result)
result.stopTestRun()
def find_tests(argv):
"""Find tests to parallel run.
:param argv: The argv given to the test runner, used to get the tests to
run.
:return: A list of test IDs.
"""
load_list = find_load_list(argv)
if load_list:
# just use the load_list
with open(load_list, 'rt') as list_file:
return [id for id in list_file.read().split('\n') if id]
# run in --list-tests mode
argv = prepare_argv(argv) + ['--list-tests', '--subunit']
process = subprocess.Popen(argv,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
process.stdin.close()
test = ProtocolTestCase(process.stdout)
result = GatherIDs()
test.run(result)
process.wait()
if process.returncode:
raise Exception('error listing tests: %s' % err)
return result.ids
def run(self, result):
with tempfile.NamedTemporaryFile() as test_list_file:
for test_id in self._test_ids:
test_list_file.write(test_id + '\n')
test_list_file.flush()
argv = self._args + ['--subunit', '--load-list', test_list_file.name]
process = subprocess.Popen(argv, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, bufsize=1)
try:
# If it tries to read, give it EOF.
process.stdin.close()
ProtocolTestCase.__init__(self, process.stdout)
ProtocolTestCase.run(self, result)
finally:
process.wait()
def _runTest(self, result):
yeti = os.environ["YETI"]
port = os.environ.get("YETI_PORT", "4422")
cmd = yeti.split() + ["--formatter=subunit",
"--quiet",
"--solo=1",
"--port=%s" % port]
for base, dirs, files in os.walk(self.tests_directory):
for filename in fnmatch.filter(files, "test_*.html"):
cmd.append(os.path.join(base, filename))
proc = subprocess.Popen(cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
suite = ProtocolTestCase(proc.stdout)
suite.run(result)
proc.wait()
def run(self, result):
with tempfile.NamedTemporaryFile() as test_list_file:
for test_id in self._test_ids:
test_list_file.write(test_id + '\n')
test_list_file.flush()
argv = self._args + [
'--subunit', '--load-list', test_list_file.name
]
process = subprocess.Popen(argv,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
bufsize=1)
try:
# If it tries to read, give it EOF.
process.stdin.close()
ProtocolTestCase.__init__(self, process.stdout)
ProtocolTestCase.run(self, result)
finally:
process.wait()
def run_tests_from_stream(input_stream, result, passthrough_stream=None,
forward_stream=None):
"""Run tests from a subunit input stream through 'result'.
:param input_stream: A stream containing subunit input.
:param result: A TestResult that will receive the test events.
:param passthrough_stream: All non-subunit input received will be
sent to this stream. If not provided, uses the ``TestProtocolServer``
default, which is ``sys.stdout``.
:param forward_stream: All subunit input received will be forwarded
to this stream. If not provided, uses the ``TestProtocolServer``
default, which is to not forward any input.
"""
test = ProtocolTestCase(
input_stream, passthrough=passthrough_stream,
forward=forward_stream)
result.startTestRun()
test.run(result)
result.stopTestRun()
def find_tests(argv):
"""Find tests to parallel run.
:param argv: The argv given to the test runner, used to get the tests to
run.
:return: A list of test IDs.
"""
load_list = find_load_list(argv)
if load_list:
# just use the load_list
with open(load_list, 'rt') as list_file:
return [id for id in list_file.read().split('\n') if id]
# run in --list-tests mode
argv = prepare_argv(argv) + ['--list-tests', '--subunit']
process = subprocess.Popen(argv, stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
process.stdin.close()
test = ProtocolTestCase(process.stdout)
result = GatherIDs()
test.run(result)
process.wait()
if process.returncode:
raise Exception('error listing tests: %s' % err)
return result.ids
def run_tests_from_stream(input_stream,
result,
passthrough_stream=None,
forward_stream=None,
protocol_version=1,
passthrough_subunit=True):
"""Run tests from a subunit input stream through 'result'.
Non-test events - top level file attachments - are expected to be
dropped by v2 StreamResults at the present time (as all the analysis code
is in ExtendedTestResult API's), so to implement passthrough_stream they
are diverted and copied directly when that is set.
:param input_stream: A stream containing subunit input.
:param result: A TestResult that will receive the test events.
NB: This should be an ExtendedTestResult for v1 and a StreamResult for
v2.
:param passthrough_stream: All non-subunit input received will be
sent to this stream. If not provided, uses the ``TestProtocolServer``
default, which is ``sys.stdout``.
:param forward_stream: All subunit input received will be forwarded
to this stream. If not provided, uses the ``TestProtocolServer``
default, which is to not forward any input. Do not set this when
transforming the stream - items would be double-reported.
:param protocol_version: What version of the subunit protocol to expect.
:param passthrough_subunit: If True, passthrough should be as subunit
otherwise unwrap it. Only has effect when forward_stream is None.
(when forwarding as subunit non-subunit input is always turned into
subunit)
"""
if 1 == protocol_version:
test = ProtocolTestCase(input_stream,
passthrough=passthrough_stream,
forward=forward_stream)
elif 2 == protocol_version:
# In all cases we encapsulate unknown inputs.
if forward_stream is not None:
# Send events to forward_stream as subunit.
forward_result = StreamResultToBytes(forward_stream)
# If we're passing non-subunit through, copy:
if passthrough_stream is None:
# Not passing non-test events - split them off to nothing.
router = StreamResultRouter(forward_result)
router.add_rule(StreamResult(), 'test_id', test_id=None)
result = CopyStreamResult([router, result])
else:
# otherwise, copy all events to forward_result
result = CopyStreamResult([forward_result, result])
elif passthrough_stream is not None:
if not passthrough_subunit:
# Route non-test events to passthrough_stream, unwrapping them for
# display.
passthrough_result = CatFiles(passthrough_stream)
else:
passthrough_result = StreamResultToBytes(passthrough_stream)
result = StreamResultRouter(result)
result.add_rule(passthrough_result, 'test_id', test_id=None)
test = ByteStreamToStreamResult(input_stream,
non_subunit_name='stdout')
else:
raise Exception("Unknown protocol version.")
result.startTestRun()
test.run(result)
result.stopTestRun()
