Support for Dot graph via graphviz

PiperOrigin-RevId: 807965747

Author: ChinmayMadeshi

testing/src/main/java/dev/cel/testing/testrunner/CelCoverageIndex.java

@@ -14,6 +14,7 @@
 package dev.cel.testing.testrunner;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
+import static java.nio.charset.StandardCharsets.UTF_8;
 
 import com.google.auto.value.AutoValue;
 import com.google.common.collect.ImmutableList;
@@ -27,6 +28,8 @@
 import dev.cel.common.types.CelKind;
 import dev.cel.parser.CelUnparserVisitor;
 import dev.cel.runtime.CelEvaluationListener;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -43,6 +46,13 @@ final class CelCoverageIndex {
 
   private static final Logger logger = Logger.getLogger(CelCoverageIndex.class.getName());
 
+  private static final String DIGRAPH_HEADER = "digraph {\n";
+  private static final String UNCOVERED_NODE_STYLE = "color=\"indianred2\", style=filled";
+  private static final String PARTIALLY_COVERED_NODE_STYLE = "color=\"lightyellow\","
+      + "style=filled";
+  private static final String COMPLETELY_COVERED_NODE_STYLE = "color=\"lightgreen\","
+  + "style=filled";
+
   private CelAbstractSyntaxTree ast;
   private final ConcurrentHashMap<Long, NodeCoverageStats> nodeCoverageStatsMap =
       new ConcurrentHashMap<>();
@@ -68,24 +78,6 @@ public CelEvaluationListener newEvaluationListener() {
     return new EvaluationListener(nodeCoverageStatsMap);
   }
 
-  /** Returns the coverage report for the CEL test suite. */
-  public CoverageReport generateCoverageReport() {
-    CoverageReport.Builder reportBuilder =
-        CoverageReport.builder().setCelExpression(new CelUnparserVisitor(ast).unparse());
-    traverseAndCalculateCoverage(
-        CelNavigableAst.fromAst(ast).getRoot(), nodeCoverageStatsMap, true, "", reportBuilder);
-    CoverageReport report = reportBuilder.build();
-    logger.info("CEL Expression: " + report.celExpression());
-    logger.info("Nodes: " + report.nodes());
-    logger.info("Covered Nodes: " + report.coveredNodes());
-    logger.info("Branches: " + report.branches());
-    logger.info("Covered Boolean Outcomes: " + report.coveredBooleanOutcomes());
-    logger.info("Unencountered Nodes: \n" + String.join("\n", report.unencounteredNodes()));
-    logger.info("Unencountered Branches: \n" + String.join("\n",
-    report.unencounteredBranches()));
-    return report;
-  }
-
   /** A class for managing the coverage report for a CEL test suite. */
   @AutoValue
   public abstract static class CoverageReport {
@@ -103,12 +95,19 @@ public abstract static class CoverageReport {
 
     public abstract ImmutableList<String> unencounteredBranches();
 
+    public abstract String dotGraph();
+
+    // Currently only supported inside google3.
+    public abstract String graphUrl();
+
     public static Builder builder() {
       return new AutoValue_CelCoverageIndex_CoverageReport.Builder()
           .setNodes(0L)
           .setCoveredNodes(0L)
           .setBranches(0L)
           .setCelExpression("")
+          .setDotGraph("")
+          .setGraphUrl("")
           .setCoveredBooleanOutcomes(0L);
     }
 
@@ -133,6 +132,10 @@ public abstract static class Builder {
 
       public abstract Builder setCoveredBooleanOutcomes(long value);
 
+      public abstract Builder setDotGraph(String value);
+
+      public abstract Builder setGraphUrl(String value);
+
       public abstract ImmutableList.Builder<String> unencounteredNodesBuilder();
 
       public abstract ImmutableList.Builder<String> unencounteredBranchesBuilder();
@@ -153,6 +156,33 @@ public final Builder addUnencounteredBranches(String value) {
     }
   }
 
+  /** Returns the coverage report for the CEL test suite. */
+  public CoverageReport generateCoverageReport() {
+    CoverageReport.Builder reportBuilder =
+        CoverageReport.builder().setCelExpression(new CelUnparserVisitor(ast).unparse());
+    StringBuilder dotGraphBuilder = new StringBuilder(DIGRAPH_HEADER);
+    traverseAndCalculateCoverage(
+        CelNavigableAst.fromAst(ast).getRoot(),
+        nodeCoverageStatsMap,
+        true,
+        "",
+        reportBuilder,
+        dotGraphBuilder);
+    dotGraphBuilder.append("}");
+    String dotGraph = dotGraphBuilder.toString();
+    CoverageReport report = reportBuilder.setDotGraph(dotGraph).build();
+    logger.info("CEL Expression: " + report.celExpression());
+    logger.info("Nodes: " + report.nodes());
+    logger.info("Covered Nodes: " + report.coveredNodes());
+    logger.info("Branches: " + report.branches());
+    logger.info("Covered Boolean Outcomes: " + report.coveredBooleanOutcomes());
+    logger.info("Unencountered Nodes: \n" + String.join("\n", report.unencounteredNodes()));
+    logger.info("Unencountered Branches: \n" + String.join("\n",
+    report.unencounteredBranches()));
+    logger.info("Dot Graph: " + report.dotGraph());
+    return report;
+  }
+
   /** A class for managing the coverage stats for a CEL node. */
   @ThreadSafe
   private static final class NodeCoverageStats {
@@ -172,19 +202,32 @@ private void traverseAndCalculateCoverage(
       Map<Long, NodeCoverageStats> statsMap,
       boolean logUnencountered,
       String precedingTabs,
-      CoverageReport.Builder reportBuilder) {
+      CoverageReport.Builder reportBuilder,
+      StringBuilder dotGraphBuilder) {
     long nodeId = node.id();
     NodeCoverageStats stats = statsMap.getOrDefault(nodeId, new NodeCoverageStats());
     reportBuilder.setNodes(reportBuilder.nodes() + 1);
 
     boolean isInterestingBooleanNode = isInterestingBooleanNode(node, stats);
 
-    // Only unparse if the node is interesting (boolean node) and we need to log
-    // unencountered nodes.
-    String exprText = "";
-    if (isInterestingBooleanNode && logUnencountered) {
-      exprText = new CelUnparserVisitor(ast).unparse(node.expr());
+    String exprText = new CelUnparserVisitor(ast).unparse(node.expr());
+    String nodeCoverageStyle = UNCOVERED_NODE_STYLE;
+    if (stats.covered.get()) {
+      if (isInterestingBooleanNode) {
+        if (stats.hasTrueBranch.get() && stats.hasFalseBranch.get()) {
+          nodeCoverageStyle = COMPLETELY_COVERED_NODE_STYLE;
+        } else {
+          nodeCoverageStyle = PARTIALLY_COVERED_NODE_STYLE;
+        }
+      } else {
+        nodeCoverageStyle = COMPLETELY_COVERED_NODE_STYLE;
+      }
     }
+    String escapedExprText = escapeSpecialCharacters(exprText);
+    dotGraphBuilder.append(
+        String.format(
+            "%d [shape=record, %s, label=\"{<1> exprID: %d | <2> %s} | <3> %s\"];\n",
+            nodeId, nodeCoverageStyle, nodeId, kindToString(node), escapedExprText));
 
     // Update coverage for the current node and determine if we should continue logging
     // unencountered.
@@ -199,7 +242,9 @@ private void traverseAndCalculateCoverage(
     }
 
     for (CelNavigableExpr child : node.children().collect(toImmutableList())) {
-      traverseAndCalculateCoverage(child, statsMap, logUnencountered, precedingTabs, reportBuilder);
+      dotGraphBuilder.append(String.format("%d -> %d;\n", nodeId, child.id()));
+      traverseAndCalculateCoverage(
+          child, statsMap, logUnencountered, precedingTabs, reportBuilder, dotGraphBuilder);
     }
   }
 
@@ -293,4 +338,58 @@ public void callback(CelExpr celExpr, Object evaluationResult) {
       }
     }
   }
+
+  private String kindToString(CelNavigableExpr node) {
+    if (node.parent().isPresent()
+        && node.parent().get().expr().getKind().equals(ExprKind.Kind.COMPREHENSION)) {
+      CelExpr.CelComprehension comp = node.parent().get().expr().comprehension();
+      if (node.id() == comp.iterRange().id()) {
+        return "IterRange";
+      }
+      if (node.id() == comp.accuInit().id()) {
+        return "AccuInit";
+      }
+      if (node.id() == comp.loopCondition().id()) {
+        return "LoopCondition";
+      }
+      if (node.id() == comp.loopStep().id()) {
+        return "LoopStep";
+      }
+      if (node.id() == comp.result().id()) {
+        return "Result";
+      }
+    }
+
+    switch (node.getKind()) {
+      case CALL:
+        return "Call Node";
+      case COMPREHENSION:
+        return "Comprehension Node";
+      case IDENT:
+        return "Ident Node";
+      case LIST:
+        return "List Node";
+      case CONSTANT:
+        return "Literal Node";
+      case MAP:
+        return "Map Node";
+      case SELECT:
+        return "Select Node";
+      case STRUCT:
+        return "Struct Node";
+      default:
+        return "Unspecified Node";
+    }
+  }
+
+  private String escapeSpecialCharacters(String exprText) {
+    return exprText
+        .replace("\"", "\\\"")
+        .replace("\n", "\\n")
+        .replace("||", " \\| \\| ")
+        .replace("<", "\\<")
+        .replace(">", "\\>")
+        .replace("{", "\\{")
+        .replace("}", "\\}");
+  }
 }

testing/src/main/java/dev/cel/testing/testrunner/JUnitXmlReporter.java

@@ -233,6 +233,8 @@ private void addCoverageAttributes(
             XmlConstants.ATTR_INTERESTING_UNENCOUNTERED_BRANCH_PATHS,
             String.join("\n", coverageReport.unencounteredBranches()));
       }
+      currentSuite.setAttribute(
+          XmlConstants.ATTR_CEL_TEST_COVERAGE_GRAPH_URL, coverageReport.graphUrl());
     }
   }
 
@@ -284,5 +286,6 @@ private static final class XmlConstants {
     static final String ATTR_AST_BRANCH_COVERAGE = "Ast_Branch_Coverage";
     static final String ATTR_INTERESTING_UNENCOUNTERED_BRANCH_PATHS =
         "Interesting_Unencountered_Branch_Paths";
+    static final String ATTR_CEL_TEST_COVERAGE_GRAPH_URL = "Cel_Test_Coverage_Graph_URL";
   }
 }

testing/src/test/java/dev/cel/testing/testrunner/BUILD.bazel

@@ -97,7 +97,11 @@ java_test(
         "//:java_truth",
         "//bundle:cel",
         "//common:cel_ast",
+        "//common:options",
         "//common/types",
+        "//compiler:compiler_builder",
+        "//extensions",
+        "//parser:macro",
         "//runtime",
         "//runtime:evaluation_listener",
         "//testing/testrunner:cel_coverage_index",

testing/src/test/java/dev/cel/testing/testrunner/CelCoverageIndexTest.java

@@ -19,7 +19,11 @@
 import dev.cel.bundle.Cel;
 import dev.cel.bundle.CelFactory;
 import dev.cel.common.CelAbstractSyntaxTree;
+import dev.cel.common.CelOptions;
 import dev.cel.common.types.SimpleType;
+import dev.cel.compiler.CelCompiler;
+import dev.cel.extensions.CelExtensions;
+import dev.cel.parser.CelStandardMacro;
 import dev.cel.runtime.CelEvaluationListener;
 import dev.cel.runtime.CelRuntime;
 import dev.cel.testing.testrunner.CelCoverageIndex.CoverageReport;
@@ -90,4 +94,35 @@ public void getCoverageReport_partialCoverage_shortCircuit() throws Exception {
             "Expression ID 4 ('x > 1 && y > 1'): lacks 'true' coverage",
             "\t\tExpression ID 2 ('x > 1'): lacks 'true' coverage");
   }
+
+  @Test
+  public void getCoverageReport_comprehension_generatesDotGraph() throws Exception {
+    cel = CelFactory.standardCelBuilder().build();
+    CelCompiler compiler =
+        cel.toCompilerBuilder()
+            .setOptions(CelOptions.newBuilder().populateMacroCalls(true).build())
+            .setStandardMacros(CelStandardMacro.STANDARD_MACROS)
+            .addLibraries(CelExtensions.comprehensions())
+            .build();
+    ast = compiler.compile("[1, 2, 3].all(i, i % 2 != 0)").getAst();
+    program = cel.createProgram(ast);
+    CelCoverageIndex coverageIndex = new CelCoverageIndex();
+    coverageIndex.init(ast);
+    CelEvaluationListener listener = coverageIndex.newEvaluationListener();
+
+    program.trace(ImmutableMap.of(), listener);
+
+    CoverageReport report = coverageIndex.generateCoverageReport();
+    assertThat(report.dotGraph())
+        .contains("label=\"{<1> exprID: 1 | <2> IterRange} | <3> [1, 2, 3]\"");
+    assertThat(report.dotGraph()).contains("label=\"{<1> exprID: 12 | <2> AccuInit} | <3> true\"");
+    assertThat(report.dotGraph()).doesNotContain("red"); // No unencountered nodes.
+    assertThat(report.dotGraph())
+        .contains(
+            "label=\"{<1> exprID: 14 | <2> LoopCondition} | <3>"
+                + " @not_strictly_false(@result)\"");
+    assertThat(report.dotGraph())
+        .contains("label=\"{<1> exprID: 16 | <2> LoopStep} | <3> @result && i % 2 != 0\"");
+    assertThat(report.dotGraph()).contains("label=\"{<1> exprID: 17 | <2> Result} | <3> @result\"");
+  }
 }

testing/src/test/java/dev/cel/testing/testrunner/JUnitXmlReporterTest.java

@@ -178,6 +178,7 @@ public void testGenerateReport_coverageReport_withCoverage() throws IOException
             .addUnencounteredNodes("Node 2")
             .addUnencounteredBranches("Branch 1")
             .addUnencounteredBranches("Branch 2")
+            .setGraphUrl("http://graphviz/url")
             .build();
 
     when(context.getSuiteName()).thenReturn(SUITE_NAME);
@@ -202,6 +203,7 @@ public void testGenerateReport_coverageReport_withCoverage() throws IOException
                 + " name=\"TestSuiteName\" tests=\"1\" time=\"0.9\"><testsuite"
                 + " Ast_Branch_Coverage=\"50.00% (5 out of 10 branch outcomes covered)\""
                 + " Ast_Node_Coverage=\"100.00% (10 out of 10 nodes covered)\" Cel_Expr=\"\""
+                + " Cel_Test_Coverage_Graph_URL=\"http://graphviz/url\""
                 + " Interesting_Unencountered_Branch_Paths=\"Branch 1&#10;Branch 2\""
                 + " Interesting_Unencountered_Nodes=\"Node 1&#10;Node 2\" errors=\"0\""
                 + " failures=\"0\" name=\"TestClass1\" tests=\"1\" time=\"0.4\"><testcase"