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