test/groovy/org/codehaus/groovy/grails/commons/GrailsPluginManagerTests.groovy

   1 package org.codehaus.groovy.grails.commons;
   2
   3 import java.io.IOException;
   4
   5 import org.codehaus.groovy.grails.plugins.*
   6 import org.codehaus.groovy.grails.commons.test.AbstractGrailsMockTests;
   7 import org.codehaus.groovy.grails.plugins.exceptions.PluginException
   8 import org.springframework.beans.factory.support.RootBeanDefinition;
   9 import org.springframework.context.support.GenericApplicationContext;
  10 import org.springframework.web.servlet.i18n.CookieLocaleResolver
  11 import org.springframework.core.io.Resource;
  12
  13
  14 public class GrailsPluginManagerTests extends AbstractGrailsMockTests {
  15
  16         private static final String RESOURCE_PATH = "classpath:org/codehaus/groovy/grails/plugins/ClassEditorGrailsPlugin.groovy";
  17
  18     protected void onSetUp() {
  19         super.onSetUp();
  20
  21         gcl.parseClass('''
  22 dataSource {
  23         pooled = false
  24         driverClassName = "org.hsqldb.jdbcDriver"
  25         username = "sa"
  26         password = ""
  27     dbCreate = "create-drop" // one of 'create', 'create-drop','update'
  28     url = "jdbc:hsqldb:mem:devDB"
  29
  30 }
  31 hibernate {
  32     cache.use_second_level_cache=true
  33     cache.use_query_cache=true
  34     cache.provider_class='org.hibernate.cache.OSCacheProvider'
  35 }
  36         ''')
  37     }
  38
  39
  40
  41     public void testObservablePlugin() {
  42          def manager = new DefaultGrailsPluginManager([MyGrailsPlugin,AnotherGrailsPlugin, ObservingGrailsPlugin] as Class[], ga)
  43
  44          manager.loadPlugins()
  45
  46          assertTrue manager.hasGrailsPlugin("another")
  47
  48          // Get the "another" plugin and all the plugins that are
  49          // observing it.
  50          def plugin = manager.getGrailsPlugin("another")
  51          def observers = manager.getPluginObservers(plugin)
  52
  53          // Check that the observers are what we expect (note that the
  54          // core plugin "logging" should be one of them).
  55          def expectedObservers = ["logging", "observing"]
  56          assertTrue observers*.name.containsAll(expectedObservers)
  57          assertEquals expectedObservers.size(), observers.size()
  58
  59          // Also check that the "logging" plugin is observing the "my"
  60          // plugin (which is not observed by any other plugins).
  61          observers = manager.getPluginObservers(manager.getGrailsPlugin("my"))
  62          expectedObservers = ["logging"]
  63
  64          assertTrue observers*.name.containsAll(expectedObservers)
  65          assertEquals expectedObservers.size(), observers.size()
  66
  67          // Make sure the observers are being notified of changes to
  68          // the observed plugin.
  69          def event = [source:"foo"]
  70          manager.informObservers("another", event)
  71
  72          assertEquals "bar", event.source
  73     }
  74
  75     public void testNoSelfObserving() {
  76         def manager = new DefaultGrailsPluginManager([AnotherGrailsPlugin,ObservingAllGrailsPlugin] as Class[], ga)
  77
  78         manager.loadPlugins()
  79
  80         // Get the "another" plugin and all the plugins that are
  81         // observing it.
  82         def plugin = manager.getGrailsPlugin("another")
  83         def observers = manager.getPluginObservers(plugin)
  84
  85         // Check that the observers are what we expect (note that the
  86         // core plugin "logging" should be one of them).
  87         def expectedObservers = ["logging", "observingAll"]
  88         assertTrue observers*.name.containsAll(expectedObservers)
  89         assertEquals expectedObservers.size(), observers.size()
  90
  91         // Now check that the "observingAll" plugin is *not* observing
  92         // itself.
  93         observers = manager.getPluginObservers(manager.getGrailsPlugin("observingAll"))
  94         expectedObservers = ["logging"]
  95
  96         assertTrue observers*.name.containsAll(expectedObservers)
  97         assertEquals expectedObservers.size(), observers.size()
  98     }
  99
 100         public void testDisabledPlugin() {
 101                 def manager = new DefaultGrailsPluginManager([MyGrailsPlugin,AnotherGrailsPlugin,DisabledGrailsPlugin] as Class[], ga)
 102
 103                 manager.loadPlugins()
 104
 105             assertTrue manager.hasGrailsPlugin("my")
 106             assertNotNull manager.getGrailsPlugin("my").instance
 107             assertFalse manager.hasGrailsPlugin("disabled")
 108     }
 109
 110         public void testDefaultGrailsPluginManager() throws Exception {
 111                 DefaultGrailsPluginManager manager = new DefaultGrailsPluginManager(RESOURCE_PATH,ga);
 112                 assertEquals(1, manager.getPluginResources().length);
 113         }
 114
 115         public void testLoadPlugins() throws Exception {
 116         println "LOAD PLUGINS"
 117         GrailsPluginManager manager = new DefaultGrailsPluginManager(RESOURCE_PATH,ga);
 118                 manager.loadPlugins();
 119
 120
 121                 GrailsPlugin plugin = manager.getGrailsPlugin("classEditor");
 122                 assertNotNull(plugin);
 123                 assertEquals("classEditor",plugin.getName());
 124                 assertEquals("1.1", plugin.getVersion());
 125
 126                 plugin = manager.getGrailsPlugin("classEditor", "1.1");
 127                 assertNotNull(plugin);
 128
 129                 plugin = manager.getGrailsPlugin("classEditor", "1.2");
 130                 assertNull(plugin);
 131         }
 132
 133         public void testWithLoadLastPlugin() throws Exception {
 134                 def manager = new DefaultGrailsPluginManager([MyGrailsPlugin,AnotherGrailsPlugin,ShouldLoadLastGrailsPlugin] as Class[], ga)
 135
 136                 manager.loadPlugins()
 137
 138         }
 139
 140         public void testDependencyResolutionFailure() throws Exception {
 141                 def manager = new DefaultGrailsPluginManager([MyGrailsPlugin] as Class[], ga)
 142
 143                 try {
 144                         manager.loadPlugins()
 145                         assert !manager.hasGrailsPlugin("my")
 146                 }
 147                 catch(PluginException pe) {
 148                         // expected
 149                 }
 150         }
 151
 152         public void testDependencyResolutionSucces() throws Exception {
 153                 def manager = new DefaultGrailsPluginManager([MyGrailsPlugin,AnotherGrailsPlugin, SomeOtherGrailsPlugin] as Class[], ga)
 154
 155                 manager.loadPlugins()
 156         }
 157
 158         public void testDoRuntimeConfiguration() {
 159                 def manager = new DefaultGrailsPluginManager([MyGrailsPlugin,AnotherGrailsPlugin] as Class[], ga)
 160
 161                 manager.loadPlugins()
 162
 163                 def parent = createMockApplicationContext()
 164                 parent.registerMockBean("grailsApplication", ga)
 165         parent.registerMockBean(PluginMetaManager.BEAN_ID, new DefaultPluginMetaManager(new Resource[0]));
 166
 167                 def springConfig = new org.codehaus.groovy.grails.commons.spring.WebRuntimeSpringConfiguration(parent)
 168                 springConfig.servletContext = createMockServletContext()
 169                 manager.doRuntimeConfiguration(springConfig)
 170
 171                 def ctx = springConfig.getApplicationContext()
 172
 173                 assert ctx.containsBean("classEditor")
 174         }
 175
 176         public void testDoPostProcessing() {
 177                 def manager = new DefaultGrailsPluginManager([MyGrailsPlugin,AnotherGrailsPlugin] as Class[], ga)
 178
 179                 manager.loadPlugins()
 180
 181                 def parent = createMockApplicationContext()
 182                 parent.registerMockBean("grailsApplication", ga)
 183                 parent.registerMockBean(PluginMetaManager.BEAN_ID, new DefaultPluginMetaManager(new Resource[0]));
 184                 def springConfig = new org.codehaus.groovy.grails.commons.spring.WebRuntimeSpringConfiguration(parent)
 185                 springConfig.servletContext = createMockServletContext()
 186
 187                 manager.doRuntimeConfiguration(springConfig)
 188
 189                 def ctx = springConfig.getApplicationContext()
 190
 191                 assert ctx.containsBean("classEditor")
 192
 193                 manager.doPostProcessing(ctx)
 194
 195                 assert ctx.containsBean("localeResolver")
 196         }
 197
 198
 199         public void testEviction() {
 200                 def manager = new DefaultGrailsPluginManager([MyGrailsPlugin,AnotherGrailsPlugin,SomeOtherGrailsPlugin,ShouldEvictSomeOtherGrailsPlugin] as Class[], ga)
 201
 202                 manager.loadPlugins()
 203
 204                 assertFalse manager.hasGrailsPlugin("someOther")
 205                 assertTrue manager.hasGrailsPlugin("my")
 206                 assertTrue manager.hasGrailsPlugin("another")
 207                 assertTrue manager.hasGrailsPlugin("shouldEvictSomeOther")
 208         }
 209
 210     void testShutdownCalled() {
 211         def manager = new DefaultGrailsPluginManager([MyGrailsPlugin,AnotherGrailsPlugin] as Class[], ga)
 212
 213         manager.loadPlugins()
 214
 215         assertEquals "nullme",MyGrailsPlugin.SHUTDOWN_FIELD
 216         manager.shutdown()
 217         assertNull MyGrailsPlugin.SHUTDOWN_FIELD
 218     }
 219
 220 }
 221 class MyGrailsPlugin {
 222     static SHUTDOWN_FIELD = "nullme"
 223     def dependsOn = [another:1.2]
 224         def version = 1.1
 225         def doWithSpring = {
 226                 classEditor(org.springframework.beans.propertyeditors.ClassEditor,application.classLoader )
 227         }
 228     def onShutdown = {
 229          SHUTDOWN_FIELD = null
 230     }
 231 }
 232 class AnotherGrailsPlugin {
 233         def version = 1.2
 234     def watchedResources = ['classpath:org/codehaus/groovy/grails/plugins/*.xml']
 235         def doWithApplicationContext = { ctx ->
 236         RootBeanDefinition bd = new RootBeanDefinition(CookieLocaleResolver.class);
 237         ctx.registerBeanDefinition("localeResolver", bd);
 238         }
 239 }
 240 class SomeOtherGrailsPlugin {
 241         def version = 1.4
 242         def dependsOn = [my:1.1, another:1.2]
 243 }
 244 class ShouldLoadLastGrailsPlugin {
 245         def loadAfter = ["my", "someOther"]
 246         def version = 1.5
 247 }
 248 class ShouldEvictSomeOtherGrailsPlugin {
 249         def evict = ['someOther']
 250         def version = 1.1
 251 }
 252 class DisabledGrailsPlugin {
 253     def version = 1.0
 254     def status = "disabled"
 255 }
 256 class ObservingGrailsPlugin {
 257     def version = "1.0-RC1"
 258     def observe = ['another']
 259
 260     def onChange = { event ->
 261         assert event.source != null
 262         event.source = "bar"
 263     }
 264 }
 265 class ObservingAllGrailsPlugin {
 266     def version = "1.0"
 267     def observe = ['*']
 268 }