feat: ouput the type of error node

arex-compare-core/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>arex-compare-parent</artifactId>
         <groupId>com.arextest</groupId>
-        <version>0.2.14</version>
+        <version>0.2.15</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

arex-compare-core/src/main/java/com/arextest/diff/handler/CompareHandler.java

@@ -37,6 +37,8 @@ public List<LogEntity> doHandler(RulesConfig rulesConfig, KeyComputeResponse key
     compareContext.logProcess = logProcess;
     compareContext.quickCompare = rulesConfig.isQuickCompare();
 
+    compareContext.simplifyLogEntity = rulesConfig.isSimplifyLogEntity();
+
     if (msgStructureFuture != null) {
       MutablePair<MsgStructure, MsgStructure> msgStructureMutablePair = msgStructureFuture.join();
       compareContext.baseMsgStructure = msgStructureMutablePair.getLeft();

arex-compare-core/src/main/java/com/arextest/diff/handler/log/register/LogRegister.java

@@ -185,6 +185,7 @@ private static LogEntity produceLog(Object obj1, Object obj2, int unmatchedType,
     LogEntity log =
         new LogEntity(obj1, obj2,
             getUnmatchedPair(unmatchedType, compareContext).buildListKeys(currentListKeys));
+    log.simplifyLogMsg(compareContext.simplifyLogEntity);
     log.getLogTag().setErrorType(errorType);
     return log;
   }

arex-compare-core/src/main/java/com/arextest/diff/model/CompareOptions.java

@@ -106,10 +106,17 @@ public class CompareOptions {
   private Boolean ipIgnore;
 
   /**
-   * This option is true, only compare the list elements which are existed in the baseMsg and testMsg
+   * This option is true, only compare the list elements which are existed in the baseMsg and
+   * testMsg
    */
   private Boolean onlyCompareExistListElements;
 
+  /**
+   * This option is true, the log entity message is simplified
+   * The baseMsg and testMsg are only output when leaf nodes
+   */
+  private Boolean simplifyLogEntity;
+
   public CompareOptions() {
   }
 
@@ -299,6 +306,11 @@ public CompareOptions putOnlyCompareExistListElements(Boolean onlyCompareExistLi
     return this;
   }
 
+  public CompareOptions putSimplifyLogEntity(Boolean simplifyLogEntity) {
+    this.simplifyLogEntity = simplifyLogEntity;
+    return this;
+  }
+
   public String getCategoryType() {
     return categoryType;
   }
@@ -366,4 +378,9 @@ public Boolean getIpIgnore() {
   public Boolean getOnlyCompareExistListElements() {
     return onlyCompareExistListElements;
   }
+
+  public Boolean getSimplifyLogEntity() {
+    return simplifyLogEntity;
+  }
+
 }

arex-compare-core/src/main/java/com/arextest/diff/model/GlobalOptions.java

@@ -64,10 +64,17 @@ public class GlobalOptions {
   private Boolean ipIgnore;
 
   /**
-   * This option is true, only compare the list elements which are existed in the baseMsg and testMsg
+   * This option is true, only compare the list elements which are existed in the baseMsg and
+   * testMsg
    */
   private Boolean onlyCompareExistListElements;
 
+  /**
+   * This option is true, the log entity message is simplified
+   * The baseMsg and testMsg are only output when leaf nodes
+   */
+  private Boolean simplifyLogEntity;
+
   public GlobalOptions() {
     this.nameToLower = false;
     this.nullEqualsEmpty = false;
@@ -132,6 +139,11 @@ public GlobalOptions putOnlyCompareExistListElements(Boolean onlyCompareExistLis
     return this;
   }
 
+  public GlobalOptions putSimplifyLogEntity(Boolean simplifyLogEntity) {
+    this.simplifyLogEntity = simplifyLogEntity;
+    return this;
+  }
+
   public String getPluginJarUrl() {
     return pluginJarUrl;
   }
@@ -176,4 +188,8 @@ public Boolean getOnlyCompareExistListElements() {
     return onlyCompareExistListElements;
   }
 
+  public Boolean getSimplifyLogEntity() {
+    return simplifyLogEntity;
+  }
+
 }

arex-compare-core/src/main/java/com/arextest/diff/model/RulesConfig.java

@@ -57,6 +57,8 @@ public class RulesConfig {
 
   private boolean onlyCompareExistListElements;
 
+  private boolean simplifyLogEntity;
+
   //region: inner processed class
   private List<List<ExpressionNodeEntity>> expressionExclusions;
 
@@ -227,6 +229,14 @@ public void setOnlyCompareExistListElements(boolean onlyCompareExistListElements
     this.onlyCompareExistListElements = onlyCompareExistListElements;
   }
 
+  public boolean isSimplifyLogEntity() {
+    return simplifyLogEntity;
+  }
+
+  public void setSimplifyLogEntity(boolean simplifyLogEntity) {
+    this.simplifyLogEntity = simplifyLogEntity;
+  }
+
   public List<List<ExpressionNodeEntity>> getExpressionExclusions() {
     return expressionExclusions;
   }

arex-compare-core/src/main/java/com/arextest/diff/model/compare/CompareContext.java

@@ -62,6 +62,8 @@ public class CompareContext {
 
   public byte ignoreReferenceNotFound = 0;
 
+  public boolean simplifyLogEntity = false;
+
   public CompareContext() {
     this.currentTraceLeft = new ArrayList<>();
     this.currentTraceRight = new ArrayList<>();

arex-compare-core/src/main/java/com/arextest/diff/model/log/LogEntity.java

@@ -1,13 +1,15 @@
 package com.arextest.diff.model.log;
 
 import com.arextest.diff.model.enumeration.UnmatchedType;
+import com.arextest.diff.model.log.LogTag.NodeErrorType;
 import com.arextest.diff.utils.ListUti;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.NullNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import java.io.Serializable;
 import java.util.List;
+import java.util.Optional;
 
 public class LogEntity implements Serializable {
 
@@ -40,9 +42,10 @@ public LogEntity() {
   }
 
   public LogEntity(Object baseValue, Object testValue, UnmatchedPairEntity pathPair) {
-    this.baseValue = valueToString(baseValue);
-    this.testValue = valueToString(testValue);
+    this.baseValue = baseValue;
+    this.testValue = testValue;
     this.pathPair = pathPair;
+    addNodeErrorType();
     processLogInfo(this.baseValue, this.testValue, pathPair.getUnmatchedType());
   }
 
@@ -111,30 +114,6 @@ public void setAddRefPkNodePathRight(String addRefPkNodePathRight) {
     this.addRefPkNodePathRight = addRefPkNodePathRight;
   }
 
-  // public String getPath() {
-  //     return path;
-  // }
-  //
-  // public void setPath(String path) {
-  //     this.path = path;
-  // }
-  //
-  // public String getLeftPath() {
-  //     return leftPath;
-  // }
-  //
-  // public void setLeftPath(String leftPath) {
-  //     this.leftPath = leftPath;
-  // }
-  //
-  // public String getRightPath() {
-  //     return rightPath;
-  // }
-  //
-  // public void setRightPath(String rightPath) {
-  //     this.rightPath = rightPath;
-  // }
-
   public int getWarn() {
     return warn;
   }
@@ -151,29 +130,9 @@ public void setLogTag(LogTag logTag) {
     this.logTag = logTag;
   }
 
-  // private void processPath() {
-  //     if (this.pathPair != null) {
-  //         if (this.pathPair.getLeftUnmatchedPath().size() >= this.pathPair.getRightUnmatchedPath().size()) {
-  //             this.path = ListUti.convertPathToStringForShow(this.pathPair.getLeftUnmatchedPath());
-  //         } else {
-  //             this.path = ListUti.convertPathToStringForShow(this.pathPair.getRightUnmatchedPath());
-  //         }
-  //         this.leftPath = ListUti.convertPathToStringForShow(this.pathPair.getLeftUnmatchedPath());
-  //         this.rightPath = ListUti.convertPathToStringForShow(this.pathPair.getRightUnmatchedPath());
-  //     }
-  // }
-
-  private String valueToString(Object value) {
-    if (value instanceof NullNode || value == null) {
-      return null;
-    }
-    if (value instanceof ObjectNode || value instanceof ArrayNode) {
-      return null;
-    }
-    if (value instanceof JsonNode) {
-      return ((JsonNode) value).asText();
-    }
-    return value.toString();
+  public void simplifyLogMsg(boolean simplifyLogEntity) {
+    this.baseValue = valueToString(baseValue, simplifyLogEntity);
+    this.testValue = valueToString(testValue, simplifyLogEntity);
   }
 
   private void processLogInfo(Object baseValue, Object testValue, int unmatchedType) {
@@ -231,6 +190,65 @@ private void processLogInfo(Object baseValue, Object testValue, int unmatchedTyp
     }
   }
 
+  private String valueToString(Object value, boolean simplifyLogEntity) {
+    if (value instanceof NullNode || value == null) {
+      return null;
+    }
+    if (value instanceof ObjectNode || value instanceof ArrayNode) {
+      return simplifyLogEntity ? null : value.toString();
+    }
+    if (value instanceof JsonNode) {
+      return ((JsonNode) value).asText();
+    }
+    return value.toString();
+  }
+
+  private void addNodeErrorType() {
+    NodeErrorType nodeErrorType = new NodeErrorType();
+    nodeErrorType.setBaseNodeType(judgeNodeErrorType(baseValue));
+    nodeErrorType.setTestNodeType(judgeNodeErrorType(testValue));
+    logTag.setNodeErrorType(nodeErrorType);
+  }
+
+  private String judgeNodeErrorType(Object value) {
+    if (value == null) {
+      return "null";
+    }
+    String simpleName = value.getClass().getSimpleName();
+    String type = convertJsonNodeToString(simpleName);
+    return Optional.ofNullable(type).orElse(simpleName);
+  }
+
+  private String convertJsonNodeToString(String simpleClassName) {
+    switch (simpleClassName) {
+      case "ObjectNode":
+        return "object";
+      case "ArrayNode":
+        return "array";
+      case "NullNode":
+        return "null";
+      case "TextNode":
+        return "string";
+      case "IntNode":
+        return "int";
+      case "LongNode":
+        return "long";
+      case "DoubleNode":
+        return "double";
+      case "FloatNode":
+        return "float";
+      case "BigIntegerNode":
+        return "bigInteger";
+      case "BigDecimalNode":
+        return "bigDecimal";
+      case "BooleanNode":
+        return "boolean";
+      default:
+        return null;
+    }
+  }
+
+
   @Override
   public String toString() {
     if (this.pathPair == null) {

arex-compare-core/src/main/java/com/arextest/diff/model/log/LogTag.java

@@ -9,6 +9,8 @@ public class LogTag implements Serializable {
    */
   private int errorType = 0;
 
+  private NodeErrorType nodeErrorType;
+
   public LogTag() {
   }
 
@@ -19,4 +21,37 @@ public int getErrorType() {
   public void setErrorType(int errorType) {
     this.errorType = errorType;
   }
+
+  public NodeErrorType getNodeErrorType() {
+    return nodeErrorType;
+  }
+
+  public void setNodeErrorType(NodeErrorType nodeErrorType) {
+    this.nodeErrorType = nodeErrorType;
+  }
+
+  public static class NodeErrorType {
+
+    private String baseNodeType;
+    private String testNodeType;
+
+    public NodeErrorType() {
+    }
+
+    public String getBaseNodeType() {
+      return baseNodeType;
+    }
+
+    public void setBaseNodeType(String baseNodeType) {
+      this.baseNodeType = baseNodeType;
+    }
+
+    public String getTestNodeType() {
+      return testNodeType;
+    }
+
+    public void setTestNodeType(String testNodeType) {
+      this.testNodeType = testNodeType;
+    }
+  }
 }

arex-compare-core/src/main/java/com/arextest/diff/utils/OptionsToRulesConvert.java

@@ -82,6 +82,9 @@ private static void globalOptionsToRules(GlobalOptions globalOptions, RulesConfi
     if (globalOptions.getOnlyCompareExistListElements() != null) {
       rulesConfig.setOnlyCompareExistListElements(globalOptions.getOnlyCompareExistListElements());
     }
+    if (globalOptions.getSimplifyLogEntity() != null) {
+      rulesConfig.setSimplifyLogEntity(globalOptions.getSimplifyLogEntity());
+    }
   }
 
   private static void optionsToRules(CompareOptions compareOptions, RulesConfig rulesConfig) {
@@ -131,6 +134,9 @@ private static void optionsToRules(CompareOptions compareOptions, RulesConfig ru
     if (compareOptions.getOnlyCompareExistListElements() != null) {
       rulesConfig.setOnlyCompareExistListElements(compareOptions.getOnlyCompareExistListElements());
     }
+    if (compareOptions.getSimplifyLogEntity() != null) {
+      rulesConfig.setSimplifyLogEntity(compareOptions.getSimplifyLogEntity());
+    }
   }
 
   private static Map<List<String>, List<TransformMethod>> decompressAndTransformConvert(