KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > nanocontainer > script > groovy > OldGroovyNodeBuilderTestCase


1 package org.nanocontainer.script.groovy;
2
3 import java.io.Reader JavaDoc;
4 import java.io.StringReader JavaDoc;
5 import java.io.StringWriter JavaDoc;
6
7 import org.jmock.Mock;
8 import org.nanocontainer.NanoPicoContainer;
9 import org.nanocontainer.integrationkit.PicoCompositionException;
10 import org.nanocontainer.reflection.DefaultNanoPicoContainer;
11 import org.nanocontainer.script.AbstractScriptedContainerBuilderTestCase;
12 import org.nanocontainer.script.NanoContainerMarkupException;
13 import org.nanocontainer.testmodel.A;
14 import org.nanocontainer.testmodel.B;
15 import org.nanocontainer.testmodel.HasParams;
16 import org.nanocontainer.testmodel.ParentAssemblyScope;
17 import org.nanocontainer.testmodel.SomeAssemblyScope;
18 import org.nanocontainer.testmodel.WebServerConfig;
19 import org.nanocontainer.testmodel.X;
20 import org.picocontainer.ComponentAdapter;
21 import org.picocontainer.MutablePicoContainer;
22 import org.picocontainer.PicoContainer;
23 import org.picocontainer.defaults.ComponentAdapterFactory;
24 import org.picocontainer.defaults.InstanceComponentAdapter;
25 import org.picocontainer.defaults.SetterInjectionComponentAdapter;
26 import org.picocontainer.defaults.SetterInjectionComponentAdapterFactory;
27 import org.picocontainer.defaults.UnsatisfiableDependenciesException;
28
29 /**
30  * @author Paul Hammant
31  * @author Mauro Talevi
32  * @version $Revision: 1775 $
33  */

34 public class OldGroovyNodeBuilderTestCase extends AbstractScriptedContainerBuilderTestCase {
35     private static final String JavaDoc ASSEMBLY_SCOPE = "SOME_SCOPE";
36
37     public void testInstantiateBasicScriptable() throws PicoCompositionException {
38         Reader JavaDoc script = new StringReader JavaDoc("" +
39                 "import org.nanocontainer.testmodel.*\n" +
40                 "X.reset()\n" +
41                 "builder = new org.nanocontainer.script.groovy.OldGroovyNodeBuilder()\n" +
42                 "nano = builder.container {\n" +
43                 " component(A)\n" +
44                 "}");
45
46         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
47         // LifecyleContainerBuilder starts the container
48
pico.dispose();
49
50         assertEquals("Should match the expression", "<A!A", X.componentRecorder);
51     }
52
53     public void testComponentInstances() throws PicoCompositionException {
54         Reader JavaDoc script = new StringReader JavaDoc("" +
55                 "import org.nanocontainer.testmodel.*\n" +
56                 "builder = new org.nanocontainer.script.groovy.OldGroovyNodeBuilder()\n" +
57                 "nano = builder.container {\n" +
58                 " component(key:'a', instance:'apple')\n" +
59                 " component(key:'b', instance:'banana')\n" +
60                 " component(instance:'noKeySpecified')\n" +
61                 "}");
62
63         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
64         assertEquals("apple", pico.getComponentInstance("a"));
65         assertEquals("banana", pico.getComponentInstance("b"));
66         assertEquals("noKeySpecified", pico.getComponentInstance(String JavaDoc.class));
67     }
68
69     public void testShouldFailWhenNeitherClassNorInstanceIsSpecifiedForComponent() {
70         Reader JavaDoc script = new StringReader JavaDoc("" +
71                 "builder = new org.nanocontainer.script.groovy.OldGroovyNodeBuilder()\n" +
72                 "nano = builder.container {\n" +
73                 " component(key:'a')\n" +
74                 "}");
75
76         try {
77             buildContainer(script, null, ASSEMBLY_SCOPE);
78             fail("NanoContainerMarkupException should have been raised");
79         } catch (NanoContainerMarkupException e) {
80             // expected
81
}
82     }
83
84     public void testShouldAcceptConstantParametersForComponent() throws PicoCompositionException {
85         Reader JavaDoc script = new StringReader JavaDoc("" +
86                 "import org.picocontainer.defaults.ConstantParameter\n" +
87                 "import org.nanocontainer.testmodel.*\n" +
88                 "" +
89                 "builder = new org.nanocontainer.script.groovy.OldGroovyNodeBuilder()\n" +
90                 "nano = builder.container {\n" +
91                 " component(key:'byClass', class:HasParams, parameters:[ 'a', 'b', new ConstantParameter('c') ])\n" +
92                 " component(key:'byClassString', class:'org.nanocontainer.testmodel.HasParams', parameters:[ 'c', 'a', 't' ])\n" +
93                 "}");
94
95         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
96         HasParams byClass = (HasParams) pico.getComponentInstance("byClass");
97         assertEquals("abc", byClass.getParams());
98
99         HasParams byClassString = (HasParams) pico.getComponentInstance("byClassString");
100         assertEquals("cat", byClassString.getParams());
101     }
102
103     public void testShouldAcceptComponentParametersForComponent() throws PicoCompositionException {
104         Reader JavaDoc script = new StringReader JavaDoc("" +
105                 "import org.picocontainer.defaults.ComponentParameter\n" +
106                 "import org.nanocontainer.testmodel.*\n" +
107                 "" +
108                 "builder = new org.nanocontainer.script.groovy.OldGroovyNodeBuilder()\n" +
109                 "nano = builder.container {\n" +
110                 " component(key:'a1', class:A)\n" +
111                 " component(key:'a2', class:A)\n" +
112                 " component(key:'b1', class:B, parameters:[ new ComponentParameter('a1') ])\n" +
113                 " component(key:'b2', class:B, parameters:[ new ComponentParameter('a2') ])\n" +
114                 "}");
115
116         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
117         A a1 = (A) pico.getComponentInstance("a1");
118         A a2 = (A) pico.getComponentInstance("a2");
119         B b1 = (B) pico.getComponentInstance("b1");
120         B b2 = (B) pico.getComponentInstance("b2");
121
122         assertNotNull(a1);
123         assertNotNull(a2);
124         assertNotNull(b1);
125         assertNotNull(b2);
126
127         assertSame(a1, b1.a);
128         assertSame(a2, b2.a);
129         assertNotSame(a1, a2);
130         assertNotSame(b1, b2);
131     }
132
133     public void testShouldAcceptComponentParameterWithClassNameKey() throws PicoCompositionException {
134         Reader JavaDoc script = new StringReader JavaDoc("" +
135                 "import org.picocontainer.defaults.ComponentParameter\n" +
136                 "import org.nanocontainer.testmodel.*\n" +
137                 "" +
138                 "builder = new org.nanocontainer.script.groovy.OldGroovyNodeBuilder()\n" +
139                 "nano = builder.container {\n" +
140                 " component(class:A)\n" +
141                 " component(key:B, class:B, parameters:[ new ComponentParameter(A) ])\n" +
142                 "}");
143
144         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
145         A a = (A) pico.getComponentInstance(A.class);
146         B b = (B) pico.getComponentInstance(B.class);
147
148         assertNotNull(a);
149         assertNotNull(b);
150         assertSame(a, b.a);
151     }
152
153     public void testComponentParametersScript() {
154         Reader JavaDoc script = new StringReader JavaDoc("" +
155                 "package org.nanocontainer.script.groovy\n" +
156                 "import org.picocontainer.defaults.ComponentParameter\n" +
157                 "import org.nanocontainer.testmodel.*\n" +
158                 "builder = new OldGroovyNodeBuilder()\n" +
159                 "nano = builder.container {\n" +
160                 " component(key:'a', class:A)\n" +
161                 " component(key:'b', class:B, parameters:[ new ComponentParameter('a') ])\n" +
162                 "}");
163
164         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
165         A a = (A) pico.getComponentInstance("a");
166         B b = (B) pico.getComponentInstance("b");
167         assertSame(a, b.a);
168     }
169
170     public void testShouldBeAbleToHandOffToNestedBuilder() {
171         Reader JavaDoc script = new StringReader JavaDoc("" +
172                 "package org.nanocontainer.script.groovy\n" +
173                 "import org.nanocontainer.testmodel.*\n" +
174                 "builder = new OldGroovyNodeBuilder()\n" +
175                 "nano = builder.container {\n" +
176                 " component(key:'a', class:A)\n" +
177                 " newBuilder(class:'org.nanocontainer.script.groovy.TestingChildBuilder') {\n" +
178                 " component(key:'b', class:B)\n" +
179                 " }\n" +
180                 "}");
181
182         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
183         Object JavaDoc a = pico.getComponentInstance("a");
184         Object JavaDoc b = pico.getComponentInstance("b");
185
186         assertNotNull(a);
187         assertNotNull(b);
188     }
189
190     public void testInstantiateBasicComponentInDeeperTree() {
191         X.reset();
192         Reader JavaDoc script = new StringReader JavaDoc("" +
193                 "package org.nanocontainer.script.groovy\n" +
194                 "import org.nanocontainer.testmodel.*\n" +
195                 "builder = new OldGroovyNodeBuilder()\n" +
196                 "nano = builder.container {\n" +
197                 " container() {\n" +
198                 " component(A)\n" +
199                 " }\n" +
200                 "}");
201
202         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
203         pico.dispose();
204         assertEquals("Should match the expression", "<A!A", X.componentRecorder);
205     }
206
207     public void testCustomComponentAdapterFactoryCanBeSpecified() {
208         Reader JavaDoc script = new StringReader JavaDoc("" +
209                 "package org.nanocontainer.script.groovy\n" +
210                 "import org.nanocontainer.testmodel.*\n" +
211                 "builder = new OldGroovyNodeBuilder()\n" +
212                 "nano = builder.container(componentAdapterFactory:assemblyScope) {\n" +
213                 " component(A)\n" +
214                 "}");
215
216         A a = new A();
217         Mock cafMock = mock(ComponentAdapterFactory.class);
218         cafMock.expects(once()).method("createComponentAdapter").with(same(A.class), same(A.class), eq(null)).will(returnValue(new InstanceComponentAdapter(A.class, a)));
219         ComponentAdapterFactory componentAdapterFactory = (ComponentAdapterFactory) cafMock.proxy();
220         PicoContainer pico = buildContainer(script, null, componentAdapterFactory);
221         assertSame(a, pico.getComponentInstanceOfType(A.class));
222     }
223
224     public void testCustomComponentMonitorCanBeSpecified() {
225         Reader JavaDoc script = new StringReader JavaDoc("" +
226                 "package org.nanocontainer.script.groovy\n" +
227                 "import java.io.StringWriter\n" +
228                 "import org.picocontainer.monitors.WriterComponentMonitor\n" +
229                 "import org.nanocontainer.testmodel.*\n" +
230                 "builder = new OldGroovyNodeBuilder()\n" +
231                 "writer = new StringWriter()\n" +
232                 "monitor = new WriterComponentMonitor(writer) \n"+
233                 "nano = builder.container(componentMonitor: monitor) {\n" +
234                 " component(A)\n" +
235                 " component(key:StringWriter, instance:writer)\n" +
236                 "}");
237
238         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
239         pico.getComponentInstanceOfType(WebServerConfig.class);
240         StringWriter JavaDoc writer = (StringWriter JavaDoc)pico.getComponentInstanceOfType(StringWriter JavaDoc.class);
241         assertTrue(writer.toString().length() > 0);
242     }
243
244     public void testCustomComponentMonitorCanBeSpecifiedWhenCAFIsSpecified() {
245         Reader JavaDoc script = new StringReader JavaDoc("" +
246                 "package org.nanocontainer.script.groovy\n" +
247                 "import java.io.StringWriter\n" +
248                 "import org.picocontainer.defaults.DefaultComponentAdapterFactory\n" +
249                 "import org.picocontainer.monitors.WriterComponentMonitor\n" +
250                 "import org.nanocontainer.testmodel.*\n" +
251                 "builder = new OldGroovyNodeBuilder()\n" +
252                 "writer = new StringWriter()\n" +
253                 "monitor = new WriterComponentMonitor(writer) \n"+
254                 "nano = builder.container(componentAdapterFactory: new DefaultComponentAdapterFactory(), componentMonitor: monitor) {\n" +
255                 " component(A)\n" +
256                 " component(key:StringWriter, instance:writer)\n" +
257                 "}");
258
259         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
260         pico.getComponentInstanceOfType(WebServerConfig.class);
261         StringWriter JavaDoc writer = (StringWriter JavaDoc)pico.getComponentInstanceOfType(StringWriter JavaDoc.class);
262         assertTrue(writer.toString().length() > 0);
263     }
264
265     public void testCustomComponentMonitorCanBeSpecifiedWhenParentIsSpecified() {
266         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer();
267         Reader JavaDoc script = new StringReader JavaDoc("" +
268                 "package org.nanocontainer.script.groovy\n" +
269                 "import java.io.StringWriter\n" +
270                 "import org.picocontainer.monitors.WriterComponentMonitor\n" +
271                 "import org.nanocontainer.testmodel.*\n" +
272                 "builder = new OldGroovyNodeBuilder()\n" +
273                 "writer = new StringWriter()\n" +
274                 "monitor = new WriterComponentMonitor(writer) \n"+
275                 "nano = builder.container(parent:parent, componentMonitor: monitor) {\n" +
276                 " component(A)\n" +
277                 " component(key:StringWriter, instance:writer)\n" +
278                 "}");
279
280         PicoContainer pico = buildContainer(script, parent, ASSEMBLY_SCOPE);
281         pico.getComponentInstanceOfType(WebServerConfig.class);
282         StringWriter JavaDoc writer = (StringWriter JavaDoc)pico.getComponentInstanceOfType(StringWriter JavaDoc.class);
283         assertTrue(writer.toString().length() > 0);
284     }
285
286     public void testCustomComponentMonitorCanBeSpecifiedWhenParentAndCAFAreSpecified() {
287         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer();
288         Reader JavaDoc script = new StringReader JavaDoc("" +
289                 "package org.nanocontainer.script.groovy\n" +
290                 "import java.io.StringWriter\n" +
291                 "import org.picocontainer.defaults.DefaultComponentAdapterFactory\n" +
292                 "import org.picocontainer.monitors.WriterComponentMonitor\n" +
293                 "import org.nanocontainer.testmodel.*\n" +
294                 "builder = new OldGroovyNodeBuilder()\n" +
295                 "writer = new StringWriter()\n" +
296                 "monitor = new WriterComponentMonitor(writer) \n"+
297                 "nano = builder.container(parent:parent, componentAdapterFactory: new DefaultComponentAdapterFactory(), componentMonitor: monitor) {\n" +
298                 " component(A)\n" +
299                 " component(key:StringWriter, instance:writer)\n" +
300                 "}");
301
302         PicoContainer pico = buildContainer(script, parent, ASSEMBLY_SCOPE);
303         pico.getComponentInstanceOfType(WebServerConfig.class);
304         StringWriter JavaDoc writer = (StringWriter JavaDoc)pico.getComponentInstanceOfType(StringWriter JavaDoc.class);
305         assertTrue(writer.toString().length() > 0);
306     }
307
308     public void testInstantiateWithImpossibleComponentDependenciesConsideringTheHierarchy() {
309         X.reset();
310         Reader JavaDoc script = new StringReader JavaDoc("" +
311                 "package org.nanocontainer.script.groovy\n" +
312                 "import org.nanocontainer.testmodel.*\n" +
313                 "builder = new OldGroovyNodeBuilder()\n" +
314                 "nano = builder.container {\n" +
315                 " component(B)\n" +
316                 " container() {\n" +
317                 " component(A)\n" +
318                 " }\n" +
319                 " component(C)\n" +
320                 "}");
321
322         try {
323             buildContainer(script, null, ASSEMBLY_SCOPE);
324             fail("Should not have been able to instansiate component tree due to visibility/parent reasons.");
325         } catch (UnsatisfiableDependenciesException expected) {
326         }
327     }
328
329     public void testInstantiateWithChildContainerAndStartStopAndDisposeOrderIsCorrect() {
330         X.reset();
331         Reader JavaDoc script = new StringReader JavaDoc("" +
332                 "package org.nanocontainer.script.groovy\n" +
333                 "import org.nanocontainer.testmodel.*\n" +
334                 "builder = new OldGroovyNodeBuilder()\n" +
335                 "nano = builder.container {\n" +
336                 " component(A)\n" +
337                 " container() {\n" +
338                 " component(B)\n" +
339                 " }\n" +
340                 " component(C)\n" +
341                 "}\n");
342
343         // A and C have no no dependancies. B Depends on A.
344
PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
345         //pico.start();
346
pico.stop();
347         pico.dispose();
348
349         assertEquals("Should match the expression", "<A<C<BB>C>A>!B!C!A", X.componentRecorder);
350     }
351
352     public void testBuildContainerWithParentAttribute() {
353         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer();
354         parent.registerComponentInstance("hello", "world");
355
356         Reader JavaDoc script = new StringReader JavaDoc("" +
357                 "package org.nanocontainer.script.groovy\n" +
358                 "import org.nanocontainer.testmodel.*\n" +
359                 "nano = builder.container(parent:parent) {\n" +
360                 " component(A)\n" +
361                 "}\n");
362
363         PicoContainer pico = buildContainer(script, parent, ASSEMBLY_SCOPE);
364         // Should be able to get instance that was registered in the parent container
365
assertEquals("world", pico.getComponentInstance("hello"));
366     }
367
368
369     public void testBuildContainerWithParentDependencyAndAssemblyScope() {
370         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer();
371         parent.registerComponentImplementation("a", A.class);
372
373         Reader JavaDoc script = new StringReader JavaDoc("" +
374                 "package org.nanocontainer.script.groovy\n" +
375                 "import org.nanocontainer.testmodel.*\n" +
376                 "nano = builder.container(parent:parent, scope:assemblyScope) {\n" +
377                 " if ( assemblyScope instanceof SomeAssemblyScope ){\n "+
378                 " component(B)\n" +
379                 " }\n "+
380                 "}\n");
381
382         PicoContainer pico = buildContainer(script, parent, new SomeAssemblyScope());
383         assertNotNull(pico.getComponentInstanceOfType(B.class));
384     }
385
386     // NANO-156
387
//FIXME: attempting to build the parent container from the script
388
// at the same time as the child yields compilation error!
389
//This does not occur if parent and child are build separately!
390
// Not true, if different Readers can be used.
391
public void testBuildContainerWithParentAndChildAssemblyScopes() {
392         String JavaDoc script = "" +
393                         "package org.nanocontainer.script.groovy\n" +
394                         "import org.nanocontainer.testmodel.*\n" +
395                         "nano = builder.container(parent:parent, scope:assemblyScope) {\n" +
396                         " System.out.println('assemblyScope:'+assemblyScope)\n " +
397                         " if ( assemblyScope instanceof ParentAssemblyScope ) {\n "+
398                         " System.out.println('parent scope')\n " +
399                         " component(A)\n" +
400                         " } else if ( assemblyScope instanceof SomeAssemblyScope ) {\n "+
401                         " System.out.println('child scope')\n " +
402                         " component(B)\n" +
403                         " } else { \n" +
404                         " System.out.println('Invalid scope')\n " +
405                         " } \n "+
406                         "}\n";
407         NanoPicoContainer parent = new DefaultNanoPicoContainer(buildContainer(
408                 new StringReader JavaDoc(script), null, new ParentAssemblyScope()));
409 // NanoPicoContainer parent = new DefaultNanoPicoContainer();
410
// parent.registerComponentImplementation(A.class);
411
assertNotNull(parent.getComponentInstanceOfType(A.class));
412         PicoContainer pico = buildContainer(new StringReader JavaDoc(script), parent, new SomeAssemblyScope());
413         assertNotNull(pico.getComponentInstanceOfType(B.class));
414     }
415
416     public void testBuildContainerWhenExpectedParentDependencyIsNotFound() {
417         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer();
418
419         Reader JavaDoc script = new StringReader JavaDoc("" +
420                 "package org.nanocontainer.script.groovy\n" +
421                 "import org.nanocontainer.testmodel.*\n" +
422                 "nano = builder.container(parent:parent, scope:assemblyScope) {\n" +
423                 " if ( assemblyScope instanceof SomeAssemblyScope ){\n "+
424                 " component(B)\n" +
425                 " }\n "+
426                 "}\n");
427
428         try {
429             buildContainer(script, parent, new SomeAssemblyScope());
430             fail("UnsatisfiableDependenciesException expected");
431         } catch (UnsatisfiableDependenciesException e) {
432             // expected
433
}
434     }
435
436     public void testBuildContainerWithParentAttributesPropagatesComponentAdapterFactory() {
437         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer(new SetterInjectionComponentAdapterFactory() );
438         Reader JavaDoc script = new StringReader JavaDoc("" +
439                 "package org.nanocontainer.script.groovy\n" +
440                 "import org.nanocontainer.testmodel.*\n" +
441                 "nano = builder.container(parent:parent) {\n" +
442                 "}\n");
443
444         MutablePicoContainer pico = (MutablePicoContainer)buildContainer(script, parent, ASSEMBLY_SCOPE);
445         // Should be able to get instance that was registered in the parent container
446
ComponentAdapter componentAdapter = pico.registerComponentImplementation(String JavaDoc.class);
447         assertTrue("ComponentAdapter should be originally defined by parent" , componentAdapter instanceof SetterInjectionComponentAdapter);
448     }
449
450
451
452     public void testExceptionThrownWhenParentAttributeDefinedWithinChild() {
453         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer(new SetterInjectionComponentAdapterFactory() );
454         Reader JavaDoc script = new StringReader JavaDoc("" +
455                 "package org.nanocontainer.script.groovy\n" +
456                 "import org.nanocontainer.testmodel.*\n" +
457                 "nano = new OldGroovyNodeBuilder().container() {\n" +
458                 " component(A)\n" +
459                 " container(parent:parent) {\n" +
460                 " component(B)\n" +
461                 " }\n" +
462                 "}\n");
463
464         try {
465             buildContainer(script, parent, ASSEMBLY_SCOPE);
466             fail("NanoContainerMarkupException should have been thrown.");
467         } catch (NanoContainerMarkupException ignore) {
468             // ignore
469
}
470     }
471
472     public void testWithDynamicClassPathThatDoesNotExist() {
473         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer();
474         try {
475             Reader JavaDoc script = new StringReader JavaDoc("" +
476                     " child = null\n" +
477                     " pico = builder.container {\n" +
478                     " classPathElement(path:'this/path/does/not/exist.jar')\n" +
479                     " component(class:\"FooBar\") " +
480                     " }" +
481                     "");
482
483             buildContainer(script, parent, ASSEMBLY_SCOPE);
484             fail("should have barfed with bad path exception");
485         } catch (NanoContainerMarkupException e) {
486             // excpected
487
}
488
489     }
490
491
492     public void testWithDynamicClassPath() {
493         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer();
494         Reader JavaDoc script = new StringReader JavaDoc(
495                 ""
496                         + " File testCompJar = new File(System.getProperty(\"testcomp.jar\"))\n"
497                         + " compJarPath = testCompJar.getCanonicalPath()\n"
498                         + " child = null\n"
499                         + " pico = builder.container {\n"
500                         + " classPathElement(path:compJarPath)\n"
501                         + " component(class:\"TestComp\")\n"
502                         + " }" + "");
503
504         MutablePicoContainer pico = (MutablePicoContainer) buildContainer(script, parent, ASSEMBLY_SCOPE);
505
506         assertTrue(pico.getComponentInstances().size() == 1);
507         assertEquals("TestComp", pico.getComponentInstances().get(0).getClass()
508                 .getName());
509     }
510
511     public void testWithDynamicClassPathWithPermissions() {
512         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer();
513         Reader JavaDoc script = new StringReader JavaDoc(
514                 ""
515                         + " File testCompJar = new File(System.getProperty(\"testcomp.jar\"))\n"
516                         + " compJarPath = testCompJar.getCanonicalPath()\n"
517                         + " child = null\n"
518                         + " pico = builder.container {\n"
519                         + " classPathElement(path:compJarPath) {\n"
520                         + " grant(new java.net.SocketPermission('google.com','connect'))\n"
521                         + " }\n"
522                         + " component(class:\"TestComp\")\n"
523                         + " }" + "");
524
525         MutablePicoContainer pico = (MutablePicoContainer)buildContainer(script, parent, ASSEMBLY_SCOPE);
526
527         assertTrue(pico.getComponentInstances().size() == 1);
528         // can't actually test the permission under JUNIT control. We're just
529
// testing the syntax here.
530
}
531
532     public void testGrantPermissionInWrongPlace() {
533         DefaultNanoPicoContainer parent = new DefaultNanoPicoContainer();
534         try {
535             Reader JavaDoc script = new StringReader JavaDoc("" +
536                     " File testCompJar = new File(System.getProperty(\"testcomp.jar\"))\n" +
537                     " compJarPath = testCompJar.getCanonicalPath()\n" +
538                     " child = null\n" +
539                     " pico = builder.container {\n" +
540                     " grant(new java.net.SocketPermission('google.com','connect'))\n" +
541                     " }" +
542                     "");
543
544             buildContainer(script, parent, ASSEMBLY_SCOPE);
545             fail("should barf with [Don't know how to create a 'grant' child] exception");
546         } catch (NanoContainerMarkupException e) {
547             assertTrue(e.getMessage().indexOf("Don't know how to create a 'grant' child") > -1);
548         }
549
550     }
551
552     public void testComponentAdapterIsPotentiallyScriptable() throws PicoCompositionException {
553         Reader JavaDoc script = new StringReader JavaDoc("" +
554                 "import org.nanocontainer.testmodel.*\n" +
555                 "X.reset()\n" +
556                 "builder = new org.nanocontainer.script.groovy.OldGroovyNodeBuilder()\n" +
557                 "nano = builder.container {\n" +
558                 " ca = component(java.lang.Object) \n" +
559                 " component(instance:ca.getClass().getName())\n" +
560                 "}");
561
562         PicoContainer pico = buildContainer(script, null, ASSEMBLY_SCOPE);
563         // LifecyleContainerBuilder starts the container
564
assertEquals("org.picocontainer.defaults.CachingComponentAdapter", pico.getComponentInstances().get(1).toString());
565     }
566
567
568     private PicoContainer buildContainer(Reader JavaDoc script, PicoContainer parent, Object JavaDoc scope) {
569         return buildContainer(new GroovyContainerBuilder(script, getClass().getClassLoader()), parent, scope);
570     }
571
572 }
573
Popular Tags