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 (c)) 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.security.client.test;
  24
  25 import java.util.List;
  26
  27 import javax.ws.rs.core.Response;
  28
  29 //import org.apache.commons.codec.binary.Base64;
  30 import org.jboss.resteasy.client.ClientResponse;
  31 import org.jboss.resteasy.plugins.providers.multipart.MultipartOutput;
  32
  33 import org.testng.Assert;
  34 import org.testng.annotations.Test;
  35
  36 import org.collectionspace.services.account.AccountTenant;
  37 import org.collectionspace.services.account.AccountsCommon;
  38 import org.collectionspace.services.account.Status;
  39 import org.collectionspace.services.client.AccountClient;
  40 import org.collectionspace.services.client.AccountFactory;
  41 import org.collectionspace.services.client.CollectionObjectClient;
  42 import org.collectionspace.services.client.CollectionObjectFactory;
  43 import org.collectionspace.services.client.CollectionSpaceClient;
  44 import org.collectionspace.services.client.PoxPayloadOut;
  45 import org.collectionspace.services.client.test.AbstractServiceTestImpl;
  46 import org.collectionspace.services.client.test.BaseServiceTest;
  47 import org.collectionspace.services.collectionobject.CollectionobjectsCommon;
  48 import org.collectionspace.services.collectionobject.TitleGroup;
  49 import org.collectionspace.services.collectionobject.TitleGroupList;
  50 import org.collectionspace.services.jaxb.AbstractCommonList;
  51
  52 import org.slf4j.Logger;
  53 import org.slf4j.LoggerFactory;
  54
  55 /**
  56  * AuthenticationServiceTest uses CollectionObject service to test
  57  * authentication
  58  *
  59  * $LastChangedRevision: 434 $ $LastChangedDate: 2009-07-28 14:34:15 -0700 (Tue,
  60  * 28 Jul 2009) $
  61  */
  62 public class AuthenticationServiceTest extends AbstractServiceTestImpl {
  63
  64     /** The known resource id. */
  65     private String knownResourceId = null;
  66     private String barneyAccountId = null; //active
  67     private String georgeAccountId = null; //inactive
  68     /** The logger. */
  69     private final String CLASS_NAME = AuthenticationServiceTest.class.getName();
  70     private final Logger logger = LoggerFactory.getLogger(CLASS_NAME);
  71
  72     /* (non-Javadoc)
  73      * @see org.collectionspace.services.client.test.AbstractServiceTest#getServicePathComponent()
  74      */
  75     @Override
  76     protected String getServicePathComponent() {
  77         // no need to return anything but null since no auth resources are
  78         // accessed
  79         throw new UnsupportedOperationException();
  80     }
  81
  82         @Override
  83         protected String getServiceName() {
  84         // no need to return anything but null since no auth resources are
  85         // accessed
  86         throw new UnsupportedOperationException();
  87         }
  88
  89     /* (non-Javadoc)
  90      * @see org.collectionspace.services.client.test.BaseServiceTest#getClientInstance()
  91      */
  92     @Override
  93     protected CollectionSpaceClient getClientInstance() {
  94         return new AccountClient();
  95     }
  96
  97     /* (non-Javadoc)
  98      * @see org.collectionspace.services.client.test.BaseServiceTest#getAbstractCommonList(org.jboss.resteasy.client.ClientResponse)
  99      */
 100     @Override
 101     protected AbstractCommonList getAbstractCommonList(
 102             ClientResponse<AbstractCommonList> response) {
 103         throw new UnsupportedOperationException(); //Since this test does not support lists, this method is not needed.
 104     }
 105
 106     @Test(dataProvider = "testName")
 107     @Override
 108     public void readPaginatedList(String testName) throws Exception {
 109         // Test not supported.
 110     }
 111
 112     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
 113     public void createActiveAccount(String testName) throws Exception {
 114
 115         if (logger.isDebugEnabled()) {
 116             logger.debug(testBanner(testName, CLASS_NAME));
 117         }
 118         // Perform setup, such as initializing the type of service request
 119         // (e.g. CREATE, DELETE), its valid and expected status codes, and
 120         // its associated HTTP method name (e.g. POST, DELETE).
 121         setupCreate();
 122
 123         AccountClient accountClient = new AccountClient();
 124         // This should not be needed - the auth is already set up
 125         //accountClient.setAuth(true, "test", true, "test", true);
 126
 127         // Submit the request to the service and store the response.
 128         AccountsCommon account =
 129                 createAccountInstance("barney", "barney08", "barney@dinoland.com",
 130                 accountClient.getTenantId(), false);
 131         ClientResponse<Response> res = accountClient.create(account);
 132         int statusCode = res.getStatus();
 133
 134         if (logger.isDebugEnabled()) {
 135             logger.debug(testName + ": barney status = " + statusCode);
 136         }
 137         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 138                 invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 139         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 140
 141         // Store the ID returned from this create operation
 142         // for additional tests below.
 143         barneyAccountId = extractId(res);
 144         if (logger.isDebugEnabled()) {
 145             logger.debug(testName + ": barneyAccountId=" + barneyAccountId);
 146         }
 147         res.releaseConnection();
 148
 149     }
 150
 151     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
 152     public void createInactiveAccount(String testName) throws Exception {
 153
 154         if (logger.isDebugEnabled()) {
 155             logger.debug(testBanner(testName, CLASS_NAME));
 156         }
 157         // Perform setup.
 158         setupCreate();
 159
 160         AccountClient accountClient = new AccountClient();
 161         // This should not be needed - the auth is already set up
 162         //accountClient.setAuth(true, "test", true, "test", true);
 163
 164         // Submit the request to the service and store the response.
 165         AccountsCommon account =
 166                 createAccountInstance("george", "george08", "george@curiousland.com",
 167                 accountClient.getTenantId(), false);
 168         ClientResponse<Response> res = accountClient.create(account);
 169         int statusCode = res.getStatus();
 170
 171         if (logger.isDebugEnabled()) {
 172             logger.debug(testName + ": george status = " + statusCode);
 173         }
 174         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 175                 invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 176         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 177
 178         // Store the ID returned from this create operation
 179         // for additional tests below.
 180         georgeAccountId = extractId(res);
 181         if (logger.isDebugEnabled()) {
 182             logger.debug(testName + ": georgeAccountId=" + georgeAccountId);
 183         }
 184         res.releaseConnection();
 185         //deactivate
 186         setupUpdate();
 187         account.setStatus(Status.INACTIVE);
 188         if (logger.isDebugEnabled()) {
 189             logger.debug(testName + ":updated object");
 190             logger.debug(objectAsXmlString(account,
 191                     AccountsCommon.class));
 192         }
 193
 194         // Submit the request to the service and store the response.
 195         ClientResponse<AccountsCommon> res1 = accountClient.update(georgeAccountId, account);
 196         statusCode = res1.getStatus();
 197         // Check the status code of the response: does it match the expected response(s)?
 198         if (logger.isDebugEnabled()) {
 199             logger.debug(testName + ": status = " + statusCode);
 200         }
 201         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 202                 invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 203         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 204         res1.releaseConnection();
 205     }
 206
 207
 208     /* (non-Javadoc)
 209      * @see org.collectionspace.services.client.test.AbstractServiceTest#create()
 210      */
 211     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 212     dependsOnMethods = {"createActiveAccount"})
 213     @Override
 214     public void create(String testName) {
 215         if (logger.isDebugEnabled()) {
 216             logger.debug(testBanner(testName, CLASS_NAME));
 217         }
 218         setupCreate();
 219         CollectionObjectClient collectionObjectClient = new CollectionObjectClient();
 220         collectionObjectClient.setAuth(true, "barney", true, "barney08", true);
 221         String identifier = BaseServiceTest.createIdentifier();
 222         PoxPayloadOut multipart = createCollectionObjectInstance(
 223                 collectionObjectClient.getCommonPartName(), identifier);
 224         ClientResponse<Response> res = collectionObjectClient.create(multipart);
 225         if (logger.isDebugEnabled()) {
 226             logger.debug("create: status = " + res.getStatus());
 227         }
 228         //so it does not have any permissions out-of-the-box to create a
 229         //collection object
 230         Assert.assertEquals(res.getStatus(),
 231                 Response.Status.FORBIDDEN.getStatusCode(), "expected "
 232                 + Response.Status.FORBIDDEN.getStatusCode());
 233
 234         // Store the ID returned from this create operation for additional tests
 235         // below.
 236         res.releaseConnection();
 237
 238     }
 239
 240     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 241     dependsOnMethods = {"createActiveAccount"})
 242     public void createWithoutAuthn(String testName) {
 243         if (logger.isDebugEnabled()) {
 244             logger.debug(testBanner(testName, CLASS_NAME));
 245         }
 246         setupCreate();
 247         CollectionObjectClient collectionObjectClient = new CollectionObjectClient();
 248         String user = collectionObjectClient.getProperty(collectionObjectClient.USER_PROPERTY);
 249         String pass = collectionObjectClient.getProperty(collectionObjectClient.PASSWORD_PROPERTY);
 250         collectionObjectClient.setAuth(false, user, true, pass, true);
 251         String identifier = BaseServiceTest.createIdentifier();
 252         PoxPayloadOut multipart = createCollectionObjectInstance(
 253                 collectionObjectClient.getCommonPartName(), identifier);
 254         ClientResponse<Response> res = collectionObjectClient.create(multipart);
 255         if (logger.isDebugEnabled()) {
 256             logger.debug("create: status = " + res.getStatus());
 257         }
 258         Assert.assertEquals(res.getStatus(),
 259                 Response.Status.UNAUTHORIZED.getStatusCode(), "expected "
 260                 + Response.Status.UNAUTHORIZED.getStatusCode());
 261         res.releaseConnection();
 262
 263     }
 264
 265     @Test(dataProvider = "testName", dependsOnMethods = {"createInactiveAccount"})
 266     public void createWithInactiveAccount(String testName) {
 267         if (logger.isDebugEnabled()) {
 268             logger.debug(testBanner(testName));
 269         }
 270         CollectionObjectClient collectionObjectClient = new CollectionObjectClient();
 271         collectionObjectClient.setAuth(true, "george", true, "george08", true);
 272         String identifier = BaseServiceTest.createIdentifier();
 273         PoxPayloadOut multipart = createCollectionObjectInstance(
 274                 collectionObjectClient.getCommonPartName(), identifier);
 275
 276         ClientResponse<Response> res = collectionObjectClient.create(multipart);
 277         if (logger.isDebugEnabled()) {
 278             logger.debug(testName + ": status = " + res.getStatus());
 279         }
 280         Assert.assertEquals(res.getStatus(),
 281                 Response.Status.FORBIDDEN.getStatusCode(), "expected "
 282                 + Response.Status.FORBIDDEN.getStatusCode());
 283         res.releaseConnection();
 284     }
 285
 286     /**
 287      * Creates the collection object instance without password.
 288      */
 289     @Test(dataProvider = "testName", dependsOnMethods = {"createActiveAccount"})
 290     public void createWithoutPassword(String testName) {
 291         if (logger.isDebugEnabled()) {
 292             logger.debug(testBanner(testName));
 293         }
 294         CollectionObjectClient collectionObjectClient = new CollectionObjectClient();
 295         String user = collectionObjectClient.getProperty(collectionObjectClient.USER_PROPERTY);
 296         collectionObjectClient.setAuth(true, user, true, "", false);
 297         String identifier = BaseServiceTest.createIdentifier();
 298         PoxPayloadOut multipart = createCollectionObjectInstance(
 299                 collectionObjectClient.getCommonPartName(), identifier);
 300         ClientResponse<Response> res = collectionObjectClient.create(multipart);
 301         if (logger.isDebugEnabled()) {
 302             logger.debug(testName + ": status = " + res.getStatus());
 303         }
 304         Assert.assertEquals(res.getStatus(), Response.Status.UNAUTHORIZED.getStatusCode(), "expected " + Response.Status.UNAUTHORIZED.getStatusCode());
 305         res.releaseConnection();
 306     }
 307
 308     /**
 309      * Creates the collection object with unknown user
 310      */
 311     @Test(dataProvider = "testName", dependsOnMethods = {"createActiveAccount"})
 312     public void createWithUnknownUser(String testName) {
 313         if (logger.isDebugEnabled()) {
 314             logger.debug(testBanner(testName));
 315         }
 316         CollectionObjectClient collectionObjectClient = new CollectionObjectClient();
 317         collectionObjectClient.setAuth(true, "foo", true, "bar", true);
 318         String identifier = BaseServiceTest.createIdentifier();
 319         PoxPayloadOut multipart = createCollectionObjectInstance(
 320                 collectionObjectClient.getCommonPartName(), identifier);
 321         ClientResponse<Response> res = collectionObjectClient.create(multipart);
 322         if (logger.isDebugEnabled()) {
 323             logger.debug(testName + ": status = " + res.getStatus());
 324         }
 325         Assert.assertEquals(res.getStatus(), Response.Status.UNAUTHORIZED.getStatusCode(), "expected " + Response.Status.UNAUTHORIZED.getStatusCode());
 326         res.releaseConnection();
 327     }
 328
 329     /**
 330      * Creates the collection object instance with incorrect password.
 331      */
 332     @Test(dataProvider = "testName", dependsOnMethods = {"createActiveAccount"})
 333     public void createWithIncorrectPassword(String testName) {
 334         if (logger.isDebugEnabled()) {
 335             logger.debug(testBanner(testName));
 336         }
 337         CollectionObjectClient collectionObjectClient = new CollectionObjectClient();
 338         String user = collectionObjectClient.getProperty(collectionObjectClient.USER_PROPERTY);
 339         collectionObjectClient.setAuth(true, user, true, "bar", true);
 340         String identifier = BaseServiceTest.createIdentifier();
 341         PoxPayloadOut multipart = createCollectionObjectInstance(
 342                 collectionObjectClient.getCommonPartName(), identifier);
 343         ClientResponse<Response> res = collectionObjectClient.create(multipart);
 344         if (logger.isDebugEnabled()) {
 345             logger.debug(testName + ": status = " + res.getStatus());
 346         }
 347         Assert.assertEquals(res.getStatus(), Response.Status.UNAUTHORIZED.getStatusCode(), "expected " + Response.Status.UNAUTHORIZED.getStatusCode());
 348         res.releaseConnection();
 349     }
 350
 351     /**
 352      * Creates the collection object instance with incorrect user password.
 353      */
 354     @Test(dataProvider = "testName", dependsOnMethods = {"createActiveAccount"})
 355     public void createWithIncorrectUserPassword(String testName) {
 356         if (logger.isDebugEnabled()) {
 357             logger.debug(testBanner(testName));
 358         }
 359         CollectionObjectClient collectionObjectClient = new CollectionObjectClient();
 360         collectionObjectClient.setAuth(true, "foo", true, "bar", true);
 361         String identifier = BaseServiceTest.createIdentifier();
 362         PoxPayloadOut multipart = createCollectionObjectInstance(
 363                 collectionObjectClient.getCommonPartName(), identifier);
 364         ClientResponse<Response> res = collectionObjectClient.create(multipart);
 365         if (logger.isDebugEnabled()) {
 366             logger.debug(testName + ": status = "
 367                     + res.getStatus());
 368         }
 369         Assert.assertEquals(res.getStatus(), Response.Status.UNAUTHORIZED.getStatusCode(), "expected " + Response.Status.UNAUTHORIZED.getStatusCode());
 370         res.releaseConnection();
 371     }
 372
 373     /**
 374      * Creates the collection object instance with incorrect user password.
 375      */
 376     @Test(dataProvider = "testName", dependsOnMethods = {"createActiveAccount"})
 377     public void createWithoutTenant(String testName) {
 378         if (logger.isDebugEnabled()) {
 379             logger.debug(testBanner(testName));
 380         }
 381         CollectionObjectClient collectionObjectClient = new CollectionObjectClient();
 382         collectionObjectClient.setAuth(true, "babybop", true, "babybop09", true);
 383         String identifier = BaseServiceTest.createIdentifier();
 384         PoxPayloadOut multipart = createCollectionObjectInstance(
 385                 collectionObjectClient.getCommonPartName(), identifier);
 386         ClientResponse<Response> res = collectionObjectClient.create(multipart);
 387         if (logger.isDebugEnabled()) {
 388             logger.debug(testName + ": status = "
 389                     + res.getStatus());
 390         }
 391         Assert.assertEquals(res.getStatus(), Response.Status.UNAUTHORIZED.getStatusCode(), "expected " + Response.Status.UNAUTHORIZED.getStatusCode());
 392         res.releaseConnection();
 393     }
 394
 395     /* (non-Javadoc)
 396      * @see org.collectionspace.services.client.test.AbstractServiceTest#delete()
 397      */
 398     @Override
 399     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 400     dependsOnMethods = {"create"})
 401     public void delete(String testName) {
 402         setupDelete();
 403
 404     }
 405
 406     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 407     dependsOnMethods = {"create", "createWithInactiveAccount"})
 408     public void deleteAccounts(String testName) throws Exception {
 409
 410         if (logger.isDebugEnabled()) {
 411             logger.debug(testBanner(testName, CLASS_NAME));
 412         }
 413         // Perform setup.
 414         setupDelete();
 415         AccountClient accountClient = new AccountClient();
 416         // accountClient.setAuth(true, "test", true, "test", true);
 417         // Submit the request to the service and store the response.
 418         ClientResponse<Response> res = accountClient.delete(barneyAccountId);
 419         int statusCode = res.getStatus();
 420         if (logger.isDebugEnabled()) {
 421             logger.debug(testName + ": barney status = " + statusCode);
 422         }
 423         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 424                 invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 425
 426         res = accountClient.delete(georgeAccountId);
 427         statusCode = res.getStatus();
 428         if (logger.isDebugEnabled()) {
 429             logger.debug(testName + ": george status = " + statusCode);
 430         }
 431         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 432                 invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 433         res.releaseConnection();
 434     }
 435
 436     // ---------------------------------------------------------------
 437     // Utility methods used by tests above
 438     // ---------------------------------------------------------------
 439     /**
 440      * Creates the collection object instance.
 441      *
 442      * @param commonPartName the common part name
 443      * @param identifier the identifier
 444      *
 445      * @return the multipart output
 446      */
 447     private PoxPayloadOut createCollectionObjectInstance(
 448             String commonPartName, String identifier) {
 449         return createCollectionObjectInstance(commonPartName, "objectNumber-"
 450                 + identifier, "title-" + identifier);
 451     }
 452
 453     /**
 454      * Creates the collection object instance.
 455      *
 456      * @param commonPartName the common part name
 457      * @param objectNumber the object number
 458      * @param title the object title
 459      *
 460      * @return the multipart output
 461      */
 462     private PoxPayloadOut createCollectionObjectInstance(
 463             String commonPartName, String objectNumber, String title) {
 464         CollectionobjectsCommon collectionObject = new CollectionobjectsCommon();
 465
 466         collectionObject.setObjectNumber(objectNumber);
 467         TitleGroupList titleGroupList = new TitleGroupList();
 468         List<TitleGroup> titleGroups = titleGroupList.getTitleGroup();
 469         TitleGroup titleGroup = new TitleGroup();
 470         titleGroup.setTitle(title);
 471         titleGroups.add(titleGroup);
 472         collectionObject.setTitleGroupList(titleGroupList);
 473         PoxPayloadOut multipart =
 474                 CollectionObjectFactory.createCollectionObjectInstance(
 475                 commonPartName, collectionObject, null, null);
 476
 477         if (logger.isDebugEnabled()) {
 478             logger.debug("to be created, collectionobject common ",
 479                     collectionObject, CollectionobjectsCommon.class);
 480         }
 481         return multipart;
 482     }
 483
 484     private AccountsCommon createAccountInstance(String screenName,
 485             String passwd, String email, String tenantId, boolean invalidTenant) {
 486
 487         AccountsCommon account = AccountFactory.createAccountInstance(screenName,
 488                 screenName, passwd, email, tenantId,
 489                 true, invalidTenant, true, true);
 490
 491         List<AccountTenant> atl = account.getTenants();
 492
 493         //disable 2nd tenant till tenant identification is in effect
 494         //on the service side for 1-n user-tenants
 495 //        AccountsCommon.Tenant at2 = new AccountsCommon.Tenant();
 496 //        at2.setId(UUID.randomUUID().toString());
 497 //        at2.setName("collectionspace.org");
 498 //        atl.add(at2);
 499 //        account.setTenants(atl);
 500
 501         if (logger.isDebugEnabled()) {
 502             logger.debug("to be created, account common");
 503             logger.debug(objectAsXmlString(account,
 504                     AccountsCommon.class));
 505         }
 506         return account;
 507
 508     }
 509
 510     /* (non-Javadoc)
 511      * @see org.collectionspace.services.client.test.AbstractServiceTest#createList()
 512      */
 513     @Override
 514     public void createList(String testName) throws Exception {
 515         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 516     }
 517
 518     /* (non-Javadoc)
 519      * @see org.collectionspace.services.client.test.AbstractServiceTest#createWithEmptyEntityBody()
 520      */
 521     @Override
 522     public void createWithEmptyEntityBody(String testName) throws Exception {
 523         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 524     }
 525
 526     /* (non-Javadoc)
 527      * @see org.collectionspace.services.client.test.AbstractServiceTest#createWithMalformedXml()
 528      */
 529     @Override
 530     public void createWithMalformedXml(String testName) throws Exception {
 531         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 532     }
 533
 534     /* (non-Javadoc)
 535      * @see org.collectionspace.services.client.test.AbstractServiceTest#createWithWrongXmlSchema()
 536      */
 537     @Override
 538     public void createWithWrongXmlSchema(String testName) throws Exception {
 539         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 540     }
 541
 542     /* (non-Javadoc)
 543      * @see org.collectionspace.services.client.test.AbstractServiceTest#read()
 544      */
 545     @Override
 546     public void read(String testName) throws Exception {
 547         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 548     }
 549
 550     /* (non-Javadoc)
 551      * @see org.collectionspace.services.client.test.AbstractServiceTest#readNonExistent()
 552      */
 553     @Override
 554     public void readNonExistent(String testName) throws Exception {
 555         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 556     }
 557
 558     /* (non-Javadoc)
 559      * @see org.collectionspace.services.client.test.AbstractServiceTest#readList()
 560      */
 561     @Override
 562     public void readList(String testName) throws Exception {
 563         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 564     }
 565
 566     /* (non-Javadoc)
 567      * @see org.collectionspace.services.client.test.AbstractServiceTest#update()
 568      */
 569     @Override
 570     public void update(String testName) throws Exception {
 571         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 572     }
 573
 574     /* (non-Javadoc)
 575      * @see org.collectionspace.services.client.test.AbstractServiceTest#updateWithEmptyEntityBody()
 576      */
 577     @Override
 578     public void updateWithEmptyEntityBody(String testName) throws Exception {
 579         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 580     }
 581
 582     /* (non-Javadoc)
 583      * @see org.collectionspace.services.client.test.AbstractServiceTest#updateWithMalformedXml()
 584      */
 585     @Override
 586     public void updateWithMalformedXml(String testName) throws Exception {
 587         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 588     }
 589
 590     /* (non-Javadoc)
 591      * @see org.collectionspace.services.client.test.AbstractServiceTest#updateWithWrongXmlSchema()
 592      */
 593     @Override
 594     public void updateWithWrongXmlSchema(String testName) throws Exception {
 595         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 596     }
 597
 598     /* (non-Javadoc)
 599      * @see org.collectionspace.services.client.test.AbstractServiceTest#updateNonExistent()
 600      */
 601     @Override
 602     public void updateNonExistent(String testName) throws Exception {
 603         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 604     }
 605
 606     /* (non-Javadoc)
 607      * @see org.collectionspace.services.client.test.AbstractServiceTest#deleteNonExistent()
 608      */
 609     @Override
 610     public void deleteNonExistent(String testName) throws Exception {
 611         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 612     }
 613 }