JAVA自动化测试中多数据源的切换

最新推荐文章于 2024-04-10 21:29:28 发布
最新推荐文章于 2024-04-10 21:29:28 发布
阅读量560 收藏 1
点赞数
分类专栏： Selenium2.0&WebDriver

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

在做自动化测试时，数据驱动是一个很重要的概念，当数据与脚本分离后，面对茫茫多的数据，管理数据又成了一个大问题，而数据源又可能面对多个，就跟在开发过程中，有时候要连接MYSQL，有时候又要连接SQL SERVER一样，如何做到快速切换？下面的示例中，我们将从一个数据源开始，一步步的演示下去：

一. 用外部文件做数据驱动的基本写法

1.1　我们在做数据驱动时，把数据存储在JAVA的属性文件中：data.properties

1
2
username=test
password=123456

1.2　解析properties文件

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
public class PropertiesHandler {
 
    private static Properties loadPropertiesFile(String filePath){
        Properties p = new Properties();
        InputStream in = null;
        try {
            in = new FileInputStream(new File(filePath));
            p.load(in);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(in != null){
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return p;
    }
     
    /**
     * 将property转换成Map
     * @param key
     * @return
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static Map<String, String> getPropertyData(String filePath){
        try{
            return new HashMap<String, String>((Map)PropertiesHandler.loadPropertiesFile(filePath));
        }catch(Exception e){
            e.printStackTrace();
        }
        return new HashMap<String, String>();
    }
     
    public static void main(String[] args) {
        System.out.println(PropertiesHandler.getPropertyData("file/data.properties"));
    }
}

1.3　写一个TestBase类，里面用来存放TestNg的DataProvider

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class TestBase {
     
    @DataProvider
    public Object[][] dataProvider(){
        return this.getTestData();
    }
     
    private Object[][] getTestData(){
        PropertiesData testData = new PropertiesData();
        List<Map<String, String>> listData = testData.getTestMethodData();
        Object[][] object = new Object[listData.size()][];
        for (int i = 0; i < listData.size(); i++) {
            object[i] = new Object[]{listData.get(i)};
        }
        return object;
    }
     
}

可以看出，我只要有一个类，能够提供出一个数据类型为：List<Map<String, String>>的数据对象，就能够转换成Object[][]的二维数组，就能够提供给测试方法运行了。

1.4　在1.3中出现了一个PropertiesData类，现在来实现这个类

1
2
3
4
5
6
7
8
9
public class PropertiesData {
     
    public List<Map<String, String>> getTestMethodData(){
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        list.add(PropertiesHandler.getPropertyData("file/data.properties"));
        return list;
    }
     
}

1.5　以上中有数据解析类，有数据加载类，有数据提供的基础类，于是我们再结合测试方法，把这三个基础类给融合在一起，就形成了一个外部文件来做数据源的完整示例了：

1
2
3
4
5
6
7
8
9
public class TestDemo extends TestBase{
     
    @Test(dataProvider="dataProvider")
    public void testDemo(Map<String, String> param){
        System.out.println(param.get("username"));
        System.out.println(param.get("password"));
    }
     
}

1.6　以上的运行结果输出为：

二.　属性文件换成txt文件的实现

2.1　如果有多个数据源，我想用txt来存放数据，txt里面存放一个json串：data.txt

1
2
3
4
{
    "username":"test",
    "password":"123456"
}

2.2　读出这个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
public class FileUtils {
 
    public static String readFile(String fileName) {
        InputStream is = null;
        StringBuffer sb = new StringBuffer();
        try {
            is = new FileInputStream(fileName);
            byte[] byteBuffer = new byte[is.available()];
            int read = 0;
            while((read = is.read(byteBuffer)) != -1){
                sb.append(new String(byteBuffer, 0, read));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(is!=null){
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }
     
    public static void main(String[] args) {
        System.out.println(FileUtils.readFile("file/data.txt"));
    }
     
}

2.3　将读取出来的JSON串进行解析(这里需要用到一个JAR包，gson.jar)

1
2
3
4
5
6
7
8
9
10
11
12
public class TxtData {
     
    public List<Map<String, String>> getTestMethodData(){
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        String data = FileUtils.readFile("file/data.txt");
        Gson gson = new Gson();
        Map<String, String> dataMap = gson.fromJson(data, new TypeToken<Map<String, String>>(){}.getType());
        list.add(dataMap);
        return list;
    }
     
}

2.4　将TxtData类给用上，即将TestBase类里的用到PropertiesData类的地方换成TxtData类即可

1
2
3
4
5
6
7
8
9
private Object[][] getTestData(){
    TxtData testData = new TxtData();
    List<Map<String, String>> listData = testData.getTestMethodData();
    Object[][] object = new Object[listData.size()][];
    for (int i = 0; i < listData.size(); i++) {
        object[i] = new Object[]{listData.get(i)};
    }
    return object;
}

2.5　运行TestDemo测试类后，发现结果与之前用PropertiesData类出现的结果一模一样。

三.　用接口来实现

3.1　上面的两种数据源，在把数据源里的内容给加载出来且加载出来的数据类型为：List<Map<String, String>>后，只需要把TestBase类里的数据源加载类给替换一个即可，那如此一来，我们可以利用JAVA里面的interface来重构我们的代码，首先当然得要有一个interface

1
2
3
public interface DataInterface {
    public List<Map<String, String>> getTestMethodData();
}

3.2　我们的PropertiesData类与TxtData类当然要实现这个接口了

1
2
3
4
5
6
7
8
9
public class PropertiesData implements DataInterface{
     
    public List<Map<String, String>> getTestMethodData(){
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        list.add(PropertiesHandler.getPropertyData("file/data.properties"));
        return list;
    }
     
}
1
2
3
4
5
6
7
8
9
10
11
12
public class TxtData implements DataInterface{
     
    public List<Map<String, String>> getTestMethodData(){
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        String data = FileUtils.readFile("file/data.txt");
        Gson gson = new Gson();
        Map<String, String> dataMap = gson.fromJson(data, new TypeToken<Map<String, String>>(){}.getType());
        list.add(dataMap);
        return list;
    }
     
}

3.3　然后在TestBase里就要有所改变了，即产生数据加载的类对象要发生改变，我们在TestBase里新加一个方法(这是产生类对象的一种新的方式)

1
2
3
4
5
6
7
8
9
private DataInterface getDataInstance(String key){
    DataInterface data = null;
    try {
        data = (DataInterface) Class.forName(key).newInstance();
    } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
        e.printStackTrace();
    }
    return data;
}

3.4　TestBase类里的getTestData()方法就要重新的改变一下了

1
2
3
4
5
6
7
8
9
private Object[][] getTestData(){
    DataInterface testData = this.getDataInstance("com.test.testdata.PropertiesData");
    List<Map<String, String>> listData = testData.getTestMethodData();
    Object[][] object = new Object[listData.size()][];
    for (int i = 0; i < listData.size(); i++) {
        object[i] = new Object[]{listData.get(i)};
    }
    return object;
}
1
2
3
4
5
6
7
8
9
private Object[][] getTestData(){
    DataInterface testData = this.getDataInstance("com.test.testdata.TxtData");
    List<Map<String, String>> listData = testData.getTestMethodData();
    Object[][] object = new Object[listData.size()][];
    for (int i = 0; i < listData.size(); i++) {
        object[i] = new Object[]{listData.get(i)};
    }
    return object;
}

3.5　再次运行TestDemo，即可发现结果仍然是一样的。所以，这时候只需要改变数据加载类的路径即可了。

四.　将数据加载类的路径可配置化

4.1　这时候，我们就可以想着把数据加载类的路径写在配置文件中了config.properties

1
DataSource=com.test.testdata.TxtData

4.2　加载config文件

1
2
3
4
5
6
7
8
9
10
public class Config {
     
    public static String DATA_SOURCE;
     
    static{
        Map<String, String> map = PropertiesHandler.getPropertyData("config/config.properties");
        DATA_SOURCE = map.get("DataSource");
    }
     
}

4.3　将TestBase里的getTestData()方法再改进一下：

1
2
3
4
5
6
7
8
9
private Object[][] getTestData(){
    DataInterface testData = this.getDataInstance(Config.DATA_SOURCE);
    List<Map<String, String>> listData = testData.getTestMethodData();
    Object[][] object = new Object[listData.size()][];
    for (int i = 0; i < listData.size(); i++) {
        object[i] = new Object[]{listData.get(i)};
    }
    return object;
}

4.4　再次运行TestDemo类，结果仍然是一样的。到此为止，我们已实现了去更改配置文件里面的内容，来选择加载数据源。

五.　多数据源的切换

5.1　如果一个测试类里有两个测试方法，那么在配置文件里配置好数据源后，就表示这两个测试方法都将会加载同样的数据源，但如果我们希望一个测试方法用属性文件的数据源，另一个方法用TXT的数据源，这个如何办？也就是需要实现在全局配置化后，局部可再次选择数据源。我将会利用到JAVA里的注解，来实现。所以我们先定义一个DataSource的注解

1
2
3
4
5
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSource {
    String value();
}

5.2　解析该注解

1
2
3
4
5
6
7
8
9
10
11
public class DataSources {
     
    public static String getDataSource(Method method){
        DataSource ds = method.getAnnotation(DataSource.class);
        if(ds != null){
            return ds.value();
        }
        return null;
    }
     
}

5.3　该注解的使用

1
2
3
4
5
6
@DataSource("com.test.testdata.PropertiesData")
@Test(dataProvider="dataProvider")
public void testDemo(Map<String, String> param){
    System.out.println(param.get("username"));
    System.out.println(param.get("password"));
}

5.4　TestBase类里的getTestData()方法再次的更改，要利用上这个注解解析出来的值

1
2
3
4
5
6
7
8
9
10
11
12
13
private Object[][] getTestData(Method method){
    String sourceKey = DataSources.getDataSource(method);
    if(sourceKey==null){
        sourceKey = Config.DATA_SOURCE;
    }
    DataInterface testData = this.getDataInstance(sourceKey);
    List<Map<String, String>> listData = testData.getTestMethodData();
    Object[][] object = new Object[listData.size()][];
    for (int i = 0; i < listData.size(); i++) {
        object[i] = new Object[]{listData.get(i)};
    }
    return object;
}

这段代码可以看到，如果测试方法标注DataSource,则会以标注的注解值为准，否则则会以全局配置的值为准。

5.5　在TestDemo里多加一个测试方法，以示区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class TestDemo extends TestBase{
     
    @DataSource("com.test.testdata.PropertiesData")
    @Test(dataProvider="dataProvider")
    public void testDemo(Map<String, String> param){
        System.out.println(param.get("username"));
        System.out.println(param.get("password"));
    }
     
    @Test(dataProvider="dataProvider")
    public void testDemo1(Map<String, String> param){
        System.out.println(param.get("username"));
        System.out.println(param.get("password"));
    }
     
}

上面的测试类中，两个测试方法，一个用了全局的配置数据源值，一个用了注解数据源值。大家可以运行的看看结果。

六.　工程结构图：

至于源码，大家自行的拷贝粘贴吧，也当作是一种知识的巩固。

点亮测试人生！QQ：408129370

SpringBoot中多数据源灵活切换解决方案
lucky_love816的博客
04-26 1366
本篇内容介绍了“SpringBoot中如何使用Dynamic Datasource配置多数据源”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。支持无数据源启动，支持配置懒启动数据源(3.3.2+)。支持数据库敏感配置信息 加密 ENC()。支持每个数据库独立初始化表结构schema和数据库database。
spring boot + mybatis(通用mapper) druid多数据源切换配置
08-14
在Spring Boot应用中，整合MyBatis和Druid并实现多数据源切换是一项常见的需求，尤其是在处理多个数据库环境（如开发、测试、生产）时。本文将深入探讨如何配置和使用这一技术栈。 首先，我们需要了解`spring boot`...
java多数据源自动切换
11-03
基于Spring AOP的多数据源自动切换，根据Service或者Dao上的注解自动切换数据源
java接口自动化，基于SpingBoot架构
weixin_42354199的博客
01-25 4443
1：环境准备：jdk1.8 依赖管理:maven 代码管理：git 二、框架结构 data ————————————————测试数据目录 | rus ————————————————项目目录（不同项目不同名称） | | searchbydetail.json —————————测试数据文件 | | search.csv ————————————数据驱动文件 report —————————————————测试报告目录 src | main | | java | | | com.tal.seg.auto
0代码实现接口自动化测试-RF框架实践
03-31 2067
robotframework是一款关键字自动化测试框架，可能做各种类型的自动化测试。本文介绍通过 robotframework 来实现接口测试。 目录 01、安装接口请求的第三方库 02、接口关键字基础 1. 创建测试集合并导入接口库 2. get接口 3. post 表单接口 4. post json接口 5. put 接口 6. delete 接口 7. 文件上传 8. 文件下载接口 9. 需要签名验证的接口 10. cookie关联 11. token关联 03、rf数据
Springboot整合Druid与Mybatis的多数据源切换
10-17
本教程将详细介绍如何在Spring Boot项目中整合Druid数据源池与Mybatis，实现多数据源切换的功能，并提供一个亲测可用的解决方案。 首先，让我们了解Spring Boot、Druid和Mybatis这三大组件的基础知识： **Spring ...
基于SpringBoot开发的智能接口自动化测试框架_支持Excel数据驱动测试_多环境配置管理_动态数据源切换_RPC接口本地化调用_日志收集与分析_测试报告生成_支持Junit.zip
最新发布
07-20
本文将详细解读一款基于SpringBoot开发的智能接口自动化测试框架的核心特点和功能，包括它如何支持Excel数据驱动测试、多环境配置管理、动态数据源切换、RPC接口本地化调用、日志收集与分析以及测试报告的生成。...
自动化测试~数据源
weixin_34355559的博客
08-15 330
介绍 本篇介绍框架PhoenixAutotest中的数据源模块以及在项目中的使用示例。阅读本文的前提，是您已经完成了基础入门篇，如果您错过了请点击入门介绍。 所谓数据源，即把在测试过程中所要录入的数据集中地放在一个地方（源），而不是散落在脚本（代码）中。这样的好处显而易见，只能清晰，维护简便。为了能尽可能地满足各种实际情况，框架不仅提供了几种（XM...
spring多数据源动态切换方案
07-03
用于详细描述配置spring下多数据源动态切换方案的实施配置说明。可以自动切换数据源的配置。
自动化测试系列（5）—— 定义数据源
X_Xian_的博客
08-02 425
自动化测试系列（第五天）—— 定义数据源 上一篇通过chrome进行了登录验证操作，也放上了测试代码，分析一下testng的定义数据源操作 第一种方式：需要明确测试数据组数 @DataProvider( name= &amp;quot;list&amp;quot;) public Object[][] createData(){ return new Object[][]{ ...
接口自动化数据源问题
一个有趣灵魂的测试员，指点江山，挥斥方遒
06-02 740
1、常见数据源类型 数据源说的是数据的源头，数据来自于哪里。在实现接口自动化测试的过程中，测试数据来源的问题是我们需要去解决的一个重要问题，并且，选择什么样的数据源可能会直接影响到我们测试框架的设计难度，执行效率和扩展性。 那么在自动化测试的实现过程中，可以作为数据源的技术有哪些呢？ Excel文件：管理方便，操作性强，增加一行一列都非常简单 CSV文件：管理方便，操作性强，增加一行一列都非常简单 数据库：相对来说没那么容易维护，表设计更复杂，修改表结构都需要通过SQL脚本执行，并且需要自己去实现一套数据
UI自动化测试框架：PO 模式+数据驱动（超详细）
HUA1211的博客
04-10 5690
PO（PageObject）设计模式将某个页面的所有元素对象定位和对元素对象的操作封装成一个 Page 类，并以页面为单位来写测试用例，实现页面对象和测试用例的分离。PO 模式的设计思想与面向对象相似，能让测试代码变得可读性更好，可维护性高，复用性高。PO 模式可以把一个页面分为三个层级：对象库层、操作层、业务层。对象库层：封装定位元素的方法。操作层：封装对元素的操作。业务层：将一个或多个操作组合起来完成一个业务功能。
java 多个数据源_JAVA自动化测试中多数据源的切换
weixin_31755771的博客
02-13 436
在做自动化测试时，数据驱动是一个很重要的概念，当数据与脚本分离后，面对茫茫多的数据，管理数据又成了一个大问题，而数据源又可能面对多个，就跟在开发过程中，有时候要连接MYSQL，有时候又要连接SQL SERVER一样，如何做到快速切换？下面的示例中，我们将从一个数据源开始，一步步的演示下去：一. 用外部文件做数据驱动的基本写法1.1　我们在做数据驱动时，把数据存储在JAVA的属性文件中：data.p...
java结合testng，利用excel做数据源的数据驱动实例
weixin_34248118的博客
11-17 395
数据驱动部分，是自动化测试常用部分，也是参数化设计的重要环节，前面分享了，mysql、yaml做数据源，那么再来分享下excel做数据驱动 思路： 先用POI读取excel。解析读取数据，返回list,返回Object[][]即可 工具类文件： 读取excel，返回map对象list集合 ReadExcelUtil.java import org.apache.poi.hssf.u...
学习笔记_spring多数据源配置
今生今世的专栏
05-06 1027
项目中我们经常会遇到多数据源的问题，尤其是数据同步或定时任务等项目更是如此。多数据源让人最头痛的，不是配置多个数据源，而是如何能灵活动态的切换数据源。例如在一个spring和hibernate的框架的项目中，我们在spring配置中往往是配置一个dataSource来连接数据库，然后绑定给sessionFactory，在dao层代码中再指定sessionFactory来进行数据库操作。
mybatis自动切换多个数据源
义臻的博客
08-11 8129
假设现在有两个数据库myone和mytwo,读者可以理解为一个写库,一个读库,数据库中都各自有一个表,表的格式都一样，如下：------------------------------------------------------------ id int(11) PRI auto_increment username varchar(20) password varchar(2...
Java自动化测试：多数据源切换实战教程
"这篇教程详细介绍了在Java自动化测试中如何实现多数据源的切换，通过实例讲解了数据驱动和外部文件作为数据源的使用方法...以上就是Java自动化测试中多数据源切换的实例讲解，希望对您在进行相关测试工作时有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值