TestNG源代码分析：依赖管理的实现

TestNG源代码分析：依赖管理的实现

2018-03-19

1 背景

当case之间有依赖关系，有依赖关系的case，它们的执行顺序是有限制的。TestNG提供了依赖管理功能

2 基础理论

这个执行顺序可以用拓扑排序算法实现。

只要是有向无环图就能被拓扑排序，拓扑排序维基典型实现算法：

L ← Empty list that will contain the sorted elements
S ← Set of all nodes with no incoming edges
while S is non-empty do
    remove a node n from S
    insert n into L
    foreach node m with an edge e from n to m do
        remove edge e from thegraph
        if m has no other incoming edges then
            insert m into S
if graph has edges then
    return error (graph has at least one cycle)
else
    return L (a topologically sorted order)

TestNG依赖管理功能

• dependsOnMethods

@Test
public void serverStartedOk(){}
@Test(dependsOnMethods={ "serverStartedOk" })
public void method1() {}  

• dependsOnGroups

@Test(groups = { "init" })
public void serverStartedOk(){}
@Test(groups = { "init" })
public void initEnvironment(){}
@Test(dependsOnGroups = { "init.*})
public void method1() {} 

3 TestNG依赖管理源代码

如何找到依赖原理源代码？

通过报错，即即故意制造一个循环依赖，然后看stack trace：

错误代码如下：

    @Test(dependsOnMethods={"MethodA"})
    public void MethodA(){}

Stack Trace

at org.testng.internal.Graph.topologicalSort(Graph.java:143)
at org.testng.internal.MethodHelper.topologicalSort(MethodHelper.java:231)

org.testng.TestNGException:
The following methods have cyclic dependencies:
Sample.MethodA()[pri:0, instance:Demo.Sample@50c87b21]

    at org.testng.internal.Graph.topologicalSort(Graph.java:143)
    at org.testng.internal.MethodHelper.topologicalSort(MethodHelper.java:231)
    at org.testng.internal.MethodHelper.sortMethods(MethodHelper.java:287)
    at org.testng.internal.MethodHelper.collectAndOrderMethods(MethodHelper.java:60)
    at org.testng.TestRunner.initMethods(TestRunner.java:464)
    at org.testng.TestRunner.init(TestRunner.java:247)
    at org.testng.TestRunner.init(TestRunner.java:217)
    at org.testng.TestRunner.<init>(TestRunner.java:169)
    at org.testng.remote.support.RemoteTestNG6_9_10$1.newTestRunner(RemoteTestNG6_9_10.java:28)
    at org.testng.remote.support.RemoteTestNG6_9_10$DelegatingTestRunnerFactory.newTestRunner(RemoteTestNG6_9_10.java:61)
    at org.testng.SuiteRunner$ProxyTestRunnerFactory.newTestRunner(SuiteRunner.java:594)
    at org.testng.SuiteRunner.init(SuiteRunner.java:168)
    at org.testng.SuiteRunner.<init>(SuiteRunner.java:117)
    at org.testng.TestNG.createSuiteRunner(TestNG.java:1339)
    at org.testng.TestNG.createSuiteRunners(TestNG.java:1326)
    at org.testng.TestNG.runSuitesLocally(TestNG.java:1180)
    at org.testng.TestNG.runSuites(TestNG.java:1104)
    at org.testng.TestNG.run(TestNG.java:1076)
    at org.testng.remote.AbstractRemoteTestNG.run(AbstractRemoteTestNG.java:126)
    at org.testng.remote.RemoteTestNG.initAndRun(RemoteTestNG.java:152)
    at org.testng.remote.RemoteTestNG.main(RemoteTestNG.java:57)

4 源代码分析

//MethodHelper.topologicalSort
private static Graph<ITestNGMethod> topologicalSort(ITestNGMethod[] methods, List<ITestNGMethod> sequentialList, List<ITestNGMethod> parallelList)
//Graph.topologicalSort
public void topologicalSort()

注意：

• methods变量包括所有的要跑的用例和用例依赖的用例（依赖用例依赖的用例也包括）
• 依赖管理代码在Graph类中实现，MethodHelper.topologicalSort方法会调用Graph类中的方法

Graph类有三个变量

  //m_nodes:放的是所有的节点的引用
  private Map<T, Node<T>> m_nodes = Maps.newLinkedHashMap();
  //m_independentNodes:所有独立节点的引用，这样的节点（用例）可并发运行
  private List<T> m_strictlySortedNodes = null;
  //m_strictlySortedNodes:经过严格排序的非独立节点
  private Map<T, Node<T>> m_independentNodes = null;

Graph.topologicalSort方法实现依赖节点的拓扑排序

//m_nodes:放的是所有的节点(用例)的引用
//m_independentNodes:所有独立节点的引用
//m_strictlySortedNodes:经过严格排序的非独立节点
public void topologicalSort() {
    ppp("================ SORTING");
    //m_strictlySortedNodes集合: 最后的结果放到这个集合中
    m_strictlySortedNodes=Lists.newArrayList();
    initializeIndependentNodes();

    //nodes2集合: 非独立的节点
    List<Node<T>>nodes2 =Lists.newArrayList();

    //1 创建非独立节点集合，即存在依赖关系的方法的集合
    for (Node<T> n :getNodes()) {  //getNodes()返回m_nodes
        if (!isIndependent(n.getObject())){// 判断该节点是否独立，如果不独立的话，添加到nodes2中
            ppp("ADDING FOR SORT: " +n.getObject());
            nodes2.add(n.clone()); //使用的是clone方法来进行对象的复制，一般不推荐使用clone方法，参见Effective Java Item 11
        }
        else {
            ppp("SKIPPING INDEPENDENT NODE" + n);
        }
    }

    //2 将非独立的节点集合排序，为了让属于同类中的方法在集合中的位置近一些，从而在调用的顺序上能够相邻一些
    Collections.sort(nodes2);

    //3 进行拓扑排序，如果发现有循环依赖，马上抛出异常
    while (!nodes2.isEmpty()) {
        Node<T> node =findNodeWithNoPredecessors(nodes2); // 从nodes2集合中找到没有前驱节点的节点
        if (null == node) {   // 如果没有找到节点，那么创建一个Tarjan对象来得到一个cycle
            List<T> cycle =newTarjan<T>(this,nodes2.get(0).getObject()).getCycle(); // 这里实现了Tarjan算法，用来得到环的路径信息
            StringBuffer sb = new StringBuffer();  //在非并发环境中应该尽量使用StringBuilder
            sb.append("The following methodshave cyclic dependencies:\n");
            for (T m : cycle) {
                sb.append(m).append("\n");
            }
            throw newTestNGException(sb.toString());
        }
        else {   //如果找到了，将这个没有任何前驱节点的节点放到结果结合中，然后从nodes2集合中删除该节点
            m_strictlySortedNodes.add(node.getObject());
            removeFromNodes(nodes2, node);
        }
    }
    ppp("===============DONESORTING");
    if (m_verbose) {
        dumpSortedNodes();
    }
}

调用方法

private void initializeIndependentNodes() {
    if (null == m_independentNodes) {
        List<Node<T>> list = Lists.newArrayList(m_nodes.values());
        Collections.sort(list);
        m_independentNodes = Maps.newLinkedHashMap();
        for (Node<T> node : list) {
            m_independentNodes.put(node.getObject(), node);
        }
    }
}

private Collection<Node<T>> getNodes() {
    return m_nodes.values();
}

MethodHelper.topologicalSort方法，调用Graph方法区分独立节点和依赖节点，并调用toplogicalSort进行依赖节点拓扑排序

private static Graph<ITestNGMethod> topologicalSort(ITestNGMethod[] methods, List<ITestNGMethod> sequentialList, List<ITestNGMethod> parallelList) {
  Graph<ITestNGMethod> result = new Graph<>();
  if (methods.length == 0) {
    return result;  //如果传入的methods数组长度为0，直接返回了空的graph
  }

  // 区分出要顺序执行的用例（依赖用例）和可并行的用例（独立用例）
  for (ITestNGMethod m : methods) {
    result.addNode(m); //对于每个方法instance，添加到graph中    

    List<ITestNGMethod> predecessors = Lists.newArrayList(); //获得该方法依赖的方法
    String[] methodsDependedUpon = m.getMethodsDependedUpon();
    String[] groupsDependedUpon = m.getGroupsDependedUpon();
    if (methodsDependedUpon.length > 0) {
      ITestNGMethod[] methodsNamed =
        MethodHelper.findDependedUponMethods(m, methods);
      for (ITestNGMethod pred : methodsNamed) {
        predecessors.add(pred);
      }
    }
    if (groupsDependedUpon.length > 0) {
      for (String group : groupsDependedUpon) {
        ITestNGMethod[] methodsThatBelongToGroup =
          MethodGroupsHelper.findMethodsThatBelongToGroup(m, methods, group);
        for (ITestNGMethod pred : methodsThatBelongToGroup) {
          predecessors.add(pred);
        }
      }
    }

    for (ITestNGMethod predecessor : predecessor s) {
      result.addPredecessor(m, predecessor); //将依赖方法加入graph中
    }
  }

  result.topologicalSort();
  sequentialList.addAll(result.getStrictlySortedNodes());
  parallelList.addAll(result.getIndependentNodes());

  return result;
}

调用方法

public void addNode(T tm) {
    ppp("ADDING NODE " + tm + " " + tm.hashCode());
    m_nodes.put(tm, new Node<>(tm));
    // Initially, all the nodes are put in the independent list as well
}

public void addPredecessor(T tm, T predecessor) {
    Node<T> node = findNode(tm);
    if (null == node) {
      throw new TestNGException("Non-existing node: " + tm);
    }
    else {
      node.addPredecessor(predecessor);
      addNeighbor(tm, predecessor);
      // Remove these two nodes from the independent list
      initializeIndependentNodes();
      m_independentNodes.remove(predecessor);
      m_independentNodes.remove(tm);
      ppp("  REMOVED " + predecessor + " FROM INDEPENDENT OBJECTS");
    }
}

public Set<T> getIndependentNodes() {
    return m_independentNodes.keySet();
}

public List<T> getStrictlySortedNodes() {
    return m_strictlySortedNodes;
}

参考

[1] TestNG源代码分析 --- 依赖管理的实现（一）

[2] TestNG源代码分析 --- 依赖管理的实现（二）