【Python】【Xmind】解析工具 xmind用例转为excel用例(不限级数 多少级都可以)

 

一、图标说明

 

 

二、效果

xmind备注

【前置条件】
【操作步骤】
【SQL校验】
【预期结果】
【备注】

 

三、解析XMind

备注:已封装好 可直接调用

JarExcelUtil工具类:https://www.cnblogs.com/danhuai/p/13538291.html

Xmind版本:XMind 8

"""
-*- coding:utf-8 -*-
@Time   :2020/9/4 15:07
@Author :维斯
@File   :jar_xmind_util.py
@Version:1.0
"""
import json

import xmind

from common.jar_excel_util import JarExcelUtil


class JarXmindUtil:
    def __init__(self):
        # markers字段 "markers": ["star-orange"]
        self.model = ['star-dark-gray', '$所属模块$']  # [所属模块(灰色星星标志),标识]
        self.check = ['star-orange', '$验证点$']  # [验证点(黄色星星标志),标识]
        self.except_case = ['people-red', '$异常$']  # [异常用例(红色人像标志),标识]
        self.normal_case = ['people-green', '$正常$']  # [正常用例(绿色人像标志),标识]
        self.priority_1 = ['priority-1', '$高$']  # [重要级别-高(1号优先级标志),标识]
        self.priority_2 = ['priority-2', '$中$']  # [重要级别-中(2号优先级标志),标识]
        self.priority_3 = ['priority-3', '$低$']  # [重要级别-低(3号优先级标志),标识]

        # 汇总
        self.all_markers = [self.model,
                            self.check,
                            self.except_case,
                            self.normal_case,
                            self.priority_1,
                            self.priority_2,
                            self.priority_3
                            ]

        self.note = ['note', '$备注节点$']
        self.comment = ['comment', '$批注节点$']

        # 节点分割符
        self.node_split = ' /'  # 节点分割符
        self.node_split_excel = ' /'  # 写入表格中的多节点分割符
        # 预期结果分割符
        self.node_expect_split = '预期结果:'

        # 用例编号前缀
        self.case_number_model = 'CASE_200917'  # 生成的用例编号 如 CASE_200917000001、CASE_200917000002

        # Xmind备注信息模板解析(严格按照此顺序解析)
        self.xmind_note_model = [['【前置条件】', '内容'],
                                 ['【操作步骤】', '内容'],
                                 ['【SQL校验】', '内容'],
                                 ['【预期结果】', '内容'],
                                 ['【备注】', '内容']]

        # 测试用例表格
        self.headers = [
            ['用例编号', len(self.case_number_model) + 5 + 5],  # 长度多5个字符
            ['用例类型'],
            ['重要级别'],
            ['所属模块', 20],
            ['验证点', 20],
            ['用例标题', 60],
            ['前置条件', 12],
            ['操作步骤', 12],
            ['SQL校验', 12],
            ['预期结果', 12],
            ['备注', 12]
        ]

    @staticmethod
    def del_endswith_none(str1: str):
        """
        删除字符串首尾的空字符(空格、换行)
        :param str1:
        """
        s = str1
        if str1 is not None:
            while True:
                if s.endswith(' ') or s.endswith('    ') or s.endswith('\r\n') or s.endswith('\r') or s.endswith('\n'):
                    s = s[:-1]
                elif s.startswith(' ') or s.startswith('    ') or s.startswith('\r\n') or s.startswith(
                        '\r') or s.startswith('\n'):
                    s = s[1:]
                else:
                    break
        return s

    def to_excel(self, out_file, result_node: list):
        """
        解析的Xmind数据写入表格文件
        :param out_file: 表格文件
        :param result_node: 列表 每一个元素为一个完整的xmind路径
        """
        body_data = []
        count = 0
        for re in result_node:
            count += 1
            # 1 分割某链路所有节点
            node_list = re.split(self.node_split)
            # 2 判断节点属性
            re_model = ''  # 所属模块
            re_check = ''  # 验证点
            re_case_type = ''  # 用例类型
            re_case_name = ''  # 用例标题
            re_priority = ''  # 重要级别
            re_expect = ''  # 预期结果
            re_note = ''  # 备注(xmind中的备注)
            re_comment = ''  # 批注(xmind中的批注)

            for n in node_list:
                n: str
                # 2.1 所属模块
                if n.startswith(self.model[1]):
                    re_model += n.replace(self.model[1], '') + self.node_split_excel
                # 2.3 验证点
                if n.startswith(self.check[1]):
                    re_check += n.replace(self.check[1], '') + self.node_split_excel
                # 2.4 用例类型&用例标题
                if n.startswith(self.except_case[1]) or n.startswith(self.normal_case[1]):
                    if n.startswith(self.except_case[1]):
                        re_case_type = self.except_case[1][1:-1]
                        re_case_type_swap1 = n.split(self.except_case[1])
                        if re_case_type_swap1 == 3:
                            re_case_name += re_case_type_swap1[1] + self.node_split_excel
                        else:
                            re_case_name += n.replace(self.except_case[1], '') + self.node_split_excel
                    if n.startswith(self.normal_case[1]):
                        re_case_type = self.normal_case[1][1:-1]
                        re_case_type_swap2 = n.split(self.normal_case[1])
                        if re_case_type_swap2 == 3:
                            re_case_name += re_case_type_swap2[1] + self.node_split_excel
                        else:
                            re_case_name += n.replace(self.normal_case[1], '') + self.node_split_excel
                # 2.5 重要级别
                if n.startswith(self.priority_1[1]):
                    re_priority = self.priority_1[1][1:-1]
                if n.startswith(self.priority_2[1]):
                    re_priority = self.priority_2[1][1:-1]
                if n.startswith(self.priority_3[1]):
                    re_priority = self.priority_3[1][1:-1]
                # 2.6 预期结果
                re_expect = n[n.find(self.node_expect_split):]
                re_expect = re_expect[len(self.node_expect_split):]
                re_expect = self.del_endswith_none(re_expect)
                # 2.7 备注
                re_note_swap = n.split(self.note[1])
                if len(re_note_swap) == 3:
                    re_note = re_note_swap[1]
                # 2.8 批注
                re_comment_swap = n.split(self.comment[1])
                if len(re_comment_swap) == 3:
                    re_comment = re_comment_swap[1]

            # 删除末尾的分割符
            length = len(self.node_split_excel)
            re_model = re_model[:len(re_model) - length]
            re_check = re_check[:len(re_check) - length]
            re_case_name = re_case_name[:len(re_case_name) - length]
            # 删除用例名称后的 预期结果、空格、换行
            index = re_case_name.find(self.node_expect_split)
            re_case_name = re_case_name[:None if index == -1 else index]
            re_case_name = self.del_endswith_none(re_case_name)

            # 解析XMind中的备注信息
            for n in range(len(self.xmind_note_model)):
                # 提取名称(如:【前置条件】 提取为 前置条件) 分别去除前后1个字符
                n_name = self.xmind_note_model[n][1:-1]
                # 提取此名称下的数据(如:提取哪些内容是前置条件)  截取XMind中备注信息中 n至n+1中的数据
                if n < len(self.xmind_note_model) - 1:
                    n_data = re_note[
                             re_note.find(self.xmind_note_model[n][0]):re_note.find(self.xmind_note_model[n + 1][0])]
                else:
                    n_data = re_note[re_note.find(self.xmind_note_model[n][0]):]
                n_data = n_data[len(self.xmind_note_model[n][0]):]
                n_data = self.del_endswith_none(n_data)
                self.xmind_note_model[n][1] = n_data

            # 3 拼接节点至指定表格字段
            body = [
                self.case_number_model + str(count).zfill(6),  # 用例编号
                re_case_type,  # 用例类型
                re_priority,  # 重要级别
                re_model,  # 所属模块
                re_check,  # 验证点
                re_case_name,  # 用例标题
                self.xmind_note_model[0][1],  # 前置条件
                self.xmind_note_model[1][1],  # 操作步骤
                self.xmind_note_model[2][1],  # SQL校验
                self.xmind_note_model[3][1],  # 预期结果
                self.xmind_note_model[4][1]  # 备注
            ]
            body_data.append(body)
        JarExcelUtil(header_list=self.headers).write(out_file=out_file, data_body=body_data)
        print('数据写入Excel完成!(路径:{})'.format(out_file))

    @staticmethod
    def analysis(xmind_path):
        """
        解析Xmind文件(获取每条完整路径)
        :param xmind_path: xmind文件
        :return: 返回所有路径list
        """
        wb = xmind.load(xmind_path)
        data = wb.to_prettify_json()
        data = json.loads(data)
        result_data = []
        # 画布
        for data_topic in data:
            # 1级
            data_1 = data_topic.get('topic')
            title_1 = data_1.get('title')

            # 递归后面所有级(2级、3级、......)
            JarXmindUtil().__base(title_1, data_1, result_data)
        print('{},xmind数据解析完成!'.format(xmind_path))
        # print(*result_data, sep='\n')
        return result_data

    def __base(self, title_long_x, data_topics_x, result_data_all):
        """
        递归Xmind所有子标题
        :param title_long_x:
        :param data_topics_x:
        :param result_data_all:
        """
        # 递归所有级
        topics_list = data_topics_x.get('topics')
        for topics in topics_list:  # 循环所有路径
            title = ''
            swap = ''
            # 取节点图标属性
            markers: list = topics.get('markers')
            if len(markers) != 0:
                for marker in markers:  # 循环该节点所有属性
                    for all_mar in self.all_markers:  # 循环预定所有属性值
                        if marker == all_mar[0]:  # 节点markers属性中有预定值

                            # 若是用例名称节点 则获取备注与批注信息
                            if marker == self.all_markers[2][0] or marker == self.all_markers[3][0]:  # 绿色人像或红色人像
                                # 是用例节点
                                s_note = topics.get('note') if topics.get('note') is not None else ''
                                s_comment = topics.get('comment') if topics.get('comment') is not None else ''
                                title = '{}{}{}{}{}'.format(title_long_x + swap, self.node_split,
                                                            all_mar[1] + topics.get('title') +
                                                            all_mar[1] + self.node_split,
                                                            self.note[1] + str(s_note) +
                                                            self.note[1] + self.node_split,  # 备注
                                                            self.comment[1] + str(s_comment) + self.comment[
                                                                1] + self.node_split)  # 批注
                                swap = self.node_split + all_mar[1] + topics.get('title') + all_mar[
                                    1] + self.node_split + self.note[
                                           1] + str(s_note) + self.note[1] + self.node_split + self.comment[
                                           1] + str(s_comment) + self.comment[1]
                            else:
                                # 非用例节点
                                title = '{}{}{}'.format(title_long_x + swap, self.node_split,
                                                        all_mar[1] + topics.get('title') + all_mar[1] + self.node_split)
                                swap = self.node_split + all_mar[1] + topics.get('title') + all_mar[1]
                            break


                        else:
                            # 循环到最后 没匹配到(说明此标志没有在预定标志中)
                            if markers[len(markers) - 1] == marker \
                                    and self.all_markers[len(self.all_markers) - 1] == all_mar:
                                print('节点:【{}】,在预定标志中未匹配到此标志({})'.format(topics.get('title'), marker))
            else:
                title = '{}{}{}'.format(title_long_x, self.node_split, topics.get('title'))

            # 取节点值
            if topics.get('topics') is not None:
                JarXmindUtil().__base(title, topics, result_data_all)
            else:
                result_data_all.append(title)
                continue


if __name__ == '__main__':
    ju = JarXmindUtil()
    # XMind文件
    path = 'E:\\xxx项目测试用例.xmind'

    # 用例编号前缀
    ju.case_number_model = 'CASE_201101'

    # step1 解析xmind
    result = ju.analysis(path)
    # step2 写入excel
    ju.to_excel('xxx项目测试用例.xlsx', result)

 

posted @ 2020-09-21 11:10  淡怀  阅读(1115)  评论(0编辑  收藏  举报