runtime/org.argeo.slc.launcher/src/test/java/org/argeo/slc/lib/detached/DetachedCastorTest.java

   1 package org.argeo.slc.lib.detached;
   2
   3 import java.util.Enumeration;
   4 import java.util.Properties;
   5
   6 import org.apache.commons.logging.Log;
   7 import org.apache.commons.logging.LogFactory;
   8 import org.argeo.slc.detached.DetachedAnswer;
   9 import org.argeo.slc.detached.DetachedRequest;
  10 import org.argeo.slc.detached.DetachedXmlConverter;
  11 import org.argeo.slc.detached.DetachedXmlConverterCompat;
  12 import org.argeo.slc.unit.AbstractSpringTestCase;
  13 import org.argeo.slc.unit.UnitXmlUtils;
  14 import org.springframework.xml.transform.StringResult;
  15 import org.springframework.xml.transform.StringSource;
  16 import org.springframework.xml.validation.XmlValidator;
  17
  18 public class DetachedCastorTest extends AbstractSpringTestCase {
  19         private final Log log = LogFactory.getLog(getClass());
  20
  21         private DetachedXmlConverter converter = null;
  22         private XmlValidator validator = null;
  23         private DetachedXmlConverter converterCompat = null;
  24
  25         public void setUp() {
  26                 converter = getBean("slcDefault.detached.xmlConverterCastor");
  27                 validator = getBean("slcDefault.detached.xml.xsdValidator");
  28                 converterCompat = new DetachedXmlConverterCompat();
  29         }
  30
  31         public void testRequest() throws Exception {
  32                 DetachedRequest request = createTestRequest();
  33
  34                 StringResult result = new StringResult();
  35                 converter.marshallCommunication(request, result);
  36                 String xml = result.toString();
  37                 log.debug(xml + "\n");
  38
  39                 UnitXmlUtils.assertXmlValidation(validator, new StringSource(xml));
  40                 DetachedRequest requestUnm = (DetachedRequest) converter
  41                                 .unmarshallCommunication(new StringSource(xml));
  42                 assertDetachedRequest(request, requestUnm);
  43         }
  44
  45         public void testRequestCompat() throws Exception {
  46                 DetachedRequest request = createTestRequest();
  47
  48                 StringResult result = new StringResult();
  49                 converter.marshallCommunication(request, result);
  50                 String xml = result.toString();
  51                 log.debug(xml + "\n");
  52
  53                 UnitXmlUtils.assertXmlValidation(validator, new StringSource(xml));
  54                 DetachedRequest requestUnm = (DetachedRequest) converterCompat
  55                                 .unmarshallCommunication(new StringSource(xml));
  56                 assertDetachedRequest(request, requestUnm);
  57         }
  58
  59         public void testAnswer() throws Exception {
  60                 DetachedAnswer answer = createTestAnswer();
  61                 StringResult result = new StringResult();
  62                 converter.marshallCommunication(answer, result);
  63                 String xml = result.toString();
  64                 log.debug(xml + "\n");
  65
  66                 UnitXmlUtils.assertXmlValidation(validator, new StringSource(xml));
  67                 DetachedAnswer answerUnm = (DetachedAnswer) converter
  68                                 .unmarshallCommunication(new StringSource(xml));
  69                 assertDetachedAnswer(answer, answerUnm);
  70         }
  71
  72         public void testAnswerCompat() throws Exception {
  73                 DetachedAnswer answer = createTestAnswer();
  74                 StringResult result = new StringResult();
  75                 converterCompat.marshallCommunication(answer, result);
  76                 String xml = result.toString();
  77                 log.debug(xml + "\n");
  78
  79                 UnitXmlUtils.assertXmlValidation(validator, new StringSource(xml));
  80                 DetachedAnswer answerUnm = (DetachedAnswer) converter
  81                                 .unmarshallCommunication(new StringSource(xml));
  82                 assertDetachedAnswer(answer, answerUnm);
  83         }
  84
  85         public static DetachedRequest createTestRequest() {
  86                 DetachedRequest request = new DetachedRequest();
  87                 request.setUuid("12345");
  88                 request.setPath("/root/test");
  89                 request.setRef("testRef");
  90                 Properties properties = new Properties();
  91                 properties.setProperty("key1", "value1");
  92                 properties.setProperty("key2", "value2");
  93                 request.setProperties(properties);
  94                 return request;
  95         }
  96
  97         public static DetachedAnswer createTestAnswer() {
  98                 DetachedAnswer answer = new DetachedAnswer();
  99                 answer.setUuid("12345");
 100                 answer.setStatus(DetachedAnswer.PROCESSED);
 101                 answer.setLog("my log\nline break.");
 102                 Properties properties = new Properties();
 103                 properties.setProperty("key1", "value1");
 104                 properties.setProperty("key2", "value2");
 105                 answer.setProperties(properties);
 106                 return answer;
 107         }
 108
 109         public static void assertDetachedRequest(DetachedRequest expected,
 110                         DetachedRequest reached) {
 111                 assertEquals(expected.getUuid(), reached.getUuid());
 112                 assertEquals(expected.getPath(), reached.getPath());
 113                 assertEquals(expected.getRef(), reached.getRef());
 114                 Properties expectedProps = expected.getProperties();
 115                 Properties reachedProps = reached.getProperties();
 116                 assertEquals(expectedProps.size(), reachedProps.size());
 117                 Enumeration<Object> keys = expectedProps.keys();
 118                 while (keys.hasMoreElements()) {
 119                         String key = (String) keys.nextElement();
 120                         assertTrue(reachedProps.containsKey(key));
 121                         assertEquals(expectedProps.getProperty(key), reachedProps
 122                                         .getProperty(key));
 123                 }
 124         }
 125
 126         public static void assertDetachedAnswer(DetachedAnswer expected,
 127                         DetachedAnswer reached) {
 128                 assertEquals(expected.getUuid(), reached.getUuid());
 129                 assertEquals(expected.getStatus(), reached.getStatus());
 130                 assertEquals(expected.getLog(), reached.getLog());
 131                 Properties expectedProps = expected.getProperties();
 132                 Properties reachedProps = reached.getProperties();
 133                 assertEquals(expectedProps.size(), reachedProps.size());
 134                 Enumeration<Object> keys = expectedProps.keys();
 135                 while (keys.hasMoreElements()) {
 136                         String key = (String) keys.nextElement();
 137                         assertTrue(reachedProps.containsKey(key));
 138                         assertEquals(expectedProps.getProperty(key), reachedProps
 139                                         .getProperty(key));
 140                 }
 141         }
 142 }