SoapUI : Get/Set property Value from groovy

Get/Set property Value of a Project from script

To be able to get a property value of a Project  from the mock Service within the same project, you can use the below command under the Script of your mockService

def varProperty = mockResponse.mockOperation.mockService.project.getPropertyValue("someProjectProperty")

And from a groovy script test step you can use

def testCaseProperty = testRunner.testCase.getPropertyValue( "MyProp" )
def testSuiteProperty = testRunner.testCase.testSuite.getPropertyValue( "MyProp" )
def projectProperty = testRunner.testCase.testSuite.project.getPropertyValue( "MyProp" )
def globalProperty = com.eviware.soapui.SoapUI.globalProperties.getPropertyValue( "MyProp" )

To be able to set the same property with a different value using command you can use the below command

mockResponse.mockOperation.mockService.project.setPropertyValue("someProjectProperty", "NewValue")

And from a groovy script test step you can use

testRunner.testCase.setPropertyValue("MyProp", "NewVal")
testRunner.testCase.testSuite.setPropertyValue("MyProp", "NewVal")
testRunner.testCase.testSuite.project.setPropertyValue("MyProp", "NewVal")
com.eviware.soapui.SoapUI.globalProperties.setPropertyValue( "MyProp", someValue )

To get/set values from the assertion script, you can use the below code in your assertion script. This kind of approach may help you with property transfer.

messageExchange.modelItem.testStep.testCase.setPropertyValue("MyProp", "NewVal")
messageExchange.modelItem.testStep.testCase.testSuite.setPropertyValue("MyProp", "NewVal")
messageExchange.modelItem.testStep.testCase.testSuite.project.setPropertyValue("MyProp", "NewVal")

You can repace the hard values with another variable to be able to optimize your code.

SoapUI : Fetching path of the project file

In order to fetch the current path of the project you can use the "projectPath" function of GroovyUtils. This example can be useful when you have to refer files which will be located within project however you do not want to perform modification every time you move them to another location on the same server or another server.

def groovyUtils = new com.eviware.soapui.support.GroovyUtils( context )
def projectDir = groovyUtils.projectPath
def csvFilePath = projectDir + testRunner.testCase.testSuite.getPropertyValue( "externalFile" )
log.info "File : " + csvFilePath

SoapUI : Externalizing target URL and TestSuite custom parameters

SoapUI's best strength is "groovy" which is almost always there to save you from specific project requirements. We had this requirement to externalize target URL of a test step and test suit, and agin groovy was there to save our day.

• You must accept that you cannot externalize everything, there will always be something that you will have to hardcode. So, we started with hardcoding the path of an external file using TestSuite's custom properties.
• Add a groovy test step under the test case you want to achieve this functionality.

def csvFilePath = testRunner.testCase.testSuite.getPropertyValue( "externalFile" )
context.fileReader = new BufferedReader(new FileReader(csvFilePath))
def groovyUtils = new com.eviware.soapui.support.GroovyUtils( context )
// Read data from external file and set property
rowsData = context.fileReader.readLines()
int rowsize = rowsData.size()
String[] dataSet
 
for(int i =0;  i < rowsize;  i++)
{
    rowdata = rowsData[i]
    String[] data = rowdata.split(";")
    testRunner.testCase.testSuite.setPropertyValue(data[0], data[1])
}
def testcases = testRunner.testCase.testSuite.getTestCaseList()
testcases.each { testcase ->
    // for all testStep inside testCase...
    def teststeps = testcase.getTestStepList()
    teststeps.each { teststep ->
        targetURL = testRunner.testCase.testSuite.getPropertyValue( teststep.getName() + "_URL" )
        teststep.setPropertyValue('endpoint', targetURL )
    }
}

In case you prefer to update the target URL/end point of the test steps withing TestSuit's setup script then you'll have to modify the script a little bit to be able to fetch the test step name.

def result =com.eviware.soapui.support.UISupport.prompt("Please select the enviornment", "Environment", ['SIT', 'UAT'])def testcases =testSuite.getTestCaseList()testcases.each { testcase ->
    def teststeps =testcase.getTestStepList()teststeps.each { teststep ->
        targetURL = testRunner.testCase.testSuite.getPropertyValue( teststep.getName() + "_URL" )
 teststep.setPropertyValue('endpoint', targetURL )
    }}

Soap Request Schema Validation : mock Services

Below script can be placed under "OnRequest Script" of a mock service to automatically validate the XML Schema compliance to the corresponding incoming request.

The script validates the incoming request and incase the request does not comply to the Schema of the WSDL then an automated fault message is sent by the mock service on behalf of the incoming request. Implementation of this script can help us overcome the situation where we have to manually validate the request sent by application to the mock service to make sure it complies to the schema structure of the WSDL.

    import com.eviware.soapui.impl.wsdl.WsdlOperation;
    import com.eviware.soapui.impl.wsdl.support.wsdl.WsdlValidator;
    import com.eviware.soapui.impl.wsdl.support.wsdl.WsdlContext;
    import com.eviware.soapui.impl.wsdl.mock.WsdlMockOperation
    import com.eviware.soapui.impl.wsdl.panels.mockoperation.WsdlMockRequestMessageExchange;
    import com.eviware.soapui.impl.wsdl.mock.WsdlMockResult;
    import com.eviware.soapui.model.iface.MessagePart
    import org.w3c.dom.Element;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    import com.eviware.soapui.support.XmlHolder;
    def requestHolder = new XmlHolder( mockRequest.requestContent);
    requestHolder.declareNamespace( "soapenv", "http://schemas.xmlsoap.org/soap/envelope/");
    validateRequest( requestHolder);

     public validateRequest( requestHolder){
      def operationElementName = getOperationElementName( requestHolder);
      def operationName = operationElementToOperationName(operationElementName);
      if( operationName == null){
       String faultstring = "VALIDATION ERROR: The operation-element '" + operationElementName +
             "' can not be found. Are request and mockup of the same version?";
       log.info( faultstring);
       return createFaultResponse( faultstring, context.mockService.getMockedOperations().get(0));
      }
      WsdlContext wsdlcontext = context.mockService.getMockedInterfaces()[0].getDefinitionContext();
      WsdlValidator validator = new WsdlValidator(wsdlcontext);
      WsdlMockOperation operation = context.mockService.getMockOperationByName( operationName);
      WsdlMockRequestMessageExchange msgExchange = new WsdlMockRequestMessageExchange(mockRequest, operation);
      def errors = validator.assertRequest(msgExchange, /*envelopeOnly*/false);
      if (errors.length > 0 ){
       String validationErrors = "VALIDATION ERRORS: " + errors.collect(){ '\n' + it };
       log.info( validationErrors);
       return createFaultResponse( validationErrors, operation);
      }
      log.info("Request Validation OK!");
     }
     private String getOperationElementName( requestHolder){
      Element bodyElement = requestHolder.getDomNode( "//soapenv:Body");
      def operationElement = bodyElement.getChildNodes().item(0);
      while (operationElement && operationElement.nodeType != 1)
      {//nodeType 1 is Element
       operationElement = operationElement.nextSibling;
      }
      def operationElementName = operationElement.getNodeName();
      if( operationElementName.contains(':')){
       operationElementName = operationElementName.split(':')[1];
      }
      return operationElementName;
     }
      
     private String operationElementToOperationName(String operationElementName) {
      for( WsdlOperation wo : context.mockService.getMockedOperations()){   
       log.info( "- Operation: " + wo.getName())
       for( MessagePart mp : wo.getDefaultRequestParts()){
        String partElementName = mp.getProperties().get("partElementName");
        if( partElementName.contains('}')){
         int idx = partElementName.indexOf('}');
         partElementName = partElementName.substring(idx+1, partElementName.length());
        }
        log.info( "   " + partElementName);
        if( operationElementName.equals(partElementName)){
         return wo.getName();
        }
       }
      }
      return null;
     }
     private WsdlMockResult createFaultResponse( String faultstring, operation){
      String content = '''<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
            <soapenv:Body>
               <soapenv:Fault>
                  <faultcode>Server</faultcode>
                  <faultstring><![CDATA[''' + faultstring + ''']]></faultstring>
            </soapenv:Fault>
            </soapenv:Body>
         </soapenv:Envelope>''';
      WsdlMockResult mr = new WsdlMockResult(mockRequest);
      mockRequest.httpResponse.writer << content;
      mockRequest.httpResponse.status = 500;
      return mr;
     }

SoapUI : Start/Stop of mock services

When you are testing an application which has various interfaces with different application, you will need many mocks to execute your unit tests. With multiple mocks it is also difficult to manage them. Think of a scenario where the application has interface with 20 or perhaps even more application/web services, and in such cases that many number of mock services. In these kind of scenarios starting and stopping all the mocks is a time taking activity. 

So, why shouldn't we automate them :)

Starting mock service

Below groovy script will help you start all the mock services in the current workspace and minimize them all.

// get Workspace environment
def Envi = context.testCase.testSuite.project.workspace
def NumberOfProject = Envi.getProjectCount()
 
// Get project list
def localProject = context.testCase.testSuite.project
 
// Get SoapUI GUI object to control the same
def SoapGUI = new com.eviware.soapui.support.UISupport()
for ( Indx in 0 .. NumberOfProject-1 ) {

    def CurrentProject = Envi.getProjectAt(Indx)
    if( localProject != CurrentProject) {

        def CountCurrentMock = CurrentProject.getMockServiceCount()
        def ListCurrentMock = CurrentProject.getMockServiceList()
        ListCurrentMock.each{

            def CurrentMockService = it
            def CurrentMockName = CurrentMockService.name
            def MockRunnerContext = CurrentMockService.getMockRunner()
            def MockModelItem = CurrentMockService.getModelItem()

            if( MockRunnerContext == null ) {

                log.info "Starting "+CurrentMockService.getName()
                def MockDesktopItem = SoapGUI.selectAndShow( MockModelItem )
                StartContextMock = CurrentMockService.start()    

            }

            else{

                log.warn "Allready started "+CurrentMockService.getName()

            }

        }

        for (ms in CurrentProject.mockServiceList){

            // Open Window and minimize it
            def mockPanel = com.eviware.soapui.support.UISupport.showDesktopPanel( ms )
            com.eviware.soapui.SoapUI.desktop.minimize( mockPanel )

        }

    }

}

Stopping mock service

Below groovy script will stop all the open mock services and close all the open windows under the current soapUI workspace.

 

    // Define object for current workspace
    def Envi = context.testCase.testSuite.project.workspace
    def NumberOfProject = Envi.getProjectCount()
     
    // Define object to get project
    def localProject = context.testCase.testSuite.project
     
    // Define object to control soapUI GUI interface
    def SoapGUI = new com.eviware.soapui.support.UISupport()
     
    for ( Indx in 0 .. NumberOfProject-1 ) {

        def CurrentProject = Envi.getProjectAt(Indx)
        if( localProject != CurrentProject) {

            def CountCurrentMock = CurrentProject.getMockServiceCount()
            def ListCurrentMock = CurrentProject.getMockServiceList()
            ListCurrentMock.each{

                def CurrentMockService = it
                def CurrentMockName = CurrentMockService.name
                def MockRunnerContext = CurrentMockService.getMockRunner()
                def MockModelItem = CurrentMockService.getModelItem()
                if( MockRunnerContext != null ) {

                    log.info "Stoping "+CurrentMockService.getName()
                    MockRunnerContext.stop()

                }
                else
                {

                    log.warn "Allready stopped "+CurrentMockService.getName()

                }

            }

        }

    }
    // Close all open windows
    com.eviware.soapui.SoapUI.desktop.closeAll()

When your project needs to target to a platform which is accessible only from a proxy, you may have to do it within SoapUI. However, when you are running your project files from a different machine, it might not be feasible to do the same . You can achieve it by putting the below script

import groovy.sql.Sql
import java.sql.DriverManager  
import java.sql.Connection  
import javax.sql.DataSource  
import java.sql.Driver;  
import java.util.*;  
import java.text.*; 
import com.orange.karma.testutils.Utils;
import com.eviware.soapui.SoapUI 
import com.eviware.soapui.settings.ProxySettings

//Set Proxy configuration
public void getProxySettings()
{
 // Get Current proxy configuration
 log.info "ENABLE_PROXY set to : " + SoapUI.settings.getString( ProxySettings.ENABLE_PROXY, "No Value set" )
 log.info "AUTO_PROXY set to : " + SoapUI.settings.getString( ProxySettings.AUTO_PROXY, "No Value set" )
 log.info "Host : " + SoapUI.settings.getString( ProxySettings.HOST, "No value set" )
 log.info "Port : " + SoapUI.settings.getString( ProxySettings.PORT, "No value set" )
}

// Define proxy settings on the project
getProxySettings()
def proxyHost = project.getPropertyValue("proxyHost")
log.info "proxyHost: > "+ proxyHost

if (proxyHost?.trim()) {
 def proxyPort = project.getPropertyValue("proxyPort")
 log.info "proxyPort: " + proxyPort + "... " + proxyHost?.trim()
 
 SoapUI.settings.setString( ProxySettings.HOST, proxyHost )
 SoapUI.settings.setString( ProxySettings.PORT, proxyPort )
 SoapUI.getSettings().setBoolean(ProxySettings.ENABLE_PROXY,true)
 SoapUI.getSettings().setBoolean(ProxySettings.AUTO_PROXY,false)
} else {
 SoapUI.getSettings().setBoolean(ProxySettings.ENABLE_PROXY,true)
 log.info "EnableProxy: " + SoapUI.settings.getString( ProxySettings.ENABLE_PROXY, "No Value set" )
}
SoapUI.saveSettings();
SoapUI.updateProxyFromSettings(); 
getProxySettings()

// Set URL for all testSteps under test cases
def testSuites =this.project.getTestSuiteList()
testSuites.each { testsuite ->
    // for all testCase inside testsuite...
    def testCases = testsuite.getTestCaseList()
    testCases.each { testcase ->
    // for all testStep inside testCase...
    def teststeps = testcase.getTestStepList() 
    targetURL = project.getPropertyValue( "EndPoint" )
    teststeps.each { teststep ->
                    teststep.setPropertyValue('endpoint', targetURL )
                                   
    }
}
}

targetURL = project.getPropertyValue( "EndPoint" )
log.info targetURL

SoapUI : set proxy from script

When your project needs to target to a platform which is accessible only from a proxy, you may have to do it within SoapUI. However, when you are running your project files from a different machine, it might not be feasible to do the same . You can achieve it by putting the below script

import groovy.sql.Sql
import java.sql.DriverManager  
import java.sql.Connection  
import javax.sql.DataSource  
import java.sql.Driver;  
import java.util.*;  
import java.text.*; 
import com.orange.karma.testutils.Utils;
import com.eviware.soapui.SoapUI 
import com.eviware.soapui.settings.ProxySettings

//Set Proxy configuration
public void getProxySettings()
{
 // Get Current proxy configuration
 log.info "ENABLE_PROXY set to : " + SoapUI.settings.getString( ProxySettings.ENABLE_PROXY, "No Value set" )
 log.info "AUTO_PROXY set to : " + SoapUI.settings.getString( ProxySettings.AUTO_PROXY, "No Value set" )
 log.info "Host : " + SoapUI.settings.getString( ProxySettings.HOST, "No value set" )
 log.info "Port : " + SoapUI.settings.getString( ProxySettings.PORT, "No value set" )
}

// Define proxy settings on the project
getProxySettings()
def proxyHost = project.getPropertyValue("proxyHost")
log.info "proxyHost: > "+ proxyHost

if (proxyHost?.trim()) {
 def proxyPort = project.getPropertyValue("proxyPort")
 log.info "proxyPort: " + proxyPort + "... " + proxyHost?.trim()
 
 SoapUI.settings.setString( ProxySettings.HOST, proxyHost )
 SoapUI.settings.setString( ProxySettings.PORT, proxyPort )
 SoapUI.getSettings().setBoolean(ProxySettings.ENABLE_PROXY,true)
 SoapUI.getSettings().setBoolean(ProxySettings.AUTO_PROXY,false)
} else {
 SoapUI.getSettings().setBoolean(ProxySettings.ENABLE_PROXY,true)
 log.info "EnableProxy: " + SoapUI.settings.getString( ProxySettings.ENABLE_PROXY, "No Value set" )
}
SoapUI.saveSettings();
SoapUI.updateProxyFromSettings(); 
getProxySettings()

// Set URL for all testSteps under test cases
def testSuites =this.project.getTestSuiteList()
testSuites.each { testsuite ->
    // for all testCase inside testsuite...
    def testCases = testsuite.getTestCaseList()
    testCases.each { testcase ->
    // for all testStep inside testCase...
    def teststeps = testcase.getTestStepList() 
    targetURL = project.getPropertyValue( "EndPoint" )
    teststeps.each { teststep ->
                    teststep.setPropertyValue('endpoint', targetURL )
                                   
    }
}
}

targetURL = project.getPropertyValue( "EndPoint" )
log.info targetURL

SoapUI Mocks : Automated response from CSV files

When you have hundreds of responses for an operation within a mockService it can be very difficult to search and modify them. This dificulty increases with the number of people who are working on the same project at the same time trying to edit these responses. Having the responses in an easy editable CSV file is much convinient. To achieve this goal we have found a solution which has been described below : 

Step 1 : Update Mock Service

Update the mockService to validate the incoming request for conformity of the request. You can refer to topic "Soap Request Schema Validation : mock Services" to achieve this level.

Step 2 : Update Operation

Open the operation under mockService and put the script below under 

Here below is full script from the above screen

// Define CSV File location and Create Object to read CSV File
def csvFilePath = "C:\\DriveOther\\Trainings\\SoapUI\\mocktest.csv"
context.fileReader = new BufferedReader(new FileReader(csvFilePath))
def groovyUtils = new com.eviware.soapui.support.GroovyUtils( context )
def holder = groovyUtils.getXmlHolder ( mockRequest.requestContent)
def today = new Date()
holder.namespaces["com"] = "http://www.dummy.com/namespace1"
holder.namespaces["cus"] = "http://www.dummy.com/namespace2"
 
def param1 = holder.getNodeValue("//com:param1")
def param2 = holder.getNodeValue("//cus:param2")
def param3 = holder.getNodeValue("//cus:param3")
 
if ( param1 != null )
 param1 = param1.toUpperCase()
if ( param2 != null )
 param2 = param2.toUpperCase()
if ( param3 != null )
 param3 = param3.toUpperCase()
 
log.info("   myOperation : received request -- $param1 : $param2 ; param3 : $param3" )
 
// Read data from file
rowsData = context.fileReader.readLines()
int rowsize = rowsData.size()
String[] dataSet
 
for(int i =0;  i < rowsize;  i++)
{
    rowdata = rowsData[i]
    String[] data = rowdata.split(",")
    if(data[3].toUpperCase() == param3)
    {
      dataSet = data
      break;
    }
}
log.info (" Data : " + dataSet)
 
if (dataSet==null)
{
 return "ResponseUnknown"
}
else
{
 if(dataSet[4]=="0")
 {
  return "NominalResponse"
 }
 else
 {
  return dataSet[4]
 }
}

The above script search for the requested data in the CSV file, if the data is found and value for "returnCode" column is "0" in the CSV file then it returns the "NominalResponse" otherwise returns the response which is mentioned in the place of returnCode under the CSV file. If both these case are failed then it returns "ResponseUnknown". 

Step 3 : Update the Response

The next step is to update the nominal response and parameterize the values with the actual results from the CSV file. Here a new search is made to the CSV file and corresponding data is fetched. Since we already know that the data exist in the CSV file hence no alternate is given, however you are free to improve this script as per your need.

Put the below script (need to udpated for each webservice and each operation) in the "Script" tab of the "NominalResponse". This script fetch the corresponding data from the CSV file and put it in place of the context variables which are used in the response.

// Define CSV File location and Create Object to read CSV File
def csvFilePath = "C:\\DriveOther\\Trainings\\SoapUI\\mocktest.csv"
context.fileReader = new BufferedReader(new FileReader(csvFilePath))
def groovyUtils = new com.eviware.soapui.support.GroovyUtils( context )
def holder = groovyUtils.getXmlHolder ( mockRequest.requestContent)
def today = new Date()
def devStbLcd
holder.namespaces["com"] = "http://www.dummy.com/ns1"
holder.namespaces["cus"] = "http://www.dummy.com/ns2"
 
def param1 = holder.getNodeValue("//com:param1")
def param2 = holder.getNodeValue("//cus:param2")
def param3 = holder.getNodeValue("//cus:param3")
 
if ( param1 != null )
 param1 = param1.toUpperCase()
if ( param2 != null )
 param2 = param2.toUpperCase()
if ( param3 != null )
 param3 = param3.toUpperCase()
 
log.info("   GetDeviceFirstLastConnectionDates : received request -- $param2 : $param3 ; param1 : $param1" )
 
// Read data from file
rowsData = context.fileReader.readLines()
int rowsize = rowsData.size()
String[] dataSet
 
for(int i =0;  i < rowsize;  i++)
{
    rowdata = rowsData[i]
    String[] data = rowdata.split(",")
    if(data[3].toUpperCase() == param3)
    {
      dataSet = data
      break;
    }
}
log.info (" Data : " + dataSet)
context.returnCode = dataSet[4]
context.rfm = dataSet[5]
context.fcd = dataSet[6]
if(dataSet[7] == "0")
{
 devStbLcd = today
}
else
{
 devStbLcd = today - 365
}
context.lcd = devStbLcd.format("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")

The above script has to be made common for all the common responses, if any special case response  is required then add the special case in the CSV file and in the response list and update the scripts according to your needs.