精华内容
下载资源
问答
  • 关键字驱动模型 源码: import csv import unittest from ddt import ddt, data, unpack def getCsvData(): value_rows = [] with open('./shuju.csv') as f: f_csv = csv.reader(f) next(f_c...

    数据表:
    在这里插入图片描述
    关键字驱动模型
    在这里插入图片描述
    源码:

    
    import csv
    import unittest
    from ddt import ddt, data, unpack
    def getCsvData():
        value_rows = []
        with open('./shuju.csv') as f:
            f_csv = csv.reader(f)
            next(f_csv)
            for r in f_csv:
                value_rows.append(r)
        return value_rows
    def add(x,y):
        sum =  x+y
        return sum
    @ddt
    class MyTestCase(unittest.TestCase):
        @data(*getCsvData())
        @unpack
        def test_something(self, searchTerm, searchResult):
            print(add(int(searchTerm),int(searchResult)))
    if __name__ == '__main__':
        unittest.main()
        ```
    
    
    展开全文
  •  为了提高测试效率,越来越多的测试工作引入了自动化测试的思想和方法。实践证明,软件自动化测试技术提高了软件测试的速度和效率,节省了软件测试成本,缩短了产品发布周期。同时,自动化测试技术也完成了许多...
  • 自动化测试的一个框架,没有使用robotframework,关键字支持大概十几个吧,如果不够可以自己在代码中完善,测试用例写在excel中,运行AutoTest.py就行
  • 数据驱动 数据和程序的分离,程序不变,数据变 from selenium import webdriver import time driver = webdriver.Firefox(executable_path = "d:\geckodriver") driver.get("http://www.bing.com") search_box = ...

    数据驱动

    数据和程序的分离,程序不变,数据变

    from selenium import webdriver
    import time
    driver = webdriver.Firefox(executable_path = "d:\geckodriver")
    driver.get("http://www.bing.com")
    search_box = driver.find_element_by_xpath("//input[@id='sb_form_q']")
    search_box.send_keys("大话西游之月光宝盒")
    query_button = driver.find_element_by_xpath("//input[@id='sb_form_go']")
    query_button.click()
    time.sleep(5)
    
    assert "周星驰" in driver.page_source
    driver.quit()
    

    请使用数据驱动的方式,实现访问网址、搜索框定位表达式、搜索词输入、搜索按钮定位表达式和断言值作为数据驱动的数据文件,然后执行测试脚本。
    测试脚本:

    from selenium import webdriver
    import time
    import os.path
    import sys
    
    def get_data_from_file(data_file_path,coding="utf-8"):
        if not os.path.exists(data_file_path):
            print("数据文件不存在!")
            sys.exit(0)
        test_data = []
        with open(data_file_path,'r',encoding=coding) as fp:
            for line in fp:
                if line.strip() == "":
                    continue
                test_data.append(line.split("||"))
        return test_data    
    test_data = get_data_from_file("f:\\urls.txt")
    #print(test_data)
    
    def test_step(url,searchbox_xpath,search_button_xpath,search_word,assert_word):
        driver = webdriver.Firefox(executable_path = "d:\geckodriver")
        driver.get(url)
        search_box = driver.find_element_by_xpath(searchbox_xpath)
        search_box.send_keys(search_word)
        query_button = driver.find_element_by_xpath(search_button_xpath)
        query_button.click()
        time.sleep(5)
        assert assert_word in driver.page_source
        driver.quit()
    
    for data in test_data:
        url = data[0].strip()
        searchbox_xpath = data[1].strip()
        search_button_xpath = data[2].strip()
        search_word = data[3].strip()
        assert_word = data[4].strip()
        print(url,searchbox_xpath,search_button_xpath,search_word,assert_word)
        test_step(url,searchbox_xpath,search_button_xpath,search_word,assert_word)
    
    

    数据文件:

    http://www.sogou.com||//input[@id='query']||//input[@id='stb']||神奇动物在哪里||叶茨
    http://www.bing.com||//*[@id='sb_form_q']||//*[@id='sb_form_go']||亚洲杯||国足
    

    在这里插入图片描述
    基于txt的数据驱动测试框架

    #encoding=utf-8
    from selenium import webdriver
    import time
    import traceback
    with open(u"data.txt") as fp:
        data = fp.readlines()
    
    
    driver = webdriver.Chrome(executable_path="d:\\chromedriver")
    #driver = webdriver.Ie(executable_path="d:\\IEDriverServer")
    test_result = []
    for i in range(len(data)):
        try:
            driver.get("http://www.baidu.com")
            driver.find_element_by_id("kw").send_keys(\
            data[i].split("||")[0].strip())
            driver.find_element_by_id("su").click()
            time.sleep()
            assert data[i].split("||")[1].strip() in driver.page_source
            test_result.append(data[i].strip()+u"||成功\n")
            print(data[i].split('||')[0].strip()+u"搜索测试执行成功")
        except AssertionError as e:
            print(data[i].split("||")[1].strip()+u"测试断言失败")
            test_result.append(data[i].strip()+u"||断言失败\n")
        except Exception as e:
            print(data[i].split("||")[1].strip()+u"测试执行失败")
            test_result.append(data[i].strip()+u"||异常失败\n")
            traceback.print_exc()
    
    with open(u"result.txt","w") as fp:
        fp.writelines(test_result)
    driver.quit()
    
    gloryroad test||光荣之路
    摔跤爸爸||阿米尔
    超人||电影
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    关键字驱动

    一个单词,能够映射到python程序中的一个函数的自动调用。单词可以放在数据文件中。
    测试脚本:

    from selenium import webdriver
    import time
    import os.path
    import sys
    
    def get_data_from_file(data_file_data,coding="utf-8"):
        if not os.path.exists(data_file_data):
            print("数据文件不存在!")
            sys.exit(0)
        test_data = []
        with open(data_file_data,"r",encoding=coding) as fp:
            for line in fp:
                if line.strip() == "":
                    continue
                test_data.append(line.split("||"))
        return test_data    
    test_data = get_data_from_file("f:\\testcase.txt")
    print(test_data)
    
    driver = None
    def open(browser_name):
        global driver
        if browser_name == "firefox":
            driver = webdriver.Firefox(executable_path = "d:\geckodriver")
    
    def visit(url):
        global driver
        driver.get(url)
    
    def input(xpath,content):
        global driver
        driver.find_element_by_xpath(xpath).send_keys(content)  
    
    def click(xpath):
        global driver
        driver.find_element_by_xpath(xpath).click()  
    
    def assert_f(assert_word):
        global driver
        assert assert_word in driver.page_source  
    
    def close():
        global driver
        driver.quit()
    
    for line in test_data:
        action = line[0]
        xpath = line[1]
        value = line[2].strip()        
        print(action,xpath,value)
        if xpath == "None" and value == "None":
            print("1",action+"()")
            exec(action+"()")
        elif xpath == "None" and value != "None":
            print("2",action+"(\""+value+"\")")
            exec(action+"(\""+value+"\")")
        elif xpath != "None" and value == "None":
            print("3",action+"(\""+xpath+"\")")
            exec(action+"(\""+xpath+"\")")
        else:
            print("4",action+"(\""+xpath+"\",\""+value+"\")")
            exec(action+"(\""+xpath+"\",\""+value+"\")")
            #action = "open"
            #value = "firefox"
            #open('firefox')
    

    数据文件:

    open||None||firefox
    visit||None||http://www.sogou.com
    input||//input[@id='query']||疯狂动物城
    click||//input[@id='stb']||None
    assert||None||古德温
    close||None||None
    

    在这里插入图片描述

    展开全文
  • 测试人员,python初学者
  • 自动测试之关键字驱动测试模式初探。...之前在入淘宝初,对淘宝架构、测试工具不甚熟悉的情况下,提出过《基于TTCN-3的Web应用自动化测试框架》一文,但却与淘宝现有的测试工具不相符合。随着对淘宝环境逐渐熟
  • 之前有写了一篇关于简单的关键字驱动测试框架,但是仍然觉得比较冗余,今天又在网上看了几篇关于关键字驱动的例子,在这里顺便记录总结一下 关键字驱动,我们把这个过程大致分为12个步骤 1、自动化实现一个端对端...

    之前有写了一篇关于简单的关键字驱动的测试框架,但是仍然觉得比较冗余,今天又在网上看了几篇关于关键字驱动的例子,在这里顺便记录总结一下

    关键字驱动,我们把这个过程大致分为12个步骤
    1、自动化实现一个端对端的流程
    2、区分和实现动作的关键字
    3、设置数据引擎-Excel表
    4、实现java反射类
    5、设置java常量,一些固定的数据
    6、设置元素对象仓库文件
    7、设置测试套件执行引擎
    8、设置日志模块输出模块,例如log4j
    9、设置框架中的异常处理
    10、设置测试结果报告输出
    11、设置数据驱动
    12、完成框架,交付给手工测试人员

    以上内容是大致的关键字测试框架的设计步骤。
    上面所说的端对端,可以根据实际的例子加以理解,就是我们完成一个有效的测试功能完整的流程
    最简单的例如打开指定的网页,稍微复杂点的可能在加上登录等等操作。

    动作关键字就是,利用一个简短的单词(词语)来描述这个动作场景。
    来一个图片就一目了然了:一个最简单的打开指定浏览器登录的页面
    在这里插入图片描述
    所以我们首先可以对上面的关键字进行封装,这个也是关键字驱动的精髓,后面的各种操作也都是围绕这个关键字来进行的

    public class ActionsKeywords {
    	public static void openBrowser(){
    		System.out.println("方法openBrowser已经调用");
    	}
    	
    	public static void openUrl(){
    		System.out.println("方法openUrl已经调用");
    	}
    	
    	public static void click_Login_link(){
    		System.out.println("方法click_Login_link已经调用");
    	}
    	
    	public static void input_Username() {
    		System.out.println("方法input_Username已经调用");
    	}
    	
    	public static void input_Password(){
    		System.out.println("方法input_Password已经调用");
    	}
    	
    	public static void click_Submit(){
    		System.out.println("方法click_Submit已经调用");
    	}
    	
    	public static void closeBrowser(){
    		System.out.println("方法closeBrowser已经调用");
    	}
    }
    

    假设上面是我们已经封装好的关键字,然后我们需要去调研具体的关键字按照特定的顺序进行执行,我们需要在程序跑起来的时候自动的去判断到底执行哪些关键字,我们的案例绝大部分都是放在Excel里面,所以需要把Excel案例中我们想要执行的顺序和我们定义的关键字结合起来。
    这就需要搭建Data Engine—利用Apache POI

    这已经是一个比较简单的Excel读取了

    public class ExcelUtils {
    	
    	private static XSSFSheet ExcelWSheet;
    	private static XSSFWorkbook ExcelWBook;
    	private static XSSFCell Cell;
    	
    	//这里也可以定义一个构造函数来对表格进行初始化
    	public static void setExcelFile(String filePath, String sheetName) throws IOException{
    		FileInputStream ExcelFile = new FileInputStream(filePath);
    		ExcelWBook = new XSSFWorkbook(ExcelFile);
    		ExcelWSheet = ExcelWBook.getSheet(sheetName);
    	}
    	
    	public static String getCellData(int RowNum, int ColNum){
    		Cell = ExcelWSheet.getRow(RowNum).getCell(ColNum);
    		String CellData = Cell.getStringCellValue();
    		return CellData;
    	}
    		public static void main(String[] args) throws IOException {
    		String filepath = "D:" + File.separator + "ExcelTest" + File.separator + "KeywordTestCase.xlsx";
    		String sheetname = "Test Steps";
    		ExcelUtils.setExcelFile(filepath, sheetname);
    		System.out.println(ExcelUtils.getCellData(1, 3));
    	}
    }
    

    读取成功之后我们可以根据读取到的关键字进行内容的判断,然后调用对应的关键字方法,这里我们可以通过最简单的if else判断,符合那个关键字就调用对应关键字的方法,但是这样有一个问题,就是如果关键字有很多怎么办?我们需要写那么多if else进行判断吗?这里我们就需要用到java反射来优化我们的代码了,假设DriverScript是执行的类,这个类里面是我们实现调用的各种方法
    反射前面的文章里面有写,这里我们用起来!

    public class DriverScript {
    	
    	//声明一个public static的类对象,所以我们可以在main方法之外去使用
    	public static ActionsKeywords actionsKeywords;
    	public static String sActionKeyword;
    	//下面的返回类型是方法,这里用到了反射类
    	public static Method method[];
    	
    	//构造函数,我们初始化ActionsKeywords类的一个对象
    	public DriverScript() throws ClassNotFoundException{
    		Class actionKeywords = Class.forName("com.keywordtwo.test.ActionsKeywords");
    		method = actionKeywords.getMethods();
    //		for (int i = 0; i < method.length; i++) {
    //			System.out.println(method[i]);
    //		}
    	}
    	public static void main(String[] args) throws ClassNotFoundException, IOException, Exception {
    		DriverScript ds = new DriverScript();
    		
    		String filepath = "D:" + File.separator + "ExcelTest" + File.separator + "KeywordTestCase.xlsx";
    		String sheetname = "Test Steps";
    		ExcelUtils.setExcelFile(filepath, sheetname);
    		
    		for (int iRow = 1; iRow <= 6; iRow++) {
    			sActionKeyword = ExcelUtils.getCellData(iRow, 3);
    			excute_Actions();
    		}
    	}
    	
    	private static void excute_Actions() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
    		for (int i = 0; i < method.length; i++) {
    			if (method[i].getName().equals(sActionKeyword)) {
    				method[i].invoke(actionsKeywords);
    				break;
    			}
    		}
    	}
    	
    }
    

    与此同时,我们可以将我们代码中的变量构建成一个常量类,这样即使需要进行修改或者对表格进行调整的时候,也只用修改一处代码

    public class Constants {
    	
    	public static final String PATH_TESTDATA = "D:" + File.separator + "ExcelTest" + File.separator + "KeywordTestCase.xlsx";
    	public static final String File_TestData = "KeywordTestCase.xlsx";
    	
    	//设置表格里面一些单元格的索引值
    	public static final int Col_TestCaseID = 0;
    	public static final int Col_TestScenarioID = 1;
    	public static final int Col_ActionKeyword = 3;
    	
    	//表格中的sheet名字
    	public static final String Sheet_TestSteps = "Test Steps";
    
    }
    

    到这里我们已经差不多完成了60%的工作量了,现在已经可以按照Excel里面的顺序去调用我们封装的方法了,但是现在仍然有一些问题,我每个元素操作都写了一个动作关键字的静态方法,这样做并不合理,因为一旦一个页面或者流程操作需要很多个click操作,而我们知道页面中不同的元素定位的Xpath可能是不一样的,所以我们需要对元素对象操作进行分类。
    说的在直白一些
    ActionsKeywords.java文件中我们定义了两个click方法,我们把这个进行拆分,1、具体页面具体元素的xpath提取出来放到单独的文件中2、click方法单独封装起来。

    	public static void click_Login_link(){
    		System.out.println("方法click_Login_link已经调用");
    	}
    	public static void click_Submit(){
    		System.out.println("方法click_Submit已经调用");
    	}
    

    我们把Excel调整成这个样子采用page object + action keyword
    在这里插入图片描述
    Page Object只是一个代号,我们仍然需要通过读取的Page Object值去在配置文件中去查找真正的元素xpath

    public class PropertiesUtil {
    	
    	public static String getValue(String filePath, String keyWord) {
    		Properties prop = new Properties();
    		String value = null;
    		try {
    			// 通过输入缓冲流进行读取配置文件
    			InputStream InputStream = new BufferedInputStream(
    					new FileInputStream(new File(filePath)));
    			// 加载输入流
    			prop.load(InputStream);
    			// 根据关键字获取value值
    			value = prop.getProperty(keyWord);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return value;
    	}
    }
    

    在DriverScript.java文件中修改

    //只是新增了一个保存pageobject的对象
    			sActionKeyword = ExcelUtils.getCellData(iRow, Constants.Col_ActionKeyword);
    			sPageObject = ExcelUtils.getCellData(iRow, Constants.Col_PageObject);
    

    在invoke方法中

    private static void execute_Actions() throws Exception {
            //循环遍历每一个关键字驱动方法(在actionskeywords.java中)
            //method variable contain all the method and method.length returns the total number of methods
            // 下面methid.length表示方法个数,method变量表示任何一个关键字方法,例如openBrowser()
            for(int i = 0;i < method.length;i++){
                //开始对比代码中关键字方法名称和excel中关键字这列值是否匹配
                if(method[i].getName().equals(sActionKeyword)){
                    //一点匹配到关键字,并传递页面对象参数和动作关键字参数
                    method[i].invoke(actionsKeywords,sPageObject);
                    //一旦任何关键字被执行,利用break语句去跳出for循环。
                    break;
                }
            }
        }
    
    

    这里面修改之后要在keyword定义的方法中加上参数

        public static void click(String object) {
            driver.findElement(By.xpath(OR.getProperty(object))).click();
        }
    

    通过object == key来获取配置文件中 key value
    这里面一定要加上参数,全部都要加,这是反射的格式

    到现在这个样子,我们可以说我们跑一个案例下来已经没有问题了,但是在实际自动化测试项目中,很可能有几百条测试用例或者很多个测试组件,有时候我们需要全部执行,有时候我们只需要部分执行,一个好的测试框架,需要执行类似的需求。
    我们新加入一个sheet来管理案例集,并标注那些案例集需要执行
    在这里插入图片描述
    这样就修改ExcelUtils类
    1.修改方法setExcelFile,之前这个方法有两个参数,一个是path一个是sheetname,由于我们新增了一个TestCases的sheet,所以这个方法只保留path这个参数。

    	//设置Excel文件路径,方便读取到文件,这里只读取就好了,sheet切换和读取留给其他方法做
    	public static void setExcelFile(String Path) throws IOException{
    		FileInputStream ExcelFile = new FileInputStream(Path);
    		ExcelWBook = new XSSFWorkbook(ExcelFile);
    	}
    

    2.修改方法getCellData(),增加sheetName参数

    	public static String getCellData(int RowNum, int ColNum, String SheetName){
    		ExcelWSheet = ExcelWBook.getSheet(SheetName);
    		Cell = ExcelWSheet.getRow(RowNum).getCell(ColNum);
    		String CellData = Cell.getStringCellValue();
    		return CellData;
    	}
    

    3.新增一个getRowContains()方法,这个方法有三个参数,第一个是Test Case Name,第二个是列的索引号,第三个是sheet名称,该方法的返回值是当前测试用例的编号。

    	//得到一共有多少行
    	public static int getRowCount(String SheetName){
    		ExcelWSheet = ExcelWBook.getSheet(SheetName);
    		int number = ExcelWSheet.getLastRowNum();
    		return number;
    	}
    	
    	//得到测试用例的行号,如第一个案例集在第一行,第二个案例集在第五行
    	public static int getRowContains(String sTestCaseName, int colNum, String SheetName){
    		int i;
    		ExcelWSheet = ExcelWBook.getSheet(SheetName);
    		int rowCount = ExcelUtils.getRowCount(SheetName);
    		for (i = 0; i < rowCount; i++) {
    			if (ExcelUtils.getCellData(i, colNum, SheetName).equalsIgnoreCase(sTestCaseName)) {
    				break;
    			}
    		}
    		return i;	
    	}
    

    4.新增一个方法getTestStepsCount(),同样有三个参数,分别是TestCaseID,TestCase第一个步骤和sheet名称,返回的值是测试用例的步骤数

    public static int getTestStepsCount(String SheetName, String sTestCaseID, int iTestCaseStart){
    		for (int i = iTestCaseStart; i < ExcelUtils.getRowCount(SheetName); i++) {
    			//如果不相等
    			if (!sTestCaseID.equals(ExcelUtils.getCellData(i, Constants.Col_TestCaseID, SheetName))) {
    				int number = i;
    				return number;
    			}
    		}
    		//全部相等之后,也就是说sheet中只有一个testcaseid,那么执行步骤就是ExcelWSheet.getLastRowNum() + 1
    		ExcelWSheet = ExcelWBook.getSheet(SheetName);
    		int number = ExcelWSheet.getLastRowNum() + 1;
    		return number;
    	}
    

    ExcelUtils类修改完毕之后我们需要对Driver Script类进行修改了
    1.外层for循环,得到Test Cases工作簿中的Test CaseID,控制从第一个测试用例开始执行到最后一个测试用例
    2.得到RunModel的值来控制当前测试用例是否被执行。
    3.写另外一个内层for循环,控制Test Step表中的Test Case ID列。作用就是在当前测试用例,从第一个测试步骤执行到最后一个测试步骤

    public void excute_TestCase() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
    		//一共有多少条测试案例
    		int iTotalTestCases = ExcelUtils.getRowCount(Constants.Sheet_TestCases);
    		System.out.println("一共有"+iTotalTestCases+"条测试案例");
    		for (int iTestCase = 1; iTestCase <= iTotalTestCases; iTestCase++) {//从1开始,通过循环可以拿到每一个测试用例的String类型的sTestCaseID和sRunMode
    			sTestCaseID = ExcelUtils.getCellData(iTestCase, Constants.Col_TestCaseID, Constants.Sheet_TestCases);
    			sRunMode = ExcelUtils.getCellData(iTestCase, Constants.Col_RunMode, Constants.Sheet_TestCases);
    			//如果RunMode是yes
    			if (sRunMode.equalsIgnoreCase("Yes")) {
    				//开始的行号
    				iTestStep = ExcelUtils.getRowContains(sTestCaseID, Constants.Col_TestCaseID, Constants.Sheet_TestSteps);
    				//最后一个行号
    				iTestLaseStep = ExcelUtils.getTestStepsCount(Constants.Sheet_TestSteps, sTestCaseID, iTestStep);
    				System.out.println("iTestStep:"+iTestStep);
    				System.out.println("iTestLaseStep:"+iTestLaseStep);
    				//下面这个for循环的次数就等于测试用例的步骤数
    				for (; iTestStep < iTestLaseStep; iTestStep++) {
    					sActionKeyword = ExcelUtils.getCellData(iTestStep, Constants.Col_ActionKeyword, Constants.Sheet_TestSteps);
    					sPageObject = ExcelUtils.getCellData(iTestStep, Constants.Col_PageObject, Constants.Sheet_TestSteps);
    					excute_Actions();
    				}
    			}	
    		}
    	}
    

    到这里,我们实现了案例的分类读取与执行,如果添加了log4j组件,可以直接在日志中查看案例的执行情况,但是我们需要将案例的执行结果同步到excel表格中,我们现在没有办法直接获取案例执行的结果,所以我们在每个关键字中添加try-catch去捕获异常。
    在执行脚本中我们定义一个boolean型的变量,当代码跑到异常也就是catch中,我们将bResult置为false。简单一句话说,如果bResult的值变成了false,我们就在Excel对应用例位置标识failed的标记,如果是true,我们就标记pass

    public static boolean bResult;
    

    由于是关键字驱动矿建,这里无法引入TestNG生成更美观的html格式的报告。那么如何做到呐?
    1、首先我们需要在我们的关键字驱动表中去新建一列Results
    在这里插入图片描述
    在这里插入图片描述
    在常量文件中添加对应的变量

    	//第一个是测试用例结果标记列的索引,第二个是测试步骤里面的结果索引
    	public static final int Col_Result = 3;
    	public static final int Col_TestStepResult = 5;
    

    同时添加两个变量,记录结果状态pass和fail

    	//结果状态标记
    	public static final String KEYWORD_FAIL = "FAIL";
    	public static final String KEYWORD_PASS ="PASS";
    

    然后就需要继续修改我们的ExcelUtilt.java

    	//构造一个往单元格写数据的方法,主要是用来写结果pass还是fail
    	public static void setCellData(String Result, int RowNum, int ColNum, String SheetName){
    		try {
    			ExcelWSheet = ExcelWBook.getSheet(SheetName);
    			Row = ExcelWSheet.getRow(RowNum);
    			Cell = Row.getCell(ColNum);
    			if (Cell == null) {
    				Cell = Row.createCell(ColNum);
    				Cell.setCellValue(Result);
    			}else {
    				Cell.setCellValue(Result);
    			}
    			FileOutputStream fileOut = new FileOutputStream(Constants.PATH_TESTDATA);
    			ExcelWBook.write(fileOut);
    			fileOut.close();
                ExcelWBook = new XSSFWorkbook(new FileInputStream(Constants.PATH_TESTDATA));
    		} catch (Exception e) {
    			DriverScript.bResult = false;
    			e.printStackTrace();
    		}
    	}
    

    修改DriverSprict

    package com.keywordtwo.test;
    
    import java.io.BufferedInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    public class DriverScript {
    	
    	//声明一个public static的类对象,所以我们可以在main方法之外去使用
    	public static ActionsKeywords actionsKeywords;
    	public static String sActionKeyword;
    	
    	public static String sPageObject;
    	//下面的返回类型是方法,这里用到了反射类
    	public static Method method[];
    	
    	public static int iTestStep;
    	public static int iTestLaseStep;
    	public static String sTestCaseID;
    	public static String sRunMode;
    	//执行结果成功标记
    	public static boolean bResult;
    	
    	
    	
    	//构造函数,我们初始化ActionsKeywords类的一个对象
    	public DriverScript() throws ClassNotFoundException{
    		try {
    			Class actionKeywords = Class.forName("com.keywordtwo.test.ActionsKeywords");
    			method = actionKeywords.getMethods();
    		} catch (SecurityException e) {
    			
    			e.printStackTrace();
    		}
    //		for (int i = 0; i < method.length; i++) {
    //			System.out.println(method[i]);
    //		}
    	}
    	public static void main(String[] args) throws ClassNotFoundException, IOException, Exception {
    		
    		DriverScript ds = new DriverScript();
    		
    		String filepath = Constants.PATH_TESTDATA;
    		String sheetname = Constants.Sheet_TestSteps;
    		ExcelUtils.setExcelFile(filepath);
    		
    		/*for (int iRow = 1; iRow <= 6; iRow++) {
    			sActionKeyword = ExcelUtils.getCellData(iRow, Constants.Col_ActionKeyword);
    			sPageObject = ExcelUtils.getCellData(iRow, Constants.Col_PageObject);
    
    //			String keyvalue = PropertiesUtil.getValue(Constants.OR_Path, sPageObject);
    //			System.out.println(keyvalue);
    			excute_Actions();
    		}*/
    		
    		DriverScript startEngine = new DriverScript();
    		startEngine.excute_TestCase();
    	}
    	
    	public void excute_TestCase() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
    		//一共有多少条测试案例
    		int iTotalTestCases = ExcelUtils.getRowCount(Constants.Sheet_TestCases);
    		System.out.println("一共有"+iTotalTestCases+"条测试案例");
    		for (int iTestCase = 1; iTestCase <= iTotalTestCases; iTestCase++) {//从1开始,通过循环可以拿到每一个测试用例的String类型的sTestCaseID和sRunMode
    			bResult = true;
    			sTestCaseID = ExcelUtils.getCellData(iTestCase, Constants.Col_TestCaseID, Constants.Sheet_TestCases);
    			sRunMode = ExcelUtils.getCellData(iTestCase, Constants.Col_RunMode, Constants.Sheet_TestCases);
    			//如果RunMode是yes
    			System.out.println("sTestCaseID:"+sTestCaseID);
    			if (sRunMode.equalsIgnoreCase("yes")) {
    				//开始的行号
    				iTestStep = ExcelUtils.getRowContains(sTestCaseID, Constants.Col_TestCaseID, Constants.Sheet_TestSteps);
    				//最后一个行号
    				iTestLaseStep = ExcelUtils.getTestStepsCount(Constants.Sheet_TestSteps, sTestCaseID, iTestStep);
    				System.out.println("iTestStep:"+iTestStep);
    				System.out.println("iTestLaseStep:"+iTestLaseStep);
    				bResult = true;
    				//下面这个for循环的次数就等于测试用例的步骤数
    				for (; iTestStep < iTestLaseStep; iTestStep++) {
    					sActionKeyword = ExcelUtils.getCellData(iTestStep, Constants.Col_ActionKeyword, Constants.Sheet_TestSteps);
    					sPageObject = ExcelUtils.getCellData(iTestStep, Constants.Col_PageObject, Constants.Sheet_TestSteps);
    					excute_Actions();
    					if (bResult == false) {
    						ExcelUtils.setCellData(Constants.KEYWORD_FAIL, iTestCase, Constants.Col_Result, Constants.Sheet_TestCases);
    						break;
    					}
    				}
    				//成功执行完一个案例之后在判断
    				if (bResult == true) {
    					ExcelUtils.setCellData(Constants.KEYWORD_PASS, iTestCase, Constants.Col_Result, Constants.Sheet_TestCases);
    				}
    			}	
    		}
    	}
    	
    	
    	private static void excute_Actions() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
    		for (int i = 0; i < method.length; i++) {
    			if (method[i].getName().equals(sActionKeyword)) {
    				//method[i].invoke(actionsKeywords);
    				method[i].invoke(actionsKeywords,sPageObject);
    				if (bResult == true) {
    					ExcelUtils.setCellData(Constants.KEYWORD_PASS, iTestStep, Constants.Col_TestStepResult, Constants.Sheet_TestSteps);
    					break;
    				}else {
    					ExcelUtils.setCellData(Constants.KEYWORD_FAIL, iTestStep, Constants.Col_TestStepResult, Constants.Sheet_TestSteps);
    					break;
    				}
    			}
    		}
    	}
    }
    
    

    这里面仍然有一些不足,就是我们所做的操作不光光只有点击这种,我们仍然需要输入,那么输入的数据我们怎么读取进来呐?
    添加一列数据列,我们修改一下之前的result常量
    在这里插入图片描述
    修改ActionsKeywords.java类
    主要是构造一个input()的方法,我们修改每个关键字方法,参数都改成两个,一个参数是object,另外一个参数就是本文的data set。
    修改DriverScript.java类
    1.创建一个新的变量public static String sData;
    2.添加代码语句块,从excel中data set列复制给sData变量
    3.在execute_Action()代码块,把sData参数传递进去。

     sActionKeyword=ExcelUtils.getCellData(iTestStep,Constants.Col_ActionKeyword,Constants.Sheet_TestStep);
     sPageObject = ExcelUtils.getCellData(iTestStep, Constants.Col_PageObject, Constants.Sheet_TestSteps);
     sData = ExcelUtils.getCellData(iTestStep, Constants.Col_DataSet, Constants.Sheet_TestSteps);
     execute_Actions();
    

    这里是真正的读取参数然后将参数通过反射传递给真正的方法

    这样就可以了,回过头来总结,当有人问你是否熟悉关键字驱动的时候你是否可以说的清楚?
    注意到我们设置了一个常量类,这里主要是帮我们简化excel的操作,其实我们可以完全不用这个常量类,只需要在excel工具类中加上判断第一行的值等于多少在记录对应的列数就可以了,这样无论案例表格怎么改,都是可以执行的,这里至于怎么考虑就看个人了,一般公司的案例格式都是会固定的,统一原则嘛!

    首先在我个人看来,
    1、关键字驱动的核心是数据引擎,也就是我们的Excel表,我们后续的设计都是围绕着这个表格进行的。最基本的就是要有案例列表和案例执行步骤列表,一个测试过程会有很多的案例,而且每个案例又会包含很多个执行步骤,每个步骤又会有不同的操作
    2、有了驱动表之后我们为了涉及方便设置了常量类,其中包含了我们的文件路径,一些默认值、索引值以及工作簿的名称,以UI自动化为例,不同页面都会有相应的点击操作,我们不能把每一个点击操作都写成一个关键字,这样关键字的数量就会非常庞大,我们将这些操作抽象的部分提取出来,一个点击的btn有对应的xpath路径,而点击的操作click都是相同的,这里仍然是设计驱动表所需要关注的,也就是对象仓库,把不同页面的不同对象提取出来,也就是我们的案例操作涉及到哪些元素提出出来放到一个配置文件里面,加入页面元素的路径有修改,我们直接修改配置文件里面的内容就可以了,而代码如click关键字是不需要修改的
    4、其次才是设计我们的excel工具类,由于我们之前提取了一部分常量出来,所以excel工具类就变得没有那么复杂注意row和cell和提取写入方式,工具类基本就完成了基本操作每个小的方法基本10行左右的代码就可以搞定了
    5、封装关键字,将每一个关键字封装成一个一个的方法,打开浏览器是一个关键字,输入URL是一个关键字,点击是一个关键字,输入帐号是一个关键字。
    6、有了excel工具类,我们就可以读取我们想要的数据,写入我们想要的结果,我们读取到excel关键字需要和我们定义的关键字关联起来才能有对应的操作,这里就涉及到java的反射机制,这里我们可不可以不用java的反射,那么不用反射怎么做?我们需要读取到一个关键字然后进行if-else判断看读取到的关键字和哪个方法匹配,那么如果一个测试步骤有很多个关键字呐?我们也这么以此去if-else判断吗?显然这样代码的维护性是很差的。反射正好帮我们解决了这个问题,将所有的关键字的方法都存储在一个数组中,然后在数组中去查找对应的关键字7
    7、这些都完成之后我们才会设计我们执行的代码Driver Script类通过内外层循环加是否执行关键字来判断具体的案例执行以及通过异常处理来跟踪具体测试步骤的执行结果,当然大家还可以通过log4j组件来跟踪完善我们的测试过程。

    展开全文
  • 什么是关键字驱动自动化测试

    千次阅读 2020-07-22 17:57:03
    为 了提高测试效率和准确性,越来越多的测试工作引入了自动化测试的思想和方法,随着自动化测试工具的发展,自动化测试更加容易实现更高效。实践证明,软件自 动化测试技术帮助软件开发和测试人员在更短的时间内开发...

    第一章 前言

    为 了提高测试效率和准确性,越来越多的测试工作引入了自动化测试的思想和方法,随着自动化测试工具的发展,自动化测试更加容易实现更高效。实践证明,软件自 动化测试技术帮助软件开发和测试人员在更短的时间内开发出更高质量的产品,通过代替频繁重复的手工测试从而节省了大量的时间开支。同时,自动化测试技术也避免了手工测试出现的人为错误,完成了许多手工测试无法实现的工作。

    自动化测试相较于手动测试有许多明显的优势,执行高效率、测试数据覆盖面大、结果可信。但同时自动化测试也存在着一些限制。简单的录制/回放测试工具本省无法提供高效的测试。依靠捕捉产生脚本的维护需要耗费大量的时间。在项目需求不稳定或页面频繁变动的阶段,自动化测试的效率将非常低下。

    面对自动化测试的这种尴尬,关键字驱动的自动化测试可有效地提高自动化测试脚本的维护效率。关键字驱动的自动化测试搭建了一个自动化测试框架,测试框架脚本与业务、数据分离,节省了大量对脚本的维护工作。本文对关键字驱动的自动化测试做具体介绍。

    第二章 自动化测试工具存在的问题

    基本的录制/回 放自动化测试具有简单易用、快速上手的特点,但在实际应用过程中存在很多问题。最常见的一个问题是对程序界面进行测试时,一旦界面有任何改动,都需要我们 去手工修改已录制的相应测试脚本,或者重新进行一次录制。这需要消耗很大的工作量,尤其对于程序中各模块都要使用的公共程序部分(如登陆页面),他的改动 会引起大量脚本的返工。如在使用Rational Robot录制的点击按钮操作的脚本:测试工具通过按钮的名字、显示文本来识别这个按钮。可以想象,当其中任何一个部分发生变化时都会对脚本造成影响,维护如此的脚本将很可能花费大量成本。

    另一个问题是移植风险大。被测试软件转换平台,或转变自动化测试工具都可能造成测试用例被破坏,很可能要对现有脚本进行大量修改或重新录制。因此转换平台或转换工具可能对自动化测试带来毁灭性影响。

    第三章 自动化测试的发展

    3.1自动化测试框架的发展

    一 个自动化测试框架就是一个由假设、概念以及为自动化测试提供支持的实践的集合。自动化测试框架可以减少测试脚本实现和维护的成本,使测试人员把精力集中在 测试用例的设计上。自动化测试框架的好坏直接影响到自动化测试的成功与否。一个优秀的自动化测试框架应该满足以下特点:

    加入我们,软件测试技术交流群,1125760266,领取最新软件测试资料大厂面试和Python自动化、接口、框架搭建学习资料!

    1. 测试框架与被测应用程序独立。虽然测试的应用程序不一样,但被测应用程序之间却会有相同的地方,测试框架应聚焦在不同测试应用程序中共同的部分,把与具体应用程序有关的部分从框架中移除。

    2. 测 试框架应易于扩展、维护。测试框架应被高度模块化,这样可以提高框架的维护性。各个模块之间相互独立,对模块内部的修改不应该影响其他模块。除此之外,系 统应该有充足、详细的文档,与软件开发一样,这也是必不可少的。设计文档可以帮助开发人员扩展、维护测试框架,而使用文档则可以告诉用户要怎么使用该框 架。

    3. 测试脚本所使用的测试语言应该是与框架独立的。不同的测试框架可能在不同的应用领域有不同的表现,有些适用于Java应用程序的测试, 有些可能适用于Web应用程序的测试,如果测试脚本所采用的语言是私有的、与测试框架绑定的,那么当需要从一个测试框架迁移到另外一个测试框架时,所有的测试脚本都需要重写。

    4. 测 试框架不应该让框架的复杂性影响到测试人员。在大多数情况下,测试人员就是测试人员而不是开发人员,甚至有的时候,他们不是专业的测试人员,可能只是具有 很少软件开发经验的某个应用领域的专家。对于这些使用者来说,测试框架的使用要简单、测试语言要易于理解,这样可以使他们专注于业务相关内容的编写。

    基于界面的软件自动化测试框架和工具的发展大致经历了三个阶段:

    1)简单的录制/回放:由工具录制并记录操作的过程和数据形成脚本,通过回放来重复人工操作的过程。在这种模式下数据和脚本混在一起,几乎一个测试用例对应一个脚本,维护成本很高。而且即使界面的简单变化也需要重新录制,脚本可重复使用的效率低。

    2)数据驱动 (data driven)的自动化测试:从数据文件读取输入数据,通过变量的参数化,将测试数据传入测试脚本,不同的数据文件对应不同的测试用例。在这种模式下数据和脚本分离,脚本的利用率、可维护性大大提高,数据的覆盖率也较高,但受界面变化的影响仍然很大。

    3)关键字驱动(keyword driven)的自动化测试:关键字驱动测试是数据驱动测试的一种改进类型,它将测试逻辑按照关键字进行分解,形成数据文件,关键字对应封装的业务逻辑。 主要关键字包括三类:被操作对象(Item)、操作(Operation)和值(value),依据不同对象还有其他对应参数。关键字驱动的主要思想是:脚本与数据分离、界面元素名与测试内部对象名分离、测试描述与具体实现细节分离。数据驱动的自动化测试框架在受界面影响方面,较数据驱动和录制/回放有明显的优势,可根据界面的变化更新对应的关键字对象,而不用重新录制脚本。

    关键字驱动的自动化测试系统与数据驱动的系统相比,主要的不同有两点:第一点是数据文件 的设计方法不同,数据驱动系统中数据文件存储的是测试输入数据,脚本中仍然存在业务逻辑,这样业务的变化会引起脚本的更改,而关键字驱动系统数据文件的设 计将业务和测试输入数据都集成在数据表格中,虽然设计复杂,但当业务发生变化时,无需更改测试所用的脚本,从而提高了测试的效率。第二点是与数据驱动系统 相比,由于关键字驱动系统中数据文件的设计包含了业务信息,因此,将测试所进行的操作封装为关键字支持脚本。由动作封装的关键字支持脚本不包含任何的数据和业务信息,其重用性得到了极大的增强。
    3.2自动化测试脚本的发展
    相应地,软件测试自动化脚本的类型也依据脚本框架的演进在不断发展,从低到高的发展层次是:

    1. 线性脚本:通过录制直接产生的线性执行的脚本,类似于宏录制。

    2. 结构化的脚本:具有顺序、循环、分支等结构的脚本。

    3. 共享的脚本:可以被多个测试用例使用,被其它脚本调用的脚本。

    4. 数据驱动的脚本:数据和流程控制分离的脚本,通过读入数据文件来驱动流程进行的脚本。

    5. 关键字驱动的脚本:脚本、数据、业务分离,数据和关键字在不同的数据表中,通过关键字来驱动测试业务逻辑。关键字驱动脚本的特点是它描述一个测试事例做什么, 而不是如何做,测试脚本调用测试用例再具体执行。

    第四章 关键字驱动的自动化测试框架

    4.1基本原理

    关键字驱动的自动化测试框架是对数据驱动的逻辑扩展,用关键字的形式将测试逻辑封装在数据文件中,测试工具只要能够解释这些关键字即可对其应用自动化,它的核心思想可以概括为三个分离。

    1)界面元素名与测试内部对象名的分离 在被测应用程序和录制生成的测试脚本之间增加一个抽象层,它可以将界面上的所有元素映射成相对应的一个逻辑对象,测试针对这些逻辑对象进行,界面元素的改变只会影响映射表,而不会影响测试。

    2)测试描述与具体实现细节的分离,把测试描述和测试的具体实现细节分离开来。测试描述只说明软件测试要做什么以及期待什么样的结果,而不管怎样执行测试或怎样证实结果。这样做是因为测试的实现细节通常与特定的平台以及特定的测试执行工具有着密切的联系。这种分离使得测试描述对于应用实现细节是不敏感的,而且有利于测试在工具和平台间的移植。

    3)脚本与数据的分离 最后,可以把测试执行过程中所需的测试数据从脚本中提取出来,在运行时测试脚本再从数据存放处读取预先定制好的数据,这样脚本和数据可以独立维护。

    以上这三个分离各司其职、互相独立,最大程度地减少相互之间的影响。从关键字驱动的思想可以看出,该种测试框架不仅实现了将数据和脚本相分离,而且实现了测试逻辑和数据的分离,大大提高了脚本的复用度和维护性,从而更大限度地实现了测试工具的自动化。

    例如在一个登陆页面输入用户名,用一个测试表来表示:

    窗口 对象 行为 参数
    Loginpage UserID InputText admin

    这个测试表的含义是在LoginPage窗口的UserID文本框中输入“admin”。其中InputText是关键字,当测试程序读取它的时候,就会调用相应的处理函数,处理脚本动作。

    关键字驱动测试模型

    测 试首先由初始脚本开始,把高层测试表传递给高层驱动器,高层驱动器在处理这些表的过程中,遇到中层测试表就调用中层驱动器,中层驱动器处理中层表。当低层 驱动器处理低层表的时候,他试着使应用与测试保持同步。当低层驱动遇到某一成员的关键字指令时,它调用相应的函数模块来处理关键字的动作指令。所有这些元 素都要依靠映射表中的信息,踏实自动化模型和应用间的桥梁。

    应用映射表

    映射表是关键字驱动自动化测试中的关键组件之一。映射表是对应用中的每一个对象定义一套命名规范,并利用映射表把这些名字和自动化工具识别的对象名联系起来,是工具能准确定位和操纵对象,我们的脚本只需进行单点维护。

    映射表的建立有许多种,简单的就是 通过自动化测试工具进行自动捕获,将捕获的对象信息存储于指定的数据表格或数据库之中。如果是自动捕获可以分类记录尽可能多的对象的属性,使得测试脚本更 方便地标识对象。另一种就是采用人工录入,即对于自动化软件测试需要用到的对象信息采用手工识别的方式录入数据文件或数据库之中。这种方式通常是挑选最能 达到测试效果的一组对象属性即可。对于结构复杂的软件可以根据软件的不同层次或是软件界面的不同区域划分对象库。例如对于窗口空间,我们可以将窗口命名为 上下左右主几个部分,将位于不同窗口区域的控件信息保存到相应的窗口名称之下,这样当软件升级或者是GUI界面发生变化时,对于增加的窗口或者是控件,只需要使用测试工具捕获其标识属性,并人工填充到映射表内即可。这样就为测试脚本提供了对象识别的仓库。

    成员函数

    成员函数是实现用户对界面对象操作指令的函数,一个成员对象的类型对应一个成员函数库。例如对以一个文本框对象,可对它进行多种操作:输入文本、验证文本框的值等,实现这些操作行为的函数就被放在文本框的成员函数库中。一般的测试工具都提供了这样的函数。

    成员函数相当于在应用和自动化工具之间提供了一个隔离层,如果没有这个隔离层,自动化工具本身的改变会影响到已有的脚本。有了隔离层,当测试工具发生变化时,可以在成员函数库中增加一段修补代码来适应变化。

    测试表和核心驱动程序

    测试表分低层、中层、高层。低层测试表指定了测试的每一步指令语句,这些指令都是直接作用在界面对象上的,是无法再锌粉的指令。中层测试表把低层表组装起来执行任务,形成测试用例。高层测试表把中层表组装起来,利用循环完成不同的中层测试,形成测试集。

    例如打开网页、登陆、关闭页面这三个动作可以用三个低层表来表示(如表),每个表定义了实现相应动作的具体步骤,所以低层表示又叫做步骤表。低层表中使用了映射表中定义的对象名,和成员函数库定义的底层关键字库。

    窗口 对象 行为 参数
    LoginPage UserIDField InputText “admin”
    LoginPage UserIDField InputText “123”
    LoginPage UserIDField Click

    这个“登陆”动作的低层表可能出现在“验证正确登陆”,“验证错误登陆”和“验证空白登陆”等中层用例表中,这些中层表合起来构成了“验证权限”高层表。

    对应以上这三个测试表,核心数据驱动引擎相应地分成高层、中层、低层驱动器。高层驱动循环读取高层表的每条记录,遇到中间表的关键字,就把这个表传递给中层驱动器,依次类推直至到达低层表,低层驱动器来完成最后的执行。

    加入我们,软件测试技术交流群,1125760266,领取最新软件测试资料大厂面试和Python自动化、接口、框架搭建学习资料!

    展开全文
  • 关键字驱动自动化测试

    千次阅读 2018-08-17 11:37:33
    为 了提高测试效率和准确性,越来越多的测试工作引入了自动化测试的思想和方法,随着自动化测试工具的发展,自动化测试更加容易实现更高效。实践证明,软件自 动化测试技术帮助软件开发和测试人员在更短的时间内开发...
  • 1、自动化测试框架发展的第三个阶段是关键字驱动测试框架阶段,它是当前比较流行的一种框架一,并且现在的自动化测试工具已经将关键字驱动框架融入到工具中。在录制过程中自动化测试工具会将对象及操作属性保存到...
  • 个人理解自动化测试关键字驱动的目的就是为了让更多的人参与到自动化测试中来,提高测试效率,关键字驱动框架搭建完成时候,使用起来对没有技术基础的同学来说也是十分简单的 摘录网上的一个例子: 老师对着同学...
  • python+ddt数据驱动+unitTest+关键字驱动实现接口自动化测试
  • 【附源码】在关键字驱动测试框架中,除了PO模式以及一些常规Action的封装外,在团队中如何让不会写代码的人也可以进行自动化测试?通过代码实现,使得非技术型测试工程师通过修改数据文件即可执行不同的自动化测试,...
  • python selenium 关键字驱动开源 说明 最新的selenium3 python3的开源优化 使用 点击获取源码 配置yamls下的config的url url: https://testerhome.com/ 命令运行 python runner.py 或者修改start....
  • 自动化测试中的关键字驱动

    千次阅读 2021-08-26 17:33:11
    自动化测试中的关键字驱动关键字驱动python 实现关键字驱动getattr:实现反射机制思路 关键字驱动 通过关键字做对应的动作,很早的自动化测试工具都走的这个方向,比如RobotFramework,QTP等,这里简单介绍一下...
  • 时隔已久,再次冒烟,自动化测试工作仍在继续,自动化测试中的数据驱动技术尤为重要,不然咋去实现数据分离呢,对吧,这里就简单介绍下与传统unittest自动化测试框架匹配的DDT数据驱动技术。 话不多说,先撸一波源码...
  • 关键字驱动自动化测试的一种实现方式。将一些重复率高的动作写成关键字进行复用,也可以用现有的关键字组合新的关键字。 举例 数据驱动 假设我们有一个根据按下不同按键会发出对应按键所表式字符声音的计算器 按下...
  • 文章目录自动化测试的实施策略单元测试框架数据驱动设计模式核心原理适用场景代码示例关键字驱动设计模式混合模式驱动设计模式其他设计模式浅谈 自动化测试的实施策略 单元测试框架 数据驱动设计模式 核心原理 适用...
  • 数据与程序的分离,提示自动化测试的的可维护性。测试步骤代码如下: from selenium import webdriver import time import sys #读取txt文件 def get_data(file_path): with open(file_path, encoding='...
  • 关键字驱动框架是一种功能自动化测试框架,它也被称为表格驱动测试或者基于动作字的测试。关键字驱动的框架的基本工作是将测试用例分成四个不同的部分。首先是测试步骤(Test Step),二是测试步骤中的对象(Test ...
  • 关键字驱动测试是数据驱动测试的一种改进类型 主要关键字包括三类:被操作对象(Item)、操作(Operation)和值(value),用面向对象形式可将其表现为Item.Operation(Value) 将测试逻辑按照这些关键字进行分解,...
  • 为了提高软件自动化测试脚本的可复用性,提出了一种基于关键字驱动自动化测试框架(LKDT)。首先对目前现有自动化测试框架进行了归纳分析;然后提出了LKDT的系统架构,给出了其中所包含的关键技术;最后以实际的...
  • 数据驱动 优点 > 被测系统/功能还处于开发阶段时,就能开始着手写测试脚本。   > 模块的脚本设计和数据集的使用可减少冗余的脚本 被测系统功能有变化时,只需修改与此业务功能相关的特定脚本。   >...
  • 在这样的前提条件下,论文采用了关键字驱动脚本技术,同时吸取了当前流行的自动化测试框架中一些先进的思想,提出了一个适合网管系统测试的自动化测试框架。然后论文对该框架的测试流程进行详细的描述,在此框架的...
  • 那么这篇文章我们将了解关键字驱动测试又是如何驱动自动化测试完成整个测试过程的。关键字驱动框架是一种功能自动化测试框架,它也被称为表格驱动测试或者基于动作字的测试。关键字驱动的框架的基本工作是将测试用例...
  • 这里写自定义目录标题RobotFrameWork说明简介特点安装和环境配置RF库介绍RF关键字的使用RFweb自动化环境搭建UI框架分层设计断言RF接口自动化环境搭建与jenkins持续集成如何插入一段漂亮的代码片生成一个适合你的列表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,192
精华内容 17,276
关键字:

自动化测试之关键字驱动