Beginning soapUI Scripting 6: The XmlHolder Class and Working with CDATA

You can download a project containing examples using the XmlHolder class (including the script covered in detail in this post) here.  While I discuss XPath expressions here, a detailed explanation of how they work is beyond the scope of this post-- if you're unfamiliar with XPath, I highly recommend this tutorial at www.w3schools.com.

In this post I'll be looking at soapUI's XmlHolder class, which provides methods to work easily with XML data within scripts.  As you'll see, adding it to your toolbox can open up a lot of new and very useful possibilities, including the ability to mimic XPath assertions.  You may be asking yourself why you'd want to do that-- XPath assertions are included as a standard assertion type, after all, and shouldn't require any additional scripting.  But if you've looked at any of my extended tutorials working with the PeriodicTable sample web service, you've actually seen one scenario where the XmlHolder class could come in handy: working with CDATA.

The CDATA Problem

Below is a screenshot from soapUI that shows the response to a test request to the GetAtomicNumber operation of the aforementioned PeriodicTable web service.  The operation takes the name of an element (hydrogen in this case) as an argument and responds with information about certain properties of that element-- including, of course, its atomic number:



A response from the GetAtomicNumber operation
The XML block containing information about hydrogen is returned as a CDATA section-- it's a string that's returned as the value of the GetAtomicNumberResult node.  Consequently, if you try to create a single standard XPath assertion looking for any of the nodes contained within that CDATA section (if you try to assert that the value of the MeltingPoint element is 14, for example) you'll run into problems.

You could just deal with this with a basic Contains assertion, looking for the MeltingPoint node as a string.  Since the Contains assertion looks at the entire response as a string, the issues related to parsing XML with a CDATA section are bypassed.  However, you may have a particular situation where you can't or don't want to use a Contains assertion.

SoapUI's site provides a detailed explanation of how to deal with this scenario here.  In a nutshell, you can use one XPath expression to isolate the CDATA section, effectively stripping off the rest of the XML in which it's embedded.  Once isolated, you can use further XPath expressions on the XML in the CDATA section.

Scripting may not be necessary in some scenarios where you can use two XPath expressions together (in a Property Transfer step, for example, where you can specify multiple transfers).  If you're trying to create an assertion against a test request that uses CDATA, however, some scripting will probably be required-- and the methods provided by the XmlHolder class can make things a whole lot easier.

Sample Script Using the XmlHolder Class

Let's jump right into a short script.  If you've downloaded the sample project, this is the Groovy assertion for the GetAtomicNumber test request test step (comments are excluded here); it tackles the problem I gave above as an example: verifying that the value of the MeltingPoint XML element is 14:

import com.eviware.soapui.support.XmlHolder

respXmlHolder = new XmlHolder(messageExchange.getResponseContentAsXml())
respXmlHolder.declareNamespace("ns1","http://www.webserviceX.NET")
CDATAXml = respXmlHolder.getNodeValue("//ns1:GetAtomicNumberResult")
log.info(CDATAXml)
CDATAXmlHolder = new XmlHolder(CDATAXml)
meltPoint = CDATAXmlHolder.getNodeValue("//MeltingPoint")
log.info("Melting Point = $meltPoint")
assert meltPoint == "14"

Let's look at this script line by line:

import com.eviware.soapui.support.XmlHolder

The XmlHolder class is not included with soapUI's core components; therefore, this line is required to import it from its package, the com.eviware.soapui.support package, for use in the script.

respXmlHolder = new XmlHolder(messageExchange.getResponseContentAsXml())

This line creates a new XmlHolder object and assigns it to the variable respXmlHolder.  The XmlHolder constructor (the method used to create our new XmlHolder object-- the constructor has the same name as the class itself and is preceded by the new keyword) takes a string of XML as an argument.  In this case, the XML we're interested in getting is our response data-- and conveniently, soapUI provides us with the built-in messageExchange variable in script assertions.  We can use this variable's getResponseContentAsXml() method to quickly get our test request's response XML (as a string).  We end up with an XmlHolder object that contains and can act on our response XML.

respXmlHolder.declareNamespace("ns1","http://www.webserviceX.NET")
CDATAXml = respXmlHolder.getNodeValue("//ns1:GetAtomicNumberResult")
log.info(CDATAXml)

In these lines we're using our XmlHolder object (respXmlHolder) to use an XPath expression with the response XML.  The first line declares a namespace to use in our XPath expression, assigning the URI "http://www.webserviceX.NET" to the prefix "ns1".  In the next line, the XPath expression itself is passed as an argument (a string) to the getNodeValue() method of the XmlHolder object; note how the XPath expression uses the namespace prefix we just defined in the previous line: //ns1:GetAtomicNumberResult.  This XPath expression returns the value of the GetAtomicNumberResult element in the response XML, which is the CDATA section.  The result of the evaluation is assigned to the variable CDATAXml and (for informational purposes only) the contents of CDATAXml are written to the script log-- you should see a string of XML in the log starting (and ending) with a "NewDataSet" tag:



At this point we've basically isolated the CDATA section of our original XML response; now we can use that data with XPath expressions.

CDATAXmlHolder = new XmlHolder(CDATAXml)
meltPoint = CDATAXmlHolder.getNodeValue("//MeltingPoint")
log.info("Melting Point = $meltPoint")

These lines are similar to preceding lines, repeating many of the same actions.  In the first line we create another XmlHolder object, this time using the variable CDATAXml as the argument to its constructor, and assign it to variable CDATAXmlHolder.  In the second line, we use the getNodeValue() method to evaluate the XPath expression //MeltingPoint.  The result of the evaluation is assigned to the variable meltPoint and written to the script log:



Finally, we have our assertion:

assert meltPoint == "14"

The assertion checks to make sure the value we previously retrieved from the MeltingPoint element matches its expected value.  There's one crucial thing to note here: the getNodeValue() method returns a string value.  This is taken into account in our assertion, which checks that the value of meltPoint matches "14"-- the string representation of the number 14-- instead of a pure numeric representation.

One final note: I see a NullPointerException when the getNodeValue() method is used in an assert statement and the assertion fails (there's no error if the assertion passes).  I'm not sure if this is an as yet unidentified issue with my script or a minor bug in soapUI (I'm using version 4.5.1).  Passing the result of the getNodeValue() method to a variable and then using that variable with the assert statement (as I did in the example above) seems to avoid the error.

I'll look at some key points in the remaining assertion scripts in the example project in my next post.