RobotFramework学习系列(二)

 上一篇文章大概讲了RobotFramework 构建测试套件部分。这篇文章讲一下如何从文本文件(.txt或者.robot文件)到Robot进行测试数据结构的转化。以下面的文件为例test.txt

*** Settings ***
Suite Setup       Initialize
Suite Teardown    Clear
Resource          ../Test_Run_Call.txt

*** Test Cases ***
Init_Env
    log    Status is OK!

Scope_Test
    log    Status is OK!

    def _parse(self, path):
        try:
            return TestData(source=abspath(path),
                            include_suites=self.include_suites,
                            warn_on_skipped=self.warn_on_skipped)
        except DataError, err:
            raise DataError("Parsing '%s' failed: %s" % (path, unicode(err)))

　　由文件到Robot数据结构主要是通过_parse这个函数来完成。也就是TestData这个函数来完成(虽然看着像一个类，但其不是哦~不要被它欺骗)

# robot/parsing/model.py
def TestData(parent=None, source=None, include_suites=None,
             warn_on_skipped=False):
    if os.path.isdir(source):
        return TestDataDirectory(parent, source).populate(include_suites,
                                                          warn_on_skipped)
    return TestCaseFile(parent, source).populate()

 　　由上面的源码可以得知，此处根据传入的source类型不同，而调用不同的类。当source为文件时，调用TestCaseFile这个类进行构建，而当source为目录时，调用TestDataDirectory进行构建。这也说明，robot支持指定单独的文件(suite)，也支持指定包含许多文件(Suite)目录。下面以TestCaseFile这个类进行分析。

class TestCaseFile(_TestData):

    def __init__(self, parent=None, source=None):
        self.directory = os.path.dirname(source) if source else None
        self.setting_table = TestCaseFileSettingTable(self)
        self.variable_table = VariableTable(self)
        self.testcase_table = TestCaseTable(self)
        self.keyword_table = KeywordTable(self)
        _TestData.__init__(self, parent, source)

    def populate(self):
        FromFilePopulator(self).populate(self.source)
        self._validate()
        return self

    def _validate(self):
        if not self.testcase_table.is_started():
            raise DataError('File has no test case table.')

    def _table_is_allowed(self, table):
        return True

    def has_tests(self):
        return True

    def __iter__(self):
        for table in [self.setting_table, self.variable_table,
                      self.testcase_table, self.keyword_table]:
            yield table

　　简单画了一下TestCaseFile所关联的类，可能会比较容易理解

 　　TestCaseFile初始化时会赋值4种属性，包括setting_table，variable_table，testcase_table，keyword_table。通过类初始化时传递self的方式，将属性类变量与自身联系。这4种table都继承于_Table，不同的是TestCaseFileSettingTable先继承于_SettingTable，而其多继承于_Table和_WithSettings

　　TestCaseFile(parent, source)的构建发生发生了以下几种操作

　　1、TestCaseFileSettingTable（继承于_SettingTable）初始化，添加了doc，suite_setup，suite_teardown ...... 等等的内部属性，这些属性都是各种类(Documentation, Fixture，Tags，ImportList等等)的实例

　　2、VariableTable、TestCaseTable以及KeyWordTable（继承于_Table）初始化，这些类，主要是内部有一个列表，用于将来对解析出来的对象进行保存

　　好了，接下来就来到了重点populate() 这个函数真是真是，太复杂了，一个函数完成了文件解析以及往TestCaseFile类中添加各种数据

    def populate(self):
        FromFilePopulator(self).populate(self.source)
        self._validate()
        return self

　　这个函数主要是调用了FromFilePopulator这个类的populate函数，源码如下，这个类内部维持一个字典_populators，看到这个字典基本上就有点恍然大悟，内部就是四种解析器对应TestCaseFile内部的四种变量，可以很明确的说它们就是相互对应的。

　　这个对象构建的时候，创建了三个内部变量，_datafile保存了传入的TestCaseFile类实例，_poplator被赋值了一个NullPopulator()这个是一个空的解析器，只是为了占位，_curdir是获取了文件所在的位置。

　　populate(self, path)，此处path是传入的self.source(在TestCaseFile构建时，传入的_Table中的属性)，为具体的文件。具体所做的事情，已经在下面的源码中标记了。其中关键部分由_get_reader这个私有方法实现

READERS = {'html': HtmlReader, 'htm': HtmlReader, 'xhtml': HtmlReader,
           'tsv': TsvReader , 'rst': RestReader, 'rest': RestReader,
           'txt': TxtReader, 'robot': TxtReader}

class FromFilePopulator(object):
    _populators = {'setting': SettingTablePopulator,
                   'variable': VariableTablePopulator,
                   'test case': TestTablePopulator,
                   'keyword': KeywordTablePopulator}

    def __init__(self, datafile):
        self._datafile = datafile
        self._populator = NullPopulator()
        self._curdir = self._get_curdir(datafile.directory)

    def _get_curdir(self, path):
        return path.replace('\','\\') if path else None

    def populate(self, path):
        LOGGER.info("Parsing file '%s'." % path)
        source = self._open(path)       <<<=================     调用内部的私有方法，简单的打开文件而已 
        try:
            self._get_reader(path).read(source, self)   
        except:
            raise DataError(get_error_message())
        finally:
            source.close()              <<<=================      和上面向对应，关闭打开的文件        

    def _open(self, path):
        if not os.path.isfile(path):
            raise DataError("Data source does not exist.")
        try:
            # IronPython handles BOM incorrectly if not using binary mode:
            # http://code.google.com/p/robotframework/issues/detail?id=1580
            return open(path, 'rb')
        except:
            raise DataError(get_error_message())

    def _get_reader(self, path):
        extension = os.path.splitext(path.lower())[-1][1:]  <<<========获取文件的扩展名，假如文件为test.txt，extension为txt，如果文件为test.robot,extension为robot
        try:
            return READERS[extension]()   <<<=========根据文件扩展名不同,从READERS中获取处理文件的类名，并实例化(通过 “()”)                   
        except KeyError:
            raise DataError("Unsupported file format '%s'." % extension)

    def start_table(self, header):
        self._populator.populate()
        table = self._datafile.start_table(DataRow(header).all)
        self._populator = self._populators[table.type](table) 
                if table is not None else NullPopulator()
        return bool(self._populator)

    def eof(self):
        self._populator.populate()

    def add(self, row):
        if PROCESS_CURDIR and self._curdir:
            row = self._replace_curdirs_in(row)
        data = DataRow(row)
        if data:
            self._populator.add(data)

    def _replace_curdirs_in(self, row):
        return [cell.replace('${CURDIR}', self._curdir) for cell in row]

　　这里以txt文件为例，READERS[extension]()返回的是TxtReader()，TxtReader实际继承于TsvReader。可以直接看TsvReader的源码。

　　读文件部分，RobotFramework单独封装了一个Uft8Reader类，保证读出来的数据不会出现编码问题。Utf8Reader(tsvfile).readlines()只是简单的返回数据单独行的一个列表。相当于file.readlines()

　　主要处理的部分是11~16行。process为标志处理

NBSP = u'xA0'


class TsvReader(object):

    def read(self, tsvfile, populator):
        process = False
        for row in Utf8Reader(tsvfile).readlines():
            row = self._process_row(row)   <<<========= 处理空格      
            cells = [self._process_cell(cell) for cell in self.split_row(row)]   <<<=========处理换行符 以及包含 | |的行
            if cells and cells[0].strip().startswith('*') and 
                    populator.start_table([c.replace('*', '') for c in cells]):
                process = True
            elif process:
                populator.add(cells)
        populator.eof()

    def _process_row(self, row):
        if NBSP in row:
            row = row.replace(NBSP, ' ')
        return row.rstrip()

    @classmethod
    def split_row(cls, row):
        return row.split('	')

    def _process_cell(self, cell):
        if len(cell) > 1 and cell[0] == cell[-1] == '"':
            cell = cell[1:-1].replace('""', '"')
        return cell

 　　　此时populator实例为FromFilePopulator(), start_table传入的变量为每一行数据去除*的部分，如文章开头定义的test.txt，此时传入的数据为Settings，注意，此时row会处理成cells，为一个列表类型。start_table的主要作用是解析文件的各个部分的头部，确定下面的部分由哪个解析器进行解析。

    def start_table(self, header):
        self._populator.populate()
        table = self._datafile.start_table(DataRow(header).all)
        self._populator = self._populators[table.type](table) 
                if table is not None else NullPopulator()
        return bool(self._populator)

　　DataRow会将文件的行数据(此时为行数据的列表)进行转化，并根据是否以"#"开头转化成comment。这个类内置很多使用@property进行获取的属性DataRow(header).all便是返回所有非#开头的字段

　　此处self._datafile为上文提到的TestCaseFile类实例，所以此时调用的start_table是为TestCaseFile的方法，而这个方法是从_TestData继承来的

    def start_table(self, header_row):
        try:
            table = self._tables[header_row[0]]
        except (KeyError, IndexError):
            return None
        if not self._table_is_allowed(table):
            return None
        table.set_header(header_row)
        return table

　　header_row[0]所取即为刚刚所讲DataRow(header).all中的第一个数据，拿文章开头的文件为例，即为Settings。

　　self._tables  实际为TestCaseFile初始化时，构成的一个字典映射，贴一下代码和实际结构，构造在初始化时。其中self.setting_table,self.variable_table即为刚开始讲TestCaseFile时所列的四个变量对应的类实例~是不是有似曾相识的感觉

class _TestData(object):
    _setting_table_names = 'Setting', 'Settings', 'Metadata'
    _variable_table_names = 'Variable', 'Variables'
    _testcase_table_names = 'Test Case', 'Test Cases'
    _keyword_table_names = 'Keyword', 'Keywords', 'User Keyword', 'User Keywords'

    def __init__(self, parent=None, source=None):
        self.parent = parent
        self.source = utils.abspath(source) if source else None
        self.children = []
        self._tables = utils.NormalizedDict(self._get_tables())

    def _get_tables(self):
        for names, table in [(self._setting_table_names, self.setting_table),
                             (self._variable_table_names, self.variable_table),
                             (self._testcase_table_names, self.testcase_table),
                             (self._keyword_table_names, self.keyword_table)]:
            for name in names:
                yield name, table

    def start_table(self, header_row):
        try:
            table = self._tables[header_row[0]]
        except (KeyError, IndexError):
            return None
        if not self._table_is_allowed(table):
            return None
        table.set_header(header_row)
        return table

　　

 　　此处table通过字典和key，可以选出具体是哪个table，如果是Settings，则为TestCaseSettingTable，如果是Test Cases，则为TestCaseTable 等等。。

　　此处拿TestCaseSettingTable为例，后执行set_header(head_now)，此处是为了兼容老的头部写法，这块可以看一下代码，很简单

　　Ok。table的具体实例拿到了。

self._populator = self._populators[table.type](table)  if table is not None else NullPopulator()

　　table.type是获取table的属性，为setting. self._populators，文章前面也讲过，是四种映射组成的字典。ok，确定了数据为Setting类型，那么解析器就是SettingTablePopulator了。所以self._populator的赋值同样找到了。

　　go on~

　　按照robot文件的写法，头部完成后，会根据头部，确定下面的写法。后续调用populator.add(cells)对后续的数据继续解析，解析器解析其中的数据往table中写入数据。

　　基本的逻辑就是：

　　　　需要解析文件(TeseCaseFile)，需要对应解析的解析器(FromFilePopulator)，所以需要找对应的解析器根据文件类型确定文件的读方法(TxtReader)，然后根据读出来的部分，确认Section(SettingTestCase等等)确定保存数据的表(TestCaseSettingTable, KeyWordTable等等)以及用来解析数据的解析器(SettingTablePopulator,VariableTablePopulator)等等，后续的数据解析基本上就没有问题啦