Esempio n. 1
0
 @Override
 public void gatherArtifactInfo(ArtifactInfoContext aic) {
   SimpleMethod simpleMethodToCall;
   try {
     simpleMethodToCall = SimpleMethod.getSimpleMethod(this.xmlURL, this.methodName);
     if (simpleMethodToCall != null) {
       if (!aic.hasVisited(simpleMethodToCall)) {
         aic.addSimpleMethod(simpleMethodToCall);
         simpleMethodToCall.gatherArtifactInfo(aic);
       }
     }
   } catch (MiniLangException e) {
     Debug.logWarning(
         "Could not find <simple-method name=\""
             + this.methodName
             + "\"> in XML document "
             + this.xmlResource
             + ": "
             + e.toString(),
         module);
   }
 }
Esempio n. 2
0
 public CallSimpleMethod(Element element, SimpleMethod simpleMethod) throws MiniLangException {
   super(element, simpleMethod);
   if (MiniLangValidate.validationOn()) {
     MiniLangValidate.attributeNames(
         simpleMethod, element, "method-name", "xml-resource", "scope");
     MiniLangValidate.requiredAttributes(simpleMethod, element, "method-name");
     MiniLangValidate.constantAttributes(
         simpleMethod, element, "method-name", "xml-resource", "scope");
     MiniLangValidate.childElements(simpleMethod, element, "result-to-field");
   }
   this.methodName = element.getAttribute("method-name");
   String xmlResourceAttribute = element.getAttribute("xml-resource");
   if (xmlResourceAttribute.isEmpty()) {
     xmlResourceAttribute = simpleMethod.getFromLocation();
   }
   this.xmlResource = xmlResourceAttribute;
   URL xmlURL = null;
   try {
     xmlURL = FlexibleLocation.resolveLocation(this.xmlResource);
   } catch (MalformedURLException e) {
     MiniLangValidate.handleError(
         "Could not find SimpleMethod XML document in resource: "
             + this.xmlResource
             + "; error was: "
             + e.toString(),
         simpleMethod,
         element);
   }
   this.xmlURL = xmlURL;
   this.scope = element.getAttribute("scope");
   List<? extends Element> resultToFieldElements =
       UtilXml.childElementList(element, "result-to-field");
   if (UtilValidate.isNotEmpty(resultToFieldElements)) {
     if (!"function".equals(this.scope)) {
       MiniLangValidate.handleError(
           "Inline scope cannot include <result-to-field> elements.", simpleMethod, element);
     }
     List<ResultToField> resultToFieldList =
         new ArrayList<ResultToField>(resultToFieldElements.size());
     for (Element resultToFieldElement : resultToFieldElements) {
       resultToFieldList.add(new ResultToField(resultToFieldElement, simpleMethod));
     }
     this.resultToFieldList = resultToFieldList;
   } else {
     this.resultToFieldList = null;
   }
 }
Esempio n. 3
0
 @Override
 public boolean exec(MethodContext methodContext) throws MiniLangException {
   if (UtilValidate.isEmpty(this.methodName)) {
     throw new MiniLangRuntimeException("method-name attribute is empty", this);
   }
   SimpleMethod simpleMethodToCall = SimpleMethod.getSimpleMethod(this.xmlURL, this.methodName);
   if (simpleMethodToCall == null) {
     throw new MiniLangRuntimeException(
         "Could not find <simple-method name=\""
             + this.methodName
             + "\"> in XML document "
             + this.xmlResource,
         this);
   }
   MethodContext localContext = methodContext;
   if ("function".equals(this.scope)) {
     Map<String, Object> localEnv = new HashMap<String, Object>();
     localEnv.putAll(methodContext.getEnvMap());
     localEnv.remove(this.simpleMethod.getEventResponseCodeName());
     localEnv.remove(this.simpleMethod.getServiceResponseMessageName());
     localContext =
         new MethodContext(localEnv, methodContext.getLoader(), methodContext.getMethodType());
   }
   String returnVal = simpleMethodToCall.exec(localContext);
   if (Debug.verboseOn())
     Debug.logVerbose(
         "Called simple-method named ["
             + this.methodName
             + "] in resource ["
             + this.xmlResource
             + "], returnVal is ["
             + returnVal
             + "]",
         module);
   if (simpleMethodToCall.getDefaultErrorCode().equals(returnVal)) {
     if (methodContext.getMethodType() == MethodContext.EVENT) {
       methodContext.putEnv(
           simpleMethod.getEventResponseCodeName(), simpleMethod.getDefaultErrorCode());
     } else if (methodContext.getMethodType() == MethodContext.SERVICE) {
       methodContext.putEnv(
           simpleMethod.getServiceResponseMessageName(), simpleMethod.getDefaultErrorCode());
     }
     return false;
   }
   if (methodContext.getMethodType() == MethodContext.EVENT) {
     // FIXME: This doesn't make sense. We are comparing the called method's response code with
     // this method's
     // response code. Since response codes are configurable per method, this code will fail.
     String responseCode =
         (String) localContext.getEnv(this.simpleMethod.getEventResponseCodeName());
     if (this.simpleMethod.getDefaultErrorCode().equals(responseCode)) {
       Debug.logWarning(
           "Got error ["
               + responseCode
               + "] calling inline simple-method named ["
               + this.methodName
               + "] in resource ["
               + this.xmlResource
               + "], message is "
               + methodContext.getEnv(this.simpleMethod.getEventErrorMessageName()),
           module);
       return false;
     }
   } else if (methodContext.getMethodType() == MethodContext.SERVICE) {
     // FIXME: This doesn't make sense. We are comparing the called method's response message with
     // this method's
     // response message. Since response messages are configurable per method, this code will fail.
     String responseMessage =
         (String) localContext.getEnv(this.simpleMethod.getServiceResponseMessageName());
     if (this.simpleMethod.getDefaultErrorCode().equals(responseMessage)) {
       Debug.logWarning(
           "Got error ["
               + responseMessage
               + "] calling inline simple-method named ["
               + this.methodName
               + "] in resource ["
               + this.xmlResource
               + "], message is "
               + methodContext.getEnv(this.simpleMethod.getServiceErrorMessageName())
               + ", and the error message list is: "
               + methodContext.getEnv(this.simpleMethod.getServiceErrorMessageListName()),
           module);
       return false;
     }
   }
   if ("function".equals(this.scope) && this.resultToFieldList != null) {
     Map<String, Object> results = localContext.getResults();
     if (results != null) {
       for (ResultToField resultToField : this.resultToFieldList) {
         resultToField.exec(methodContext.getEnvMap(), results);
       }
     }
   }
   return true;
 }
Esempio n. 4
0
  @Override
  public void run(TestResult result) {
    result.startTest(this);

    try {
      // define request
      Security security = SecurityFactory.getInstance(delegator);
      MockServletContext servletContext = new MockServletContext();
      request.setAttribute("security", security);
      request.setAttribute("servletContext", servletContext);
      request.setAttribute("delegator", delegator);
      request.setAttribute("dispatcher", dispatcher);
      Map<String, Object> serviceResult =
          SimpleMethod.runSimpleService(
              methodLocation,
              methodName,
              dispatcher.getDispatchContext(),
              UtilMisc.toMap(
                  "test",
                  this,
                  "testResult",
                  result,
                  "locale",
                  Locale.getDefault(),
                  "request",
                  request,
                  "response",
                  response));

      // do something with the errorMessage
      String errorMessage = (String) serviceResult.get(ModelService.ERROR_MESSAGE);
      if (UtilValidate.isNotEmpty(errorMessage)) {
        result.addFailure(this, new AssertionFailedError(errorMessage));
      }

      // do something with the errorMessageList
      List<Object> errorMessageList =
          UtilGenerics.cast(serviceResult.get(ModelService.ERROR_MESSAGE_LIST));
      if (UtilValidate.isNotEmpty(errorMessageList)) {
        for (Object message : errorMessageList) {
          result.addFailure(this, new AssertionFailedError(message.toString()));
        }
      }

      // do something with the errorMessageMap
      Map<String, Object> errorMessageMap =
          UtilGenerics.cast(serviceResult.get(ModelService.ERROR_MESSAGE_MAP));
      if (!UtilValidate.isEmpty(errorMessageMap)) {
        for (Map.Entry<String, Object> entry : errorMessageMap.entrySet()) {
          result.addFailure(
              this, new AssertionFailedError(entry.getKey() + ": " + entry.getValue()));
        }
      }

    } catch (MiniLangException e) {
      result.addError(this, e);
    } catch (SecurityConfigurationException e) {
      result.addError(this, e);
    }

    result.endTest(this);
  }