View Javadoc

1   /*
2    * $Id: TransformerWeightingTestCase.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.transformer;
11  
12  import org.mule.api.transformer.DiscoverableTransformer;
13  import org.mule.api.transformer.Transformer;
14  import org.mule.api.transformer.TransformerException;
15  import org.mule.tck.junit4.AbstractMuleContextTestCase;
16  import org.mule.tck.testmodels.fruit.BloodOrange;
17  import org.mule.tck.testmodels.fruit.Fruit;
18  import org.mule.tck.testmodels.fruit.FruitBowl;
19  import org.mule.tck.testmodels.fruit.Orange;
20  import org.mule.transformer.simple.ObjectToByteArray;
21  import org.mule.transformer.simple.SerializableToByteArray;
22  import org.mule.transformer.types.DataTypeFactory;
23  import org.mule.transformer.types.SimpleDataType;
24  
25  import java.io.FilterInputStream;
26  import java.io.IOException;
27  import java.util.Iterator;
28  import java.util.List;
29  
30  import org.junit.Test;
31  
32  import static org.junit.Assert.assertEquals;
33  import static org.junit.Assert.assertFalse;
34  import static org.junit.Assert.assertNotNull;
35  import static org.junit.Assert.assertTrue;
36  
37  public class TransformerWeightingTestCase extends AbstractMuleContextTestCase
38  {
39  
40      @Test
41      public void testExactMatch() throws Exception
42      {
43          DummyTransformer trans = new DummyTransformer();
44          trans.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
45          trans.registerSourceType(DataTypeFactory.create(IOException.class));
46  
47          TransformerWeighting weighting = new TransformerWeighting(IOException.class, byte[].class, trans);
48  
49          assertFalse(weighting.isNotMatch());
50          assertTrue(weighting.isExactMatch());
51      }
52  
53      @Test
54      public void testNearMatch() throws Exception
55      {
56          ObjectToByteArray trans = new ObjectToByteArray();
57  
58          TransformerWeighting weighting = new TransformerWeighting(FilterInputStream.class, byte[].class, trans);
59  
60          assertFalse(weighting.isNotMatch());
61          assertFalse(weighting.isExactMatch());
62          assertEquals(1, weighting.getInputWeighting());
63          assertEquals(0, weighting.getOutputWeighting());
64  
65      }
66  
67      @Test
68      public void testNoMatchWeighting() throws Exception
69      {
70          SerializableToByteArray trans = new SerializableToByteArray();
71  
72          TransformerWeighting weighting = new TransformerWeighting(FruitBowl.class, byte[].class, trans);
73  
74          assertTrue(weighting.isNotMatch());
75          assertEquals(-1, weighting.getInputWeighting());
76          assertEquals(0, weighting.getOutputWeighting());
77  
78      }
79  
80      @Test
81      public void testCompareWeightingWithNearMatches() throws Exception
82      {
83          ObjectToByteArray trans1 = new ObjectToByteArray();
84  
85          DummyTransformer trans2 = new DummyTransformer();
86          trans2.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
87          trans2.registerSourceType(DataTypeFactory.create(Exception.class));
88  
89          TransformerWeighting weighting1 =
90                  new TransformerWeighting(IOException.class, byte[].class, trans1);
91          TransformerWeighting weighting2 =
92                  new TransformerWeighting(IOException.class, byte[].class, trans2);
93  
94          assertFalse(weighting1.isNotMatch());
95          assertFalse(weighting2.isNotMatch());
96          assertFalse(weighting1.isExactMatch());
97          assertFalse(weighting2.isExactMatch());
98          //Weighting2 two is a better match
99          assertEquals(1, weighting2.compareTo(weighting1));
100 
101         assertEquals(3, weighting1.getInputWeighting());
102         assertEquals(1, weighting2.getInputWeighting());
103         assertEquals(0, weighting1.getOutputWeighting());
104         assertEquals(0, weighting2.getOutputWeighting());
105 
106     }
107 
108     @Test
109     public void testCompareWeightingWithExactMatch() throws Exception
110     {
111         ObjectToByteArray trans1 = new ObjectToByteArray();
112 
113         DummyTransformer trans2 = new DummyTransformer();
114         trans2.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
115         trans2.registerSourceType(DataTypeFactory.create(IOException.class));
116 
117         TransformerWeighting weighting1 =
118                 new TransformerWeighting(IOException.class, byte[].class, trans1);
119         TransformerWeighting weighting2 =
120                 new TransformerWeighting(IOException.class, byte[].class, trans2);
121 
122         assertFalse(weighting1.isNotMatch());
123         assertFalse(weighting2.isNotMatch());
124         assertFalse(weighting1.isExactMatch());
125         assertTrue(weighting2.isExactMatch());
126         //Weighting2 two is an exact match
127         assertEquals(1, weighting2.compareTo(weighting1));
128 
129         assertEquals(3, weighting1.getInputWeighting());
130         assertEquals(0, weighting2.getInputWeighting());
131         assertEquals(0, weighting1.getOutputWeighting());
132         assertEquals(0, weighting2.getOutputWeighting());
133 
134     }
135 
136     @Test
137     public void testCompareWeightingWithNoMatch() throws Exception
138     {
139         ObjectToByteArray trans1 = new ObjectToByteArray();
140 
141         DummyTransformer trans2 = new DummyTransformer();
142         trans2.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
143         trans2.registerSourceType(DataTypeFactory.create(FruitBowl.class));
144 
145         TransformerWeighting weighting1 =
146                 new TransformerWeighting(IOException.class, byte[].class, trans1);
147         TransformerWeighting weighting2 =
148                 new TransformerWeighting(IOException.class, byte[].class, trans2);
149 
150         assertFalse(weighting1.isNotMatch());
151         assertTrue(weighting2.isNotMatch());
152         assertFalse(weighting1.isExactMatch());
153         assertFalse(weighting2.isExactMatch());
154         //Weighting2 two is not a match
155         assertEquals(-1, weighting2.compareTo(weighting1));
156 
157         assertEquals(3, weighting1.getInputWeighting());
158         assertEquals(-1, weighting2.getInputWeighting());
159         assertEquals(0, weighting1.getOutputWeighting());
160         assertEquals(0, weighting2.getOutputWeighting());
161 
162     }
163 
164     @Test
165     public void testPriorityMatching() throws Exception
166     {
167         DummyTransformer t1 = new DummyTransformer();
168         t1.setName("--t1");
169         t1.registerSourceType(DataTypeFactory.create(Orange.class));
170         t1.setReturnDataType(DataTypeFactory.create(Fruit.class));
171         muleContext.getRegistry().registerTransformer(t1);
172 
173         DummyTransformer t2 = new DummyTransformer();
174         t2.setName("--t2");
175         t2.registerSourceType(DataTypeFactory.OBJECT);
176         t2.setReturnDataType(DataTypeFactory.create(Fruit.class));
177         muleContext.getRegistry().registerTransformer(t2);
178 
179         List trans = muleContext.getRegistry().lookupTransformers(new SimpleDataType(BloodOrange.class), new SimpleDataType(Fruit.class));
180         assertEquals(2, trans.size());
181         for (Iterator iterator = trans.iterator(); iterator.hasNext();)
182         {
183             Transformer transformer = (Transformer) iterator.next();
184             assertTrue(transformer.getName().startsWith("--"));
185         }
186 
187         Transformer result = muleContext.getRegistry().lookupTransformer(new SimpleDataType(BloodOrange.class), new SimpleDataType(Fruit.class));
188         assertNotNull(result);
189         assertEquals("--t1", result.getName());
190     }
191 
192     private static class DummyTransformer extends AbstractTransformer implements DiscoverableTransformer
193     {
194         private int weighting;
195 
196         public DummyTransformer()
197         {
198             super();
199         }
200         
201         public int getPriorityWeighting()
202         {
203             return weighting;
204         }
205 
206 
207         public void setPriorityWeighting(int weighting)
208         {
209             this.weighting = weighting;
210         }
211 
212         @Override
213         protected Object doTransform(Object src, String encoding) throws TransformerException
214         {
215             return src;
216         }
217     }
218 }