org.argeo.slc.core/src/main/java/org/argeo/slc/unit/test/tree/UnitTestTreeUtil.java

   1 package org.argeo.slc.unit.test.tree;
   2
   3 import org.apache.commons.logging.Log;
   4 import org.apache.commons.logging.LogFactory;
   5
   6 import static junit.framework.Assert.assertEquals;
   7 import static junit.framework.Assert.assertNotNull;
   8 import static junit.framework.Assert.assertNull;
   9 import static junit.framework.Assert.fail;
  10 import static org.argeo.slc.unit.UnitUtils.assertDateSec;
  11
  12 import org.argeo.slc.core.structure.SimpleSElement;
  13 import org.argeo.slc.core.structure.tree.TreeSPath;
  14 import org.argeo.slc.core.test.SimpleResultPart;
  15 import org.argeo.slc.core.test.TestResultPart;
  16 import org.argeo.slc.core.test.tree.PartSubList;
  17 import org.argeo.slc.core.test.tree.TreeTestResult;
  18
  19 /** Utilities for unit tests. */
  20 public class UnitTestTreeUtil {
  21         private final static Log log = LogFactory.getLog(UnitTestTreeUtil.class);
  22
  23         public static void assertTreeTestResult(TreeTestResult expected,
  24                         TreeTestResult reached) {
  25                 assertEquals(expected.getUuid(), reached.getUuid());
  26                 assertDateSec(expected.getCloseDate(), reached.getCloseDate());
  27
  28                 assertEquals(expected.getResultParts().size(), reached.getResultParts()
  29                                 .size());
  30                 for (TreeSPath path : expected.getResultParts().keySet()) {
  31                         PartSubList lstExpected = expected.getResultParts().get(path);
  32                         PartSubList lstReached = expected.getResultParts().get(path);
  33                         if (lstReached == null) {
  34                                 fail("No result for path " + path);
  35                                 return;
  36                         }
  37                         assertPartSubList(lstExpected, lstReached);
  38                 }
  39
  40                 assertEquals(expected.getElements().size(), reached.getElements()
  41                                 .size());
  42                 for (TreeSPath path : expected.getElements().keySet()) {
  43                         // String nameExpected = expected.getElements().get(path);
  44                         // String nameReached = expected.getElements().get(path);
  45                         SimpleSElement elemExpected = (SimpleSElement) expected
  46                                         .getElements().get(path);
  47                         SimpleSElement elemReached = (SimpleSElement) expected
  48                                         .getElements().get(path);
  49                         assertNotNull(elemReached);
  50                         assertElements(elemExpected, elemReached);
  51                 }
  52
  53         }
  54
  55         public static void assertElements(SimpleSElement expected,
  56                         SimpleSElement reached) {
  57                 assertEquals(expected.getLabel(), reached.getLabel());
  58                 assertEquals(expected.getTags().size(), reached.getTags().size());
  59                 for (String tagName : expected.getTags().keySet()) {
  60                         String expectedTagValue = expected.getTags().get(tagName);
  61                         String reachedTagValue = reached.getTags().get(tagName);
  62                         assertNotNull(reachedTagValue);
  63                         assertEquals(expectedTagValue, reachedTagValue);
  64                 }
  65         }
  66
  67         public static void assertPartSubList(PartSubList lstExpected,
  68                         PartSubList lstReached) {
  69                 assertEquals(lstExpected.getParts().size(), lstReached.getParts()
  70                                 .size());
  71                 for (int i = 0; i < lstExpected.getParts().size(); i++) {
  72                         assertPart(lstExpected.getParts().get(i), lstReached.getParts()
  73                                         .get(i));
  74                 }
  75         }
  76
  77         /** Asserts one part of a tree test result */
  78         public static void assertPart(TreeTestResult testResult, String pathStr,
  79                         int index, Integer status, String message) {
  80                 TreeSPath path = new TreeSPath(pathStr);
  81                 PartSubList list = testResult.getResultParts().get(path);
  82                 if (list == null) {
  83                         fail("No result for path " + path);
  84                         return;
  85                 }
  86                 if (index >= list.getParts().size()) {
  87                         fail("Not enough parts.");
  88                 }
  89                 SimpleResultPart part = (SimpleResultPart) list.getParts().get(index);
  90                 assertPart(part, status, message, null, part.getTestRunUuid(), true);
  91         }
  92
  93         public static void assertPart(TestResultPart expected,
  94                         TestResultPart reached) {
  95                 String expectedTestRunUuid = null;
  96                 if (expected instanceof SimpleResultPart) {
  97                         expectedTestRunUuid = ((SimpleResultPart) expected)
  98                                         .getTestRunUuid();
  99                 }
 100
 101                 assertPart(reached, expected.getStatus(), expected.getMessage(),
 102                                 expected.getExceptionMessage(), expectedTestRunUuid, false);
 103         }
 104
 105         /** Assert one part of a tree test result. */
 106         private static void assertPart(TestResultPart part, Integer status,
 107                         String message, String exceptionDescription,
 108                         String expectedTestRunUuid, boolean skipExceptionMessage) {
 109                 assertEquals(status, part.getStatus());
 110
 111                 if (log.isTraceEnabled()) {
 112                         log.trace("Expected message:" + message);
 113                         log.trace("Reached message:" + part.getMessage());
 114                 }
 115                 assertEquals(message, part.getMessage());
 116                 if (!skipExceptionMessage) {
 117                         if (exceptionDescription == null) {
 118                                 assertNull(part.getExceptionMessage());
 119                         } else {
 120                                 if (log.isTraceEnabled()) {
 121                                         log.trace("Expected exception message:"
 122                                                         + exceptionDescription);
 123                                         log.trace("Reached exception message:"
 124                                                         + part.getExceptionMessage());
 125                                 }
 126
 127                                 assertEquals(exceptionDescription, part.getExceptionMessage());
 128                         }
 129                 }
 130
 131                 if (expectedTestRunUuid != null) {
 132                         SimpleResultPart reachedPart = (SimpleResultPart) part;
 133                         assertNotNull(reachedPart.getTestRunUuid());
 134                         assertEquals(expectedTestRunUuid, reachedPart.getTestRunUuid());
 135                 } else {
 136                         if (part instanceof SimpleResultPart) {
 137                                 assertNull(((SimpleResultPart) part).getTestRunUuid());
 138                         }
 139
 140                 }
 141
 142         }
 143
 144         /** Makes sure this is a singleton */
 145         private UnitTestTreeUtil() {
 146
 147         }
 148 }