1
2
3
4
5
6
7 package com.atlassian.plugin.descriptors;
8
9 import com.atlassian.plugin.ModuleDescriptor;
10 import com.atlassian.plugin.Plugin;
11 import com.atlassian.plugin.PluginParseException;
12 import com.atlassian.plugin.StateAware;
13 import com.atlassian.plugin.elements.ResourceDescriptor;
14 import com.atlassian.plugin.impl.StaticPlugin;
15 import com.atlassian.plugin.mock.MockAnimal;
16 import com.atlassian.plugin.mock.MockAnimalModuleDescriptor;
17 import com.atlassian.plugin.mock.MockMineral;
18 import com.atlassian.plugin.module.ModuleFactory;
19 import com.atlassian.plugin.util.ClassLoaderUtils;
20 import com.atlassian.plugin.util.ClassUtils;
21 import com.atlassian.plugin.util.MyModule;
22 import com.atlassian.plugin.util.MySubClass;
23 import com.atlassian.plugin.util.MySuperClass;
24 import junit.framework.TestCase;
25 import org.dom4j.DocumentException;
26 import org.dom4j.DocumentHelper;
27 import org.dom4j.Element;
28
29 import java.io.IOException;
30 import java.net.MalformedURLException;
31 import java.net.URL;
32 import java.net.URLClassLoader;
33 import java.util.Collection;
34 import java.util.Enumeration;
35 import java.util.List;
36
37 import static java.util.Arrays.asList;
38 import static org.mockito.Mockito.mock;
39
40 public class TestAbstractModuleDescriptor extends TestCase
41 {
42 public void testAssertModuleClassImplements() throws DocumentException, PluginParseException
43 {
44 ModuleDescriptor descriptor = new AbstractModuleDescriptor(ModuleFactory.LEGACY_MODULE_FACTORY) {
45 public void init(Plugin plugin, Element element) throws PluginParseException
46 {
47 super.init(plugin, element);
48 enabled();
49 assertModuleClassImplements(MockMineral.class);
50 }
51
52 public Object getModule()
53 {
54 return null;
55 }
56 };
57
58 try
59 {
60 descriptor.init(new StaticPlugin(), DocumentHelper.parseText("<animal key=\"key\" name=\"bear\" class=\"com.atlassian.plugin.mock.MockBear\" />").getRootElement());
61 ((StateAware)descriptor).enabled();
62 fail("Should have blown up.");
63 }
64 catch (PluginParseException e)
65 {
66 assertEquals("Given module class: com.atlassian.plugin.mock.MockBear does not implement com.atlassian.plugin.mock.MockMineral", e.getMessage());
67 }
68
69
70 descriptor.init(new StaticPlugin(), DocumentHelper.parseText("<animal key=\"key\" name=\"bear\" class=\"com.atlassian.plugin.mock.MockGold\" />").getRootElement());
71 }
72
73 public void testLoadClassFromNewModuleFactory()
74 {
75 ModuleFactory moduleFactory = mock(ModuleFactory.class);
76 AbstractModuleDescriptor moduleDescriptor = new StringModuleDescriptor(moduleFactory, "foo");
77 Plugin plugin = mock(Plugin.class);
78 moduleDescriptor.loadClass(plugin, "foo");
79 assertEquals(String.class, moduleDescriptor.getModuleClass());
80 }
81
82 public void testLoadClassFromNewModuleFactoryWithExtendsNumberType()
83 {
84 ModuleFactory moduleFactory = mock(ModuleFactory.class);
85 AbstractModuleDescriptor moduleDescriptor = new ExtendsNumberModuleDescriptor(moduleFactory, "foo");
86 Plugin plugin = mock(Plugin.class);
87
88 try
89 {
90 moduleDescriptor.loadClass(plugin, "foo");
91 fail("Should have complained about extends type");
92 }
93 catch (IllegalStateException ex)
94 {
95
96 }
97 }
98
99 public void testLoadClassFromNewModuleFactoryWithExtendsNothingType()
100 {
101 ModuleFactory moduleFactory = mock(ModuleFactory.class);
102 AbstractModuleDescriptor moduleDescriptor = new ExtendsNothingModuleDescriptor(moduleFactory, "foo");
103 Plugin plugin = mock(Plugin.class);
104
105 try
106 {
107 moduleDescriptor.loadClass(plugin, "foo");
108 fail("Should have complained about extends type");
109 }
110 catch (IllegalStateException ex)
111 {
112
113 }
114 }
115
116 public void testGetModuleReturnClass()
117 {
118 AbstractModuleDescriptor desc = new MockAnimalModuleDescriptor();
119 assertEquals(MockAnimal.class, desc.getModuleReturnClass());
120 }
121
122 public void testGetModuleReturnClassWithExtendsNumber()
123 {
124 ModuleFactory moduleFactory = mock(ModuleFactory.class);
125 AbstractModuleDescriptor moduleDescriptor = new ExtendsNothingModuleDescriptor(moduleFactory, "foo");
126 assertEquals(Object.class, moduleDescriptor.getModuleReturnClass());
127 }
128
129 public void testLoadClassFromNewModuleFactoryButUnknownType()
130 {
131 ModuleFactory moduleFactory = mock(ModuleFactory.class);
132 AbstractModuleDescriptor moduleDescriptor = new AbstractModuleDescriptor(moduleFactory)
133 {
134 public AbstractModuleDescriptor init()
135 {
136 moduleClassName = "foo";
137 return this;
138 }
139
140 @Override
141 public Object getModule()
142 {
143 return null;
144 }
145 }.init();
146 try
147 {
148 Plugin plugin = mock(Plugin.class);
149 moduleDescriptor.loadClass(plugin, "foo");
150 fail("Should have complained about unknown type");
151 }
152 catch (IllegalStateException ex)
153 {
154
155 }
156 }
157
158 public void testSingletonness() throws DocumentException, PluginParseException
159 {
160 ModuleDescriptor descriptor = makeSingletonDescriptor();
161
162
163 descriptor.init(new StaticPlugin(), DocumentHelper.parseText("<animal key=\"key\" name=\"bear\" class=\"com.atlassian.plugin.mock.MockBear\" />").getRootElement());
164 ((StateAware)descriptor).enabled();
165 Object module = descriptor.getModule();
166 assertTrue(module == descriptor.getModule());
167
168
169 descriptor = makeSingletonDescriptor();
170 descriptor.init(new StaticPlugin(), DocumentHelper.parseText("<animal key=\"key\" name=\"bear\" class=\"com.atlassian.plugin.mock.MockBear\" singleton=\"true\" />").getRootElement());
171 ((StateAware)descriptor).enabled();
172 module = descriptor.getModule();
173 assertTrue(module == descriptor.getModule());
174
175
176 descriptor = makeSingletonDescriptor();
177 descriptor.init(new StaticPlugin(), DocumentHelper.parseText("<animal key=\"key\" name=\"bear\" class=\"com.atlassian.plugin.mock.MockBear\" singleton=\"false\" />").getRootElement());
178 ((StateAware)descriptor).enabled();
179 module = descriptor.getModule();
180 assertTrue(module != descriptor.getModule());
181 }
182
183 public void testGetResourceDescriptor() throws DocumentException, PluginParseException
184 {
185 ModuleDescriptor descriptor = makeSingletonDescriptor();
186 descriptor.init(new StaticPlugin(), DocumentHelper.parseText("<animal key=\"key\" name=\"bear\" class=\"com.atlassian.plugin.mock.MockBear\">" +
187 "<resource type='velocity' name='view' location='foo' />" +
188 "</animal>").getRootElement());
189
190 assertNull(descriptor.getResourceLocation("foo", "bar"));
191 assertNull(descriptor.getResourceLocation("velocity", "bar"));
192 assertNull(descriptor.getResourceLocation("foo", "view"));
193 assertEquals(new ResourceDescriptor(DocumentHelper.parseText("<resource type='velocity' name='view' location='foo' />").getRootElement()).getResourceLocationForName("view").getLocation(), descriptor.getResourceLocation("velocity", "view").getLocation());
194 }
195
196 public void testGetResourceDescriptorByType() throws DocumentException, PluginParseException
197 {
198 ModuleDescriptor descriptor = makeSingletonDescriptor();
199 descriptor.init(new StaticPlugin(), DocumentHelper.parseText("<animal key=\"key\" name=\"bear\" class=\"com.atlassian.plugin.mock.MockBear\">" +
200 "<resource type='velocity' name='view' location='foo' />" +
201 "<resource type='velocity' name='input-params' location='bar' />" +
202 "</animal>").getRootElement());
203
204 final List resourceDescriptors = descriptor.getResourceDescriptors("velocity");
205 assertNotNull(resourceDescriptors);
206 assertEquals(2, resourceDescriptors.size());
207
208 ResourceDescriptor resourceDescriptor = (ResourceDescriptor) resourceDescriptors.get(0);
209 assertEquals(new ResourceDescriptor(DocumentHelper.parseText("<resource type='velocity' name='view' location='foo' />").getRootElement()), resourceDescriptor);
210
211 resourceDescriptor = (ResourceDescriptor) resourceDescriptors.get(1);
212 assertEquals(new ResourceDescriptor(DocumentHelper.parseText("<resource type='velocity' name='input-params' location='bar' />").getRootElement()), resourceDescriptor);
213 }
214
215 private ModuleDescriptor makeSingletonDescriptor()
216 {
217 ModuleDescriptor descriptor = new AbstractModuleDescriptor(ModuleFactory.LEGACY_MODULE_FACTORY) {
218 Object module;
219
220 public void init(Plugin plugin, Element element) throws PluginParseException
221 {
222 super.init(plugin, element);
223 }
224
225 public Object getModule()
226 {
227 try
228 {
229 if (!isSingleton())
230 {
231 return ClassLoaderUtils.loadClass(getModuleClass().getName(), TestAbstractModuleDescriptor.class).newInstance();
232 }
233 else
234 {
235 if (module == null)
236 {
237 module = ClassLoaderUtils.loadClass(getModuleClass().getName(), TestAbstractModuleDescriptor.class).newInstance();
238 }
239
240 return module;
241 }
242 }
243 catch (Exception e)
244 {
245 throw new RuntimeException("What happened Dave?");
246 }
247 }
248 };
249 return descriptor;
250 }
251
252 private static class StringModuleDescriptor extends AbstractModuleDescriptor<String>
253 {
254 public StringModuleDescriptor(ModuleFactory moduleFactory, String className)
255 {
256 super(moduleFactory);
257 moduleClassName = className;
258 }
259
260 @Override
261 public String getModule()
262 {
263 return null;
264 }
265
266 }
267
268 private static class ExtendsNumberModuleDescriptor<T extends Number> extends AbstractModuleDescriptor<T>
269 {
270 public ExtendsNumberModuleDescriptor(ModuleFactory moduleFactory, String className)
271 {
272 super(moduleFactory);
273 moduleClassName = className;
274 }
275
276 @Override
277 public T getModule()
278 {
279 return null;
280 }
281 }
282
283 private static class ExtendsNothingModuleDescriptor<T> extends AbstractModuleDescriptor<T>
284 {
285 public ExtendsNothingModuleDescriptor(ModuleFactory moduleFactory, String className)
286 {
287 super(moduleFactory);
288 moduleClassName = className;
289 }
290
291 @Override
292 public T getModule()
293 {
294 return null;
295 }
296 }
297 }