git.aero2k.de Git - tmp/jakarta-migration.git/blob

   1 package org.collectionspace.services.IntegrationTests.xmlreplay;
   2
   3 import org.apache.commons.cli.*;
   4
   5 import org.apache.commons.io.FileUtils;
   6 import org.apache.commons.jexl2.JexlEngine;
   7 import org.collectionspace.services.common.api.Tools;
   8 import org.dom4j.*;
   9 import org.dom4j.io.SAXReader;
  10
  11 import java.io.*;
  12 import java.util.*;
  13
  14 /**  This class is used to replay a request to the Services layer, by sending the XML payload
  15  *   in an appropriate Multipart request.
  16  *   See example usage in calling class XmlReplayTest in services/IntegrationTests, and also in main() in this class.
  17  *   @author Laramie Crocker
  18  */
  19 @SuppressWarnings("unchecked")
  20 public class XmlReplay {
  21
  22     public XmlReplay(String basedir, String reportsDir){
  23         this.basedir = basedir;
  24         this.serviceResultsMap = createResultsMap();
  25         this.reportsList = new ArrayList<String>();
  26         this.reportsDir = reportsDir;
  27     }
  28
  29     public static final String DEFAULT_CONTROL = "xml-replay-control.xml";
  30     public static final String DEFAULT_MASTER_CONTROL = "xml-replay-master.xml";
  31     public static final String DEFAULT_DEV_MASTER_CONTROL = "dev-master.xml";
  32         private static final int MAX_REATTEMPTS = 10;
  33         private static final String REATTEMPT_KEY = "REATTEMPT_KEY";
  34
  35     private String reportsDir = "";
  36     public String getReportsDir(){
  37         return reportsDir;
  38     }
  39     private String basedir = ".";  //set from constructor.
  40     public String getBaseDir(){
  41         return basedir;
  42     }
  43
  44     private String controlFileName = DEFAULT_CONTROL;
  45     public String getControlFileName() {
  46         return controlFileName;
  47     }
  48     public void setControlFileName(String controlFileName) {
  49         this.controlFileName = controlFileName;
  50     }
  51
  52     private String protoHostPort = "";
  53     public String getProtoHostPort() {
  54         return protoHostPort;
  55     }
  56     public void setProtoHostPort(String protoHostPort) {
  57         this.protoHostPort = protoHostPort;
  58     }
  59
  60     private boolean autoDeletePOSTS = true;
  61     public boolean isAutoDeletePOSTS() {
  62         return autoDeletePOSTS;
  63     }
  64     public void setAutoDeletePOSTS(boolean autoDeletePOSTS) {
  65         this.autoDeletePOSTS = autoDeletePOSTS;
  66     }
  67
  68     private Dump dump;
  69     public Dump getDump() {
  70         return dump;
  71     }
  72     public void setDump(Dump dump) {
  73         this.dump = dump;
  74     }
  75
  76     AuthsMap defaultAuthsMap;
  77     public AuthsMap getDefaultAuthsMap(){
  78         return defaultAuthsMap;
  79     }
  80     public void setDefaultAuthsMap(AuthsMap authsMap){
  81         defaultAuthsMap = authsMap;
  82     }
  83
  84     private Map<String, ServiceResult> serviceResultsMap;
  85     public Map<String, ServiceResult> getServiceResultsMap(){
  86         return serviceResultsMap;
  87     }
  88     public static Map<String, ServiceResult> createResultsMap(){
  89         return new HashMap<String, ServiceResult>();
  90     }
  91
  92     private List<String> reportsList;
  93     public  List<String> getReportsList(){
  94         return reportsList;
  95     }
  96
  97     @Override
  98         public String toString(){
  99         return "XmlReplay{"+this.basedir+", "+this.defaultAuthsMap+", "+this.dump+", "+this.reportsDir+'}';
 100     }
 101
 102     // ============== METHODS ===========================================================
 103
 104     /** Optional information method: call this method after instantiating this class using the constructor XmlReplay(String), which sets the basedir.  Then you
 105      *   pass in your relative masterFilename to that basedir to this method, which will return true if the file is readable, valid xml, etc.
 106      *   Do this in preference to  just seeing if File.exists(), because there are rules to finding the file relative to the maven test dir, yada, yada.
 107      *   This method makes it easy to have a development test file that you don't check in, so that dev tests can be missing gracefully, etc.
 108      */
 109     public boolean masterConfigFileExists(String masterFilename){
 110         try {
 111             org.dom4j.Document doc = openMasterConfigFile(masterFilename);
 112             if (doc == null){
 113                 return false;
 114             }
 115             return true;
 116         } catch (Throwable t){
 117             return false;
 118         }
 119     }
 120
 121     public org.dom4j.Document openMasterConfigFile(String masterFilename) throws FileNotFoundException {
 122         String fullPath = Tools.glue(basedir, "/", masterFilename);
 123         File f = new File(fullPath);
 124         if (!f.exists()){
 125             return null;
 126         }
 127         org.dom4j.Document document = getDocument(fullPath); //will check full path first, then checks relative to PWD.
 128         if (document == null){
 129             throw new FileNotFoundException("XmlReplay master control file ("+masterFilename+") not found in basedir: "+basedir+". Exiting test.");
 130         }
 131         return document;
 132     }
 133
 134     /** specify the master config file, relative to getBaseDir(), but ignore any tests or testGroups in the master.
 135      *  @return a Document object, which you don't need to use: all options will be stored in XmlReplay instance.
 136      */
 137     public org.dom4j.Document readOptionsFromMasterConfigFile(String masterFilename) throws FileNotFoundException {
 138         org.dom4j.Document document = openMasterConfigFile(masterFilename);
 139         if (document == null){
 140             throw new FileNotFoundException(masterFilename);
 141         }
 142         protoHostPort = document.selectSingleNode("/xmlReplayMaster/protoHostPort").getText().trim();
 143         AuthsMap authsMap = readAuths(document);
 144         setDefaultAuthsMap(authsMap);
 145         Dump dump = XmlReplay.readDumpOptions(document);
 146         setDump(dump);
 147         return document;
 148     }
 149
 150     public List<List<ServiceResult>> runMaster(String masterFilename) throws Exception {
 151         return runMaster(masterFilename, true);
 152     }
 153
 154     /** Creates new instances of XmlReplay, one for each controlFile specified in the master,
 155      *  and setting defaults from this instance, but not sharing ServiceResult objects or maps. */
 156         public List<List<ServiceResult>> runMaster(String masterFilename, boolean readOptionsFromMaster) throws Exception {
 157         List<List<ServiceResult>> list = new ArrayList<List<ServiceResult>>();
 158         org.dom4j.Document document;
 159         if (readOptionsFromMaster){
 160             document = readOptionsFromMasterConfigFile(masterFilename);
 161         } else {
 162             document = openMasterConfigFile(masterFilename);
 163         }
 164         if (document==null){
 165             throw new FileNotFoundException(masterFilename);
 166         }
 167         String controlFile, testGroup, test;
 168         List<Node> runNodes;
 169         runNodes = document.selectNodes("/xmlReplayMaster/run");
 170         for (Node runNode : runNodes) {
 171             controlFile = runNode.valueOf("@controlFile");
 172             testGroup = runNode.valueOf("@testGroup");
 173             test = runNode.valueOf("@test"); //may be empty
 174
 175             //Create a new instance and clone only config values, not any results maps.
 176             XmlReplay replay = new XmlReplay(basedir, this.reportsDir);
 177             replay.setControlFileName(controlFile);
 178             replay.setProtoHostPort(protoHostPort);
 179             replay.setAutoDeletePOSTS(isAutoDeletePOSTS());
 180             replay.setDump(dump);
 181             replay.setDefaultAuthsMap(getDefaultAuthsMap());
 182
 183             //Now run *that* instance.
 184             List<ServiceResult> results = replay.runTests(testGroup, test);
 185             list.add(results);
 186             this.reportsList.addAll(replay.getReportsList());   //Add all the reports from the inner replay, to our master replay's reportsList, to generate the index.html file.
 187         }
 188         XmlReplayReport.saveIndexForMaster(basedir, reportsDir, masterFilename, this.reportsList);
 189         return list;
 190     }
 191
 192     /** Use this if you wish to run named tests within a testGroup, otherwise call runTestGroup(). */
 193     public List<ServiceResult>  runTests(String testGroupID, String testID) throws Exception {
 194         List<ServiceResult> result = runXmlReplayFile(this.basedir,
 195                                 this.controlFileName,
 196                                 testGroupID,
 197                                 testID,
 198                                 this.serviceResultsMap,
 199                                 this.autoDeletePOSTS,
 200                                 dump,
 201                                 this.protoHostPort,
 202                                 this.defaultAuthsMap,
 203                                 this.reportsList,
 204                                 this.reportsDir);
 205         return result;
 206     }
 207
 208     /** Use this if you wish to specify just ONE test to run within a testGroup, otherwise call runTestGroup(). */
 209     public ServiceResult  runTest(String testGroupID, String testID) throws Exception {
 210         List<ServiceResult> result = runXmlReplayFile(this.basedir,
 211                                 this.controlFileName,
 212                                 testGroupID,
 213                                 testID,
 214                                 this.serviceResultsMap,
 215                                 this.autoDeletePOSTS,
 216                                 dump,
 217                                 this.protoHostPort,
 218                                 this.defaultAuthsMap,
 219                                 this.reportsList,
 220                                 this.reportsDir);
 221         if (result.size()>1){
 222             throw new IndexOutOfBoundsException("Multiple ("+result.size()+") tests with ID='"+testID+"' were found within test group '"+testGroupID+"', but there should only be one test per ID attribute.");
 223         }
 224         return result.get(0);
 225     }
 226
 227     /** Use this if you wish to run all tests within a testGroup.*/
 228     public List<ServiceResult> runTestGroup(String testGroupID) throws Exception {
 229         //NOTE: calling runTest with empty testID runs all tests in a test group, but don't expose this fact.
 230         // Expose this method (runTestGroup) instead.
 231         return runTests(testGroupID, "");
 232     }
 233
 234     public List<ServiceResult> autoDelete(String logName){
 235         return autoDelete(this.defaultAuthsMap, this.serviceResultsMap, logName, 0);
 236     }
 237
 238     /** Use this method to clean up resources created on the server that returned CSIDs, if you have
 239      *  specified autoDeletePOSTS==false, which means you are managing the cleanup yourself.
 240      * @param serviceResultsMap a Map of ServiceResult objects, which will contain ServiceResult.deleteURL.
 241      * @return a List<String> of debug info about which URLs could not be deleted.
 242      */
 243     private static List<ServiceResult> autoDelete(AuthsMap defaultAuths, Map<String, ServiceResult> serviceResultsMap, String logName, int reattempt) {
 244         List<ServiceResult> results = new ArrayList<ServiceResult>();
 245         HashMap<String, ServiceResult> reattemptList = new HashMap<String, ServiceResult>();
 246         int deleteFailures = 0;
 247         for (ServiceResult pr : serviceResultsMap.values()) {
 248             try {
 249                 if (pr.autoDelete == true && Tools.notEmpty(pr.deleteURL)){
 250                     ServiceResult deleteResult = XmlReplayTransport.doDELETE(pr.deleteURL, defaultAuths.getDefaultAuth(), pr.testID, "[autodelete:"+logName+"]");
 251                     if (deleteResult.gotExpectedResult() == false || deleteResult.responseCode != 200) {
 252                         reattemptList.put(REATTEMPT_KEY + deleteFailures++, pr); // We need to try again after our dependents have been deleted. cow()
 253                     }
 254                     results.add(deleteResult);
 255                 } else {
 256                     ServiceResult errorResult = new ServiceResult();
 257                     errorResult.fullURL = pr.fullURL;
 258                     errorResult.testGroupID = pr.testGroupID;
 259                     errorResult.fromTestID = pr.fromTestID;
 260                     errorResult.overrideGotExpectedResult();
 261                     results.add(errorResult);
 262                 }
 263             } catch (Throwable t){
 264                 String s = (pr!=null) ? "ERROR while cleaning up ServiceResult map: "+pr+" for "+pr.deleteURL+" :: "+t
 265                                       : "ERROR while cleaning up ServiceResult map (null ServiceResult): "+t;
 266                 System.err.println(s);
 267                 ServiceResult errorResult = new ServiceResult();
 268                 errorResult.fullURL = pr.fullURL;
 269                 errorResult.testGroupID = pr.testGroupID;
 270                 errorResult.fromTestID = pr.fromTestID;
 271                 errorResult.error = s;
 272                 results.add(errorResult);
 273             }
 274         }
 275         //
 276         // If there were things we had trouble deleting, it might have been because they had dependents that
 277         // needed to be deleted first.  Therefore, we're going to try again and again (recursively) up until we reach
 278         // our MAX_REATTEMPTS limit.
 279         //
 280         if (reattemptList.size() > 0 && reattempt < MAX_REATTEMPTS) {
 281                 return autoDelete(defaultAuths, reattemptList, logName, ++reattempt); // recursive call
 282         }
 283
 284         return results;
 285     }
 286
 287     public static class AuthsMap {
 288         Map<String,String> map;
 289         String defaultID="";
 290         public String getDefaultAuth(){
 291             return map.get(defaultID);
 292         }
 293         @Override
 294                 public String toString(){
 295             return "AuthsMap: {default='"+defaultID+"'; "+map.keySet()+'}';
 296         }
 297     }
 298
 299     public static AuthsMap readAuths(org.dom4j.Document document){
 300     Map<String, String> map = new HashMap<String, String>();
 301         List<Node> authNodes = document.selectNodes("//auths/auth");
 302         for (Node auth : authNodes) {
 303             map.put(auth.valueOf("@ID"), auth.getStringValue());
 304         }
 305         AuthsMap authsMap = new AuthsMap();
 306         Node auths = document.selectSingleNode("//auths");
 307         String defaultID = "";
 308         if (auths != null){
 309             defaultID = auths.valueOf("@default");
 310         }
 311         authsMap.map = map;
 312         authsMap.defaultID = defaultID;
 313         return authsMap;
 314     }
 315
 316     public static class Dump {
 317         public boolean payloads = false;
 318         //public static final ServiceResult.DUMP_OPTIONS dumpServiceResultOptions = ServiceResult.DUMP_OPTIONS;
 319         public ServiceResult.DUMP_OPTIONS dumpServiceResult = ServiceResult.DUMP_OPTIONS.minimal;
 320         @Override
 321                 public String toString(){
 322             return "payloads: "+payloads+" dumpServiceResult: "+dumpServiceResult;
 323         }
 324     }
 325
 326     public static Dump getDumpConfig(){
 327         return new Dump();
 328     }
 329
 330     public static Dump readDumpOptions(org.dom4j.Document document){
 331         Dump dump = getDumpConfig();
 332         Node dumpNode = document.selectSingleNode("//dump");
 333         if (dumpNode != null){
 334             dump.payloads = Tools.isTrue(dumpNode.valueOf("@payloads"));
 335             String dumpServiceResultStr = dumpNode.valueOf("@dumpServiceResult");
 336             if (Tools.notEmpty(dumpServiceResultStr)){
 337                 dump.dumpServiceResult = ServiceResult.DUMP_OPTIONS.valueOf(dumpServiceResultStr);
 338             }
 339         }
 340         return dump;
 341     }
 342
 343     private static class PartsStruct {
 344         public List<Map<String,String>> varsList = new ArrayList<Map<String,String>>();
 345         String responseFilename = "";
 346         String overrideTestID = "";
 347         String startElement = "";
 348         String label = "";
 349
 350         public static PartsStruct readParts(Node testNode, final String testID, String xmlReplayBaseDir){
 351             PartsStruct resultPartsStruct = new PartsStruct();
 352             resultPartsStruct.responseFilename = testNode.valueOf("filename");
 353             resultPartsStruct.startElement = testNode.valueOf("startElement");
 354             resultPartsStruct.label = testNode.valueOf("label");
 355             String responseFilename = testNode.valueOf("filename");
 356             if (Tools.notEmpty(responseFilename)){
 357                 resultPartsStruct.responseFilename = xmlReplayBaseDir + '/' + responseFilename;
 358                 List<Node> varNodes = testNode.selectNodes("vars/var");
 359                 readVars(testNode, varNodes, resultPartsStruct);
 360             }
 361             return resultPartsStruct;
 362         }
 363
 364         private static void readVars(Node testNode, List<Node> varNodes, PartsStruct resultPartsStruct){
 365             Map<String,String> vars = new HashMap<String,String>();
 366             resultPartsStruct.varsList.add(vars);
 367             //System.out.println("### vars: "+vars.size()+" ########");
 368             for (Node var: varNodes){
 369                 String ID = var.valueOf("@ID");
 370                 String value = var.getText();
 371                 //System.out.println("ID: "+ID+" value: "+value);
 372                 vars.put(ID, value); //vars is already part of resultPartsStruct.varsList
 373             }
 374             //System.out.println("### end-vars ########");
 375         }
 376     }
 377
 378
 379
 380     private static String fixupFullURL(String fullURL, String protoHostPort, String uri){
 381         if ( ! uri.startsWith(protoHostPort)){
 382             fullURL = Tools.glue(protoHostPort, "/", uri);
 383         } else {
 384             fullURL = uri;
 385         }
 386         return fullURL;
 387     }
 388
 389     private static String fromTestID(String fullURL, Node testNode, Map<String, ServiceResult> serviceResultsMap){
 390         String fromTestID = testNode.valueOf("fromTestID");
 391         if (Tools.notEmpty(fromTestID)){
 392             ServiceResult getPR = serviceResultsMap.get(fromTestID);
 393             if (getPR != null){
 394                 fullURL = Tools.glue(fullURL, "/", getPR.location);
 395             }
 396         }
 397         return fullURL;
 398     }
 399
 400     private static String CSIDfromTestID(Node testNode, Map<String, ServiceResult> serviceResultsMap){
 401         String result = "";
 402         String fromTestID = testNode.valueOf("fromTestID");
 403         if (Tools.notEmpty(fromTestID)){
 404             ServiceResult getPR = serviceResultsMap.get(fromTestID);
 405             if (getPR != null){
 406                 result = getPR.location;
 407             }
 408         }
 409         return result;
 410     }
 411
 412     public static org.dom4j.Document getDocument(String xmlFileName) {
 413         org.dom4j.Document document = null;
 414         SAXReader reader = new SAXReader();
 415         try {
 416             document = reader.read(xmlFileName);
 417         } catch (DocumentException e) {
 418             System.out.println("ERROR reading document: "+e);
 419             //e.printStackTrace();
 420         }
 421         return document;
 422     }
 423
 424     protected static String validateResponseSinglePayload(ServiceResult serviceResult,
 425                                                  Map<String, ServiceResult> serviceResultsMap,
 426                                                  PartsStruct expectedResponseParts,
 427                                                  XmlReplayEval evalStruct)
 428     throws Exception {
 429         String OK = "";
 430         byte[] b = FileUtils.readFileToByteArray(new File(expectedResponseParts.responseFilename));
 431         String expectedPartContent = new String(b);
 432         Map<String,String> vars = expectedResponseParts.varsList.get(0);  //just one part, so just one varsList.  Must be there, even if empty.
 433         expectedPartContent = XmlReplayEval.eval(expectedPartContent, serviceResultsMap, vars, evalStruct.jexl, evalStruct.jc);
 434         serviceResult.expectedContentExpanded = expectedPartContent;
 435         String label = "NOLABEL";
 436         String leftID  = "{from expected part, label:"+label+" filename: "+expectedResponseParts.responseFilename+"}";
 437         String rightID = "{from server, label:"+label
 438                             +" fromTestID: "+serviceResult.fromTestID
 439                             +" URL: "+serviceResult.fullURL
 440                             +"}";
 441         String startElement = expectedResponseParts.startElement;
 442         String partLabel = expectedResponseParts.label;
 443         if (Tools.isBlank(startElement)){
 444             if (Tools.notBlank(partLabel))
 445             startElement = "/document/*[local-name()='"+partLabel+"']";
 446         }
 447         TreeWalkResults.MatchSpec matchSpec = TreeWalkResults.MatchSpec.createDefault();
 448         TreeWalkResults list =
 449             XmlCompareJdom.compareParts(expectedPartContent,
 450                                         leftID,
 451                                         serviceResult.result,
 452                                         rightID,
 453                                         startElement,
 454                                         matchSpec);
 455         serviceResult.addPartSummary(label, list);
 456         return OK;
 457     }
 458
 459     protected static String validateResponse(ServiceResult serviceResult,
 460                                              Map<String, ServiceResult> serviceResultsMap,
 461                                              PartsStruct expectedResponseParts,
 462                                              XmlReplayEval evalStruct){
 463         String OK = "";
 464         if (expectedResponseParts == null) return OK;
 465         if (serviceResult == null) return OK;
 466         if (serviceResult.result.length() == 0) return OK;
 467         try {
 468             return validateResponseSinglePayload(serviceResult, serviceResultsMap, expectedResponseParts, evalStruct);
 469         } catch (Exception e){
 470             String err = "ERROR in XmlReplay.validateResponse() : "+e;
 471             return err  ;
 472         }
 473     }
 474
 475     //================= runXmlReplayFile ======================================================
 476
 477     public static List<ServiceResult> runXmlReplayFile(String xmlReplayBaseDir,
 478                                           String controlFileName,
 479                                           String testGroupID,
 480                                           String oneTestID,
 481                                           Map<String, ServiceResult> serviceResultsMap,
 482                                           boolean param_autoDeletePOSTS,
 483                                           Dump dump,
 484                                           String protoHostPortParam,
 485                                           AuthsMap defaultAuths,
 486                                           List<String> reportsList,
 487                                           String reportsDir)
 488                                           throws Exception {
 489         //Internally, we maintain two collections of ServiceResult:
 490         //  the first is the return value of this method.
 491         //  the second is the serviceResultsMap, which is used for keeping track of CSIDs created by POSTs, for later reference by DELETE, etc.
 492         List<ServiceResult> results = new ArrayList<ServiceResult>();
 493
 494         XmlReplayReport report = new XmlReplayReport(reportsDir);
 495
 496         String controlFile = Tools.glue(xmlReplayBaseDir, "/", controlFileName);
 497         org.dom4j.Document document;
 498         document = getDocument(controlFile); //will check full path first, then checks relative to PWD.
 499         if (document==null){
 500             throw new FileNotFoundException("XmlReplay control file ("+controlFileName+") not found in basedir: "+xmlReplayBaseDir+" Exiting test.");
 501         }
 502         String protoHostPort;
 503         if (Tools.isEmpty(protoHostPortParam)){
 504             protoHostPort = document.selectSingleNode("/xmlReplay/protoHostPort").getText().trim();
 505             System.out.println("DEPRECATED: Using protoHostPort ('"+protoHostPort+"') from xmlReplay file ('"+controlFile+"'), not master.");
 506         } else {
 507             protoHostPort = protoHostPortParam;
 508         }
 509         if (Tools.isEmpty(protoHostPort)){
 510             throw new Exception("XmlReplay control file must have a protoHostPort element");
 511         }
 512
 513         String authsMapINFO;
 514         AuthsMap authsMap = readAuths(document);
 515         if (authsMap.map.size()==0){
 516             authsMap = defaultAuths;
 517             authsMapINFO = "Using defaultAuths from master file: "+defaultAuths;
 518         } else {
 519             authsMapINFO = "Using AuthsMap from control file: "+authsMap;
 520         }
 521
 522         report.addTestGroup(testGroupID, controlFileName);   //controlFileName is just the short name, without the full path.
 523         String xmlReplayHeader = "========================================================================"
 524                           +"\r\nXmlReplay running:"
 525                           +"\r\n   controlFile: "+ (new File(controlFile).getCanonicalPath())
 526                           +"\r\n   protoHostPort: "+protoHostPort
 527                           +"\r\n   testGroup: "+testGroupID
 528                           + (Tools.notEmpty(oneTestID) ? "\r\n   oneTestID: "+oneTestID : "")
 529                           +"\r\n   AuthsMap: "+authsMapINFO
 530                           +"\r\n   param_autoDeletePOSTS: "+param_autoDeletePOSTS
 531                           +"\r\n   Dump info: "+dump
 532                           +"\r\n========================================================================"
 533                           +"\r\n";
 534         report.addRunInfo(xmlReplayHeader);
 535
 536         System.out.println(xmlReplayHeader);
 537
 538         String autoDeletePOSTS = "";
 539         List<Node> testgroupNodes;
 540         if (Tools.notEmpty(testGroupID)){
 541             testgroupNodes = document.selectNodes("//testGroup[@ID='"+testGroupID+"']");
 542         } else {
 543             testgroupNodes = document.selectNodes("//testGroup");
 544         }
 545
 546         JexlEngine jexl = new JexlEngine();   // Used for expression language expansion from uri field.
 547         XmlReplayEval evalStruct = new XmlReplayEval();
 548         evalStruct.serviceResultsMap = serviceResultsMap;
 549         evalStruct.jexl = jexl;
 550
 551         for (Node testgroup : testgroupNodes) {
 552
 553             XmlReplayEval.MapContextWKeys jc = new XmlReplayEval.MapContextWKeys();//MapContext();  //Get a new JexlContext for each test group.
 554             evalStruct.jc = jc;
 555
 556             autoDeletePOSTS = testgroup.valueOf("@autoDeletePOSTS");
 557             List<Node> tests;
 558             if (Tools.notEmpty(oneTestID)){
 559                 tests = testgroup.selectNodes("test[@ID='"+oneTestID+"']");
 560             } else {
 561                 tests = testgroup.selectNodes("test");
 562             }
 563             String authForTest = ""; // reset auth for each test group
 564             int testElementIndex = -1;
 565
 566             for (Node testNode : tests) {
 567                 long startTime = System.currentTimeMillis();
 568                 try {
 569                     testElementIndex++;
 570                     String testID = testNode.valueOf("@ID");
 571                     //
 572                     // Figure out if we will auto delete resources
 573                     boolean autoDelete = param_autoDeletePOSTS;
 574                     String autoDeleteValue = testNode.valueOf("@autoDeletePOSTS");
 575                     if (autoDeleteValue != null && !autoDeleteValue.trim().isEmpty()) {
 576                         autoDelete = Boolean.valueOf(autoDeleteValue).booleanValue();
 577                     }
 578
 579                     String testIDLabel = Tools.notEmpty(testID) ? (testGroupID+'.'+testID) : (testGroupID+'.'+testElementIndex);
 580                     String method = testNode.valueOf("method");
 581                     String contentType = testNode.valueOf("contentType");
 582                     String uri = testNode.valueOf("uri");
 583                     String fullURL = Tools.glue(protoHostPort, "/", uri);
 584
 585                     if (contentType == null || contentType.equals("")) {
 586                         contentType = XmlReplayTransport.APPLICATION_XML;
 587                     }
 588
 589                     String currentAuthForTest = null;
 590                     String authIDForTest = testNode.valueOf("@auth");
 591
 592                     if (Tools.notEmpty(authIDForTest)){
 593                         currentAuthForTest = authsMap.map.get(authIDForTest);
 594                     } else {
 595                         String tokenAuthExpression = testNode.valueOf("@tokenauth");
 596                         if (Tools.notEmpty(tokenAuthExpression)){
 597                             currentAuthForTest = "Bearer " + XmlReplayEval.eval(tokenAuthExpression, serviceResultsMap, null, jexl, jc);
 598                         }
 599                     }
 600
 601                     if (Tools.notEmpty(currentAuthForTest)){
 602                         authForTest = currentAuthForTest; //else just run with current from last loop;
 603                     }
 604                     if (Tools.isEmpty(authForTest)){
 605                         authForTest = defaultAuths.getDefaultAuth();
 606                     }
 607
 608                     if (uri.indexOf("$")>-1){
 609                         uri = XmlReplayEval.eval(uri, serviceResultsMap, null, jexl, jc);
 610                     }
 611                     fullURL = fixupFullURL(fullURL, protoHostPort, uri);
 612
 613                     List<Integer> expectedCodes = new ArrayList<Integer>();
 614                     String expectedCodesStr = testNode.valueOf("expectedCodes");
 615                     if (Tools.notEmpty(expectedCodesStr)){
 616                          String[] codesArray = expectedCodesStr.split(",");
 617                          for (String code : codesArray){
 618                              expectedCodes.add(new Integer(code.trim()));
 619                          }
 620                     }
 621
 622                     Node responseNode = testNode.selectSingleNode("response");
 623                     PartsStruct expectedResponseParts = null;
 624                     if (responseNode!=null){
 625                         expectedResponseParts = PartsStruct.readParts(responseNode, testID, xmlReplayBaseDir);
 626                         //System.out.println("reponse parts: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"+expectedResponseParts);
 627                     }
 628
 629                     ServiceResult serviceResult;
 630                     boolean isPOST = method.equalsIgnoreCase("POST");
 631                     boolean isPUT =  method.equalsIgnoreCase("PUT");
 632                     if ( isPOST || isPUT ) {
 633                         PartsStruct parts = PartsStruct.readParts(testNode, testID, xmlReplayBaseDir);
 634                         if (Tools.notEmpty(parts.overrideTestID)) {
 635                             testID = parts.overrideTestID;
 636                         }
 637                         if (isPOST){
 638                             String csid = CSIDfromTestID(testNode, serviceResultsMap);
 639                             if (Tools.notEmpty(csid)) uri = Tools.glue(uri, "/", csid+"/items/");
 640                         } else if (isPUT) {
 641                             uri = fromTestID(uri, testNode, serviceResultsMap);
 642                         }
 643                         //vars only make sense in two contexts: POST/PUT, because you are submitting another file with internal expressions,
 644                         // and in <response> nodes. For GET, DELETE, there is no payload, so all the URLs with potential expressions are right there in the testNode.
 645                         Map<String,String> vars = null;
 646                         if (parts.varsList.size()>0){
 647                             vars = parts.varsList.get(0);
 648                         }
 649                         serviceResult = XmlReplayTransport.doPOST_PUTFromXML(parts.responseFilename, vars, protoHostPort, uri, method, contentType, evalStruct, authForTest, testIDLabel);
 650                         serviceResult.autoDelete = autoDelete;
 651                         if (vars!=null) {
 652                             serviceResult.addVars(vars);
 653                         }
 654                         results.add(serviceResult);
 655                         //if (isPOST){
 656                             serviceResultsMap.put(testID, serviceResult);      //PUTs do not return a Location, so don't add PUTs to serviceResultsMap.
 657                         //}
 658                         fullURL = fixupFullURL(fullURL, protoHostPort, uri);
 659                     } else if (method.equalsIgnoreCase("DELETE")){
 660                         String fromTestID = testNode.valueOf("fromTestID");
 661                         ServiceResult pr = Tools.notBlank(fromTestID) ? serviceResultsMap.get(fromTestID) : null;
 662                         if (pr != null) {
 663                             serviceResult = XmlReplayTransport.doDELETE(pr.deleteURL, authForTest, testIDLabel, fromTestID);
 664                             serviceResult.fromTestID = fromTestID;
 665                             if (expectedCodes.size()>0){
 666                                 serviceResult.expectedCodes = expectedCodes;
 667                             }
 668                             results.add(serviceResult);
 669                             if (serviceResult.codeInSuccessRange(serviceResult.responseCode)){  //gotExpectedResult depends on serviceResult.expectedCodes.
 670                                 serviceResultsMap.remove(fromTestID);
 671                             }
 672                         } else {
 673                             if (Tools.notEmpty(fromTestID)){
 674                                 serviceResult = new ServiceResult();
 675                                 serviceResult.responseCode = 0;
 676                                 serviceResult.error = "ID not found in element fromTestID: "+fromTestID;
 677                                 System.err.println("****\r\nServiceResult: "+serviceResult.error+". SKIPPING TEST. Full URL: "+fullURL);
 678                             } else {
 679                                 serviceResult = XmlReplayTransport.doDELETE(fullURL, authForTest, testID, fromTestID);
 680                             }
 681                             serviceResult.fromTestID = fromTestID;
 682                             results.add(serviceResult);
 683                         }
 684                     } else if (method.equalsIgnoreCase("GET")){
 685                         fullURL = fromTestID(fullURL, testNode, serviceResultsMap);
 686                         serviceResult = XmlReplayTransport.doGET(fullURL, authForTest, testIDLabel);
 687                         results.add(serviceResult);
 688                         serviceResultsMap.put(testID, serviceResult);
 689                     } else if (method.equalsIgnoreCase("LIST")){
 690                         fullURL = fixupFullURL(fullURL, protoHostPort, uri);
 691                         String listQueryParams = ""; //TODO: empty for now, later may pick up from XML control file.
 692                         serviceResult = XmlReplayTransport.doLIST(fullURL, listQueryParams, authForTest, testIDLabel);
 693                         results.add(serviceResult);
 694                         serviceResultsMap.put(testID, serviceResult);
 695                     } else {
 696                         throw new Exception("HTTP method not supported by XmlReplay: "+method);
 697                     }
 698
 699                     serviceResult.testID = testID;
 700                     serviceResult.fullURL = fullURL;
 701                     serviceResult.auth = authForTest;
 702                     serviceResult.method = method;
 703                     if (expectedCodes.size()>0){
 704                         serviceResult.expectedCodes = expectedCodes;
 705                     }
 706                     if (Tools.isEmpty(serviceResult.testID)) serviceResult.testID = testIDLabel;
 707                     if (Tools.isEmpty(serviceResult.testGroupID)) serviceResult.testGroupID = testGroupID;
 708
 709                     Node expectedLevel = testNode.selectSingleNode("response/expected");
 710                     if (expectedLevel!=null){
 711                         String level = expectedLevel.valueOf("@level");
 712                         serviceResult.payloadStrictness = level;
 713                     }
 714                     //=====================================================
 715                     //  ALL VALIDATION FOR ALL REQUESTS IS DONE HERE:
 716                     //=====================================================
 717                     boolean hasError = false;
 718                     String vError = validateResponse(serviceResult, serviceResultsMap, expectedResponseParts, evalStruct);
 719                     if (Tools.notEmpty(vError)){
 720                         serviceResult.error = vError;
 721                         serviceResult.failureReason = " : VALIDATION ERROR; ";
 722                         hasError = true;
 723                     }
 724                     if (hasError == false){
 725                         hasError = ! serviceResult.gotExpectedResult();
 726                     }
 727
 728                     report.addTestResult(serviceResult);
 729
 730                     if ((dump.dumpServiceResult == ServiceResult.DUMP_OPTIONS.detailed) || (dump.dumpServiceResult == ServiceResult.DUMP_OPTIONS.full)) {
 731                         System.out.println("\r\n#---------------------#");
 732                     }
 733
 734                     String leader = (dump.dumpServiceResult == ServiceResult.DUMP_OPTIONS.detailed) ? "XmlReplay:" + testIDLabel +": ": "";
 735                     String serviceResultRow = serviceResult.dump(dump.dumpServiceResult, hasError) + "; time:" + (System.currentTimeMillis()-startTime);
 736                     //System.out.println(timeString() + "\n" + leader + serviceResultRow + "\r\n");
 737                     System.out.println(String.format("Time: %s\nLeader: %s\nAuth: %s\nResult: %s\r\n",
 738                                 timeString(), testIDLabel, Tools.notEmpty(authIDForTest) ? authIDForTest : "<inferred>", serviceResultRow));
 739
 740                     boolean doingAuto = (dump.dumpServiceResult == ServiceResult.DUMP_OPTIONS.auto);
 741                     if (dump.payloads || (doingAuto&&hasError) ) {
 742                         if (Tools.notBlank(serviceResult.requestPayload)){
 743                             System.out.println("\r\n========== request payload ===============");
 744                             System.out.println(serviceResult.requestPayload);
 745                             System.out.println("==========================================\r\n");
 746                         }
 747                     }
 748                     if (dump.payloads || (doingAuto&&hasError)) {
 749                         if (Tools.notBlank(serviceResult.result)){
 750                             System.out.println("\r\n========== response payload ==============");
 751                             System.out.println(serviceResult.result);
 752                             System.out.println("==========================================\r\n");
 753                         }
 754                     }
 755                 } catch (Throwable t) {
 756                     String msg = "ERROR: XmlReplay experienced an error in a test node: "+testNode+" Throwable: "+t;
 757                     System.out.println(msg);
 758                     System.out.println(Tools.getStackTrace(t));
 759                     ServiceResult serviceResult = new ServiceResult();
 760                     serviceResult.error = msg;
 761                     serviceResult.failureReason = " : SYSTEM ERROR; ";
 762                     results.add(serviceResult);
 763                 }
 764             }
 765             if (Tools.isTrue(autoDeletePOSTS) && param_autoDeletePOSTS){
 766                 autoDelete(defaultAuths, serviceResultsMap, "default", 0);
 767             }
 768         }
 769
 770         //=== Now spit out the HTML report file ===
 771         File m = new File(controlFileName);
 772         String localName = m.getName();//don't instantiate, just use File to extract file name without directory.
 773         String reportName = localName+'-'+testGroupID+".html";
 774
 775         File resultFile = report.saveReport(xmlReplayBaseDir, reportsDir, reportName);
 776         if (resultFile!=null) {
 777             String toc = report.getTOC(reportName);
 778             reportsList.add(toc);
 779         }
 780         //================================
 781
 782         return results;
 783     }
 784
 785                 private static String timeString() {
 786                         java.util.Date date= new java.util.Date();
 787                         java.sql.Timestamp ts = new java.sql.Timestamp(date.getTime());
 788                         return ts.toString();
 789                 }
 790
 791
 792     //======================== MAIN ===================================================================
 793
 794     private static Options createOptions() {
 795         Options options = new Options();
 796         options.addOption("xmlReplayBaseDir", true, "default/basedir");
 797         return options;
 798     }
 799
 800     public static String usage(){
 801         String result = "org.collectionspace.services.IntegrationTests.xmlreplay.XmlReplay {args}\r\n"
 802                         +"  -xmlReplayBaseDir <dir> \r\n"
 803                         +" You may also override these with system args, e.g.: \r\n"
 804                         +"   -DxmlReplayBaseDir=/path/to/dir \r\n"
 805                         +" These may also be passed in via the POM.\r\n"
 806                         +" You can also set these system args, e.g.: \r\n"
 807                         +"  -DtestGroupID=<oneID> \r\n"
 808                         +"  -DtestID=<one TestGroup ID>"
 809                         +"  -DautoDeletePOSTS=<true|false> \r\n"
 810                         +"    (note: -DautoDeletePOSTS won't force deletion if set to false in control file.";
 811         return result;
 812     }
 813
 814     private static String opt(CommandLine line, String option){
 815         String result;
 816         String fromProps = System.getProperty(option);
 817         if (Tools.notEmpty(fromProps)){
 818             return fromProps;
 819         }
 820         if (line==null){
 821             return "";
 822         }
 823         result = line.getOptionValue(option);
 824         if (result == null){
 825             result = "";
 826         }
 827         return result;
 828     }
 829
 830         public static void main(String[]args) throws Exception {
 831         Options options = createOptions();
 832         //System.out.println("System CLASSPATH: "+prop.getProperty("java.class.path", null));
 833         CommandLineParser parser = new GnuParser();
 834         try {
 835             // parse the command line arguments
 836             CommandLine line = parser.parse(options, args);
 837
 838             String xmlReplayBaseDir = opt(line, "xmlReplayBaseDir");
 839             String reportsDir = opt(line, "reportsDir");
 840             String testGroupID      = opt(line, "testGroupID");
 841             String testID           = opt(line, "testID");
 842             String autoDeletePOSTS  = opt(line, "autoDeletePOSTS");
 843             String dumpResults      = opt(line, "dumpResults");
 844             String controlFilename   = opt(line, "controlFilename");
 845             String xmlReplayMaster  = opt(line, "xmlReplayMaster");
 846
 847             if (Tools.isBlank(reportsDir)){
 848                 reportsDir = xmlReplayBaseDir + XmlReplayTest.REPORTS_DIRNAME;
 849             }
 850             reportsDir = Tools.fixFilename(reportsDir);
 851             xmlReplayBaseDir = Tools.fixFilename(xmlReplayBaseDir);
 852             controlFilename = Tools.fixFilename(controlFilename);
 853
 854             boolean bAutoDeletePOSTS = true;
 855             if (Tools.notEmpty(autoDeletePOSTS)) {
 856                 bAutoDeletePOSTS = Tools.isTrue(autoDeletePOSTS);
 857             }
 858             boolean bDumpResults = false;
 859             if (Tools.notEmpty(dumpResults)) {
 860                 bDumpResults = Tools.isTrue(autoDeletePOSTS);
 861             }
 862             if (Tools.isEmpty(xmlReplayBaseDir)){
 863                 System.err.println("ERROR: xmlReplayBaseDir was not specified.");
 864                 return;
 865             }
 866             File f = new File(Tools.glue(xmlReplayBaseDir, "/", controlFilename));
 867             if (Tools.isEmpty(xmlReplayMaster) && !f.exists()){
 868                 System.err.println("Control file not found: "+f.getCanonicalPath());
 869                 return;
 870             }
 871             File fMaster = new File(Tools.glue(xmlReplayBaseDir, "/", xmlReplayMaster));
 872             if (Tools.notEmpty(xmlReplayMaster)  && !fMaster.exists()){
 873                 System.err.println("Master file not found: "+fMaster.getCanonicalPath());
 874                 return;
 875             }
 876
 877             String xmlReplayBaseDirResolved = (new File(xmlReplayBaseDir)).getCanonicalPath();
 878             System.out.println("XmlReplay ::"
 879                             + "\r\n    xmlReplayBaseDir: "+xmlReplayBaseDir
 880                             + "\r\n    xmlReplayBaseDir(resolved): "+xmlReplayBaseDirResolved
 881                             + "\r\n    controlFilename: "+controlFilename
 882                             + "\r\n    xmlReplayMaster: "+xmlReplayMaster
 883                             + "\r\n    testGroupID: "+testGroupID
 884                             + "\r\n    testID: "+testID
 885                             + "\r\n    autoDeletePOSTS: "+bAutoDeletePOSTS
 886                             + (Tools.notEmpty(xmlReplayMaster)
 887                                        ? ("\r\n    will use master file: "+fMaster.getCanonicalPath())
 888                                        : ("\r\n    will use control file: "+f.getCanonicalPath()) )
 889                              );
 890
 891             if (Tools.notEmpty(xmlReplayMaster)){
 892                 if (Tools.notEmpty(controlFilename)){
 893                     System.out.println("WARN: controlFilename: "+controlFilename+" will not be used because master was specified.  Running master: "+xmlReplayMaster);
 894                 }
 895                 XmlReplay replay = new XmlReplay(xmlReplayBaseDirResolved, reportsDir);
 896                 replay.readOptionsFromMasterConfigFile(xmlReplayMaster);
 897                 replay.setAutoDeletePOSTS(bAutoDeletePOSTS);
 898                 Dump dumpFromMaster = replay.getDump();
 899                 dumpFromMaster.payloads = Tools.isTrue(dumpResults);
 900                 replay.setDump(dumpFromMaster);
 901                 replay.runMaster(xmlReplayMaster, false); //false, because we already just read the options, and override a few.
 902             } else {
 903                 Dump dump = getDumpConfig();
 904                 dump.payloads = Tools.isTrue(dumpResults);
 905                 List<String> reportsList = new ArrayList<String>();
 906                 runXmlReplayFile(xmlReplayBaseDirResolved, controlFilename, testGroupID, testID, createResultsMap(), bAutoDeletePOSTS, dump, "", null, reportsList, reportsDir);
 907                 System.out.println("DEPRECATED: reportsList is generated, but not dumped: "+reportsList.toString());
 908             }
 909         } catch (ParseException exp) {
 910             // oops, something went wrong
 911             System.err.println("Cmd-line parsing failed.  Reason: " + exp.getMessage());
 912             System.err.println(usage());
 913         } catch (Exception e) {
 914             System.out.println("Error : " + e.getMessage());
 915             e.printStackTrace();
 916         }
 917     }
 918
 919 }