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