Add failed rows sample table to test case notifications (#24912)

* Load sampleData for TestCase entities when hydrating the ChangeEvent entity.

* Implement failedRowsSample table rendering across notification channels

* Improve table style in failedRowsSample notification

* Improve table style in Slack

* Improve table style on GChat

* Improve table style on MS Teams & refactor TeamsCardAssembler

* Enforce text limits from Handlebars template

* Fix failing tests

* Move table rendering to Handlebars custom helper

Author: manerow

openmetadata-service/pom.xml

@@ -1090,6 +1090,11 @@
       <artifactId>commonmark-ext-autolink</artifactId>
       <version>${commonmark.version}</version>
     </dependency>
+    <dependency>
+      <groupId>org.commonmark</groupId>
+      <artifactId>commonmark-ext-gfm-tables</artifactId>
+      <version>${commonmark.version}</version>
+    </dependency>
     <!-- Flexmark HTML to Markdown Converter -->
     <dependency>
       <groupId>com.vladsch.flexmark</groupId>

openmetadata-service/src/main/java/org/openmetadata/service/apps/bundles/changeEvent/msteams/TeamsMessage.java

@@ -127,6 +127,9 @@ public static class TextBlock implements TeamsMessage.BodyItem {
 
     @JsonProperty("fontType")
     private String fontType;
+
+    @JsonProperty("isSubtle")
+    private Boolean isSubtle;
   }
 
   @Getter
@@ -143,6 +146,12 @@ public static class Container implements TeamsMessage.BodyItem {
 
     @JsonProperty("items")
     private List<TeamsMessage.BodyItem> items;
+
+    @JsonProperty("bleed")
+    private Boolean bleed;
+
+    @JsonProperty("spacing")
+    private String spacing;
   }
 
   @Getter
@@ -171,6 +180,79 @@ public static class Fact {
     private String value;
   }
 
+  @Getter
+  @Setter
+  @AllArgsConstructor
+  @NoArgsConstructor
+  @Builder
+  public static class Table implements TeamsMessage.BodyItem {
+    @JsonProperty("type")
+    private String type;
+
+    @JsonProperty("gridStyle")
+    private String gridStyle;
+
+    @JsonProperty("firstRowAsHeader")
+    private Boolean firstRowAsHeader;
+
+    @JsonProperty("columns")
+    private List<TeamsMessage.TableColumnDefinition> columns;
+
+    @JsonProperty("rows")
+    private List<TeamsMessage.TableRow> rows;
+
+    @JsonProperty("spacing")
+    private String spacing;
+
+    @JsonProperty("showGridLines")
+    private Boolean showGridLines;
+
+    @JsonProperty("separator")
+    private Boolean separator;
+
+    @JsonProperty("horizontalCellContentAlignment")
+    private String horizontalCellContentAlignment;
+  }
+
+  @Getter
+  @Setter
+  @AllArgsConstructor
+  @NoArgsConstructor
+  @Builder
+  public static class TableColumnDefinition {
+    @JsonProperty("width")
+    private Integer width;
+  }
+
+  @Getter
+  @Setter
+  @AllArgsConstructor
+  @NoArgsConstructor
+  @Builder
+  public static class TableRow {
+    @JsonProperty("type")
+    private String type;
+
+    @JsonProperty("cells")
+    private List<TeamsMessage.TableCell> cells;
+
+    @JsonProperty("style")
+    private String style;
+  }
+
+  @Getter
+  @Setter
+  @AllArgsConstructor
+  @NoArgsConstructor
+  @Builder
+  public static class TableCell {
+    @JsonProperty("type")
+    private String type;
+
+    @JsonProperty("items")
+    private List<TeamsMessage.BodyItem> items;
+  }
+
   // Interface for Body Items
   public interface BodyItem {}
 }

openmetadata-service/src/main/java/org/openmetadata/service/formatter/util/FormatterUtil.java

@@ -47,6 +47,7 @@
 import org.openmetadata.schema.type.EventType;
 import org.openmetadata.schema.type.FieldChange;
 import org.openmetadata.schema.type.Include;
+import org.openmetadata.schema.type.TableData;
 import org.openmetadata.schema.utils.JsonUtils;
 import org.openmetadata.service.Entity;
 import org.openmetadata.service.formatter.decorators.MessageDecorator;
@@ -332,6 +333,13 @@ private static ChangeEvent getChangeEventForEntityTimeSeries(
           (TestCaseRepository) Entity.getEntityRepository(TEST_CASE);
       testCaseRepository.setInheritedFields(
           testCase, new EntityUtil.Fields(testCaseRepository.getAllowedFields()));
+      // Load failedRowsSample
+      try {
+        TableData failedRowsSample = testCaseRepository.getSampleData(testCase, false);
+        testCase.setFailedRowsSample(failedRowsSample);
+      } catch (Exception e) {
+        LOG.info("Failed to load failedRowsSample: {}", e.getMessage());
+      }
       ChangeEvent changeEvent =
           getChangeEvent(
               updateBy,

openmetadata-service/src/main/java/org/openmetadata/service/notifications/channels/HtmlSanitizer.java

@@ -10,12 +10,16 @@ public final class HtmlSanitizer {
   private static final PolicyFactory EMAIL_POLICY =
       new HtmlPolicyBuilder()
           .allowElements("p", "br", "div", "span")
+          .allowAttributes("style", "class")
+          .onElements("div", "pre", "code")
           .allowElements("ul", "ol", "li")
           .allowElements("strong", "b", "em", "i", "u", "s", "del")
           .allowElements("pre", "code")
           .allowElements("blockquote")
           .allowElements("h1", "h2", "h3", "h4", "h5", "h6")
           .allowElements("table", "thead", "tbody", "tr", "td", "th")
+          .allowAttributes("class")
+          .onElements("table", "thead", "tbody", "tr", "td", "th")
           .allowElements("a")
           .allowAttributes("href", "title")
           .onElements("a")

openmetadata-service/src/main/java/org/openmetadata/service/notifications/channels/HtmlToMarkdownAdapter.java

@@ -8,12 +8,15 @@
 import com.vladsch.flexmark.html2md.converter.HtmlNodeRendererHandler;
 import com.vladsch.flexmark.util.data.DataHolder;
 import com.vladsch.flexmark.util.data.MutableDataSet;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 import lombok.extern.slf4j.Slf4j;
 import org.jetbrains.annotations.NotNull;
 import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
 
 @Slf4j
 public class HtmlToMarkdownAdapter implements TemplateFormatAdapter {
@@ -22,6 +25,7 @@ public class HtmlToMarkdownAdapter implements TemplateFormatAdapter {
       FlexmarkHtmlConverter.builder(new MutableDataSet())
           .htmlNodeRendererFactory(new CodeAndPreRenderer.Factory())
           .htmlNodeRendererFactory(new InlineElementRenderer.Factory())
+          .htmlNodeRendererFactory(new TableRenderer.Factory())
           .build();
   private static final HtmlToMarkdownAdapter INSTANCE = new HtmlToMarkdownAdapter();
 
@@ -185,4 +189,159 @@ public HtmlNodeRenderer apply(DataHolder options) {
       }
     }
   }
+
+  /** Handles HTML tables and converts them to GFM-style Markdown tables. */
+  static class TableRenderer implements HtmlNodeRenderer {
+    private static final int MAX_COL_WIDTH = 50;
+
+    TableRenderer(DataHolder options) {}
+
+    @Override
+    public @NotNull Set<HtmlNodeRendererHandler<?>> getHtmlNodeRendererHandlers() {
+      return new HashSet<>(
+          Arrays.asList(
+              new HtmlNodeRendererHandler<>("div", Element.class, this::renderDiv),
+              new HtmlNodeRendererHandler<>("table", Element.class, this::renderTable),
+              new HtmlNodeRendererHandler<>("thead", Element.class, this::skipElement),
+              new HtmlNodeRendererHandler<>("tbody", Element.class, this::skipElement),
+              new HtmlNodeRendererHandler<>("tr", Element.class, this::skipElement),
+              new HtmlNodeRendererHandler<>("th", Element.class, this::skipElement),
+              new HtmlNodeRendererHandler<>("td", Element.class, this::skipElement)));
+    }
+
+    private void skipElement(Element elem, HtmlNodeConverterContext ctx, HtmlMarkdownWriter out) {
+      // Skip - handled by table renderer
+    }
+
+    /** Handles div elements, extracting and rendering any nested tables as GFM markdown. */
+    private void renderDiv(Element div, HtmlNodeConverterContext ctx, HtmlMarkdownWriter out) {
+      Element nestedTable = div.selectFirst("table");
+      if (nestedTable != null) {
+        renderTable(nestedTable, ctx, out);
+      } else {
+        ctx.renderChildren(div, false, null);
+      }
+    }
+
+    private void renderTable(Element table, HtmlNodeConverterContext ctx, HtmlMarkdownWriter out) {
+      List<List<String>> headerRows = new ArrayList<>();
+      List<List<String>> bodyRows = new ArrayList<>();
+
+      // Extract header rows from thead
+      Element thead = table.selectFirst("thead");
+      if (thead != null) {
+        for (Element tr : thead.select("> tr")) {
+          List<String> row = extractRowCells(tr, "th", "td");
+          if (!row.isEmpty()) headerRows.add(row);
+        }
+      }
+
+      // Extract body rows from tbody or directly from table
+      Element tbody = table.selectFirst("tbody");
+      Elements bodyTrs = tbody != null ? tbody.select("> tr") : table.select("> tr");
+      for (Element tr : bodyTrs) {
+        // Skip rows that are inside thead
+        if (tr.parent() != null && "thead".equalsIgnoreCase(tr.parent().tagName())) continue;
+        List<String> row = extractRowCells(tr, "td", "th");
+        if (!row.isEmpty()) bodyRows.add(row);
+      }
+
+      // If no explicit header, use first body row as header
+      if (headerRows.isEmpty() && !bodyRows.isEmpty()) {
+        // Check if first row might be headers (all th cells)
+        Element firstTr =
+            tbody != null ? tbody.selectFirst("> tr") : table.selectFirst("> tr:not(thead > tr)");
+        if (firstTr != null && !firstTr.select("> th").isEmpty()) {
+          headerRows.add(bodyRows.removeFirst());
+        }
+      }
+
+      // Determine column count
+      int colCount = 0;
+      for (List<String> row : headerRows) colCount = Math.max(colCount, row.size());
+      for (List<String> row : bodyRows) colCount = Math.max(colCount, row.size());
+
+      if (colCount == 0) return;
+
+      // Calculate column widths
+      int[] colWidths = new int[colCount];
+      for (int i = 0; i < colCount; i++) colWidths[i] = 3; // minimum width
+
+      for (List<String> row : headerRows) {
+        for (int i = 0; i < row.size(); i++) {
+          colWidths[i] = Math.max(colWidths[i], Math.min(row.get(i).length(), MAX_COL_WIDTH));
+        }
+      }
+      for (List<String> row : bodyRows) {
+        for (int i = 0; i < row.size(); i++) {
+          colWidths[i] = Math.max(colWidths[i], Math.min(row.get(i).length(), MAX_COL_WIDTH));
+        }
+      }
+
+      out.blankLine();
+
+      // Render header
+      if (!headerRows.isEmpty()) {
+        for (List<String> headerRow : headerRows) {
+          renderRow(out, headerRow, colWidths, colCount);
+        }
+      } else {
+        // Create generic headers
+        List<String> genericHeaders = new ArrayList<>();
+        for (int i = 0; i < colCount; i++) genericHeaders.add("Column " + (i + 1));
+        renderRow(out, genericHeaders, colWidths, colCount);
+      }
+
+      // Render separator
+      out.append("|");
+      for (int i = 0; i < colCount; i++) {
+        out.append("-".repeat(colWidths[i] + 2)).append("|");
+      }
+      out.line();
+
+      // Render body
+      for (List<String> row : bodyRows) {
+        renderRow(out, row, colWidths, colCount);
+      }
+
+      out.blankLine();
+    }
+
+    private List<String> extractRowCells(Element tr, String primary, String secondary) {
+      List<String> cells = new ArrayList<>();
+      Elements primaryCells = tr.select("> " + primary);
+      Elements secondaryCells = tr.select("> " + secondary);
+      Elements allCells = primaryCells.isEmpty() ? secondaryCells : primaryCells;
+
+      for (Element cell : allCells) {
+        String text = cell.text().replace("|", "\\|").replace("\n", " ").trim();
+        cells.add(text);
+      }
+      return cells;
+    }
+
+    private void renderRow(HtmlMarkdownWriter out, List<String> cells, int[] colWidths, int colCt) {
+      out.append("|");
+      for (int i = 0; i < colCt; i++) {
+        String cell = i < cells.size() ? cells.get(i) : "";
+        if (cell.length() > colWidths[i]) {
+          cell = cell.substring(0, colWidths[i] - 3) + "...";
+        }
+        out.append(" ").append(padRight(cell, colWidths[i])).append(" |");
+      }
+      out.line();
+    }
+
+    private String padRight(String s, int width) {
+      if (s.length() >= width) return s;
+      return s + " ".repeat(width - s.length());
+    }
+
+    static class Factory implements HtmlNodeRendererFactory {
+      @Override
+      public HtmlNodeRenderer apply(DataHolder options) {
+        return new TableRenderer(options);
+      }
+    }
+  }
 }

openmetadata-service/src/main/java/org/openmetadata/service/notifications/channels/MarkdownParser.java

@@ -5,6 +5,7 @@
 import org.commonmark.Extension;
 import org.commonmark.ext.autolink.AutolinkExtension;
 import org.commonmark.ext.gfm.strikethrough.StrikethroughExtension;
+import org.commonmark.ext.gfm.tables.TablesExtension;
 import org.commonmark.node.Node;
 import org.commonmark.parser.Parser;
 
@@ -18,7 +19,8 @@ private MarkdownParser() {}
 
   static {
     List<Extension> extensions =
-        List.of(AutolinkExtension.create(), StrikethroughExtension.create());
+        List.of(
+            AutolinkExtension.create(), StrikethroughExtension.create(), TablesExtension.create());
     PARSER = Parser.builder().extensions(extensions).build();
   }