KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > test > javax > management > relation > RelationServiceTest


1 /*
2  * Copyright (C) The MX4J Contributors.
3  * All rights reserved.
4  *
5  * This software is distributed under the terms of the MX4J License version 1.0.
6  * See the terms of the MX4J License in the documentation provided with this software.
7  */

8
9
10 package test.javax.management.relation;
11
12 // Java imports
13

14 import java.util.ArrayList JavaDoc;
15 import java.util.Iterator JavaDoc;
16 import java.util.List JavaDoc;
17 import java.util.Map JavaDoc;
18 import javax.management.InstanceNotFoundException JavaDoc;
19 import javax.management.MBeanServer JavaDoc;
20 import javax.management.MBeanServerFactory JavaDoc;
21 import javax.management.ObjectName JavaDoc;
22 import javax.management.relation.RelationService JavaDoc;
23 import javax.management.relation.RelationTypeNotFoundException JavaDoc;
24 import javax.management.relation.RelationTypeSupport JavaDoc;
25 import javax.management.relation.Role JavaDoc;
26 import javax.management.relation.RoleInfo JavaDoc;
27 import javax.management.relation.RoleList JavaDoc;
28 import javax.management.relation.RoleResult JavaDoc;
29 import javax.management.relation.RoleStatus JavaDoc;
30
31 import junit.framework.TestCase;
32
33 /**
34  * @version $Revision: 1.18 $
35  */

36 public class RelationServiceTest extends TestCase
37 {
38    private MBeanServer JavaDoc m_server = null;
39    private ObjectName JavaDoc m_relationServiceObjectName = null;
40    private RelationService JavaDoc m_relationService;
41
42    // convenience MBean ObjectNames
43
ObjectName JavaDoc mbeanObjectName1;
44    ObjectName JavaDoc mbeanObjectName2;
45    ObjectName JavaDoc mbeanObjectName3;
46    ObjectName JavaDoc mbeanObjectName4;
47    ObjectName JavaDoc mbeanObjectName5;
48    ObjectName JavaDoc mbeanObjectName6;
49
50    public RelationServiceTest(String JavaDoc s)
51    {
52       super(s);
53    }
54
55    protected void setUp()
56    {
57       m_server = MBeanServerFactory.createMBeanServer();
58       // create and register relation service
59
try
60       {
61          m_relationServiceObjectName = new ObjectName JavaDoc("DefaultDomain:type=javax.management.relation.RelationService");
62       }
63       catch (Exception JavaDoc ex)
64       {
65          ex.printStackTrace();
66       }
67    }
68
69    public void tearDown() throws Exception JavaDoc
70    {
71       m_server.unregisterMBean(m_relationServiceObjectName);
72       MBeanServerFactory.releaseMBeanServer(m_server);
73    }
74
75    public void testIsActive()
76    {
77       try
78       {
79          registerRelationService(true);
80          m_relationService.isActive();
81       }
82       catch (Exception JavaDoc e)
83       {
84          fail("Relation Service should be active");
85       }
86    }
87
88    public void testGetFalsePurgeFlag() throws Exception JavaDoc
89    {
90       registerRelationService(false);
91       assertTrue(m_relationService.getPurgeFlag() == false);
92    }
93
94
95    public void testGetTruePurgeFlag() throws Exception JavaDoc
96    {
97       registerRelationService(true);
98       assertTrue(m_relationService.getPurgeFlag());
99    }
100
101    public void testCreateRelationType()
102    {
103       try
104       {
105          registerRelationService(true);
106          RoleInfo JavaDoc[] roleInfos = createRoleInfos("contained", "container");
107          m_relationService.createRelationType("relationTypeName1", roleInfos);
108          // create one relation type expect 1 returned from call getAllRelationTypeNames
109
assertTrue(m_relationService.getAllRelationTypeNames().size() == 1);
110          assertEquals("relationTypeName1", m_relationService.getAllRelationTypeNames().get(0));
111       }
112       catch (Exception JavaDoc e)
113       {
114          fail("Valid call to createRelationType");
115       }
116    }
117
118    public void testAddRelationType()
119    {
120       try
121       {
122          registerRelationService(true);
123
124          String JavaDoc relationTypeName = "RelationTypeUnitTest";
125          m_relationService.addRelationType(new SimpleRelationType(relationTypeName));
126          assertTrue(m_relationService.getAllRelationTypeNames().size() == 1);
127          assertEquals(relationTypeName, m_relationService.getAllRelationTypeNames().get(0));
128
129
130       }
131       catch (Exception JavaDoc e)
132       {
133          fail("Valid call to createRelationType");
134       }
135    }
136
137    public void testGetAllRelationTypeNames() throws Exception JavaDoc
138    {
139       registerRelationService(true);
140       String JavaDoc relationTypeName1 = "TestRelation1";
141       String JavaDoc relationTypeName2 = "TestRelation2";
142       String JavaDoc relationTypeName3 = "TestRelation3";
143       String JavaDoc relationTypeName4 = "TestRelation4";
144       m_relationService.addRelationType(new SimpleRelationType(relationTypeName1));
145       m_relationService.addRelationType(new SimpleRelationType(relationTypeName2));
146       m_relationService.addRelationType(new SimpleRelationType(relationTypeName3));
147       m_relationService.addRelationType(new SimpleRelationType(relationTypeName4));
148
149       assertTrue(m_relationService.getAllRelationTypeNames().size() == 4);
150    }
151
152    public void testDuplicateRelationTypeNameThrowsException() throws Exception JavaDoc
153    {
154       registerRelationService(true);
155       String JavaDoc relationTypeName1 = "TestRelation1";
156       String JavaDoc relationTypeName2 = "TestRelation1";
157       try
158       {
159          m_relationService.addRelationType(new SimpleRelationType(relationTypeName1));
160       }
161       catch (Exception JavaDoc e)
162       {
163          fail("first one should be ok as no duplicates");
164       }
165
166       try
167       {
168          m_relationService.addRelationType(new SimpleRelationType(relationTypeName2));
169          fail("Should have had an exception");
170       }
171       catch (Exception JavaDoc expected)
172       {
173          // should be an exception 2 relationTypeNames the same!!
174
}
175    }
176
177    public void testGetRoleInfos() throws Exception JavaDoc
178    {
179       registerRelationService(true);
180       registerMBeans();
181       m_relationService.createRelationType("aRelationTypeName", createRoleInfos("mother", "child"));
182
183       RoleList JavaDoc roleList = new RoleList JavaDoc();
184
185       createRoleList(mbeanObjectName1, "mother", roleList);
186       createRoleList(mbeanObjectName2, "child", roleList);
187
188       m_relationService.createRelation("relationId1", "aRelationTypeName", roleList);
189       List JavaDoc l = m_relationService.getRoleInfos("aRelationTypeName");
190       assertTrue(l.size() == 2);
191    }
192
193    public void testRemoveRelationType() throws Exception JavaDoc
194    {
195       registerRelationService(true);
196       registerMBeans();
197
198       RoleList JavaDoc roleList = new RoleList JavaDoc();
199
200       createRoleList(mbeanObjectName1, "owner", roleList);
201       createRoleList(mbeanObjectName2, "car", roleList);
202
203       m_relationService.createRelationType("testValidRelationTypeNameRemoval", createRoleInfos("car", "owner"));
204       m_relationService.createRelation("relationID", "testValidRelationTypeNameRemoval", roleList);
205
206       try
207       {
208          m_relationService.removeRelationType("testValidRelationTypeNameRemoval");
209       }
210       catch (Exception JavaDoc e)
211       {
212          fail("No exception expected as relationType registered and valid");
213       }
214
215       assertTrue(m_relationService.getAllRelationTypeNames().size() == 0);
216    }
217
218    public void testRemoveRelationType_NonExistent() throws Exception JavaDoc
219    {
220       registerRelationService(true);
221       try
222       {
223          m_relationService.removeRelationType("invalidRelationType_notCreated");
224          fail("Expected a RelationTypeNotFoundException to be thrown");
225       }
226       catch (RelationTypeNotFoundException JavaDoc expected)
227       {
228          // ok
229
}
230       catch (Exception JavaDoc e)
231       {
232          fail("Wrong exception this was not expected");
233       }
234    }
235
236    public void testAddRelationMBeanNotRegistered() throws Exception JavaDoc
237    {
238       registerRelationService(true);
239       ObjectName JavaDoc mbeanObjectName = new ObjectName JavaDoc("domain:name=testMbeanNotRegistered");
240       try
241       {
242          m_relationService.addRelation(mbeanObjectName);
243          fail("MBean not registered should throw an exception");
244       }
245       catch (InstanceNotFoundException JavaDoc expected)
246       {
247          //ok exception expected
248
}
249       catch (Exception JavaDoc e)
250       {
251          fail("not expected");
252       }
253    }
254
255    /**
256     * Call RelationService.addService passing an object name
257     * of a Relation with a set of roles.
258     * <p/>
259     * Call RelationService.addService passing an object name
260     * of another relation with a different set of roles.
261     * <p/>
262     * Call RelationService.getAllRoles passing the relation id of
263     * the second relation added.
264     * <p/>
265     * You will see that the roles returned are actually those of
266     * the first relation added.
267     *
268     * @throws Exception
269     */

270    public void testAddRelation_correctRolesReturned() throws Exception JavaDoc
271    {
272       registerRelationService(true);
273       registerMBeans();
274
275       RoleList JavaDoc roleList = new RoleList JavaDoc();
276       createRoleList(mbeanObjectName1, "owner", roleList);
277       createRoleList(mbeanObjectName2, "car", roleList);
278
279       ObjectName JavaDoc relationSupportObjectName = new ObjectName JavaDoc("relationDomain:name=aRelationSupport");
280       SimpleRelationTestSupport relationSupport = new SimpleRelationTestSupport("relationID",
281                                                                                 m_relationServiceObjectName,
282                                                                                 "relationTypeName",
283                                                                                 roleList);
284
285       m_server.registerMBean(relationSupport, relationSupportObjectName);
286
287       /* create the relationType */
288       m_relationService.createRelationType("relationTypeName", createRoleInfos("car", "owner"));
289
290       /* now add the relation */
291       m_relationService.addRelation(relationSupportObjectName);
292
293       ////////////////////////////////////////////////////////////////////////////////////////////////
294

295       RoleList JavaDoc roleList1 = new RoleList JavaDoc();
296       createRoleList(mbeanObjectName3, "parent", roleList1);
297       createRoleList(mbeanObjectName4, "child", roleList1);
298
299       ObjectName JavaDoc relationSupportObjectName2 = new ObjectName JavaDoc("relationDomain:name=aRelationSupport2");
300       SimpleRelationTestSupport relationSupport2 = new SimpleRelationTestSupport("relationID2",
301                                                                                  m_relationServiceObjectName,
302                                                                                  "relationTypeName2",
303                                                                                  roleList1);
304
305       m_server.registerMBean(relationSupport2, relationSupportObjectName2);
306
307       m_relationService.createRelationType("relationTypeName2", createRoleInfos("parent", "child"));
308       m_relationService.addRelation(relationSupportObjectName2);
309
310       ///////////////// validate querying roles for relationId2(added second) returns the correct roles ////////////////////////////////
311
RoleResult JavaDoc result1 = m_relationService.getAllRoles("relationID2");
312       RoleList JavaDoc actual1 = result1.getRoles();
313       // we have to do this as role does not have an equals or hashcode, must check if it is added it will break compatibility!!!!
314
final Role JavaDoc role = (Role JavaDoc)roleList1.get(0);
315       boolean success = false;
316       for (Iterator JavaDoc iterator = actual1.iterator(); iterator.hasNext();)
317       {
318          Role JavaDoc role1 = (Role JavaDoc)iterator.next();
319          String JavaDoc roleName = role1.getRoleName();
320          if (roleName.equals(role.getRoleName())) success = true;
321       }
322       assertTrue(success);
323
324       ///////////////////// validate querying roles for relaionID (added first) returns the expected roles ///////////////////////////////
325
RoleResult JavaDoc result = m_relationService.getAllRoles("relationID");
326       RoleList JavaDoc actual = result.getRoles();
327
328       final Role JavaDoc role2 = (Role JavaDoc)roleList.get(0);
329       boolean success2 = false;
330       for (Iterator JavaDoc iterator = actual.iterator(); iterator.hasNext();)
331       {
332          Role JavaDoc role1 = (Role JavaDoc)iterator.next();
333          String JavaDoc roleName = role1.getRoleName();
334          if (roleName.equals(role2.getRoleName())) success2 = true;
335       }
336       assertTrue(success2);
337
338       //assertTrue(roleList.contains(actual.get(0)));
339
}
340
341    public void testAddRelation() throws Exception JavaDoc
342    {
343       registerRelationService(true);
344       registerMBeans();
345
346       RoleList JavaDoc roleList = new RoleList JavaDoc();
347       createRoleList(mbeanObjectName1, "owner", roleList);
348       createRoleList(mbeanObjectName2, "car", roleList);
349
350       ObjectName JavaDoc relationSupportObjectName = new ObjectName JavaDoc("relationDomain:name=aRelationSupport");
351       SimpleRelationTestSupport relationSupport = new SimpleRelationTestSupport("relationID",
352                                                                                 m_relationServiceObjectName,
353                                                                                 "relationTypeName",
354                                                                                 roleList);
355
356       m_server.registerMBean(relationSupport, relationSupportObjectName);
357
358       /* create the relationType */
359       m_relationService.createRelationType("relationTypeName", createRoleInfos("car", "owner"));
360       try
361       {
362          /* now add the relation */
363          m_relationService.addRelation(relationSupportObjectName);
364       }
365       catch (Exception JavaDoc e)
366       {
367          e.printStackTrace();
368       }
369    }
370
371    public void testGetRoleInfo() throws Exception JavaDoc
372    {
373       registerRelationService(true);
374       registerMBeans();
375
376       RoleList JavaDoc roleList = new RoleList JavaDoc();
377       createRoleList(mbeanObjectName1, "owner", roleList);
378       createRoleList(mbeanObjectName2, "car", roleList);
379
380       ObjectName JavaDoc relationSupportObjectName = new ObjectName JavaDoc("relationDomain:name=aRelationSupport");
381       SimpleRelationTestSupport relationSupport = new SimpleRelationTestSupport("relationID",
382                                                                                 m_relationServiceObjectName,
383                                                                                 "relationTypeName",
384                                                                                 roleList);
385
386       m_server.registerMBean(relationSupport, relationSupportObjectName);
387
388       RoleInfo JavaDoc[] roleInfos = createRoleInfos("car", "owner");
389
390       /* create the relationType */
391       m_relationService.createRelationType("relationTypeName", roleInfos);
392
393       RoleInfo JavaDoc info = m_relationService.getRoleInfo("relationTypeName", "owner");
394
395       assertEquals(info, roleInfos[1]);
396    }
397
398    public void testIsRelationMBean() throws Exception JavaDoc
399    {
400       String JavaDoc relationID = "relationID";
401       try
402       {
403          ObjectName JavaDoc relationSupportObjectName = new ObjectName JavaDoc("relationDomain:name=aRelationSupport");
404          setUpRelationServiceForQueryTesting(relationID, relationSupportObjectName);
405          assertTrue(m_relationService.isRelationMBean(relationID).equals(relationSupportObjectName));
406       }
407       catch (Exception JavaDoc e)
408       {
409          e.printStackTrace(); //To change body of catch statement use Options | File Templates.
410
}
411    }
412
413    public void testIsRelation()
414    {
415       String JavaDoc relationID = "relationID";
416       try
417       {
418          ObjectName JavaDoc relationSupportObjectName = new ObjectName JavaDoc("relationDomain:name=aRelationSupport");
419          setUpRelationServiceForQueryTesting(relationID, relationSupportObjectName);
420          assertTrue(m_relationService.isRelation(relationSupportObjectName).equals(relationID));
421       }
422       catch (Exception JavaDoc e)
423       {
424          e.printStackTrace(); //To change body of catch statement use Options | File Templates.
425
}
426    }
427
428    public void testHasRelation()
429    {
430       String JavaDoc relationID = "relationID";
431       try
432       {
433          ObjectName JavaDoc relationSupportObjectName = new ObjectName JavaDoc("relationDomain:name=aRelationSupport");
434          setUpRelationServiceForQueryTesting(relationID, relationSupportObjectName);
435          assertTrue((m_relationService.hasRelation(relationID)).booleanValue());
436       }
437       catch (Exception JavaDoc e)
438       {
439          e.printStackTrace(); //To change body of catch statement use Options | File Templates.
440
}
441    }
442
443    public void tesetGetAllRelationIds() throws Exception JavaDoc
444    {
445       registerRelationService(true);
446       registerMBeans();
447
448       RoleList JavaDoc roleList = new RoleList JavaDoc();
449       createRoleList(mbeanObjectName1, "owner", roleList);
450       createRoleList(mbeanObjectName2, "car", roleList);
451
452       /* create the relationType first then creaste the relation*/
453       m_relationService.createRelationType("relationTypeName1", createRoleInfos("car", "owner"));
454       m_relationService.createRelationType("relationTypeName2", createRoleInfos("car", "owner"));
455       m_relationService.createRelationType("relationTypeName3", createRoleInfos("car", "owner"));
456
457       m_relationService.createRelation("relationID1", "relationTypeName1", roleList);
458       m_relationService.createRelation("relationID2", "relationTypeName2", roleList);
459       m_relationService.createRelation("relationID3", "relationTypeName3", roleList);
460
461       List JavaDoc allIds = m_relationService.getAllRelationIds();
462
463       assertTrue(allIds.size() == 3);
464    }
465
466    public void testRoleReading0() throws Exception JavaDoc
467    {
468       registerRelationService(true);
469       registerMBeans();
470       String JavaDoc relationTypeName = "relationTypeName";
471       m_relationService.addRelationType(new SimpleRelationType(relationTypeName));
472       Integer JavaDoc value = m_relationService.checkRoleReading("primary", relationTypeName);
473       // role is a ok returns 0
474
assertEquals(value.intValue(), 0);
475    }
476
477    public void testRoleReading1() throws Exception JavaDoc
478    {
479       registerRelationService(true);
480       registerMBeans();
481       String JavaDoc relationTypeName = "relationTypeName";
482       m_relationService.addRelationType(new SimpleRelationType(relationTypeName));
483       Integer JavaDoc value = m_relationService.checkRoleReading("book", relationTypeName);
484       // RoleStatus.NO_ROLE_WITH_NAME = 1
485
assertEquals(value.intValue(), RoleStatus.NO_ROLE_WITH_NAME);
486    }
487
488    public void testRoleReading2() throws Exception JavaDoc
489    {
490       registerRelationService(true);
491       registerMBeans();
492       String JavaDoc relationTypeName = "relationTypeName";
493       m_relationService.addRelationType(new TestRelationType(relationTypeName));
494       Integer JavaDoc value = m_relationService.checkRoleReading("primary", relationTypeName);
495       // RoleStatus.ROLE_NOT_READABLE = 2
496
assertEquals(value.intValue(), RoleStatus.ROLE_NOT_READABLE);
497    }
498
499    public void testCreateRelation() throws Exception JavaDoc
500    {
501       registerRelationService(true);
502       registerMBeans();
503       RoleList JavaDoc roleList = new RoleList JavaDoc();
504       createRoleList(mbeanObjectName1, "owner", roleList);
505       createRoleList(mbeanObjectName2, "car", roleList);
506
507       /* create the relationType first then creaste the relation*/
508       String JavaDoc relationTypeName = "relationTypeName";
509       RoleInfo JavaDoc[] roleInfos = createRoleInfos("car", "owner");
510       Object JavaDoc[] params1 = {relationTypeName, roleInfos};
511       String JavaDoc[] signature1 = {"java.lang.String", roleInfos.getClass().getName()};
512
513       m_server.invoke(m_relationServiceObjectName, "createRelationType", params1, signature1);
514       String JavaDoc relationId = "relationId1";
515
516       Object JavaDoc[] params = {relationId, relationTypeName, roleList};
517       String JavaDoc[] signature = {"java.lang.String", "java.lang.String", "javax.management.relation.RoleList"};
518       m_server.invoke(m_relationServiceObjectName, "createRelation", params, signature);
519    }
520
521    private void setUpRelationServiceForQueryTesting(String JavaDoc relationID,
522                                                     ObjectName JavaDoc mbeanObjectName) throws Exception JavaDoc
523    {
524       registerRelationService(true);
525       registerMBeans();
526
527       RoleList JavaDoc roleList = new RoleList JavaDoc();
528       createRoleList(mbeanObjectName1, "owner", roleList);
529       createRoleList(mbeanObjectName2, "car", roleList);
530
531       //ObjectName relationSupportObjectName = new ObjectName("relationDomain:name=aRelationSupport");
532
SimpleRelationTestSupport relationSupport = new SimpleRelationTestSupport(relationID,
533                                                                                 m_relationServiceObjectName,
534                                                                                 "relationTypeName",
535                                                                                 roleList);
536
537       m_server.registerMBean(relationSupport, mbeanObjectName);
538
539       /* create the relationType */
540       try
541       {
542          m_relationService.createRelationType("relationTypeName", createRoleInfos("car", "owner"));
543
544          /* now add the relation */
545          m_relationService.addRelation(mbeanObjectName);
546       }
547       catch (Exception JavaDoc e)
548       {
549          e.printStackTrace(); //To change body of catch statement use Options | File Templates.
550
}
551    }
552
553    private void registerMBeans()
554    {
555       try
556       {
557          // create and build 6 MBeans in the server to act as relations in the relationService
558
String JavaDoc mbeanClassName = "test.javax.management.relation.SimpleStandard";
559          mbeanObjectName1 = new ObjectName JavaDoc("domain:type=SimpleStandard_1");
560          mbeanObjectName2 = new ObjectName JavaDoc("domain:type=SimpleStandard_2");
561          mbeanObjectName3 = new ObjectName JavaDoc("domain:type=SimpleStandard_3");
562          mbeanObjectName4 = new ObjectName JavaDoc("domain:type=SimpleStandard_4");
563          mbeanObjectName5 = new ObjectName JavaDoc("domain:type=SimpleStandard_5");
564          mbeanObjectName6 = new ObjectName JavaDoc("domain:type=SimpleStandard_6");
565
566          m_server.createMBean(mbeanClassName, mbeanObjectName1, null);
567          m_server.createMBean(mbeanClassName, mbeanObjectName2, null);
568          m_server.createMBean(mbeanClassName, mbeanObjectName3, null);
569          m_server.createMBean(mbeanClassName, mbeanObjectName4, null);
570          m_server.createMBean(mbeanClassName, mbeanObjectName5, null);
571          m_server.createMBean(mbeanClassName, mbeanObjectName6, null);
572       }
573       catch (Exception JavaDoc e)
574       {
575          e.printStackTrace();
576       }
577    }
578
579    private void registerRelationService(boolean purge) throws Exception JavaDoc
580    {
581       m_relationService = new RelationService JavaDoc(purge);
582       m_server.registerMBean(m_relationService, m_relationServiceObjectName);
583    }
584
585    private RoleInfo JavaDoc[] createRoleInfos(String JavaDoc roleName1,
586                                       String JavaDoc roleName2) throws Exception JavaDoc
587    {
588       RoleInfo JavaDoc[] roleInfos = new RoleInfo JavaDoc[2];
589       roleInfos[0] = new RoleInfo JavaDoc(roleName1, "test.javax.management.relation.SimpleStandard", true, true, 1, -1, null);
590       roleInfos[1] = new RoleInfo JavaDoc(roleName2, "test.javax.management.relation.SimpleStandard", true, true, 0, -1, null);
591       return roleInfos;
592    }
593
594    private RoleList JavaDoc createRoleList(ObjectName JavaDoc mbeanObjectName,
595                                    String JavaDoc roleName,
596                                    RoleList JavaDoc roleList)
597    {
598       ArrayList JavaDoc roleValue = new ArrayList JavaDoc();
599       roleValue.add(mbeanObjectName);
600       Role JavaDoc role = new Role JavaDoc(roleName, roleValue);
601       roleList.add(role);
602       return roleList;
603    }
604
605    class TestRelationType extends RelationTypeSupport JavaDoc
606    {
607       public TestRelationType(String JavaDoc relationTypeName)
608       {
609          super(relationTypeName);
610          try
611          {
612             RoleInfo JavaDoc primaryRoleInfo = new RoleInfo JavaDoc("primary",
613                                                     "test.javax.management.relation.SimpleStandard",
614                                                     false, //read
615
true, //write
616
2,
617                                                     2,
618                                                     "Primary :)");
619             addRoleInfo(primaryRoleInfo);
620
621             RoleInfo JavaDoc secondaryRoleInfo = new RoleInfo JavaDoc("secondary",
622                                                       "test.javax.management.relation.SimpleStandard",
623                                                       true,
624                                                       false,
625                                                       2,
626                                                       2,
627                                                       "Secondary");
628             addRoleInfo(secondaryRoleInfo);
629          }
630          catch (Exception JavaDoc ex)
631          {
632             throw new RuntimeException JavaDoc(ex.getMessage());
633          }
634       }
635    }
636
637    public void testSimpleRoleListCtor() throws Exception JavaDoc
638    {
639       registerRelationService(true);
640       registerMBeans();
641       RoleList JavaDoc rl = new RoleList JavaDoc();
642       assertTrue("New RoleList isn't empty", rl.isEmpty());
643       rl = new RoleList JavaDoc(42);
644       assertTrue("New RoleList(42) isn't empty", rl.isEmpty());
645    }
646
647    public void testRoleListCopyCtor() throws Exception JavaDoc
648    {
649       registerRelationService(true);
650       registerMBeans();
651       RoleList JavaDoc rl = new RoleList JavaDoc();
652       rl.add(new Role JavaDoc("romeo", new ArrayList JavaDoc()));
653       rl.add(new Role JavaDoc("juliet", new ArrayList JavaDoc()));
654       RoleList JavaDoc rlcopy = new RoleList JavaDoc(rl);
655       assertTrue("Bogus copy", rl.equals(rlcopy));
656
657       try
658       {
659          new RoleList JavaDoc(null);
660          fail("Expecting IllegalArgumentException");
661       }
662       catch (IllegalArgumentException JavaDoc x)
663       {
664          assertTrue(true);
665       }
666    }
667
668    public void testUpdateRoleMap() throws Exception JavaDoc
669    {
670       List JavaDoc roleValue = new ArrayList JavaDoc();
671       roleValue.add(new ObjectName JavaDoc("domain:type=SimpleStandard_2"));
672       Role JavaDoc role = new Role JavaDoc("myTestRoleName", roleValue);
673
674       String JavaDoc relationID = "myTestRelation";
675       setUpRelationServiceForQueryTesting(relationID, new ObjectName JavaDoc("domain:type=testType"));
676
677       m_relationService.updateRoleMap("domain:type=SimpleStandard_1", role, new ArrayList JavaDoc());
678       Map JavaDoc result = m_relationService.getReferencedMBeans(relationID);
679       assertTrue("The referenced mbeans are not as expected, 2 were added but only " + result.size() + " found", result.size() == 2);
680    }
681
682    public void testFindReferencingMBeans() throws Exception JavaDoc
683    {
684       //basic init...
685
registerRelationService(true);
686       registerMBeans();
687
688       //this is going to be our referenced bean
689
ObjectName JavaDoc targetObjectName = mbeanObjectName1;
690
691       //create constraint
692
m_relationService.createRelationType("relationType1", createRoleInfos("roleName1", "roleName2"));
693
694       RoleList JavaDoc roleList = new RoleList JavaDoc();
695       ArrayList JavaDoc values = new ArrayList JavaDoc();
696       values.add(targetObjectName); //our test target
697
values.add(mbeanObjectName2);
698
699       roleList.add(new Role JavaDoc("roleName1", values));
700
701       //create first referencing relation (to meanObjectName1);
702
m_relationService.createRelation("relationID1", "relationType1", roleList);
703
704       roleList = new RoleList JavaDoc();
705       values = new ArrayList JavaDoc();
706       values.add(targetObjectName); //our test target
707
values.add(mbeanObjectName3);
708       roleList.add(new Role JavaDoc("roleName1", values));
709       roleList.add(new Role JavaDoc("roleName2", values));
710
711       //create second referencing relation (to meanObjectName1);
712
m_relationService.createRelation("relationID2", "relationType1", roleList);
713
714       Map JavaDoc result = m_relationService.findReferencingRelations(targetObjectName, null, null); //our test target should have 2 references by now....
715

716       //dsamsonoff - under 575066 this would fail - map size would always return 1
717
assertTrue("The referencing mbeans are not as expected, 2 were added but only " + result.size() + " found", result.size() == 2);
718
719    }
720 }
721
Popular Tags