Debian Codegraph @

src/test/java/org/jboss/modules/ModuleClassLoaderTest.java

raw
1 /*
2 * JBoss, Home of Professional Open Source.
3 * Copyright 2014 Red Hat, Inc., and individual contributors
4 * as indicated by the @author tags.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 package org.jboss.modules;
20
21 import org.jboss.modules.filter.MultiplePathFilterBuilder;
22 import org.jboss.modules.filter.PathFilters;
23 import org.jboss.modules.test.ImportedClass;
24 import org.jboss.modules.test.ImportedInterface;
25 import org.jboss.modules.test.TestClass;
26 import org.jboss.modules.util.TestModuleLoader;
27 import org.jboss.modules.util.TestResourceLoader;
28 import org.junit.Before;
29 import org.junit.Test;
30
31 import java.net.URL;
32 import java.util.Enumeration;
33 import java.util.List;
34
35 import static org.jboss.modules.util.Util.toList;
36 import static org.junit.Assert.assertEquals;
37 import static org.junit.Assert.assertNotNull;
38 import static org.junit.Assert.assertNull;
39 import static org.junit.Assert.assertTrue;
40 import static org.junit.Assert.fail;
41
42 /**
43 * Test to verify module functionality.
44 *
45 * @author John Bailey
46 * @author <a href="mailto:[email protected]">Flavia Rainone</a>
47 */
48 public class ModuleClassLoaderTest extends AbstractModuleTestCase {
49
50 private static final String MODULE_WITH_CONTENT_ID = "test-with-content";
51 private static final String MODULE_WITH_RESOURCE_ID = "test-with-resource";
52 private static final String MODULE_TO_IMPORT_ID = "test-to-import";
53 private static final String MODULE_WITH_EXPORT_ID = "test-with-export";
54 private static final String MODULE_WITH_DOUBLE_EXPORT_ID = "test-with-double-export";
55 private static final String MODULE_WITH_INVERTED_DOUBLE_EXPORT_ID = "test-with-inverted-double-export";
56 private static final String MODULE_WITH_FILTERED_EXPORT_ID = "test-with-filtered-export";
57 private static final String MODULE_WITH_FILTERED_IMPORT_ID = "test-with-filtered-import";
58 private static final String MODULE_WITH_FILTERED_DOUBLE_EXPORT_ID = "test-with-filtered-double-export";
59
60 private TestModuleLoader moduleLoader;
61
62 @Before
63 public void setupModuleLoader() throws Exception {
64 moduleLoader = new TestModuleLoader();
65
66 final ModuleSpec.Builder moduleWithContentBuilder = ModuleSpec.build(MODULE_WITH_CONTENT_ID);
67 moduleWithContentBuilder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(
68 TestResourceLoader.build()
69 .addClass(TestClass.class)
70 .addResources(getResource("test/modulecontentloader/rootOne"))
71 .create()
72 ));
73 moduleWithContentBuilder.addDependency(new ModuleDependencySpecBuilder()
74 .setName(MODULE_TO_IMPORT_ID.toString())
75 .build());
76 moduleWithContentBuilder.addDependency(DependencySpec.createLocalDependencySpec());
77 moduleLoader.addModuleSpec(moduleWithContentBuilder.create());
78
79 final ModuleSpec.Builder moduleWithResourceBuilder = ModuleSpec.build(MODULE_WITH_RESOURCE_ID);
80 moduleWithResourceBuilder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(
81 TestResourceLoader.build()
82 .addClass(TestClass.class)
83 .addResources(getResource("class-resources"))
84 .create()
85 ));
86 moduleWithResourceBuilder.addDependency(new ModuleDependencySpecBuilder()
87 .setName(MODULE_TO_IMPORT_ID.toString())
88 .build());
89 moduleWithResourceBuilder.addDependency(DependencySpec.createLocalDependencySpec());
90 moduleLoader.addModuleSpec(moduleWithResourceBuilder.create());
91
92 final ModuleSpec.Builder moduleToImportBuilder = ModuleSpec.build(MODULE_TO_IMPORT_ID);
93 moduleToImportBuilder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(
94 TestResourceLoader.build()
95 .addClass(ImportedClass.class)
96 .addClass(ImportedInterface.class)
97 .addResources(getResource("test/modulecontentloader/rootTwo"))
98 .create()
99 ));
100 moduleToImportBuilder.addDependency(DependencySpec.createLocalDependencySpec());
101 moduleLoader.addModuleSpec(moduleToImportBuilder.create());
102
103 final ModuleSpec.Builder moduleWithExportBuilder = ModuleSpec.build(MODULE_WITH_EXPORT_ID);
104 moduleWithExportBuilder.addDependency(new ModuleDependencySpecBuilder()
105 .setName(MODULE_TO_IMPORT_ID.toString())
106 .setExport(true)
107 .setOptional(false)
108 .build());
109 moduleWithExportBuilder.addDependency(DependencySpec.createLocalDependencySpec());
110 moduleLoader.addModuleSpec(moduleWithExportBuilder.create());
111
112 final MultiplePathFilterBuilder nestedAndOrgJBossExcludingBuilder = PathFilters.multiplePathFilterBuilder(true);
113 nestedAndOrgJBossExcludingBuilder.addFilter(PathFilters.match("org/jboss/**"), false);
114 nestedAndOrgJBossExcludingBuilder.addFilter(PathFilters.match("nested"), false);
115
116 final ModuleSpec.Builder moduleWithExportFilterBuilder = ModuleSpec.build(MODULE_WITH_FILTERED_EXPORT_ID);
117 moduleWithExportFilterBuilder.addDependency(new ModuleDependencySpecBuilder()
118 .setExportFilter(nestedAndOrgJBossExcludingBuilder.create())
119 .setModuleLoader(null)
120 .setName(MODULE_TO_IMPORT_ID.toString())
121 .setOptional(false)
122 .build());
123 moduleWithExportFilterBuilder.addDependency(DependencySpec.createLocalDependencySpec());
124 moduleLoader.addModuleSpec(moduleWithExportFilterBuilder.create());
125
126 final ModuleSpec.Builder moduleWithImportFilterBuilder = ModuleSpec.build(MODULE_WITH_FILTERED_IMPORT_ID);
127 moduleWithImportFilterBuilder.addDependency(new ModuleDependencySpecBuilder()
128 .setImportFilter(nestedAndOrgJBossExcludingBuilder.create())
129 .setName(MODULE_TO_IMPORT_ID.toString())
130 .setOptional(false)
131 .build());
132 moduleWithImportFilterBuilder.addDependency(DependencySpec.createLocalDependencySpec());
133 moduleLoader.addModuleSpec(moduleWithImportFilterBuilder.create());
134
135 final ModuleSpec.Builder moduleWithDoubleExportBuilder = ModuleSpec.build(MODULE_WITH_DOUBLE_EXPORT_ID);
136 moduleWithDoubleExportBuilder.addDependency(new ModuleDependencySpecBuilder()
137 .setName(MODULE_TO_IMPORT_ID.toString())
138 .setExport(true)
139 .build());
140 moduleWithDoubleExportBuilder.addDependency(new ModuleDependencySpecBuilder()
141 .setName(MODULE_WITH_CONTENT_ID.toString())
142 .setExport(true)
143 .build());
144 moduleWithDoubleExportBuilder.addDependency(DependencySpec.createLocalDependencySpec());
145 moduleLoader.addModuleSpec(moduleWithDoubleExportBuilder.create());
146
147 final ModuleSpec.Builder moduleWithInvertedDoubleExportBuilder = ModuleSpec.build(MODULE_WITH_INVERTED_DOUBLE_EXPORT_ID);
148 moduleWithInvertedDoubleExportBuilder.addDependency(new ModuleDependencySpecBuilder()
149 .setName(MODULE_WITH_CONTENT_ID.toString())
150 .setExport(true)
151 .build());
152 moduleWithInvertedDoubleExportBuilder.addDependency(new ModuleDependencySpecBuilder()
153 .setName(MODULE_TO_IMPORT_ID.toString())
154 .setExport(true)
155 .build());
156 moduleWithInvertedDoubleExportBuilder.addDependency(DependencySpec.createLocalDependencySpec());
157 moduleLoader.addModuleSpec(moduleWithInvertedDoubleExportBuilder.create());
158
159 final ModuleSpec.Builder moduleWithFilteredDoubleExportBuilder = ModuleSpec.build(MODULE_WITH_FILTERED_DOUBLE_EXPORT_ID);
160 moduleWithFilteredDoubleExportBuilder.addDependency(new ModuleDependencySpecBuilder()
161 .setImportFilter(PathFilters.not(PathFilters.match("nested")))
162 .setExport(true)
163 .setName(MODULE_TO_IMPORT_ID.toString())
164 .build());
165 moduleWithFilteredDoubleExportBuilder.addDependency(new ModuleDependencySpecBuilder()
166 .setName(MODULE_WITH_EXPORT_ID.toString())
167 .setExport(true)
168 .build());
169 moduleWithFilteredDoubleExportBuilder.addDependency(DependencySpec.createLocalDependencySpec());
170 moduleLoader.addModuleSpec(moduleWithFilteredDoubleExportBuilder.create());
171 }
172
173 @Test
174 public void testLocalClassLoad() throws Exception {
175 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
176 final ModuleClassLoader classLoader = testModule.getClassLoader();
177
178 try {
179 Class<?> testClass = classLoader.loadClass("org.jboss.modules.test.TestClass");
180 assertNotNull(testClass);
181 } catch (ClassNotFoundException e) {
182 fail("Should have loaded local class");
183 }
184 }
185
186 @Test
187 public void testResourceLoad() throws Exception {
188 final Module testModule = moduleLoader.loadModule(MODULE_WITH_RESOURCE_ID);
189 final ModuleClassLoader classLoader = testModule.getClassLoader();
190
191 try {
192 Class<?> testClass = classLoader.loadClass("org.jboss.modules.test.TestClass");
193 // direct
194 assertNotNull(testClass.getResource("/file1.txt")); // translates to /file1.txt
195 assertNotNull(testClass.getResource("file2.txt")); // translates to /org/jboss/modules/test/file2.txt
196 // relative
197 assertNotNull(testClass.getResource("../../../../file1.txt")); // should translate to /file1.txt
198 assertNotNull(testClass.getResource("test/../file2.txt")); // should translate to /org/jboss/modules/test/file2.txt
199 } catch (ClassNotFoundException e) {
200 e.printStackTrace();
201 fail("Should have loaded local class");
202 }
203 }
204
205 @Test
206 public void testLocalClassLoadNotFound() throws Exception {
207 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
208 final ModuleClassLoader classLoader = testModule.getClassLoader();
209
210 try {
211 classLoader.loadClass("org.jboss.modules.test.BogusClass");
212 fail("Should have thrown ClassNotFoundException");
213 } catch (ClassNotFoundException expected) {
214 }
215 }
216
217 @Test
218 public void testImportClassLoad() throws Exception {
219 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
220 final ModuleClassLoader classLoader = testModule.getClassLoader();
221
222 try {
223 Class<?> testClass = classLoader.loadClass("org.jboss.modules.test.ImportedClass");
224 assertNotNull(testClass);
225 } catch (ClassNotFoundException e) {
226 fail("Should have loaded imported class");
227 }
228 }
229
230 @Test
231 public void testFilteredImportClassLoad() throws Exception {
232 final Module testModule = moduleLoader.loadModule(MODULE_WITH_FILTERED_IMPORT_ID);
233 final ModuleClassLoader classLoader = testModule.getClassLoader();
234
235 try {
236 classLoader.loadClass("org.jboss.modules.test.ImportedClass");
237 fail("Should have thrown ClassNotFoundException");
238 } catch (ClassNotFoundException expected) {
239 }
240 }
241
242 @Test
243 public void testDoubleExportCLassLoad() throws Exception {
244 final Module testModule = moduleLoader.loadModule(MODULE_WITH_DOUBLE_EXPORT_ID);
245 final ModuleClassLoader classLoader = testModule.getClassLoader();
246 Class<?> testClass = classLoader.loadExportedClass("org.jboss.modules.test.ImportedClass");
247 assertNotNull(testClass);
248
249 testClass = classLoader.loadExportedClass("org.jboss.modules.test.TestClass");
250 assertNotNull(testClass);
251 }
252
253 @Test
254 public void testInvertedDoubleExportCLassLoad() throws Exception {
255 final Module testModule = moduleLoader.loadModule(MODULE_WITH_INVERTED_DOUBLE_EXPORT_ID);
256 final ModuleClassLoader classLoader = testModule.getClassLoader();
257 Class<?> testClass = classLoader.loadExportedClass("org.jboss.modules.test.ImportedClass");
258 assertNotNull(testClass);
259
260 testClass = classLoader.loadExportedClass("org.jboss.modules.test.TestClass");
261 assertNotNull(testClass);
262 }
263
264 @Test
265 public void testFilteredDoubleExportCLassLoad() throws Exception {
266 final Module testModule = moduleLoader.loadModule(MODULE_WITH_FILTERED_DOUBLE_EXPORT_ID);
267 final ModuleClassLoader classLoader = testModule.getClassLoader();
268 Class<?> testClass = classLoader.loadExportedClass("org.jboss.modules.test.ImportedClass");
269 assertNotNull(testClass);
270 }
271
272 @Test
273 public void testLocalResourceRetrieval() throws Exception {
274 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
275 final ModuleClassLoader classLoader = testModule.getClassLoader();
276 final URL resUrl = classLoader.getResource("test.txt");
277 assertNotNull(resUrl);
278 }
279
280 @Test
281 public void testLocalResourceRetrievalNotFound() throws Exception {
282 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
283 final ModuleClassLoader classLoader = testModule.getClassLoader();
284 final URL resUrl = classLoader.getResource("bogus.txt");
285 assertNull(resUrl);
286 }
287
288 @Test
289 public void testImportResourceRetrieval() throws Exception {
290 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
291 final ModuleClassLoader classLoader = testModule.getClassLoader();
292 final URL resUrl = classLoader.getResource("testTwo.txt");
293 assertNotNull(resUrl);
294 }
295
296 @Test
297 public void testFilteredImportResourceRetrieval() throws Exception {
298 final Module testModule = moduleLoader.loadModule(MODULE_WITH_FILTERED_IMPORT_ID);
299 final ModuleClassLoader classLoader = testModule.getClassLoader();
300
301 URL resUrl = classLoader.getResource("nested/nested.txt");
302 assertNull(resUrl);
303 }
304
305 @Test
306 public void testLocalResourcesRetrieval() throws Exception {
307 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
308 final ModuleClassLoader classLoader = testModule.getClassLoader();
309 final Enumeration<URL> resUrls = classLoader.getResources("test.txt");
310 assertNotNull(resUrls);
311 final List<URL> resUrlList = toList(resUrls);
312 assertEquals(1, resUrlList.size());
313 assertTrue(resUrlList.get(0).getPath().contains("rootOne"));
314 }
315
316 @Test
317 public void testLocalResourcesRetrievalNotFound() throws Exception {
318 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
319 final ModuleClassLoader classLoader = testModule.getClassLoader();
320 final Enumeration<URL> resUrls = classLoader.getResources("bogus.txt");
321 assertNotNull(resUrls);
322 final List<URL> resUrlList = toList(resUrls);
323 assertTrue(resUrlList.isEmpty());
324 }
325
326 @Test
327 public void testImportResourcesRetrieval() throws Exception {
328 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
329 final ModuleClassLoader classLoader = testModule.getClassLoader();
330 final Enumeration<URL> resUrls = classLoader.getResources("testTwo.txt");
331 assertNotNull(resUrls);
332 final List<URL> resUrlList = toList(resUrls);
333 assertEquals(1, resUrlList.size());
334 assertTrue(resUrlList.get(0).getPath().contains("rootTwo"));
335 }
336
337 @Test
338 public void testLocalAndImportResourcesRetrieval() throws Exception {
339 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
340 final ModuleClassLoader classLoader = testModule.getClassLoader();
341 final Enumeration<URL> resUrls = classLoader.getResources("nested/nested.txt");
342 assertNotNull(resUrls);
343 final List<URL> resUrlList = toList(resUrls);
344 assertEquals(2, resUrlList.size());
345 boolean rootOne = false;
346 boolean rootTwo = false;
347 for(URL resUrl : resUrlList) {
348 if(!rootOne)
349 rootOne = resUrl.getPath().contains("rootOne");
350 if(!rootTwo)
351 rootTwo = resUrl.getPath().contains("rootTwo");
352 }
353 assertTrue(rootOne);
354 assertTrue(rootTwo);
355 }
356
357 @Test
358 public void testFilteredImportResourcesRetrieval() throws Exception {
359 final Module testModule = moduleLoader.loadModule(MODULE_WITH_FILTERED_IMPORT_ID);
360 final ModuleClassLoader classLoader = testModule.getClassLoader();
361
362 Enumeration<URL> resUrls = classLoader.getResources("nested/nested.txt");
363 List<URL> resUrlList = toList(resUrls);
364 assertTrue(resUrlList.isEmpty());
365 }
366
367 @Test
368 public void testManifest() throws Exception {
369 final Module testModule = moduleLoader.loadModule(MODULE_WITH_CONTENT_ID);
370 final ModuleClassLoader classLoader = testModule.getClassLoader();
371
372 final Class<?> testClass = classLoader.loadClass("org.jboss.modules.test.TestClass");
373 System.out.println(testClass.getClassLoader());
374 final Package pkg = testClass.getPackage();
375 assertEquals("JBoss Modules Test Classes", pkg.getSpecificationTitle());
376 }
377 }