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

   1 /**
   2  * CollectionSpacePerformanceTest.java
   3  *
   4  * {Purpose of This Class}
   5  *
   6  * {Other Notes Relating to This Class (Optional)}
   7  *
   8  * $LastChangedBy: $
   9  * $LastChangedRevision: $
  10  * $LastChangedDate: $
  11  *
  12  * This document is a part of the source code and related artifacts
  13  * for CollectionSpace, an open source collections management system
  14  * for museums and related institutions:
  15  *
  16  * http://www.collectionspace.org
  17  * http://wiki.collectionspace.org
  18  *
  19  * Copyright © 2009 {Contributing Institution}
  20  *
  21  * Licensed under the Educational Community License (ECL), Version 2.0.
  22  * You may not use this file except in compliance with this License.
  23  *
  24  * You may obtain a copy of the ECL 2.0 License at
  25  * https://source.collectionspace.org/collection-space/LICENSE.txt
  26  */
  27 package org.collectionspace.services.PerformanceTests.test;
  28
  29 import java.util.ArrayList;
  30 import java.util.List;
  31 import java.util.Random;
  32
  33 import javax.ws.rs.core.MultivaluedMap;
  34 import javax.ws.rs.core.Response;
  35 import javax.xml.bind.JAXBContext;
  36 import javax.xml.bind.Marshaller;
  37
  38 import org.collectionspace.services.collectionobject.CollectionobjectsCommon;
  39 import org.collectionspace.services.collectionobject.TitleGroup;
  40 import org.collectionspace.services.collectionobject.TitleGroupList;
  41 import org.collectionspace.services.intake.IntakesCommon;
  42 import org.collectionspace.services.relation.RelationsCommon;
  43 import org.collectionspace.services.relation.RelationshipType;
  44 import org.jboss.resteasy.client.ClientResponse;
  45 import org.jboss.resteasy.plugins.providers.multipart.InputPart;
  46 import org.jboss.resteasy.plugins.providers.multipart.MultipartInput;
  47
  48 /**
  49  * The Class CollectionSpacePerformanceTests.
  50  */
  51 public abstract class CollectionSpacePerformanceTest {
  52
  53         protected final static String OBJECT_NUMBER = "objectNumber_";
  54         protected final static String OBJECT_TITLE = "objectTitle_";
  55
  56         /*
  57          * Package scoped methods.
  58          */
  59
  60         /**
  61          * Fill collection object.
  62          *
  63          * @param co the co
  64          * @param identifier the identifier
  65          */
  66         void fillCollectionObject(CollectionobjectsCommon co, String identifier) {
  67                 fillCollectionObject(co, OBJECT_NUMBER + identifier, OBJECT_TITLE + identifier);
  68         }
  69
  70         /**
  71          * Fill collection object.
  72          *
  73          * @param co the co
  74          * @param objectNumber the object number
  75          * @param title the object title
  76          */
  77         void fillCollectionObject(CollectionobjectsCommon co, String objectNumber,
  78                         String title) {
  79                 co.setObjectNumber(objectNumber);
  80                 TitleGroupList titleGroupList = new TitleGroupList();
  81                 List<TitleGroup> titleGroups = titleGroupList.getTitleGroup();
  82                 TitleGroup titleGroup = new TitleGroup();
  83                 titleGroup.setTitle(title);
  84                 titleGroups.add(titleGroup);
  85                 co.setTitleGroupList(titleGroupList);
  86         }
  87
  88         /**
  89          * Fill intake.
  90          *
  91          * @param theIntake the the intake
  92          * @param identifier the identifier
  93          */
  94         void fillIntake(IntakesCommon theIntake, String identifier) {
  95                 fillIntake(theIntake, "entryNumber-" + identifier, "entryDate-"
  96                                 + identifier);
  97         }
  98
  99         /**
 100          * Fill intake.
 101          *
 102          * @param theIntake the the intake
 103          * @param entryNumber the entry number
 104          * @param entryDate the entry date
 105          */
 106         void fillIntake(IntakesCommon theIntake, String entryNumber, String entryDate) {
 107                 theIntake.setEntryNumber(entryNumber);
 108                 theIntake.setEntryDate(entryDate);
 109         }
 110
 111     /**
 112      * Fill relation.
 113      *
 114      * @param relation the relation
 115      * @param subjectCsid the document id1
 116      * @param subjectDocumentType the document type1
 117      * @param objectCsid the document id2
 118      * @param objectDocumentType the document type2
 119      * @param rt the rt
 120      */
 121     void fillRelation(RelationsCommon relation, String subjectCsid, String subjectDocumentType,
 122                 String objectCsid, String objectDocumentType, RelationshipType rt)
 123     {
 124         relation.setSubjectCsid(subjectCsid);
 125         relation.setSubjectDocumentType(subjectDocumentType);
 126         relation.setSubjectCsid(objectCsid);
 127         relation.setObjectDocumentType(objectDocumentType);
 128
 129         relation.setRelationshipType(rt.toString());
 130     }
 131
 132         /**
 133          * Creates the identifier.
 134          *
 135          * @return the string
 136          */
 137         String createIdentifier() {
 138                 long identifier = System.currentTimeMillis();
 139                 return Long.toString(identifier);
 140         }
 141
 142         /**
 143          * Extract id.
 144          *
 145          * @param res the res
 146          *
 147          * @return the string
 148          */
 149         String extractId(ClientResponse<Response> res) {
 150                 String result = null;
 151
 152                 MultivaluedMap mvm = res.getMetadata();
 153                 String uri = (String) ((ArrayList) mvm.get("Location")).get(0);
 154                 verbose("extractId:uri=" + uri);
 155                 String[] segments = uri.split("/");
 156                 result = segments[segments.length - 1];
 157                 verbose("id=" + result);
 158
 159                 return result;
 160         }
 161
 162         String extractId(Response res) {
 163                 String result = null;
 164
 165                 MultivaluedMap mvm = res.getMetadata();
 166                 String uri = (String) ((ArrayList) mvm.get("Location")).get(0);
 167                 verbose("extractId:uri=" + uri);
 168                 String[] segments = uri.split("/");
 169                 result = segments[segments.length - 1];
 170                 verbose("id=" + result);
 171
 172                 return result;
 173         }
 174
 175         /**
 176          * Extract part.
 177          *
 178          * @param input
 179          *            the input
 180          * @param label
 181          *            the label
 182          * @param clazz
 183          *            the clazz
 184          *
 185          * @return the object
 186          *
 187          * @throws Exception
 188          *             the exception
 189          */
 190         static Object extractPart(MultipartInput input, String label, Class clazz) {
 191                 Object obj = null;
 192
 193                 try {
 194                         for (InputPart part : input.getParts()) {
 195                                 String partLabel = part.getHeaders().getFirst("label");
 196                                 if (label.equalsIgnoreCase(partLabel)) {
 197                                         String partStr = part.getBodyAsString();
 198                                         obj = part.getBody(clazz, null);
 199                                         break;
 200                                 }
 201                         }
 202                 } catch (Exception e) {
 203                         e.printStackTrace();
 204                 }
 205
 206                 return obj;
 207         }
 208
 209         /**
 210          * Verbose.
 211          *
 212          * @param msg the msg
 213          */
 214         void verbose(String msg) {
 215 //              System.out.println(msg);
 216         }
 217
 218         /**
 219          * Verbose.
 220          *
 221          * @param msg the msg
 222          * @param o the o
 223          * @param clazz the clazz
 224          */
 225         void verbose(String msg, Object o, Class clazz) {
 226                 try {
 227                         verbose(msg);
 228                         JAXBContext jc = JAXBContext.newInstance(clazz);
 229                         Marshaller m = jc.createMarshaller();
 230                         m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
 231                         m.marshal(o, System.out);
 232                 } catch (Exception e) {
 233                         e.printStackTrace();
 234                 }
 235         }
 236
 237         /**
 238          * Verbose map.
 239          *
 240          * @param map the map
 241          */
 242         void verboseMap(MultivaluedMap map) {
 243                 for (Object entry : map.entrySet()) {
 244                         MultivaluedMap.Entry mentry = (MultivaluedMap.Entry) entry;
 245                         verbose("  name=" + mentry.getKey() + " value=" + mentry.getValue());
 246                 }
 247         }
 248
 249         boolean isEnabled() {
 250             return Boolean.getBoolean("cspace.perf");
 251         }
 252
 253 }