Wednesday, November 3, 2010

Features Gained with SOAP UI Pro Version

This documents differences between the free and Pro version of SOAP UI, as determined solely from browsing the SOAP UI website. This might be useful in determining if the free 14-day trial of the Pro version is worth your time.

SOAP UI offers these high-level docs around the differences:

SOAP UI Product Comparison
SOAP UI - The Value (PDF)

The bullet points here were pulled directly from those docs, plus some additional ones (and the inline detail) from the tutorials; some of their bullet points were omitted because either I could find no additional detail, they seemed to overlap other features already mentioned, or they didn't seem worth mentioning. Here are the features that seemed to provide some value-add:

  • scripting libraries (note that Groovy/Javascript are available since v3.0):

soapUI Pro adds the possibility to have a central library of Groovy Classes that can be accessed from any script within soapUI, which can be useful for centralizing common tasks and functionality and for creating soapUI extensions.

-- so this means an ability to create a reusable set of Groovy modules.

  • advanced reporting

soapUI Pro provides extensive reporting functionality including reports on different levels (project, Test Suite,Test Case ...) and different formats like pdf, cvs, xls and xml as well as easy customization options. Use soapUI to create reports and use your valuable resources on something else.

  • Load testing: Reporting, Statistics Exporting

Create Printable Reports or export underlying report data to XML or CSV files (see this writeup)

  • Maven 2

...apparently there are some maven plugin settings available in Pro version only, around report formatting, etc. - see this writeup.

  • Contract Coverage

soapUI Pro provides unique contract coverage functionality. Reliable coverage figures are fundamental for effective testing; knowing what you have tested and what you haven’t is great support when you shall decide if you have tested enough or where to focus you r efforts next. Coverage metrics are also useful showing compliance to customer requirements.

  • Data Source Driven Tests

One of the major time consumers when testing applications is going through lots of different data sets in order to test the functionality of a Web Service. This is easily solved in soapUI Pro with the DataSource TestStep where you can connect to a data source and feed the Web Service with data. (tutorial:

soapUI Pro provides functionality for easily creating and running data driven tests. The time savings are huge; with soapUI Pro a Test Case can be created in minutes instead of alternatives taking several hours. Yet bigger savings can be made using soapUI Pro for data driven load tests or for test chaining where the result from one test case can be used as input to another test case.

SoapUI Pro adds a number of useful features to the already feature-packed open-source version. One of the most popular is the DataSource TestStep, which together with the DataSourceLoop TestStep makes the creation of complex data driven tests a breeze (almost), allowing you to use data from a number of sources (Excel, JDBC, XML, etc) to drive and validate your functional TestCases. You can even combine multiple DataSources to have them feed each other. (

  • Functional, LoadTest, Mock services feature: Opens the generated report in a browser
  • Coverage: WSDL, Test Case, Test Suite, ... etc various others - see this writeup

soapUI Pro introduces the unique concept of Web Service Coverage, which dynamically allows you to analyze how much of a given SOAP or REST Web Service is being covered by your Functional Tests, MockServices, Mock Clients and SOAP Monitor clients and targets. (see

Simplified testing when you have CDATA in responseremove ... CDATA tags before soapUI processes the response so it is seen as standard XML ... Sure, it wouldn't be compliant with the original schema, but it would make transfers and assertions so much easier. ...Event Handlers in soapUI Pro can do this for us...(

  • Requirements Management

soapUI Pro provides basic functionality for requirements management. You can in an easy way add, remove, edit, import and export requirements. Links from a requirement to specific test cases can be used to verify that your product fulfills a set of requirements. (

  • Form Based input for easy manual testing

soapUI Pro provides functionality to create request messages in an easy way. The basic format for request messages is XML. This function provides a user friendly form-based interface where you can create request messages without knowing XML. Even people with deep XML knowledge can benefit from this feature; you get a better overview and the editing work goes much faster.

  • SOAP monitoring 

...allows you to monitor, record, analyze and even modify SOAP traffic as it is been transferred between an existing client and server application. It even supports WS-Security and SSL decryption (if you have all the necessary keystores available) for digging into encrypted messages. (

  • Team-based projects

soapUI Pro provides functionality crucial for team testing. In a project involving several people you often come to a situation where two team members are updating different test cases at the same time. If you only have one project file it’s impossible to make simultaneous updates and it’s very hard to synchronize the test cases manually.

  • Test refactoring

soapUI Pro provides functionality valuable when updating your SOA. If the data structures change, for example renaming of information elements, soapUI Pro will go through your tests and automatically update all references to the element name in all your tests. This saves time; a change can be made in minutes instead of days or even weeks, and it gives you peace in mind; you  know that the name has been changed wherever it’s used. 

When updating a WSDL, the underlying contract changes may require changes to all messages related to a certain modification, for example if an element has been renamed or moved. Also, XPath expressions in assertions, property transfers and expansions, etc. may need to be updated to correctly reference updated elements.

The WSDL Refactoring feature in soapUI Pro aims at greatly easing this update process by providing a wizard allowing you to map old message elements to new ones, resulting in automatically updated message content and xpath expressions. You always have the possibility to manually override or discard those changes created by soapUI during the process, ensuring that the correct result comes out in the end.

    JDBC appears to be available in both free (v3.5 - see and Pro versions; the Pro version adds these:

  • XPath Wizards

soapUI Pro provides functionality to generate XPath code automatically. This function saves a lot of time; generating one single XPath expression by hand can take several minutes and with this feature you’ll do it in a few seconds. It’s highly appreciated by all kinds of testers, both technical and non-technical. Most of our users apply this feature frequently and many state that they  don’t know how they managed to do their work before they had it.

  • Graphic SQL builder

The Pro version has a very useful additional feature of using a connection configured at the project level and a graphical wizard for building the SQL query....soapUI Pro provides functionality to create complex Database Queries without deep SQL skills. This lowers the threshold for anyone who wants to start testing and makes life easier for more experienced testers.

...see for more on that....and in general, see

Finally, available in Pro version:

  • Support
  • Training


  1. Thanks for posting this very useful information Gary. There were quite a few things on there that I didn't realize. Now I might have to convince my boss to buy an upgrade!

  2. Glad to help, Nick. We're still evaluating the cost-benefit - I was charged with doing this initial research, but not quite sure what our tester wants to do with it. If you do upgrade, let me know what you think. Product literature is one thing - but hands-on experience is much more relevant.