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