1
2
3
4
5
6
7 package org.mule.mule.model;
8
9 import org.mule.RequestContext;
10 import org.mule.api.MuleEventContext;
11 import org.mule.api.model.InvocationResult;
12 import org.mule.model.resolvers.ReflectionEntryPointResolver;
13 import org.mule.tck.junit4.AbstractMuleContextTestCase;
14 import org.mule.tck.testmodels.fruit.Apple;
15 import org.mule.tck.testmodels.fruit.Banana;
16 import org.mule.tck.testmodels.fruit.Fruit;
17 import org.mule.tck.testmodels.fruit.FruitBowl;
18 import org.mule.tck.testmodels.fruit.FruitLover;
19 import org.mule.tck.testmodels.fruit.Kiwi;
20 import org.mule.tck.testmodels.fruit.Orange;
21 import org.mule.tck.testmodels.fruit.WaterMelon;
22 import org.mule.transport.NullPayload;
23
24 import java.lang.reflect.Method;
25
26 import org.junit.Test;
27 import org.mockito.cglib.proxy.Enhancer;
28 import org.mockito.cglib.proxy.MethodInterceptor;
29 import org.mockito.cglib.proxy.MethodProxy;
30
31 import static org.junit.Assert.assertEquals;
32 import static org.junit.Assert.assertTrue;
33
34 public class ReflectionEntryPointResolverTestCase extends AbstractMuleContextTestCase
35 {
36
37 @Test
38 public void testExplicitMethodMatch() throws Exception
39 {
40 ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
41 InvocationResult result = resolver.invoke(new WaterMelon(), getTestEventContext("blah"));
42 assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
43 }
44
45 @Test
46 public void testExplicitMethodMatchComplexObject() throws Exception
47 {
48 ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
49 InvocationResult result = resolver.invoke(new FruitBowl(), getTestEventContext(new FruitLover("Mmmm")));
50 assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
51 }
52
53 @Test
54 public void testMethodMatchWithArguments() throws Exception
55 {
56 ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
57 InvocationResult result = resolver.invoke(new FruitBowl(), getTestEventContext(new Object[]{new Apple(), new Banana()}));
58 assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
59 assertTrue(result.getResult() instanceof Fruit[]);
60
61 assertTrue(((Fruit[]) result.getResult())[0] instanceof Apple);
62 assertTrue(((Fruit[]) result.getResult())[1] instanceof Banana);
63 assertEquals("addAppleAndBanana", result.getMethodCalled());
64
65 result = resolver.invoke(new FruitBowl(), getTestEventContext(new Object[]{new Banana(), new Apple()}));
66 assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
67 assertTrue(result.getResult() instanceof Fruit[]);
68 assertTrue(((Fruit[]) result.getResult())[0] instanceof Banana);
69 assertTrue(((Fruit[]) result.getResult())[1] instanceof Apple);
70 assertEquals("addBananaAndApple", result.getMethodCalled());
71 }
72
73 @Test
74 public void testExplicitMethodMatchSetArrayFail() throws Exception
75 {
76 ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
77 InvocationResult result = resolver.invoke(new FruitBowl(), getTestEventContext(new Fruit[]{new Apple(), new Orange()}));
78 assertEquals("Test should have failed because the arguments were not wrapped properly: ",
79 result.getState(), InvocationResult.State.FAILED);
80 }
81
82 @Test
83 public void testExplicitMethodMatchSetArrayPass() throws Exception
84 {
85 ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
86 InvocationResult result = resolver.invoke(new FruitBowl(), getTestEventContext(new Object[]{new Fruit[]{new Apple(), new Orange()}}));
87 assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
88 }
89
90
91
92
93
94 @Test
95 public void testFailEntryPointMultiplePayloadMatches() throws Exception
96 {
97 ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
98 RequestContext.setEvent(getTestEvent("Hello"));
99 InvocationResult result = resolver.invoke(new MultiplePayloadsTestObject(), RequestContext.getEventContext());
100 assertEquals(result.getState(), InvocationResult.State.FAILED);
101 }
102
103 @Test
104 public void testMatchOnNoArgs() throws Exception
105 {
106 ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
107
108
109 InvocationResult result = resolver.invoke(new Kiwi(), getTestEventContext(NullPayload.getInstance()));
110 assertEquals(result.getState(), InvocationResult.State.FAILED);
111
112 resolver.setAcceptVoidMethods(true);
113 result = resolver.invoke(new Kiwi(), getTestEventContext(NullPayload.getInstance()));
114 assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
115 assertEquals("bite", result.getMethodCalled());
116 }
117
118 @Test
119 public void testAnnotatedMethodOnProxyWithMethodSet() throws Exception
120 {
121 ReflectionEntryPointResolver resolver = new ReflectionEntryPointResolver();
122
123 Enhancer e = new Enhancer();
124 e.setSuperclass(WaterMelon.class);
125 e.setCallback(new DummyMethodCallback());
126 Object proxy = e.create();
127
128 MuleEventContext context = getTestEventContext("Blah");
129 InvocationResult result = resolver.invoke(proxy, context);
130 assertEquals(result.getState(), InvocationResult.State.SUCCESSFUL);
131 }
132
133 private class DummyMethodCallback implements MethodInterceptor
134 {
135 public DummyMethodCallback()
136 {
137 super();
138 }
139
140 public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable
141 {
142 System.out.println("before: " + method.getName());
143 Object r = proxy.invokeSuper(obj, args);
144 System.out.println("after: " + method.getName());
145
146
147 return r;
148 }
149 }
150 }