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_rpa(self): rpa_false = GOLDEN_XML self._validate_rpa(ExecutionResult(StringIO(rpa_false)), False) self._validate_rpa(ExecutionResult(StringIO(rpa_false), rpa=True), True) rpa_true = GOLDEN_XML.replace('rpa="false"', 'rpa="true"') self._validate_rpa(ExecutionResult(StringIO(rpa_true)), True) self._validate_rpa(ExecutionResult(StringIO(rpa_true), rpa=False), False)
def run(suite, **config): result = suite.run(output=None, log=None, report=None, stdout=StringIO(), stderr=StringIO(), **config) return result.suite
def run(suite, **kwargs): config = dict(output=None, log=None, report=None, stdout=StringIO(), stderr=StringIO()) config.update(kwargs) result = suite.run(**config) return result.suite
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 _handle_variables_in_expression(expression, variable_store): variables = None variable_started = False tokens = [] for toknum, tokval, _, _, _ in generate_tokens(StringIO(expression).readline): if variable_started: if toknum == token.NAME: if variables is None: variables = variable_store.as_dict(decoration=False) if tokval not in variables: variable_not_found('$%s' % tokval, variables, deco_braces=False) tokval = 'RF_VAR_' + tokval else: tokens.append((token.ERRORTOKEN, '$')) variable_started = False if toknum == token.ERRORTOKEN and tokval == '$': variable_started = True else: tokens.append((toknum, tokval)) if variables is None: return expression, {} expression = untokenize(tokens).strip() variables = VariableNamespace(variables, variable_store) return expression, variables
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 _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_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 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_equal(output.getvalue(), expected)
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_equal(output.getvalue(), expected)
def test_dont_register_signal_handlers_when_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 setUp(self): self.result = ExecutionResult(StringIO(GOLDEN_XML)) self.suite = self.result.suite self.test = self.suite.tests[0] self.keyword = self.test.keywords[0] self.user_keyword = self.test.keywords[1] self.message = self.keyword.messages[0] self.setup = self.suite.keywords[0] self.errors = self.result.errors
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 setUp(self): result = ExecutionResult(StringIO(GOLDEN_XML)) self._suite = result.suite self._test = self._suite.tests[0] self._keyword = self._test.keywords[0] self._user_keyword = self._test.keywords[1] self._message = self._keyword.messages[0] self._setup = self._suite.keywords[0] self._errors = result.errors
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 _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_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 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_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 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_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_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 _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_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 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_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 \\ \\'])