Test Mule Applications | MuleSoft Documentation
# Test Mule Applications
Building a comprehensive suite of automated tests for a Mule application enables you to detect any regression or incompatible change in your application during tests in a local environment. MUnit is a Mule testing framework that lets you easily automate testing Mule applications by using _unit_ , _integration_ , and _functional_ tests. MUnit also provides a set of tools, such as a processor mocking framework that lets you test units of code in isolation.
See the MUnit documentation for more details.
When you write your application, follow some best practices like modularizing your code, and writing short flows to make your code easy to test. Create readable and maintainable tests, by using descriptive names and error messages that help you identify issues and address them.
You can use the Test Recorder (beta) in Anypoint Studio to record a processing flow and then configure a unit test based on the captured event. See Test Recorder in Studio for details and examples.
After you test your application’s logic and behavior, you can test your Mule application’s performance by profiling Mule runtime engine (Mule). This process can help you identify memory or performance-related issues in Mule applications or custom Mule extensions. To profile Mule, you need to load a Java Profiler into your on-premises Mule instance.
See Profiling Mule for more instructions.
## Unit Tests
The concept of unit tests varies according to your programming paradigm, but its core concept is always _to validate the correctness of an individual unit of source code_.
In the context of unit testing, a unit of code is the smallest testable part of an application. What exactly constitutes the smallest testable part of an application depends on the application. For Mule applications, the smallest testable part is a Mule flow or a subflow.
As a developer, you must evaluate if the code you want to test interacts with other units of code or components and ensure that you design your unit test so that it isolates the unit of code being tested.
Isolation ensures that any test failure relates to the code being tested, and not to some other code or component. To isolate your target code unit, use tools such as the `mock-when` processor provided by MUnit.
See Mocking a Message Before and Inside a Foreach Processor for a usage example of the `mock-when` processor.
## Integration Tests
Because units of code collaborate to create an actual application, after you successfully test those units, you are ready to test your whole app through integration tests.
The goal of an integration test is _to validate that different units of code and modules work together as intended_.
Depending on the nature of your application, your integration tests might require a _sandbox_ testing environment, which enables isolated testing evaluation outside of the working application environment. You must ensure that the state of the data in the sandbox is correct for the test to produce the intended result. Perform this verification before and after running the integration test.
## Functional Tests
Functional testing involves testing the use cases envisioned for your Mule application as a whole.
For example, to test a Mule application that is meant to maintain two-way synchronization between two systems, you can design a test case that creates an entry in each system and verifies the replication in the opposite. Or, if you want to test a batch-processing application, you can run a test with a representative set of information and validate the results of the batch. Finally, to test service orchestration, you can generate an event at one end of a flow and test the result at the other end, after the event went through different services.
As with integration testing, run your functional test cases using environment properties and versions of the services dedicated to testing.
## Writing Testable Code
You can make your testing much easier (and create a more configurable, extensible, and readable application) by modularizing your code and defining execution environments.
  * Modularize your code
Breaking down your code into different files helps with readability. Do this by grouping flows that work together to achieve a common goal, or group code according to specific functional criteria.
  * Write short flows
Long flows can be hard to follow, hard to code, and hard to maintain, so it is best to avoid them. From the perspective of unit testing, long flows offer too many scenarios that can be triggered by a single point, and they require you to perform very complex evaluations to validate a single scenario.
  * Define execution environments
Parameterize your code using placeholders. Normal use cases for this include addresses of outbound endpoints, such as DB or HTTP. Using placeholders enables you to modify the actual address when running tests (either unit or integration), and make it easier to promote your code between environments (DEV/QA/UAT/PROD).


## Best Practices for Writing Tests
  * Write your tests to be readable and maintainable.
  * Name your test according to what you want to see when the test fails.
  * Use descriptive names for the error thrown by the test upon failure, to avoid receiving wrongly written or ambiguous error messages when the test fails.
  * Avoid long flows because they are harder to follow.
  * Code your test so that the scenario being covered and the failure conditions are explicit.


## See Also
  * MUnit Test Structure Fundamentals
  *