View Javadoc

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