Robot Framework源码解析(2) - 执行测试的入口点

 1 from robot.conf import RobotSettings
 2 from robot.model import ModelModifier
 3 from robot.output import LOGGER, pyloggingconf
 4 from robot.reporting import ResultWriter
 5 from robot.running import TestSuiteBuilder
 6 from robot.utils import Application, unic, text
 7 
 8 class RobotFramework(Application):
 9 
10     def __init__(self):
11         Application.__init__(self, USAGE, arg_limits=(1,),
12                              env_options='ROBOT_OPTIONS', logger=LOGGER)
13 
14     def main(self, datasources, **options):
15         ......
16 
17 def run_cli(arguments=None, exit=True):
18     if arguments is None:
19         arguments = sys.argv[1:]
20     return RobotFramework().execute_cli(arguments, exit=exit)
21 
22 
23 def run(*tests, **options):
24    return RobotFramework().execute(*tests, **options)
25 
26 
27 if __name__ == '__main__':
28     run_cli(sys.argv[1:])

 1 class Application(object):
 2 
 3     def __init__(self, usage, name=None, version=None, arg_limits=None,
 4                  env_options=None, logger=None, **auto_options):
 5         self._ap = ArgumentParser(usage, name, version, arg_limits,
 6                                   self.validate, env_options, **auto_options)
 7         self._logger = logger or DefaultLogger()
 8 
 9     def main(self, arguments, **options):
10         raise NotImplementedError
11 
12 ......
13 
14     def execute_cli(self, cli_arguments, exit=True):
15         with self._logger:
16             self._logger.info('%s %s' % (self._ap.name, self._ap.version))
17             options, arguments = self._parse_arguments(cli_arguments)
18             rc = self._execute(arguments, options)
19         if exit:
20             self._exit(rc)
21         return rc
22     def _parse_arguments(self, cli_args):
23         try:
24             options, arguments = self.parse_arguments(cli_args)
25         except Information as msg:
26             self._report_info(msg.message)
27         except DataError as err:
28             self._report_error(err.message, help=True, exit=True)
29         else:
30             self._logger.info('Arguments: %s' % ','.join(arguments))
31             return options, arguments
32 
33     def parse_arguments(self, cli_args):
34         """Public interface for parsing command line arguments.
35 
36         :param    cli_args: Command line arguments as a list
37         :returns: options (dict), arguments (list)
38         :raises:  :class:`~robot.errors.Information` when --help or --version used
39         :raises:  :class:`~robot.errors.DataError` when parsing fails
40         """
41         return self._ap.parse_args(cli_args)
42 
43     def execute(self, *arguments, **options):
44         with self._logger:
45             self._logger.info('%s %s' % (self._ap.name, self._ap.version))
46             return self._execute(list(arguments), options)
47 
48     def _execute(self, arguments, options):
49         try:
50             rc = self.main(arguments, **options)
51         except DataError as err:
52             return self._report_error(err.message, help=True)
53         except (KeyboardInterrupt, SystemExit):
54             return self._report_error('Execution stopped by user.',
55                                       rc=STOPPED_BY_USER)
56         except:
57             error, details = get_error_details(exclude_robot_traces=False)
58             return self._report_error('Unexpected error: %s' % error,
59                                       details, rc=FRAMEWORK_ERROR)
60         else:
61             return rc or 0

 1     def main(self, datasources, **options):
 2         settings = RobotSettings(options)
 3         LOGGER.register_console_logger(**settings.console_output_config)
 4         LOGGER.info('Settings:\n%s' % unic(settings))
 5         builder = TestSuiteBuilder(settings['SuiteNames'],
 6                                    extension=settings.extension,
 7                                    rpa=settings.rpa)
 8         suite = builder.build(*datasources)
 9         settings.rpa = builder.rpa
10         suite.configure(**settings.suite_config)
11         if settings.pre_run_modifiers:
12             suite.visit(ModelModifier(settings.pre_run_modifiers,
13                                       settings.run_empty_suite, LOGGER))
14         with pyloggingconf.robot_handler_enabled(settings.log_level):
15             old_max_error_lines = text.MAX_ERROR_LINES
16             text.MAX_ERROR_LINES = settings.max_error_lines
17             try:
18                 result = suite.run(settings)
19             finally:
20                 text.MAX_ERROR_LINES = old_max_error_lines
21             LOGGER.info("Tests execution ended. Statistics:\n%s"
22                         % result.suite.stat_message)
23             if settings.log or settings.report or settings.xunit:
24                 writer = ResultWriter(settings.output if settings.log
25                                       else result)
26                 writer.write_results(settings.get_rebot_settings())
27         return result.return_code

1 from .builder import TestSuiteBuilder, ResourceFileBuilder
2 from .context import EXECUTION_CONTEXTS
3 from .model import Keyword, TestCase, TestSuite
4 from .testlibraries import TestLibrary
5 from .usererrorhandler import UserErrorHandler
6 from .userkeyword import UserLibrary
7 from .runkwregister import RUN_KW_REGISTER

 1 class TestSuiteBuilder(object):
 2 
 3     def __init__(self, include_suites=None, warn_on_skipped='DEPRECATED',
 4                  extension=None, rpa=None):
 5         self.include_suites = include_suites
 6         self.extensions = self._get_extensions(extension)
 7         builder = StepBuilder()
 8         self._build_steps = builder.build_steps
 9         self._build_step = builder.build_step
10         self.rpa = rpa
11         self._rpa_not_given = rpa is None
12         # TODO: Remove in RF 3.2.
13         if warn_on_skipped != 'DEPRECATED':
14             warnings.warn("Option 'warn_on_skipped' is deprecated and has no "
15                           "effect.", DeprecationWarning)
16 ......
17 
18     def build(self, *paths):
19         """
20         :param paths: Paths to test data files or directories.
21         :return: :class:`~robot.running.model.TestSuite` instance.
22         """
23         if not paths:
24             raise DataError('One or more source paths required.')
25         if len(paths) == 1:
26             return self._parse_and_build(paths[0])
27         root = TestSuite()
28         for path in paths:
29             root.suites.append(self._parse_and_build(path))
30         root.rpa = self.rpa
31         return root
32 ......

1 from robot import run_cli
2 
3 # Run tests and return the return code.
4 rc = run_cli(['--name', 'Example', 'tests.robot'], exit=False)
5 
6 # Run tests and exit to the system automatically.
7 run_cli(['--name', 'Example', 'tests.robot'])

 1 class TestSuite(model.TestSuite):
 2     """Represents a single executable test suite.
 3 
 4     See the base class for documentation of attributes not documented here.
 5     """
 6     __slots__ = ['resource']
 7     test_class = TestCase    #: Internal usage only.
 8     keyword_class = Keyword  #: Internal usage only.
 9 
10     def __init__(self,  name='', doc='', metadata=None, source=None, rpa=False):
11         model.TestSuite.__init__(self, name, doc, metadata, source, rpa)
12         #: :class:`ResourceFile` instance containing imports, variables and
13         #: keywords the suite owns. When data is parsed from the file system,
14         #: this data comes from the same test case file that creates the suite.
15         self.resource = ResourceFile(source=source)
16 。。。。。。
17     def run(self, settings=None, **options):
18         from .namespace import IMPORTER
19         from .signalhandler import STOP_SIGNAL_MONITOR
20         from .runner import Runner
21 
22         with LOGGER:
23             if not settings:
24                 settings = RobotSettings(options)
25                 LOGGER.register_console_logger(**settings.console_output_config)
26             with pyloggingconf.robot_handler_enabled(settings.log_level):
27                 with STOP_SIGNAL_MONITOR:
28                     IMPORTER.reset()
29                     output = Output(settings)
30                     runner = Runner(output, settings)
31                     self.visit(runner)
32                 output.close(runner.result)
33         return runner.result

1     def visit(self, visitor):
2         """:mod:`Visitor interface <robot.model.visitor>` entry-point."""
3         visitor.visit_suite(self)

 1 class Runner(SuiteVisitor):
 2 
 3 。。。。。。

 1 class SuiteVisitor(object):
 2     """Abstract class to ease traversing through the test suite structure.
 3 
 4     See the :mod:`module level <robot.model.visitor>` documentation for more
 5     information and an example.
 6     """
 7 
 8     def visit_suite(self, suite):
 9         """Implements traversing through the suite and its direct children.
10 
11         Can be overridden to allow modifying the passed in ``suite`` without
12         calling :func:`start_suite` or :func:`end_suite` nor visiting child
13         suites, tests or keywords (setup and teardown) at all.
14         """
15         if self.start_suite(suite) is not False:
16             suite.keywords.visit(self)
17             suite.suites.visit(self)
18             suite.tests.visit(self)
19             self.end_suite(suite)
20 
21     def start_suite(self, suite):
22         """Called when suite starts. Default implementation does nothing.
23 
24         Can return explicit ``False`` to stop visiting.
25         """
26         pass
27 
28     def end_suite(self, suite):
29         """Called when suite ends. Default implementation does nothing."""
30         pass