View Javadoc
1   package it.com.atlassian.plugin.loaders;
2   
3   import com.atlassian.plugin.DefaultModuleDescriptorFactory;
4   import com.atlassian.plugin.ModuleDescriptor;
5   import com.atlassian.plugin.Plugin;
6   import com.atlassian.plugin.PluginParseException;
7   import com.atlassian.plugin.StateAware;
8   import com.atlassian.plugin.descriptors.UnrecognisedModuleDescriptor;
9   import com.atlassian.plugin.elements.ResourceDescriptor;
10  import com.atlassian.plugin.elements.ResourceLocation;
11  import com.atlassian.plugin.hostcontainer.DefaultHostContainer;
12  import com.atlassian.plugin.impl.UnloadablePlugin;
13  import com.atlassian.plugin.loaders.SinglePluginLoader;
14  import com.atlassian.plugin.mock.MockAnimalModuleDescriptor;
15  import com.atlassian.plugin.mock.MockBear;
16  import com.atlassian.plugin.mock.MockGold;
17  import com.atlassian.plugin.mock.MockMineral;
18  import com.atlassian.plugin.mock.MockMineralModuleDescriptor;
19  import com.atlassian.plugin.mock.MockVegetableModuleDescriptor;
20  import com.atlassian.plugin.util.ClassLoaderUtils;
21  import com.google.common.collect.ImmutableList;
22  import com.google.common.collect.Iterables;
23  import org.hamcrest.Matchers;
24  import org.hamcrest.collection.IsIterableWithSize;
25  import org.junit.Test;
26  
27  import java.util.ArrayList;
28  import java.util.Collection;
29  import java.util.Iterator;
30  import java.util.List;
31  import java.util.Map;
32  
33  import static org.hamcrest.MatcherAssert.assertThat;
34  import static org.hamcrest.Matchers.endsWith;
35  import static org.hamcrest.Matchers.hasSize;
36  import static org.hamcrest.Matchers.instanceOf;
37  import static org.hamcrest.Matchers.is;
38  import static org.hamcrest.Matchers.notNullValue;
39  import static org.hamcrest.Matchers.nullValue;
40  
41  public class TestSinglePluginLoader {
42      @Test
43      public void singlePluginLoader() {
44          final SinglePluginLoader loader = new SinglePluginLoader("test-system-plugin.xml");
45          final DefaultModuleDescriptorFactory moduleDescriptorFactory = new DefaultModuleDescriptorFactory(new DefaultHostContainer());
46          moduleDescriptorFactory.addModuleDescriptor("animal", MockAnimalModuleDescriptor.class);
47          moduleDescriptorFactory.addModuleDescriptor("mineral", MockMineralModuleDescriptor.class);
48          final Iterable<Plugin> plugins = loader.loadAllPlugins(moduleDescriptorFactory);
49  
50          assertThat(plugins, IsIterableWithSize.iterableWithSize(1));
51  
52          // test the plugin information
53          final Plugin plugin = plugins.iterator().next();
54          assertThat(plugin.isSystemPlugin(), is(true));
55      }
56  
57      @Test
58      public void rejectOsgiPlugin() {
59          final SinglePluginLoader loader = new SinglePluginLoader("test-osgi-plugin.xml");
60          final DefaultModuleDescriptorFactory moduleDescriptorFactory = new DefaultModuleDescriptorFactory(new DefaultHostContainer());
61          final Iterable<Plugin> plugins = loader.loadAllPlugins(moduleDescriptorFactory);
62  
63          assertThat(plugins, IsIterableWithSize.iterableWithSize(1));
64  
65          // test the plugin information
66          final Plugin plugin = plugins.iterator().next();
67          assertThat(plugin, instanceOf(UnloadablePlugin.class));
68          assertThat(plugin.getKey(), is("test.atlassian.plugin"));
69      }
70  
71      @Test
72      public void atlassianPlugin() {
73          final SinglePluginLoader loader = new SinglePluginLoader("test-atlassian-plugin.xml");
74          final DefaultModuleDescriptorFactory moduleDescriptorFactory = new DefaultModuleDescriptorFactory(new DefaultHostContainer());
75          moduleDescriptorFactory.addModuleDescriptor("animal", MockAnimalModuleDescriptor.class);
76          moduleDescriptorFactory.addModuleDescriptor("mineral", MockMineralModuleDescriptor.class);
77          moduleDescriptorFactory.addModuleDescriptor("vegetable", MockVegetableModuleDescriptor.class);
78          final Iterable<Plugin> plugins = loader.loadAllPlugins(moduleDescriptorFactory);
79  
80          assertThat(plugins, IsIterableWithSize.iterableWithSize(1));
81  
82          // test the plugin information
83          final Plugin plugin = plugins.iterator().next();
84          enableModules(plugin);
85          assertThat(plugin.getName(), is("Test Plugin"));
86          assertThat(plugin.getKey(), is("test.atlassian.plugin"));
87          assertThat(plugin.getPluginInformation(), notNullValue());
88          assertThat(plugin.getPluginInformation().getVersion(), is("1.0"));
89          assertThat(plugin.getI18nNameKey(), is("test.atlassian.plugin.i18n"));
90          assertThat(plugin.getPluginInformation().getDescriptionKey(), is("test.atlassian.plugin.desc.i18n"));
91          assertThat(plugin.getPluginInformation().getDescription(), is("This plugin descriptor is just used for test purposes!"));
92          assertThat(plugin.getPluginInformation().getVendorName(), is("Atlassian Software Systems Pty Ltd"));
93          assertThat(plugin.getPluginInformation().getVendorUrl(), is("http://www.atlassian.com"));
94          assertThat(plugin.getModuleDescriptors().size(), is(4));
95  
96          final ModuleDescriptor bearDescriptor = plugin.getModuleDescriptor("bear");
97          assertThat(bearDescriptor.getCompleteKey(), is("test.atlassian.plugin:bear"));
98          assertThat(bearDescriptor.getKey(), is("bear"));
99          assertThat(bearDescriptor.getName(), is("Bear Animal"));
100         assertThat(bearDescriptor.getModuleClass(), Matchers.<Class>is(MockBear.class));
101         assertThat(bearDescriptor.getDescription(), is("A plugin module to describe a bear"));
102         assertThat(bearDescriptor.isEnabledByDefault(), is(true));
103         assertThat(bearDescriptor.getI18nNameKey(), is("test.atlassian.module.bear.name"));
104         assertThat(bearDescriptor.getDescriptionKey(), is("test.atlassian.module.bear.description"));
105 
106         final Iterable<ResourceDescriptor> resources = bearDescriptor.getResourceDescriptors();
107         assertThat(resources, IsIterableWithSize.iterableWithSize(3));
108 
109         final Map<String, String> params = bearDescriptor.getParams();
110         assertThat(params.get("height"), is("20"));
111         assertThat(params.get("colour"), is("brown"));
112 
113         final List<ModuleDescriptor<MockGold>> goldDescriptors = plugin.getModuleDescriptorsByModuleClass(MockGold.class);
114         assertThat(goldDescriptors, hasSize(1));
115         final ModuleDescriptor goldDescriptor = goldDescriptors.get(0);
116         assertThat(goldDescriptor.getCompleteKey(), is("test.atlassian.plugin:gold"));
117         assertThat(goldDescriptor.getModule(), Matchers.is(new MockGold(20)));
118         final List<ModuleDescriptor<MockMineral>> mineralDescriptors = plugin.getModuleDescriptorsByModuleClass(MockMineral.class);
119         assertThat(mineralDescriptors, hasSize(1));
120         final ModuleDescriptor mineralDescriptor = mineralDescriptors.get(0);
121         assertThat(mineralDescriptor, is(goldDescriptor));
122 
123         assertThat(plugin.getResourceDescriptors(), IsIterableWithSize.iterableWithSize(1));
124         final ResourceLocation pluginResource = plugin.getResourceLocation("download", "icon.gif");
125         assertThat(pluginResource.getLocation(), is("/icon.gif"));
126     }
127 
128     @Test
129     public void disabledPlugin() throws PluginParseException {
130         final SinglePluginLoader loader = new SinglePluginLoader("test-disabled-plugin.xml");
131         final DefaultModuleDescriptorFactory moduleDescriptorFactory = new DefaultModuleDescriptorFactory(new DefaultHostContainer());
132         moduleDescriptorFactory.addModuleDescriptor("mineral", MockMineralModuleDescriptor.class);
133         final Iterable<Plugin> plugins = loader.loadAllPlugins(moduleDescriptorFactory);
134         assertThat(plugins, Matchers.iterableWithSize(1));
135         final Plugin plugin = plugins.iterator().next();
136         assertThat(plugin.isEnabledByDefault(), is(false));
137 
138         final Collection<ModuleDescriptor<?>> moduleDescriptors = plugin.getModuleDescriptors();
139         assertThat(moduleDescriptors, hasSize(1));
140         final ModuleDescriptor module = plugin.getModuleDescriptor("gold");
141         assertThat(module.isEnabledByDefault(), is(false));
142     }
143 
144     @Test
145     public void pluginsInOrder() throws PluginParseException {
146         final SinglePluginLoader loader = new SinglePluginLoader(ClassLoaderUtils.getResource("test-ordered-pluginmodules.xml", SinglePluginLoader.class));
147         final DefaultModuleDescriptorFactory moduleDescriptorFactory = new DefaultModuleDescriptorFactory(new DefaultHostContainer());
148         moduleDescriptorFactory.addModuleDescriptor("animal", MockAnimalModuleDescriptor.class);
149         final Iterable plugins = loader.loadAllPlugins(moduleDescriptorFactory);
150         final Plugin plugin = (Plugin) plugins.iterator().next();
151         final Collection<ModuleDescriptor<?>> modules = plugin.getModuleDescriptors();
152         assertThat(modules, hasSize(3));
153         final Iterator iterator = modules.iterator();
154         assertThat(((MockAnimalModuleDescriptor) iterator.next()).getKey(), is("yogi1"));
155         assertThat(((MockAnimalModuleDescriptor) iterator.next()).getKey(), is("yogi2"));
156         assertThat(((MockAnimalModuleDescriptor) iterator.next()).getKey(), is("yogi3"));
157     }
158 
159     @Test
160     public void unknownPluginModule() throws PluginParseException {
161         final SinglePluginLoader loader = new SinglePluginLoader("test-bad-plugin.xml");
162         final Iterable<Plugin> plugins = loader.loadAllPlugins(new DefaultModuleDescriptorFactory(new DefaultHostContainer()));
163 
164         assertThat(plugins, Matchers.iterableWithSize(1));
165 
166         final Plugin plugin = plugins.iterator().next();
167         final List<ModuleDescriptor<?>> moduleList = ImmutableList.copyOf(plugin.getModuleDescriptors());
168         assertThat(moduleList, hasSize(1));
169 
170         // The module that had the problem should be an
171         // UnrecognisedModuleDescriptor
172         assertThat(moduleList.get(0).getClass(), Matchers.<Class>is(UnrecognisedModuleDescriptor.class));
173     }
174 
175     // PLUG-5
176     @Test
177     public void pluginWithOnlyPermittedModules() throws PluginParseException {
178         final SinglePluginLoader loader = new SinglePluginLoader("test-atlassian-plugin.xml");
179 
180         // Define the module descriptor factory
181         final DefaultModuleDescriptorFactory moduleDescriptorFactory = new DefaultModuleDescriptorFactory(new DefaultHostContainer());
182         moduleDescriptorFactory.addModuleDescriptor("animal", MockAnimalModuleDescriptor.class);
183         moduleDescriptorFactory.addModuleDescriptor("mineral", MockMineralModuleDescriptor.class);
184 
185         // Exclude mineral
186         final List<String> permittedList = new ArrayList<>();
187         permittedList.add("animal");
188         moduleDescriptorFactory.setPermittedModuleKeys(permittedList);
189 
190         final Iterable<Plugin> plugins = loader.loadAllPlugins(moduleDescriptorFactory);
191 
192         // 1 plugin returned
193         assertThat(plugins, Matchers.iterableWithSize(1));
194 
195         final Plugin plugin = plugins.iterator().next();
196 
197         // Only one descriptor, animal
198         assertThat(plugin.getModuleDescriptors(), hasSize(1));
199         assertThat(plugin.getModuleDescriptor("bear"), notNullValue());
200         assertThat(plugin.getModuleDescriptor("gold"), nullValue());
201     }
202 
203     // PLUG-5
204     @Test
205     public void pluginWithOnlyPermittedModulesAndMissingModuleDescriptor() throws PluginParseException {
206         final SinglePluginLoader loader = new SinglePluginLoader("test-atlassian-plugin.xml");
207 
208         // Define the module descriptor factory
209         final DefaultModuleDescriptorFactory moduleDescriptorFactory = new DefaultModuleDescriptorFactory(new DefaultHostContainer());
210         moduleDescriptorFactory.addModuleDescriptor("animal", MockAnimalModuleDescriptor.class);
211 
212         // Exclude mineral
213         final List<String> permittedList = new ArrayList<>();
214         permittedList.add("animal");
215         moduleDescriptorFactory.setPermittedModuleKeys(permittedList);
216 
217         final Iterable<Plugin> plugins = loader.loadAllPlugins(moduleDescriptorFactory);
218 
219         // 1 plugin returned
220         assertThat(plugins, Matchers.iterableWithSize(1));
221 
222         final Plugin plugin = plugins.iterator().next();
223 
224         // Only one descriptor, animal
225         assertThat(plugin.getModuleDescriptors(), hasSize(1));
226         assertThat(plugin.getModuleDescriptor("bear"), notNullValue());
227         assertThat(plugin.getModuleDescriptor("gold"), nullValue());
228     }
229 
230     @Test
231     public void badPluginKey() throws PluginParseException {
232         final SinglePluginLoader loader = new SinglePluginLoader("test-bad-plugin-key-plugin.xml");
233         final Iterable<Plugin> plugins = loader.loadAllPlugins(null);
234         assertThat(plugins, Matchers.iterableWithSize(1));
235         final Plugin plugin = plugins.iterator().next();
236         assertThat(plugin, instanceOf(UnloadablePlugin.class));
237         assertThat(plugin.getKey(), is("test-bad-plugin-key-plugin.xml"));
238         assertThat(((UnloadablePlugin) plugin).getErrorText(), endsWith("Plugin keys cannot contain ':'. Key is 'test:bad'"));
239     }
240 
241     @Test
242     public void nonUniqueKeysWithinAPlugin() throws PluginParseException {
243         final SinglePluginLoader loader = new SinglePluginLoader("test-bad-non-unique-keys-plugin.xml");
244         final DefaultModuleDescriptorFactory moduleDescriptorFactory = new DefaultModuleDescriptorFactory(new DefaultHostContainer());
245         moduleDescriptorFactory.addModuleDescriptor("animal", MockAnimalModuleDescriptor.class);
246         moduleDescriptorFactory.addModuleDescriptor("mineral", MockMineralModuleDescriptor.class);
247 
248         final Iterable<Plugin> plugins = loader.loadAllPlugins(moduleDescriptorFactory);
249         assertThat(plugins, Matchers.iterableWithSize(1));
250         final Plugin plugin = Iterables.get(plugins, 0);
251         assertThat(plugin, instanceOf(UnloadablePlugin.class));
252         assertThat(((UnloadablePlugin) plugin).getErrorText(), endsWith("Found duplicate key 'bear' within plugin 'test.bad.plugin'"));
253     }
254 
255     @Test
256     public void badResource() {
257         final Iterable<Plugin> plugins = new SinglePluginLoader("foo").loadAllPlugins(null);
258         assertThat(plugins, Matchers.iterableWithSize(1));
259         assertThat(Iterables.get(plugins, 0), instanceOf(UnloadablePlugin.class));
260         assertThat(Iterables.get(plugins, 0).getKey(), is("foo"));
261     }
262 
263     public void enableModules(final Plugin plugin) {
264         for (final ModuleDescriptor descriptor : plugin.getModuleDescriptors()) {
265             if (descriptor instanceof StateAware) {
266                 ((StateAware) descriptor).enabled();
267             }
268         }
269     }
270 }