TestNG工厂注释详解（六）

    首先我们来理解什么是工厂注释，以及它能够给结合TestNG测试框架能够给测试效率带来什么样的效率提升。我们在之前的文章

体系中分享了TestNG框架中的组以及依赖，本章节接着讲工厂注释这部分是强大功能。所谓工厂注释可以理解为我们在实际的测试

过程中会经常遇到一组具有不同测试数据的测试用例来执行，因此我们可以在TestNG的配置文件中指定单独定义一个测试套件，这

样的方式处理起来比较麻烦，而且数据定义在testng.xml配置文件中总感觉显得比较奇怪，也不符合数据驱动的思想和模式，因此我

们可以使用@Factory解决这个问题，具体先看如下的案例代码，测试类SimpleTest.class的源码：

package test.factory;

import org.testng.annotations.Test;

public class SimpleTest
{
    @Test
    public void test_one()
    {
        System.out.println("this is a  test one");
    }
}

 

工厂注释的类源码，具体如下：

package test.factory;


import org.testng.annotations.Factory;
import org.testng.annotations.Test;

public class SimpleTestFactory
{
    @Factory
    public Object[] factoryMethod()
    {
        return new Object[]{
            new SimpleTest(),
            new SimpleTest()
        };
    }
}

 

执行工厂注释的测试方法后，就会把测试类里面的测试用例test_one执行N次，具体执行结果信息如下所示：

 

     使用工厂注释的方式最大的优势是可以把参数化通过参数传递在初始化类时的测试类，然后应用于这个类中的所有测试方法。我们还是通

过具体的案例代码来演示这部分，测试类的源码：

package test.factory;

import org.testng.annotations.Test;

public class ParameterTets
{
    private int param;
    public ParameterTets(int param)
    {
        this.param=param;
    }

    @Test
    public void test_one()
    {
        int oneValue=param+1;
        System.out.println(oneValue);
    }

    @Test
    public void test_two()
    {
        int twoValue=param+2;
        System.out.println(twoValue);
    }
}

 

工厂注释的源码具体如下：

package test.factory;

import org.testng.annotations.Factory;

public class ParameterFactory
{
    @Factory
    public Object[] parameterFactory()
    {
        return new Object[]{
                new ParameterTets(0),
                new ParameterTets(1)
        };
    }
}

 

执行后，可以看到，工厂注释里面的测试数据被测试类里面的测试方法全部被引用了。通过可以的方式可以达到一个测试数据被多个测试方法来引用，

从而达到测试场景最大化的覆盖率。 

      最后我们来看工厂注释与数据驱动模式的结合，这样的目的也是为了更好的整合数据驱动的方式来进行，我们还是根据具体的案例来看如下的测

试代码，数据驱动的类测试源码如下：

package test.factory;

import org.testng.annotations.DataProvider;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;

public class DataProviderTest
{
    private int param;

    @Factory(dataProvider = "dataMethod")
    public DataProviderTest(int param)
    {
        this.param=param;
    }

    @DataProvider
    public static Object[][] dataMethod()
    {
        return new Object[][]
                {
                        {0},
                        {1}
                };
    }

    @Test
    public void test_one()
    {
        int oneValue=param+1;
        System.out.println(oneValue);
    }

    @Test
    public void test_two()
    {
        int twoValue=param+2;
        System.out.println(twoValue);
    }
}

语句如上的代码，我们可以看到，我们把工厂注释和数据驱动能够完整的结合起来，然后进行来应用于我们实际

的的测试用例的应用。那么就会涉及到，在实际的测试中，我们到底使用工厂注释比较好还是使用数据驱动的模

式了，可以这样来进行理解，使用 DataProvider 的测试方法将基于 DataProvider 提供的数据执行多次。测试方

法将使用测试方法所属的测试类的同一实例执行，而工厂将使用相应类的单独实例执行测试类内存在的所有测试方

法。我们还是结合具体的案例来说明，我们首先来看DataProvider的方式，案例源码如下：

package test.factory;

import org.testng.annotations.BeforeClass;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class DataProviderClass
{
    @BeforeClass
    public void beforeClass()
    {
        System.out.println("before class executed");
    }

    @Test(dataProvider = "dataMethod")
    public void  test_one(String param)
    {
        System.out.println("the param value is:"+param);
    }

    @DataProvider
    public Object[][] dataMethod()
    {
        return new Object[][]
                {
                        {"one"},
                        {"two"}
                };
    }
}

执行如上的案例代码后，可以看到我们使用了DataProvider，把值赋值给param，其实内部执行的过程还是符合参数

化的本质化的思想的，对Object的对象的值进行循环，赋值给param，然后执行不同的测试数据。我们接着来看工厂

的的注释测试类源码：

package test.factory;

import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

public class FactoryClass
{
    private String param="";

    public FactoryClass(String param)
    {
        this.param=param;
    }

    @BeforeClass
    public void beforeClass()
    {
        System.out.println("before class executed");
    }

    @Test
    public void test_one()
    {
        System.out.println("the param value is :"+this.param);
    }
}

接着再来看工厂注释的类，源码如下：

package test.factory;

import org.testng.annotations.Factory;

public class FactoryClassTest
{
    @Factory
    public Object[] factoryMethod()
    {
        return new Object[]{
                new FactoryClass("one"),
                new FactoryClass("two")

        };
    }
}

执行后，显示执行的结果信息。其实本质上还是一个列表对象循环赋值的过程，不过我个人更加推荐使用DataProvider

的的方式来使用基于数据驱动的参数化的形式。

     下面我们具体来看工厂注释和依赖这部分的应用，依赖这部分主要应用于业务的测试场景，因为在有的业务场景中每

个测试用例之间都是存在依赖关系的，我们结合具体的案例来看依赖这部分和工厂注释的结合应用，案例代码如下：

package test.factory;

import org.testng.annotations.Test;

public class DependClassTest
{
    private int param;

    public DependClassTest(int param )
    {
        this.param=param;
    }

    @Test(dependsOnMethods = {"test_two"})
    public void test_one()
    {
        System.out.println(this.param);
    }

    @Test
    public void test_two()
    {
        System.out.println(this.param);
    }

}

工厂注释的案例源码，具体如下：

package test.factory;

import org.testng.annotations.Factory;

public class DependFactory
{
    @Factory
    public Object[] factoryMethod()
    {
        return new Object[]{
                new DependClassTest(1),
                new DependClassTest(2)
        };
    }
}

我们依据代码代码，可以看到，可以很完整的把依赖与工厂注释能够整合起来。

      感谢您的阅读！后续持续更新！

 

 

 

a