Index: trunk/autoquest-plugin-http/src/main/java/de/ugoe/cs/autoquest/plugin/http/SOAPUtils.java
===================================================================
--- trunk/autoquest-plugin-http/src/main/java/de/ugoe/cs/autoquest/plugin/http/SOAPUtils.java (revision 1990)
+++ trunk/autoquest-plugin-http/src/main/java/de/ugoe/cs/autoquest/plugin/http/SOAPUtils.java (revision 1992)
@@ -18,7 +18,9 @@
import java.util.ArrayList;
import java.util.Collection;
+import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
+import java.util.Set;
import javax.xml.transform.Transformer;
@@ -51,4 +53,19 @@
/**
*
+ * Defines how sequences are ordered:
+ *
+ * - REQUEST: by the request order id
+ * - RESPONSE: by the response order id
+ *
+ *
+ *
+ * @author Steffen Herbold
+ */
+ public enum SequenceOrder {
+ REQUEST, RESPONSE
+ }
+
+ /**
+ *
* Replaces events with a {@link SOAPEventType} with new events of {@link SimpleSOAPEventType}
* and no target.
@@ -63,9 +80,9 @@
*/
public static Collection> convertToSimpleSOAPEvent(Collection> sequences,
- boolean keepOnlySOAPEvents)
+ boolean keepOnlySOAPEvents)
{
Collection> newSequences = new LinkedList<>();
EqualSOAPDataMap equalSOAPDataMap = new EqualSOAPDataMap();
- for( List sequence : sequences ) {
+ for (List sequence : sequences) {
List newSequence = null;
if (sequence != null) {
@@ -74,10 +91,7 @@
if (event.getType() instanceof SOAPEventType) {
SOAPEventType eventType = (SOAPEventType) event.getType();
- newSequence.add(new Event(new SimpleSOAPEventType(eventType.getCalledMethod(),
- eventType.getServiceName(),
- eventType.getClientName(),
- eventType
- .getSoapRequestBody(),
- equalSOAPDataMap)));
+ newSequence.add(new Event(new SimpleSOAPEventType(eventType
+ .getCalledMethod(), eventType.getServiceName(), eventType
+ .getClientName(), eventType.getSoapRequestBody(), equalSOAPDataMap)));
}
else {
@@ -92,8 +106,24 @@
return newSequences;
}
-
- /**
- *
- * Removes all non SOAP events from a sequence. Warning: this change is performed in-place!
+
+ /**
+ *
+ * Removes all non SOAP events from the contained sequences
+ *
+ *
+ * @param sequences
+ * sequences where the events are replaced
+ */
+ public static Collection> removeNonSOAPEvents(Collection> sequences) {
+ Collection> soapOnlySequences = new LinkedList<>();
+ for (List sequence : sequences) {
+ soapOnlySequences.add(removeNonSOAPEvents(sequence));
+ }
+ return soapOnlySequences;
+ }
+
+ /**
+ *
+ * Removes all non SOAP events from a sequence
*
*
@@ -101,11 +131,12 @@
* sequence where the events are replaced
*/
- public static void removeNonSOAPEvents(List sequence) {
- for (Iterator eventIter = sequence.iterator(); eventIter.hasNext();) {
- Event event = eventIter.next();
- if (!(event.getType() instanceof SOAPEventType)) {
- eventIter.remove();
- }
- }
+ public static List removeNonSOAPEvents(List sequence) {
+ List soapOnlySequence = new LinkedList<>();
+ for (Event event : sequence) {
+ if (event.getType() instanceof SOAPEventType) {
+ soapOnlySequence.add(event);
+ }
+ }
+ return soapOnlySequence;
}
@@ -192,5 +223,5 @@
return getSoapRequestBodyFromEvent(event, false);
}
-
+
/**
*
@@ -210,7 +241,8 @@
}
else if (event.getType() instanceof SimpleSOAPEventType) {
- if( useRandomRequestBodies ) {
+ if (useRandomRequestBodies) {
requestBody = ((SimpleSOAPEventType) event.getType()).getRandomSoapRequestBody();
- } else {
+ }
+ else {
requestBody = ((SimpleSOAPEventType) event.getType()).getSoapRequestBody();
}
@@ -316,15 +348,20 @@
return attributeValues;
}
-
- /**
- *
- * Allows the removal of pre- and suffixes from SOAP operation names in {@link SimpleSOAPEventType}.
- *
- *
- * @param sequences sequences where the operation names are normalized
- */
- public static Collection> normalizeOperationNames(Collection> sequences, String prefixToRemove, String suffixToRemove) {
+
+ /**
+ *
+ * Allows the removal of pre- and suffixes from SOAP operation names in
+ * {@link SimpleSOAPEventType}.
+ *
+ *
+ * @param sequences
+ * sequences where the operation names are normalized
+ */
+ public static Collection> normalizeOperationNames(Collection> sequences,
+ String prefixToRemove,
+ String suffixToRemove)
+ {
Collection> normalizedSequences = new LinkedList<>();
- for(List sequence : sequences ) {
+ for (List sequence : sequences) {
List normalizedSequence = new LinkedList<>();
for (Iterator eventIter = sequence.iterator(); eventIter.hasNext();) {
@@ -333,12 +370,19 @@
SimpleSOAPEventType eventType = (SimpleSOAPEventType) event.getType();
String methodName = eventType.getCalledMethod();
- if( prefixToRemove!=null && methodName.startsWith(prefixToRemove) ) {
- methodName = methodName.substring(prefixToRemove.length(), methodName.length());
+ if (prefixToRemove != null && methodName.startsWith(prefixToRemove)) {
+ methodName =
+ methodName.substring(prefixToRemove.length(), methodName.length());
// remove prefix
- }
- if( suffixToRemove!=null && methodName.endsWith(suffixToRemove) ) {
- methodName = methodName.substring(0, methodName.length()-suffixToRemove.length());
- }
- event = new Event(new SimpleSOAPEventType(methodName, eventType.getServiceName(), eventType.getClientName(), eventType.getSoapRequestBody(), eventType.getEqualSOAPDataMap()), event.getTarget());
+ }
+ if (suffixToRemove != null && methodName.endsWith(suffixToRemove)) {
+ methodName =
+ methodName.substring(0, methodName.length() - suffixToRemove.length());
+ }
+ event =
+ new Event(new SimpleSOAPEventType(methodName, eventType.getServiceName(),
+ eventType.getClientName(),
+ eventType.getSoapRequestBody(),
+ eventType.getEqualSOAPDataMap()),
+ event.getTarget());
}
normalizedSequence.add(event);
@@ -347,4 +391,113 @@
}
return normalizedSequences;
+ }
+
+ /**
+ *
+ * Sorts the sequences by the orderingId of the requests/responses. This function only supports
+ * the ordering of {@link Event}s with a {@link SOAPEventType}.
+ *
+ *
+ * @param sequences
+ * sequences to be order
+ * @param orderType
+ * determines if sequences are ordered by request or response
+ * @return sorted sequences
+ */
+ public static Collection> sortSequences(Collection> sequences,
+ SequenceOrder orderType)
+ {
+ Collection> sortedSequences = new LinkedList<>();
+ for (List sequence : sequences) {
+ // use insertion sort
+ List sortedSequence = new LinkedList<>();
+ long lastOrderId = Long.MIN_VALUE;
+ long selectedOrderId;
+ Event selectedEvent;
+ while (sortedSequence.size() != sequence.size()) {
+ selectedEvent = null;
+ selectedOrderId = Long.MAX_VALUE;
+ for (Event event : sequence) {
+ if (!(event.getType() instanceof SOAPEventType)) {
+ throw new RuntimeException(
+ "Can only order SOAPEventTypes. SimpleSOAPEvent is also not supported. Event type found: " +
+ event.getType().getClass().getName());
+ }
+ SOAPEventType soapEventType = (SOAPEventType) event.getType();
+ long eventOrderId;
+ switch (orderType)
+ {
+ case REQUEST:
+ eventOrderId = soapEventType.getExchange().getRequest().getOrderingId();
+ break;
+ case RESPONSE:
+ eventOrderId =
+ soapEventType.getExchange().getResponse().getOrderingId();
+ break;
+ default:
+ throw new RuntimeException("unsupported order type: " +
+ orderType.toString());
+ }
+ if (eventOrderId > lastOrderId && eventOrderId < selectedOrderId) {
+ selectedOrderId = eventOrderId;
+ selectedEvent = event;
+ }
+ }
+ if (selectedEvent != null) {
+ sortedSequence.add(selectedEvent);
+ lastOrderId = selectedOrderId;
+ }
+ else {
+ throw new RuntimeException(
+ "could not select next event; possibly the same order Id for multiple exchanges events!?");
+ }
+ }
+ sortedSequences.add(sortedSequence);
+ }
+ return sortedSequences;
+ }
+
+ /**
+ *
+ * Removes calls to and from all ignored services from the sequences.
+ *
+ *
+ * @param sequences sequences where the ignored services are removed
+ * @param ignoredServicesString comma separted string that defines the ignored services
+ * @return sequences without events that reference the ignored services
+ */
+ public static Collection> removeCallsToIgnoredServices(Collection> sequences, String ignoredServicesString) {
+ Set ignoredServices = new HashSet<>();
+ if (ignoredServicesString != null) {
+ for (String service : ignoredServicesString.split(",")) {
+ ignoredServices.add(service.trim());
+ }
+ }
+ return removeCallsToIgnoredServices(sequences, ignoredServices);
+ }
+
+ /**
+ *
+ * Removes calls to and from all ignored services from the sequences.
+ *
+ *
+ * @param sequences sequences where the ignored services are removed
+ * @param ignoredServices set with all ignored service names
+ * @return sequences without events that reference the ignored services
+ */
+ public static Collection> removeCallsToIgnoredServices(Collection> sequences, Set ignoredServices) {
+ Collection> onlyAcceptedServicesSequences = new LinkedList<>();
+ for (List sequence : sequences) {
+ List onlyAcceptedServicesSequence = new LinkedList<>();
+ for (Event event : sequence) {
+ SimpleSOAPEventType eventType = (SimpleSOAPEventType) event.getType();
+ if (!ignoredServices.contains(eventType.getServiceName()) &&
+ !ignoredServices.contains(eventType.getClientName()) ) {
+ onlyAcceptedServicesSequence.add(event);
+ }
+ }
+ onlyAcceptedServicesSequences.add(onlyAcceptedServicesSequence);
+ }
+ return onlyAcceptedServicesSequences;
}