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     // Search tests
 438     // ---------------------------------------------------------------
 439
 440     @Override
 441     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
 442     public void searchWorkflowDeleted(String testName) throws Exception {
 443         // Fixme: null test for now, overriding test in base class
 444     }
 445
 446     // ---------------------------------------------------------------
 447     // Utility methods used by tests above
 448     // ---------------------------------------------------------------
 449     /**
 450      * Creates the collection object instance.
 451      *
 452      * @param commonPartName the common part name
 453      * @param identifier the identifier
 454      *
 455      * @return the multipart output
 456      */
 457     private PoxPayloadOut createCollectionObjectInstance(
 458             String commonPartName, String identifier) {
 459         return createCollectionObjectInstance(commonPartName, "objectNumber-"
 460                 + identifier, "title-" + identifier);
 461     }
 462
 463     /**
 464      * Creates the collection object instance.
 465      *
 466      * @param commonPartName the common part name
 467      * @param objectNumber the object number
 468      * @param title the object title
 469      *
 470      * @return the multipart output
 471      */
 472     private PoxPayloadOut createCollectionObjectInstance(
 473             String commonPartName, String objectNumber, String title) {
 474         CollectionobjectsCommon collectionObject = new CollectionobjectsCommon();
 475
 476         collectionObject.setObjectNumber(objectNumber);
 477         TitleGroupList titleGroupList = new TitleGroupList();
 478         List<TitleGroup> titleGroups = titleGroupList.getTitleGroup();
 479         TitleGroup titleGroup = new TitleGroup();
 480         titleGroup.setTitle(title);
 481         titleGroups.add(titleGroup);
 482         collectionObject.setTitleGroupList(titleGroupList);
 483         PoxPayloadOut multipart =
 484                 CollectionObjectFactory.createCollectionObjectInstance(
 485                 commonPartName, collectionObject, null, null);
 486
 487         if (logger.isDebugEnabled()) {
 488             logger.debug("to be created, collectionobject common ",
 489                     collectionObject, CollectionobjectsCommon.class);
 490         }
 491         return multipart;
 492     }
 493
 494     private AccountsCommon createAccountInstance(String screenName,
 495             String passwd, String email, String tenantId, boolean invalidTenant) {
 496
 497         AccountsCommon account = AccountFactory.createAccountInstance(screenName,
 498                 screenName, passwd, email, tenantId,
 499                 true, invalidTenant, true, true);
 500
 501         List<AccountTenant> atl = account.getTenants();
 502
 503         //disable 2nd tenant till tenant identification is in effect
 504         //on the service side for 1-n user-tenants
 505 //        AccountsCommon.Tenant at2 = new AccountsCommon.Tenant();
 506 //        at2.setId(UUID.randomUUID().toString());
 507 //        at2.setName("collectionspace.org");
 508 //        atl.add(at2);
 509 //        account.setTenants(atl);
 510
 511         if (logger.isDebugEnabled()) {
 512             logger.debug("to be created, account common");
 513             logger.debug(objectAsXmlString(account,
 514                     AccountsCommon.class));
 515         }
 516         return account;
 517
 518     }
 519
 520     /* (non-Javadoc)
 521      * @see org.collectionspace.services.client.test.AbstractServiceTest#createList()
 522      */
 523     @Override
 524     public void createList(String testName) throws Exception {
 525         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 526     }
 527
 528     /* (non-Javadoc)
 529      * @see org.collectionspace.services.client.test.AbstractServiceTest#createWithEmptyEntityBody()
 530      */
 531     @Override
 532     public void createWithEmptyEntityBody(String testName) throws Exception {
 533         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 534     }
 535
 536     /* (non-Javadoc)
 537      * @see org.collectionspace.services.client.test.AbstractServiceTest#createWithMalformedXml()
 538      */
 539     @Override
 540     public void createWithMalformedXml(String testName) throws Exception {
 541         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 542     }
 543
 544     /* (non-Javadoc)
 545      * @see org.collectionspace.services.client.test.AbstractServiceTest#createWithWrongXmlSchema()
 546      */
 547     @Override
 548     public void createWithWrongXmlSchema(String testName) throws Exception {
 549         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 550     }
 551
 552     /* (non-Javadoc)
 553      * @see org.collectionspace.services.client.test.AbstractServiceTest#read()
 554      */
 555     @Override
 556     public void read(String testName) throws Exception {
 557         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 558     }
 559
 560     /* (non-Javadoc)
 561      * @see org.collectionspace.services.client.test.AbstractServiceTest#readNonExistent()
 562      */
 563     @Override
 564     public void readNonExistent(String testName) throws Exception {
 565         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 566     }
 567
 568     /* (non-Javadoc)
 569      * @see org.collectionspace.services.client.test.AbstractServiceTest#readList()
 570      */
 571     @Override
 572     public void readList(String testName) throws Exception {
 573         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 574     }
 575
 576     /* (non-Javadoc)
 577      * @see org.collectionspace.services.client.test.AbstractServiceTest#update()
 578      */
 579     @Override
 580     public void update(String testName) throws Exception {
 581         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 582     }
 583
 584     /* (non-Javadoc)
 585      * @see org.collectionspace.services.client.test.AbstractServiceTest#updateWithEmptyEntityBody()
 586      */
 587     @Override
 588     public void updateWithEmptyEntityBody(String testName) throws Exception {
 589         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 590     }
 591
 592     /* (non-Javadoc)
 593      * @see org.collectionspace.services.client.test.AbstractServiceTest#updateWithMalformedXml()
 594      */
 595     @Override
 596     public void updateWithMalformedXml(String testName) throws Exception {
 597         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 598     }
 599
 600     /* (non-Javadoc)
 601      * @see org.collectionspace.services.client.test.AbstractServiceTest#updateWithWrongXmlSchema()
 602      */
 603     @Override
 604     public void updateWithWrongXmlSchema(String testName) throws Exception {
 605         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 606     }
 607
 608     /* (non-Javadoc)
 609      * @see org.collectionspace.services.client.test.AbstractServiceTest#updateNonExistent()
 610      */
 611     @Override
 612     public void updateNonExistent(String testName) throws Exception {
 613         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 614     }
 615
 616     /* (non-Javadoc)
 617      * @see org.collectionspace.services.client.test.AbstractServiceTest#deleteNonExistent()
 618      */
 619     @Override
 620     public void deleteNonExistent(String testName) throws Exception {
 621         //FIXME: Should this test really be empty?  If so, please comment accordingly.
 622     }
 623 }