1
2
3
4
5
6
7
8
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
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
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
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 }