1 8 9 10 package test.javax.management.relation; 11 12 14 import java.util.ArrayList ; 15 import java.util.Iterator ; 16 import java.util.List ; 17 import java.util.Map ; 18 import javax.management.InstanceNotFoundException ; 19 import javax.management.MBeanServer ; 20 import javax.management.MBeanServerFactory ; 21 import javax.management.ObjectName ; 22 import javax.management.relation.RelationService ; 23 import javax.management.relation.RelationTypeNotFoundException ; 24 import javax.management.relation.RelationTypeSupport ; 25 import javax.management.relation.Role ; 26 import javax.management.relation.RoleInfo ; 27 import javax.management.relation.RoleList ; 28 import javax.management.relation.RoleResult ; 29 import javax.management.relation.RoleStatus ; 30 31 import junit.framework.TestCase; 32 33 36 public class RelationServiceTest extends TestCase 37 { 38 private MBeanServer m_server = null; 39 private ObjectName m_relationServiceObjectName = null; 40 private RelationService m_relationService; 41 42 ObjectName mbeanObjectName1; 44 ObjectName mbeanObjectName2; 45 ObjectName mbeanObjectName3; 46 ObjectName mbeanObjectName4; 47 ObjectName mbeanObjectName5; 48 ObjectName mbeanObjectName6; 49 50 public RelationServiceTest(String s) 51 { 52 super(s); 53 } 54 55 protected void setUp() 56 { 57 m_server = MBeanServerFactory.createMBeanServer(); 58 try 60 { 61 m_relationServiceObjectName = new ObjectName ("DefaultDomain:type=javax.management.relation.RelationService"); 62 } 63 catch (Exception ex) 64 { 65 ex.printStackTrace(); 66 } 67 } 68 69 public void tearDown() throws Exception 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 e) 83 { 84 fail("Relation Service should be active"); 85 } 86 } 87 88 public void testGetFalsePurgeFlag() throws Exception 89 { 90 registerRelationService(false); 91 assertTrue(m_relationService.getPurgeFlag() == false); 92 } 93 94 95 public void testGetTruePurgeFlag() throws Exception 96 { 97 registerRelationService(true); 98 assertTrue(m_relationService.getPurgeFlag()); 99 } 100 101 public void testCreateRelationType() 102 { 103 try 104 { 105 registerRelationService(true); 106 RoleInfo [] roleInfos = createRoleInfos("contained", "container"); 107 m_relationService.createRelationType("relationTypeName1", roleInfos); 108 assertTrue(m_relationService.getAllRelationTypeNames().size() == 1); 110 assertEquals("relationTypeName1", m_relationService.getAllRelationTypeNames().get(0)); 111 } 112 catch (Exception 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 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 e) 132 { 133 fail("Valid call to createRelationType"); 134 } 135 } 136 137 public void testGetAllRelationTypeNames() throws Exception 138 { 139 registerRelationService(true); 140 String relationTypeName1 = "TestRelation1"; 141 String relationTypeName2 = "TestRelation2"; 142 String relationTypeName3 = "TestRelation3"; 143 String 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 153 { 154 registerRelationService(true); 155 String relationTypeName1 = "TestRelation1"; 156 String relationTypeName2 = "TestRelation1"; 157 try 158 { 159 m_relationService.addRelationType(new SimpleRelationType(relationTypeName1)); 160 } 161 catch (Exception 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 expected) 172 { 173 } 175 } 176 177 public void testGetRoleInfos() throws Exception 178 { 179 registerRelationService(true); 180 registerMBeans(); 181 m_relationService.createRelationType("aRelationTypeName", createRoleInfos("mother", "child")); 182 183 RoleList roleList = new RoleList (); 184 185 createRoleList(mbeanObjectName1, "mother", roleList); 186 createRoleList(mbeanObjectName2, "child", roleList); 187 188 m_relationService.createRelation("relationId1", "aRelationTypeName", roleList); 189 List l = m_relationService.getRoleInfos("aRelationTypeName"); 190 assertTrue(l.size() == 2); 191 } 192 193 public void testRemoveRelationType() throws Exception 194 { 195 registerRelationService(true); 196 registerMBeans(); 197 198 RoleList roleList = new RoleList (); 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 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 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 expected) 227 { 228 } 230 catch (Exception e) 231 { 232 fail("Wrong exception this was not expected"); 233 } 234 } 235 236 public void testAddRelationMBeanNotRegistered() throws Exception 237 { 238 registerRelationService(true); 239 ObjectName mbeanObjectName = new ObjectName ("domain:name=testMbeanNotRegistered"); 240 try 241 { 242 m_relationService.addRelation(mbeanObjectName); 243 fail("MBean not registered should throw an exception"); 244 } 245 catch (InstanceNotFoundException expected) 246 { 247 } 249 catch (Exception e) 250 { 251 fail("not expected"); 252 } 253 } 254 255 270 public void testAddRelation_correctRolesReturned() throws Exception 271 { 272 registerRelationService(true); 273 registerMBeans(); 274 275 RoleList roleList = new RoleList (); 276 createRoleList(mbeanObjectName1, "owner", roleList); 277 createRoleList(mbeanObjectName2, "car", roleList); 278 279 ObjectName relationSupportObjectName = new ObjectName ("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 288 m_relationService.createRelationType("relationTypeName", createRoleInfos("car", "owner")); 289 290 291 m_relationService.addRelation(relationSupportObjectName); 292 293 295 RoleList roleList1 = new RoleList (); 296 createRoleList(mbeanObjectName3, "parent", roleList1); 297 createRoleList(mbeanObjectName4, "child", roleList1); 298 299 ObjectName relationSupportObjectName2 = new ObjectName ("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 RoleResult result1 = m_relationService.getAllRoles("relationID2"); 312 RoleList actual1 = result1.getRoles(); 313 final Role role = (Role )roleList1.get(0); 315 boolean success = false; 316 for (Iterator iterator = actual1.iterator(); iterator.hasNext();) 317 { 318 Role role1 = (Role )iterator.next(); 319 String roleName = role1.getRoleName(); 320 if (roleName.equals(role.getRoleName())) success = true; 321 } 322 assertTrue(success); 323 324 RoleResult result = m_relationService.getAllRoles("relationID"); 326 RoleList actual = result.getRoles(); 327 328 final Role role2 = (Role )roleList.get(0); 329 boolean success2 = false; 330 for (Iterator iterator = actual.iterator(); iterator.hasNext();) 331 { 332 Role role1 = (Role )iterator.next(); 333 String roleName = role1.getRoleName(); 334 if (roleName.equals(role2.getRoleName())) success2 = true; 335 } 336 assertTrue(success2); 337 338 } 340 341 public void testAddRelation() throws Exception 342 { 343 registerRelationService(true); 344 registerMBeans(); 345 346 RoleList roleList = new RoleList (); 347 createRoleList(mbeanObjectName1, "owner", roleList); 348 createRoleList(mbeanObjectName2, "car", roleList); 349 350 ObjectName relationSupportObjectName = new ObjectName ("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 359 m_relationService.createRelationType("relationTypeName", createRoleInfos("car", "owner")); 360 try 361 { 362 363 m_relationService.addRelation(relationSupportObjectName); 364 } 365 catch (Exception e) 366 { 367 e.printStackTrace(); 368 } 369 } 370 371 public void testGetRoleInfo() throws Exception 372 { 373 registerRelationService(true); 374 registerMBeans(); 375 376 RoleList roleList = new RoleList (); 377 createRoleList(mbeanObjectName1, "owner", roleList); 378 createRoleList(mbeanObjectName2, "car", roleList); 379 380 ObjectName relationSupportObjectName = new ObjectName ("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 [] roleInfos = createRoleInfos("car", "owner"); 389 390 391 m_relationService.createRelationType("relationTypeName", roleInfos); 392 393 RoleInfo info = m_relationService.getRoleInfo("relationTypeName", "owner"); 394 395 assertEquals(info, roleInfos[1]); 396 } 397 398 public void testIsRelationMBean() throws Exception 399 { 400 String relationID = "relationID"; 401 try 402 { 403 ObjectName relationSupportObjectName = new ObjectName ("relationDomain:name=aRelationSupport"); 404 setUpRelationServiceForQueryTesting(relationID, relationSupportObjectName); 405 assertTrue(m_relationService.isRelationMBean(relationID).equals(relationSupportObjectName)); 406 } 407 catch (Exception e) 408 { 409 e.printStackTrace(); } 411 } 412 413 public void testIsRelation() 414 { 415 String relationID = "relationID"; 416 try 417 { 418 ObjectName relationSupportObjectName = new ObjectName ("relationDomain:name=aRelationSupport"); 419 setUpRelationServiceForQueryTesting(relationID, relationSupportObjectName); 420 assertTrue(m_relationService.isRelation(relationSupportObjectName).equals(relationID)); 421 } 422 catch (Exception e) 423 { 424 e.printStackTrace(); } 426 } 427 428 public void testHasRelation() 429 { 430 String relationID = "relationID"; 431 try 432 { 433 ObjectName relationSupportObjectName = new ObjectName ("relationDomain:name=aRelationSupport"); 434 setUpRelationServiceForQueryTesting(relationID, relationSupportObjectName); 435 assertTrue((m_relationService.hasRelation(relationID)).booleanValue()); 436 } 437 catch (Exception e) 438 { 439 e.printStackTrace(); } 441 } 442 443 public void tesetGetAllRelationIds() throws Exception 444 { 445 registerRelationService(true); 446 registerMBeans(); 447 448 RoleList roleList = new RoleList (); 449 createRoleList(mbeanObjectName1, "owner", roleList); 450 createRoleList(mbeanObjectName2, "car", roleList); 451 452 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 allIds = m_relationService.getAllRelationIds(); 462 463 assertTrue(allIds.size() == 3); 464 } 465 466 public void testRoleReading0() throws Exception 467 { 468 registerRelationService(true); 469 registerMBeans(); 470 String relationTypeName = "relationTypeName"; 471 m_relationService.addRelationType(new SimpleRelationType(relationTypeName)); 472 Integer value = m_relationService.checkRoleReading("primary", relationTypeName); 473 assertEquals(value.intValue(), 0); 475 } 476 477 public void testRoleReading1() throws Exception 478 { 479 registerRelationService(true); 480 registerMBeans(); 481 String relationTypeName = "relationTypeName"; 482 m_relationService.addRelationType(new SimpleRelationType(relationTypeName)); 483 Integer value = m_relationService.checkRoleReading("book", relationTypeName); 484 assertEquals(value.intValue(), RoleStatus.NO_ROLE_WITH_NAME); 486 } 487 488 public void testRoleReading2() throws Exception 489 { 490 registerRelationService(true); 491 registerMBeans(); 492 String relationTypeName = "relationTypeName"; 493 m_relationService.addRelationType(new TestRelationType(relationTypeName)); 494 Integer value = m_relationService.checkRoleReading("primary", relationTypeName); 495 assertEquals(value.intValue(), RoleStatus.ROLE_NOT_READABLE); 497 } 498 499 public void testCreateRelation() throws Exception 500 { 501 registerRelationService(true); 502 registerMBeans(); 503 RoleList roleList = new RoleList (); 504 createRoleList(mbeanObjectName1, "owner", roleList); 505 createRoleList(mbeanObjectName2, "car", roleList); 506 507 508 String relationTypeName = "relationTypeName"; 509 RoleInfo [] roleInfos = createRoleInfos("car", "owner"); 510 Object [] params1 = {relationTypeName, roleInfos}; 511 String [] signature1 = {"java.lang.String", roleInfos.getClass().getName()}; 512 513 m_server.invoke(m_relationServiceObjectName, "createRelationType", params1, signature1); 514 String relationId = "relationId1"; 515 516 Object [] params = {relationId, relationTypeName, roleList}; 517 String [] 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 relationID, 522 ObjectName mbeanObjectName) throws Exception 523 { 524 registerRelationService(true); 525 registerMBeans(); 526 527 RoleList roleList = new RoleList (); 528 createRoleList(mbeanObjectName1, "owner", roleList); 529 createRoleList(mbeanObjectName2, "car", roleList); 530 531 SimpleRelationTestSupport relationSupport = new SimpleRelationTestSupport(relationID, 533 m_relationServiceObjectName, 534 "relationTypeName", 535 roleList); 536 537 m_server.registerMBean(relationSupport, mbeanObjectName); 538 539 540 try 541 { 542 m_relationService.createRelationType("relationTypeName", createRoleInfos("car", "owner")); 543 544 545 m_relationService.addRelation(mbeanObjectName); 546 } 547 catch (Exception e) 548 { 549 e.printStackTrace(); } 551 } 552 553 private void registerMBeans() 554 { 555 try 556 { 557 String mbeanClassName = "test.javax.management.relation.SimpleStandard"; 559 mbeanObjectName1 = new ObjectName ("domain:type=SimpleStandard_1"); 560 mbeanObjectName2 = new ObjectName ("domain:type=SimpleStandard_2"); 561 mbeanObjectName3 = new ObjectName ("domain:type=SimpleStandard_3"); 562 mbeanObjectName4 = new ObjectName ("domain:type=SimpleStandard_4"); 563 mbeanObjectName5 = new ObjectName ("domain:type=SimpleStandard_5"); 564 mbeanObjectName6 = new ObjectName ("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 e) 574 { 575 e.printStackTrace(); 576 } 577 } 578 579 private void registerRelationService(boolean purge) throws Exception 580 { 581 m_relationService = new RelationService (purge); 582 m_server.registerMBean(m_relationService, m_relationServiceObjectName); 583 } 584 585 private RoleInfo [] createRoleInfos(String roleName1, 586 String roleName2) throws Exception 587 { 588 RoleInfo [] roleInfos = new RoleInfo [2]; 589 roleInfos[0] = new RoleInfo (roleName1, "test.javax.management.relation.SimpleStandard", true, true, 1, -1, null); 590 roleInfos[1] = new RoleInfo (roleName2, "test.javax.management.relation.SimpleStandard", true, true, 0, -1, null); 591 return roleInfos; 592 } 593 594 private RoleList createRoleList(ObjectName mbeanObjectName, 595 String roleName, 596 RoleList roleList) 597 { 598 ArrayList roleValue = new ArrayList (); 599 roleValue.add(mbeanObjectName); 600 Role role = new Role (roleName, roleValue); 601 roleList.add(role); 602 return roleList; 603 } 604 605 class TestRelationType extends RelationTypeSupport 606 { 607 public TestRelationType(String relationTypeName) 608 { 609 super(relationTypeName); 610 try 611 { 612 RoleInfo primaryRoleInfo = new RoleInfo ("primary", 613 "test.javax.management.relation.SimpleStandard", 614 false, true, 2, 617 2, 618 "Primary :)"); 619 addRoleInfo(primaryRoleInfo); 620 621 RoleInfo secondaryRoleInfo = new RoleInfo ("secondary", 622 "test.javax.management.relation.SimpleStandard", 623 true, 624 false, 625 2, 626 2, 627 "Secondary"); 628 addRoleInfo(secondaryRoleInfo); 629 } 630 catch (Exception ex) 631 { 632 throw new RuntimeException (ex.getMessage()); 633 } 634 } 635 } 636 637 public void testSimpleRoleListCtor() throws Exception 638 { 639 registerRelationService(true); 640 registerMBeans(); 641 RoleList rl = new RoleList (); 642 assertTrue("New RoleList isn't empty", rl.isEmpty()); 643 rl = new RoleList (42); 644 assertTrue("New RoleList(42) isn't empty", rl.isEmpty()); 645 } 646 647 public void testRoleListCopyCtor() throws Exception 648 { 649 registerRelationService(true); 650 registerMBeans(); 651 RoleList rl = new RoleList (); 652 rl.add(new Role ("romeo", new ArrayList ())); 653 rl.add(new Role ("juliet", new ArrayList ())); 654 RoleList rlcopy = new RoleList (rl); 655 assertTrue("Bogus copy", rl.equals(rlcopy)); 656 657 try 658 { 659 new RoleList (null); 660 fail("Expecting IllegalArgumentException"); 661 } 662 catch (IllegalArgumentException x) 663 { 664 assertTrue(true); 665 } 666 } 667 668 public void testUpdateRoleMap() throws Exception 669 { 670 List roleValue = new ArrayList (); 671 roleValue.add(new ObjectName ("domain:type=SimpleStandard_2")); 672 Role role = new Role ("myTestRoleName", roleValue); 673 674 String relationID = "myTestRelation"; 675 setUpRelationServiceForQueryTesting(relationID, new ObjectName ("domain:type=testType")); 676 677 m_relationService.updateRoleMap("domain:type=SimpleStandard_1", role, new ArrayList ()); 678 Map 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 683 { 684 registerRelationService(true); 686 registerMBeans(); 687 688 ObjectName targetObjectName = mbeanObjectName1; 690 691 m_relationService.createRelationType("relationType1", createRoleInfos("roleName1", "roleName2")); 693 694 RoleList roleList = new RoleList (); 695 ArrayList values = new ArrayList (); 696 values.add(targetObjectName); values.add(mbeanObjectName2); 698 699 roleList.add(new Role ("roleName1", values)); 700 701 m_relationService.createRelation("relationID1", "relationType1", roleList); 703 704 roleList = new RoleList (); 705 values = new ArrayList (); 706 values.add(targetObjectName); values.add(mbeanObjectName3); 708 roleList.add(new Role ("roleName1", values)); 709 roleList.add(new Role ("roleName2", values)); 710 711 m_relationService.createRelation("relationID2", "relationType1", roleList); 713 714 Map result = m_relationService.findReferencingRelations(targetObjectName, null, null); 716 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 |