An introduction to MUnit for Java programmers

February 13 2020

0 comments

Unit tests are an integral part of the software development lifecycle. However, for most it is a task that must be endured and compounded by what seem like arbitrary test coverage targets.

In this blog, I will introduce MUnit by making reference to concepts already familiar to Java developers, thereby making the transition to MuleSoft developer and architect smoother.

The role of unit testing

Unit tests play an essential role at the implementation stage of a project’s lifecycle, they provide reassurance that the application under test performs as it’s  expected to. In later stages (maintenance and evolution), they provide regression testing for applications, ensuring changes have not adversely affected functioning features. 

Regardless of what is being tested, unit testing satisfies a set of governance and quality requirements, often in a semantically similar manager and tooling. MUnit is no different. 

What is MUnit?

The testing framework used to write unit tests for Mule applications is called MUnit and is built upon Java technologies. It embraces the xUnit architecture and approach, and provides support for common test tasks including fixtures, assertions, mocking, suites, and code coverage reports. 

MUnit tests are created by the developer in the same IDE as the Mule application (Anypoint Studio) and organized into a Maven project directory structure typical of a Java project. Anypoint Studio’s low-code/no-code approach provides a canvas where tests can be developed by building flows that mock and assert corresponding flows in the Mule application.

The MUnit approach

MUnit requires a developer to write unit testable flows. Such flows are small, containing only a few Mule event processors, and satisfy a single use case. Thus developers are directed to follow software development best practices and write simple, single units of functionality. Mule fully supports this approach to flow development through sub-flows and flow references. Studio even has a refactor flow feature to facilitate the creation of referenceable flows.

Fig 1: The extract-and-transform-data subflow is easily unit testable

How does MUnit related to Java unit testing?

MUnit is built on JUnit, Hamcrest, and Mockito. These are common libraries familiar to seasoned Java developers and are established as essential tools for unit test development. Because of these tools, and adherence to xUnit common architecture, many features of MUnit will be familiar to Java developers. This can be seen in the explicit use of test suites that organize tests into cases, and especially in the test assertions which reflect the familiar features of the Hamcrest library.

MUnit supported features

MUnit shares a basic component architecture with the xUnit framework. It provides a test runner that executes the tests and outputs the result in the IDE and/or as a surefire report. Tests are organized into suites and cases that rely on the same test fixtures and assertions are defined that verify the test case’s behavior. Below are the common features MUnit supports:

Test fixtures

Test fixtures, also known as a test context, sets up the conditions for a test to run. When the test completes, the state is restored or torn down. Conditions can be set up before a test suite executes and before a test runs. Test suites are further extended by parameterizing executions, thereby enabling the running of the same test but with different inputs. 

Assertions

The heart of a unit test is the assertion of its behavior. A logical expression sets a condition and verifies the results of the test. MUnit provides out-of-the-box result verification as assert equals (check if an expression is equal to a value), assert that (perform an assertion over an expression), assert expression (asserts that an expression is successful), and run custom (run a custom assertion).

With the support of the MunitTools module, assertions are expressed in DataWeave 2.x which simplifies common value assertions. Sophisticated assertion expression can be written to test more complex use cases with the use of the assert expression feature.

Test doubles

A feature that replaces a production object with a fake object. Often known as stubs, mocks, and dummies, which provide a way to ensure tests are deterministic by removing uncontrollable elements from the test execution. MUnit provides spy, mock, conditional mocks, verify call (verifies a call), and fail (fails a test). These are configurable for each test case and for a test suite as a whole. They are executed as part of each unit test.

Test execution

As mentioned above, unit tests are executed at the implementation, maintenance, and evolutionary stages of a projects lifecycle and the results are collated and analyzed. If all tests pass, the application will continue on its journey through the projects lifecycle. However, for execution to be possible a test harness is required. MUnit tests execution is dependent on the Mule runtime. The Mule runtime must be launched and running successfully before the MUnit tests can be executed. By contrast, JUnit has a much more lightweight test harness and tests run almost immediately. What both JUnit and MUnit share is an integration with the Maven lifecycle phases. For both, all test suites (or a subset) can be executed with a Maven command and in the Studio IDE.

Conclusion

JUnit and MUnit share a common framework which makes learning how to write quality MUnit tests much easier. For the experienced Java developer, there is little resistance to making the transition into Mule, especially when it comes to unit testing. Beyond unit tests there are many other types of tests commonly performed by Mule professionals, they include integration, user acceptance, performance, resilience tests, and more. The good news is that the tools already familiar to Java application testers can be readily applied to the testing of Mule applications.

This is the end of the first part of a multi-part series examining MUnit from the perspective of a Java programmer. As you have seen, MUnit reassuringly offers similar functionality that a Java programmer would expect to find available in a Java testing framework. We have seen that MUnit supports test fixtures and suites, parameterized testing, and a wide range of ways to assert. 

If you are interested in learning more about MUnit and related DevOps activities essential for the implementation of production-ready Mule applications then our course Anypoint Platform Development: Production-Ready Development Practices (Mule 4) is for you.



We'd love to hear your opinion on this post