1

我正在试验testng。我的目标是在几个类中有测试方法，并在一个单独的类中准备和总结一堆测试的“支持”方法。

另一个要求是，在测试套件中，必须为多个测试部分调用支持方法。例如，第一部分包含 testA 和 testB，第二部分包含 testC 和 testD。这将导致以下步骤：

支持1，测试A，测试B，支持2，支持1，测试C，测试D，支持2

我（部分）工作的第一种方法是用 注释所有方法@Test，使用组并定义组之间的依赖关系，例如测试方法依赖于组“setUp”，它是上面示例中的一个支持方法“support1”的组.

这种方法的问题是支持方法算作测试，因此生成的报告显示错误数量的“真实”测试。

下一个想法是使用@BeforeGroupsand @AfterGroups，将支持的方法放在一个组中，并使用组依赖项。支持的方法不应再被视为测试。但我一开始就被困住了。例如我试过

@BeforeGroups (groups = {"setUp"})

对于类中的设置方法Support，以及

@Test(groups = { "TestA" }, dependsOnGroups = { "setUp" })

在“真正的”测试课上。这会导致以下（简化的）错误：

[testng] DependencyMap::Method "TestClass.testSomething()[...]" depends on nonexistent group "setUp"

为什么组“setUp”不存在？我忽略了什么吗？

还是有另一种可行的方法？

谢谢你的帮助！

编辑： 测试是从 Ant 开始的，我使用这样的 testng.xml：

<test name="TestA">
    <groups>
        <run>
            <include name="setUp" />
            <include name="TestA"/>
            <include name="tearDown"/>
        </run>
    </groups>
    <classes>
        <class name="seleniumtest.test.technical.Support"/>
        <class name="seleniumtest.test.business.TestClassA"/>
    </classes>
</test>
<test name="TestB">
    <groups>
        <run>
            <include name="setUp" />
            <include name="TestB"/>
            <include name="tearDown"/>
        </run>
    </groups>
    <classes>
        <class name="seleniumtest.test.technical.Support"/>
        <class name="seleniumtest.test.business.TestClassB"/>
    </classes>
</test>
4

3 回答 3

4

我发现故障了！！

问题出在注释上

@Test(groups = { "TestA" }, dependsOnGroups = { "setUp" })

基本上你的错误信息是试图说没有@Test 方法与组名作为setUp!! 针对您的问题，解决方案是修改测试方法的注释，如下所示

 @Test(groups = { "TestA" })

并在支持方法中修改注解

  @BeforeGroups (groups = {"TestA"})

我用这个设置运行了一个示例

public class TestSupport {

    @BeforeGroups(groups = { "sample","sample1" })
    public void beforeTest() {
        System.out.println("Before test");
    }

    @AfterGroups(groups = { "sample","sample1" })
    public void afterTest() {
        System.out.println("after test");
    }

}

和我的测试课一样

public class TestClassA {

    @Test(groups = { "sample" })
    public void superTestA() {
        System.out.println("This is the actual test");
    }

    @Test(groups = { "sample" })
    public void superTestB() {
        System.out.println("This is the another test under sample group");
    }

    @Test(groups = { "sample1" })
    public void superTest() {
        System.out.println("This is another test");
    }
}

和我的 testng.xml 如下所示

<test name="sampletest" >
     <groups>
        <run>
            <include name="sample" />
            <include name="sample1" />

        </run>
    </groups>
    <classes>
        <class name="test.global.testng.TestClassA"/>
        <class name="test.global.testng.TestSupport"/>
    </classes>

  </test>

现在这是测试的运行方式：beforeGroups-> superTestA/superTestB ->afterGroups并且beforeGroups-> superTest -> afterGroups关闭

于 2012-07-17T11:29:38.317 回答
2

我想我已经想出了我想要的解决方案。

我需要在支持类中分别使用@BeforeTestand@AfterTest而不是@BeforeGroupsand ：@AfterGroups

@BeforeTest(groups = {"setUp"})
public void beforeTest() {[...]}

@AfterTest( groups = {"tearDown"})
public void afterTest() {[...]}

在测试类中：

@Test(groups = { "TestA" })
public void testSomething() {[...]}

dependsOnGroups就像巴顿的方法一样，它已经消失了。

与我的问题相比，testng.xml 没有变化。即可以在 testng.xml 文件中配置测试，而无需更改 java 代码。

此外，该解决方案还消除了 BeforeGroups 方法的另一个问题，至少正如 Patton 所假设的那样（@Patton 我并不是要冒犯你）。对于后者，使用多个测试组的测试不会按预期运行，因为该beforeTest()方法将在任何组之前运行。例如，如果您有以下测试（testng.xml 的摘录）：

    <groups>
        <run>
            <include name="TestA"/>
            <include name="TestB"/>
        </run>
    </groups>

...执行的结果步骤是：
beforeTest()、TestA、beforeTest()、TestB、afterTest()。

将解决方案与 BeforeTest 一起使用，您将进行以下测试：

    <groups>
        <run>
            <include name="setUp" />
            <include name="TestA"/>
            <include name="TestB"/>
            <include name="tearDown"/>
        </run>
    </groups>

...执行的结果步骤是：
setUp = beforeTest()、TestA、TestB、tearDown = afterTest()。

于 2012-07-17T14:02:19.520 回答
0 
package com.test.MySample;

import org.testng.annotations.*; 

public class TestNGTest1 {    

    @BeforeTest   
    public void BeforeTest() {         
        System.out.println("@BeforeTest");
    }

    @BeforeClass    
    public void BeforeClass() {         
        System.out.println("@BeforeClass");
    }      

    @BeforeGroups  (groups = {"My group"}) 
    public void BeforeGroups() {       
        System.out.println("@BeforeGroups");
    }

    @BeforeGroups  (groups = {"My group1"}) 
    public void BeforeGroups1() {       
        System.out.println("@BeforeGroups1");
    }

    @AfterGroups  (groups = {"My group1"}) 
    public void AfterGroups1() {       
        System.out.println("@AfterGroups1");
    }

    @BeforeMethod    
    public void BeforeMethod() {         
        System.out.println("@BeforeMethod");     
    } 

    @Test(groups = {"My group"})     
    public void test1() {         
        System.out.println("test1");     
    } 

    @Test (groups = {"My group", "My group1"})    
    public void test2() {         
        System.out.println("test2");     
    }

    @AfterMethod    
    public void AfterMethod() {         
        System.out.println("@AfterMethod");     
    } 

    @AfterGroups  (groups = {"My group"}) 
    public void AfterGroups() {       
        System.out.println("@AfterGroups");
    }

    @AfterClass    
    public void AfterClass() {         
        System.out.println("@AfterClass");
    }  

    @AfterTest   
    public void AfterTest() {         
        System.out.println("@AfterTest");
    }
}
于 2013-08-15T14:21:01.873 回答