def test_line_separator(self): output = StringIO() writer = HtmlWriter(output) writer.start('b') writer.end('b') writer.element('i') assert_equal(repr(output.getvalue()), repr('<b>\n</b>\n<i></i>\n'))
def get_lines(suite=(), strings=(), basemillis=100, start_block='', end_block='', split_threshold=9999, min_level='INFO'): output = StringIO() data = JsExecutionResult(suite, None, None, strings, basemillis, min_level=min_level) writer = JsResultWriter(output, start_block, end_block, split_threshold) writer.write(data, settings={}) return output.getvalue().splitlines()
def test_end_of_line_whitespace_is_removed(self): output = StringIO() create_test_case_file().save(output=output) expected = """\ *** test case *** some and other A test A kw an arg """ assert_equals(repr(expected), repr(output.getvalue()))
def test_json_dump_mapping(self): output = StringIO() dumper = JsonDumper(output) mapped1 = object() mapped2 = "string" dumper.dump([mapped1, [mapped2, {mapped2: mapped1}]], mapping={mapped1: "1", mapped2: "a"}) assert_equal(output.getvalue(), "[1,[a,{a:1}]]") assert_raises(ValueError, dumper.dump, [mapped1])
def test_dont_register_signal_handlers_then_run_on_thread(self): stream = StringIO() thread = threading.Thread(target=run_without_outputs, args=(self.data,), kwargs=dict(stdout=stream, stderr=stream)) thread.start() thread.join() output = stream.getvalue() assert_true('ERROR' not in output.upper(), 'Errors:\n%s' % output)
def test_configuring_number_of_separating_spaces(self): output = StringIO() create_test_case_file().save(output=output, txt_separating_spaces=8) expected = """\ *** test case *** some and other A test A kw an arg """ assert_equals(repr(expected), repr(output.getvalue()))
class _MockLogger(object): def __init__(self): self._output = StringIO() def message(self, msg): self._output.write(msg.message) def value(self): return self._output.getvalue()
def test_json_dump_mapping(self): output = StringIO() dumper = JsonDumper(output) mapped1 = object() mapped2 = 'string' dumper.dump([mapped1, [mapped2, {mapped2: mapped1}]], mapping={mapped1: '1', mapped2: 'a'}) assert_equal(output.getvalue(), '[1,[a,{a:1}]]') assert_raises(ValueError, dumper.dump, [mapped1])
def test_non_ascii(self): self.output = StringIO() writer = HtmlWriter(self.output) writer.start(u'p', attrs={'name': u'hyv\xe4\xe4'}, newline=False) writer.content(u'y\xf6') writer.element('i', u't\xe4', newline=False) writer.end('p', newline=False) self._verify(u'<p name="hyv\xe4\xe4">y\xf6<i>t\xe4</i></p>')
def __init__(self, stdout=True): if stdout: self._original = sys.stdout self._set_stream = self._set_stdout else: self._original = sys.stderr self._set_stream = self._set_stderr self._stream = StringIO() self._set_stream(self._stream)
class PythonCapturer(object): def __init__(self, stdout=True): if stdout: self._original = sys.stdout self._set_stream = self._set_stdout else: self._original = sys.stderr self._set_stream = self._set_stderr self._stream = StringIO() self._set_stream(self._stream) def _set_stdout(self, stream): sys.stdout = stream def _set_stderr(self, stream): sys.stderr = stream def release(self): # Original stream must be restored before closing the current self._set_stream(self._original) try: return self._get_value(self._stream) finally: self._stream.close() self._avoid_at_exit_errors(self._stream) def _get_value(self, stream): try: return decode_output(stream.getvalue()) except UnicodeError: # Error occurs if non-ASCII chars logged both as str and unicode. stream.buf = decode_output(stream.buf) stream.buflist = [decode_output(item) for item in stream.buflist] return stream.getvalue() def _avoid_at_exit_errors(self, stream): # Avoid ValueError at program exit when logging module tries to call # methods of streams it has intercepted that are already closed. # Which methods are called, and does logging silence possible errors, # depends on Python/Jython version. For related discussion see # http://bugs.python.org/issue6333 stream.write = lambda s: None stream.flush = lambda: None
def test_suite_message(self): xml = """ <robot> <suite name="foo"> <status status="FAIL">Setup failed</status> </suite> </robot> """ suite = ExecutionResult(StringIO(xml)).suite assert_equal(suite.message, 'Setup failed')
def test_omit_keywords_during_xml_parsing(self): class NonVisitingSuite(TestSuite): def visit(self, visitor): pass result = Result(root_suite=NonVisitingSuite()) builder = ExecutionResultBuilder(StringIO(GOLDEN_XML), include_keywords=False) builder.build(result) assert_equal(len(result.suite.tests[0].body), 0)
def _split(self, options): split_options = [] start_position = 0 tokens = generate_tokens(StringIO(options).readline) for toknum, tokval, tokpos, _, _ in tokens: if toknum == token.OP and tokval == ';': split_options.append(options[start_position:tokpos[1]]) start_position = tokpos[1] + 1 split_options.append(options[start_position:]) return split_options
def test_already_processed(self): inp = SUITE_TEARDOWN_FAILED.replace('generator="Robot', 'generator="Rebot') passed, failed, teardowns = ExecutionResult(StringIO(inp)).suite.tests assert_equal(passed.status, 'PASS') assert_equal(passed.message, '') assert_equal(failed.status, 'FAIL') assert_equal(failed.message, 'Message') assert_equal(teardowns.status, 'PASS') assert_equal(teardowns.message, '')
def test_run_multiple_times_with_different_stdout_and_stderr(self): stdout, stderr = StringIO(), StringIO() self._run(stdout, stderr) self._assert_normal_stdout_stderr_are_empty() self._assert_output(stdout, [('My Suite', 2), ('My Test', 1)]) self._assert_output(stderr, [('Hello, world!', 1)]) stdout.close(); stderr.close() output = StringIO() self._run(output, output, variable='MESSAGE:Hi, again!') self._assert_normal_stdout_stderr_are_empty() self._assert_output(output, [('My Suite', 2), ('My Test', 1), ('Hi, again!', 1), ('Hello, world!', 0)]) output.close() self._run(variable='MESSAGE:Last hi!') self._assert_output(sys.__stdout__, [('My Suite', 2), ('My Test', 1)]) self._assert_output(sys.__stderr__, [('Last hi!', 1), ('Hello, world!', 0)])
class ClosableOutput(object): def __init__(self, path): self._output = StringIO() self._path = path def __enter__(self): return self def __exit__(self, *args): self.close() def write(self, data): self._output.write(data) def close(self): self.value = self._output.getvalue() self._output.close() def __str__(self): return self._path
def test_excluding_keywords_and_already_processed(self): inp = SUITE_TEARDOWN_FAILED.replace('generator="Robot', 'generator="Rebot') suite = ExecutionResult(StringIO(inp), include_keywords=False).suite passed, failed, teardowns = suite.tests assert_equal(passed.status, 'PASS') assert_equal(passed.message, '') assert_equal(failed.status, 'FAIL') assert_equal(failed.message, 'Message') assert_equal(teardowns.status, 'PASS') assert_equal(teardowns.message, '') for item in suite, passed, failed, teardowns: assert_equal(list(item.keywords), [])
def test_original_signal_handlers_are_restored(self): orig_sigint = signal.getsignal(signal.SIGINT) orig_sigterm = signal.getsignal(signal.SIGTERM) my_sigterm = lambda signum, frame: None signal.signal(signal.SIGTERM, my_sigterm) try: run_without_outputs(self.data, stdout=StringIO()) assert_signal_handler_equal(signal.SIGINT, orig_sigint) assert_signal_handler_equal(signal.SIGTERM, my_sigterm) finally: signal.signal(signal.SIGINT, orig_sigint) signal.signal(signal.SIGTERM, orig_sigterm)
def _read_html(self, doctree, rawdata): htmlfile = StringIO() htmlfile.write(publish_from_doctree( doctree, writer_name='html', settings_overrides={'output_encoding': 'UTF-8'})) htmlfile.seek(0) return HtmlReader().read(htmlfile, rawdata)
def test_excluding_keywords(self): suite = ExecutionResult(StringIO(SUITE_TEARDOWN_FAILED), include_keywords=False).suite passed, failed, teardowns = suite.tests assert_equal(passed.status, 'FAIL') assert_equal(passed.message, 'Parent suite teardown failed:\nXXX') assert_equal(failed.status, 'FAIL') assert_equal(failed.message, 'Message\n\n' 'Also parent suite teardown failed:\nXXX') assert_equal(teardowns.status, 'FAIL') assert_equal(teardowns.message, 'Parent suite teardown failed:\nXXX') for item in suite, passed, failed, teardowns: assert_equal(list(item.keywords), [])
def test_start_table(self): tsv = StringIO('''*SettING*\t* Value *\t*V* ***Variable *Not*Table* Keyword*\tNot a table because doesn't start with '*' *******************T*e*s*t*********C*a*s*e************\t***********\t******\t* ''') TsvReader().read(tsv, FromFilePopulator(self.tcf)) assert_equals(self.tcf.setting_table.name, 'SettING') assert_equals(self.tcf.setting_table.header, ['SettING', 'Value', 'V'])
def test_test_message(self): xml = """ <robot> <suite name="foo"> <test name="test"> <status status="FAIL">Failure message</status> </test> </suite> </robot> """ test = ExecutionResult(StringIO(xml)).suite.tests[0] assert_equal(test.message, 'Failure message') assert_equal(test.status, 'FAIL') assert_equal(test.longname, 'foo.test')
def _parse_to_tokens(self, item): result = {} method = None arguments = [] tokens = generate_tokens(StringIO(item).readline) for toknum, tokval, _, _, _ in tokens: if toknum == token.NAME and not method: method = tokval elif toknum == token.STRING: arguments.append(ast.literal_eval(tokval)) elif toknum in [token.NAME, token.NUMBER] and method: arguments.append(ast.literal_eval(tokval)) result[method] = arguments return result
def test_nested_suites(self): xml = """ <robot> <suite name="foo"> <suite name="bar"> <suite name="quux"> </suite> </suite> </suite> </robot> """ suite = ExecutionResult(StringIO(xml)).suite assert_equal(suite.name, 'foo') assert_equal(suite.suites[0].name, 'bar') assert_equal(suite.longname, 'foo') assert_equal(suite.suites[0].longname, 'foo.bar') assert_equal(suite.suites[0].suites[0].name, 'quux') assert_equal(suite.suites[0].suites[0].longname, 'foo.bar.quux')
def test_rows(self): tsv = StringIO('''Ignored text before tables... Mote\tignored\text *Setting*\t*Value*\t*Value* Document\tWhatever\t\t\\\t Default Tags\tt1\tt2\tt3\t\t *Variable*\tWhatever \\ \\ 2 escaped spaces before and after \\ \\\t\\ \\ value \\ \\ ''') TsvReader().read(tsv, FromFilePopulator(self.tcf)) assert_equals(self.tcf.setting_table.doc.value, 'Whatever ') assert_equals(self.tcf.setting_table.default_tags.value, ['t1', 't2', 't3']) assert_equals(self.tcf.variable_table.variables[0].name, '\\ \\ 2 escaped spaces before and after \\ \\') assert_equals(self.tcf.variable_table.variables[0].value, ['\\ \\ value \\ \\'])
def test_quotes(self): tsv = StringIO('''*Variable*\t*Value* ${v}\tHello ${v}\t"Hello" ${v}\t"""Hello""" ${v}\t"""""Hello""""" ${v}\t"Hel""lo" ${v}\t"""Hel "" """" lo""""""" ${v}\t"Hello ${v}\tHello" ''') TsvReader().read(tsv, FromFilePopulator(self.tcf)) actual = [variable for variable in self.tcf.variable_table.variables] expected = [ 'Hello', 'Hello', '"Hello"', '""Hello""', 'Hel"lo', '"Hel " "" lo"""', '"Hello', 'Hello"' ] assert_equals(len(actual), len(expected)) for act, exp in zip(actual, expected): assert_equals(act.name, '${v}') assert_equals(act.value, [exp])
def _decorate_variables(expression, variable_store): variable_started = False variable_found = False tokens = [] for toknum, tokval, _, _, _ in generate_tokens( StringIO(expression).readline): if variable_started: if toknum == token.NAME: if tokval not in variable_store: variable_not_found( '$%s' % tokval, variable_store.as_dict(decoration=False), deco_braces=False) tokval = 'RF_VAR_' + tokval variable_found = True else: tokens.append((token.ERRORTOKEN, '$')) variable_started = False if toknum == token.ERRORTOKEN and tokval == '$': variable_started = True else: tokens.append((toknum, tokval)) return untokenize(tokens).strip() if variable_found else expression
def test_importing_library_from_pythonpath(self): errors = StringIO() run(self.data, outputdir=TEMP, stdout=StringIO(), stderr=errors) self._assert_output(errors, '')
class TestHtmlWriter(unittest.TestCase): def setUp(self): self.output = StringIO() self.writer = HtmlWriter(self.output) def test_start(self): self.writer.start('r') self._verify('<r>\n') def test_start_without_newline(self): self.writer.start('robot', newline=False) self._verify('<robot>') def test_start_with_attribute(self): self.writer.start('robot', {'name': 'Suite1'}, False) self._verify('<robot name="Suite1">') def test_start_with_attributes(self): self.writer.start('test', {'class': '123', 'x': 'y', 'a': 'z'}) self._verify('<test a="z" class="123" x="y">\n') def test_start_with_non_ascii_attributes(self): self.writer.start('test', {'name': u'\xA7', u'\xE4': u'\xA7'}) self._verify(u'<test name="\xA7" \xE4="\xA7">\n') def test_start_with_quotes_in_attribute_value(self): self.writer.start('x', {'q':'"', 'qs': '""""', 'a': "'"}, False) self._verify('<x a="\'" q=""" qs="""""">') def test_start_with_html_in_attribute_values(self): self.writer.start('x', {'1':'<', '2': '&', '3': '</html>'}, False) self._verify('<x 1="<" 2="&" 3="</html>">') def test_start_with_newlines_and_tabs_in_attribute_values(self): self.writer.start('x', {'1':'\n', '3': 'A\nB\tC', '2': '\t', '4': '\r\n'}, False) self._verify('<x 1=" " 2="	" 3="A B	C" 4=" ">') def test_end(self): self.writer.start('robot', newline=False) self.writer.end('robot') self._verify('<robot></robot>\n') def test_end_without_newline(self): self.writer.start('robot', newline=False) self.writer.end('robot', newline=False) self._verify('<robot></robot>') def test_end_alone(self): self.writer.end('suite', newline=False) self._verify('</suite>') def test_content(self): self.writer.start('robot') self.writer.content('Hello world!') self._verify('<robot>\nHello world!') def test_content_with_non_ascii_data(self): self.writer.start('robot', newline=False) self.writer.content(u'Circle is 360\xB0. ') self.writer.content(u'Hyv\xE4\xE4 \xFC\xF6t\xE4!') self.writer.end('robot', newline=False) expected = u'Circle is 360\xB0. Hyv\xE4\xE4 \xFC\xF6t\xE4!' self._verify('<robot>%s</robot>' % expected) def test_multiple_content(self): self.writer.start('robot') self.writer.content('Hello world!') self.writer.content('Hi again!') self._verify('<robot>\nHello world!Hi again!') def test_content_with_chars_needing_escaping(self): self.writer.content('Me, "Myself" & I > U') self._verify('Me, "Myself" & I > U') def test_content_alone(self): self.writer.content('hello') self._verify('hello') def test_none_content(self): self.writer.start('robot') self.writer.content(None) self.writer.content('') self._verify('<robot>\n') def test_element(self): self.writer.element('div', 'content', {'id': '1'}) self.writer.element('i', newline=False) self._verify('<div id="1">content</div>\n<i></i>') def test_line_separator(self): output = StringIO() writer = HtmlWriter(output) writer.start('b') writer.end('b') writer.element('i') assert_equal(repr(output.getvalue()), repr('<b>\n</b>\n<i></i>\n')) def test_non_ascii(self): self.output = StringIO() writer = HtmlWriter(self.output) writer.start(u'p', attrs={'name': u'hyv\xe4\xe4'}, newline=False) writer.content(u'y\xf6') writer.element('i', u't\xe4', newline=False) writer.end('p', newline=False) self._verify(u'<p name="hyv\xe4\xe4">y\xf6<i>t\xe4</i></p>') def _verify(self, expected): assert_equal(self.output.getvalue(), expected)
def test_custom_stdout(self): stdout = StringIO() assert_equal(rebot(self.data, report='None', stdout=stdout, outputdir=TEMP), 1) self._assert_output(stdout, [('Log:', 1), ('Report:', 0)]) self._assert_outputs()
def test_combining_results(self): output = StringIO() writer = TestableOutputWriter(output) ExecutionResult(GOLDEN_XML, GOLDEN_XML).visit(writer) self._assert_xml_content(self._xml_lines(output.getvalue()), self._xml_lines(GOLDEN_XML_TWICE))
def __init__(self): self._output = StringIO()
def __init__(self, path): self._output = StringIO() self._path = path
def setUp(self): self.output = StringIO() self.writer = HtmlWriter(self.output)
def test_single_result_serialization(self): output = StringIO() writer = TestableOutputWriter(output) ExecutionResult(GOLDEN_XML).visit(writer) self._assert_xml_content(self._xml_lines(output.getvalue()), self._xml_lines(GOLDEN_XML))
def setUp(self): self.result = ExecutionResult(StringIO(GOLDEN_XML), StringIO(GOLDEN_XML))
class TestHtmlWriter(unittest.TestCase): def setUp(self): self.output = StringIO() self.writer = HtmlWriter(self.output) def test_start(self): self.writer.start('r') self._verify('<r>\n') def test_start_without_newline(self): self.writer.start('robot', newline=False) self._verify('<robot>') def test_start_with_attribute(self): self.writer.start('robot', {'name': 'Suite1'}, False) self._verify('<robot name="Suite1">') def test_start_with_attributes(self): self.writer.start('test', {'class': '123', 'x': 'y', 'a': 'z'}) self._verify('<test a="z" class="123" x="y">\n') def test_start_with_non_ascii_attributes(self): self.writer.start('test', {'name': u'\xA7', u'\xE4': u'\xA7'}) self._verify(u'<test name="\xA7" \xE4="\xA7">\n') def test_start_with_quotes_in_attribute_value(self): self.writer.start('x', {'q': '"', 'qs': '""""', 'a': "'"}, False) self._verify('<x a="\'" q=""" qs="""""">') def test_start_with_html_in_attribute_values(self): self.writer.start('x', {'1': '<', '2': '&', '3': '</html>'}, False) self._verify('<x 1="<" 2="&" 3="</html>">') def test_start_with_newlines_and_tabs_in_attribute_values(self): self.writer.start('x', { '1': '\n', '3': 'A\nB\tC', '2': '\t', '4': '\r\n' }, False) self._verify( '<x 1=" " 2="	" 3="A B	C" 4=" ">') def test_end(self): self.writer.start('robot', newline=False) self.writer.end('robot') self._verify('<robot></robot>\n') def test_end_without_newline(self): self.writer.start('robot', newline=False) self.writer.end('robot', newline=False) self._verify('<robot></robot>') def test_end_alone(self): self.writer.end('suite', newline=False) self._verify('</suite>') def test_content(self): self.writer.start('robot') self.writer.content('Hello world!') self._verify('<robot>\nHello world!') def test_content_with_non_ascii_data(self): self.writer.start('robot', newline=False) self.writer.content(u'Circle is 360\xB0. ') self.writer.content(u'Hyv\xE4\xE4 \xFC\xF6t\xE4!') self.writer.end('robot', newline=False) expected = u'Circle is 360\xB0. Hyv\xE4\xE4 \xFC\xF6t\xE4!' self._verify('<robot>%s</robot>' % expected) def test_multiple_content(self): self.writer.start('robot') self.writer.content('Hello world!') self.writer.content('Hi again!') self._verify('<robot>\nHello world!Hi again!') def test_content_with_chars_needing_escaping(self): self.writer.content('Me, "Myself" & I > U') self._verify('Me, "Myself" & I > U') def test_content_alone(self): self.writer.content('hello') self._verify('hello') def test_none_content(self): self.writer.start('robot') self.writer.content(None) self.writer.content('') self._verify('<robot>\n') def test_element(self): self.writer.element('div', 'content', {'id': '1'}) self.writer.element('i', newline=False) self._verify('<div id="1">content</div>\n<i></i>') def test_line_separator(self): output = StringIO() writer = HtmlWriter(output) writer.start('b') writer.end('b') writer.element('i') assert_equal(output.getvalue(), '<b>\n</b>\n<i></i>\n') def test_non_ascii(self): self.output = StringIO() writer = HtmlWriter(self.output) writer.start(u'p', attrs={'name': u'hyv\xe4\xe4'}, newline=False) writer.content(u'y\xf6') writer.element('i', u't\xe4', newline=False) writer.end('p', newline=False) self._verify(u'<p name="hyv\xe4\xe4">y\xf6<i>t\xe4</i></p>') def _verify(self, expected): assert_equal(self.output.getvalue(), expected)
def _add_long_step_and_save(self, format): data = create_test_case_file() data.testcase_table.tests[0].add_step(['A kw', '1', '2', '3', '4', '6', '7', '8']) output = StringIO() data.save(format=format, output=output) return output.getvalue().strip()
def setUp(self): result = ExecutionResult(StringIO(GOLDEN_XML), StringIO(GOLDEN_XML), StringIO(GOLDEN_XML), merge=True) self.suite = result.suite self.test = self.suite.tests[0]
def test_custom_stdout(self): stdout = StringIO() assert_equal(run_without_outputs(self.data, stdout=stdout), 1) self._assert_output(stdout, [('Pass And Fail', 2), ('Output:', 1), ('Log:', 0), ('Report:', 0)]) self._assert_outputs()
def _xml_lines(self, text): with ETSource(text) as source: tree = ET.parse(source) output = StringIO() tree.write(output) return output.getvalue().splitlines()
def test_custom_stderr(self): stderr = StringIO() assert_equal(run_without_outputs(self.warn, stderr=stderr), 0) self._assert_output(stderr, [('[ WARN ]', 4), ('[ ERROR ]', 2)]) self._assert_outputs([('Warnings And Errors', 2), ('Output:', 1), ('Log:', 0), ('Report:', 0)])
def test_unknown_elements_cause_an_error(self): assert_raises(DataError, ExecutionResult, StringIO('<some_tag/>'))
def _add_long_step_and_save(self, format): data = create_test_case_file() data.testcase_table.tests[0].add_step(["A kw", "1", "2", "3", "4", "6", "7", "8"]) output = StringIO() data.save(format=format, output=output) return output.getvalue().strip()
def test_failed_test(self): tc = ExecutionResult(StringIO(SUITE_TEARDOWN_FAILED)).suite.tests[1] assert_equal(tc.status, 'FAIL') assert_equal(tc.message, 'Message\n\n' 'Also parent suite teardown failed:\nXXX')
def setUp(self): robottime.TIMESTAMP_CACHE = _FakeTimeCache() FileLogger._get_writer = lambda *args: StringIO() self.logger = FileLogger('whatever', 'INFO')
def _dump(self, data): output = StringIO() JsonDumper(output).dump(data) return output.getvalue()