Difficulty navigating SOAP client WSDL with PHP functions - php

Question

I am experimenting with a public SOAP API in preparation for testing an internal SOAP API that we are working on at work. I am running into problems dealing with automatically associating method names with parameter names.
More specifically I am testing against http://www.webservicex.net/stockquote.asmx?WSDL and what I am trying to do is write a function I can use in Behat so that our QA people can easily create new scenarios specifying new functions (as they are created) without me writing a new function every time.
To do this I built a function wrapper for SoapClient::__soapCall(). I have been able to get calls to specific functions to work such as this:
<?php
public function iGetAQuoteFor($symbol) {
$response = $this->client->GetQuote(array('symbol' => $symbol));
$quote = simplexml_load_string($response->GetQuoteResult)->Stock;
echo "Quote:\n" . print_r($quote, true) . "\n";
}
?>
So obviously I need to identify the parameter I am sending to the SOAP service for it to be effective. But to do that I need to be able to map the function name to the option names. I have tried processing the WSDL with SimpleXML, but I am having a difficult time navigating the results of that. I have tried a bunch of different methods and made some headway when I used the SimpleXML function 'children' and specified the 'wsdl' namespace. But what I get below that isn't any better.
Here is my soap call function (written as a Behat context):
/**
* Calls a specific SOAP function (defined in the WSDL).
*
* #param string $functionName
* #param string $options (optional, no implemented yet)
*
* #Given /^I make a SOAP call to "([^"]*)" with "([^"]*)"$/
* #Given /^I make a SOAP call to "([^"]*)"$/
*/
public function iMakeASOAPCallTo($functionName, $passedOptions = NULL) {
//Deal with the options
$options = array($passedOptions);
if (stristr($passedOptions, ',')) {
$options = explode(',', $passedOptions);
}
else if (empty($passedOptions)) {
$options = array();
}
//Also should try to figure out how to match the function call to the option wrapper
#Function placeholder
//Attempt to make the call
try {
$result = $this->client->__soapCall($functionName, $options);
}
catch (\Exception $e) {
throw new Exception("Failed to call SOAP function.");
}
//Process the result
if (!empty($result)) {
$result = $this->decodeSOAPResult($functionName, $result);
if (!empty($result)) {
echo " It returns:\n" . print_r($result, true) . "\n";
}
else {
throw new Exception("Invalid result from function call.");
}
}
else {
throw new Exception("Failed result or exception from function call.");
}
}
And this is my function that attempts to get the schema details after establishing the connection to the soap service.
private function buildSchemaDetails() {
$xml = simplexml_load_file($this->soapURL);
echo "\n" . print_r($xml, true) . "\n";
echo "For the ns:\n";
$element = $xml->getDocNamespaces();
echo "\n" . print_r($element, true) . "\n";
$element = $xml->children('wsdl', true)->types->children();
echo "\n" . print_r($element, true) . "\n";
die();
}
As you can see I have some testing code in there. It is ugly right now, but I need to figure out how to process this. If anyone knows of a tool that does all of this for me ahead of time that would be awesome.
Essentially what I want to be able to do is identify the parameters to a function before I make any attempts to call it. If the function has only one parameter then I would like to just map the variable entered to the one parameter name based on the function I am calling and then call it.
This is useful within Behat when writing features and scenarios because then it allows me to write a Gherkin-style line such as 'Then I make a SOAP call to "GetQuote" with "GOOG"' and not having to worry about specifying the name of the parameter. In the case of this WSDL I found it to be a bit ridiculous that couldn't just pass in the one variable and be done with it. I have seen anther SOAP service where I didn't have to specify the parameter name.
So being able to understand the call structure is key to simplifying all of this.