View Javadoc

1   /*
2    * $Id: ReflectionEntryPointResolverTestCase.java 22377 2011-07-11 12:41:42Z dirk.olmes $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.mule.model;
12  
13  import org.mule.RequestContext;
14  import org.mule.api.MuleEventContext;
15  import org.mule.api.model.InvocationResult;
16  import org.mule.model.resolvers.ReflectionEntryPointResolver;
17  import org.mule.tck.junit4.AbstractMuleContextTestCase;
18  import org.mule.tck.testmodels.fruit.Apple;
19  import org.mule.tck.testmodels.fruit.Banana;
20  import org.mule.tck.testmodels.fruit.Fruit;
21  import org.mule.tck.testmodels.fruit.FruitBowl;
22  import org.mule.tck.testmodels.fruit.FruitLover;
23  import org.mule.tck.testmodels.fruit.Kiwi;
24  import org.mule.tck.testmodels.fruit.Orange;
25  import org.mule.tck.testmodels.fruit.WaterMelon;
26  import org.mule.transport.NullPayload;
27  
28  import java.lang.reflect.Method;
29  
30  import org.junit.Test;
31  import org.mockito.cglib.proxy.Enhancer;
32  import org.mockito.cglib.proxy.MethodInterceptor;
33  import org.mockito.cglib.proxy.MethodProxy;
34  
35  import static org.junit.Assert.assertEquals;
36  import static org.junit.Assert.assertTrue;
37  
38  public class ReflectionEntryPointResolverTestCase extends AbstractMuleContextTestCase
39  {
40  
41      @Test
42      public void testExplicitMethodMatch() throws Exception
43      {
44          ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
45          InvocationResult result = resolver.invoke(new WaterMelon(), getTestEventContext("blah"));
46          assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
47      }
48  
49      @Test
50      public void testExplicitMethodMatchComplexObject() throws Exception
51      {
52          ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
53          InvocationResult result = resolver.invoke(new FruitBowl(), getTestEventContext(new FruitLover("Mmmm")));
54          assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
55      }
56  
57      @Test
58      public void testMethodMatchWithArguments() throws Exception
59      {
60          ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
61          InvocationResult result = resolver.invoke(new FruitBowl(), getTestEventContext(new Object[]{new Apple(), new Banana()}));
62          assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
63          assertTrue(result.getResult() instanceof Fruit[]);
64          //test that the correct methd was called
65          assertTrue(((Fruit[]) result.getResult())[0] instanceof Apple);
66          assertTrue(((Fruit[]) result.getResult())[1] instanceof Banana);
67          assertEquals("addAppleAndBanana", result.getMethodCalled());
68  
69          result = resolver.invoke(new FruitBowl(), getTestEventContext(new Object[]{new Banana(), new Apple()}));
70          assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
71          assertTrue(result.getResult() instanceof Fruit[]);
72          assertTrue(((Fruit[]) result.getResult())[0] instanceof Banana);
73          assertTrue(((Fruit[]) result.getResult())[1] instanceof Apple);
74          assertEquals("addBananaAndApple", result.getMethodCalled());
75      }
76  
77      @Test
78      public void testExplicitMethodMatchSetArrayFail() throws Exception
79      {
80          ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
81          InvocationResult result = resolver.invoke(new FruitBowl(), getTestEventContext(new Fruit[]{new Apple(), new Orange()}));
82          assertEquals("Test should have failed because the arguments were not wrapped properly: ",
83                  result.getState(), InvocationResult.State.FAILED);
84      }
85  
86      @Test
87      public void testExplicitMethodMatchSetArrayPass() throws Exception
88      {
89          ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
90          InvocationResult result = resolver.invoke(new FruitBowl(), getTestEventContext(new Object[]{new Fruit[]{new Apple(), new Orange()}}));
91          assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
92      }
93  
94      /**
95       * Tests entrypoint discovery when there is more than one discoverable method
96       * with MuleEventContext parameter.
97       */
98      @Test
99      public void testFailEntryPointMultiplePayloadMatches() throws Exception
100     {
101         ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
102         RequestContext.setEvent(getTestEvent("Hello"));
103         InvocationResult result = resolver.invoke(new MultiplePayloadsTestObject(), RequestContext.getEventContext());
104         assertEquals(result.getState(), InvocationResult.State.FAILED);
105     }
106 
107     @Test
108     public void testMatchOnNoArgs() throws Exception
109     {
110         ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
111         //This should fail because the Kiwi.bite() method has a void return type, and by default
112         //void methods are ignorred
113         InvocationResult result = resolver.invoke(new Kiwi(), getTestEventContext(NullPayload.getInstance()));
114         assertEquals(result.getState(), InvocationResult.State.FAILED);
115 
116         resolver.setAcceptVoidMethods(true);
117         result = resolver.invoke(new Kiwi(), getTestEventContext(NullPayload.getInstance()));
118         assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
119         assertEquals("bite", result.getMethodCalled());
120     }
121 
122     @Test
123     public void testAnnotatedMethodOnProxyWithMethodSet() throws Exception
124     {
125         ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
126 
127         Enhancer e = new Enhancer();
128         e.setSuperclass(WaterMelon.class);
129         e.setCallback(new DummyMethodCallback());
130         Object proxy = e.create();
131 
132         MuleEventContext context = getTestEventContext("Blah");
133         InvocationResult result = resolver.invoke(proxy, context);
134         assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
135     }
136 
137     private class DummyMethodCallback implements MethodInterceptor
138     {
139         public DummyMethodCallback()
140         {
141             super();
142         }
143         
144         public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable
145         {
146             System.out.println("before: " + method.getName());
147             Object r = proxy.invokeSuper(obj, args);
148             System.out.println("after: " + method.getName());
149 
150             //Add handler code here
151             return r;
152         }
153     }
154 }