testNG 优先级和依赖关系

Question

我在优先级方面遇到了一些问题&依赖于testNG。例如，如果我有这个

@Test
public void login () { ... }
@Test (dependsOnMethods = {"login"})
public void method1 () { ... }
@Test (dependsOnMethods = {"method1"})
public void method2 () { ... }
@Test (dependsOnMethods = {"login"})
public void logout () { ... }

在这种情况下，它是这样运行的：

登录-->方法1-->注销-->方法2-

这不会起作用，因为我不再连接

你会对我说，注销取决于方法2，一切都会好起来的。。。

是的，它会。。。但当方法1或2失败时，它将跳过注销，而不是这样做。。。这不是我想要的。

然后你会说我。。。在这种情况下，只需使用优先级而不是依赖项即可轻松运行。。。。是的，但是如果方法1失败了怎么办。。。那么方法2可能很好，但不起作用，因为方法1失败了，所以我会有一个假阴性。

你知道怎么做对吗？

Answer 1

您应该使用before/after方法来完成此操作：

@BeforeClass
public void login () { ... }
@Test
public void method1 () { ... }
@Test(dependsOnMethods = {"method1"})
public void method2 () { ... }
@AfterClass(alwaysRun=true) // alwaysRun to run the after method even if a test fails
public void logout () { ... }

Answer 2

您可以声明logout依赖于"方法2"；并始终运行：

始终运行

public abstract boolean alwaysRun

如果设置为true，则此测试方法将始终运行，即使它依赖于失败的方法。如果此测试不依赖于任何方法或组，则会忽略此属性。

默认值：

false

示例：

@Test
public void login () { ... }
@Test (dependsOnMethods = {"login"})
public void method1 () { ... }
@Test (dependsOnMethods = {"method1"})
public void method2 () { ... }
@Test (dependsOnMethods = {"method2"}, alwaysRun = true)
public void logout () { ... }

Answer 3

您可以将方法定义为：

        @Test(priority=1)
public void login()
{
    System.out.println("login");
}
@Test(priority=2)
public void method1()
{
    System.out.println("Method1");
    Assert.assertEquals("Method1", "login", "invalid msg not verified"); // Here test is failing as the expected value is not matching the actual value
    System.out.println("Verified");
}
@Test(priority=3)
public void method2()
{
    System.out.println("Method2");
    Assert.assertEquals("Method2", "Method2", "invalid msg not verified"); // Method1 fails however method2 is executed as actual and expected value are matching.
    System.out.println("Verified");
}
@Test(priority=4)
public void logout()
{
    System.out.println("logout");
}

这将帮助您执行优先级为1的所有测试，然后只有优先级为2的测试才会进入优先级为3的测试，然后进入优先级为4的测试。我在上面的代码中添加了"断言"，这将在任何测试失败的情况下帮助您进一步前进。

Answer 4

我相信，当这个问题同时得到很好的头脑风暴时，在实现过程中很少有概念被忽略。希望这能为问题提供一个解决方案：

@Test
public void login () { ... }
@Test (dependsOnMethods = {"login"}, groups = { "afterLogin" })
public void method1 () { ... }
@Test (dependsOnMethods = {"method1"}, groups = { "afterLogin" }, priority = 1) 
public void method2 () { ... }
// you mark dependsOnMethods when it actually "depends on" something prior to its execution and 
// hence corresponds to the failure of method it is depending on
@Test (dependsOnMethods = {"login"}, priority = 2)
public void logout () { ... }

这将确保序列登录-->方法1-->方法2-->注销

其中，

情况1：如果login失败，则不应执行与其相关的方法。

情况2：如果方法1或2失败，则不会跳过logout测试

案例3：如果方法1和方法2不依赖于登录，那么您实际上可以以更低/更高/相等的优先级执行它们，确保they are all independent。

Answer 5

这可能有助于

@Test (priority=1)
public void login()
{   
    System.out.println("login");
}
@Test(priority=2,dependsOnMethods={"login"})
public void method1()
{
    System.out.println("method1");
}
@Test(priority=3,dependsOnMethods={"method1"})
public void method2()
{
    System.out.println("method2");
}
@Test(priority=4,dependsOnMethods={"login"})
public void logout()
{
    System.out.println("logout");
}