testNg使用

testNg使用

测试是检查应用程序的功能的过程是否按要求工作，在开发人员层面进行单元测试，在采取适当措施来测试每一个实体（类或方法）以确保最终产品符合要求。单元测试是非常必要的，这是软件公司向他们的客户提供高质量的软件产品必要前提。
JUnit让开发人员了解测试的实用性，尤其是在单元测试这一模块上比任何其他测试框架都要简单明了。凭借一个相当简单，务实，严谨的架构，JUnit已经能够“感染”了一大批开发人员。
JUnit缺点：

• 最初的设计，使用于单元测试，现在只用于各种测试。
• 不能依赖测试配置控制欠佳(安装/拆卸)
• 侵入性(强制扩展类，并以某种方式命名方法)
• 静态编程模型(不必要的重新编译)
• 不适合管理复杂项目应用，JUnit复杂项目中测试非常棘手。

TestNG是什么?TestNG按照官方的定义：
TestNG是一个测试框架，其灵感来自JUnit和NUnit，但引入了一些新的功能，使其功能更强大，使用更方便。
TestNG是一个开源自动化测试框架;TestNG表示下一代(Next Generation的首字母)。 TestNG类似于JUnit(特别是JUnit 4)，但它不是JUnit框架的扩展。它的灵感来源于JUnit。它的目的是优于JUnit，尤其是在用于测试集成多类时。 TestNG的创始人是Cedric Beust(塞德里克·博伊斯特)。
TestNG消除了大部分的旧框架的限制，使开发人员能够编写更加灵活和强大的测试。 因为它在很大程度上借鉴了Java注解(JDK5.0引入的)来定义测试，它也可以显示如何使用这个新功能在真实的Java语言生产环境中。
TestNG的特点

• 注解
• TestNG使用Java和面向对象的功能
• 支持综合类测试(例如，默认情况下，不用创建一个新的测试每个测试方法的类的实例)
• 独立的编译时测试代码和运行时配置/数据信息
• 灵活的运行时配置
• 主要介绍“测试组”。当编译测试，只要要求TestNG运行所有的“前端”的测试，或“快”，“慢”，“数据库”等
• 支持依赖测试方法，并行测试，负载测试，局部故障
• 灵活的插件API支持
• 多线程测试

1. 引用pom依赖

  
            org.testng
            testng
            6.8.7
            test
  

2. 注解：在TestNG中，我们可以使用以下注释来执行测试类的配置，如设置/清理数据库，准备虚拟数据，部署/关闭服务器等。

@BeforeSuite	- 对于套件测试，在此套件中的所有测试运行之前运行。
@AfterSuite	- 对于套件测试，在此套件中的所有测试运行之后运行。
@BeforeTest	- 对于套件测试，在运行属于标签内的类的任何测试方法之前运行。
@AfterTest	- 对于套件测试，在运行属于标签内的类的所有测试方法都已运行之后运行。
@BeforeGroups：	在调用属于该组的第一个测试方法之前运行。
@AfterGroups：	在调用属于组的最后一个测试方法之后运行。
@BeforeClass-	在当前类的第一个测试方法之前运行。
@AfterClass	运行当前类中的所有测试方法之后都运行。
@BeforeMethod	- 在每个测试方法之前运行。
@AfterMethod	- 在每个测试方法之后运行。

注：套件测试是一起运行的多个测试类
3.异常，可通过expectedExceptions捕获

@Test(expectedExceptions = UserLoginException.class)
    public void throwIfLgoinFailedl() throws UserLoginException {
        orderBo.login(null,null);
    }

4.@Test(enabled = false)有助于禁用此测试用例

5. “超时”表示如果单元测试花费的时间超过指定的毫秒数，那么TestNG将会中止它并将其标记为失败。

@Test(timeOut = 4500) // time in mulliseconds
    public void testThisShouldPass() throws InterruptedException {
        Thread.sleep(4000);
    }

6. 分组测试是TestNG中的一个新的创新功能，它在JUnit框架中是不存在的。 它允许您将方法调度到适当的部分，并执行复杂的测试方法分组。 您不仅可以声明属于某个分组的方法，还可以指定包含其他组的组。 然后调用TestNG，并要求其包含一组特定的组(或正则表达式)，同时排除另一个分组。 组测试提供了如何分区测试的最大灵活性，如果您想要背靠背运行两组不同的测试，则不需要重新编译任何内容。
   使用标记在testng.xml文件中指定分组。 它可以在或标签下找到。 标签中指定分组适用于其下的所有标签。

---

runSelenium()和runSelenium1()属于分组：selenium-test。testConnectOracle()和testConnectMsSQL()属于分组：database 。如果分组selenium-test和database通过，则runFinal()将被执行。

public class TestGroup {

    @BeforeGroups("database")
    public void setupDB() {
        System.out.println("setupDB()");
    }

    @AfterGroups("database")
    public void cleanDB() {
        System.out.println("cleanDB()");
    }

    @Test(groups = "selenium-test")
    public void runSelenium() {
        System.out.println("runSelenium()");
    }

    @Test(groups = "selenium-test")
    public void runSelenium1() {
        System.out.println("runSelenium()1");
    }

    @Test(groups = "database")
    public void testConnectOracle() {
        System.out.println("testConnectOracle()");
    }

    @Test(groups = "database")
    public void testConnectMsSQL() {
        System.out.println("testConnectMsSQL");
    }

    @Test(dependsOnGroups = { "database", "selenium-test" })
    public void runFinal() {
        System.out.println("runFinal");
    }
}

• 测试套件是用于测试软件程序的行为或一组行为的测试用例的集合。 在TestNG中，我们无法在测试源代码中定义一个套件，但它可以由一个XML文件表示，因为套件是执行的功能。 它还允许灵活配置要运行的测试。 套件可以包含一个或多个测试，并由标记定义。
  是testng.xml的根标记。 它描述了一个测试套件，它又由几个部分组成。
  下表列出了接受的所有定义的合法属性。

属性	描述
name	套件的名称，这是一个强制属性。
verbose	运行的级别或详细程度。
parallel	TestNG是否运行不同的线程来运行这个套件。
thread-count	如果启用并行模式(忽略其他方式)，则要使用的线程数。
annotations	在测试中使用的注释类型。
time-out	在本测试中的所有测试方法上使用的默认超时。

• 指定包名称而不是类名称

• 指定包含或排除的方法

• include、exclude指定要包括或排除某个分组

• 有时，我们可能需要以特定顺序调用测试用例中的方法，或者可能希望在方法之间共享一些数据和状态。 TestNG支持这种依赖关系，因为它支持在测试方法之间显式依赖的声明。
  TestNG允许指定依赖关系：

• 在@Test注释中使用属性dependsOnMethods，或者

• 在@Test注释中使用属性dependsOnGroups。

TestNG中的另一个有趣的功能是参数化测试。 在大多数情况下，您会遇到业务逻辑需要大量测试的场景。 参数化测试允许开发人员使用不同的值一次又一次地运行相同的测试。
TestNG可以通过两种不同的方式将参数直接传递给测试方法：

• 使用testng.xml

• 使用数据提供者(@Parameters或@DataProvider将参数传递给@Test方法)

• @Parameters

• @DataProvider

public class TestParameterDataProvider {

    @Test(dataProvider = "provideNumbers")
    public void test(int number, int expected) {
        Assert.assertEquals(number + 10, expected);
    }

    @DataProvider(name = "provideNumbers")
    public Object[][] provideData() {

        return new Object[][] { { 10, 20 }, { 100, 110 }, { 200, 210 } };
    }

}

• @DataProvider支持传递一个对象参数

public class TestParameterDataProvider2 {

    @Test(dataProvider = "dbconfig")
    public void testConnection(Map map) {

        for (Map.Entry entry : map.entrySet()) {
            System.out.println("[Key] : " + entry.getKey() + " [Value] : " + entry.getValue());
        }

    }

    @DataProvider(name = "dbconfig")
    public Object[][] provideDbConfig() {
        Map map = readDbConfig();
        return new Object[][] { { map } };
    }

    public Map readDbConfig() {

        Properties prop = new Properties();
        InputStream input = null;
        Map map = new HashMap();

        try {
            input = getClass().getClassLoader().getResourceAsStream("db.properties");

            prop.load(input);

            map.put("jdbc.driver", prop.getProperty("jdbc.driver"));
            map.put("jdbc.url", prop.getProperty("jdbc.url"));
            map.put("jdbc.username", prop.getProperty("jdbc.username"));
            map.put("jdbc.password", prop.getProperty("jdbc.password"));

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (input != null) {
                try {
                    input.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return map;

    }

}

• @DataProvider + 方法,根据测试方法名称传递不同的参数

public class TestParameterDataProvider3 {

    @Test(dataProvider = "dataProvider")
    public void test1(int number, int expected) {
        Assert.assertEquals(number, expected);
    }

    @Test(dataProvider = "dataProvider")
    public void test2(String email, String expected) {
        Assert.assertEquals(email, expected);
    }

    @DataProvider(name = "dataProvider")
    public Object[][] provideData(Method method) {

        Object[][] result = null;

        if (method.getName().equals("test1")) {
            result = new Object[][] {
                { 1, 1 }, { 200, 200 }
            };
        } else if (method.getName().equals("test2")) {
            result = new Object[][] {
                { "[email protected]", "[email protected]" },
                { "[email protected]", "[email protected]" }
            };
        }

        return result;

    }

}

• 在TestNG中，我们可以使用org.testng.ITestContext来确定调用当前测试方法的运行时参数。 在最后一个例子中，根据包含的分组名称传递参数

public class TestParameterDataProvider4 {

    @Test(dataProvider = "dataProvider", groups = {"groupA"})
    public void test1(int number) {
        Assert.assertEquals(number, 1);
    }

    @Test(dataProvider = "dataProvider", groups = "groupB")
    public void test2(int number) {
        Assert.assertEquals(number, 2);
    }

    @DataProvider(name = "dataProvider")
    public Object[][] provideData(ITestContext context) {

        Object[][] result = null;

        //get test name
        //System.out.println(context.getName());

        for (String group : context.getIncludedGroups()) {

            System.out.println("group : " + group);

            if ("groupA".equals(group)) {
                result = new Object[][] { { 1 } };
                break;
            }

        }

        if (result == null) {
            result = new Object[][] { { 2 } };
        }
        return result;

    }

}

• xml

• invocationCount确定TestNG应该运行这个测试方法的次数

• threadPoolSize属性告诉TestNG创建一个线程池以通过多个线程运行测试方法。 使用线程池，会大大降低测试方法的运行时间。

• TestNG + Spring

    


#代码
@Test
@ContextConfiguration(locations = { "classpath:spring-test-config.xml" })
public class TestSpring extends AbstractTestNGSpringContextTests {

    @Autowired
    EmailGenerator emailGenerator;

    @Test()
    void testEmailGenerator() {

        String email = emailGenerator.generate();
        System.out.println(email);

        Assert.assertNotNull(email);
        Assert.assertEquals(email, "[email protected]");


    }

}

• JUnit 4和TestNG都是Java中非常受欢迎的单元测试框架。两种框架在功能上看起来非常相似。 哪一个更好？ 在Java项目中应该使用哪个单元测试框架？
  下面表中概括了JUnit 4和TestNG之间的功能比较。如下图所示 -
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p7lU2vxB-1597108812642)(evernotecid://1B6E6F67-D7E8-416E-8DE9-096BB4A77F37/appyinxiangcom/10870897/ENResource/p492)]

1. 注释支持
   注释/注解支持在JUnit 4和TestNG中是非常类似的。

特点	JUnit	4TestNG
测试注释	@Test	@Test
在套件中的所有测试运行之前运行	-	@BeforeSuite
在套件中的所有测试运行之后运行	-	@AfterSuite
测试之前运行	-	@BeforeTest
测试之后运行	-	@AfterTest
在调用属于任何这些组的第一个测试方法之前运行	-	@BeforeGroups
在调用属于任何这些组的第一个测试方法之后运行	-	@AfterGroups
在调用当前类的第一个测试方法之前运行	@BeforeClass	@BeforeClass
在调用当前类的第一个测试方法之后运行	@AfterClass	@AfterClass
在每个测试方法之前运行	@Before	@BeforeMethod
在每个测试方法之后运行	@After	@AfterMethod
忽略测试	@ignore	@Test(enbale=false)
预期的异常	@Test(expected = ArithmeticException.class)	@Test(expectedExceptions = ArithmeticException.class)
超时测试	@Test(timeout = 1000)	@Test(timeout = 1000)

• JUnit4和TestNG之间的主要注释差异是：
  在JUnit 4中，我们必须声明“@BeforeClass”和“@AfterClass”方法作为静态方法。 TestNG在方法声明中更灵活，它没有这个约束。
  3个额外的setUp / tearDown级别：suite和group(@Before / AfterSuite，@Before / After Test，@Before / After Group)。
• JUnit 4

@BeforeClass
public static void oneTimeSetUp() {
    // one-time initialization code
    System.out.println("@BeforeClass - oneTimeSetUp");
}

• JavaTestNG

@BeforeClass
public void oneTimeSetUp() {
        // one-time initialization code
        System.out.println("@BeforeClass - oneTimeSetUp");
}

Java在JUnit 4中，注释命名约定有点混乱，例如“Before”，“After”和“Expected”，我们并不真正了解“Before”和“After”之前的内容，以及要测试中的“预期” 方法。TestiNG更容易理解，它使用类似“BeforeMethod”，“AfterMethod”和“ExpectedException”就很明了。

2. 异常测试
   “异常测试”是指从单元测试中抛出的异常，此功能在JUnit 4和TestNG中都可实现。

• JUnit 4

@Test(expected = ArithmeticException.class)
public void divisionWithException() {
  int i = 1/0;
}

• TestNG

@Test(expectedExceptions = ArithmeticException.class)
public void divisionWithException() {
  int i = 1/0;
}

3. 忽略测试
   “忽略”表示是否应该忽略单元测试，该功能在JUnit 4和TestNG中均可实现。

• JUnit 4

@Ignore("Not Ready to Run")
@Test
public void divisionWithException() {
  System.out.println("Method is not ready yet");
}

• TestNG

@Test(enabled=false)
public void divisionWithException() {
  System.out.println("Method is not ready yet");
}

4. 时间测试
   “时间测试”表示如果单元测试所花费的时间超过指定的毫秒数，则测试将会终止，并将其标记为失败，此功能在JUnit 4和TestNG中均可实现。

• JUnit 4

@Test(timeout = 1000)
public void infinity() {
    while (true);
}

• TestNG

@Test(timeOut = 1000)
public void infinity() {
    while (true);
}

5. 套件测试
   “套件测试”是指捆绑几个单元测试并一起运行。 此功能在JUnit 4和TestNG中都可实现。 然而，两者都使用非常不同的方法来实现它。
   JUnit 4“@RunWith”和“@Suite”用于运行套件测试。下面的类代码表示在JunitTest5执行之后，单元测试“JunitTest1”和“JunitTest2”一起运行。 所有的声明都是在类内定义的。

@RunWith(Suite.class)
@Suite.SuiteClasses({
        JunitTest1.class,
        JunitTest2.class
})
public class JunitTest5 {
}

• TestNGXML文件用于运行套件测试。以下XML文件表示单元测试“TestNGTest1”和“TestNGTest2”将一起运行。

suite name="My test suite">
  
    
       
       
    
  

XMLTestNG可以做捆绑类测试，也可以捆绑方法测试。 凭借TestNG独特的“分组”概念，每种方法都可以与一个组合相结合，可以根据功能对测试进行分类(分组)。 例如，
下面是一个有四个方法的类，三个组(method1，method2和method3)

@Test(groups="method1")
public void testingMethod1() {
  System.out.println("Method - testingMethod1()");
}

@Test(groups="method2")
public void testingMethod2() {
    System.out.println("Method - testingMethod2()");
}

@Test(groups="method1")
public void testingMethod1_1() {
    System.out.println("Method - testingMethod1_1()");
}

@Test(groups="method4")
public void testingMethod4() {
    System.out.println("Method - testingMethod4()");
}

使用以下XML文件，可以仅使用组“method1”执行单元测试。

XML通过“分组”测试概念，集成测试的可能性是无限制的。 例如，我们只能从所有单元测试类中测试“DatabaseFuntion”分组。

6. 参数化测试
   “参数化测试”是指单位测试参数值的变化。 此功能在JUnit 4和TestNG中都实现。 然而，两者都使用非常不同的方法来实现它。
   JUnit 4“@RunWith”和“@Parameter”用于提供单元测试的参数值，@Parameters必须返回List []，参数将作为参数传入类构造函数。

@RunWith(value = Parameterized.class)
public class JunitTest6 {

     private int number;

     public JunitTest6(int number) {
        this.number = number;
     }

     @Parameters
     public static Collection<Object[]]]> data() {
       Object[][] data = new Object[][] { { 1 }, { 2 }, { 3 }, { 4 } };
       return Arrays.asList(data);
     }

     @Test
     public void pushTest() {
       System.out.println("Parameterized Number is : " + number);
     }
}

这里有很多限制，我们必须遵循“JUnit”的方式来声明参数，并且必须将参数传递给构造函数才能初始化类成员作为测试的参数值。参数类的返回类型为“List []”，数据已被限制为String或用于测试的原始类型值。
TestNGXML文件或“@DataProvider”用于提供不同参数进行测试。
用于参数化测试的XML文件 -
只有“@Parameters”在需要参数测试的方法中声明，参数化数据将在TestNG的XML配置文件中提供。 通过这样做，我们可以使用不同数据集的单个测试用例，甚至获得不同的结果。 另外，即使是最终用户，QA还是QE都可以在XML文件中提供自己的数据进行测试。

public class TestNGTest6_1_0 {

@Test
@Parameters(value="number")
public void parameterIntTest(int number) {
       System.out.println("Parameterized Number is : " + number);
    }
}

JavaXML文件的内容如下

XML@DataProvider用于参数化测试将数据值拉入XML文件可能非常方便，但测试偶尔会需要复杂的类型，这些类型不能被表示为一个字符串或一个原始类型值。 TestNG使用@DataProvider注解来处理这种情况，这有助于将复杂参数类型映射到测试方法。
@DataProvider for Vector，String或Integer作为参数，参考如下代码 -

@Test(dataProvider = "Data-Provider-Function")
    public void parameterIntTest(Class clzz, String[] number) {
       System.out.println("Parameterized Number is : " + number[0]);
       System.out.println("Parameterized Number is : " + number[1]);
    }

    //This function will provide the patameter data
    @DataProvider(name = "Data-Provider-Function")
    public Object[][] parameterIntTestProvider() {
        return new Object[][]{
                   {Vector.class, new String[] {"java.util.AbstractList",
"java.util.AbstractCollection"}},
                   {String.class, new String[] {"1", "2"}},
                   {Integer.class, new String[] {"1", "2"}}
                  };
    }

Java@DataProvider作为对象的参数“TestNGTest6_3_0”是一个简单的对象，只需使用get/set方法进行演示。

@Test(dataProvider = "Data-Provider-Function")
public void parameterIntTest(TestNGTest6_3_0 clzz) {
   System.out.println("Parameterized Number is : " + clzz.getMsg());
   System.out.println("Parameterized Number is : " + clzz.getNumber());
}

//This function will provide the patameter data
@DataProvider(name = "Data-Provider-Function")
public Object[][] parameterIntTestProvider() {

    TestNGTest6_3_0 obj = new TestNGTest6_3_0();
    obj.setMsg("Hello");
    obj.setNumber(123);

    return new Object[][]{
               {obj}
    };
}

JavaTestNG的参数化测试非常用户友好和灵活(在XML文件或类内)。 它可以支持许多复杂的数据类型作为参数值，可能性是无限的。 如上例所示，我们甚至可以传入我们自己的对象(TestNGTest6_3_0)进行参数化测试

7.依赖性测试
“参数化测试”表示方法是依赖性测试，它将在所需方法之前执行。 如果依赖方法失败，则所有后续测试将会被跳过，不会被标记为失败。
JUnit 4JUnit框架着重于测试隔离; 目前它不支持此功能。
TestNG它使用“dependOnMethods”来实现依赖测试如下

@Test
public void method1() {
   System.out.println("This is method 1");
}

@Test(dependsOnMethods={"method1"})
public void method2() {
    System.out.println("This is method 2");
}

Java“method2()”只有在“method1()”运行成功的情况下才会执行，否则“method2()”将跳过测试。
结论
在考虑所有功能比较之后，建议使用TestNG作为Java项目的核心单元测试框架，因为TestNG在参数化测试，依赖测试和套件测试(分组概念)方面更加突出。 TestNG用于高级测试和复杂集成测试。 它的灵活性对于大型测试套件尤其有用。 此外，TestNG还涵盖了整个核心的JUnit4功能。这样说来，好像也没有理由使用JUnit了