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

我们再来看 src/robot/run.py 的工作原理。摘录部分代码:

from robot.conf import RobotSettings
from robot.model import ModelModifier
from robot.output import LOGGER, pyloggingconf
from robot.reporting import ResultWriter
from robot.running import TestSuiteBuilder
from robot.utils import Application, unic, text

class RobotFramework(Application):

    def __init__(self):
        Application.__init__(self, USAGE, arg_limits=(1,),
                             env_options='ROBOT_OPTIONS', logger=LOGGER)

    def main(self, datasources, **options):
        ......

def run_cli(arguments=None, exit=True):
    if arguments is None:
        arguments = sys.argv[1:]
    return RobotFramework().execute_cli(arguments, exit=exit)


def run(*tests, **options):
   return RobotFramework().execute(*tests, **options)


if __name__ == '__main__':
    run_cli(sys.argv[1:])

在上一章我们提到Java的命令行入口其实最终还是转到了其它入口点，例如robot.run的run_cli(mytests.robot)  

这里就先看第51行的run_cli方法 ，方法很简单，只是调用了RobotFramework类中的execute_cli方法。RobotFramework是run.py的一个内部类，也是Application的子类。通过第6行的 from robot.utils import Application可查看Application是做什么的。

src/robot/utils/application.py

摘录部分代码：

class Application(object):

    def __init__(self, usage, name=None, version=None, arg_limits=None,
                 env_options=None, logger=None, **auto_options):
        self._ap = ArgumentParser(usage, name, version, arg_limits,
                                  self.validate, env_options, **auto_options)
        self._logger = logger or DefaultLogger()

    def main(self, arguments, **options):
        raise NotImplementedError

......

    def execute_cli(self, cli_arguments, exit=True):
        with self._logger:
            self._logger.info('%s %s' % (self._ap.name, self._ap.version))
            options, arguments = self._parse_arguments(cli_arguments)
            rc = self._execute(arguments, options)
        if exit:
            self._exit(rc)
        return rc
    def _parse_arguments(self, cli_args):
        try:
            options, arguments = self.parse_arguments(cli_args)
        except Information as msg:
            self._report_info(msg.message)
        except DataError as err:
            self._report_error(err.message, help=True, exit=True)
        else:
            self._logger.info('Arguments: %s' % ','.join(arguments))
            return options, arguments

    def parse_arguments(self, cli_args):
        """Public interface for parsing command line arguments.

        :param    cli_args: Command line arguments as a list
        :returns: options (dict), arguments (list)
        :raises:  :class:`~robot.errors.Information` when --help or --version used
        :raises:  :class:`~robot.errors.DataError` when parsing fails
        """
        return self._ap.parse_args(cli_args)

    def execute(self, *arguments, **options):
        with self._logger:
            self._logger.info('%s %s' % (self._ap.name, self._ap.version))
            return self._execute(list(arguments), options)

    def _execute(self, arguments, options):
        try:
            rc = self.main(arguments, **options)
        except DataError as err:
            return self._report_error(err.message, help=True)
        except (KeyboardInterrupt, SystemExit):
            return self._report_error('Execution stopped by user.',
                                      rc=STOPPED_BY_USER)
        except:
            error, details = get_error_details(exclude_robot_traces=False)
            return self._report_error('Unexpected error: %s' % error,
                                      details, rc=FRAMEWORK_ERROR)
        else:
            return rc or 0

Application的execute_cli方法，其实也只是做了参数的解析工作（请看第17行 和 第18行的方法调用），具体的任务如何执行交给了本实例的main方法（第50行）。那么仍然回到 src/robot/run.py 看RobotFramework的main方法：

    def main(self, datasources, **options):
        settings = RobotSettings(options)
        LOGGER.register_console_logger(**settings.console_output_config)
        LOGGER.info('Settings:\n%s' % unic(settings))
        builder = TestSuiteBuilder(settings['SuiteNames'],
                                   extension=settings.extension,
                                   rpa=settings.rpa)
        suite = builder.build(*datasources)
        settings.rpa = builder.rpa
        suite.configure(**settings.suite_config)
        if settings.pre_run_modifiers:
            suite.visit(ModelModifier(settings.pre_run_modifiers,
                                      settings.run_empty_suite, LOGGER))
        with pyloggingconf.robot_handler_enabled(settings.log_level):
            old_max_error_lines = text.MAX_ERROR_LINES
            text.MAX_ERROR_LINES = settings.max_error_lines
            try:
                result = suite.run(settings)
            finally:
                text.MAX_ERROR_LINES = old_max_error_lines
            LOGGER.info("Tests execution ended. Statistics:\n%s"
                        % result.suite.stat_message)
            if settings.log or settings.report or settings.xunit:
                writer = ResultWriter(settings.output if settings.log
                                      else result)
                writer.write_results(settings.get_rebot_settings())
        return result.return_code

在这个方法里，进行了设置项的赋值（第2行），真正执行测试并输出测试结果（第18行）。通过第5，8，18行可以看到测试的执行过程首先是通过TestSuiteBuilder构建了一个suite，然后执行该suite的run方法。那么我们来看看TestSuiteBuilder是如何构建一个suite的。

通过from robot.running import TestSuiteBuilder可以知道TestSuiteBuilder是在robot.running路径下，我们先看看这个包的__init__.py

from .builder import TestSuiteBuilder, ResourceFileBuilder
from .context import EXECUTION_CONTEXTS
from .model import Keyword, TestCase, TestSuite
from .testlibraries import TestLibrary
from .usererrorhandler import UserErrorHandler
from .userkeyword import UserLibrary
from .runkwregister import RUN_KW_REGISTER

由第1行可以看出TestSuiteBuilder在 src/robot/running/builder.py：摘录的部分代码：

class TestSuiteBuilder(object):

    def __init__(self, include_suites=None, warn_on_skipped='DEPRECATED',
                 extension=None, rpa=None):
        self.include_suites = include_suites
        self.extensions = self._get_extensions(extension)
        builder = StepBuilder()
        self._build_steps = builder.build_steps
        self._build_step = builder.build_step
        self.rpa = rpa
        self._rpa_not_given = rpa is None
        # TODO: Remove in RF 3.2.
        if warn_on_skipped != 'DEPRECATED':
            warnings.warn("Option 'warn_on_skipped' is deprecated and has no "
                          "effect.", DeprecationWarning)
......

    def build(self, *paths):
        """
        :param paths: Paths to test data files or directories.
        :return: :class:`~robot.running.model.TestSuite` instance.
        """
        if not paths:
            raise DataError('One or more source paths required.')
        if len(paths) == 1:
            return self._parse_and_build(paths[0])
        root = TestSuite()
        for path in paths:
            root.suites.append(self._parse_and_build(path))
        root.rpa = self.rpa
        return root
......

build方法的最后返回了一个TestSuite对象。走到这里好像有点太快了，为了更好的理解这个TestSuite，我们回过头来,顺藤摸瓜看看这个build的参数paths是什么:  def build(self, *paths)(builder.py) <-- builder.build(*datasources) (run.py)<-- def main(self, datasources, **options): <-- self.main(arguments, **options)(Application.py) <-- def _execute(self, arguments, options): <-- self._execute(arguments, options) <-- def execute_cli(self, cli_arguments, exit=True):(Application.py) <--RobotFramework().execute_cli(arguments, exit=exit)(run.py) <-- def run_cli(arguments=None, exit=True):(run.py)

原来这个paths是命令后选项参数或者是方法调用时传递过来的参数。例如

from robot import run_cli

# Run tests and return the return code.
rc = run_cli(['--name', 'Example', 'tests.robot'], exit=False)

# Run tests and exit to the system automatically.
run_cli(['--name', 'Example', 'tests.robot'])

或者 像第一篇文章中 java -jar robotframework.jar run mytests.robot这个命令，经过JarRunner解析会最终调用robot.run的run_cli("mytests.robot")这个方法

所以这个TestSuiteBuilder的目的是通过解析datasource来构建一个TestSuite ，接着回到builder.py的 build方法最后的TestSuite对象上，来看看TestSuite什么。

通过robot.running的_init_.py ：from .model import Keyword, TestCase, TestSuite，可以看出TestSuite在 src/robot/running/model.py，摘录有关TestSuite的代码：

class TestSuite(model.TestSuite):
    """Represents a single executable test suite.

    See the base class for documentation of attributes not documented here.
    """
    __slots__ = ['resource']
    test_class = TestCase    #: Internal usage only.
    keyword_class = Keyword  #: Internal usage only.

    def __init__(self,  name='', doc='', metadata=None, source=None, rpa=False):
        model.TestSuite.__init__(self, name, doc, metadata, source, rpa)
        #: :class:`ResourceFile` instance containing imports, variables and
        #: keywords the suite owns. When data is parsed from the file system,
        #: this data comes from the same test case file that creates the suite.
        self.resource = ResourceFile(source=source)
。。。。。。
    def run(self, settings=None, **options):
        from .namespace import IMPORTER
        from .signalhandler import STOP_SIGNAL_MONITOR
        from .runner import Runner

        with LOGGER:
            if not settings:
                settings = RobotSettings(options)
                LOGGER.register_console_logger(**settings.console_output_config)
            with pyloggingconf.robot_handler_enabled(settings.log_level):
                with STOP_SIGNAL_MONITOR:
                    IMPORTER.reset()
                    output = Output(settings)
                    runner = Runner(output, settings)
                    self.visit(runner)
                output.close(runner.result)
        return runner.result

通过第10行的__init__方法可以看到，TestSuite初始化的时候包括name,doc,metadata,import,Variabel等数据。通过同一个图片我想大家应该就可以更 好的理解这里封装的信息了：

是的，就是这个可视化工具RIDE里的信息.当然这个类里面封装的信息并不全，因为它是model.TestSuite的子类，在父类中封装了更多的信息。

仍然回到  src/robot/run.py 的main方法，suite构建后会调用suite.run方法收集result。看 TestSuite类的第31行 self.visit(runner)，这个visit方法都做了写什么？参数runner有时什么呢？ 我们先在父类中看visit方法

/src/robot/model/testsuite.py

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

方法很简单，只是去调用这个runner参数的visit_suite()方法。我们通过TestSuite类run方法中的from .runner import Runner可以知道 这个runner参数是:

src/robot/running/runner.py

class Runner(SuiteVisitor):

 3 。。。。。。

Runner是SuiteVisitor的子类，里面并没有visit_suite 方法。去看看SuiteVisitor。 通过model包__init__.py的 from .visitor import SuiteVisitor 可知，SuiteVisitor在  /src/robot/model/visitor.py，摘录部分代码:

class SuiteVisitor(object):
    """Abstract class to ease traversing through the test suite structure.

    See the :mod:`module level <robot.model.visitor>` documentation for more
    information and an example.
    """

    def visit_suite(self, suite):
        """Implements traversing through the suite and its direct children.

        Can be overridden to allow modifying the passed in ``suite`` without
        calling :func:`start_suite` or :func:`end_suite` nor visiting child
        suites, tests or keywords (setup and teardown) at all.
        """
        if self.start_suite(suite) is not False:
            suite.keywords.visit(self)
            suite.suites.visit(self)
            suite.tests.visit(self)
            self.end_suite(suite)

    def start_suite(self, suite):
        """Called when suite starts. Default implementation does nothing.

        Can return explicit ``False`` to stop visiting.
        """
        pass

    def end_suite(self, suite):
        """Called when suite ends. Default implementation does nothing."""
        pass

在visit_suite方法中，开始了测试的执行，start_suite,end_suite 都在Runner具体实现. 今天先写到这里，下一章再接着分析visit_suite()里调用的各个方法的具体实现.

 

如果喜欢作者的文章，请关注"写代码的猿"订阅号以便第一时间获得最新内容。本文版权归作者所有，欢迎转载.