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                 // Attributes
  29                 assertEquals(expected.getAttributes().size(), reached.getAttributes()
  30                                 .size());
  31                 for (String key : expected.getAttributes().keySet()) {
  32                         String expectedValue = expected.getAttributes().get(key);
  33                         String reachedValue = reached.getAttributes().get(key);
  34                         assertNotNull(reachedValue);
  35                         assertEquals(expectedValue, reachedValue);
  36                 }
  37
  38                 // Result parts
  39                 assertEquals(expected.getResultParts().size(), reached.getResultParts()
  40                                 .size());
  41                 for (TreeSPath path : expected.getResultParts().keySet()) {
  42                         PartSubList lstExpected = expected.getResultParts().get(path);
  43                         PartSubList lstReached = expected.getResultParts().get(path);
  44                         if (lstReached == null) {
  45                                 fail("No result for path " + path);
  46                                 return;
  47                         }
  48                         assertPartSubList(lstExpected, lstReached);
  49                 }
  50
  51                 // Elements
  52                 assertEquals(expected.getElements().size(), reached.getElements()
  53                                 .size());
  54                 for (TreeSPath path : expected.getElements().keySet()) {
  55                         // String nameExpected = expected.getElements().get(path);
  56                         // String nameReached = expected.getElements().get(path);
  57                         SimpleSElement elemExpected = (SimpleSElement) expected
  58                                         .getElements().get(path);
  59                         SimpleSElement elemReached = (SimpleSElement) expected
  60                                         .getElements().get(path);
  61                         assertNotNull(elemReached);
  62                         assertElements(elemExpected, elemReached);
  63                 }
  64
  65         }
  66
  67         public static void assertElements(SimpleSElement expected,
  68                         SimpleSElement reached) {
  69                 assertEquals(expected.getLabel(), reached.getLabel());
  70                 assertEquals(expected.getTags().size(), reached.getTags().size());
  71                 for (String tagName : expected.getTags().keySet()) {
  72                         String expectedTagValue = expected.getTags().get(tagName);
  73                         String reachedTagValue = reached.getTags().get(tagName);
  74                         assertNotNull(reachedTagValue);
  75                         assertEquals(expectedTagValue, reachedTagValue);
  76                 }
  77         }
  78
  79         public static void assertPartSubList(PartSubList lstExpected,
  80                         PartSubList lstReached) {
  81                 assertEquals(lstExpected.getParts().size(), lstReached.getParts()
  82                                 .size());
  83                 for (int i = 0; i < lstExpected.getParts().size(); i++) {
  84                         assertPart(lstExpected.getParts().get(i), lstReached.getParts()
  85                                         .get(i));
  86                 }
  87         }
  88
  89         /** Asserts one part of a tree test result */
  90         public static void assertPart(TreeTestResult testResult, String pathStr,
  91                         int index, Integer status, String message) {
  92                 TreeSPath path = new TreeSPath(pathStr);
  93                 PartSubList list = testResult.getResultParts().get(path);
  94                 if (list == null) {
  95                         fail("No result for path " + path);
  96                         return;
  97                 }
  98                 if (index >= list.getParts().size()) {
  99                         fail("Not enough parts.");
 100                 }
 101                 SimpleResultPart part = (SimpleResultPart) list.getParts().get(index);
 102                 assertPart(part, status, message, null, part.getTestRunUuid(), true);
 103         }
 104
 105         public static void assertPart(TestResultPart expected,
 106                         TestResultPart reached) {
 107                 String expectedTestRunUuid = null;
 108                 if (expected instanceof SimpleResultPart) {
 109                         expectedTestRunUuid = ((SimpleResultPart) expected)
 110                                         .getTestRunUuid();
 111                 }
 112
 113                 assertPart(reached, expected.getStatus(), expected.getMessage(),
 114                                 expected.getExceptionMessage(), expectedTestRunUuid, false);
 115         }
 116
 117         /** Assert one part of a tree test result. */
 118         private static void assertPart(TestResultPart part, Integer status,
 119                         String message, String exceptionDescription,
 120                         String expectedTestRunUuid, boolean skipExceptionMessage) {
 121                 assertEquals(status, part.getStatus());
 122
 123                 if (message != null) {
 124                         if (log.isTraceEnabled()) {
 125                                 log.trace("Expected message:" + message);
 126                                 log.trace("Reached message:" + part.getMessage());
 127                         }
 128                         assertEquals(message, part.getMessage());
 129                 }
 130
 131                 if (!skipExceptionMessage) {
 132                         if (exceptionDescription == null) {
 133                                 assertNull(part.getExceptionMessage());
 134                         } else {
 135                                 if (log.isTraceEnabled()) {
 136                                         log.trace("Expected exception message:"
 137                                                         + exceptionDescription);
 138                                         log.trace("Reached exception message:"
 139                                                         + part.getExceptionMessage());
 140                                 }
 141
 142                                 assertEquals(exceptionDescription, part.getExceptionMessage());
 143                         }
 144                 }
 145
 146                 if (expectedTestRunUuid != null) {
 147                         SimpleResultPart reachedPart = (SimpleResultPart) part;
 148                         assertNotNull(reachedPart.getTestRunUuid());
 149                         assertEquals(expectedTestRunUuid, reachedPart.getTestRunUuid());
 150                 } else {
 151                         if (part instanceof SimpleResultPart) {
 152                                 assertNull(((SimpleResultPart) part).getTestRunUuid());
 153                         }
 154
 155                 }
 156
 157         }
 158
 159         /** Makes sure this is a singleton */
 160         private UnitTestTreeUtil() {
 161
 162         }
 163 }