数据驱动剖析及 TestNg 数据驱动介绍

子豪_002

数据驱动特点

数据驱动是指在脚本固定的情况下，根据数据的条数来决定脚本的运行次数，即有几组数据，脚本就会
运行几遍。

数据驱动概述

数据驱动(Data Driven)，这里强调的是数据，驱动即执行，那么数据驱动就是根据数据来执行测试脚本。

场景：测试登录，分别用刘能和赵四的帐号去测试。
先写一个公共方法来描述登录的过程：(伪代码实现)

1. public boolean login(String username, String password){
   
2.     //do login
   
3. }
   
4. 再到测试方法里面去调用这个login方法/函数：
   
5. public void test1(){
   
6.     login("liuneng","123456");
   
7. }
   
8. 
   
9. public void test2(){
   
10.     login("zhaosi","654321");
    
11. }

复制代码

这样测试用例就写完了，执行test1与test2两个方法即可。但细心的你可能会发现test1与test2这两个测试方
法里的方法体除了数据，其它完全一样，这就存在重构的空间了：

1. public boolean login(String[][] accounts){
   
2.     for(int i = 0; i<accounts.length; i++){
   
3.         //do login
   
4.     }
   
5. }
   
6. 
   
7. public void test(){
   
8.     String[][] accounts = [["liuneng","123456"],["zhaosi","654321"]];
   
9.     login(accounts);
   
10. }

复制代码

经过重构后的代码，就有点数据驱动的意思了，根据accounts的length来决定login方法/函数体运行几次，这
样维护起来就方便了，假如又有一个老王的帐号想用来测试，就不需要再加一个测试方法了，只需要：
String[][] accounts = [["liuneng","123456"],["zhaosi","654321"],["laowang","000000"]];
重构后的代码，是不是令你很激动？原来这就是数据驱动！别急，淡定，这还不是真的数据驱动，因为上面
只有一个测试方法，最后执行完后，报告中记录的也是只有一个测试方法，而场景中：分别用刘能和赵四的
帐号去测试，是希望在测试报告中有两个测试方法出现，显然上面的代码还不能满足我们的需求，于是进一
步优化：

1. public boolean login(String username, String password){
   
2.     //do login
   
3. }  
   
4. 
   
5. public void test(String username, String password){
   
6.     login(username,password);
   
7. }
   
8. 
   
9. public void executor(){
   
10.     String[][] accounts = [["liuneng","123456"],["zhaosi","654321"]];
    
11.     for(int i = 0; i<accounts.length; i++){
    
12.         test(accounts[i][0],accounts[i][1]);
    
13.     }
    
14. }

复制代码

是的，离数据驱动原理真相越来越近了，上面多了个executor方法，这是啥？这就是车子的发动机引擎啊，
就是测试脚本的执行引擎，让测试方法能够被执行起来，以及根据你所提供的测试数据的条数，决定测试
方法的执行次数，并且报告中会显示是两个测试方法，这就是数据驱动。测试框架就是一个执行引擎，并
且测试框架都会支持数据驱动这一基本诉求，比如TestNg里的dataProvider，junit里的Parameters等。下
面将为大家介绍TestNg里的dataProvider的用法。
TestNg数据驱动

TestNg的数据驱动也是以注解的形式来表达的：

1. 
   
2. public class TestData {
   
3. 
   
4.     @DataProvider(name="dataDemo")
   
5.     public Object[][] dataProvider(){
   
6.         return new Object[][]{{1,2},{3,4}};
   
7.     }
   
8. 
   
9.     @Test(dataProvider="dataDemo")
   
10.     public void testDemo(int a, int b){
    
11.         int sum = a + b;
    
12.         System.out.println("this is sum: "+sum);
    
13.     }
    
14. 
    
15. }

复制代码

说明：

TestNg的数据驱动的提供数据的方法用@DataProvider注解
@DataProvider中的name属性表示该数据源的名称
@DataProvider的方法要返回一个Object[][]的二维数组，当然也可以是Iterator的数据结构。
在测试方法中要用到数据源，则要在@Test中加上dataProvider属性，其值为数据源的名称。
Object[][]二维数组{{1,2},{3,4}}可以理解为有两组数据，分别为：{1,2}，{3,4}，所以测试方法会运行两
次，每一次运行时，测试方法的第一个参数a对应这一组数据中的第一个，也就是1或者3，第二个参数b则
对应这一组数据中的第二个，也就是2或者4，如果还有数据，则依次类推。当然数据源的每一组数据的个
数要大于或等于测试方法的参数个数，否则会报错，且数据类型要对应上，否则也会报错。
上面的示例中我们指定了@DataProvider数据源的名称为dataDemo，其实也可以不指定其名称，如果不指
定其名称，则数据源的名称为该数据源方法的方法名，比如：

1. 
   
2. public class TestData {
   
3. 
   
4.     @DataProvider
   
5.     public Object[][] dataProvider(){
   
6.         return new Object[][]{{1,2},{3,4}};
   
7.     }
   
8. 
   
9.     @Test(dataProvider="dataProvider")
   
10.     public void testDemo(int a, int b){
    
11.         int sum = a + b;
    
12.         System.out.println("this is sum: "+sum);
    
13.     }
    
14. 
    
15. }

复制代码

上面的例子中，@DataProvider数据源的方法与测试方法是在同一个测试类里，或者@DataProvider数据源的
方法放在测试类的父类中。但其实还有一种方式，@DataProvider数据源的方法可以单独的放在一个类里，比如：

1. 
   
2. public class DataSource {
   
3. 
   
4.     @DataProvider
   
5.     public static Object[][] dataProvider(){
   
6.         return new Object[][]{{1,2},{3,4}};
   
7.     }
   
8. 
   
9. }
   
10. 
    
11. public class TestData {
    
12. 
    
13.     @Test(dataProvider="dataProvider",dataProviderClass=DataSource.class)
    
14.     public void testDemo(int a, int b){
    
15.         int sum = a + b;
    
16.         System.out.println("this is sum: "+sum);
    
17.     }
    
18. 
    
19. }

复制代码

说明：

在测试方法中可以指定一个数据源的类，用dataProviderClass来指定
如果用了dataProviderClass指定数据源的类，则@DataProvider数据源的方法必须是static的。
其实@DataProvider数据源的方法，还可以提供一个参数Method，这个Method是指要使用该数据源的测试
方法的Method对象，比如：

1. 
   
2. public class TestData {
   
3. 
   
4.     @DataProvider
   
5.     public Object[][] dataProvider(Method method){
   
6.         //method对象指使用该数据源的测试方法的Method对象，这是java中的一种反射
   
7.         System.out.println(method.getName());//输出testDemo
   
8.         return new Object[][]{{1,2},{3,4}};
   
9.     }
   
10. 
    
11.     @Test(dataProvider="dataProvider")
    
12.     public void testDemo(int a, int b){
    
13.         int sum = a + b;
    
14.         System.out.println("this is sum: "+sum);
    
15.     }
    
16. 
    
17. }
    
18. 很显然，有了这个Method对象后，就很方便我们扩展了，请看下面的例子：
    
19. 
    
20. 先写一个类，将所有的数据都放在里面：
    
21. public class DataSource {
    
22.     /**
    
23.      * dataMap里有两个数据源，分别是testDemo与testDemo1
    
24.      * 根据测试方法的名称，来使用不同的数据源。
    
25.      * 比如testDemo方法就用数据源{{1,2},{3,4}}
    
26.      * testDemo1方法就用数据源{{5,6},{3,4}}
    
27.      * @return
    
28.      */
    
29.     public Map<String, Object[][]> dataSource(){
    
30.         Map<String, Object[][]> dataMap = new HashMap<String, Object[][]>();
    
31.         Object[][] o1 = new Object[][]{{1,2},{3,4}};
    
32.         dataMap.put("testDemo", o1);
    
33.         Object[][] o2 = new Object[][]{{5,6},{7,8}};
    
34.         dataMap.put("testDemo1", o2);
    
35.         return dataMap;
    
36.     }
    
37. 
    
38. }
    
39. 再结合到@DataProvider数据源方法与测试方法中去：
    
40. public class TestData {
    
41. 
    
42.     @DataProvider
    
43.     public Object[][] dataProvider(Method method){
    
44.         DataSource data = new DataSource();
    
45.         Object[][] obj = data.dataSource().get(method.getName());
    
46.         return obj;
    
47.     }
    
48. 
    
49.     @Test(dataProvider="dataProvider")
    
50.     public void testDemo(int a, int b){
    
51.         int sum = a + b;
    
52.         System.out.println("this is sum: "+sum);
    
53.     }
    
54. 
    
55.     @Test(dataProvider="dataProvider")
    
56.     public void testDemo1(int a, int b){
    
57.         int sum = a + b;
    
58.         System.out.println("this is sum: "+sum);
    
59.     }
    
60. 
    
61. }
    
62. 以上两个测试方法用到了同一个数据源@DataProvider，这样为我们以后写测试框架定下了基调。
    
63. 
    
64. enum的使用
    
65. 
    
66. enum是java中的一个关键字，中文翻译过来是枚举，先来看看用法：
    
67. 
    
68. public enum TestEnum {
    
69.     /**
    
70.      * 定义两组数据,分别是{200,"success."}与{400,"failed."}
    
71.      * 枚举的意思是根据定义好的数据，来生成对象，有几组数据，就生成几个对象
    
72.      */
    
73.     SUCCESS(200,"success."),
    
74.     FAIL(400,"failed.");
    
75. 
    
76.     private int retCode;
    
77. 
    
78.     private String retMsg;
    
79. 
    
80.     private TestEnum(int retCode, String retMsg) {
    
81.         this.retCode = retCode;
    
82.         this.retMsg = retMsg;
    
83.     }
    
84. 
    
85.     public int getRetCode() {
    
86.         return retCode;
    
87.     }
    
88. 
    
89.     public String getRetMsg() {
    
90.         return retMsg;
    
91.     }
    
92. 
    
93.     public static void main(String[] args) {
    
94.         System.out.println(TestEnum.SUCCESS.getRetCode());//输出200
    
95.         System.out.println(TestEnum.FAIL.getRetMsg());//输出failed.
    
96.     }
    
97. 
    
98. }

复制代码

子豪_002

说明：枚举的意思是根据定义好的数据，来生成对象，有几组数据，就生成几个对象。上面的例子中生成
了SUCCESS和FAIL两个对象。
联想到之前的数据驱动，是有几组数据测试方法就会执行几次，枚举是有几组数据就会生成几个对象，冥
冥之中枚举与数据驱动好像有那么点联系，既然枚举已经定义好了，那么根据上面我们介绍到的知识点，
把枚举与数据驱动联系起来。

1. 
   
2. public class DataSource {
   
3. 
   
4. public Map<String, Object[][]> dataSource(){
   
5. Map<String, Object[][]> dataMap = new HashMap<String, Object[][]>();
   
6. TestEnum[] te = TestEnum.values();//enum提供的方法，是把生成的几组对象给放到一个数组里{
   
7. TestEnum.SUCCESS,TestEnum.FAIL}
   
8. Object[][] o1 = new Object[te.length][];//定义一个数据源，其数据条数与TestEnum的数组条数一样
   
9. for (int i = 0; i < o1.length; i++) {
   
10. Object[] o1temp = new Object[]{te[i]};//将每一个TestEnum再单独的放到一个数组里，o1temp
    
11. 为{TestEnum},
    
12. o1[i] = o1temp;//{{TestEnum.SUCCESS},{TestEnum.FAIL}}，o1[0]就为{TestEnum.SUCCESS},
    
13. 枚举出来的TestEnum.SUCCESS与TestEnum.FAIL都是一个TestEnum对象，只是对象里面的属性值不同
    
14. }
    
15. //循环添加后，数据结构为{{TestEnum.SUCCESS},{TestEnum.FAIL}}
    
16. dataMap.put("testDemo", o1);
    
17. Object[][] o2 = new Object[][]{{5,6},{7,8}};
    
18. dataMap.put("testDemo1", o2);
    
19. return dataMap;
    
20. }
    
21. 
    
22. }
    
23. 
    
24. public class TestData {
    
25. 
    
26. @DataProvider
    
27. public Object[][] dataProvider(Method method){
    
28. DataSource data = new DataSource();
    
29. Object[][] obj = data.dataSource().get(method.getName());
    
30. return obj;
    
31. }
    
32. 
    
33. @Test(dataProvider="dataProvider")
    
34. public void testDemo(TestEnum te){
    
35. System.out.println("retCode is: "+te.getRetCode() +" retMsg is: "+te.getRetMsg());
    
36. }
    
37. 
    
38. @Test(dataProvider="dataProvider")
    
39. public void testDemo1(int a, int b){
    
40. int sum = a + b;
    
41. System.out.println("this is sum: "+sum);
    
42. }
    
43. 
    
44. }

复制代码

以上对于对象放于二维数组中不懂的，请去翻阅前面的文档，有对二维数组的详细讲解。

关于@Parameters

这里所说的@Parameters就TestNg的@Parameters，在前面我们介绍过用TestNg的xml配置文件来制定策
略执行测试类，那xml配置文件与测试方法间如何进行参数传递？@Parameters就是干这个事的，所以，
@Parameters只是参数的传递，并不是真正意义上的数据驱动，我个人对这个应用的不多，但还是有必
要给大家介绍一下用法。

1. 
   
2. public class TestDemo {
   
3. 
   
4. @Parameters({"a","b"})
   
5. @Test
   
6. public void testDemo(int a, int b){
   
7. int sum = a+b;
   
8. System.out.println("this is sum: "+sum); //输出3
   
9. }
   
10. 
    
11. }
    
12. <?xml version="1.0" encoding="UTF-8"?>
    
13. <suite name="Suite" verbose="1" parallel="false" thread-count="1">
    
14. <parameter name="a" value="1"/>
    
15. <parameter name="b" value="2"/>
    
16. <test name="Test1">
    
17. <classes>
    
18. <class name="com.test.demo.TestDemo" />
    
19. </classes>
    
20. </test>
    
21. </suite>

复制代码

说明：

@Parameters注解能用在测试方法或者@Before/@After/@Factory上面。
@Parameters中的字符串是在xml中的parameter结点的name。
在xml中的parameter结点的value就是该name对应的具体的参数值。
@Parameters注解的{}中的参数的顺序，对应其标注的方法上的参数的顺序。