快速教你如何搭建关键字驱动自动化测试框架？

前言

上篇文章我们已经了解到了数据驱动自动化测试框架是如何构建和驱动测试的！那么这篇文章我们将了解关键字驱动测试又是如何驱动自动化测试完成整个测试过程的。关键字驱动框架是一种功能自动化测试框架，它也被称为表格驱动测试或者基于动作字的测试。关键字驱动的框架的基本工作是将测试用例分成四个不同的部分。首先是测试步骤（Test Step），二是测试步骤中的对象（Test Object），三是测试对象执行的动作(Action)，四是测试对象需要的数据（Test Data）。

其实我们做关键字的驱动的思想，就是把编码从测试用例和测试步骤中分离出来，这样对于不会编码的人员更容易理解自动化，从而让手工测试人员也可以编写自动脚本。（这并不意味这不需要自动化测试人员，对于自动化框架的构建，自动化代码的更新，结构调整等都需要一个技术性的人员）对于测试小的项目的团队，可以有两个手工测试人员和一个自动化测试人员。

项目功能

我们今天将要实现的功能是测试126邮箱的登录及登录后发送一封带附件的邮件

测试地址

https://mail.126.com/

项目目录

接下来我们来看看我们的项目目录是如何设计的，每个目录的功能是用来做什么的？

框架搭建

接下来我们一步一步来考虑如何搭建整个项目及每个py代码文件如何编写？

框架主要功能模块

1.新建util文件夹，并在此文件夹下新建ObjectMap.py文件，主要实现页面元素查找功能的封装

from selenium.webdriver.support.wait import WebDriverWait


def getElement(driver, by, locator):
    '''
    查找单一元素
    :param driver:
    :param by:
    :param locator:
    :return: 元素对象
    '''
    try:
        element = WebDriverWait(driver, 30).until(lambda x : x.find_element(by, locator))
    except Exception as e:
        raise e
    else:
        return element

def getElements(driver, by, locator):
    '''
    获取一组元素
    :param driver:
    :param by:
    :param locator:
    :return: 一组元素对象
    '''
    try:
        elements = WebDriverWait(driver, 30).until(lambda x : x.find_element(by, locator))
    except Exception as e:
        raise e
    else:
        return elements


if __name__=="__main__":
    from selenium import webdriver
    import time

    driver = webdriver.Firefox()
    driver.get('https://mail.126.com')
    time.sleep(5)
    driver.switch_to.frame(getElement(driver, 'xpath', "//div[@id='loginDiv']/iframe"))
    username = getElement(driver, 'xpath', "//input[@name='email']")
    username.send_keys('linuxxiaochao')
    driver.switch_to.default_content()
    driver.quit()

2.util文件夹下新建WaitUntil.py文件，主要实现显示等待元素功能的封装

from selenium.webdriver.common.by import By
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

class WaitUnit(object):
    def __init__(self, driver):
        self.byDic = {
            'id': By.ID,
            'name': By.NAME,
            'class_name': By.CLASS_NAME,
            'xpath': By.XPATH,
            'link_text': By.LINK_TEXT
        }
        self.driver = driver
        self.wait = WebDriverWait(self.driver, 50)

    def presenceOfElementLocated(self, by, locator):
        '''
        显示等待某个元素出现在dom中，不一定可见，存在返回元素对象
        :param by:
        :param locator:
        :return:
        '''
        try:
            if by.lower() in self.byDic:
                self.wait.until(EC.presence_of_element_located((self.byDic[by.lower()], locator)))
            else:
                raise TypeError('未找到定位方式,请确保定位方式正确')
        except Exception as e:
            raise e

    def frameToBeAvailableAndSwtichToIt(self, by, locator):
        '''
        检查frame是否存在，存在就切换到frame中
        :param by:
        :param locator:
        :return:
        '''
        try:
            if by.lower() in self.byDic:
                self.wait.until(EC.frame_to_be_available_and_switch_to_it((self.byDic[by.lower()], locator)))
            else:
                raise TypeError('未找到定位方式,请确保定位方式正确')
        except Exception as e:
            raise e
    def visibiltyOfElementLocated(self, by, locator):
        '''
        显示等待页面元素出现在dom中， 并且可见， 存在则返回该元素对象
        :param by:
        :param locator:
        :return:
        '''
        try:
            if by.lower() in self.byDic:
                self.wait.until(EC.visibility_of_element_located((self.byDic[by.lower()], locator)))
            else:
                raise TypeError('未找到定位方式,请确保定位方式正确')
        except Exception as e:
            raise e

if __name__=='__main__':
    from selenium import webdriver
    from util.ObjectMap import *
    driver = webdriver.Firefox()
    driver.get('https://mail.126.com')

    wait = WaitUnit(driver)
    wait.frameToBeAvailableAndSwtichToIt('xpath', "//div[@id='loginDiv']/iframe")
    wait.visibiltyOfElementLocated('xpath', "//input[@name='email']")
    uname = getElement(driver, 'xpath', "//input[@name='email']")
    uname.send_keys('python')
    driver.quit()

3.新建ClipboardUtil.py文件，用来实现剪切版的操作（我们发送邮件时，需要添加附件，通过这个功能来实现上传附件）

import win32clipboard as w
import win32con

class Clipboard(object):

    @staticmethod
    def getText():
        '''
        获取剪切板的内容
        :return:
        '''

        try:
            # 打开剪切板
            w.OpenClipboard()
            # 读取数据
            value = w.GetClipboardData(win32con.CF_TEXT)
            # 关闭剪切板
            w.CloseClipboard()
        except Exception as e:
            raise e
        else:
            return value

    @staticmethod
    def setText(value):
        '''
        设置剪切板内容
        :return:
        '''
        try:
            w.OpenClipboard()# 打开剪切板
            w.EmptyClipboard()# 清空剪切板
            w.SetClipboardData(win32con.CF_UNICODETEXT, value) # 设置内容
            w.CloseClipboard() # 关闭
        except Exception as e:
            raise e

if __name__=='__main__':
    from selenium import webdriver

    value = 'python'
    driver = webdriver.Firefox()
    driver.get('http://www.baidu.com')
    query = driver.find_element_by_id('kw')
    Clipboard.setText(value)
    clValue = Clipboard.getText()
    query.send_keys(clValue.decode('utf-8'))

4.新建KeyBoardUtil.py文件，主要实现模拟键盘的操作（配合上面剪切板的功能实现，粘贴附件的路径，回车等）

import win32api
import win32con

class KeyBoardKeys(object):
    '''
    模拟键盘
    '''
    # 键盘编码
    vk_code ={
        'enter':0x0D,
        'tab' : 0x09,
        'ctrl':0x11,
        'v':0x56
    }
    @staticmethod
    def keyDown(keyName):
        '''
        模拟按下键
        :param keyName:
        :return:
        '''
        try:
            win32api.keybd_event(KeyBoardKeys.vk_code[keyName],0,0,0)
        except Exception as e:
            raise e
    @staticmethod
    def keyUp(keyName):
        '''
        释放键
        :param keyName:
        :return:
        '''
        try:
            win32api.keybd_event(KeyBoardKeys.vk_code[keyName],0,win32con.KEYEVENTF_KEYUP,0)
        except Exception as e:
            raise e
    @staticmethod
    def oneKey(key):
        '''
        模拟当个按键
        :param key:
        :return:
        '''
        try:
            KeyBoardKeys.keyDown(key)
            KeyBoardKeys.keyUp(key)
        except Exception as e:
            raise e

    @staticmethod
    def twoKeys(key1, key2):
        '''
        模拟组合按键
        :param key1:
        :param key2:
        :return:
        '''
        try:
            KeyBoardKeys.keyDown(key1)
            KeyBoardKeys.keyDown(key2)
            KeyBoardKeys.keyUp(key1)
            KeyBoardKeys.keyUp(key2)
        except Exception as e:
            raise e

if __name__=='__main__':
    from selenium import webdriver

    driver = webdriver.Firefox()
    driver.get('http://www.baidu.com')
    driver.find_element_by_id('kw').send_keys('python')
    KeyBoardKeys.oneKey('enter')

5.新建DirAndTime.py文件，主要实现获取当前时间，生成特殊路径，这里主要用来生成屏幕截图保存的路径及图片名称

from datetime import datetime, date
from config.VarConfig import *

class DirAndTime(object):
    @staticmethod
    def getCurrentDate():
        '''
        获取当前日期
        :return:
        '''
        try:
            currentDate = date.today()
        except Exception as e:
            raise e
        else:
            return str(currentDate)
    @staticmethod
    def getCurrentTime():
        '''
        获取当前时间
        :return:
        '''
        try:
            Time = datetime.now()
            currentTime = Time.strftime('%H_%M_%S')
        except Exception as e:
            raise e
        else:
            return currentTime
    @staticmethod
    def CreatePicturePath():
        '''
        创建图片存放路径路径
        :return:
        '''
        try:

            picturePath = os.path.join(exceptionPath , DirAndTime.getCurrentDate())
            if not os.path.exists(picturePath):
                os.makedirs(picturePath) # 生成多级目录
        except Exception as e:
            raise e
        else:
            return picturePath

if __name__=='__main__':
    print(DirAndTime.getCurrentDate())
    print(DirAndTime.getCurrentTime())
    print(DirAndTime.CreatePicturePath())

6.新建ParseExcel.py用来解析excel文件

from openpyxl import load_workbook
from config.VarConfig import *
from datetime import datetime, date

class ParseExcel(object):
    '''
    解析excel文件的封装
    '''
    def __init__(self):
        # 加载excel文件到内存
        self.wb = load_workbook(excelPath)

    def getRowValue(self, sheetName, rawNo):
        '''
        获取某一行的数据
        :param sheetName:
        :param rawNo:
        :return: 列表
        '''
        sh = self.wb[sheetName]
        rowValueList = []
        for y in range(2, sh.max_column+1):
            value = sh.cell(rawNo,y).value
            rowValueList.append(value)
        return rowValueList
    def getColumnValue(self, sheetName, colNo):
        '''
        获取某一列的数据
        :param sheetName:
        :param colNo:
        :return: 列表
        '''
        sh = self.wb[sheetName]
        colValueList = []
        for x in range(2, sh.max_row +1):
            value = sh.cell(x, colNo).value
            colValueList.append(value)
        return colValueList

    def getCellOfValue(self, sheetName, rowNo, colNo):
        '''
        获取某一个单元格的数据
        :param sheetName:
        :param rowNo:
        :param colNo:
        :return: 字符串
        '''
        sh = self.wb[sheetName]
        value = sh.cell(rowNo, colNo).value
        return value
    def writeCell(self, sheetName, rowNo, colNo, value):
        '''
        向某个单元格写入数据
        :param rowNo: 行号
        :param colNo: 列号
        :param value:
        :return: 无
        '''
        sh = self.wb[sheetName]
        sh.cell(rowNo, colNo).value = value
        self.wb.save(excelPath)
    def writeCurrentTime(self, sheetName, rowNo, colNo):
        '''
        向某个单元格写入当前时间
        :return:
        '''
        sh = self.wb[sheetName]
        Time = datetime.now()
        currentTime = Time.strftime('%Y:%m:%d %H:%M:%S')
        sh.cell(rowNo, colNo).value = currentTime
        self.wb.save(excelPath)

    def writeTestResult(self, sheetName, rowNo, result, errorInfo = None, errorPic = None):
        ParseExcel().writeCurrentTime(sheetName, rowNo, testStep_testRunTime)
        ParseExcel().writeCell(sheetName, rowNo, testStep_testResult, result)
        if errorInfo and errorInfo:
            ParseExcel().writeCell(sheetName, rowNo, testStep_testErrorInfo, errorInfo)
            ParseExcel().writeCell(sheetName, rowNo, testStep_testErrorPic, errorPic)
        else:
            ParseExcel().writeCell(sheetName, rowNo, testStep_testErrorInfo, '')
            ParseExcel().writeCell(sheetName, rowNo, testStep_testErrorPic, '')
if __name__=='__main__':
    p = ParseExcel()
    print(p.getRowValue('126account',2))
    print(p.getColumnValue('126account',3))
    print(p.getCellOfValue('126account', 2, 3))

7.新建Log.py文件，用来记录代码运行日志

import logging
import time
from config.VarConfig import *

class Logger(object):
    '''
    封装的日志模块
    '''
    def __init__(self, logger, CmdLevel=logging.INFO, FileLevel=logging.INFO):
        """

        :param logger:
        :param CmdLevel:
        :param FileLevel:
        """
        try:
            self.logger = logging.getLogger(logger)
            self.logger.setLevel(logging.DEBUG)  # 设置日志输出的默认级别
            # 日志输出格式
            fmt = logging.Formatter('%(asctime)s - %(filename)s:[%(lineno)s] - [%(levelname)s] - %(message)s')
            # 日志文件名称
            # self.LogFileName = os.path.join(conf.log_path, "{0}.log.txt".format(time.strftime("%Y-%m-%d")))# %H_%M_%S
            currTime = time.strftime("%Y-%m-%d")
            self.LogFileName = logPath+currTime+'.txt'
            # 设置控制台输出
            # sh = logging.StreamHandler()
            # sh.setFormatter(fmt)
            # sh.setLevel(CmdLevel)# 日志级别

            # 设置文件输出
            fh = logging.FileHandler(self.LogFileName)
            fh.setFormatter(fmt)
            fh.setLevel(FileLevel)# 日志级别

            # self.logger.addHandler(sh)
            self.logger.addHandler(fh)
        except Exception as e:
            raise e

if __name__ == '__main__':
    logger = Logger("fox",CmdLevel=logging.DEBUG, FileLevel=logging.DEBUG)
    logger.logger.debug("debug")
    logger.logger.log(logging.ERROR,'%(module)s %(info)s',{'module':'log日志','info':'error'}) #ERROR,log日志 error

业务操作功能模块

新建action文件夹，主要存储页面的各种操作，如点击操作，输入操作等

1.文件夹下新建PageAction.py文件

from util.ObjectMap import *
from util.ClipboardUtil import Clipboard
from util.KeyBoardUtil import KeyBoardKeys
from util.WaitUntil import WaitUnit
from util.DirAndTime import *
from selenium import webdriver

driver = None
waitUtil = None
# 打开浏览器
def openBrowser(browser):
    global driver, waitUtil
    try:
        if browser.lower() =='ie':
            driver = webdriver.Ie(executable_path=iePath)
        elif browser.lower() == 'chrome':
            driver = webdriver.Chrome(executable_path=chromePath)
        else:
            # driver = webdriver.Firefox(executable_path=fireFox)
            driver = webdriver.Firefox()
    except Exception as e:
        raise e
    else:
        waitUtil = WaitUnit(driver) # driver 创建之后， 创建等待类实例对象

# 浏览器窗口最大化
def maximize_browser():
    try:
        driver.maximize_window()
    except Exception as e:
        raise e
# 加载网址
def loadUrl(url):
    try:
        driver.get(url)
    except Exception as e:
        raise e

# 强制等待
def sleep(sleepSeconds):
    try:
        import time
        time.sleep(sleepSeconds)
    except Exception as e:
        raise e
# 清除输入框的内容
def clear(by, locator):
    try:
        getElement(driver, by, locator).clear()
    except Exception as e:
        raise e
# 输入框中输入内容
def inputValue(by, locator, value):
    try:
        element = getElement(driver, by, locator)
        # element.click()
        element.send_keys(value)
    except Exception as e:
        raise e
# 点击操作
def clickBtn(by, locator):
    try:
        getElement(driver, by, locator).click()
    except Exception as e:
        raise e
# 断言页面的title
def assertTitle(titleStr):
    try:
        assert titleStr in driver.title, "%s not found in title!" % titleStr
    except AssertionError as e:
        raise AssertionError(e)
    except Exception as e:
        raise e

# 断言目标字符串是否包含在页面源码中
def assert_string_in_page_source(assertString):
    try:
        assert assertString in driver.page_source, "%s not found in page source!" % assertString
    except AssertionError as e:
        raise AssertionError(e)
    except Exception as e:
        raise e

# 获取当前页面的title
def getTitle():
    try:
        return driver.title
    except Exception as e:
        raise e

# 获取页面源码
def getPageSource():
    try:
        return driver.page_source
    except Exception as e:
        raise e
# 切换到frame里面
def switchToFrame(by, locator):
    try:
        driver.switch_to.frame(getElement(driver, by, locator))
    except Exception as e:
        raise e

# 跳到默认的frame
def switchToDefault():
    try:
        driver.switch_to.default_content()
    except Exception as e:
        raise e

# 模拟ctrl+v键
def ctrlV(value):
    try:
        Clipboard.setText(value)
        sleep(2)
        KeyBoardKeys.twoKeys('ctrl', 'v')
    except Exception as e:
        raise e

# 模拟tab键
def tabKey():
    try:
        KeyBoardKeys.oneKey('tab')
    except Exception as e:
        raise e

# 模拟enter键
def enterKey():
    try:
        KeyBoardKeys.oneKey('enter')
    except Exception as e:
        raise e

# 屏幕截图
def saveScreenShot():
    pictureName = DirAndTime.CreatePicturePath() +'\\'+DirAndTime.getCurrentTime() + '.png'
    try:
        driver.get_screenshot_as_file(pictureName)
    except Exception as e:
        raise e
    else:
        return pictureName

def waitPresenceOfElementLocated(by, locator):
    '''
    显示等待页面元素出现在DOM中，单并不一定可见
    :param by:
    :param locator:
    :return:
    '''
    waitUtil.presenceOfElementLocated(by, locator)

def waitFrameToBeAvailableAndSwitchToIt(by, locator):
    '''
    检查frame是否存在，存在就切换到frame中
    :param by:
    :param locator:
    :return:
    '''
    waitUtil.frameToBeAvailableAndSwtichToIt(by, locator)

def waitVisibiltyOfElementLocated(by, locator):
    '''
    显示等待页面元素出现在DOM中，并且可见
    :param by:
    :param locator:
    :return:
    '''
    waitUtil.visibiltyOfElementLocated(by, locator)

# 关闭浏览器
def quitBroswer():
    try:
        driver.quit()
    except Exception as e:
        raise e
if __name__=='__main__':
    openBrowser('firefox')
    loadUrl('http://www.baidu.com')
    # inputValue('id', 'kw','python')
    # clear('id', 'kw')
    # inputValue('id', 'kw', 'python')
    # clickBtn('id', 'su')
    # sleep(3)
    # title = getTitle()
    # print(title)
    # assertTitle('python')
    # assert_string_in_page_source('python')
    ctrlV('python')

项目数据文件设计

我们既然要实现关键字驱动的测试，无疑是通过关键字数据文件来控制代码的执行

新建testData文件夹，并新建126mailSend.xlsx文件。文件内容包括3个sheet页，分别为测试用例，登录，发送邮件

测试用例页

登录页

 发送邮件页

注意：表格中的关键字 需要和PageAction.py中的方法名字保持一致

项目配置模块

新建config目录，并新建VarConfig.py文件记录全局的目录及excel文件部分信息

# 存储全局的变量
import os

# 项目根目录
projectPath = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# 截图目录
exceptionPath = projectPath +r'\exceptionpictures'

# 驱动存放路径， 需要自己根据自己电脑的驱动为止修改
iePath = ''
chromePath = ''
fireFox = ''

# excel文件存放路径
excelPath = projectPath + r'\testData\126mailSend.xlsx'
# loh文件存放路径
logPath = projectPath + '\\log\\'
# 测试用例部分列对应的列号
testCase_testCaseName = 2
testCase_testStepName = 4
testCase_testIsExecute = 5
testCase_testRunEndTime = 6
testCase_testResult = 7

# 用例步骤对应的列号
testStep_testNum = 1
testStep_testStepDescribe = 2
testStep_keyWord = 3
testStep_elementBy = 4
testStep_elementLocator = 5
testStep_operateValue = 6
testStep_testRunTime = 7
testStep_testResult = 8
testStep_testErrorInfo = 9
testStep_testErrorPic = 10


if __name__=='__main__':

    print(projectPath)
    print(exceptionPath)

测试用例编写

前期所有的准备都已经完成，接下来我们开始编写测试用例

新建testCases文件夹，并新建Test126SendMailWithAttachment.py编写用例

from util.ParseExcel import ParseExcel
from config.VarConfig import *
from action.PageAction import *
import traceback
from util.log import Logger
import logging

log = Logger(__name__, CmdLevel=logging.INFO, FileLevel=logging.INFO)
p = ParseExcel()
sheetName = p.wb.sheetnames# 获取到excel的所有sheet名称

def Test126MailSendWithAtt():
    try:
        testCasePassNum = 0

        requiredCase = 0
        isExecuteColumnValues = p.getColumnValue(sheetName[0], testCase_testIsExecute)
        # print(columnValues)
        for index, value in enumerate(isExecuteColumnValues):
            # print(index, value)
            # 获取对应的步骤sheet名称
            stepSheetName = p.getCellOfValue(sheetName[0],index+2, testCase_testStepName)
            # print(stepSheetName)
            if value.strip().lower() == 'y':
                requiredCase += 1
                testStepPassNum = 0
                print('开始执行测试用例"{}"'.format(stepSheetName))
                log.logger.info('开始执行测试用例"{}"'.format(stepSheetName))
                # 如果用例被标记为执行y，切换到对应的sheet页
                # 获取对应的sheet表中的总步骤数，关键字，定位方式，定位表达式，操作值
                # 步骤总数
                values = p.getColumnValue(stepSheetName, testStep_testNum) # 第一列数据
                stepNum = len(values)
                print(stepNum)
                for step in range(2, stepNum+2):
                    rawValue = p.getRowValue(stepSheetName, step)
                    # 执行步骤名称
                    stepName = rawValue[testStep_testStepDescribe -2]
                    # 关键字
                    keyWord = rawValue[testStep_keyWord - 2]
                    # 定位方式
                    by = rawValue[testStep_elementBy - 2]
                    # 定位表达式
                    locator = rawValue[testStep_elementLocator - 2]
                    # 操作值
                    operateValue = rawValue[testStep_operateValue - 2]

                    if keyWord and by and locator and operateValue:
                        func = keyWord + '(' +'"' +by +'"'+ ',' +'"'+locator+ '"'+',' +'"'+ operateValue + '"'+')'
                    elif keyWord and by and locator and operateValue is None:
                        func = keyWord + '(' +'"' +by +'"'+ ',' +'"'+locator+ '"'+')'

                    elif keyWord and operateValue and type(operateValue) == str and by is None and locator is None:
                        func = keyWord + '(' +'"' + operateValue + '"' + ')'

                    elif keyWord and operateValue and type(operateValue) == int and by is None and locator is None:
                        func = keyWord + '(' + str(operateValue) +')'

                    else:
                        func = keyWord + '('+')'

                    try:
                        # 执行测试步骤
                        eval(func)
                    except Exception:
                        # 截图
                        picPath = saveScreenShot()
                        # 写回测试结果
                        errorInfo = traceback.format_exc()
                        p.writeTestResult(stepSheetName, step, 'Failed', errorInfo, picPath)
                        print('步骤"{}"执行失败'.format(stepName))
                        log.logger.info('步骤"{}"执行失败'.format(stepName))
                        raise
                    else:
                        print('步骤"{}"执行通过'.format(stepName))
                        log.logger.info('步骤"{}"执行通过'.format(stepName))
                        # 标记测试步骤为pass
                        p.writeTestResult(stepSheetName, step, 'Pass')
                        testStepPassNum += 1
                # print('通过用例步数数:',testStepPassNum)
                if testStepPassNum == stepNum:
                    # 标记测试用例sheet页的执行结果为pass
                    p.writeCell(sheetName[0], index+2, testCase_testResult, 'Pass')
                    testCasePassNum += 1
                else:
                    p.writeCell(sheetName[0], index + 2, testCase_testResult, 'Failed')
        print('共{}条用例，{}条需要被执行，本次执行通过{}条'.format(len(isExecuteColumnValues), requiredCase, testCasePassNum))
        log.logger.info('共{}条用例，{}条需要被执行，本次执行通过{}条'.format(len(isExecuteColumnValues), requiredCase, testCasePassNum))
    except Exception as e:
        print(traceback.format_exc(e))
        log.logger.info(traceback.format_exc(e))

if __name__=='__main__':
    Test126MailSendWithAtt()

加载用例

项目主目录下直接新建RunTest.py，用例运行测试用例

if __name__=='__main__':
    from testCases.Test126SendMailWithAttachment import Test126MailSendWithAtt
    Test126MailSendWithAtt()

项目总结

1.使用外部测试数据文件，使用Excel管理测试用例的集合和每个测试用例的所有测试步骤 ，实现一个文件中完成测试用例的维护

2.每个测试用例的测试结果在一个文件中查看和统计

3.通过定义关键字，操作元素的定位方式及定位表达式和操作值就可以实现每个测试用例步 骤的执行，可以更加灵活地实现自动化测试的需求

4.实现定位表达式和测试代码的分离，实现定位表达式直接在测试数据文件中进行维护。

5.框架提供日志功能，方便调试和监控自动化测试程序的执行

6.基于关键字测试框架，即使不懂开发技术的测试人员也可以实施自动化测试，便于在整个 测试团队中推广和使用自动化测试技术，降低自动化测试实施的技术门槛

7.基于关键字的方式，可以进行任意关键字的扩展，以满足更加复杂项目的自动化测试需求

运行框架

1.运行环境需要安装了python3.x+selenium2.x；第三方模块openpyxl,pypiwin32,
  win32api, win32con
2.本地已配置chrome/firefox/ie浏览器及对应版本驱动
3.需要修改Excel文件中对应的用户名和密码
4.直接运行RunTest.py文件即可执行整个框架

写的不是很详细，框架源码请到我的Git上下载；QQ交流群：878565760 有任何问题加群交流，框架问题也可以加我个人qq281754043咨询