TestModuleOperations


1   /*
2    * File   : $Source: /usr/local/cvs/opencms/test/org/opencms/module/TestModuleOperations.java,v $
3    * Date   : $Date: 2006/03/27 14:53:04 $
4    * Version: $Revision: 1.22 $
5    *
6    * This library is part of OpenCms -
7    * the Open Source Content Mananagement System
8    *
9    * Copyright (c) 2005 Alkacon Software GmbH (http://www.alkacon.com)
10   *
11   * This library is free software; you can redistribute it and/or
12   * modify it under the terms of the GNU Lesser General Public
13   * License as published by the Free Software Foundation; either
14   * version 2.1 of the License, or (at your option) any later version.
15   *
16   * This library is distributed in the hope that it will be useful,
17   * but WITHOUT ANY WARRANTY; without even the implied warranty of
18   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19   * Lesser General Public License for more details.
20   *
21   * For further information about Alkacon Software GmbH, please see the
22   * company website: http://www.alkacon.com
23   *
24   * For further information about OpenCms, please see the
25   * project website: http://www.opencms.org
26   * 
27   * You should have received a copy of the GNU Lesser General Public
28   * License along with this library; if not, write to the Free Software
29   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
30   */
31  
32  package org.opencms.module;
33  
34  import org.opencms.configuration.CmsConfigurationException;
35  import org.opencms.file.CmsObject;
36  import org.opencms.file.types.CmsResourceTypeUnknown;
37  import org.opencms.file.types.I_CmsResourceType;
38  import org.opencms.loader.CmsDumpLoader;
39  import org.opencms.main.CmsException;
40  import org.opencms.main.I_CmsEventListener;
41  import org.opencms.main.OpenCms;
42  import org.opencms.report.CmsShellReport;
43  import org.opencms.security.CmsSecurityException;
44  import org.opencms.test.OpenCmsTestCase;
45  import org.opencms.test.OpenCmsTestLogAppender;
46  import org.opencms.test.OpenCmsTestProperties;
47  
48  import java.io.File  ;
49  import java.util.ArrayList  ;
50  import java.util.HashMap  ;
51  import java.util.List  ;
52  import java.util.Map  ;
53  
54  import junit.extensions.TestSetup;
55  import junit.framework.Test;
56  import junit.framework.TestSuite;
57  
58  /**
59   * Unit tests for OpenCms module operations.<p>
60   * 
61   * @author Alexander Kandzior 
62   * 
63   * @version $Revision: 1.22 $
64   */
65  public class TestModuleOperations extends OpenCmsTestCase {
66  
67      /**
68       * Default JUnit constructor.<p>
69       * 
70       * @param arg0 JUnit parameters
71       */
72      public TestModuleOperations(String   arg0) {
73  
74          super(arg0);
75      }
76  
77      /**
78       * Test suite for this test class.<p>
79       * 
80       * @return the test suite
81       */
82      public static Test suite() {
83  
84          OpenCmsTestProperties.initialize(org.opencms.test.AllTests.TEST_PROPERTIES_PATH);
85  
86          TestSuite suite = new TestSuite();
87          suite.setName(TestModuleOperations.class.getName());
88  
89          suite.addTest(new TestModuleOperations("testModuleImport"));
90          suite.addTest(new TestModuleOperations("testModuleExport"));
91          suite.addTest(new TestModuleOperations("testOldModuleImport"));
92          suite.addTest(new TestModuleOperations("testModuleImportMissingResTypeClass"));
93          suite.addTest(new TestModuleOperations("testModuleDependencies"));
94          suite.addTest(new TestModuleOperations("testModuleAdditionalResourcesWorkaround"));
95          suite.addTest(new TestModuleOperations("testModuleActionClass"));
96  
97          TestSetup wrapper = new TestSetup(suite) {
98  
99              protected void setUp() {
100 
101                 setupOpenCms("simpletest", "/sites/default/");
102             }
103 
104             protected void tearDown() {
105 
106                 removeOpenCms();
107             }
108         };
109 
110         return wrapper;
111     }
112 
113     /**
114      * Tests a module action class.<p>
115      * 
116      * @throws Throwable if something goes wrong
117      */
118     public void testModuleActionClass() throws Throwable   {
119 
120         CmsObject cms = getCmsObject();
121         echo("Testing module action class");
122 
123         String   moduleName = "org.opencms.configuration.TestModule1";
124 
125         // basic check if the module was imported correctly (during configuration)
126         if (!OpenCms.getModuleManager().hasModule(moduleName)) {
127             fail("Module '" + moduleName + "' was not imported!");
128         }
129 
130         CmsModule module = OpenCms.getModuleManager().getModule(moduleName);
131         I_CmsModuleAction actionInstance = module.getActionInstance();
132 
133         if (actionInstance == null) {
134             fail("Module '" + moduleName + "' has no action instance!");
135         }
136 
137         if (!(actionInstance instanceof TestModuleActionImpl)) {
138             fail("Module '" + moduleName + "' has action class of unexpected type!");
139         }
140 
141         // since module is configured by default, initialize must have been already called
142         assertEquals(true, TestModuleActionImpl.m_initialize);
143         // since something was published during setup, module method must habe been called
144         assertEquals(true, TestModuleActionImpl.m_publishProject);
145         // other values should not have been changed
146         assertEquals(false, TestModuleActionImpl.m_moduleUpdate);
147         assertEquals(false, TestModuleActionImpl.m_moduleUninstall);
148         assertEquals(false, TestModuleActionImpl.m_shutDown);
149         // reset other module action values
150         TestModuleActionImpl.m_cmsEvent = -1;
151         TestModuleActionImpl.m_publishProject = false;
152 
153         // publish the current project
154         cms.publishProject();
155         assertEquals(true, TestModuleActionImpl.m_publishProject);
156         assertTrue(TestModuleActionImpl.m_cmsEvent == I_CmsEventListener.EVENT_PUBLISH_PROJECT);
157 
158         // update the module
159         CmsModule newModule = new CmsModule(
160             module.getName(),
161             module.getGroup(),
162             module.getDescription(),
163             module.getActionClass(),
164             module.getDescription(),
165             module.getVersion(),
166             module.getAuthorName(),
167             module.getAuthorEmail(),
168             module.getDateCreated(),
169             module.getUserInstalled(),
170             module.getDateInstalled(),
171             module.getDependencies(),
172             module.getExportPoints(),
173             module.getResources(),
174             module.getParameters());
175 
176         // update the module
177         OpenCms.getModuleManager().updateModule(cms, newModule);
178         assertEquals(true, TestModuleActionImpl.m_moduleUpdate);
179 
180         // make sure we are in the "Offline" project
181         cms.getRequestContext().setCurrentProject(cms.readProject("Offline"));
182         assertEquals("Offline", cms.getRequestContext().currentProject().getName());
183 
184         // delete the module
185         OpenCms.getModuleManager().deleteModule(cms, module.getName(), false, new CmsShellReport(cms.getRequestContext().getLocale()));
186         assertEquals(true, TestModuleActionImpl.m_moduleUninstall);
187 
188         // reset module action values
189         TestModuleActionImpl.m_cmsEvent = -1;
190         TestModuleActionImpl.m_publishProject = false;
191 
192         // publish the current project 
193         cms.publishProject();
194         // since module was uninstalled, no update on action class must have happend
195         assertEquals(false, TestModuleActionImpl.m_publishProject);
196         assertTrue(TestModuleActionImpl.m_cmsEvent == -1);
197     }
198 
199     /**
200      * Tests a the "additionalresources" workaround.<p>
201      * 
202      * @throws Throwable if something goes wrong
203      */
204     public void testModuleAdditionalResourcesWorkaround() throws Throwable   {
205 
206         CmsObject cms = getCmsObject();
207         String   moduleName = "org.opencms.test.additionalResourcesWorkaround";
208 
209         // first test - conversion of resources to "additionalresources"
210         String   res1 = "/system/modules/tests/test1/";
211         String   res2 = "/system/modules/tests/test2/";
212         String   res3 = "/system/modules/tests/test3/";
213         String   res4 = "/system/modules/tests/test4/";
214         String   res5 = "/system/modules/tests/test5/";
215 
216         List   resources = new ArrayList  ();
217         resources.add(res1);
218         resources.add(res2);
219         resources.add(res3);
220         resources.add(res4);
221 
222         String   sep = ";";
223         String   additionalResources = res1 + sep + res2 + sep + res3 + sep + res4;
224 
225         CmsModule module1;
226 
227         //  test - set resources based on "additionalresources"
228         additionalResources += sep + "-" + sep + res5;
229 
230         Map   parameters = new HashMap  ();
231         parameters.put("additionalresources", additionalResources);
232 
233         module1 = new CmsModule(
234             moduleName,
235             "A test module for additioanlresources",
236             "ModuleGroup",
237             null,
238             null,
239             new CmsModuleVersion("1.0"),
240             "Alexander Kandzior",
241             "alex@opencms.org",
242             System.currentTimeMillis(),
243             null,
244             0L,
245             null,
246             null,
247             null,
248             parameters);
249 
250         OpenCms.getModuleManager().addModule(cms, module1);
251         module1 = OpenCms.getModuleManager().getModule(moduleName);
252 
253         assertTrue(module1.getResources().size() == 5);
254         resources = module1.getResources();
255         assertTrue(resources.contains(res1));
256         assertTrue(resources.contains(res2));
257         assertTrue(resources.contains(res3));
258         assertTrue(resources.contains(res4));
259         assertTrue(resources.contains(res5));
260 
261     }
262 
263     /**
264      * Tests a module import.<p>
265      * 
266      * @throws Throwable if something goes wrong
267      */
268     public void testModuleDependencies() throws Throwable   {
269 
270         CmsObject cms = getCmsObject();
271         echo("Testing module dependencies");
272 
273         String   moduleName = "org.opencms.test.modules.test2";
274 
275         String   moduleFile = OpenCms.getSystemInfo().getAbsoluteRfsPathRelativeToWebInf(
276             "packages/" + moduleName + ".zip");
277 
278         boolean caughtException = false;
279         try {
280             OpenCms.getImportExportManager().importData(cms, moduleFile, null, new CmsShellReport(cms.getRequestContext().getLocale()));
281         } catch (CmsException e) {
282             // any other CmsException means test failure
283             caughtException = true;
284         }
285 
286         // basic check if the module was _not_ imported
287         if (!caughtException || OpenCms.getModuleManager().hasModule(moduleName)) {
288             fail("Module '" + moduleName + "' was imported even though depdencies are not fullfilled!");
289         }
290 
291         CmsModule module;
292         module = CmsModuleImportExportHandler.readModuleFromImport(moduleFile);
293 
294         List   dependencies = OpenCms.getModuleManager().checkDependencies(
295             module,
296             CmsModuleManager.DEPENDENCY_MODE_IMPORT);
297 
298         if (dependencies.size() != 2) {
299             fail("Module '" + moduleName + "' has 2 dependencies, not " + dependencies.size());
300         }
301 
302         CmsModuleDependency dep1 = new CmsModuleDependency("org.opencms.test.dependency1", new CmsModuleVersion("1.0"));
303         CmsModuleDependency dep2 = new CmsModuleDependency("org.opencms.test.dependency2", new CmsModuleVersion("2.0"));
304 
305         if (!dependencies.contains(dep1)) {
306             fail("Missing required dependency: " + dep1);
307         }
308         if (!dependencies.contains(dep2)) {
309             fail("Missing required dependency: " + dep2);
310         }
311 
312         // add one (of two) depdendencies, with different but o.k. version number
313         addDependency(cms, new CmsModuleDependency(dep1.getName(), new CmsModuleVersion("2.5")));
314 
315         dependencies = OpenCms.getModuleManager().checkDependencies(module, CmsModuleManager.DEPENDENCY_MODE_IMPORT);
316 
317         if (dependencies.size() != 1) {
318             fail("Module '" + moduleName + "' still needs 1 dependency, not " + dependencies.size());
319         }
320 
321         if (!dependencies.contains(dep2)) {
322             fail("Missing required dependency: " + dep2);
323         }
324 
325         // add depdendency with wrong version
326         CmsModuleDependency dep3 = new CmsModuleDependency("org.opencms.test.dependency2", new CmsModuleVersion("1.0"));
327         addDependency(cms, dep3);
328 
329         dependencies = OpenCms.getModuleManager().checkDependencies(module, CmsModuleManager.DEPENDENCY_MODE_IMPORT);
330 
331         if (dependencies.size() != 1) {
332             fail("Module '" + moduleName + "' still needs 1 dependency, not " + dependencies.size());
333         }
334 
335         if (!dependencies.contains(dep2)) {
336             fail("Missing required dependency: " + dep2);
337         }
338 
339         // finally add depdendency with right version
340         addDependency(cms, dep2);
341 
342         dependencies = OpenCms.getModuleManager().checkDependencies(module, CmsModuleManager.DEPENDENCY_MODE_IMPORT);
343 
344         if (dependencies.size() != 0) {
345             fail("Module '" + moduleName + "' must have dependencies fullfilled");
346         }
347 
348         // now try the import again, this time it must work
349         OpenCms.getImportExportManager().importData(cms, moduleFile, null, new CmsShellReport(cms.getRequestContext().getLocale()));
350 
351         module = OpenCms.getModuleManager().getModule(moduleName);
352         // check the module data
353         assertEquals(module.getNiceName(), "OpenCms configuration test module 2");
354         assertEquals(module.getDescription(), "Test 2 for the OpenCms module import");
355         assertEquals(module.getVersion(), new CmsModuleVersion("1.5"));
356         assertTrue(module.getActionClass() == null);
357         assertEquals(module.getAuthorName(), "Alexander Kandzior");
358         assertEquals(module.getAuthorEmail(), "alex@opencms.org");
359         assertEquals(module.getExportPoints().size(), 2);
360         assertEquals(module.getResources().size(), 1);
361         assertEquals(module.getResources().get(0), "/system/modules/org.opencms.test.modules.test2/");
362         assertEquals(module.getParameter("param1"), "value1");
363         assertEquals(module.getParameter("param2"), "value2");
364 
365         // now try to delete the dependencies, this must generate an error
366         caughtException = false;
367         try {
368             OpenCms.getModuleManager().deleteModule(cms, dep1.getName(), false, new CmsShellReport(cms.getRequestContext().getLocale()));
369         } catch (CmsConfigurationException e) {
370             caughtException = true;
371         }
372         if (!caughtException) {
373             fail("Deleting '" + dep1.getName() + "' must generate an error");
374         }
375         caughtException = false;
376         try {
377             OpenCms.getModuleManager().deleteModule(cms, dep2.getName(), false, new CmsShellReport(cms.getRequestContext().getLocale()));
378         } catch (CmsConfigurationException e) {
379             caughtException = true;
380         }
381         if (!caughtException) {
382             fail("Deleting '" + dep2.getName() + "' must generate an error");
383         }
384 
385         CmsModuleDependency dep4 = new CmsModuleDependency(
386             "org.opencms.test.modules.test2",
387             new CmsModuleVersion("1.5"));
388 
389         module = OpenCms.getModuleManager().getModule(dep1.getName());
390         dependencies = OpenCms.getModuleManager().checkDependencies(module, CmsModuleManager.DEPENDENCY_MODE_DELETE);
391         if (!dependencies.contains(dep4)) {
392             fail("Dependency not checked: " + dep4);
393         }
394 
395         module = OpenCms.getModuleManager().getModule(dep2.getName());
396         dependencies = OpenCms.getModuleManager().checkDependencies(module, CmsModuleManager.DEPENDENCY_MODE_DELETE);
397         if (!dependencies.contains(dep4)) {
398             fail("Dependency not checked: " + dep4);
399         }
400 
401         // delete the imported module
402         OpenCms.getModuleManager().deleteModule(cms, moduleName, false, new CmsShellReport(cms.getRequestContext().getLocale()));
403 
404         // delete the dependencies (must work now since dependency is removed)
405         OpenCms.getModuleManager().deleteModule(cms, dep1.getName(), false, new CmsShellReport(cms.getRequestContext().getLocale()));
406         OpenCms.getModuleManager().deleteModule(cms, dep2.getName(), false, new CmsShellReport(cms.getRequestContext().getLocale()));
407 
408         // publish the current project
409         cms.publishProject();
410     }
411 
412     /**
413      * Tests a module export (and then re-import).<p>
414      * 
415      * @throws Throwable if something goes wrong
416      */
417     public void testModuleExport() throws Throwable   {
418 
419         CmsObject cms = getCmsObject();
420         echo("Testing export an re-import of a module");
421 
422         String   moduleName = "org.opencms.test.modules.testExport";
423 
424         String   moduleFile = OpenCms.getSystemInfo().getAbsoluteRfsPathRelativeToWebInf(
425             "packages/" + moduleName + ".zip");
426         File   file = new File  (moduleFile);
427         if (file.exists()) {
428             // probably from a old test run that didn't end with a success
429             file.delete();
430         }
431 
432         CmsModule module = new CmsModule(
433             moduleName,
434             "A test module for export",
435             "ModuleGroup",
436             null,
437             "This is the description",
438             new CmsModuleVersion("1.0"),
439             "Alexander Kandzior",
440             "alex@opencms.org",
441             System.currentTimeMillis(),
442             null,
443             0L,
444             null,
445             null,
446             null,
447             null);
448 
449         // add the module to the module manager
450         OpenCms.getModuleManager().addModule(cms, module);
451 
452         // basic check if the module was created correctly
453         if (!OpenCms.getModuleManager().hasModule(moduleName)) {
454             fail("Module '" + moduleName + "' was not created!");
455         }
456 
457         // generate a module export handler
458         CmsModuleImportExportHandler moduleExportHandler = new CmsModuleImportExportHandler();
459         moduleExportHandler.setFileName(moduleFile);
460         moduleExportHandler.setAdditionalResources(new String  [0]);
461         moduleExportHandler.setModuleName(moduleName.replace('\\', '/'));
462         moduleExportHandler.setDescription("Module export of " + moduleExportHandler.getModuleName());
463 
464         // export the module
465         OpenCms.getImportExportManager().exportData(cms, moduleExportHandler, new CmsShellReport(cms.getRequestContext().getLocale()));
466 
467         // now delete the module from the manager
468         OpenCms.getModuleManager().deleteModule(cms, moduleName, false, new CmsShellReport(cms.getRequestContext().getLocale()));
469 
470         // ensure that the module was deleted
471         if (OpenCms.getModuleManager().hasModule(moduleName)) {
472             fail("Module '" + moduleName + "' was not deleted!");
473         }
474 
475         // now import the module again
476         OpenCms.getImportExportManager().importData(cms, moduleFile, null, new CmsShellReport(cms.getRequestContext().getLocale()));
477 
478         // basic check if the module was imported correctly
479         if (!OpenCms.getModuleManager().hasModule(moduleName)) {
480             fail("Module '" + moduleName + "' was not imported!");
481         }
482 
483         CmsModule importedModule = OpenCms.getModuleManager().getModule(moduleName);
484         // now check the other module data
485         if (!module.isIdentical(importedModule)) {
486             fail("Impoted module not identical to original module!");
487         }
488 
489         if (file.exists()) {
490             // clean up
491             file.delete();
492         } else {
493             fail("Module export file was not written to expected location!");
494         }
495     }
496 
497     /**
498      * Tests a module import.<p>
499      * 
500      * @throws Throwable if something goes wrong
501      */
502     public void testModuleImport() throws Throwable   {
503 
504         CmsObject cms = getCmsObject();
505         echo("Testing import of a module");
506 
507         String   moduleName = "org.opencms.test.modules.test1";
508 
509         String   moduleFile = OpenCms.getSystemInfo().getAbsoluteRfsPathRelativeToWebInf(
510             "packages/" + moduleName + ".zip");
511         OpenCms.getImportExportManager().importData(cms, moduleFile, null, new CmsShellReport(cms.getRequestContext().getLocale()));
512 
513         // basic check if the module was imported correctly
514         if (!OpenCms.getModuleManager().hasModule(moduleName)) {
515             fail("Module '" + moduleName + "' was not imported!");
516         }
517 
518         CmsModule module = OpenCms.getModuleManager().getModule(moduleName);
519         // now check the other module data
520         assertEquals(module.getNiceName(), "OpenCms configuration test module 1");
521         assertEquals(module.getDescription(), "Test 1 for the OpenCms module import");
522         assertEquals(module.getVersion(), new CmsModuleVersion("1.0"));
523         assertTrue(module.getActionClass() == null);
524         assertEquals(module.getAuthorName(), "Alexander Kandzior");
525         assertEquals(module.getAuthorEmail(), "alex@opencms.org");
526         assertEquals(module.getExportPoints().size(), 2);
527         assertEquals(module.getResources().size(), 1);
528         assertEquals(module.getResources().get(0), "/system/modules/org.opencms.test.modules.test1/");
529         assertEquals(module.getParameter("param1"), "value1");
530         assertEquals(module.getParameter("param2"), "value2");
531     }
532 
533     /**
534      * Tests a module import with an unknown resource type class.<p>
535      * 
536      * @throws Throwable if something goes wrong
537      */
538     public void testModuleImportMissingResTypeClass() throws Throwable   {
539 
540         CmsObject cms = getCmsObject();
541         echo("Testing a module import with an unknown resource type class");
542 
543         String   moduleName = "org.opencms.test.modules.test4";
544 
545         String   moduleFile = OpenCms.getSystemInfo().getAbsoluteRfsPathRelativeToWebInf(
546             "packages/" + moduleName + ".zip");
547         
548         try {
549             // importing this module will generate an expected error in the log
550             OpenCmsTestLogAppender.setBreakOnError(false);
551             OpenCms.getImportExportManager().importData(cms, moduleFile, null, new CmsShellReport(cms.getRequestContext().getLocale()));
552         } finally {
553             OpenCmsTestLogAppender.setBreakOnError(true);            
554         }
555 
556         // basic check if the module was imported correctly
557         if (!OpenCms.getModuleManager().hasModule(moduleName)) {
558             fail("Module '" + moduleName + "' was not imported!");
559         }
560 
561         CmsModule module = OpenCms.getModuleManager().getModule(moduleName);
562         // now check the other module data
563         assertEquals(module.getNiceName(), "OpenCms configuration test module 4");
564         assertEquals(module.getDescription(), "Test 4 for the OpenCms module import: Missing classes");
565         assertEquals(module.getVersion(), new CmsModuleVersion("1.0"));
566         assertEquals(module.getActionClass(), "org.opencms.missing.moduleClass");
567         assertEquals(module.getAuthorName(), "Alexander Kandzior");
568         assertEquals(module.getAuthorEmail(), "alex@opencms.org");
569         assertEquals(module.getExportPoints().size(), 0);
570         assertEquals(module.getResources().size(), 0);
571         assertEquals(module.getParameter("param1"), "value1");
572         assertEquals(module.getParameter("param2"), "value2");
573                 
574         // check for the new resource type
575         I_CmsResourceType missingType = OpenCms.getResourceManager().getResourceType("missing");
576         assertNotNull(missingType);
577         // check configured and actual class name
578         assertEquals(missingType.getClassName(), "org.opencms.missing.resourceTypeClass");
579         assertEquals(missingType.getTypeId(), 88);
580         assertEquals(missingType.getLoaderId(), CmsDumpLoader.RESOURCE_LOADER_ID);
581         assertEquals(missingType.getClass().getName(), CmsResourceTypeUnknown.class.getName());
582     }
583     
584     /**
585      * Tests a module import of an old (OpenCms 5.0) style module.<p>
586      * 
587      * @throws Throwable if something goes wrong
588      */
589     public void testOldModuleImport() throws Throwable   {
590 
591         CmsObject cms = getCmsObject();
592         echo("Testing import of an old OpenCms 5.0 module");
593 
594         String   moduleName = "org.opencms.test.modules.testOld";
595 
596         String   moduleFile = OpenCms.getSystemInfo().getAbsoluteRfsPathRelativeToWebInf(
597             "packages/" + moduleName + ".zip");
598         OpenCms.getImportExportManager().importData(cms, moduleFile, null, new CmsShellReport(cms.getRequestContext().getLocale()));
599 
600         // basic check if the module was imported correctly
601         if (!OpenCms.getModuleManager().hasModule(moduleName)) {
602             fail("Module '" + moduleName + "' was not imported!");
603         }
604 
605         CmsModule module = OpenCms.getModuleManager().getModule(moduleName);
606         // now check the other module data
607         assertEquals(module.getNiceName(), "OpenCms v5.0 test module");
608         assertEquals(
609             module.getDescription().trim(),
610             "This is a module in the OpenCms v5.0.x style.\n\t\tThe XML format for modules has changed in OpenCms 6.0.");
611         assertEquals(module.getVersion(), new CmsModuleVersion("2.05"));
612         assertTrue(module.getActionClass() == null);
613         assertEquals(module.getAuthorName(), "Alexander Kandzior");
614         assertEquals(module.getAuthorEmail(), "alex@opencms.org");
615         // check if "additionalresources" where converted to module resources        
616         assertTrue(module.getResources().size() == 2);
617         assertEquals(module.getResources().get(0), "/system/modules/org.opencms.test.modules.testOld/");
618         assertEquals(module.getResources().get(1), "/alkacon-documentation/documentation-flexcache/");
619     }
620 
621     /**
622      * Adds a module dependency for the tests.<p>
623      * 
624      * @param cms the current OpenCms context
625      * @param dep the dependency to check
626      * 
627      * @throws CmsConfigurationException in case something goes wrong
628      * @throws CmsSecurityException in case something goes wrong
629      */
630     private void addDependency(CmsObject cms, CmsModuleDependency dep)
631     throws CmsSecurityException, CmsConfigurationException {
632 
633         if (OpenCms.getModuleManager().hasModule(dep.getName())) {
634             // remove other version of dependency if it exists
635             OpenCms.getModuleManager().deleteModule(cms, dep.getName(), true, new CmsShellReport(cms.getRequestContext().getLocale()));
636         }
637 
638         CmsModule module = new CmsModule(
639             dep.getName(),
640             "A test module dependency",
641             "ModuleGroup",
642             null,
643             null,
644             dep.getVersion(),
645             "Alexander Kandzior",
646             "alex@opencms.org",
647             System.currentTimeMillis(),
648             null,
649             0L,
650             null,
651             null,
652             null,
653             null);
654 
655         // add the module to the module manager
656         OpenCms.getModuleManager().addModule(cms, module);
657     }
658 }
659
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags