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

最新推荐文章于 2024-04-10 21:29:28 发布
转载 最新推荐文章于 2024-04-10 21:29:28 发布 · 894 阅读 · 0

转载地址：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 1410
本篇内容介绍了“SpringBoot中如何使用Dynamic Datasource配置多数据源”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。支持无数据源启动，支持配置懒启动数据源(3.3.2+)。支持数据库敏感配置信息 加密 ENC()。支持每个数据库独立初始化表结构schema和数据库database。
接口测试用例数据驱动&高级断言_rest_assured
sinat_34766121的博客
04-12 2384
https://testerhome.com/topics/15161 https://github.com/reese0329/rest_assured idea 引入包 Alt+Enter 参考 https://testerhome.com/topics/11731 接口测试大纲 接口测试的价值 移动互联网公司的一般架构简化模拟 真实的后端服务 接口...
java多数据源自动切换
11-03
基于Spring AOP的多数据源自动切换，根据Service或者Dao上的注解自动切换数据源
Java自动化测试中多数据源的切换(实例讲解)
08-29
下面小编就为大家带来一篇Java自动化测试中多数据源的切换(实例讲解)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java接口自动化，基于SpingBoot架构
weixin_42354199的博客
01-25 4475
1：环境准备：jdk1.8 依赖管理:maven 代码管理：git 二、框架结构 data ————————————————测试数据目录 | rus ————————————————项目目录（不同项目不同名称） | | searchbydetail.json —————————测试数据文件 | | search.csv ————————————数据驱动文件 report —————————————————测试报告目录 src | main | | java | | | com.tal.seg.auto
接口被开发改了，测试怎么高效修改完对应接口用例
yuexiashitou的博客
04-12 1430
不知道大家有没有同感，做接口测试麻烦的不是测试本身，而是接口它会变,更麻烦的不是接口变了，而是它变了而你不知道。等到你测完，开发才悠悠跟你说——“那个接口我改了点东西，你再看一眼哈”。 我那是看一眼的工作量吗？ 我得review一遍看影响到哪些接口，再根据影响到的接口，查看并修改对应的接口用例，调用链下游的用例，该改的改，改完再跑一次接口测试。 ——这意味着已经做完的工作又要来推翻重来一遍，我本来已经干完活儿悠哉摸鱼了，现在得加班了，我那40米大刀已经举起来你看到了没？ 吐槽归吐槽，但人真的不是精密的
Springboot整合Druid与Mybatis的多数据源切换
10-17
本教程将详细介绍如何在Spring Boot项目中整合Druid数据源池与Mybatis，实现多数据源切换的功能，并提供一个亲测可用的解决方案。 首先，让我们了解Spring Boot、Druid和Mybatis这三大组件的基础知识： **Spring ...
spring boot + mybatis(通用mapper) druid多数据源切换配置
08-14
在Spring Boot应用中，整合MyBatis和Druid并实现多数据源切换是一项常见的需求，尤其是在处理多个数据库环境（如开发、测试、生产）时。本文将深入探讨如何配置和使用这一技术栈。 首先，我们需要了解`spring boot`...
基于SpringBoot开发的智能接口自动化测试框架_支持Excel数据驱动测试_多环境配置管理_动态数据源切换_RPC接口本地化调用_日志收集与分析_测试报告生成_支持Junit.zip
最新发布
07-20
本文将详细解读一款基于SpringBoot开发的智能接口自动化测试框架的核心特点和功能，包括它如何支持Excel数据驱动测试、多环境配置管理、动态数据源切换、RPC接口本地化调用、日志收集与分析以及测试报告的生成。...
java基础 - 实现一个简单的Http接口功能自动化测试框架（HttpClient + TestNG）
软件测试入门笔记
05-29 2961
http接口自动化测试
0代码实现接口自动化测试-RF框架实践
03-31 2090
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数据
接口自动化数据源问题
一个有趣灵魂的测试员，指点江山，挥斥方遒
06-02 771
1、常见数据源类型 数据源说的是数据的源头，数据来自于哪里。在实现接口自动化测试的过程中，测试数据来源的问题是我们需要去解决的一个重要问题，并且，选择什么样的数据源可能会直接影响到我们测试框架的设计难度，执行效率和扩展性。 那么在自动化测试的实现过程中，可以作为数据源的技术有哪些呢？ Excel文件：管理方便，操作性强，增加一行一列都非常简单 CSV文件：管理方便，操作性强，增加一行一列都非常简单 数据库：相对来说没那么容易维护，表设计更复杂，修改表结构都需要通过SQL脚本执行，并且需要自己去实现一套数据
搭建关键字驱动自动化测试框架
m0_68405758的博客
07-25 610
上篇文章我们已经了解到了数据驱动自动化测试框架是如何构建和驱动测试的！那么这篇文章我们将了解关键字驱动测试又是如何驱动自动化测试完成整个测试过程的。关键字驱动框架是一种功能自动化测试框架，它也被称为表格驱动测试或者基于动作字的测试。关键字驱动的框架的基本工作是将测试用例分成四个不同的部分。首先是测试步骤（Test Step），二是测试步骤中的对象（Test Object），三是测试对象执行的动作(Action)，四是测试对象需要的数据（Test Data）。
自动化测试~数据源
Jenkins中文社区
06-20 211
介绍 本篇介绍框架PhoenixWebUIFramework中的数据源模块以及在项目中的使用示例。阅读本文的前提，是您已经完成了基础入门篇，如果您错过了请点击入门介绍。 所谓数据源，即把在测试过程中所要录入的数据集中地放在一个地方（源），而不是散落在脚本（代码）中。这样的好处显而易见，只能清晰，维护简便。为了能尽可能地满足各种实际情况，框架不仅提供了几种（XML、Excel
自动化测试系列（5）—— 定义数据源
X_Xian_的博客
08-02 446
自动化测试系列（第五天）—— 定义数据源 上一篇通过chrome进行了登录验证操作，也放上了测试代码，分析一下testng的定义数据源操作 第一种方式：需要明确测试数据组数 @DataProvider( name= &amp;quot;list&amp;quot;) public Object[][] createData(){ return new Object[][]{ ...
Java接口自动化测试框架系列（五）测试框架整体执行流程
YOGOUO949596的博客
09-05 120
通过前四步的框架完善，此时已经可以开始写TestCase。 但是想框架整体运行流畅还需要对maven与testng的配置文件进行编写。 一、Maven配置文件 在pom.xml文件种配置框架所需要的jar包坐标，并通过build配置编码、版本、执行的文件地址、存在case失败时的处理方式等信息 <project xmlns="http://maven.apache.org/POM/4.0...
UI自动化测试框架：PO 模式+数据驱动（超详细）
HUA1211的博客
04-10 7540
PO（PageObject）设计模式将某个页面的所有元素对象定位和对元素对象的操作封装成一个 Page 类，并以页面为单位来写测试用例，实现页面对象和测试用例的分离。PO 模式的设计思想与面向对象相似，能让测试代码变得可读性更好，可维护性高，复用性高。PO 模式可以把一个页面分为三个层级：对象库层、操作层、业务层。对象库层：封装定位元素的方法。操作层：封装对元素的操作。业务层：将一个或多个操作组合起来完成一个业务功能。
java接口自动化框架_JAVA接口自动化测试集成框架(testng+mybatis+jsonschme+allure)
weixin_30340109的博客
02-16 784
要点:框架: testng断言: jsonschme(json-schema-validator)、AssertJ报告: allure常用库: jackson、mybatis、mybatis-generator-maven-plugin已解决痛点:1、基于TCP的自定义rpc接口调用封装2、通过mybatis封装出mapper,使用orm方便数据操作3、使用Assert进行流式断言4、通过json...
Java自动化测试：多数据源切换实战教程
"这篇教程详细介绍了在Java自动化测试中如何实现多数据源的切换，通过实例讲解了数据驱动和外部文件作为数据源的使用方法...以上就是Java自动化测试中多数据源切换的实例讲解，希望对您在进行相关测试工作时有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值