1. Project Clover database Tue Dec 20 2016 21:24:09 CET
  2. Package org.xwiki.extension.jar

File JarExtensionHandlerTest.java

 

Code metrics

20
455
37
1
1,133
709
54
0.12
12.3
37
1.46

Classes

Class Line # Actions
JarExtensionHandlerTest 56 455 0% 54 16
0.9687596.9%
 

Contributing tests

This file is covered by 23 tests. .

Source view

1    /*
2    * See the NOTICE file distributed with this work for additional
3    * information regarding copyright ownership.
4    *
5    * This is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU Lesser General Public License as
7    * published by the Free Software Foundation; either version 2.1 of
8    * the License, or (at your option) any later version.
9    *
10    * This software is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13    * Lesser General Public License for more details.
14    *
15    * You should have received a copy of the GNU Lesser General Public
16    * License along with this software; if not, write to the Free
17    * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18    * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
19    */
20    package org.xwiki.extension.jar;
21   
22    import java.io.File;
23    import java.lang.reflect.ParameterizedType;
24    import java.lang.reflect.Type;
25   
26    import org.apache.commons.lang3.reflect.MethodUtils;
27    import org.junit.Assert;
28    import org.junit.Test;
29    import org.xwiki.classloader.ClassLoaderManager;
30    import org.xwiki.component.internal.StackingComponentEventManager;
31    import org.xwiki.component.internal.multi.ComponentManagerManager;
32    import org.xwiki.component.manager.ComponentLookupException;
33    import org.xwiki.component.manager.ComponentManager;
34    import org.xwiki.component.util.DefaultParameterizedType;
35    import org.xwiki.component.util.ReflectionUtils;
36    import org.xwiki.extension.ExtensionId;
37    import org.xwiki.extension.InstallException;
38    import org.xwiki.extension.InstalledExtension;
39    import org.xwiki.extension.LocalExtension;
40    import org.xwiki.extension.repository.internal.core.CoreExtensionScanner;
41    import org.xwiki.extension.repository.internal.installed.DefaultInstalledExtension;
42    import org.xwiki.extension.test.AbstractExtensionHandlerTest;
43    import org.xwiki.logging.LogLevel;
44    import org.xwiki.logging.LoggerManager;
45    import org.xwiki.observation.ObservationManager;
46    import org.xwiki.test.annotation.AfterComponent;
47   
48    import packagefile.jarextension.DefaultTestComponent;
49    import packagefile.jarextension.TestComponent;
50    import packagefile.jarextensionwithdeps.DefaultTestComponentWithDeps;
51    import packagefile.jarextensionwithdeps.TestComponentWithDeps;
52   
53    import static org.junit.Assert.assertNotNull;
54    import static org.junit.Assert.assertNull;
55   
 
56    public class JarExtensionHandlerTest extends AbstractExtensionHandlerTest
57    {
58    private ComponentManagerManager componentManagerManager;
59   
60    private ClassLoader testApplicationClassloader;
61   
62    private ClassLoaderManager jarExtensionClassLoader;
63   
64    private static final String NAMESPACE = "namespace";
65   
 
66  23 toggle @AfterComponent
67    public void registerComponents() throws Exception
68    {
69    // Skip core extension scanner
70  23 this.mocker.registerMockComponent(CoreExtensionScanner.class);
71   
72    // Override the system ClassLoader to isolate class loading of extensions from the current ClassLoader
73    // (which already contains the extensions)
74  23 this.mocker.registerComponent(TestJarExtensionClassLoaderManager.class);
75   
76    // Make sure to fully enable ObservationManager to test EventListener live registration
77  23 StackingComponentEventManager componentEventManager = new StackingComponentEventManager();
78  23 componentEventManager.shouldStack(false);
79  23 this.mocker.setComponentEventManager(componentEventManager);
80   
81    // Ignore warning log during setup
82  23 ((LoggerManager) this.mocker.getInstance(LoggerManager.class)).pushLogListener(null);
83    }
84   
 
85  23 toggle @Override
86    public void setUp() throws Exception
87    {
88  23 super.setUp();
89   
90  23 this.testApplicationClassloader = Thread.currentThread().getContextClassLoader();
91   
92    // lookup
93  23 this.componentManagerManager = this.mocker.getInstance(ComponentManagerManager.class);
94  23 this.jarExtensionClassLoader = this.mocker.getInstance(ClassLoaderManager.class);
95   
96    // Make sure to fully enable ObservationManager to test EventListener live registration
97  23 StackingComponentEventManager componentEventManager =
98    (StackingComponentEventManager) this.mocker.getComponentEventManager();
99  23 ObservationManager manager = this.mocker.getInstance(ObservationManager.class);
100  23 componentEventManager.setObservationManager(manager);
101   
102  23 ((LoggerManager) this.mocker.getInstance(LoggerManager.class)).popLogListener();
103    }
104   
 
105  22 toggle private void assertNotEquals(Type type1, Type type2)
106    {
107  22 if (type1.equals(type2)) {
108  0 Assert.fail("expected not equals");
109    }
110    }
111   
112    /**
113    * @param namespace the namespace to be used
114    * @return the extension class loader for the current namespace
115    */
 
116  103 toggle private ClassLoader getExtensionClassloader(String namespace)
117    {
118  103 ClassLoader extensionLoader = this.jarExtensionClassLoader.getURLClassLoader(namespace, false);
119  103 if (extensionLoader == null) {
120  0 extensionLoader =
121    ((TestJarExtensionClassLoaderManager) this.jarExtensionClassLoader).testExtensionClassLoader;
122    }
123   
124  103 return extensionLoader;
125    }
126   
127    /**
128    * @param namespace the namespace to be used
129    * @return the extension ComponentManager for the current namespace
130    */
 
131  44 toggle private ComponentManager getExtensionComponentManager(String namespace)
132    {
133  44 ComponentManager extensionComponentManager = this.componentManagerManager.getComponentManager(namespace, false);
134  44 if (extensionComponentManager == null) {
135  0 try {
136  0 extensionComponentManager = this.mocker.getInstance(ComponentManager.class);
137    } catch (Exception e) {
138    // Should never happen
139    }
140    }
141   
142  44 return extensionComponentManager;
143    }
144   
145    /**
146    * Check that the extension is properly reported to be installed in all namespaces.
147    *
148    * @param installedExtension the local extension to check
149    */
 
150  23 toggle private void checkInstallStatus(InstalledExtension installedExtension)
151    {
152  23 checkInstallStatus(installedExtension, null);
153    }
154   
155    /**
156    * Check that the extension is properly reported to be installed in the given namespace.
157    *
158    * @param installedExtension the local extension to check
159    * @param namespace the namespace where it has been installed
160    */
 
161  50 toggle private void checkInstallStatus(InstalledExtension installedExtension, String namespace)
162    {
163    // check extension status
164  50 Assert.assertNotNull(installedExtension);
165  50 Assert.assertNotNull(installedExtension.getFile());
166  50 Assert.assertTrue(new File(installedExtension.getFile().getAbsolutePath()).exists());
167  50 Assert.assertTrue(installedExtension.isInstalled(namespace));
168  50 if (namespace != null) {
169  26 Assert.assertFalse(installedExtension.isInstalled(null));
170    }
171   
172    // check repository status
173  50 Assert.assertNotNull(
174    this.installedExtensionRepository.getInstalledExtension(installedExtension.getId().getId(), namespace));
175  50 if (namespace != null) {
176  26 Assert.assertNull(
177    this.installedExtensionRepository.getInstalledExtension(installedExtension.getId().getId(), null));
178    }
179    }
180   
 
181  100 toggle private Type getLoadedType(Type role, ClassLoader extensionLoader) throws ClassNotFoundException
182    {
183  100 if (role instanceof Class) {
184  46 return Class.forName(((Class<?>) role).getName(), true, extensionLoader);
185  54 } else if (role instanceof ParameterizedType) {
186  54 Class<?> rawType =
187    Class.forName(((Class<?>) ((ParameterizedType) role).getRawType()).getName(), true, extensionLoader);
188  45 return new DefaultParameterizedType(((ParameterizedType) role).getOwnerType(), rawType,
189    ((ParameterizedType) role).getActualTypeArguments());
190    }
191   
192  0 return null;
193    }
194   
195    /**
196    * Check that an extension is effectively available in all namespace and that the global component manager provide
197    * the expected default implementation.
198    *
199    * @param role the role expected to be provided by the extension
200    * @param implementation the implementation expected for the given role
201    * @param <T> the role class
202    * @return the effective role class in the extension class loader
203    * @throws Exception on error
204    */
 
205  27 toggle private <T> Type checkJarExtensionAvailability(Type role, Class<? extends T> implementation) throws Exception
206    {
207  27 return checkJarExtensionAvailability(role, implementation, null);
208    }
209   
210    /**
211    * Check that an extension is effectively available in the given namespace and that the corresponding component
212    * manager provide the expected default implementation.
213    *
214    * @param role the role expected to be provided by the extension
215    * @param implementation the implementation expected for the given role
216    * @param namespace the namespace where the extension is expected to installed
217    * @param <T> the role class
218    * @return the effective role class in the extension class loader
219    * @throws Exception on error
220    */
 
221  72 toggle private <T> Type checkJarExtensionAvailability(Type role, Class<? extends T> implementation, String namespace)
222    throws Exception
223    {
224  72 ClassLoader extensionLoader = getExtensionClassloader(namespace);
225  72 Assert.assertNotNull(extensionLoader);
226  72 Assert.assertNotSame(this.testApplicationClassloader, extensionLoader);
227   
228  72 Type loadedRole = getLoadedType(role, extensionLoader);
229    // Ensure the loaded role does not came from the application classloader (a check to validate the test)
230  72 Assert.assertFalse(loadedRole.equals(role));
231   
232  72 if (namespace != null) {
233  44 try {
234  44 this.jarExtensionClassLoader.getURLClassLoader(null, false)
235    .loadClass(ReflectionUtils.getTypeClass(loadedRole).getName());
236  0 Assert.fail("the interface should not be in the root class loader");
237    } catch (ClassNotFoundException expected) {
238    // expected
239    }
240    }
241   
242    // check components managers
243  72 Class<?> componentInstanceClass = null;
244  72 if (namespace != null) {
245  44 componentInstanceClass = getExtensionComponentManager(namespace).getInstance(loadedRole).getClass();
246   
247  44 try {
248  44 this.mocker.getInstance(loadedRole);
249  0 Assert.fail("the component should not be in the root component manager");
250    } catch (ComponentLookupException expected) {
251    // expected
252    }
253    } else {
254  28 componentInstanceClass = this.mocker.getInstance(loadedRole).getClass();
255    }
256  72 Assert.assertEquals(implementation.getName(), componentInstanceClass.getName());
257  72 Assert.assertNotSame(implementation, componentInstanceClass);
258   
259  72 return loadedRole;
260    }
261   
262    /**
263    * Check that the extension is properly reported to be not installed in all namespace.
264    *
265    * @param localExtension the local extension to check
266    */
 
267  15 toggle private void ckeckUninstallStatus(LocalExtension localExtension)
268    {
269  15 ckeckUninstallStatus(localExtension, null);
270    }
271   
272    /**
273    * Check that the extension is properly reported to be not installed in the given namespace.
274    *
275    * @param localExtension the local extension to check
276    * @param namespace the namespace where it should not be installed
277    */
 
278  23 toggle private void ckeckUninstallStatus(LocalExtension localExtension, String namespace)
279    {
280    // check extension status
281  23 Assert.assertFalse(DefaultInstalledExtension.isInstalled(localExtension, namespace));
282  23 Assert.assertFalse(DefaultInstalledExtension.isInstalled(localExtension, null));
283   
284    // check repository status
285  23 InstalledExtension installedExtension =
286    this.installedExtensionRepository.getInstalledExtension(localExtension.getId().getId(), namespace);
287  23 if (installedExtension != null) {
288  1 Assert.assertNotEquals(localExtension.getId(), installedExtension.getId());
289    }
290    }
291   
292    /**
293    * Check that an extension is effectively not available in all namespace and that the corresponding component
294    * manager does not provide an implementation.
295    *
296    * @param role the role expected to not be provide
297    * @throws Exception on error
298    */
 
299  7 toggle private void checkJarExtensionUnavailability(Type role) throws Exception
300    {
301  7 checkJarExtensionUnavailability(role, null);
302    }
303   
304    /**
305    * Check that an extension is effectively not available in the given namespace and that the corresponding component
306    * manager does not provide an implementation.
307    *
308    * @param role the role expected to not be provide
309    * @param namespace the namespace where the extension is not expected to be installed
310    * @throws Exception on error
311    */
 
312  28 toggle private void checkJarExtensionUnavailability(Type role, String namespace) throws Exception
313    {
314  28 try {
315  28 ClassLoader extensionLoader = getExtensionClassloader(namespace);
316  28 Type loadedRole = getLoadedType(role, extensionLoader);
317   
318    // check components managers
319  0 this.mocker.getInstance(loadedRole);
320  0 Assert.fail("the extension has not been uninstalled, component found!");
321    } catch (ComponentLookupException unexpected) {
322  0 Assert.fail("the extension has not been uninstalled, role found!");
323    } catch (ClassNotFoundException expected) {
324    // expected
325    }
326    }
327   
 
328  1 toggle @Test
329    public void testInstallAndUninstallExtension() throws Throwable
330    {
331  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension", "test");
332   
333    // actual install test
334  1 InstalledExtension installedExtension = install(extensionId);
335   
336  1 checkInstallStatus(installedExtension);
337   
338  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature", null));
339   
340  1 Type extensionRole1 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
341   
342    // try to install again
343  1 try {
344  1 install(extensionId);
345  0 Assert.fail("installExtension should have failed");
346    } catch (InstallException expected) {
347    // expected
348    }
349   
350    // actual uninstall test
351  1 LocalExtension localExtension = uninstall(extensionId, null);
352   
353  1 ckeckUninstallStatus(localExtension);
354   
355  1 checkJarExtensionUnavailability(TestComponent.TYPE_STRING);
356   
357    // actual reinstall test
358  1 installedExtension = install(extensionId);
359   
360  1 checkInstallStatus(installedExtension);
361   
362  1 Type extensionRole2 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
363  1 assertNotEquals(extensionRole1, extensionRole2);
364    }
365   
 
366  1 toggle @Test
367    public void testInstallAndUninstallWebjarExtension() throws Throwable
368    {
369  1 final ExtensionId extensionId = new ExtensionId("webjar", "test");
370   
371    // actual install test
372  1 InstalledExtension installedExtension = install(extensionId);
373   
374  1 checkInstallStatus(installedExtension);
375   
376    // actual uninstall test
377  1 LocalExtension localExtension = uninstall(extensionId, null);
378   
379  1 ckeckUninstallStatus(localExtension);
380   
381    // actual reinstall test
382  1 installedExtension = install(extensionId);
383   
384  1 checkInstallStatus(installedExtension);
385    }
386   
 
387  1 toggle @Test
388    public void testUpgradeAndDowngradeExtensionOnNamespace() throws Throwable
389    {
390  1 final ExtensionId extensionId1 = new ExtensionId("test", "1.0");
391  1 final ExtensionId extensionId2 = new ExtensionId("test", "2.0");
392   
393    // install 1.0
394  1 InstalledExtension installedExtension = install(extensionId1, NAMESPACE);
395   
396  1 checkInstallStatus(installedExtension, NAMESPACE);
397   
398  1 Assert.assertSame(installedExtension,
399    this.installedExtensionRepository.getInstalledExtension(extensionId1.getId(), NAMESPACE));
400  1 Assert.assertNull(this.installedExtensionRepository.getInstalledExtension(extensionId1.getId(), null));
401   
402  1 Class<?> clazz = Class.forName("test.TestClass", true, getExtensionClassloader(NAMESPACE));
403  1 assertNotNull(MethodUtils.getAccessibleMethod(clazz, "method1"));
404  1 assertNull(MethodUtils.getAccessibleMethod(clazz, "method2"));
405   
406    // upgrade to 2.0
407  1 installedExtension = install(extensionId2, NAMESPACE);
408   
409  1 checkInstallStatus(installedExtension, NAMESPACE);
410   
411  1 Assert.assertSame(installedExtension,
412    this.installedExtensionRepository.getInstalledExtension(extensionId2.getId(), NAMESPACE));
413  1 Assert.assertNull(this.installedExtensionRepository.getInstalledExtension(extensionId2.getId(), null));
414   
415  1 clazz = Class.forName("test.TestClass", true, getExtensionClassloader(NAMESPACE));
416  1 assertNotNull(MethodUtils.getAccessibleMethod(clazz, "method1"));
417  1 assertNotNull(MethodUtils.getAccessibleMethod(clazz, "method2"));
418   
419    // downgrade to 1.0
420  1 installedExtension = install(extensionId1, NAMESPACE);
421   
422  1 checkInstallStatus(installedExtension, NAMESPACE);
423   
424  1 Assert.assertSame(installedExtension,
425    this.installedExtensionRepository.getInstalledExtension(extensionId1.getId(), NAMESPACE));
426  1 Assert.assertNull(this.installedExtensionRepository.getInstalledExtension(extensionId1.getId(), null));
427   
428  1 clazz = Class.forName("test.TestClass", true, getExtensionClassloader(NAMESPACE));
429  1 assertNotNull(MethodUtils.getAccessibleMethod(clazz, "method1"));
430  1 assertNull(MethodUtils.getAccessibleMethod(clazz, "method2"));
431    }
432   
 
433  1 toggle @Test
434    public void testInstallAndUninstallExtensionOnNamespace() throws Throwable
435    {
436  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension", "test");
437   
438    // actual install test
439  1 InstalledExtension installedExtension = install(extensionId, NAMESPACE);
440   
441  1 checkInstallStatus(installedExtension, NAMESPACE);
442   
443  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature", NAMESPACE));
444  1 Assert.assertNull(this.installedExtensionRepository.getInstalledExtension("feature", null));
445   
446  1 checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, NAMESPACE);
447   
448  1 try {
449  1 install(extensionId, NAMESPACE);
450  0 Assert.fail("installExtension should have failed");
451    } catch (InstallException expected) {
452    // expected
453    }
454   
455    // actual uninstall test
456  1 LocalExtension localExtension = uninstall(extensionId, null);
457   
458  1 ckeckUninstallStatus(localExtension, NAMESPACE);
459   
460  1 checkJarExtensionUnavailability(TestComponent.TYPE_STRING, NAMESPACE);
461    }
462   
 
463  1 toggle @Test
464    public void testInstallAndUninstallExtensionWithoutComponents() throws Throwable
465    {
466  1 final ExtensionId extensionId = new ExtensionId("simplejar", "test");
467   
468    // actual install test
469  1 InstalledExtension installedExtension = install(extensionId);
470   
471  1 checkInstallStatus(installedExtension);
472   
473    // actual uninstall test
474  1 LocalExtension localExtension = uninstall(extensionId, null);
475   
476  1 ckeckUninstallStatus(localExtension);
477   
478    // actual reinstall test
479  1 installedExtension = install(extensionId);
480   
481  1 checkInstallStatus(installedExtension);
482    }
483   
 
484  1 toggle @Test
485    public void testInstallAndUninstallExtensionWithDependency() throws Throwable
486    {
487  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
488   
489    // actual install test
490  1 InstalledExtension installedExtension = install(extensionId);
491   
492  1 checkInstallStatus(installedExtension);
493   
494  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", null));
495  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature", null));
496   
497  1 Type extensionRole1 =
498    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class);
499  1 Type extensionDep1 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
500   
501    // actual uninstall test
502  1 LocalExtension localExtension = uninstall(extensionId, null);
503   
504  1 ckeckUninstallStatus(localExtension);
505   
506  1 checkJarExtensionUnavailability(TestComponentWithDeps.class);
507  1 Type extensionDep2 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
508  1 assertNotEquals(extensionDep1, extensionDep2);
509   
510    // actual reinstall test
511  1 installedExtension = install(extensionId);
512   
513  1 checkInstallStatus(installedExtension);
514   
515  1 Type extensionRole2 =
516    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class);
517  1 Type extensionDep3 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
518  1 assertNotEquals(extensionRole1, extensionRole2);
519  1 Assert.assertEquals(extensionDep2, extensionDep3);
520    }
521   
 
522  1 toggle @Test
523    public void testInstallAndUninstallExtensionWithDependencyOnANamespace() throws Throwable
524    {
525  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
526  1 final String namespace = NAMESPACE;
527   
528    // actual install test
529  1 InstalledExtension installExtension = install(extensionId, namespace);
530   
531  1 checkInstallStatus(installExtension, namespace);
532   
533  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace));
534  1 Assert.assertNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", null));
535   
536  1 checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace);
537  1 checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace);
538   
539    // actual uninstall test
540  1 LocalExtension localExtension = uninstall(extensionId, null);
541   
542  1 ckeckUninstallStatus(localExtension, namespace);
543   
544  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace);
545  1 checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace);
546    }
547   
 
548  1 toggle @Test
549    public void testInstallEntensionAndUninstallDependency() throws Throwable
550    {
551  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
552  1 final ExtensionId dependencyId = new ExtensionId("org.xwiki.test:test-extension", "test");
553   
554    // actual install test
555  1 InstalledExtension installedExtension = install(extensionId);
556   
557  1 checkInstallStatus(installedExtension);
558   
559  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", null));
560  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature", null));
561   
562  1 Type extensionRole1 =
563    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class);
564  1 Type extensionDep1 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
565   
566    // actual uninstall test
567  1 LocalExtension localExtension = uninstall(dependencyId, null);
568   
569  1 ckeckUninstallStatus(localExtension);
570   
571  1 checkJarExtensionUnavailability(TestComponent.TYPE_STRING);
572  1 checkJarExtensionUnavailability(TestComponentWithDeps.class);
573   
574    // actual reinstall test
575  1 installedExtension = install(extensionId);
576   
577  1 checkInstallStatus(installedExtension);
578   
579  1 Type extensionRole2 =
580    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class);
581  1 Type extensionDep2 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
582  1 assertNotEquals(extensionRole1, extensionRole2);
583  1 assertNotEquals(extensionDep1, extensionDep2);
584    }
585   
 
586  1 toggle @Test
587    public void testInstallExtensionAndUninstallDependencyOnANamespace() throws Throwable
588    {
589  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
590  1 final ExtensionId dependencyId = new ExtensionId("org.xwiki.test:test-extension", "test");
591  1 final String namespace = NAMESPACE;
592   
593    // actual install test
594  1 InstalledExtension installedExtension = install(extensionId, namespace);
595   
596  1 checkInstallStatus(installedExtension, namespace);
597   
598  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace));
599  1 Assert.assertNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", null));
600   
601  1 checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace);
602  1 checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace);
603   
604    // actual uninstall test
605  1 LocalExtension localExtension = uninstall(dependencyId, null);
606   
607  1 ckeckUninstallStatus(localExtension, namespace);
608   
609  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace);
610  1 checkJarExtensionUnavailability(TestComponentWithDeps.class);
611    }
612   
 
613  1 toggle @Test
614    public void testInstallDependencyInstallExtensionOnANamespaceAndUninstallExtension() throws Throwable
615    {
616  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
617  1 final ExtensionId dependencyId = new ExtensionId("org.xwiki.test:test-extension", "test");
618  1 final String namespace = NAMESPACE;
619   
620    // actual install test
621  1 InstalledExtension installedExtension = install(dependencyId);
622   
623  1 checkInstallStatus(installedExtension);
624  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature", null));
625  1 Type extensionDep1 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
626   
627    // actual install test
628  1 installedExtension = install(extensionId, namespace);
629   
630  1 checkInstallStatus(installedExtension, namespace);
631  1 checkInstallStatus(this.installedExtensionRepository.resolve(dependencyId));
632   
633  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace));
634  1 Type extensionRole1 =
635    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace);
636  1 Type extensionDep2 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
637  1 Assert.assertEquals(extensionDep1, extensionDep2);
638   
639    // actual uninstall test
640  1 LocalExtension localExtension = uninstall(extensionId, namespace);
641   
642  1 ckeckUninstallStatus(localExtension, namespace);
643  1 checkInstallStatus(this.installedExtensionRepository.resolve(dependencyId));
644   
645  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace);
646  1 Type extensionDep3 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
647  1 Assert.assertEquals(extensionDep1, extensionDep3);
648   
649    // actual reinstall test
650  1 installedExtension = install(extensionId, namespace);
651   
652  1 checkInstallStatus(installedExtension, namespace);
653   
654  1 Type extensionRole2 =
655    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace);
656  1 Type extensionDep4 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
657  1 assertNotEquals(extensionRole1, extensionRole2);
658  1 Assert.assertEquals(extensionDep1, extensionDep4);
659    }
660   
 
661  1 toggle @Test
662    public void testInstallDependencyInstallExtensionOnANamespaceAndUninstallDependency() throws Throwable
663    {
664  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
665  1 final ExtensionId dependencyId = new ExtensionId("org.xwiki.test:test-extension", "test");
666  1 final String namespace = NAMESPACE;
667   
668    // actual install test
669  1 InstalledExtension installedExtension = install(dependencyId);
670   
671  1 checkInstallStatus(installedExtension);
672  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature", null));
673  1 Type extensionDep1 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
674   
675    // actual install test
676  1 installedExtension = install(extensionId, namespace);
677   
678  1 checkInstallStatus(installedExtension, namespace);
679  1 checkInstallStatus(this.installedExtensionRepository.resolve(dependencyId));
680   
681  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace));
682  1 Type extensionRole1 =
683    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace);
684  1 Type extensionDep2 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
685  1 Assert.assertEquals(extensionDep1, extensionDep2);
686   
687    // actual uninstall test
688  1 LocalExtension localExtension = uninstall(dependencyId, null);
689   
690  1 ckeckUninstallStatus(localExtension);
691  1 ckeckUninstallStatus(this.localExtensionRepository.resolve(extensionId), namespace);
692   
693  1 checkJarExtensionUnavailability(TestComponent.TYPE_STRING);
694  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace);
695   
696    // actual reinstall test
697  1 installedExtension = install(extensionId, namespace);
698   
699  1 checkInstallStatus(installedExtension, namespace);
700  1 checkInstallStatus(this.installedExtensionRepository.resolve(dependencyId), namespace);
701   
702  1 Type extensionRole2 =
703    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace);
704  1 Type extensionDep3 =
705    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace);
706  1 assertNotEquals(extensionRole1, extensionRole2);
707  1 assertNotEquals(extensionDep1, extensionDep3);
708    }
709   
 
710  1 toggle @Test
711    public void testMultipleInstallOnANamespaceAndUninstall() throws Throwable
712    {
713  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
714  1 final String namespace1 = "namespace1";
715  1 final String namespace2 = "namespace2";
716   
717    // actual install test
718  1 InstalledExtension installedExtension = install(extensionId, namespace1);
719   
720  1 checkInstallStatus(installedExtension, namespace1);
721   
722  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace1));
723  1 Type extensionRole1 =
724    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace1);
725  1 Type extensionDep1 =
726    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace1);
727   
728    // actual install test
729    // TODO: go back to LogLevel.WARN when http://jira.xwiki.org/browse/XCOMMONS-213 is fixed
730  1 installedExtension = install(extensionId, namespace2, LogLevel.ERROR);
731   
732  1 checkInstallStatus(installedExtension, namespace2);
733   
734  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace2));
735  1 Type extensionRole2 =
736    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace2);
737  1 Type extensionDep2 =
738    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace2);
739  1 assertNotEquals(extensionRole1, extensionRole2);
740  1 assertNotEquals(extensionDep1, extensionDep2);
741   
742    // actual uninstall test
743    // FIXME: Ignore warning because of https://jira.xwiki.org/browse/XCOMMONS-213
744  1 LocalExtension localExtension = uninstall(extensionId, namespace1, LogLevel.ERROR);
745   
746  1 ckeckUninstallStatus(localExtension);
747   
748  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace1);
749  1 Type extensionDep3 =
750    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace1);
751  1 assertNotEquals(extensionDep1, extensionDep3);
752   
753  1 Type extensionRole3 =
754    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace2);
755  1 Type extensionDep4 =
756    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace2);
757  1 Assert.assertEquals(extensionRole2, extensionRole3);
758  1 Assert.assertEquals(extensionDep2, extensionDep4);
759   
760    // actual uninstall test
761    // FIXME: Ignore warning because of https://jira.xwiki.org/browse/XCOMMONS-213
762  1 localExtension = uninstall(extensionId, namespace2, LogLevel.ERROR);
763   
764  1 ckeckUninstallStatus(localExtension);
765   
766  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace2);
767  1 Type extensionDep5 =
768    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace2);
769  1 assertNotEquals(extensionDep2, extensionDep5);
770   
771  1 Type extensionDep6 =
772    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace1);
773  1 Assert.assertEquals(extensionDep3, extensionDep6);
774    }
775   
 
776  1 toggle @Test
777    public void testMultipleInstallOnANamespaceAndUninstallDependency() throws Throwable
778    {
779  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
780  1 final ExtensionId dependencyId = new ExtensionId("org.xwiki.test:test-extension", "test");
781  1 final String namespace1 = "namespace1";
782  1 final String namespace2 = "namespace2";
783   
784  1 InstalledExtension installedExtension = install(extensionId, namespace1);
785   
786  1 checkInstallStatus(installedExtension, namespace1);
787   
788  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace1));
789  1 Type extensionRole1 =
790    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace1);
791  1 Type extensionDep1 =
792    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace1);
793   
794    // TODO: go back to LogLevel.WARN when http://jira.xwiki.org/browse/XCOMMONS-213 is fixed
795  1 installedExtension = install(extensionId, namespace2, LogLevel.ERROR);
796   
797  1 checkInstallStatus(installedExtension, namespace2);
798   
799  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace2));
800  1 Type extensionRole2 =
801    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace2);
802  1 Type extensionDep2 =
803    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace2);
804  1 assertNotEquals(extensionRole1, extensionRole2);
805  1 assertNotEquals(extensionDep1, extensionDep2);
806   
807    // actual uninstall test
808  1 LocalExtension localExtension = uninstall(dependencyId, namespace1);
809   
810  1 ckeckUninstallStatus(localExtension);
811   
812  1 checkJarExtensionUnavailability(TestComponent.TYPE_STRING, namespace1);
813  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace1);
814   
815  1 Type extensionRole3 =
816    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace2);
817  1 Type extensionDep3 =
818    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace2);
819  1 Assert.assertEquals(extensionRole2, extensionRole3);
820  1 Assert.assertEquals(extensionDep2, extensionDep3);
821   
822    // actual uninstall test
823  1 localExtension = uninstall(dependencyId, namespace2);
824   
825  1 ckeckUninstallStatus(localExtension);
826   
827  1 checkJarExtensionUnavailability(TestComponent.TYPE_STRING, namespace2);
828  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace2);
829    }
830   
 
831  1 toggle @Test
832    public void testMultipleInstallOnANamespaceAndUninstallAll() throws Throwable
833    {
834  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
835  1 final String namespace1 = "namespace1";
836  1 final String namespace2 = "namespace2";
837   
838  1 InstalledExtension installedExtension = install(extensionId, namespace1);
839   
840  1 checkInstallStatus(installedExtension, namespace1);
841   
842  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace1));
843  1 Type extensionRole1 =
844    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace1);
845  1 Type extensionDep1 =
846    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace1);
847   
848    // TODO: go back to LogLevel.WARN when http://jira.xwiki.org/browse/XCOMMONS-213 is fixed
849  1 installedExtension = install(extensionId, namespace2, LogLevel.ERROR);
850   
851  1 checkInstallStatus(installedExtension, namespace2);
852   
853  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace2));
854  1 Type extensionRole2 =
855    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace2);
856  1 Type extensionDep2 =
857    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace2);
858  1 assertNotEquals(extensionRole1, extensionRole2);
859  1 assertNotEquals(extensionDep1, extensionDep2);
860   
861    // actual uninstall test
862    // FIXME: Ignore warning because of https://jira.xwiki.org/browse/XCOMMONS-213
863  1 LocalExtension localExtension = uninstall(extensionId, null, LogLevel.ERROR);
864   
865  1 ckeckUninstallStatus(localExtension);
866   
867  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace1);
868  1 Type extensionDep3 =
869    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace1);
870  1 assertNotEquals(extensionDep1, extensionDep3);
871  1 Type extensionDep4 =
872    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace2);
873  1 assertNotEquals(extensionDep2, extensionDep4);
874    }
875   
 
876  1 toggle @Test
877    public void testMultipleInstallOnANamespaceAndUninstallDependencyAll() throws Throwable
878    {
879  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
880  1 final ExtensionId dependencyId = new ExtensionId("org.xwiki.test:test-extension", "test");
881  1 final String namespace1 = "namespace1";
882  1 final String namespace2 = "namespace2";
883   
884  1 InstalledExtension installedExtension = install(extensionId, namespace1);
885   
886  1 checkInstallStatus(installedExtension, namespace1);
887   
888  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace1));
889  1 Type extensionRole1 =
890    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace1);
891  1 Type extensionDep1 =
892    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace1);
893   
894    // TODO: go back to LogLevel.WARN when http://jira.xwiki.org/browse/XCOMMONS-213 is fixed
895  1 installedExtension = install(extensionId, namespace2, LogLevel.ERROR);
896   
897  1 checkInstallStatus(installedExtension, namespace2);
898   
899  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace2));
900  1 Type extensionRole2 =
901    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace2);
902  1 Type extensionDep2 =
903    checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, namespace2);
904  1 assertNotEquals(extensionRole1, extensionRole2);
905  1 assertNotEquals(extensionDep1, extensionDep2);
906   
907    // actual uninstall test
908  1 LocalExtension localExtension = uninstall(dependencyId, null);
909   
910  1 ckeckUninstallStatus(localExtension);
911   
912  1 checkJarExtensionUnavailability(TestComponent.TYPE_STRING, namespace1);
913  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace1);
914  1 checkJarExtensionUnavailability(TestComponent.TYPE_STRING, namespace2);
915  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace2);
916    }
917   
 
918  1 toggle @Test
919    public void testMultipleInstallOnANamespaceWithGlobalDependencyAndUninstall() throws Throwable
920    {
921  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
922  1 final ExtensionId dependencyId = new ExtensionId("org.xwiki.test:test-extension", "test");
923  1 final String namespace1 = "namespace1";
924  1 final String namespace2 = "namespace2";
925   
926    // install global deps
927  1 InstalledExtension installedExtension = install(dependencyId);
928   
929  1 checkInstallStatus(installedExtension);
930   
931  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature", null));
932  1 Type extensionDep1 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
933   
934    // actual install test
935  1 installedExtension = install(extensionId, namespace1);
936   
937  1 checkInstallStatus(installedExtension, namespace1);
938  1 checkInstallStatus(this.installedExtensionRepository.resolve(dependencyId));
939   
940  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace1));
941  1 Type extensionRole1 =
942    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace1);
943  1 Type extensionDep2 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
944  1 Assert.assertEquals(extensionDep1, extensionDep2);
945   
946    // actual install test
947  1 installedExtension = install(extensionId, namespace2);
948   
949  1 checkInstallStatus(installedExtension, namespace2);
950  1 checkInstallStatus(this.installedExtensionRepository.resolve(dependencyId));
951   
952  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace2));
953  1 Type extensionRole2 =
954    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace2);
955  1 Type extensionDep3 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
956  1 assertNotEquals(extensionRole1, extensionRole2);
957  1 Assert.assertEquals(extensionDep1, extensionDep3);
958   
959    // actual uninstall test
960  1 LocalExtension localExtension = uninstall(extensionId, namespace1);
961   
962  1 ckeckUninstallStatus(localExtension);
963  1 checkInstallStatus(this.installedExtensionRepository.resolve(dependencyId));
964   
965  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace1);
966   
967  1 Type extensionRole3 =
968    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace2);
969  1 Type extensionDep4 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
970  1 Assert.assertEquals(extensionRole2, extensionRole3);
971  1 Assert.assertEquals(extensionDep1, extensionDep4);
972   
973    // actual uninstall test
974  1 localExtension = uninstall(extensionId, namespace2);
975   
976  1 ckeckUninstallStatus(localExtension);
977  1 checkInstallStatus(this.installedExtensionRepository.resolve(dependencyId));
978   
979  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace2);
980  1 Type extensionDep5 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
981  1 Assert.assertEquals(extensionDep1, extensionDep5);
982    }
983   
 
984  1 toggle @Test
985    public void testMultipleInstallOnANamespaceWithGlobalDependencyAndUninstallDependency() throws Throwable
986    {
987  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension-with-deps", "test");
988  1 final ExtensionId dependencyId = new ExtensionId("org.xwiki.test:test-extension", "test");
989  1 final String namespace1 = "namespace1";
990  1 final String namespace2 = "namespace2";
991   
992    // install global deps
993  1 InstalledExtension installedExtension = install(dependencyId);
994   
995  1 checkInstallStatus(installedExtension);
996   
997  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature", null));
998  1 Type extensionDep1 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
999   
1000  1 installedExtension = install(extensionId, namespace1);
1001   
1002  1 checkInstallStatus(installedExtension, namespace1);
1003   
1004  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace1));
1005  1 Type extensionRole1 =
1006    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace1);
1007  1 Type extensionDep2 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
1008  1 Assert.assertEquals(extensionDep1, extensionDep2);
1009   
1010  1 installedExtension = install(extensionId, namespace2);
1011   
1012  1 checkInstallStatus(installedExtension, namespace2);
1013   
1014  1 Assert.assertNotNull(this.installedExtensionRepository.getInstalledExtension("feature-with-deps", namespace2));
1015  1 Type extensionRole2 =
1016    checkJarExtensionAvailability(TestComponentWithDeps.class, DefaultTestComponentWithDeps.class, namespace2);
1017  1 Type extensionDep3 = checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
1018  1 assertNotEquals(extensionRole1, extensionRole2);
1019  1 Assert.assertEquals(extensionDep1, extensionDep3);
1020   
1021    // actual uninstall test
1022  1 LocalExtension localExtension = uninstall(dependencyId, null);
1023   
1024  1 ckeckUninstallStatus(localExtension);
1025  1 ckeckUninstallStatus(this.localExtensionRepository.resolve(extensionId), namespace1);
1026  1 ckeckUninstallStatus(this.localExtensionRepository.resolve(extensionId), namespace2);
1027   
1028  1 checkJarExtensionUnavailability(TestComponent.TYPE_STRING);
1029  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace1);
1030  1 checkJarExtensionUnavailability(TestComponentWithDeps.class, namespace2);
1031    }
1032   
 
1033  1 toggle @Test
1034    public void testUninstallInvalidExtensionFromNamespace() throws Throwable
1035    {
1036  1 ExtensionId extensionId = new ExtensionId("invalidextensiononnamespace", "version");
1037   
1038  1 uninstall(extensionId, "namespaceofinvalidextension");
1039    }
1040   
 
1041  1 toggle @Test
1042    public void testUninstallInvalidExtensionFromRoot() throws Throwable
1043    {
1044  1 ExtensionId extensionId = new ExtensionId("invalidextensiononroot", "version");
1045   
1046  1 uninstall(extensionId, null);
1047    }
1048   
 
1049  1 toggle @Test
1050    public void testExtensionInstalledOnNamespaceAtInit() throws Throwable
1051    {
1052  1 ExtensionId extensionId = new ExtensionId("installedextensiononnamespace", "1.0");
1053   
1054  1 InstalledExtension installedExtension = this.installedExtensionRepository.resolve(extensionId);
1055   
1056  1 checkInstallStatus(installedExtension, NAMESPACE);
1057   
1058  1 checkJarExtensionAvailability(packagefile.installedextensiononnamespace.TestInstalledComponent.TYPE_STRING,
1059    packagefile.installedextensiononnamespace.DefaultTestInstalledComponent.class, NAMESPACE);
1060   
1061  1 uninstall(extensionId, NAMESPACE);
1062    }
1063   
 
1064  1 toggle @Test
1065    public void testExtensionInstalledOnRootAtInit() throws Throwable
1066    {
1067  1 ExtensionId extensionId = new ExtensionId("installedextensiononroot", "1.0");
1068   
1069  1 InstalledExtension installedExtension = this.installedExtensionRepository.resolve(extensionId);
1070   
1071  1 checkInstallStatus(installedExtension, null);
1072   
1073  1 checkJarExtensionAvailability(packagefile.installedextensiononroot.TestInstalledComponent.TYPE_STRING,
1074    packagefile.installedextensiononroot.DefaultTestInstalledComponent.class, null);
1075   
1076  1 uninstall(extensionId, null);
1077    }
1078   
 
1079  1 toggle @Test
1080    public void testInstallOnNamespaceThenOnRoot() throws Throwable
1081    {
1082  1 final ExtensionId extensionId = new ExtensionId("org.xwiki.test:test-extension", "test");
1083   
1084    // install on namespace
1085  1 InstalledExtension installedExtension = install(extensionId, NAMESPACE);
1086   
1087  1 checkInstallStatus(installedExtension, NAMESPACE);
1088   
1089  1 Assert.assertSame(installedExtension,
1090    this.installedExtensionRepository.getInstalledExtension(extensionId.getId(), NAMESPACE));
1091  1 Assert.assertNull(this.installedExtensionRepository.getInstalledExtension(extensionId.getId(), null));
1092   
1093  1 checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class, NAMESPACE);
1094   
1095    // install on root
1096  1 installedExtension = install(extensionId);
1097   
1098  1 checkInstallStatus(installedExtension);
1099   
1100  1 checkJarExtensionAvailability(TestComponent.TYPE_STRING, DefaultTestComponent.class);
1101    }
1102   
 
1103  1 toggle @Test
1104    public void testInstallOnNamespaceThenUpgradeOnRoot() throws Throwable
1105    {
1106  1 final ExtensionId extensionId1 = new ExtensionId("jarupgrade", "1.0");
1107  1 final ExtensionId extensionId2 = new ExtensionId("jarupgrade", "2.0");
1108   
1109    // install on namespace
1110  1 InstalledExtension installedExtension1 = install(extensionId1, NAMESPACE);
1111   
1112  1 checkInstallStatus(installedExtension1, NAMESPACE);
1113   
1114  1 Assert.assertSame(installedExtension1,
1115    this.installedExtensionRepository.getInstalledExtension(extensionId1.getId(), NAMESPACE));
1116  1 Assert.assertNull(this.installedExtensionRepository.getInstalledExtension(extensionId1.getId(), null));
1117   
1118  1 checkJarExtensionAvailability(packagefile.jarupgrade1.TestComponent.class,
1119    packagefile.jarupgrade1.DefaultTestComponent.class, NAMESPACE);
1120   
1121    // install on root
1122  1 InstalledExtension installedExtension2 = install(extensionId2);
1123   
1124  1 LocalExtension localExtension = this.localExtensionRepository.getLocalExtension(extensionId1);
1125   
1126  1 ckeckUninstallStatus(localExtension, NAMESPACE);
1127  1 checkInstallStatus(installedExtension2);
1128   
1129  1 checkJarExtensionUnavailability(packagefile.jarupgrade1.TestComponent.class, NAMESPACE);
1130  1 checkJarExtensionAvailability(packagefile.jarupgrade2.TestComponent.class,
1131    packagefile.jarupgrade2.DefaultTestComponent.class);
1132    }
1133    }