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, '')
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_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
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 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)])
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):
self.output = StringIO()
self.writer = HtmlWriter(self.output)
def setUp(self):
robottime.TIMESTAMP_CACHE = _FakeTimeCache()
FileLogger._get_writer = lambda *args: StringIO()
self.logger = FileLogger('whatever', 'INFO')
def __init__(self):
self._output = StringIO()
def _dump(self, data):
output = StringIO()
JsonDumper(output).dump(data)
return output.getvalue()
