自动化测试关键字驱动的原理及实现

最新推荐文章于 2025-06-26 16:11:40 发布
最新推荐文章于 2025-06-26 16:11:40 发布
阅读量8.2k 收藏 9
点赞数 5
分类专栏： Selenium2.0&WebDriver

转载地址：http://www.cnblogs.com/zhangfei/p/5330994.html


自动化测试现在越来越趋向于平台化，平台化是致力于协同工作，提高效率，让更多人参与自动化的一个过程，在我看来，平台化中，有一个更为关键点，就是关键字驱动，只有把自动化测试的代码转换成为大家更容易懂的自然语言，才能让更多不懂代码的人加入进去，才能达到平台化的目的。今天我们就来谈谈自动化测试中关键字驱动的原理及实现方式。

       先来看一个例子，老师对着同学们说了一句：去把桌子从A地点搬到B地点。当老师发出这个命令后，发现没有人动，因为没有明确的对象，不知道这个命令是对谁发出的，于是老师再说了一句：张三，去把桌子从A地点搬到B地点。这时候，有了明确的对象--张三，有了命令的主体--搬桌子从A到B。所以这句” 张三，去把桌子从A地点搬到B地点”中就有两个关键字：张三、把桌子从A地点搬到B地点。当这两个关键字缺少任何一个，这件事就不可能完成。所以，我们可以把这个场景理解为关键字驱动，假如我们把上面这句话转换为代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MoveDesk {
     
    private Person zhangsan;
 
    public void setZhangsan(Person zhangsan) {
        this.zhangsan = zhangsan;
    }
 
    public void moveDeskFromA2B(){
        zhangsan.getTheCommandFromTeacher();
        zhangsan.findTheDeskAtA();
        zhangsan.moveDeskToB();
        zhangsan.notifyTeacherHadFinished();
    }
 
    public static void main(String[] args) {
        MoveDesk md = new MoveDesk();
        md.setZhangsan("张三");
        md.moveDeskFromA2B();
    }
 
}

 

上面的代码当然是伪代码，但从中可以看出，其为了达到一个目的，流程都是一样的，那两个关键字在main方法中体现为：张三对应md.setZhangsan("张三")，”把桌子从A地点搬到B地点”对应md.moveDeskFromA2B()。由此我们可以这样理解一下：每一个关键字对应一个具体的方法。所以，总结一下关键字驱动的实现特点：

1. 每一个关键字对应的方法(以下称为关键方法)必须能够随时被调用，这就像老师对张三发出的命令张三必须去执行一样。在JAVA里面为了达到这个关键方法随时能被调用，其类对象必须事先就被new好，所以要有一个对象池，这个对象池就像一个班级，有很多个学生可以供老师发出命令并去执行。

2. 关键字必须与关键方法进行关联，就像老师让张三搬桌子，而张三跑去买了一包烟，这就不对了，所以，必须要有一个关键字与关键方法的映射表。

3. 得有一个关键字的解析方式，比如上面那条命令中，我们要能够得出张三、把桌子从A地点搬到B地点这两个关键字，要是不能得出关键字，关键方法就会少执行，就如上面的伪代码中，如果去掉md.setZhangsan("张三")这一句，显然就会报空指针异常了。

4. 上面这三条具备后，就是执行了，老师发出的命令，张三要能够执行，当然，要是张三是个刺头就另说了。JAVA代码能够交给JVM去执行，但转换成为关键字后，JVM就不认识这些关键字了，所以，我们也必须要有一个健壮的执行引擎，让“张三，去把桌子从A地点搬到B地点”这一句话能够被执行成功。

综上所述，只要我们把上面的四条通过代码来实现，一个简单的关键字框架雏形就出来了，接下来我们一条条的实现。

1.对象池：

1
2
3
4
5
6
7
8
public class RegisterCenter {
     
    public static Map<String, Object> OBJ_POOLS = new HashMap<String, Object>();
     
    static{
        OBJ_POOLS.put(MoveDesk.class.getName(), new MoveDesk());
    }
}

 

将所有含有关键方法的类都初始化一遍，然后放到OBJ_POOLS这个对象里，方面后面直接调用关键方法。(请大家试着用注解去实现，会更炫)

2.映射表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class KeywordReflect {
     
    public static Map<String, Map<String, String>> KEYWORD_POOLS = new HashMap<String, Map<String, String>>();
     
    static{
        KEYWORD_POOLS.put("张三", KeywordReflect.methodInfo(MoveDesk.class.getName(), "setZhangsan"));
        KEYWORD_POOLS.put("把桌子从A地点搬到B地点", KeywordReflect.methodInfo(MoveDesk.class.getName(), "moveDeskFromA2B"));
    }
     
    public static Map<String, String> methodInfo(String className, String methodName){
        Map<String, String> methodInfo = new HashMap<String, String>();
        methodInfo.put("class", className);
        methodInfo.put("method", methodName);
        return methodInfo;
    }
     
}

 

说明：上面的KEYWORD_POOLS对象的数据结构是MAP里面套了一个MAP，这是因为要明确类对象，因为不同的类里可能有相同名称的方法，所以，为了避免混乱，必须标注好一个方法的类与方法名，这样才能建立好一一对应的映射表。（同样可以用注解来实现）

3.解析关键字

为了能够解析出关键字，我们得把” 张三，去把桌子从A地点搬到B地点”这句话的关键字给标注出来，改造一下”${张三}，去${把桌子从A地点搬到B地点}”,这样就把关键字给明确的标注出来了，虽然从直观感受上差了那么一点点，但却是关键字驱动中很重要的一部分。接下来的问题转变成为了对一段字符串中${}的解析了：

正则类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class RegExp {
     
    public boolean match(String reg, String str) {
        return Pattern.matches(reg, str);
    }
  
    public List<String> find(String reg, String str) {
        Matcher matcher = Pattern.compile(reg).matcher(str);
        List<String> list = new ArrayList<String>();
        while (matcher.find()) {
            list.add(matcher.group());
        }
        return list;
    }
      
}

 获取关键字类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ParseKeyword {
     
    public List<String> getKeywords(String p){
        String reg = "(?<=(?<!\\\\)\\$\\{)(.*?)(?=(?<!\\\\)\\})";    
        RegExp re = new RegExp();
        List<String> list = re.find(reg, p);
        return list;
    }
     
    public static void main(String[] args) {
        ParseKeyword p = new ParseKeyword();
        System.out.println(p.getKeywords("a${a}a"));
        System.out.println(p.getKeywords("a\\${a}a"));
        System.out.println(p.getKeywords("a${a\\}a"));
        System.out.println(p.getKeywords("a${a\\}a}a"));
        System.out.println(p.getKeywords("a${a}a${"));
        System.out.println(p.getKeywords("a${ab}a${a}"));
    }
}

 

说明：里面用到了正则预查模式，正则预查模式是正则中的一种相对高阶的用法，掌握这个后，你的正则就会上一个台阶。

4. 执行引擎:

执行引擎先要找到需要执行的语句，所以，首先应该把老师发的那个命令给读取出来，这个命令可以存放在任何格式的文件里，只要能被读出来即可，在这里我们保存在command.txt里：

读取这个命令：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Executor {
     
    public List<String> readTxtFile(String filePath) {
        List<String> list = new ArrayList<String>();
        try {
            String encoding = "UTF8";
            File file = new File(filePath);
            if (file.isFile() && file.exists()) {
                InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);
                BufferedReader bufferedReader = new BufferedReader(read);
                String lineTxt = null;
                while ((lineTxt = bufferedReader.readLine()) != null) {
                    list.add(lineTxt);
                }
                read.close();
                bufferedReader.close();
            } else {
                System.out.println("找不到指定的文件");
            }
        } catch (Exception e) {
            System.out.println("读取文件内容出错");
            e.printStackTrace();
        }
        return list;
    }
     
    public static void main(String[] args) {
        Executor e = new Executor();
        System.out.println(e.readTxtFile("src/command.txt"));
    }
     
}

 

读取之后，流程就是：获取关键字->获取关键方法->执行关键方法.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
public class Executor {
     
    private ParseKeyword pk = new ParseKeyword();
     
    public List<String> readTxtFile(String filePath) {
        List<String> list = new ArrayList<String>();
        try {
            String encoding = "UTF8";
            File file = new File(filePath);
            if (file.isFile() && file.exists()) {
                InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);
                BufferedReader bufferedReader = new BufferedReader(read);
                String lineTxt = null;
                while ((lineTxt = bufferedReader.readLine()) != null) {
                    list.add(lineTxt);
                }
                read.close();
                bufferedReader.close();
            } else {
                System.out.println("找不到指定的文件");
            }
        } catch (Exception e) {
            System.out.println("读取文件内容出错");
            e.printStackTrace();
        }
        return list;
    }
     
    public void executor(){
        List<String> commands = this.readTxtFile("src/command.txt");
        for (String command : commands) {
            List<String> keywords = pk.getKeywords(command);
            for (String keyword : keywords) {
                this.invoke(keyword);
            }
        }
    }
     
    public void invoke(String keyword){
        Map<String, String> keyMethod = KeywordReflect.KEYWORD_POOLS.get(keyword);
        String className = keyMethod.get("class");
        String methodName = keyMethod.get("method");
        Object obj = RegisterCenter.OBJ_POOLS.get(className);
        Method method = this.getMethod(methodName, obj);
        try {
            method.invoke(obj);
        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
     
    private Method getMethod(String methodName, Object obj) {
        try {
            Method[] methods = obj.getClass().getMethods();
            for (Method m : methods) {
                if (m.getName().equals(methodName)) {
                    return m;
                }
            }
        } catch (SecurityException e) {
            return null;
        }
        return null;
    }
     
    public static void main(String[] args) {
        Executor e = new Executor();
        e.executor();
    }
     
}

 

为了大家能够看到执行结果，把MoveDesk类给改改：

1
2
3
4
5
6
7
8
9
10
11
public class MoveDesk {
     
    public void setZhangsan() {
        System.out.println("this is zhangsan");
    }
 
    public void moveDeskFromA2B(){
        System.out.println("this is test!");
    }
 
}

 

这样执行之后，就能看到这两个关键方法体被执行了！执行引擎中最关键的就是利用了JAVA的反射来执行方法！

以上的代码经过测试运行通过！

由此一个最最简单的关键字驱动架子就搭建完成了，还有如下的一些点需要大家自行去完成：关键方法参数处理，关键方法返回值处理，异常处理，结合数据驱动，结合测试框架（TESTNG/JUNIT）等。也有很大的优化空间留给大家自行发挥去吧！

点亮测试人生！QQ：408129370

web自动化(5)——关键字驱动
weixin_42833736的博客
01-02 1330
关键字模型,更关注的是业务流程,其实很多企业也是如此,我们只需要在excel文件中讲测试用例维护好,而需要编写的脚本量非常小,如果页面有变动,只需要维护excel表格中的用例数据即可,而脚本基本不需要变动。
自动化测试中的关键字驱动
weixin_40274647的博客
08-26 6827
自动化测试中的关键字驱动关键字驱动python 实现关键字驱动getattr：实现反射机制思路 关键字驱动 通过关键字做对应的动作，很早的自动化测试工具都走的这个方向，比如RobotFramework，QTP等，这里简单介绍一下关键字驱动的原理 python 实现关键字驱动 python实现关键字驱动，主要用到的是python中的反射getattr getattr：实现反射机制 getattr可以通过字符串获取方法实例。这样，你就可以把一个类可能要调用的方法放在配置文件里，在需要的时候动态加载。 思路 在e
Selenium自动化框架：数据驱动、关键字驱动和混合
最新发布
OKCRW的博客
06-26 657
这个 Selenium框架 是一种代码结构，它使代码维护变得简单而高效。如果没有框架，用户可以将“c”框架产生了一些有益的结果，比如增加了代码可重用性、更高的可移植性、降低了脚本维护成本、更好的代码可读性等。SeleniumWebDriver主要创建了三种类型的框架来自动化手动测试用例数据驱动测试框架关键字驱动测试框架混合测试框架。
关键字驱动测试的原理和概念
乐在其中/Leo在其中
04-09 755
原理及特点 1.         关键字驱动测试是数据驱动测试的一种改进类型 2.         主要关键字包括三类：被操作对象（Item）、操作（Operation）和值（value），用面向对象形式可将其表现为 Item.Operation(Value) 3.         将测试逻辑按照这些关键字进行分解，形成数据文件。 4.         用关键字的形式将测试逻辑封装在数据文...
关键字驱动测试原理，Po模式和关键字模式
公子清羽的博客
09-19 3620
Po模式和关键字模式 Po模式： What? PO模式(page object model)：是一种设计思想，是为了解决自动化测试过程中随着代码量的增加导致的大量代码难以维护、难以扩展、可读性极差等灾难性的事件的方案，所谓Page Object及页面对象，页面对象是哪些东西呢？比如一个按钮是一个对象，一个页面也是一个对象. 实际的应用当中，一般我们会抽取一个页面的基类，用于对一些页面元素的功能操作进行扩展，比如获取title，模态窗口的处理，一些基本控件的处理都可以放在这个页面的基类里面。后面的..
关键字驱动框架入门教程-1-介绍
Anthony_tester的博客
01-29 6715
之前在群里，看到很多人在讨论关键字驱动框架，我之前有使用过别人写的关键字驱动框架的经历，其实我是比较不喜欢这个框架的，它更多少是作为一个开发或者测试开发人员，开发的一个框架或者工具，目的是让不懂代码的黑盒测试人员去快速编写测试脚本。刚好，我在toolsqa.com看到了这个关键字驱动的教程，所以，这里我把它翻译过来，加上一部分我自己的理解。希望大家也可以通过这个教程，知道什么是关键字驱动框架，如何
什么是关键字驱动自动化测试
A_Kaka的博客
07-22 2593
第一章 前言 为 了提高测试效率和准确性，越来越多的测试工作引入了自动化测试的思想和方法，随着自动化测试工具的发展，自动化测试更加容易实现更高效。实践证明，软件自 动化测试技术帮助软件开发和测试人员在更短的时间内开发出更高质量的产品，通过代替频繁重复的手工测试从而节省了大量的时间开支。同时，自动化测试技术也避免了手工测试出现的人为错误，完成了许多手工测试无法实现的工作。 自动化测试相较于手动测试有许多明显的优势，执行高效率、测试数据覆盖面大、结果可信。但同时自动化测试也存在着一些限制。简单的录制/回..
UI 自动化测试框架：关键字驱动+数据驱动
HB8888888的博客
02-24 6504
1. 关键字驱动框架简介 原理及特点 关键字驱动测试是数据驱动测试的一种改进类型，它也被称为表格驱动测试或者基于动作字的测试。 主要关键字包括三类：被操作对象（Item）、操作行为（Operation）和操作值（Value），用面向对象形式可将其表现为Item.Operation(Value)。 将测试逻辑按照这些关键字进行分解，形成数据文件。 用关键字的形式将测试逻辑封装在数据文件中，测试工具只要能够解释这些关键字即可对其应用自动化。 优势 执行人员可以不需要太多的技术：一旦框架建立，手.
十年测开如何理解自动化测试里的数据驱动、关键字驱动思路
Yanan990830的博客
08-16 341
“什么是数据驱动呢？ 很大一部分人肯定认为数据驱动就是把需要参数化的东西写在EXCEL里，然后在跑脚本时调用。如果我告诉你，这其实不是数据驱动，而只是较高级的参数化，你肯定会很惊讶！...
ui自动化框架，关键字驱动
11-05
关键字驱动是一种自动化测试框架设计模式，它将复杂的编程逻辑封装在关键词后面，使得非程序员也能理解和执行自动化测试。在这个主题中，我们将深入探讨UI自动化框架以及关键字驱动的概念、实现方式和优势。 一、UI...
一种关键字驱动的自动化测试框架
03-23
0引言 　　软件测试是保障和提高软件质量的重要手段[1]。软件开发者和使用者必须对软件进行充分的测试，以确保其正常工作。统计表明，在典型的软件开发项目中，软件测试工作量往往占软件开发总工作量的40%以上[2，3]。因此提高软件测试过程的效率至关重要。 　　为了提高测试效率，越来越多的测试工作引入了自动化测试的思想和方法。实践证明，软件自动化测试技术提高了软件测试的速度和效率，节省了软件测试成本，缩短了产品发布周期。同时，自动化测试技术也完成了许多手工测试无法实现的工作。所以，采用自动化测试方法和相应的测试框架成为了软件开发组织测试工作的重要支撑手段。例如，采用自动化测试工具能在测试活动中减少一
自动化测试 selenium python3 关键字驱动 数据驱动
08-08
自动化测试的一个框架，没有使用robotframework，关键字支持大概十几个吧，如果不够可以自己在代码中完善，测试用例写在excel中，运行AutoTest.py就行
关键字驱动测试框架的研究
12-28
关键字驱动测试框架的研究,为了挣点积分才上传的关键字驱动测试框架的研究,为了挣点积分才上传的关键字驱动测试框架的研究,为了挣点积分才上传的
【技术篇】自动化测试框架设计核心理念——关键字驱动！
okcross0的博客
12-14 863
很多人在接触时，都会听到驱动这样的一个概念，但是在研究时却有些不太清楚这种驱动模式的设计及实现到底该如何着手去做。关键字驱动，作为一种的设计形式，在很早的时候就已经有提及过了。它的基本原理或者说构思就是将原本的自动化代码进行代码与数据的分离，再将分离出来的代码二次分离，形成所谓行为代码与测试代码，而后再经由数据内容驱动行为代码，生成测试代码。从而更加便捷地进行自动化测试代码的管理，以及提高自动化的复用性，让使用者更加容易理解和使用自动化（毕竟还是有很多很多测试人员对代码一窍不通。
关键字驱动测试
wenjuzhi的专栏
09-28 614
关键字驱动测试（keyword-driven）原理及特点 1.关键字驱动测试是数据驱动测试的一种改进类型 2.主要关键字包括三类：被操作对象（Item）、操作（Operation）和值（value），用面向对象形式可将其表现为 Item.Operation(Value) 3.将测试逻辑按照这些关键字进行分解，形成数据文件。 4.用关键字的形式将测试逻辑封装在数据文件中，测试工具只要能够
第20章：python自动化——关键字驱动类实现
huang_zp123的博客
04-22 1629
本章主要学习的是关键字驱动的学习，将常用的一些操作，进行封装，这就是逻辑代码，专门用一个文件进行管理。测试代码专门用一个文件进行管理。逻辑代码，不涉及数据。测试代码，不涉及逻辑。分开管理，方便维护。代码和数据的分离，在后面也会讲到。下一章讲解的EXCEL数据驱动就是数据分离的一种形式。关键字驱动类，是行为的封装，重点在封装二字。 关键字驱动类除去封装基本的操作行为之外，还可以实现流程的关键字封装，在整个框架设计上，封装的定义不是固定的。
自动化测试框架设计核心理念——关键字驱动
2301_77645834的博客
09-18 1090
很多人在接触自动化测试时，都会听到驱动这样的一个概念，但是在研究时却有些不太清楚这种驱动模式的设计及实现到底该如何着手去做。关键字驱动，作为一种的设计形式，在很早的时候就已经有提及过了。它的基本原理或者说构思就是将原本的自动化代码进行代码与数据的分离，再将分离出来的代码二次分离，形成所谓行为代码与测试代码，而后再经由数据内容驱动行为代码，生成测试代码。从而更加便捷地进行自动化测试代码的管理，以及提高自动化的复用性，让使用者更加容易理解和使用自动化（毕竟还是有很多很多测试人员对代码一窍不通。
自动化测试之数据驱动和关键字驱动
py_xiaobai的博客
04-10 1606
数据驱动 数据和程序的分离，程序不变，数据变 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_x...
QTP关键字驱动自动化测试实践DEMO解析
它涵盖了自动化测试的基本概念、关键字驱动测试的原理、XML在测试中的应用、数据驱动框架的实现方式以及两者的结合使用。通过这份DEMO，测试人员可以更好地理解和掌握关键字驱动和数据驱动测试框架的设计和实施，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值