Detyped WS contract browsing and endpoint invocation

In response to some good feedback received from the community after the recent 2.0 release, I've been enriching the API of Wise Core to further simplify ws testing using it.
Till now the Wise core API has fundamentally been based on the WSEndpoint, WSMethod, WebParameter abstraction:

	public interface WSEndpoint {
	public Map<String, WSMethod> getWSMethods();
	public ClassLoader getClassLoader();
	// ...
	}
	public interface WSMethod {
	public InvocationResult invoke(Object args) throws InvocationException, IllegalArgumentException, MappingException;
	public Map<String, ? extends WebParameter> getWebParams();
	// ...
	}
	public interface WebParameter {
	public String getName();
	public Type getType();
	// ...
	}

view raw gistfile1.java hosted with ❤ by GitHub

A given WSDL contract is mapped to at least one WSEndpoint instance having one or more WSMethod instances. Each WSMethod can have multiple WebParameter objects depending on the WSDL operation signature. By inspecting the type information in WebParameter instances, the user is meant to build the actual objects to be passed as arguments to WSMethod:invoke(Object args). While effective, this might turn out to be not very practical and easy (due to reflection, see here) if the consumed WSDL contract is complex and includes multiple nested schema types.
It's well known that Wise core supports Smooks transformations, with the sake of allowing conversion of existing application data models into the object structure required for performing the invocation. However that's not really helping a lot when the target is programmatically testing a given endpoint.
In particular some users expressed the interest in the tree view offered by the Wise GUI on top of the core model: similarly to what is shown in the GUI, a tree model (think about e.g. the DOM tree approach) could be provided to describe each parameter type of a given WSMethod. Each element of the tree would allow getting children and setting values (for leaves only). So here is what I came up with:

	public interface Element extends Serializable, Cloneable {
	public boolean isLeaf();
	public boolean isRemovable();
	public Type getClassType();
	public String getName();
	public boolean isNil();
	public void setNil(boolean nil);
	public String getId();
	public boolean isNillable();
	public boolean isGroup();
	public void removeChild(String id);
	public Element getChild(String id);
	public Element getChildByName(String name);
	public Iterator<String> getChildrenIDs();
	public Iterator<? extends Element> getChildren();
	public String getValue();
	public void setValue(String value);
	public Element getPrototype();
	public Element incrementChildren();
	public int getChildrenCount();
	public boolean isLazy();
	public boolean isResolved();
	public Element clone();
	public Object toObject();
	}

view raw Element.java hosted with ❤ by GitHub

The current Wise core 2.0.1-SNAPSHOT features an implementation of the Element interface above, as well as a builder implementation for converting a WebParameter into an Element tree:

	public interface ElementBuilder {
	public ElementBuilder client(WSDynamicClient client);
	public ElementBuilder request(boolean request);
	public ElementBuilder useDefautValuesForNullLeaves(boolean useDefValuesForNullLeaves);
	public Element buildTree(Type type, String name, Object value, boolean nillable);
	}

view raw ElementBuilder.java hosted with ❤ by GitHub

The end result is in a really simplified contract browsing of a WS endpoint as well as simple invocation (see the integration test here too):

	//select a method and the parameter(s) to deal with...
	WSMethod method = client.getWSMethod("RegistrationServiceImplService", "RegistrationServiceImplPort", "Register");
	Map<String, ? extends WebParameter> pars = method.getWebParams();
	WebParameter customerPar = pars.get("Customer");
	//browse the paramter structure and eventually populate the parameter...
	ElementBuilder builder = ElementBuilderFactory.getElementBuilder().client(client).request(true).useDefautValuesForNullLeaves(true);
	Element customerElement = builder.buildTree(customerPar.getType(), customerPar.getName(), null, true);
	customerElement.getChildByName("id").setValue("1234");
	customerElement.getChildByName("name").getChildByName("firstName").setValue("Foo");
	customerElement.getChildByName("name").getChildByName("lastName").setValue("Bar");
	customerElement.getChildByName("name").getChildByName("middleName").setValue("The");
	//convert back the tree to an Object and perform the invocation...
	Map<String, Object> args = new java.util.HashMap<String, Object>();
	args.put(customerElement.getName(), customerElement.toObject());
	InvocationResult result = method.invoke(args);

view raw gistfile1.java hosted with ❤ by GitHub

The tree view can of course be used to convert and access the data returned in the InvocationResult instance.
Please note how the parameters type info is completely hidden to the user, who basically ends up setting string values for leaves elements. Strings are parsed into proper primitives (and wrappers) depending on the actual parameter type. Wise default Element impl is currently able to convert values to String, Character, all numerical types, QName, XMLGregorianCalendar and Duration classes.
So, leveraging Wise, a user can invoke / test an endpoint by browsing its contract and setting parameters in a fully dynamic and detyped way, while still being sure the generated SOAP request is compliant with the contract requirements and constraints.

The additions described above are currently being tested and will be included soon in next release. Any comment / feedback is welcome as usual!

Wise is back

It's been a couple of years since we wrote here last time. At least from my point of view, the project has basically been on hold while waiting for the underlying ws layer to stabilize (and for me to have time to update its integration here ;-)). Moreover we've been kind of waiting for the web gui work to come to an end, but unfortunately that never really took off due to lack of time from the contributors working on it. Anyway, in the mean time, both application server and its WS layer made giant steps ahead and JBoss AS 7 series comes today with a fully compliant web services stack based on a proper Apache CXF integration. Last summer I actually updated and cleaned-up the wise-core, made it build with Maven 3 and added support for AS 7, however that was not enough for a release. More recently I decided to invest some energies (and most of my spare time ;-)) on creating a GUI for the basic wise functionalities, basically what we had in the project before the donation to JBoss / Red Hat. So I basically started from one of the very nice JBoss Developer Framework quickstarts and built a JavaEE 6 web app based on CDI and JSF 2 (using RichFaces 4.3). I have to say that it actually turned out to be easier / faster then I expected to get to what you see in the snapshots below.
The GUI is basically a fully dynamic, single page webapp for quickly invoking webservice endpoints without the need of generating and compiling client stubs or directly writing SOAP xml messages. You start by typing the URL of the wsdl contract you want to consume (you can provide username and password if required, http basic auth only supported atm):

then you click on "OK" button and let Wise fetch the wsdl, parse it together with any referenced schema and finally present you a list of available endpoint operations:

you select an operation and Wise shows a tree representing the input parameters for that:

you can fill in input boxes with data, enable/disable elements (for nillable ones only) and add/remove elements for collection and list parameters. Finally, you click on "Perform invocation" button and get another tree for the result object:

That's all, very simple, yet really effective and quick solution for testing ws endpoints. No need for either writing a single line of code or playing with XML. No external tool needed (besides for your browser). And possibly even more interesting, no special technical knowledge required, so e.g a business analyst might validate WS service results without bugging the developer who worked on it ;-) (keep in mind that in most scenarios, exposing a simple test WS endpoint is basically a matter of adding a single @WebService annotation on a POJO or EJB3 class...)

You can get the Wise 2.0 core as well as the first Wise GUI release from the project download page. The core artifacts are also available on the JBoss Maven repository; the web GUI is meant for being deployed on JBoss AS 7.1 or greater, please refer to the enclosed README file for details on building and deploying it (it's basically a single command though, assuming you have Maven properly setup).

For the next releases, I can foresee interesting and not too difficult to achieve enhancements to the web GUI, mainly on supporting WS-Policy enabled endpoints / contracts (the underlying WS stack is already fully supporting that stuff). I will create jiras soon and will probably work on them assuming I can still save some time to spend on Wise; anyway any contribution is more then welcome, keep an eye on jira and feel free to jump in anytime.

Stay tuned!