Refactor for tree processor

CHANGELOG.md

@@ -153,6 +153,9 @@
 
 ### Chore & Maintenance
 
+* `[jest-jasmine2]` Simplify `Env.execute` and TreeProcessor to setup and clean
+  resources for the top suite the same way as for all of the children suites
+  ([#5885](https://github.com/facebook/jest/pull/5885))
 * `[babel-jest]` [**BREAKING**] Always return object from transformer
   ([#5991](https://github.com/facebook/jest/pull/5991))
 * `[*]` Run Prettier on compiled output

integration-tests/__tests__/__snapshots__/failures.test.js.snap

@@ -247,7 +247,7 @@ exports[`not throwing Error objects 5`] = `
       37 | });
       38 | 
 
-      at packages/jest-jasmine2/build/jasmine/Env.js:518:34
+      at packages/jest-jasmine2/build/jasmine/Env.js:541:34
       at __tests__/during_tests.test.js:36:3
 
 "

packages/jest-jasmine2/src/jasmine/Env.js

@@ -177,84 +177,102 @@ export default function(j$) {
         return j$.testPath;
       },
     });
-    defaultResourcesForRunnable(topSuite.id);
+
     currentDeclarationSuite = topSuite;
 
     this.topSuite = function() {
       return topSuite;
     };
 
-    this.execute = async function(runnablesToRun) {
-      if (!runnablesToRun) {
-        if (focusedRunnables.length) {
-          runnablesToRun = focusedRunnables;
-        } else {
-          runnablesToRun = [topSuite.id];
-        }
+    const uncaught = err => {
+      if (currentSpec) {
+        currentSpec.onException(err);
+        currentSpec.cancel();
+      } else {
+        console.error('Unhandled error');
+        console.error(err.stack);
       }
+    };
 
-      const uncaught = err => {
-        if (currentSpec) {
-          currentSpec.onException(err);
-          currentSpec.cancel();
-        } else {
-          console.error('Unhandled error');
-          console.error(err.stack);
-        }
-      };
-
+    let oldListenersException;
+    let oldListenersRejection;
+    const executionSetup = function() {
       // Need to ensure we are the only ones handling these exceptions.
-      const oldListenersException = process
-        .listeners('uncaughtException')
-        .slice();
-      const oldListenersRejection = process
-        .listeners('unhandledRejection')
-        .slice();
+      oldListenersException = process.listeners('uncaughtException').slice();
+      oldListenersRejection = process.listeners('unhandledRejection').slice();
 
       j$.process.removeAllListeners('uncaughtException');
       j$.process.removeAllListeners('unhandledRejection');
 
       j$.process.on('uncaughtException', uncaught);
       j$.process.on('unhandledRejection', uncaught);
+    };
+
+    const executionTeardown = function() {
+      j$.process.removeListener('uncaughtException', uncaught);
+      j$.process.removeListener('unhandledRejection', uncaught);
+
+      // restore previous exception handlers
+      oldListenersException.forEach(listener => {
+        j$.process.on('uncaughtException', listener);
+      });
+
+      oldListenersRejection.forEach(listener => {
+        j$.process.on('unhandledRejection', listener);
+      });
+    };
+
+    this.execute = async function(runnablesToRun, suiteTree = topSuite) {
+      if (!runnablesToRun) {
+        if (focusedRunnables.length) {
+          runnablesToRun = focusedRunnables;
+        } else {
+          runnablesToRun = [suiteTree.id];
+        }
+      }
 
-      reporter.jasmineStarted({totalSpecsDefined});
+      if (currentlyExecutingSuites.length === 0) {
+        executionSetup();
+      }
 
-      currentlyExecutingSuites.push(topSuite);
+      const lastDeclarationSuite = currentDeclarationSuite;
 
       await treeProcessor({
         nodeComplete(suite) {
           if (!suite.disabled) {
             clearResourcesForRunnable(suite.id);
           }
           currentlyExecutingSuites.pop();
-          reporter.suiteDone(suite.getResult());
+          if (suite === topSuite) {
+            reporter.jasmineDone({
+              failedExpectations: topSuite.result.failedExpectations,
+            });
+          } else {
+            reporter.suiteDone(suite.getResult());
+          }
         },
         nodeStart(suite) {
           currentlyExecutingSuites.push(suite);
-          defaultResourcesForRunnable(suite.id, suite.parentSuite.id);
-          reporter.suiteStarted(suite.result);
+          defaultResourcesForRunnable(
+            suite.id,
+            suite.parentSuite && suite.parentSuite.id,
+          );
+          if (suite === topSuite) {
+            reporter.jasmineStarted({totalSpecsDefined});
+          } else {
+            reporter.suiteStarted(suite.result);
+          }
         },
         queueRunnerFactory,
         runnableIds: runnablesToRun,
-        tree: topSuite,
+        tree: suiteTree,
       });
-      clearResourcesForRunnable(topSuite.id);
-      currentlyExecutingSuites.pop();
-      reporter.jasmineDone({
-        failedExpectations: topSuite.result.failedExpectations,
-      });
-
-      j$.process.removeListener('uncaughtException', uncaught);
-      j$.process.removeListener('unhandledRejection', uncaught);
 
-      // restore previous exception handlers
-      oldListenersException.forEach(listener => {
-        j$.process.on('uncaughtException', listener);
-      });
+      currentDeclarationSuite = lastDeclarationSuite;
 
-      oldListenersRejection.forEach(listener => {
-        j$.process.on('unhandledRejection', listener);
-      });
+      if (currentlyExecutingSuites.length === 0) {
+        executionTeardown();
+      }
     };
 
     this.addReporter = function(reporterToAdd) {

packages/jest-jasmine2/src/tree_processor.js

@@ -43,40 +43,42 @@ export default function treeProcessor(options: Options) {
     return parentEnabled || runnableIds.indexOf(node.id) !== -1;
   }
 
-  return queueRunnerFactory({
-    onException: error => tree.onException(error),
-    queueableFns: wrapChildren(tree, isEnabled(tree, false)),
-    userContext: tree.sharedUserContext(),
-  });
-
-  function executeNode(node, parentEnabled) {
+  function getNodeHandler(node: TreeNode, parentEnabled: boolean) {
     const enabled = isEnabled(node, parentEnabled);
-    if (!node.children) {
-      return {
-        fn(done) {
-          node.execute(done, enabled);
-        },
-      };
-    }
-    return {
-      async fn(done) {
-        nodeStart(node);
-        await queueRunnerFactory({
-          onException: error => node.onException(error),
-          queueableFns: wrapChildren(node, enabled),
-          userContext: node.sharedUserContext(),
-        });
-        nodeComplete(node);
-        done();
-      },
+    return node.children
+      ? getNodeWithChildrenHandler(node, enabled)
+      : getNodeWithoutChildrenHandler(node, enabled);
+  }
+
+  function getNodeWithoutChildrenHandler(node: TreeNode, enabled: boolean) {
+    return function fn(done: (error?: any) => void = () => {}) {
+      node.execute(done, enabled);
+    };
+  }
+
+  function getNodeWithChildrenHandler(node: TreeNode, enabled: boolean) {
+    return async function fn(done: (error?: any) => void = () => {}) {
+      nodeStart(node);
+      await queueRunnerFactory({
+        onException: error => node.onException(error),
+        queueableFns: wrapChildren(node, enabled),
+        userContext: node.sharedUserContext(),
+      });
+      nodeComplete(node);
+      done();
     };
   }
 
   function wrapChildren(node: TreeNode, enabled: boolean) {
     if (!node.children) {
       throw new Error('`node.children` is not defined.');
     }
-    const children = node.children.map(child => executeNode(child, enabled));
+    const children = node.children.map(child => ({
+      fn: getNodeHandler(child, enabled),
+    }));
     return node.beforeAllFns.concat(children).concat(node.afterAllFns);
   }
+
+  const treeHandler = getNodeHandler(tree, false);
+  return treeHandler();
 }