Automated interfaces for XML validation facilitate continuous software testing
ISO 20022 XML is a standardized format, yet due to dialects and variations in message content its handling is anything but trivial. Software has to be tested thoroughly to ensure that their XML output satisfies the receiving payment service providers’ requirements. Once in production use, every rejected message leads to delayed transactions and avoidable costs.
With the complexity of the task comes the need for testing with a large number of message variants. Yet, the traditional approach of testing final versions before production shows its limitations as thousands of tests are to be run: once errors start to pop up, a slow and costly bug fixing phase begins.
In order to efficiently validate a large amount of XML messages, it is desirable to employ automated testing mechanisms designed for high volumes – moving traditionally manually administered testing work to automated systems. This allows increasing the amount of tested message variants while limiting human intervention to a minimum. To further streamline the testing workflow, error reports should be rich and specific, pointing at the point of failure and hinting at the solution.
The use of automated testing enables a proactive testing strategy: thanks to the reduced effort for each run, tests can be executed at earlier stages and repeated continuously at no additional cost. This allows identifying potential problems early on, providing a cost-efficient way to create better-tested software solutions.
Reactive testing increases costs
Traditionally, testing is carried out once a version is ready to be released, checking whether all features perform as required. This implies that errors in the system leading to the creation of invalid XML messages will only be discovered as the implementation is otherwise considered almost ready for production.
Running tests on a production-ready system is a resource-intensive process. First of all, it binds human resources, as it can be laborious to simulate a large amount of cases. In addition, the test outcome would usually only point out which messages failed, but not the cause of the issue; the developer has to examine erroneous messages separately. Last but not least, the discovery of bugs late in the process requires corrections to already concluded work from the implementation phase, adding to the risk that bug fixes affect other cases.
Towards a proactive, automated approach
Shifting the testing from its reactive role of finding and fixing errors retroactively in release-ready software to a more proactive role of constant code validation during development has proven to be a cost-efficient way to minimize the budgetary impact of bugs discovered. With continuous testing, errors can promptly be fixed as they appear.
To enable a proactive testing workflow in an ISO 20022 XML project, two features are required: the ability to process a high volume of messages at once and an API interface for automation.
A validator engine’s ability to batch-process a large amount of test messages enables the execution of comprehensive testing scripts against each development version, delivering exact results with singled-out validation reports about every invalid file.
In addition, an interface for access by software applications (API) makes it possible to fully automate the process, for instance permitting nightly test-runs of the latest code. Furthermore, API access is of value also apart from bulk testing: when integrated into a system, it could for example automatically feed any erroneous XML messages through the validator.
The solution: Early and repeated high-volume testing
Utilizing a powerful programming interface supporting the validation of large batches of messages at a time, it is possible to validate software while it is being built. The integration of an API-based validator empowers the developer to quickly identify open issues, carry out required changes and revalidate almost immediately:
Using a validation service with support for large message batches is a major step towards more efficient XML testing. Developers may use a script to run a broad range of test cases on the latest development version of their software and submit the resulting transaction files to the validator; annotated error reports allow for rapid resolution of emergent issues.
Yet, a fully automated integration of a validation API allows taking this even further: repeated tests run without human interaction, while providing all the feedback required. In its most efficient application, API use even allows to auto-validate failed transactions and instruct developers which parts of the message to look at.