Introduction
I had a requirement to capture the response from at least 100 calls to a web service. This was to enable a manual check of the response by a non IT staff member who needed the responses in the form of an Excel file.
I was able to complete this using the free version of SoapUI 4.6.4 utilizing some groovy scripting. You may also like to download Fiddler2 to check things are working.
The scripting was largely a cut and paste job using code provided by M. McDonald at http://forum.loadui.org/viewtopic.php?f=5&t=16354#p38935.
If you are not familiar with SoapUI Groovy and Java, it can be very confusing but don't despair!
SoapUI Set up
Download a free version of SoapUI and install it.
When you first run it, it looks something like:
I have created a workspace to store my projects in called Automation. At this point, we go to ‘File’-> ‘New Soap Project’ and fill in the Project Name and the location of the .wsdl file for the web service.
Ensure you tick 'Create Requests' and 'Create TestSuite', then click 'OK'.
SoapUI will check the web service and return all the operations/methods you can call on that service. In my case, there is only one operation called SubmitRequestResponse, but I have selected 'Single TestCase with One Request for Each Operation' anyway.
Click 'OK' and you will be prompted to name the Test.
I called mine 'Multiple Calls TestSuit'.
Now when SoapUI has setup the project, expand the structure to look something like this:
If you double click on Request 1, you get a basic request form.
We need to ensure that the calls will get a response from the web service before we proceed so we add a soap request. In my case, the web service requires a customer number followed by a site location tag followed by one or more SalesOrders. So I replace the <part>?</part> tags in the body with my soap request.
Click the green arrow (top left) and you will get an XML response.
If you have a response, you are where you need to be.
Setting up the Test Files, Test Steps and Test Scripts
At this point, we know that SoapUI can send requests to our web service and return a response.
Now we need to set up our Test Steps and Test Scripts.
The Test files
Create a directory in your file system and add two subdirectories.
In requests, we need to add the request files.
The files must be of the same format that you added in Request 1, i.e.:
<ns0:CheckGuaranteeRequest xmlns:ns0="http://www.####.com/namespaces/portal/checkguarantee/in/2014.03">
<CustomerNumber>102277</CustomerNumber>
<SiteLocation>COAST</SiteLocation>
<SalesOrders>
<Id>1000495222</Id>
<Id>1000498217</Id>
</SalesOrders>
</ns0:CheckGuaranteeRequest>
They must also have a file extension of .xml.
The Test Steps
Examine the structure of the project and ensure that the Test Steps (1) section is expanded. Double clicking the SubmitRequestResponse shows a basic soap header. We can ignore this for now.
Right click the Test Steps header and select 'Add Step' and choose 'Groovy Script'.
Rename it to Step1.
Click 'OK' and the Groovy editor will appear.
It is here that we add our first script.
The Scripts
The test scripts were supplied by M. McDonald (see above).
Script 1
The first script is:
def fileList = []
new File("C:\\requests").eachFile { f ->
if (f.isFile() && f.name.endsWith('.xml')) {
def filename = f.name[0..-5]
fileList.add(filename)
}
}
if (fileList.size() < 1) {
testRunner.fail("No request files")
}
context.put('fileList', fileList)
The first step defines an array.
Next is a section that creates a file from our test files directory and adds it to the fileList array. It also trims off some characters, checks the size of the array to ensure some files exist, then adds the array to the 'context object' so the array is available to the other test steps we will create.
We need to change the second line to reflect the paths to our files and add a quick check.
In my case, the script becomes:
def fileList = []
new File("C:\\GroovyTest\\requests").eachFile
{ f ->
if (f.isFile()&& f.name.endsWith('.xml'))
{
def filename = f.name[0..-1]
fileList.add(filename)
log.info filename
}
}
if (fileList.size() <1)
{
testRunner.fail("No request files found")
}
context.put('fileList',fileList)
The line 'log.info filename' causes the names of the files in the request directory to be printed to the script log.
Click the script log button at the bottom of the Step1 window, then click the green arrow top left to run the script. You should see the list of files printed out.
Ok so far. We have successfully read the names of the files in our request directory and displayed them. It might be good at this point to comment out the line which prints out the filenames from the array.
Script 2
We already have step 2, it's called SubmitRequestResponse. Rename it to 'Step2'.
Remove the ' <part>?</part>' nodes in the body of the Soap request and add the following:
${=new File("C:\\GroovyTest\\requests\\" + (context.get('fileList')).last()).text}
NOTICE I HAVE CHANGED THE PATH TO THE REQUEST DIRECTORY !!!
We now need to drag Step2 below Step1 in the project structure, so it looks like:
We can now test both scripts to see if they are working.
Time to Set Up Fiddler
Just Install Fiddler Web Debugger.
Fiddler allows you to monitor what you are sending to and what you are receiving from the web service.
When you open Fiddler, it needs a little configuration in order for you to view the traffic to and from your web service. In the Taskbar, go to 'Tools' -> Fiddler options and open the connections tab. Fiddler normally listens on port 8888, so change this to 8080 as below:
That’s it for Fiddler.
Go back to SoapUI and look at 'File'-> 'Preferences'-> 'Proxy Settings'. My settings are set to 'Automatic'. I had some problems with this as I was initially using SSL.
My 'HTTP Settings' are set to the default options. A good site to set up Fiddler with SoapUI is:
By Dinesh K Mandal, 8 Sep 2011.
To test if everything is working, go back to SoapUI and double click your test case. In my case, it's called 'BasicHttpBinding_ITwoWayAsync TestSuite'.
The test case window will appear:
You might be lucky here and see a session appear in Fiddler like this:
This is good. If you didn’t see a session appearing, save everything in SoapUI and restart it, then try again.
Go back to SoapUI.
In the Test case window, click the green arrow to run the test steps:
Take a look at Fiddler and you will see a session has been captured.
If you click on the session and view the results as XML, you will see the request going to the web service in the top panel and the response from the web service in the bottom panel.
We have successfully called our web service and had a response returned. We now need a step to save the response to a file.
Script 3
Back to SoapUI and right click on 'Test Steps (2) and select 'Add Step' ->'Groovy Script'. Rename it to 'Step3'.
Add the following script to the Groovy window, changing the directories to match your directory structure.
def fileList = context.get('fileList')
def fileName = fileList.pop()
def newname = fileName[0..-5]
def response = context.expand( '${Step2#Response}' )
def f = new File("C:\\GroovyTest\\responses\\${fileName}_Response.xml")
f.write(response, "UTF-8")
if(fileList.size() >0)
{
testRunner.gotoStepByName("Step2")
}
This piece of scripting gets the array from the context (see Step1), takes a file from the array, gets its name and removes the .xml from name. It then gets the response that was returned from Step2 and stores it as 'response'.
It then creates a new file in the response directory and names it as the old file but also adding ' _Response.xml' to the file name.
It then writes the response from the web service into the file.
There is a final section that checks the size of the array and if it is greater than 0, there is still a test to run so the gotoStepByName function says goto 'Step2'.
Double click the 'Test Steps (3)’ test case and run the Test Suite.
Check Fiddler and take a look in the Response directory.
This was to save me grief in the future but hey the real information was from M. McDonald and Dinesh K. Mandal.
Hope it helps someone else.
