def assertOutput(self, template, kind, kwargs=None): """Assert the expected output from a run for a given test. :param template: A string where common strings have been replaced by a keyword so we don't run into pep8 warnings for long lines. :param kind: A string used to select the kind of test. :param kwargs: A dict with more keywords for the template. This allows some tests to add more keywords when they are test specific. """ test = tests.get_case(kind) # Get subunit output (what subprocess produce) stream = StringIO() res = subunit.TestProtocolClient(stream) test.run(res) # Inject it again (what controlling process consumes) receiver = subunit.ProtocolTestCase(StringIO(stream.getvalue())) out = StringIO() res = junitxml.JUnitXmlResult(out) # We don't care about timing here so we always return 0 which # simplifies matching the expected result res._now = lambda: 0.0 res._duration = lambda f: 0.0 expected = tests.expand_template_for_test(template, test, kwargs) res.startTestRun() receiver.run(res) # due to the nature of JUnit XML output, nothing will be written to # the stream until stopTestRun() is called. res.stopTestRun() self.assertEquals(expected, out.getvalue())
def main(): if len(sys.argv) < 2: print("Need at least one argument: path to subunit log.") exit(1) subunit_file = sys.argv[1] if len(sys.argv) > 2: html_file = sys.argv[2] else: html_file = 'results.html' html_result = HtmlOutput(html_file) stream = open(subunit_file, 'rb') # Feed the subunit stream through both a V1 and V2 parser. # Depends on having the v2 capable libraries installed. # First V2. # Non-v2 content and captured non-test output will be presented as file # segments called stdout. suite = subunit.ByteStreamToStreamResult(stream, non_subunit_name='stdout') # The HTML output code is in legacy mode. result = testtools.StreamToExtendedDecorator(html_result) # Divert non-test output accumulator = FileAccumulator() result = testtools.StreamResultRouter(result) result.add_rule(accumulator, 'test_id', test_id=None) result.startTestRun() suite.run(result) # Now reprocess any found stdout content as V1 subunit for bytes_io in accumulator.route_codes.values(): bytes_io.seek(0) suite = subunit.ProtocolTestCase(bytes_io) suite.run(html_result) result.stopTestRun()
def main(subunit_log_file): fd, results_file = tempfile.mkstemp() result = JsonOutput(results_file) stream = open(subunit_log_file, 'rb') # Feed the subunit stream through both a V1 and V2 parser. # Depends on having the v2 capable libraries installed. # First V2. # Non-v2 content and captured non-test output will be presented as file # segments called stdout. suite = subunit.ByteStreamToStreamResult(stream, non_subunit_name='stdout') # The JSON output code is in legacy mode. raw_result = testtools.StreamToExtendedDecorator(result) # Divert non-test output accumulator = FileAccumulator() result = testtools.StreamResultRouter(raw_result) result.add_rule(accumulator, 'test_id', test_id=None) result.startTestRun() suite.run(result) # Now reprocess any found stdout content as V1 subunit for bytes_io in accumulator.route_codes.values(): bytes_io.seek(0) suite = subunit.ProtocolTestCase(bytes_io) suite.run(result) result.stopTestRun() with open(results_file, 'rb') as temp_results_file: data = temp_results_file.read() try: os.unlink(results_file) except OSError as e: if e.errno != errno.ENOENT: raise return data
def process_stream(self): with open(self.in_stream, 'r') as fin: test = subunit.ProtocolTestCase(fin) runner = unittest.TextTestRunner(stream=open(os.devnull, 'w'), resultclass=self.result_class) # Run (replay) the test from subunit stream. test_result = runner.run(test) return test_result.get_results()
def run_tests(self, result_filter, input_stream=None): """Run tests through the given filter. :param result_filter: A filtering TestResult object. :param input_stream: Bytes of subunit stream data. If not provided, uses TestTestResultFilter.example_subunit_stream. """ if input_stream is None: input_stream = self.example_subunit_stream test = subunit.ProtocolTestCase(BytesIO(input_stream)) test.run(result_filter)
def __init__(self, in_stream, test_result_class_name=TempestSubunitTestResult): """Read and process subunit data from a stream. Save processed data into a class named TempestSubunitTestResult which is a class derived from unittest.TestResults. """ test = subunit.ProtocolTestCase(in_stream, passthrough=None) runner = unittest.TextTestRunner(verbosity=2, resultclass=test_result_class_name) #Run (replay) the test from subunit stream. #runner,run will return an object of type "test_result_class_name" self.result = runner.run(test)
def assertOutput(self, expected, kind): test = tests.get_case(kind) # Get subunit output (what subprocess produce) stream = StringIO() res = subunit.TestProtocolClient(stream) test.run(res) # Inject it again (what controlling process consumes) receiver = subunit.ProtocolTestCase(StringIO(stream.getvalue())) out = StringIO() text_result = results.TextTestResult(out, verbosity=0) # We don't care about timing here so we always return 0 which # simplifies matching the expected result def zero(atime): return 0.0 text_result._delta_to_float = zero receiver.run(text_result) self.assertEquals(expected, out.getvalue())
def parse(subunit_file, non_subunit_name="pythonlogging"): subunit_parser = SubunitParser() stream = open(subunit_file, 'rb') suite = subunit.ByteStreamToStreamResult(stream, non_subunit_name=non_subunit_name) result = testtools.StreamToExtendedDecorator(subunit_parser) accumulator = FileAccumulator(non_subunit_name) result = testtools.StreamResultRouter(result) result.add_rule(accumulator, 'test_id', test_id=None) result.startTestRun() suite.run(result) for bytes_io in accumulator.route_codes.values(): # v1 processing bytes_io.seek(0) suite = subunit.ProtocolTestCase(bytes_io) suite.run(subunit_parser) result.stopTestRun() return subunit_parser
def parse(stream, non_subunit_name, ports): if ports is not None and os.path.exists(ports): ports = json.loads(open(ports).read()) url_parser = UrlParser(ports) suite = subunit.ByteStreamToStreamResult(stream, non_subunit_name=non_subunit_name) result = testtools.StreamToExtendedDecorator(url_parser) accumulator = FileAccumulator(non_subunit_name) result = testtools.StreamResultRouter(result) result.add_rule(accumulator, 'test_id', test_id=None) result.startTestRun() suite.run(result) for bytes_io in accumulator.route_codes.values(): # v1 processing bytes_io.seek(0) suite = subunit.ProtocolTestCase(bytes_io) suite.run(url_parser) result.stopTestRun() return url_parser
def printErrors(self): if self.showAll: self.stream.writeln() self.printErrorList('ERROR', self.errors) self.printErrorList('FAIL', self.failures) def printErrorList(self, flavor, errors): for test, err in errors: self.colorizer.write("=" * 70, 'red') self.stream.writeln() self.colorizer.write(flavor, 'red') self.stream.writeln(": %s" % test.id()) self.colorizer.write("-" * 70, 'red') self.stream.writeln() self.stream.writeln("%s" % err) test = subunit.ProtocolTestCase(sys.stdin, passthrough=None) if sys.version_info[0:2] <= (2, 6): runner = unittest.TextTestRunner(verbosity=2) else: runner = unittest.TextTestRunner(verbosity=2, resultclass=NovaTestResult) if runner.run(test).wasSuccessful(): exit_code = 0 else: exit_code = 1 sys.exit(exit_code)
def setUp(self): self.output = StringIO() self.result = subunit.TestResultStats(self.output) self.input_stream = BytesIO() self.test = subunit.ProtocolTestCase(self.input_stream)
def to_events(self, stream): test = subunit.ProtocolTestCase(BytesIO(stream)) result = ExtendedTestResult() test.run(result) return result._events
def run_tests(self): self.setUpTestStream() self.test = subunit.ProtocolTestCase(self.input_stream) self.test.run(self.filter)
def get_test(self): return subunit.ProtocolTestCase(self.get_subunit_stream())