runtime/org.argeo.slc.support.simple/src/main/java/org/argeo/slc/unit/test/tree/UnitTestTreeUtil.java

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