I am currently busy to evaluate Mule. I am busy setting up an integration platform and I want to see what role Mule may have in there. Based on the documentation it could be an important role but that is according to the documentation, of course I want to see it for myself to make sure. The reason why Mule was selected (there are a lot of similar products like OpenESB and ServiceMix) as favorite was because the nice integration with Maven and the ease with which you can setup unit tests. For me the best way to evaluate a product is by using it and getting familiar with it. So I downloaded the newest version (2.2.0), installed it and got myself a book about Mule2 (in this case "Mule 2 A Developer's guide" from 'firstpress'). I prefer to use a book to force myself to evaluate the product by a kind of structured way, instead of just jumping from one example to another.
So by going through the book I got to the first example and I also ran into the first challenge. The example given looked like the following situation (I assume Mule is installed correctly):

1. Create a Maven project for a Mule project

I used the Mule Project Archetype:
mvn mul-project-archetype:create -DartifactId=net.pascalalma.mule -DmuleVersion=2.2.0

See the docs for more detail info about the use of this archetype.

2. Modify the default config file

To tell Mule what to do you have to supply a config file on the classpath. Default you will get an empty one created by the archetype. I put in the following (according to the example of the book):

PLAIN TEXT
XML:
1. <mule>
2.   <model name="main">
3.     <service name="Square">
4.       <inbound>
5.         <vm:inbound-endpoint path="math" synchronous="true" />
6.       </inbound>
7.       <component class="net.pascalalma.mule.Square"/>
8.       <outbound>
9.         <pass-through-router>
10.           <vm:outbound-endpoint path="inverse"/>
11.         </pass-through-router>
12.       </outbound>
13.     </service>
14.     <service name="Inverse">
15.       <inbound>
16.         <vm:inbound-endpoint path="inverse" />
17.         </inbound>
18.         <component class="net.pascalalma.mule.Inverse" />
19.         <outbound>
20.           <pass-through-router>
21.             <stdio:outbound-endpoint system="OUT"/>
22.           </pass-through-router>
23.         </outbound>
24.       </service>
25.   </model>
26. </mule>
3. Create the necessary Java classes

As you can see in the config file there are two components defined which are actually just pojo's like this:

PLAIN TEXT
JAVA:
1. package net.pascalalma.mule;
2.  
3. /**
4. *
5. * @author pascal
6. */
7. public class Square {
8.  
9.     public Integer square(Integer i) {
10.         return new Integer(i.intValue() * i.intValue());
11.     }
12. }

and

PLAIN TEXT
JAVA:
1. package net.pascalalma.mule;
2.  
3. /**
4. *
5. * @author pascal
6. */
7. public class Inverse {
8.  
9.     public Integer inverse(Integer i) {
10.         System.out.println("Doing inverse...");
11.  
12.         Integer result = new Integer(-1 * i.intValue());
13.  
14.         System.out.println("Expected result = " + result);
15.  
16.         return result ;
17.     }
18. }
4. Create the test class

Next is to create the class with which we can test the configuration of Mule. I created this class (taken as exampe from the book):

PLAIN TEXT
JAVA:
1. package net.pascalalma.mule.mathservice;
2.  
3. import java.util.Map;
4. import org.mule.DefaultMuleMessage;
5. import org.mule.api.MuleMessage;
6. import org.mule.module.client.MuleClient;
7. import org.mule.tck.FunctionalTestCase;
8.  
9. public class MathServiceTestCase extends FunctionalTestCase {
10.  
11.     protected String getConfigResources() {
12.         return "mule-config.xml";
13.     }
14.  
15.     public void testMathService() throws Exception {
16.         MuleClient client = new MuleClient();
17.  
18.         MuleMessage msg = new DefaultMuleMessage(new Integer(5), (Map)null);
19.  
20.         MuleMessage result = client.send("vm://math", new Integer(5), null);
21.  
22.         System.out.println("Resultaat: " + result.getPayloadAsString());
23.  
24.         assertEquals("-25", result.getPayloadAsString());
25.  
26.     }
27. }
5. Run the project

Now we can clean and build the project with
mvn clean install
However the build failed because the test failed!

Problem was that the result of the unit test didn't match the result I expected nor what was expected in the book! Of course, this wasn't a good thing in the evaluation of Mule. I mean, the first example I try leads to unexpected results. But because I am aware that it was far to early in the evaluation process to drop Mule as a candidate, I gave it another chance. I posted my situation on the Mule mailinglist. This is also a very important aspect of the evaluation: is the community behind the product still alive and active.
Well, in one word: yes, it is! Within a few hours I had the answer to my problem and within one day the answer was extended with some more background info why the showed behaviour differs from the one that was described in the book.
Now, these kind of things gives me confidence about the product, so I will definitely continue with the evaluation because I still believe the 'tool' can be of great value in our solution.

About the issue: it appears that Mule has changed the default value for the parameter 'defaultSynchronousEndpoints' from 'true' to 'false' in a later version of Mule. So in my case I had to add synchronous="true" to each endpoint or set the value of 'defaultSynchronousEndpoints' to 'true'.