Robot Framework 源码阅读 day1 run.py

robot里面run起来的接口主要有两类

run_cli

 def run_cli(arguments):
     """Command line execution entry point for running tests.

     :param arguments: Command line arguments as a list of strings.

     For programmatic usage the :func:`run` function is typically better. It has
     a better API for that usage and does not call :func:`sys.exit` like this
     function.

     Example::

         from robot import run_cli

         run_cli(['--include', 'tag', 'path/to/tests.html'])
     """
     RobotFramework().execute_cli(arguments)

run

def run(*datasources, **options):
    """Executes given Robot Framework data sources with given options.

   ... ... ...

    Example::

        from robot import run

        run('path/to/tests.html', include=['tag1', 'tag2'])
        with open('stdout.txt', 'w') as stdout:
            run('t1.txt', 't2.txt', report='r.html', log='NONE', stdout=stdout)

    Equivalent command line usage::

        robot --include tag1 --include tag2 path/to/tests.html
        robot --report r.html --log NONE t1.txt t2.txt > stdout.txt
    """
    return RobotFramework().execute(*datasources, **options)

我们择其一从 run往下走

return RobotFramework().execute(*datasources, **options)
　　RobotFramework 继承自Application

　　class RobotFramework(Application):

Application基类位于 /robot/utils/applicaiton.py
execute 函数执行并进入main函数体， 

    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)
 #execute 调用私有函数 _execute 执行操作
     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

由于RobotFramwork重写了main() 函数， 所以跳到RobotFramework的main接口执行。

/robot/run.py

   def main(self, datasources, **options):
         print "Enter run.main"
         settings = RobotSettings(options)
         # print settings
         LOGGER.register_console_logger(**settings.console_output_config)
         LOGGER.info('Settings:\n%s' % unic(settings))
         suite = TestSuiteBuilder(settings['SuiteNames'],
                                  settings['WarnOnSkipped']).build(*datasources)
         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):
             result = suite.run(settings)
             print result
             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

STEP 1.

[explian]:
settings = RobotSettings(options)
/robot/conf/settings.py  解析传入参数
class RobotSettings(_BaseSettings):
　　-->继承自 _BaseSettings， 没有单独的__init__ 与基类共用 __init.

　　

STEP 2.
suite = TestSuiteBuilder(settings['SuiteNames'],
                                 settings['WarnOnSkipped']).build(*datasources)

[explian]: class TestSuiteBuilder 会初始化StepBuilder
builder.build_steps/builder.build_step  解析suite里面包含的测试steps or step.

23         self._build_steps = builder.build_steps
24         self._build_step = builder.build_step

 由TestSuiteBuilder.build  生成 TestSuite
/robot/running/builder.py

    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))
         return root

STEP 3.

/robot/model/testsuite.py

 suite.configure(**settings.suite_config)

一些配置参数下发