git.aero2k.de Git - tmp/jakarta-migration.git/blob

   1 /**
   2  * This document is a part of the source code and related artifacts
   3  * for CollectionSpace, an open source collections management system
   4  * for museums and related institutions:
   5  *
   6  * http://www.collectionspace.org
   7  * http://wiki.collectionspace.org
   8  *
   9  * Copyright © 2009 Regents of the University of California
  10  *
  11  * Licensed under the Educational Community License (ECL), Version 2.0.
  12  * You may not use this file except in compliance with this License.
  13  *
  14  * You may obtain a copy of the ECL 2.0 License at
  15  * https://source.collectionspace.org/collection-space/LICENSE.txt
  16  *
  17  * Unless required by applicable law or agreed to in writing, software
  18  * distributed under the License is distributed on an "AS IS" BASIS,
  19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  20  * See the License for the specific language governing permissions and
  21  * limitations under the License.
  22  */
  23 package org.collectionspace.services.account.client.test;
  24
  25 import java.util.ArrayList;
  26 import java.util.Collection;
  27 import java.util.Hashtable;
  28 import java.util.List;
  29 import javax.ws.rs.core.Response;
  30
  31 //import org.collectionspace.services.authorization.AccountRolesList;
  32 import org.collectionspace.services.account.AccountsCommon;
  33 import org.collectionspace.services.authorization.AccountRole;
  34 import org.collectionspace.services.authorization.AccountValue;
  35 import org.collectionspace.services.authorization.Role;
  36 import org.collectionspace.services.authorization.RoleValue;
  37 import org.collectionspace.services.client.AccountClient;
  38 import org.collectionspace.services.client.AccountFactory;
  39 import org.collectionspace.services.client.AccountRoleClient;
  40 import org.collectionspace.services.client.AccountRoleFactory;
  41 import org.collectionspace.services.client.CollectionSpaceClient;
  42 import org.collectionspace.services.client.RoleClient;
  43 import org.collectionspace.services.client.RoleFactory;
  44 import org.collectionspace.services.client.test.AbstractServiceTestImpl;
  45 import org.collectionspace.services.client.test.ServiceRequestType;
  46 import org.collectionspace.services.jaxb.AbstractCommonList;
  47 import org.jboss.resteasy.client.ClientResponse;
  48
  49
  50 import org.testng.Assert;
  51 import org.testng.annotations.Test;
  52
  53 import org.slf4j.Logger;
  54 import org.slf4j.LoggerFactory;
  55 import org.testng.annotations.AfterClass;
  56 import org.testng.annotations.BeforeClass;
  57
  58 /**
  59  * AccountServiceTest, carries out tests against a
  60  * deployed and running Account, Role and AccountRole Services.
  61  *
  62  * $LastChangedRevision: 917 $
  63  * $LastChangedDate: 2009-11-06 12:20:28 -0800 (Fri, 06 Nov 2009) $
  64  */
  65 public class AccountRoleServiceTest extends AbstractServiceTestImpl {
  66
  67     /** The Constant logger. */
  68     private final static String CLASS_NAME = AccountRoleServiceTest.class.getName();
  69     private final static Logger logger = LoggerFactory.getLogger(CLASS_NAME);
  70     // Instance variables specific to this test.
  71     /** The known resource id. */
  72     private String knownResourceId = null;
  73     /** The all resource ids created. */
  74     private List<String> allResourceIdsCreated = new ArrayList<String>();
  75     /** The acc values. */
  76     private Hashtable<String, AccountValue> accValues = new Hashtable<String, AccountValue>();
  77     /** The role values. */
  78     private Hashtable<String, RoleValue> roleValues = new Hashtable<String, RoleValue>();
  79     /*
  80      * This method is called only by the parent class, AbstractServiceTestImpl
  81      */
  82
  83     /* (non-Javadoc)
  84      * @see org.collectionspace.services.client.test.BaseServiceTest#getServicePathComponent()
  85      */
  86     @Override
  87     protected String getServicePathComponent() {
  88         return new AccountRoleClient().getServicePathComponent();
  89     }
  90
  91     /**
  92      * Seed data.
  93      */
  94     @BeforeClass(alwaysRun = true)
  95     public void seedData() {
  96         String userId = "acc-role-user1";
  97         String accId = createAccount(userId, "acc-role-user1-test@cspace.org");
  98         AccountValue ava = new AccountValue();
  99         ava.setScreenName(userId);
 100         ava.setUserId(userId);
 101         ava.setAccountId(accId);
 102         accValues.put(ava.getScreenName(), ava);
 103
 104         String userId2 = "acc-role-user2";
 105         String coAccId = createAccount(userId2, "acc-role-user2-test@cspace.org");
 106         AccountValue avc = new AccountValue();
 107         avc.setScreenName(userId2);
 108         avc.setUserId(userId2);
 109         avc.setAccountId(coAccId);
 110         accValues.put(avc.getScreenName(), avc);
 111
 112         String rn1 = "ROLE_CO1";
 113         String r1RoleId = createRole(rn1);
 114         RoleValue rv1 = new RoleValue();
 115         rv1.setRoleId(r1RoleId);
 116         rv1.setRoleName(rn1);
 117         roleValues.put(rv1.getRoleName(), rv1);
 118
 119         String rn2 = "ROLE_CO2";
 120         String r2RoleId = createRole(rn2);
 121         RoleValue rv2 = new RoleValue();
 122         rv2.setRoleId(r2RoleId);
 123         rv2.setRoleName(rn2);
 124         roleValues.put(rv2.getRoleName(), rv2);
 125     }
 126
 127     /* (non-Javadoc)
 128      * @see org.collectionspace.services.client.test.BaseServiceTest#getClientInstance()
 129      */
 130     @Override
 131     protected CollectionSpaceClient getClientInstance() {
 132         return new AccountRoleClient();
 133     }
 134
 135     /* (non-Javadoc)
 136      * @see org.collectionspace.services.client.test.BaseServiceTest#getAbstractCommonList(org.jboss.resteasy.client.ClientResponse)
 137      */
 138     @Override
 139     protected AbstractCommonList getAbstractCommonList(
 140             ClientResponse<AbstractCommonList> response) {
 141         //FIXME: http://issues.collectionspace.org/browse/CSPACE-1697
 142         throw new UnsupportedOperationException();
 143     }
 144
 145     /* (non-Javadoc)
 146      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#readPaginatedList(java.lang.String)
 147      */
 148     @Test(dataProvider = "testName")
 149     @Override
 150     public void readPaginatedList(String testName) throws Exception {
 151         //FIXME: http://issues.collectionspace.org/browse/CSPACE-1697
 152     }
 153
 154     // ---------------------------------------------------------------
 155     // CRUD tests : CREATE tests
 156     // ---------------------------------------------------------------
 157     // Success outcomes
 158     /* (non-Javadoc)
 159      * @see org.collectionspace.services.client.test.ServiceTest#create(java.lang.String)
 160      */
 161     @Override
 162     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
 163     public void create(String testName) throws Exception {
 164
 165         if (logger.isDebugEnabled()) {
 166             testBanner(testName, CLASS_NAME);
 167         }
 168         // Perform setup, such as initializing the type of service request
 169         // (e.g. CREATE, DELETE), its valid and expected status codes, and
 170         // its associated HTTP method name (e.g. POST, DELETE).
 171         setupCreate();
 172
 173         // Submit the request to the service and store the response.
 174         AccountValue av = accValues.get("acc-role-user1");
 175         AccountRole accRole = createAccountRoleInstance(av,
 176                 roleValues.values(), true, true);
 177         AccountRoleClient client = new AccountRoleClient();
 178         ClientResponse<Response> res = client.create(av.getAccountId(), accRole);
 179         try {
 180             int statusCode = res.getStatus();
 181
 182             if (logger.isDebugEnabled()) {
 183                 logger.debug(testName + ": status = " + statusCode);
 184             }
 185             Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 186                     invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 187             Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 188
 189             // Store the ID returned from this create operation
 190             // for additional tests below.
 191             //this is is not important in case of this relationship
 192             knownResourceId = extractId(res);
 193             if (logger.isDebugEnabled()) {
 194                 logger.debug(testName + ": knownResourceId=" + knownResourceId);
 195             }
 196         } finally {
 197             res.releaseConnection();
 198         }
 199     }
 200
 201     //to not cause uniqueness violation for accRole, createList is removed
 202     /* (non-Javadoc)
 203      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#createList(java.lang.String)
 204      */
 205     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 206     dependsOnMethods = {"create"})
 207     @Override
 208     public void createList(String testName) throws Exception {
 209         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 210     }
 211
 212     // Failure outcomes
 213     // Placeholders until the three tests below can be uncommented.
 214     // See Issue CSPACE-401.
 215     /* (non-Javadoc)
 216      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#createWithEmptyEntityBody(java.lang.String)
 217      */
 218     @Override
 219     public void createWithEmptyEntityBody(String testName) throws Exception {
 220         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 221     }
 222
 223     /* (non-Javadoc)
 224      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#createWithMalformedXml(java.lang.String)
 225      */
 226     @Override
 227     public void createWithMalformedXml(String testName) throws Exception {
 228         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 229     }
 230
 231     /* (non-Javadoc)
 232      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#createWithWrongXmlSchema(java.lang.String)
 233      */
 234     @Override
 235     public void createWithWrongXmlSchema(String testName) throws Exception {
 236         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 237     }
 238
 239     // ---------------------------------------------------------------
 240     // CRUD tests : READ tests
 241     // ---------------------------------------------------------------
 242     // Success outcomes
 243     /* (non-Javadoc)
 244      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#read(java.lang.String)
 245      */
 246     @Override
 247     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 248     dependsOnMethods = {"create"})
 249     public void read(String testName) throws Exception {
 250
 251         if (logger.isDebugEnabled()) {
 252             testBanner(testName, CLASS_NAME);
 253         }
 254
 255         // Perform setup.
 256         setupRead();
 257
 258         // Submit the request to the service and store the response.
 259         AccountRoleClient client = new AccountRoleClient();
 260         ClientResponse<AccountRole> res = client.read(
 261                 accValues.get("acc-role-user1").getAccountId());
 262         int statusCode = res.getStatus();
 263         try {
 264             // Check the status code of the response: does it match
 265             // the expected response(s)?
 266             if (logger.isDebugEnabled()) {
 267                 logger.debug(testName + ": status = " + statusCode);
 268             }
 269             Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 270                     invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 271             Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 272
 273             AccountRole output = res.getEntity();
 274             Assert.assertNotNull(output);
 275         } finally {
 276             res.releaseConnection();
 277         }
 278     }
 279
 280     // Failure outcomes
 281     /* (non-Javadoc)
 282      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#readNonExistent(java.lang.String)
 283      */
 284     @Override
 285     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
 286     public void readNonExistent(String testName) throws Exception {
 287
 288         if (logger.isDebugEnabled()) {
 289             testBanner(testName, CLASS_NAME);
 290         }
 291
 292         // Perform setup.
 293         setupReadNonExistent();
 294
 295         // Submit the request to the service and store the response.
 296         AccountRoleClient client = new AccountRoleClient();
 297         ClientResponse<AccountRole> res = client.read(this.NON_EXISTENT_ID);
 298         int statusCode = res.getStatus();
 299         try {
 300             // Check the status code of the response: does it match
 301             // the expected response(s)?
 302             if (logger.isDebugEnabled()) {
 303                 logger.debug(testName + ": status = " + statusCode);
 304             }
 305             Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 306                     invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 307             Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 308         } finally {
 309             res.releaseConnection();
 310         }
 311     }
 312
 313     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 314     dependsOnMethods = {"create"})
 315     public void readNoRelationship(String testName) throws Exception {
 316
 317         if (logger.isDebugEnabled()) {
 318             testBanner(testName, CLASS_NAME);
 319         }
 320
 321         // Perform setup.
 322         setupRead();
 323
 324         // Submit the request to the service and store the response.
 325         AccountRoleClient client = new AccountRoleClient();
 326         ClientResponse<AccountRole> res = client.read(
 327                 accValues.get("acc-role-user2").getAccountId());
 328         int statusCode = res.getStatus();
 329         try {
 330             // Check the status code of the response: does it match
 331             // the expected response(s)?
 332             if (logger.isDebugEnabled()) {
 333                 logger.debug(testName + ": status = " + statusCode);
 334             }
 335             Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 336                     invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 337             Assert.assertEquals(statusCode, Response.Status.OK.getStatusCode());
 338             AccountRole output = res.getEntity();
 339
 340             String sOutput = objectAsXmlString(output, AccountRole.class);
 341             if(logger.isDebugEnabled()) {
 342                 logger.debug(testName + " received " + sOutput);
 343             }
 344         } finally {
 345             res.releaseConnection();
 346         }
 347     }
 348
 349     // ---------------------------------------------------------------
 350     // CRUD tests : READ_LIST tests
 351     // ---------------------------------------------------------------
 352     // Success outcomes
 353     /* (non-Javadoc)
 354      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#readList(java.lang.String)
 355      */
 356     @Override
 357     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 358     dependsOnMethods = {"createList", "read"})
 359     public void readList(String testName) throws Exception {
 360         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 361     }
 362
 363     // Failure outcomes
 364     // None at present.
 365     // ---------------------------------------------------------------
 366     // CRUD tests : UPDATE tests
 367     // ---------------------------------------------------------------
 368     // Success outcomes
 369     /* (non-Javadoc)
 370      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#update(java.lang.String)
 371      */
 372     @Override
 373     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 374     dependsOnMethods = {"read", "readList", "readNonExistent"})
 375     public void update(String testName) throws Exception {
 376         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 377     }
 378
 379     // Failure outcomes
 380     // Placeholders until the three tests below can be uncommented.
 381     // See Issue CSPACE-401.
 382     /* (non-Javadoc)
 383      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#updateWithEmptyEntityBody(java.lang.String)
 384      */
 385     @Override
 386     public void updateWithEmptyEntityBody(String testName) throws Exception {
 387         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 388     }
 389
 390     /* (non-Javadoc)
 391      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#updateWithMalformedXml(java.lang.String)
 392      */
 393     @Override
 394     public void updateWithMalformedXml(String testName) throws Exception {
 395         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 396     }
 397
 398     /* (non-Javadoc)
 399      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#updateWithWrongXmlSchema(java.lang.String)
 400      */
 401     @Override
 402     public void updateWithWrongXmlSchema(String testName) throws Exception {
 403         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 404     }
 405
 406     /* (non-Javadoc)
 407      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#updateNonExistent(java.lang.String)
 408      */
 409     @Override
 410     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 411     dependsOnMethods = {"readNonExistent", "testSubmitRequest"})
 412     public void updateNonExistent(String testName) throws Exception {
 413         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 414     }
 415
 416     // ---------------------------------------------------------------
 417     // CRUD tests : DELETE tests
 418     // ---------------------------------------------------------------
 419     // Success outcomes
 420     /* (non-Javadoc)
 421      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#delete(java.lang.String)
 422      */
 423     @Override
 424     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 425     dependsOnMethods = {"read"})
 426     public void delete(String testName) throws Exception {
 427
 428         if (logger.isDebugEnabled()) {
 429             testBanner(testName, CLASS_NAME);
 430         }
 431
 432         // Perform setup.
 433         setupDelete();
 434
 435         //
 436         // Lookup a know account, and delete all of its role relationships
 437         //
 438         AccountRoleClient client = new AccountRoleClient();
 439         ClientResponse<AccountRole> readResponse = client.read(
 440                 accValues.get("acc-role-user1").getAccountId());
 441         AccountRole toDelete = null;
 442         try {
 443                 toDelete = readResponse.getEntity();
 444         } finally {
 445                 readResponse.releaseConnection();
 446         }
 447
 448         ClientResponse<Response> res = client.delete(
 449                 toDelete.getAccounts().get(0).getAccountId(), toDelete);
 450         try {
 451             int statusCode = res.getStatus();
 452             Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 453                     invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 454             Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 455         } finally {
 456             res.releaseConnection();
 457         }
 458
 459         //
 460         // recreate 'acc-role-user1' account and roles
 461         //
 462         create(testName);
 463         setupDelete();
 464
 465         //
 466         // Lookup a know account, and delete all of its role relationships
 467         //
 468         readResponse = client.read(
 469                 accValues.get("acc-role-user1").getAccountId());
 470         toDelete = null;
 471         try {
 472                 toDelete = readResponse.getEntity();
 473         } finally {
 474                 readResponse.releaseConnection();
 475         }
 476
 477         res = client.delete(toDelete.getAccounts().get(0).getAccountId());
 478         try {
 479             int statusCode = res.getStatus();
 480             Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 481                     invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 482             Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 483         } finally {
 484             res.releaseConnection();
 485         }
 486
 487     }
 488
 489     // Failure outcomes
 490     /* (non-Javadoc)
 491      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#deleteNonExistent(java.lang.String)
 492      */
 493     @Override
 494     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
 495     public void deleteNonExistent(String testName) throws Exception {
 496         //ignoring this test as the service side returns 200 now even if it does
 497         //not find a record in the db
 498     }
 499
 500     // ---------------------------------------------------------------
 501     // Utility tests : tests of code used in tests above
 502     // ---------------------------------------------------------------
 503     /**
 504      * Tests the code for manually submitting data that is used by several
 505      * of the methods above.
 506      * @throws Exception
 507      */
 508     @Test(dependsOnMethods = {"create"})
 509     public void testSubmitRequest() throws Exception {  //FIXME:  REM - This is not testing a submit /accounts/*/accountroles, but instead just to /accounts
 510
 511         // Expected status code: 200 OK
 512         final int EXPECTED_STATUS = Response.Status.OK.getStatusCode();
 513
 514         // Submit the request to the service and store the response.
 515         String method = ServiceRequestType.READ.httpMethodName();
 516         String url = getResourceURL(accValues.get("acc-role-user1").getAccountId());
 517         int statusCode = submitRequest(method, url);
 518
 519         // Check the status code of the response: does it match
 520         // the expected response(s)?
 521         if (logger.isDebugEnabled()) {
 522             logger.debug("testSubmitRequest: url=" + url
 523                     + " status=" + statusCode);
 524         }
 525         Assert.assertEquals(statusCode, EXPECTED_STATUS);
 526
 527     }
 528
 529     // ---------------------------------------------------------------
 530     // Utility methods used by tests above
 531     // ---------------------------------------------------------------
 532     /**
 533      * Creates the account role instance.
 534      *
 535      * @param av the av
 536      * @param rvs the rvs
 537      * @param usePermId the use perm id
 538      * @param useRoleId the use role id
 539      * @return the account role
 540      */
 541     static public AccountRole createAccountRoleInstance(AccountValue pv,
 542             Collection<RoleValue> rvs,
 543             boolean usePermId,
 544             boolean useRoleId) {
 545
 546         AccountRole accRole = AccountRoleFactory.createAccountRoleInstance(
 547                 pv, rvs, usePermId, useRoleId);
 548
 549         if (logger.isDebugEnabled()) {
 550             logger.debug("to be created, accRole common");
 551             logger.debug(objectAsXmlString(accRole, AccountRole.class));
 552         }
 553         return accRole;
 554     }
 555
 556     /**
 557      * Clean up.
 558      */
 559     @AfterClass(alwaysRun = true)
 560     @Override
 561     public void cleanUp() {
 562
 563         setupDelete();
 564
 565         String noTest = System.getProperty("noTestCleanup");
 566         if (Boolean.TRUE.toString().equalsIgnoreCase(noTest)) {
 567             if (logger.isDebugEnabled()) {
 568                 logger.debug("Skipping Cleanup phase ...");
 569             }
 570             return;
 571         }
 572         if (logger.isDebugEnabled()) {
 573             logger.debug("Cleaning up temporary resources created for testing ...");
 574         }
 575
 576
 577         for (AccountValue pv : accValues.values()) {
 578             deleteAccount(pv.getAccountId());
 579         }
 580
 581         for (RoleValue rv : roleValues.values()) {
 582             deleteRole(rv.getRoleId());
 583         }
 584     }
 585
 586     /**
 587      * Creates the account.
 588      *
 589      * @param userName the user name
 590      * @param email the email
 591      * @return the string
 592      */
 593     private String createAccount(String userName, String email) {
 594
 595         if (logger.isDebugEnabled()) {
 596             testBanner("createAccount");
 597         }
 598
 599         setupCreate();
 600
 601         AccountClient accClient = new AccountClient();
 602         AccountsCommon account = AccountFactory.createAccountInstance(
 603                 userName, userName, userName, email, accClient.getTenantId(),
 604                 true, false, true, true);
 605         ClientResponse<Response> res = accClient.create(account);
 606         int statusCode = res.getStatus();
 607         if (logger.isDebugEnabled()) {
 608             logger.debug("createAccount: userName=" + userName
 609                     + " status = " + statusCode);
 610         }
 611         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 612                 invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 613         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 614         res.releaseConnection();
 615         return extractId(res);
 616     }
 617
 618     /**
 619      * Delete account.
 620      *
 621      * @param accId the acc id
 622      */
 623     private void deleteAccount(String accId) {
 624
 625         if (logger.isDebugEnabled()) {
 626             testBanner("deleteAccount");
 627         }
 628
 629         setupDelete();
 630
 631         AccountClient accClient = new AccountClient();
 632         ClientResponse<Response> res = accClient.delete(accId);
 633         int statusCode = res.getStatus();
 634         try {
 635             if (logger.isDebugEnabled()) {
 636                 logger.debug("deleteAccount: delete account id="
 637                         + accId + " status=" + statusCode);
 638             }
 639             Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 640                     invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 641             Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 642         } finally {
 643             res.releaseConnection();
 644         }
 645     }
 646
 647     /**
 648      * Creates the role.
 649      *
 650      * @param roleName the role name
 651      * @return the string
 652      */
 653     private String createRole(String roleName) {
 654         if (logger.isDebugEnabled()) {
 655             testBanner("createRole");
 656         }
 657         setupCreate();
 658         RoleClient roleClient = new RoleClient();
 659
 660         Role role = RoleFactory.createRoleInstance(roleName,
 661                         roleName, //the display name
 662                 "role for " + roleName, true);
 663         ClientResponse<Response> res = roleClient.create(role);
 664         int statusCode = res.getStatus();
 665         if (logger.isDebugEnabled()) {
 666             logger.debug("createRole: name=" + roleName
 667                     + " status = " + statusCode);
 668         }
 669         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 670                 invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 671         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 672         res.releaseConnection();
 673         return extractId(res);
 674     }
 675
 676     /**
 677      * Delete role.
 678      *
 679      * @param roleId the role id
 680      */
 681     private void deleteRole(String roleId) {
 682         if (logger.isDebugEnabled()) {
 683             testBanner("deleteRole");
 684         }
 685         setupDelete();
 686         RoleClient roleClient = new RoleClient();
 687         ClientResponse<Response> res = roleClient.delete(roleId);
 688         int statusCode = res.getStatus();
 689         try {
 690             if (logger.isDebugEnabled()) {
 691                 logger.debug("deleteRole: delete role id=" + roleId
 692                         + " status=" + statusCode);
 693             }
 694             Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 695                     invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 696             Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 697         } finally {
 698             res.releaseConnection();
 699         }
 700     }
 701
 702         @Override
 703         protected String getServiceName() {
 704                 // AccountRoles service is a sub-service of the Account service, so we return Account's service name
 705                 return AccountClient.SERVICE_NAME;
 706         }
 707 }