Written By Louisa Seers, Product Manager at IBM and Chair of the Galasa Technical Steering Committee (TSC)
When I first learned about application integration, I was working in a role which mixed many pieces of technology together to create complex business processes. For example, layering MQ, WebSphere and Docker containers with different hosting environments such as Amazon Web Services, Google Cloud, or the mainframe. Getting these technologies to work together can be complicated and require extensive experience as an enterprise architect. Application integration allows software to be created as a unique and bespoke set of applications that knit together to form critical business processes.
One of the strengths of the mainframe is its ability to handle large volumes of user interactions concurrently, but the trade-off is often one of complexity. Imagine a banking application: a system would have to handle an ATM request, mobile banking log-in, point terminal payment, and business transactions all happening simultaneously. If we look at application integration from a perspective of building blocks, the ability to upgrade or change the entire stack is not trivial, as there are many interconnected moving parts.
Despite this, individual components such as a database or the mobile application still need to be modified independently, for example to combat security vulnerabilities or to upgrade versions. This requires careful consideration of how these applications are integrated. After identifying what needs changing, the next step is to understand how to test that the change was successful. There are many steps to this: the first is unit testing, which is the ability to test individual components have been effectively changed and work independently. Often overlooked however is application integration testing, and it a difficult next step to get right. Secondly, application integration testing ensures that individual components interact with each other in a desirable way: for example, testing the relationship between the database and the middleware and how the data travels successfully between them.
Automation of this stage of testing is critical because there typically are so many configurations, routes, and scenarios to consider. And once fixed, batching updates, and testing them together can be problematic: if a problem is found and it’s difficult to find which change caused it.
Here are three tips for you to think about when performing application integration testing:
- Thorough Test Case Coverage:
Comprehensive test case coverage is crucial for uncovering potential issues in the integration of individual components. Ensure that your test cases are comprehensive and cover not only normal usage, but also edge cases and error conditions. This helps identify potential weaknesses in the system’s integration and ensures that it can handle different situations gracefully.
- Automate Testing Where Possible:
Automation plays a significant role in speeding up the integration testing process and increasing its reliability. Use automation tools to execute repetitive and complex test scenarios, allowing for more frequent testing and quicker feedback. Automated tests also help ensure consistency in testing procedures and reduce the risk of human error.
- Early and Incremental Testing:
Start integration testing early in the development process and perform it incrementally as different components become available. Early testing helps identify integration issues at the initial stages, making it easier to address them. Incremental testing allows you to focus on specific modules or functionalities as they are completed, preventing the accumulation of complex issues towards the end of the development cycle.
This can all seem pretty daunting, but Galasa could be your first step to understanding how to build test cases that cover multiple applications and can even be extended to cover proprietary applications with the use of managers. Galasa is an integration test framework that makes it easy to create and run tests using all types of applications. The framework has managers, that allow different technologies to be tested in one seamless test, for example a web interface with CICS or IMS middleware and a database backend, that can all be tested as one seamless test. Alternatively, automating existing JCL tests with the ultimate aim to increase the reliability of tricky, integrated applications, wherever they sit on the distributed architecture. Galasa is already within the Open Mainframe Project, and can allow developers to automate manual tasks that are error prone and time consuming.
To get started with Galasa, and maybe get involved with the active developer community, go to https://galasa.dev or https://www.github.com/galasa-dev. Reach out to the team and ask how they could help you get up and running, go to the Open Mainframe Project Slack and search for #galasa-users to get help on your next steps to application integration testing.