Exemplo n.º 1
0
/**
 * This is the controller for the Apex Test Runner view. It's responsible for running tests, getting
 * results, and updating the UI with the test results. The actual view is generated by
 * RunTestViewComposite.java.
 *
 * @author jwidjaja
 */
public class RunTestView extends BaseViewPart {
  private static final Logger logger = Logger.getLogger(RunTestView.class);

  private static RunTestView INSTANCE = null;
  private final ReentrantLock lock = new ReentrantLock();

  // The name that is shown on the view tab
  public static final String VIEW_NAME = "Apex Test Runner";

  // Keys used to store data in a TreeItem
  public static final String TREEDATA_TEST_RESULT = "ApexTestResult";
  public static final String TREEDATA_CODE_LOCATION = "ApexCodeLocation";
  public static final String TREEDATA_APEX_LOG = "ApexLog";
  public static final String TREEDATA_APEX_LOG_USER_DEBUG = "ApexLogUserDebug";
  public static final String TREEDATA_APEX_LOG_BODY = "ApexLogBody";

  private RunTestViewComposite runTestComposite = null;
  private IProject project = null;
  private ForceProject forceProject = null;
  private LogInfo[] logInfos = null;
  private HTTPConnection toolingRESTConnection = null;
  private ToolingStubExt toolingStubExt = null;
  private ISelectionListener fPostSelectionListener = null;

  private final Image FAILURE_ICON = ForceImages.get(ForceImages.IMAGE_FAILURE);
  private final int FAILURE_COLOR = SWT.COLOR_RED;
  private final Image WARNING_ICON = ForceImages.get(ForceImages.IMAGE_WARNING);
  private final int WARNING_COLOR = SWT.COLOR_DARK_YELLOW;
  private final Image PASS_ICON = ForceImages.get(ForceImages.IMAGE_CONFIRM);
  private final int PASS_COLOR = SWT.COLOR_DARK_GREEN;

  private final String TOOLING_ENDPOINT = "/services/data/";

  private final String QUERY_USER_ID = "SELECT Id, Username FROM User WHERE Username = '******'";
  private final String QUERY_TESTRESULT_COUNT =
      "SELECT COUNT(Id) FROM ApexTestResult WHERE AsyncApexJobId = '%s'";
  private final String QUERY_TESTRESULT =
      "SELECT ApexClassId, ApexLogId, AsyncApexJobId, Message, "
          + "MethodName, Outcome, QueueItemId, StackTrace, TestTimestamp "
          + "FROM ApexTestResult WHERE AsyncApexJobId = '%s'";
  private final String QUERY_APEX_LOG =
      "SELECT Id, Application, DurationMilliseconds, Location, LogLength, LogUserId, Operation, Request, StartTime, Status FROM ApexLog WHERE Id = '%s'";
  private final String QUERY_APEX_TEST_QUEUE_ITEM =
      "SELECT Id, Status FROM ApexTestQueueItem WHERE ParentJobId = '%s'";

  private final int POLL_FAST = 5000;
  private final int POLL_MED = 10000;
  private final int POLL_SLOW = 15000;

  public RunTestView() {
    super();
    setSelectionListener();

    INSTANCE = this;
  }

  public static RunTestView getInstance() {
    if (Utils.isEmpty(INSTANCE)) {
      // We use Display.syncExec because getting a view has to be done
      // on a UI thread.
      Display display = PlatformUI.getWorkbench().getDisplay();
      if (Utils.isEmpty(display)) return INSTANCE;

      display.syncExec(
          new Runnable() {
            @Override
            public void run() {
              try {
                INSTANCE =
                    (RunTestView)
                        PlatformUI.getWorkbench()
                            .getActiveWorkbenchWindow()
                            .getActivePage()
                            .showView(UIConstants.RUN_TEST_VIEW_ID);
              } catch (PartInitException e) {
              }
            }
          });
    }

    return INSTANCE;
  }

  /**
   * Is there a test run in progress? If yes, this method returns false. If no, this method returns
   * true.
   */
  public boolean canRun() {
    return (lock != null && !lock.isLocked());
  }

  /**
   * Run the tests, get the results, and update the UI.
   *
   * @param project
   * @param testResources
   * @param testsInJson
   * @param totalTestMethods
   * @param monitor
   */
  public void runTests(
      final IProject project,
      Map<String, IResource> testResources,
      String testsInJson,
      int totalTestMethods,
      IProgressMonitor monitor) {
    lock.lock();

    try {
      // Prepare the UI and get the log infos
      Display display = PlatformUI.getWorkbench().getDisplay();
      display.syncExec(
          new Runnable() {
            @Override
            public void run() {
              setProject(project);
              runTestComposite.clearAll();
              logInfos = runTestComposite.getLogInfoAndType();
            }
          });

      forceProject = materializeForceProject(project);
      // We need the user ID to insert a trace flag
      String userId = getUserId(forceProject.getUserName());
      // Try to insert a trace flag for apex logs. If this fails, the test run will still continue
      String traceFlagId = insertTraceFlag(logInfos, userId);

      // If user wants to cancel the launch, delete the trace flag and stop
      if (monitor.isCanceled()) {
        deleteTraceFlag(traceFlagId);
        return;
      }

      // Submit the tests for execution
      String testRunId = enqueueTests(testsInJson);

      // Poll for test results
      List<ApexTestResult> testResults = getTestResults(testRunId, totalTestMethods, monitor);

      // Whether or not user aborted, we want to delete the trace flag
      deleteTraceFlag(traceFlagId);

      // Whether or not user aborted, we want to show whatever test results we got back
      processTestResults(project, testResources, testResults);
    } finally {
      lock.unlock();
    }
  }

  /**
   * Get a ForceProject from an IProject.
   *
   * @param project
   * @return ForceProject
   */
  public ForceProject materializeForceProject(IProject project) {
    if (Utils.isEmpty(project) || !project.exists()) return null;

    ForceProject forceProject =
        ContainerDelegate.getInstance()
            .getServiceLocator()
            .getProjectService()
            .getForceProject(project);
    return forceProject;
  }

  /**
   * Queries the user ID based on the given user name.
   *
   * @param userName
   * @return User ID if valid. Null otherwise.
   */
  public String getUserId(String userName) {
    String userId = null;

    if (Utils.isEmpty(forceProject) || Utils.isEmpty(userName)) {
      return userId;
    }

    try {
      initializeConnection(forceProject);

      QueryResult qr = toolingStubExt.query(String.format(QUERY_USER_ID, userName));
      if (qr != null && qr.getSize() > 0) {
        return qr.getRecords()[0].getId();
      }
    } catch (ForceConnectionException | ForceRemoteException e) {
      logger.error("Failed to connect to Tooling API", e);
    }

    return userId;
  }

  /**
   * Inserts a TraceFlag. The userId is used for the TraceFlag's entity ID and scope ID.
   *
   * @param logInfos
   * @param userId
   * @return ID of the TraceFlag
   */
  public String insertTraceFlag(LogInfo[] logInfos, String userId) {
    String traceFlagId = null;

    if (Utils.isEmpty(forceProject) || Utils.isEmpty(logInfos) || Utils.isEmpty(userId)) {
      return traceFlagId;
    }

    try {
      initializeConnection(forceProject);

      TraceFlag tf = new TraceFlag();
      tf.setTracedEntityId(userId);

      for (LogInfo logInfo : logInfos) {
        // Translate Metadata's LogInfo into Tooling's ApexLogLevel and LogCategory
        LogCategory logCategory = logInfo.getCategory();
        LogCategoryLevel metadataLogLevel = logInfo.getLevel();

        ApexLogLevel toolingLogLevel = translateLogLevel(metadataLogLevel);

        if (logCategory.equals(LogCategory.Apex_code)) {
          tf.setApexCode(toolingLogLevel);
        } else if (logCategory.equals(LogCategory.Apex_profiling)) {
          tf.setApexProfiling(toolingLogLevel);
        } else if (logCategory.equals(LogCategory.Callout)) {
          tf.setCallout(toolingLogLevel);
        } else if (logCategory.equals(LogCategory.Db)) {
          tf.setDatabase(toolingLogLevel);
        } else if (logCategory.equals(LogCategory.System)) {
          tf.setSystem(toolingLogLevel);
        } else if (logCategory.equals(LogCategory.Validation)) {
          tf.setValidation(toolingLogLevel);
        } else if (logCategory.equals(LogCategory.Visualforce)) {
          tf.setVisualforce(toolingLogLevel);
        } else if (logCategory.equals(LogCategory.Workflow)) {
          tf.setWorkflow(toolingLogLevel);
        }
      }

      SaveResult[] sr = toolingStubExt.create(new SObject[] {tf});
      if (sr != null && sr.length > 0) {
        traceFlagId = sr[0].getId();
        if (sr[0].isSuccess()) {
          logger.debug(String.format("Created TraceFlag %s", traceFlagId));
        } else {
          logger.warn(sr[0].getErrors().toString());
        }
      }
    } catch (ForceConnectionException | ForceRemoteException e) {
      logger.error("Failed to connect to Tooling API", e);
    }

    return traceFlagId;
  }

  /**
   * Delete a TraceFlag.
   *
   * @param traceFlagId
   */
  public void deleteTraceFlag(String traceFlagId) {
    if (Utils.isEmpty(forceProject) || Utils.isEmpty(traceFlagId)) {
      return;
    }

    try {
      initializeConnection(forceProject);

      DeleteResult[] dr = toolingStubExt.delete(new String[] {traceFlagId});
      if (dr != null && dr.length > 0) {
        boolean deleteSuccess = dr[0].isSuccess();
        if (deleteSuccess) {
          logger.debug(String.format("Deleted TraceFlag %s", traceFlagId));
        } else {
          logger.warn(String.format("Failed to delete TraceFlag %s", traceFlagId));
        }
      }
    } catch (ForceConnectionException | ForceRemoteException e) {
      logger.error("Failed to connect to Tooling API", e);
    }
  }

  /**
   * Translate Metadata's LogCategoryLevel to Tooling's ApexLogLevel.
   *
   * @param metadataLogLevel
   * @return The translated log level
   */
  private ApexLogLevel translateLogLevel(LogCategoryLevel metadataLogLevel) {
    if (metadataLogLevel.equals(LogCategoryLevel.Debug)) {
      return ApexLogLevel.DEBUG;
    } else if (metadataLogLevel.equals(LogCategoryLevel.Error)) {
      return ApexLogLevel.ERROR;
    } else if (metadataLogLevel.equals(LogCategoryLevel.Fine)) {
      return ApexLogLevel.FINE;
    } else if (metadataLogLevel.equals(LogCategoryLevel.Finer)) {
      return ApexLogLevel.FINER;
    } else if (metadataLogLevel.equals(LogCategoryLevel.Finest)) {
      return ApexLogLevel.FINEST;
    } else if (metadataLogLevel.equals(LogCategoryLevel.Info)) {
      return ApexLogLevel.INFO;
    } else if (metadataLogLevel.equals(LogCategoryLevel.Warn)) {
      return ApexLogLevel.WARN;
    } else {
      return ApexLogLevel.NONE;
    }
  }

  /**
   * Enqueue a tests array to Tooling's runTestsAsynchronous.
   *
   * @param testsInJson
   * @return The test run ID if valid. Null otherwise.
   */
  public String enqueueTests(String testsInJson) {
    String response = null;

    if (Utils.isEmpty(forceProject)) {
      return response;
    }

    try {
      initializeConnection(forceProject);

      PromiseableJob<String> job =
          new RunTestsCommand(
              new HTTPAdapter<>(
                  String.class, new RunTestsTransport(toolingRESTConnection), HTTPMethod.POST),
              testsInJson);
      job.schedule();

      try {
        job.join();
        response = job.getAnswer();
      } catch (InterruptedException e) {
        logger.error("Failed to enqueue test run", e);
      }

    } catch (ForceConnectionException | ForceRemoteException e) {
      logger.error("Failed to connect to Tooling API", e);
    }

    return response;
  }

  /**
   * Retrieve test results for the given test run ID.
   *
   * @param testRunId
   * @return A list of ApexTestResult, if any.
   */
  public List<ApexTestResult> getTestResults(
      final String testRunId, final int totalTestMethods, IProgressMonitor monitor) {
    List<ApexTestResult> testResults = Lists.newArrayList();
    if (Utils.isEmpty(forceProject) || Utils.isEmpty(testRunId)) return testResults;

    try {
      initializeConnection(forceProject);

      // Get remaining daily API requests
      Limit dailyApiRequests = getApiLimit(forceProject, LimitsCommand.Type.DailyApiRequests);
      if (dailyApiRequests == null) {
        return testResults;
      }

      float apiRequestsRemaining =
          (dailyApiRequests.getRemaining() * 100.0f) / dailyApiRequests.getMax();
      if (apiRequestsRemaining <= 0) {
        return testResults;
      }

      // Poll for remaining test cases to be executed
      int totalTestDone = 0;
      QueryResult qr = null;
      // No timeout here because we don't know how long a test run can be.
      // If user wants to exit, then they can cancel the launch config.
      while (totalTestDone < totalTestMethods) {
        // Query for number of finished tests in specified test run
        qr = toolingStubExt.query(String.format(QUERY_TESTRESULT_COUNT, testRunId));

        // Update finished test counter
        if (qr.getSize() == 1) {
          SObject sObj = qr.getRecords()[0];
          if (sObj instanceof AggregateResult) {
            AggregateResult aggRes = (AggregateResult) sObj;
            Object expr0 = aggRes.getField("expr0");
            totalTestDone = (int) expr0;
            updateProgress(0, totalTestMethods, totalTestDone);
          }
        }

        // User wants to abort so we'll tell the server to abort the test run
        // and stop polling for test results. There may be some finished test results
        // so try to query those and update UI if necessary.
        if (monitor.isCanceled()) {
          abortTestRun(testRunId);
          break;
        }

        // Wait according to the interval
        int wait = getPollInterval(totalTestMethods - totalTestDone, apiRequestsRemaining);
        Thread.sleep(wait);
      }

      // Get all test results in the specified test run
      qr = toolingStubExt.query(String.format(QUERY_TESTRESULT, testRunId));
      if (qr != null && qr.getSize() > 0) {
        updateProgress(0, totalTestMethods, qr.getSize());
        for (SObject sObj : qr.getRecords()) {
          ApexTestResult testResult = (ApexTestResult) sObj;
          testResults.add(testResult);
        }
      }
    } catch (ForceConnectionException | ForceRemoteException e) {
      logger.error("Failed to connect to Tooling API", e);
    } catch (InterruptedException e) {
      logger.error("Getting test results was interrupted", e);
    } catch (Exception e) {
      logger.error("Something unexpected with getting Apex Test results", e);
    }

    return testResults;
  }

  /**
   * Get a specific API Limit
   *
   * @param type
   * @return Limit
   * @see Limit.java
   */
  public Limit getApiLimit(ForceProject forceProject, LimitsCommand.Type type) {
    try {
      initializeConnection(forceProject);

      PromiseableJob<Map<String, Limit>> job =
          new LimitsCommand(
              new HTTPAdapter<>(
                  String.class, new LimitsTransport(toolingRESTConnection), HTTPMethod.GET));
      job.schedule();

      try {
        job.join();
        Map<String, Limit> limits = job.getAnswer();
        if (limits != null && limits.size() > 0) {
          return limits.get(type.toString());
        }
      } catch (InterruptedException e) {
        logger.error("Failed to enqueue test run", e);
      }
    } catch (ForceConnectionException | ForceRemoteException e) {
      logger.error("Failed to connect to Tooling API", e);
    }

    return null;
  }

  /**
   * Get the appropriate poll interval depending on the number of tests remaining and the number of
   * API requests remaining. The higher the number of tests remaining, the slower we should poll.
   * The higher the number of remaining API requests, the faster we should poll.
   *
   * @param totalTestRemaining
   * @param apiRequestsRemaining
   * @return A poll interval
   */
  public int getPollInterval(int totalTestRemaining, float apiRequestsRemaining) {
    int intervalA = POLL_SLOW, intervalB = POLL_SLOW;

    if (totalTestRemaining <= 10) {
      intervalA = POLL_FAST;
    } else if (totalTestRemaining <= 50) {
      intervalA = POLL_MED;
    } else {
      intervalA = POLL_SLOW;
    }

    if (apiRequestsRemaining <= 25f) {
      intervalB = POLL_SLOW;
    } else if (apiRequestsRemaining <= 50f) {
      intervalB = POLL_MED;
    } else {
      intervalB = POLL_FAST;
    }

    return (intervalA + intervalB) / 2;
  }

  /**
   * Update the progress bar to show user the number of tests finished.
   *
   * @param min
   * @param max
   * @param cur
   */
  public void updateProgress(final int min, final int max, final int cur) {
    Display display = PlatformUI.getWorkbench().getDisplay();
    display.syncExec(
        new Runnable() {
          @Override
          public void run() {
            if (Utils.isNotEmpty(runTestComposite)) {
              runTestComposite.setProgress(min, max, cur);
            }
          }
        });
  }

  /**
   * Abort all ApexTestQueueItem with the same test run ID.
   *
   * @param testRunId
   */
  public void abortTestRun(String testRunId) {
    try {
      initializeConnection(forceProject);

      // Get all ApexTestQueueItem in the test run
      QueryResult qr = toolingStubExt.query(String.format(QUERY_APEX_TEST_QUEUE_ITEM, testRunId));
      if (Utils.isEmpty(qr) || qr.getSize() == 0) return;

      List<ApexTestQueueItem> abortedList = Lists.newArrayList();
      for (SObject sObj : qr.getRecords()) {
        ApexTestQueueItem atqi = (ApexTestQueueItem) sObj;
        // If the queue item is not done yet, abort them
        if (!atqi.getStatus().equals(AsyncApexJobStatus.Completed)
            && !atqi.getStatus().equals(AsyncApexJobStatus.Failed)) {
          atqi.setStatus(AsyncApexJobStatus.Aborted);
          abortedList.add(atqi);
        }
      }

      if (!abortedList.isEmpty()) {
        ApexTestQueueItem[] abortedArray = new ApexTestQueueItem[abortedList.size()];
        for (int i = 0; i < abortedList.size(); i++) {
          abortedArray[i] = abortedList.get(i);
        }

        toolingStubExt.update(abortedArray);
      }
    } catch (ForceConnectionException | ForceRemoteException e) {
      logger.error("Failed to connect to Tooling API", e);
    }
  }

  /**
   * Update the UI with the test results.
   *
   * @param project
   * @param testResources
   * @param testResults
   * @param delegate
   */
  public void processTestResults(
      final IProject project,
      final Map<String, IResource> testResources,
      final List<ApexTestResult> testResults) {
    Display display = PlatformUI.getWorkbench().getDisplay();

    display.asyncExec(
        new Runnable() {
          @Override
          public void run() {
            if (Utils.isEmpty(project)
                || Utils.isEmpty(testResources)
                || testResults == null
                || testResults.isEmpty()) {
              return;
            }

            // Map of tree items whose key is apex class id and the value is the tree item
            Map<String, TreeItem> testClassNodes = new HashMap<String, TreeItem>();

            FontRegistry registry = new FontRegistry();
            Font boldFont =
                registry.getBold(Display.getCurrent().getSystemFont().getFontData()[0].getName());

            // Reset tree
            Tree resultsTree = runTestComposite.getTree();
            resultsTree.removeAll();

            // Add each test result to the tree
            for (ApexTestResult testResult : testResults) {
              // Create or find the tree node for the test class
              String classId = testResult.getApexClassId();
              String className = null;
              if (!testClassNodes.containsKey(classId)) {
                TreeItem newClassNode = createTestClassTreeItem(resultsTree, boldFont);
                // Test result only has test class ID. Find the test class name mapped to that ID to
                // display in UI
                className =
                    testResources.containsKey(classId)
                        ? testResources.get(classId).getName()
                        : classId;
                newClassNode.setText(className);
                // Save the associated file in the tree item
                IFile testFile = getFileFromId(testResources, classId);
                if (Utils.isNotEmpty(testFile)) {
                  // For test classes, always point to the first line of the file
                  ApexCodeLocation location = new ApexCodeLocation(testFile, 1, 1);
                  newClassNode.setData(TREEDATA_CODE_LOCATION, location);
                }

                testClassNodes.put(classId, newClassNode);
              }

              // Add the a test method tree node to the test class tree node
              TreeItem classNode = testClassNodes.get(classId);
              className = classNode.getText();

              // Create a tree item for the test method and save the test result
              TreeItem newTestMethodNode =
                  createTestMethodTreeItem(classNode, testResult, className);
              // Set the color and icon of test method tree node based on test outcome
              setColorAndIconForNode(newTestMethodNode, testResult.getOutcome());
              // Update the color & icon of class tree node only if the test method
              // outcome is worse than what the class tree node indicates
              setColorAndIconForTheWorse(classNode, testResult.getOutcome());
            }

            // Expand the test classes that did not pass
            expandProblematicTestClasses(resultsTree);
          }
        });
  }

  /**
   * Create a default TreeItem for a test class.
   *
   * @param parent
   * @param font
   * @return TreeItem for test class
   */
  private TreeItem createTestClassTreeItem(Tree parent, Font font) {
    TreeItem newClassNode = new TreeItem(parent, SWT.NONE);
    newClassNode.setFont(font);
    newClassNode.setExpanded(false);
    // Mark this test class as pass until we find a test method within it that says otherwise
    setColorAndIconForNode(newClassNode, ApexTestOutcome.Pass);
    return newClassNode;
  }

  /**
   * Set color and icon for a test method's TreeItem.
   *
   * @param node
   * @param outcome
   */
  private void setColorAndIconForNode(TreeItem node, ApexTestOutcome outcome) {
    if (Utils.isEmpty(node) || Utils.isEmpty(outcome)) return;

    Display display = node.getDisplay();
    if (outcome.equals(ApexTestOutcome.Pass)) {
      node.setForeground(display.getSystemColor(PASS_COLOR));
      node.setImage(PASS_ICON);
    } else if (outcome.equals(ApexTestOutcome.Skip)) {
      node.setForeground(display.getSystemColor(WARNING_COLOR));
      node.setImage(WARNING_ICON);
    } else {
      node.setForeground(display.getSystemColor(FAILURE_COLOR));
      node.setImage(FAILURE_ICON);
    }
  }

  /**
   * Update the color & icon of a TreeItem only if the given outcome is worse than what the TreeItem
   * already indicates.
   *
   * @param node
   * @param outcome
   */
  private void setColorAndIconForTheWorse(TreeItem node, ApexTestOutcome outcome) {
    if (Utils.isEmpty(node) || Utils.isEmpty(outcome)) return;

    Image curImage = node.getImage();
    boolean worseThanPass = curImage.equals(PASS_ICON) && !outcome.equals(ApexTestOutcome.Pass);
    boolean worseThanWarning =
        curImage.equals(WARNING_ICON)
            && !outcome.equals(ApexTestOutcome.Pass)
            && !outcome.equals(ApexTestOutcome.Skip);
    if (worseThanPass || worseThanWarning) {
      setColorAndIconForNode(node, outcome);
    }
  }

  /**
   * Create a default TreeItem for a test method.
   *
   * @param classNode
   * @param testResult
   * @param className
   * @return TreeItem for test method
   */
  private TreeItem createTestMethodTreeItem(
      TreeItem classNode, ApexTestResult testResult, String className) {
    TreeItem newTestMethodNode = new TreeItem(classNode, SWT.NONE);
    newTestMethodNode.setText(testResult.getMethodName());
    newTestMethodNode.setData(TREEDATA_TEST_RESULT, testResult);

    ApexCodeLocation location =
        getCodeLocationForTestMethod(
            newTestMethodNode, className, testResult.getMethodName(), testResult.getStackTrace());
    newTestMethodNode.setData(TREEDATA_CODE_LOCATION, location);

    return newTestMethodNode;
  }

  /**
   * Get the code location of a test method. If there isn't one, we default to the code location of
   * the test class.
   *
   * @param treeItem
   * @param className
   * @param methodName
   * @param stackTrace
   * @return ApexCodeLocation
   */
  private ApexCodeLocation getCodeLocationForTestMethod(
      TreeItem treeItem, String className, String methodName, String stackTrace) {
    ApexCodeLocation tmLocation = getLocationFromStackLine(methodName, stackTrace);
    ApexCodeLocation tcLocation =
        (ApexCodeLocation) treeItem.getParentItem().getData(TREEDATA_CODE_LOCATION);
    // If there is no test method location, best effort is to use test class location
    if (Utils.isEmpty(tmLocation)) {
      tmLocation = tcLocation;
    } else {
      IFile file = tcLocation.getFile();
      tmLocation.setFile(file);
    }

    return tmLocation;
  }

  /**
   * Get line and column from a stack trace.
   *
   * @param name
   * @param stackTrace
   * @return ApexCodeLocation
   */
  private ApexCodeLocation getLocationFromStackLine(String name, String stackTrace) {
    if (Utils.isEmpty(name) || Utils.isEmpty(stackTrace)) return null;

    String line = null;
    String column = null;
    try {
      String[] temp = stackTrace.split("line");
      line = temp[1].split(",")[0].trim();
      String c = temp[1].trim();
      column = c.split("column")[1].trim();
      if (Utils.isNotEmpty(column) && column.contains("\n")) {
        column = column.substring(0, column.indexOf("\n"));
      }
    } catch (Exception e) {
    }

    return new ApexCodeLocation(name, line, column);
  }

  /**
   * Find a resource and convert to a file.
   *
   * @param testResources
   * @param classID
   * @return
   */
  private IFile getFileFromId(Map<String, IResource> testResources, String classID) {
    if (Utils.isNotEmpty(classID) && Utils.isNotEmpty(testResources)) {
      IResource testResource = testResources.get(classID);
      if (Utils.isNotEmpty(testResource)) {
        return (IFile) testResource;
      }
    }

    return null;
  }

  /**
   * Expand the TreeItems that did not pass.
   *
   * @param resultsTree
   */
  private void expandProblematicTestClasses(Tree resultsTree) {
    if (Utils.isEmpty(resultsTree)) return;

    for (TreeItem classNode : resultsTree.getItems()) {
      if (!classNode.getImage().equals(PASS_ICON)) {
        classNode.setExpanded(true);
      }
    }
  }

  /**
   * Jump to and highlight a line based on the ApexCodeLocation.
   *
   * @param location
   */
  public void highlightLine(ApexCodeLocation location) {
    if (Utils.isEmpty(location) || location.getFile() == null || !location.getFile().exists()) {
      Utils.openWarn("Highlight Failed", "Unable to highlight test file - file is unknown.");
      return;
    }

    HashMap<String, Integer> map = new HashMap<>();
    map.put(IMarker.LINE_NUMBER, location.getLine());
    try {
      IMarker marker = location.getFile().createMarker(IMarker.TEXT);
      marker.setAttributes(map);
      IDE.openEditor(getSite().getWorkbenchWindow().getActivePage(), marker);
    } catch (Exception e) {
      logger.error("Unable to highlight line.", e);
      Utils.openError(new InvocationTargetException(e), true, "Unable to highlight line.");
    }
  }

  /**
   * Update the test results tabs.
   *
   * @param selectedTreeItem
   * @param selectedTab
   */
  public void updateView(TreeItem selectedTreeItem, String selectedTab) {
    if (Utils.isEmpty(selectedTreeItem)
        || Utils.isEmpty(selectedTab)
        || Utils.isEmpty(runTestComposite)) {
      return;
    }

    // Only clear the right side because user will either select an item from the results tree
    // or a tab. We do not want to clear the tree (on the left side).
    runTestComposite.clearTabs();

    ApexTestResult testResult = (ApexTestResult) selectedTreeItem.getData(TREEDATA_TEST_RESULT);
    // If there is no test result, there is nothing to do on the right hand side so just
    // show the test file
    if (Utils.isEmpty(testResult)) {
      // Get the code location and open the file
      ApexCodeLocation location =
          (ApexCodeLocation) selectedTreeItem.getData(TREEDATA_CODE_LOCATION);
      highlightLine(location);
      return;
    }

    // If there is an ApexTestResult to work with, then check which tab is in focus
    // so we can update lazily.
    switch (selectedTab) {
      case RunTestViewComposite.STACK_TRACE:
        showStackTrace(testResult.getMessage(), testResult.getStackTrace());
        break;
      case RunTestViewComposite.SYSTEM_LOG:
        String systemLogId = testResult.getApexLogId();
        String systemApexLog = tryToGetApexLog(selectedTreeItem, systemLogId);
        showSystemLog(systemApexLog);
        break;
      case RunTestViewComposite.USER_LOG:
        String userLogId = testResult.getApexLogId();
        String userApexLog = tryToGetApexLog(selectedTreeItem, userLogId);
        showUserLog(selectedTreeItem, userApexLog);
        break;
    }

    // Show the file after updating the right hand side
    ApexCodeLocation location = (ApexCodeLocation) selectedTreeItem.getData(TREEDATA_CODE_LOCATION);
    highlightLine(location);
  }

  /**
   * Query an ApexLog with the specified log ID.
   *
   * @param forceProject
   * @param logId
   * @return ApexLog
   */
  public ApexLog getApexLog(ForceProject forceProject, String logId) {
    try {
      initializeConnection(forceProject);

      QueryResult qr = toolingStubExt.query(String.format(QUERY_APEX_LOG, logId));
      if (qr != null && qr.getSize() == 1) {
        ApexLog apexLog = (ApexLog) qr.getRecords()[0];
        return apexLog;
      }
    } catch (ForceRemoteException | ForceConnectionException e) {
    }

    return null;
  }

  /**
   * Fetch the raw body of an ApexLog with the specified log ID.
   *
   * @param forceProject
   * @param logId
   * @return Raw log. Null if something is wrong.
   */
  public String getApexLogBody(ForceProject forceProject, String logId) {
    String rawLog = null;

    try {
      initializeConnection(forceProject);

      PromiseableJob<String> job =
          new ApexLogCommand(
              new HTTPAdapter<>(
                  String.class,
                  new ApexLogTransport(toolingRESTConnection, logId),
                  HTTPMethod.GET));
      job.schedule();

      try {
        job.join();
        rawLog = job.getAnswer();
      } catch (InterruptedException e) {
        logger.error("Failed to get Apex Log", e);
      }
    } catch (ForceConnectionException | ForceRemoteException e) {
      logger.error("Failed to connect to Tooling API", e);
    }

    return rawLog;
  }

  /**
   * Get the body of an ApexLog. If that fails, get the toString of an ApexLog.
   *
   * @param selectedTreeItem
   * @param logId
   * @return A string representation of an ApexLog
   */
  public String tryToGetApexLog(TreeItem selectedTreeItem, String logId) {
    if (Utils.isEmpty(forceProject) || Utils.isEmpty(selectedTreeItem) || Utils.isEmpty(logId))
      return null;

    // Do we already have the log body?
    String apexLogBody = (String) selectedTreeItem.getData(TREEDATA_APEX_LOG_BODY);
    if (Utils.isNotEmpty(apexLogBody)) {
      return apexLogBody;
    }

    // Try to get the log body
    apexLogBody = getApexLogBody(forceProject, logId);
    if (Utils.isNotEmpty(apexLogBody)) {
      // Save it for future uses
      selectedTreeItem.setData(TREEDATA_APEX_LOG_BODY, apexLogBody);
      return apexLogBody;
    }

    // There is no ApexLog body, so try to retrieve a saved ApexLog
    ApexLog apexLog = (ApexLog) selectedTreeItem.getData(TREEDATA_APEX_LOG);
    if (Utils.isNotEmpty(apexLog)) {
      return apexLog.toString();
    }

    // Try to get the ApexLog object
    apexLog = getApexLog(forceProject, logId);
    selectedTreeItem.setData(TREEDATA_APEX_LOG, apexLog);
    return (Utils.isNotEmpty(apexLog) ? apexLog.toString() : null);
  }

  /**
   * Update the Stack Trace tab with the given error message & stack trace.
   *
   * @param message
   * @param stackTrace
   */
  public void showStackTrace(String message, String stackTrace) {
    if (Utils.isNotEmpty(runTestComposite)) {
      StringBuilder data = new StringBuilder();

      if (Utils.isNotEmpty(message)) {
        String newLine = System.getProperty("line.separator");
        data.append(message + newLine + newLine);
      }

      if (Utils.isNotEmpty(stackTrace)) {
        data.append(stackTrace);
      }

      runTestComposite.setStackTraceArea(data.toString());
    }
  }

  /**
   * Update the System Debug Log tab with the given log.
   *
   * @param log
   */
  public void showSystemLog(String log) {
    if (Utils.isNotEmpty(runTestComposite) && Utils.isNotEmpty(log)) {
      runTestComposite.setSystemLogsTextArea(log);
    }
  }

  /**
   * Update the User Debug Log tab with a filtered log.
   *
   * @param selectedTreeItem
   * @param log
   */
  public void showUserLog(TreeItem selectedTreeItem, String log) {
    if (Utils.isEmpty(selectedTreeItem) || Utils.isEmpty(runTestComposite)) {
      return;
    }

    // Do we already have a filtered log?
    String userDebugLog = (String) selectedTreeItem.getData(TREEDATA_APEX_LOG_USER_DEBUG);
    if (Utils.isNotEmpty(userDebugLog)) {
      runTestComposite.setUserLogsTextArea(userDebugLog);
      return;
    }

    // Filter the given log with only DEBUG statements
    if (Utils.isNotEmpty(log) && log.contains("DEBUG")) {
      userDebugLog = "";
      String[] newDateWithSperators = log.split("\\|");
      for (int index = 0; index < newDateWithSperators.length; index++) {
        String newDateWithSperator = newDateWithSperators[index];
        if (newDateWithSperator.contains("USER_DEBUG")) {
          String debugData = newDateWithSperators[index + 3];
          debugData = debugData.substring(0, debugData.lastIndexOf('\n'));
          userDebugLog += "\n" + debugData + "\n";
        }
      }
      // Save it for future uses
      selectedTreeItem.setData(TREEDATA_APEX_LOG_USER_DEBUG, userDebugLog);
      // Update the tab
      runTestComposite.setUserLogsTextArea(userDebugLog);
    }
  }

  /**
   * Initialize Tooling connection.
   *
   * @param forceProject
   * @throws ForceConnectionException
   * @throws ForceRemoteException
   */
  private void initializeConnection(ForceProject forceProject)
      throws ForceConnectionException, ForceRemoteException {
    if (toolingRESTConnection != null && toolingStubExt != null) return;

    toolingRESTConnection = new HTTPConnection(forceProject, TOOLING_ENDPOINT);
    toolingRESTConnection.initialize();
    toolingStubExt =
        ContainerDelegate.getInstance()
            .getFactoryLocator()
            .getToolingFactory()
            .getToolingStubExt(forceProject);
  }

  public void setProject(IProject project) {
    this.project = project;
    this.runTestComposite.setProject(project);
    this.runTestComposite.enableComposite();
  }

  public IProject getProject() {
    return project;
  }

  public RunTestViewComposite getRunTestComposite() {
    return runTestComposite;
  }

  @Override
  public void dispose() {
    super.dispose();
    getSite().getPage().removeSelectionListener(fPostSelectionListener);
  }

  @Override
  public void createPartControl(Composite parent) {
    runTestComposite = new RunTestViewComposite(parent, SWT.NONE, this);
    setPartName(VIEW_NAME);
    setTitleImage(getImage());

    UIUtils.setHelpContext(runTestComposite, this.getClass().getSimpleName());
  }

  @Override
  public void setFocus() {
    if (Utils.isNotEmpty(runTestComposite)) {
      runTestComposite.setFocus();
    }
  }

  private void setSelectionListener() {
    fPostSelectionListener =
        new ISelectionListener() {
          @Override
          public void selectionChanged(IWorkbenchPart part, ISelection selection) {
            project = getProjectService().getProject(selection);
            if (selection instanceof IStructuredSelection) {
              IStructuredSelection ss = (IStructuredSelection) selection;
              Object selElement = ss.getFirstElement();
              if (selElement instanceof IResource) {
                setProject(((IResource) selElement).getProject());
              }
            }
          }
        };
  }
}
 public CustomObjectComponentNode(String name) {
   super(name);
   image = ForceImages.get(ForceImages.CUSTOMOBJECT_NODE);
   retrieved = true;
 }
 @Override
 public Image getImage() {
   return ForceImages.get(ForceImages.APEX_GLOBAL_CLASS);
 }