View Javadoc

1   /*
2    * $Id: BadAnnotatedTransformerTestCase.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  package org.mule.api.annotations.transformer;
11  
12  import org.mule.config.transformer.AnnotatedTransformerProxy;
13  import org.mule.tck.junit4.AbstractMuleContextTestCase;
14  
15  import java.lang.reflect.Method;
16  
17  import org.junit.Test;
18  
19  import static org.junit.Assert.fail;
20  
21  public class BadAnnotatedTransformerTestCase extends AbstractMuleContextTestCase
22  {
23      @Test
24      public void testVoidTransformer() throws Exception
25      {
26          Method m = getClass().getDeclaredMethod("voidTransformer", StringBuffer.class);
27          try
28          {
29              new AnnotatedTransformerProxy(5, getClass(), m, m.getParameterTypes(), null, null);
30              fail("Cannot register invalid transformer method");
31          }
32          catch (IllegalArgumentException e)
33          {
34              //Expected
35          }
36      }
37  
38      @Test
39      public void testNoParamsTransformer() throws Exception
40      {
41          Method m = getClass().getDeclaredMethod("noParamsTransformer", new Class[]{});
42          try
43          {
44              new AnnotatedTransformerProxy(5, getClass(), m, m.getParameterTypes(), null, null);
45              fail("Cannot register invalid transformer method");
46          }
47          catch (IllegalArgumentException e)
48          {
49              //Expected
50          }
51      }
52  
53      @Test
54      public void testPrivateTransformer() throws Exception
55      {
56          Method m = getClass().getDeclaredMethod("privateTransformer", StringBuffer.class);
57          try
58          {
59              new AnnotatedTransformerProxy(5, getClass(), m, m.getParameterTypes(), null, null);
60              fail("Cannot register invalid transformer method");
61          }
62          catch (IllegalArgumentException e)
63          {
64              //Expected
65          }
66      }
67  
68      @Test
69      public void testProtectedTransformer() throws Exception
70      {
71          Method m = getClass().getDeclaredMethod("protectedTransformer", StringBuffer.class);
72          try
73          {
74              new AnnotatedTransformerProxy(5, getClass(), m, m.getParameterTypes(), null, null);
75              fail("Cannot register invalid transformer method");
76          }
77          catch (IllegalArgumentException e)
78          {
79              //Expected
80          }
81      }
82  
83      @Test
84      public void testPackageTransformer() throws Exception
85      {
86          Method m = getClass().getDeclaredMethod("packageTransformer", StringBuffer.class);
87          try
88          {
89              new AnnotatedTransformerProxy(5, getClass(), m, m.getParameterTypes(), null, null);
90              fail("Cannot register invalid transformer method");
91          }
92          catch (IllegalArgumentException e)
93          {
94              //Expected
95          }
96      }
97  
98      @Test
99      public void testPublicTransformerObjectReturn() throws Exception
100     {
101         Method m = getClass().getDeclaredMethod("publicTransformerObjectReturn", StringBuffer.class);
102         try
103         {
104             new AnnotatedTransformerProxy(5, getClass(), m, m.getParameterTypes(), null, null);
105             fail("Cannot register invalid transformer method");
106         }
107         catch (IllegalArgumentException e)
108         {
109             //Expected
110         }
111     }
112 
113     @Test
114     public void testPublicTransformerObjectParam() throws Exception
115     {
116         Method m = getClass().getDeclaredMethod("publicTransformerObjectParam", Object.class);
117         try
118         {
119             new AnnotatedTransformerProxy(5, getClass(), m, m.getParameterTypes(), null, null);
120             fail("Cannot register invalid transformer method");
121         }
122         catch (IllegalArgumentException e)
123         {
124             //Expected
125         }
126     }
127 
128     @Test
129     public void testGoodTransformerWithObjectSource() throws Exception
130     {
131         Method m = getClass().getDeclaredMethod("goodTransformer", StringBuffer.class);
132         Class c[] = new Class[]{String.class, Object.class};
133         try
134         {
135             new AnnotatedTransformerProxy(5, getClass(), m, c, null, null);
136             fail("Cannot register invalid transformer method");
137         }
138         catch (IllegalArgumentException e)
139         {
140             //Expected
141         }
142     }
143 
144     @Test
145     public void testBadTransformerRegistration() throws Exception
146     {
147         try
148         {
149             muleContext.getRegistry().registerObject("badTransformer", new BadAnnotatedTransformer());
150             fail("Cannot register invalid transformer method");            
151         }
152         catch (IllegalArgumentException e)
153         {
154             //expected
155         }
156 
157     }
158 
159     public void voidTransformer(StringBuffer in)
160     {
161         
162     }
163 
164     public String noParamsTransformer()
165     {
166         return "";
167     }
168 
169     private String privateTransformer(StringBuffer foo)
170     {
171         return foo.toString();
172     }
173 
174     protected String protectedTransformer(StringBuffer foo)
175     {
176         return foo.toString();
177     }
178 
179     String packageTransformer(StringBuffer foo)
180     {
181         return foo.toString();
182     }
183 
184     public Object publicTransformerObjectReturn(StringBuffer foo)
185     {
186         return foo;
187     }
188 
189     public String publicTransformerObjectParam(Object foo)
190     {
191         return foo.toString();
192     }
193 
194     public String goodTransformer(StringBuffer foo)
195     {
196         return foo.toString();
197     }
198 
199 }