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.client.test;
  24
  25 import java.util.List;
  26 import javax.ws.rs.core.MediaType;
  27 import javax.ws.rs.core.Response;
  28
  29 import org.collectionspace.services.client.AbstractCommonListUtils;
  30 import org.collectionspace.services.client.AcquisitionClient;
  31 import org.collectionspace.services.client.CollectionSpaceClient;
  32 import org.collectionspace.services.client.PayloadOutputPart;
  33 import org.collectionspace.services.client.PoxPayloadIn;
  34 import org.collectionspace.services.client.PoxPayloadOut;
  35 import org.collectionspace.services.common.api.GregorianCalendarDateTimeUtils;
  36 import org.collectionspace.services.jaxb.AbstractCommonList;
  37
  38 import org.collectionspace.services.acquisition.AcquisitionsCommon;
  39 import org.collectionspace.services.acquisition.AcquisitionDateGroupList;
  40 import org.collectionspace.services.acquisition.AcquisitionSourceList;
  41 import org.collectionspace.services.acquisition.OwnerList;
  42 import org.jboss.resteasy.client.ClientResponse;
  43 import org.collectionspace.services.acquisition.StructuredDateGroup;
  44
  45 import org.testng.Assert;
  46 import org.testng.annotations.Test;
  47
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 /**
  52  * AcquisitionServiceTest, carries out tests against a
  53  * deployed and running Acquisition Service.
  54  *
  55  * $LastChangedRevision: 621 $
  56  * $LastChangedDate: 2009-09-02 16:49:01 -0700 (Wed, 02 Sep 2009) $
  57  */
  58 public class AcquisitionServiceTest extends AbstractPoxServiceTestImpl<AbstractCommonList, AcquisitionsCommon> {
  59
  60     /** The logger. */
  61     private final String CLASS_NAME = AcquisitionServiceTest.class.getName();
  62     private final Logger logger = LoggerFactory.getLogger(CLASS_NAME);
  63
  64     // Instance variables specific to this test.
  65     private final static String CURRENT_DATE_UTC =
  66             GregorianCalendarDateTimeUtils.timestampUTC();
  67
  68     @Override
  69     public String getServicePathComponent() {
  70         return AcquisitionClient.SERVICE_PATH_COMPONENT;
  71     }
  72
  73     @Override
  74     protected String getServiceName() {
  75         return AcquisitionClient.SERVICE_NAME;
  76     }
  77
  78     /* (non-Javadoc)
  79      * @see org.collectionspace.services.client.test.BaseServiceTest#getClientInstance()
  80      */
  81     @Override
  82     protected CollectionSpaceClient getClientInstance() {
  83         return new AcquisitionClient();
  84     }
  85
  86     // ---------------------------------------------------------------
  87     // CRUD tests : CREATE tests
  88     // ---------------------------------------------------------------
  89     // Success outcomes
  90     /* (non-Javadoc)
  91      * @see org.collectionspace.services.client.test.ServiceTest#create(java.lang.String)
  92      */
  93     @Override
  94 //    @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class)
  95     public void create(String testName) throws Exception {
  96         // Perform setup, such as initializing the type of service request
  97         // (e.g. CREATE, DELETE), its valid and expected status codes, and
  98         // its associated HTTP method name (e.g. POST, DELETE).
  99         setupCreate();
 100
 101         // Submit the request to the service and store the response.
 102         String identifier = createIdentifier();
 103
 104         AcquisitionClient client = new AcquisitionClient();
 105         PoxPayloadOut multipart = createAcquisitionInstance(identifier);
 106         Response res = client.create(multipart);
 107
 108         int statusCode = res.getStatus();
 109
 110         // Check the status code of the response: does it match
 111         // the expected response(s)?
 112         //
 113         // Specifically:
 114         // Does it fall within the set of valid status codes?
 115         // Does it exactly match the expected status code?
 116         if(logger.isDebugEnabled()){
 117             logger.debug(testName + ": status = " + statusCode);
 118         }
 119         Assert.assertTrue(testRequestType.isValidStatusCode(statusCode),
 120                 invalidStatusCodeMessage(testRequestType, statusCode));
 121         Assert.assertEquals(statusCode, testExpectedStatusCode);
 122
 123         // Store the ID returned from the first resource created
 124         // for additional tests below.
 125         if (knownResourceId == null){
 126             knownResourceId = extractId(res);
 127             if (logger.isDebugEnabled()) {
 128                 logger.debug(testName + ": knownResourceId=" + knownResourceId);
 129             }
 130         }
 131
 132         // Store the IDs from every resource created by tests,
 133         // so they can be deleted after tests have been run.
 134         allResourceIdsCreated.add(extractId(res));
 135     }
 136
 137     /* (non-Javadoc)
 138      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#createList(java.lang.String)
 139      */
 140     @Override
 141 //    @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
 142 //       dependsOnMethods = {"create"})
 143     public void createList(String testName) throws Exception {
 144         for(int i = 0; i < 3; i++){
 145             create(testName);
 146         }
 147     }
 148
 149     /*
 150     * Tests to diagnose and fix CSPACE-2578.
 151     *
 152     * This is a bug identified in release 1.0 alpha, after first implementing an
 153     * Acquisition Funding repeatable group of fields, in which record creation
 154     * fails if there is whitespace (or more generally, a text node) between
 155     * the acquisitionFunding container element and its first child field.
 156     */
 157
 158     // Verify that record creation occurs successfully when there is NO whitespace
 159     // between the acquisitionFunding tag and its first child element tag
 160     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 161         dependsOnMethods = {"CRUDTests"}, groups = {"cspace2578group"})
 162     public void createFromXmlNoWhitespaceAfterRepeatableGroupTag(String testName) throws Exception {
 163         String testDataDir = System.getProperty("test-data.fileName");
 164         String newId =
 165             createFromXmlFile(testName, testDataDir + "/cspace-2578-no-whitespace.xml", false);
 166         testSubmitRequest(newId);
 167     }
 168
 169     // Verify that record creation occurs successfully when there is whitespace
 170     // between the acquisitionFunding tag and its first child element tag
 171
 172     // FIXME: This test currently fails.  @Test annotation is currently commented
 173     // out for check-in, to prevent service tests from failing.  Can uncomment to test
 174     // fixes, and also after the issue is resolved, to help detect any regressions.
 175
 176     @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
 177         dependsOnMethods = {"CRUDTests"}, groups = {"cspace2578group"})
 178     public void createFromXmlWhitespaceAfterRepeatableGroupTag(String testName) throws Exception {
 179         String testDataDir = System.getProperty("test-data.fileName");
 180         String newId =
 181             createFromXmlFile(testName, testDataDir + "/cspace-2578-whitespace.xml", false);
 182         AcquisitionsCommon acquisition = readAcquisitionCommonPart(newId);
 183         testSubmitRequest(newId);
 184     }
 185
 186     // Failure outcomes
 187
 188     // Placeholders until the three tests below can be uncommented.
 189     // See Issue CSPACE-401.
 190     /* (non-Javadoc)
 191      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#createWithEmptyEntityBody(java.lang.String)
 192      */
 193     @Override
 194     public void createWithEmptyEntityBody(String testName) throws Exception {
 195         //Should this really be empty?
 196     }
 197
 198     /* (non-Javadoc)
 199      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#createWithMalformedXml(java.lang.String)
 200      */
 201     @Override
 202     public void createWithMalformedXml(String testName) throws Exception {
 203         //Should this really be empty?
 204     }
 205
 206     /* (non-Javadoc)
 207      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#createWithWrongXmlSchema(java.lang.String)
 208      */
 209     @Override
 210     public void createWithWrongXmlSchema(String testName) throws Exception {
 211         //Should this really be empty?
 212     }
 213
 214     /*
 215     @Override
 216     @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
 217         dependsOnMethods = {"create", "testSubmitRequest"})
 218     public void createWithMalformedXml(String testName) throws Exception {
 219
 220         if (logger.isDebugEnabled()) {
 221             logger.debug(testBanner(testName, CLASS_NAME));
 222         };
 223
 224         // Perform setup.
 225         setupCreateWithMalformedXml();
 226
 227         // Submit the request to the service and store the response.
 228         String method = REQUEST_TYPE.httpMethodName();
 229         String url = getServiceRootURL();
 230         final String entity = MALFORMED_XML_DATA; // Constant from base class.
 231         int statusCode = submitRequest(method, url, entity);
 232
 233         // Check the status code of the response: does it match
 234         // the expected response(s)?
 235         if(logger.isDebugEnabled()){
 236             logger.debug(testName + ": url=" + url +
 237                 " status=" + statusCode);
 238          }
 239         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 240         invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 241         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 242     }
 243
 244     @Override
 245     @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
 246         dependsOnMethods = {"create", "testSubmitRequest"})
 247     public void createWithWrongXmlSchema(String testName) throws Exception {
 248
 249         if (logger.isDebugEnabled()) {
 250             logger.debug(testBanner(testName, CLASS_NAME));
 251         };
 252
 253         // Perform setup.
 254         setupCreateWithWrongXmlSchema();
 255
 256         // Submit the request to the service and store the response.
 257         String method = REQUEST_TYPE.httpMethodName();
 258         String url = getServiceRootURL();
 259         final String entity = WRONG_XML_SCHEMA_DATA;
 260         int statusCode = submitRequest(method, url, entity);
 261
 262         // Check the status code of the response: does it match
 263         // the expected response(s)?
 264         if(logger.isDebugEnabled()){
 265             logger.debug(testName + ": url=" + url +
 266                 " status=" + statusCode);
 267          }
 268         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 269         invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 270         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 271     }
 272      */
 273
 274     // ---------------------------------------------------------------
 275     // CRUD tests : READ tests
 276     // ---------------------------------------------------------------
 277     // Success outcomes
 278     /* (non-Javadoc)
 279      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#read(java.lang.String)
 280      */
 281     @Override
 282 //    @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
 283 //        dependsOnMethods = {"create"})
 284     public void read(String testName) throws Exception {
 285         // Perform setup.
 286         setupRead();
 287
 288         AcquisitionClient client = new AcquisitionClient();
 289
 290         // Submit the request to the service and store the response.
 291         ClientResponse<String> res = client.read(knownResourceId);
 292         int statusCode = res.getStatus();
 293
 294         // Check the status code of the response: does it match
 295         // the expected response(s)?
 296         if(logger.isDebugEnabled()){
 297             logger.debug(testName + ": status = " + statusCode);
 298         }
 299         Assert.assertTrue(testRequestType.isValidStatusCode(statusCode),
 300                 invalidStatusCodeMessage(testRequestType, statusCode));
 301         Assert.assertEquals(statusCode, testExpectedStatusCode);
 302
 303         PoxPayloadIn input = new PoxPayloadIn(res.getEntity());
 304         AcquisitionsCommon acquisitionObject = (AcquisitionsCommon) extractPart(input,
 305                 client.getCommonPartName(), AcquisitionsCommon.class);
 306         Assert.assertNotNull(acquisitionObject);
 307
 308         // Verify the number and contents of values in repeatable fields,
 309         // as created in the instance record used for testing.
 310         List<String> acqSources =
 311                 acquisitionObject.getAcquisitionSources().getAcquisitionSource();
 312         Assert.assertTrue(acqSources.size() > 0);
 313         Assert.assertNotNull(acqSources.get(0));
 314
 315         List<StructuredDateGroup> acqDates = acquisitionObject.getAcquisitionDateGroupList().getAcquisitionDateGroup();
 316         Assert.assertTrue(acqDates.size() > 0);
 317         Assert.assertNotNull(acqDates.get(0));
 318
 319         List<String> owners =
 320                 acquisitionObject.getOwners().getOwner();
 321         Assert.assertTrue(owners.size() > 0);
 322         Assert.assertNotNull(owners.get(0));
 323     }
 324
 325     // Failure outcomes
 326     /* (non-Javadoc)
 327      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#readNonExistent(java.lang.String)
 328      */
 329     @Override
 330 //    @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
 331 //        dependsOnMethods = {"read"})
 332     public void readNonExistent(String testName) throws Exception {
 333         // Perform setup.
 334         setupReadNonExistent();
 335
 336         // Submit the request to the service and store the response.
 337         AcquisitionClient client = new AcquisitionClient();
 338         ClientResponse<String> res = client.read(NON_EXISTENT_ID);
 339         int statusCode = res.getStatus();
 340
 341         // Check the status code of the response: does it match
 342         // the expected response(s)?
 343         if(logger.isDebugEnabled()){
 344             logger.debug(testName + ": status = " + statusCode);
 345         }
 346         Assert.assertTrue(testRequestType.isValidStatusCode(statusCode),
 347                 invalidStatusCodeMessage(testRequestType, statusCode));
 348         Assert.assertEquals(statusCode, testExpectedStatusCode);
 349     }
 350
 351     // ---------------------------------------------------------------
 352     // CRUD tests : READ_LIST tests
 353     // ---------------------------------------------------------------
 354     // Success outcomes
 355     /* (non-Javadoc)
 356      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#readList(java.lang.String)
 357      */
 358     @Override
 359 //    @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
 360 //        dependsOnMethods = {"createList", "read"})
 361     public void readList(String testName) throws Exception {
 362         // Perform setup.
 363         setupReadList();
 364
 365         // Submit the request to the service and store the response.
 366         AcquisitionClient client = new AcquisitionClient();
 367         ClientResponse<AbstractCommonList> res = client.readList();
 368         try {
 369                 // Check the status code of the response: does it match
 370                 // the expected response(s)?
 371                 assertStatusCode(res, testName);
 372                 AbstractCommonList list = res.getEntity();
 373
 374                 // Optionally output additional data about list members for debugging.
 375                 if (logger.isTraceEnabled() == true){
 376                         AbstractCommonListUtils.ListItemsInAbstractCommonList(list, logger, testName);
 377                 }
 378         } finally {
 379                 if (res != null) {
 380                 res.releaseConnection();
 381             }
 382         }
 383     }
 384
 385     // Failure outcomes
 386     // None at present.
 387
 388     // ---------------------------------------------------------------
 389     // CRUD tests : UPDATE tests
 390     // ---------------------------------------------------------------
 391
 392     // Success outcomes
 393     /* (non-Javadoc)
 394      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#update(java.lang.String)
 395      */
 396     @Override
 397 //    @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
 398 //        dependsOnMethods = {"read"})
 399     public void update(String testName) throws Exception {
 400         // Perform setup.
 401         setupUpdate();
 402
 403         // Retrieve the contents of a resource to update.
 404         AcquisitionClient client = new AcquisitionClient();
 405         ClientResponse<String> res = client.read(knownResourceId);
 406         if(logger.isDebugEnabled()){
 407             logger.debug(testName + ": read status = " + res.getStatus());
 408         }
 409         Assert.assertEquals(res.getStatus(), testExpectedStatusCode);
 410
 411         PoxPayloadIn input = new PoxPayloadIn(res.getEntity());
 412
 413         AcquisitionsCommon acquisition = (AcquisitionsCommon) extractPart(input,
 414                 client.getCommonPartName(), AcquisitionsCommon.class);
 415         Assert.assertNotNull(acquisition);
 416
 417         // Update the content of this resource.
 418         acquisition.setAcquisitionReferenceNumber("updated-" + acquisition.getAcquisitionReferenceNumber());
 419         if(logger.isDebugEnabled()){
 420             logger.debug("updated object");
 421             logger.debug(objectAsXmlString(acquisition, AcquisitionsCommon.class));
 422         }
 423         // Submit the request to the service and store the response.
 424         PoxPayloadOut output = new PoxPayloadOut(AcquisitionClient.SERVICE_PAYLOAD_NAME);
 425         PayloadOutputPart commonPart = output.addPart(acquisition, MediaType.APPLICATION_XML_TYPE);
 426         commonPart.setLabel(client.getCommonPartName());
 427
 428         res = client.update(knownResourceId, output);
 429         int statusCode = res.getStatus();
 430         // Check the status code of the response: does it match the expected response(s)?
 431         if(logger.isDebugEnabled()){
 432             logger.debug(testName + ": status = " + statusCode);
 433         }
 434         Assert.assertTrue(testRequestType.isValidStatusCode(statusCode),
 435                 invalidStatusCodeMessage(testRequestType, statusCode));
 436         Assert.assertEquals(statusCode, testExpectedStatusCode);
 437
 438         input = new PoxPayloadIn(res.getEntity());
 439         AcquisitionsCommon updatedAcquisition =
 440                 (AcquisitionsCommon) extractPart(input,
 441                         client.getCommonPartName(), AcquisitionsCommon.class);
 442         Assert.assertNotNull(updatedAcquisition);
 443
 444         Assert.assertEquals(updatedAcquisition.getAcquisitionReferenceNumber(),
 445                 acquisition.getAcquisitionReferenceNumber(),
 446                 "Data in updated object did not match submitted data.");
 447
 448     }
 449
 450     // Failure outcomes
 451     // Placeholders until the three tests below can be uncommented.
 452     // See Issue CSPACE-401.
 453     /* (non-Javadoc)
 454      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#updateWithEmptyEntityBody(java.lang.String)
 455      */
 456     @Override
 457     public void updateWithEmptyEntityBody(String testName) throws Exception {
 458         //Should this really be empty?
 459     }
 460
 461     /* (non-Javadoc)
 462      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#updateWithMalformedXml(java.lang.String)
 463      */
 464     @Override
 465     public void updateWithMalformedXml(String testName) throws Exception {
 466         //Should this really be empty?
 467     }
 468
 469     /* (non-Javadoc)
 470      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#updateWithWrongXmlSchema(java.lang.String)
 471      */
 472     @Override
 473     public void updateWithWrongXmlSchema(String testName) throws Exception {
 474         //Should this really be empty?
 475     }
 476
 477     /*
 478     @Override
 479     @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
 480         dependsOnMethods = {"create", "update", "testSubmitRequest"})
 481     public void updateWithEmptyEntityBody(String testName) throws Exception {
 482
 483         if (logger.isDebugEnabled()) {
 484             logger.debug(testBanner(testName, CLASS_NAME));
 485         };
 486
 487         // Perform setup.
 488         setupUpdateWithEmptyEntityBody();
 489
 490         // Submit the request to the service and store the response.
 491         String method = REQUEST_TYPE.httpMethodName();
 492         String url = getResourceURL(knownResourceId);
 493         String mediaType = MediaType.APPLICATION_XML;
 494         final String entity = "";
 495         int statusCode = submitRequest(method, url, mediaType, entity);
 496
 497         // Check the status code of the response: does it match
 498         // the expected response(s)?
 499         if(logger.isDebugEnabled()){
 500             (testName + ": url=" + url + " status=" + statusCode);
 501         }
 502         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 503         invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 504         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 505         }
 506
 507     @Override
 508     @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
 509         dependsOnMethods = {"create", "testSubmitRequest"})
 510     public void createWithEmptyEntityBody(String testName) throws Exception {
 511
 512         if (logger.isDebugEnabled()) {
 513             logger.debug(testBanner(testName, CLASS_NAME));
 514         };
 515
 516         // Perform setup.
 517         setupCreateWithEmptyEntityBody();
 518
 519         // Submit the request to the service and store the response.
 520         String method = REQUEST_TYPE.httpMethodName();
 521         String url = getServiceRootURL();
 522         String mediaType = MediaType.APPLICATION_XML;
 523         final String entity = "";
 524         int statusCode = submitRequest(method, url, mediaType, entity);
 525
 526         // Check the status code of the response: does it match
 527         // the expected response(s)?
 528         if(logger.isDebugEnabled()){
 529             logger.debug(testName + ": url=" + url +
 530                 " status=" + statusCode);
 531         }
 532         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 533         invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 534         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 535     }
 536
 537     @Override
 538     @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
 539         dependsOnMethods = {"create", "update", "testSubmitRequest"})
 540     public void updateWithMalformedXml(String testName) throws Exception {
 541
 542         if (logger.isDebugEnabled()) {
 543             logger.debug(testBanner(testName, CLASS_NAME));
 544         };
 545
 546         // Perform setup.
 547         setupUpdateWithMalformedXml();
 548
 549         // Submit the request to the service and store the response.
 550         String method = REQUEST_TYPE.httpMethodName();
 551         String url = getResourceURL(knownResourceId);
 552         final String entity = MALFORMED_XML_DATA;
 553         int statusCode = submitRequest(method, url, entity);
 554
 555         // Check the status code of the response: does it match
 556         // the expected response(s)?
 557         if(logger.isDebugEnabled()){
 558             logger.debug(testName + ": url=" + url +
 559                 " status=" + statusCode);
 560          }
 561         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 562         invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 563         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 564     }
 565
 566     @Override
 567     @Test(dependsOnMethods = {"create", "update", "testSubmitRequest"})
 568     public void updateWithWrongXmlSchema(String testName) {
 569
 570         if (logger.isDebugEnabled()) {
 571             logger.debug(testBanner(testName, CLASS_NAME));
 572         };
 573
 574         // Perform setup.
 575         setupUpdateWithWrongXmlSchema();
 576
 577         // Submit the request to the service and store the response.
 578         String method = REQUEST_TYPE.httpMethodName();
 579         String url = getResourceURL(knownResourceId);
 580         final String entity = WRONG_XML_SCHEMA_DATA;
 581         int statusCode = submitRequest(method, url, entity);
 582
 583         // Check the status code of the response: does it match
 584         // the expected response(s)?
 585         if(logger.isDebugEnabled()){
 586             logger.debug(testName + ": url=" + url +
 587                 " status=" + statusCode);
 588          }
 589         Assert.assertTrue(REQUEST_TYPE.isValidStatusCode(statusCode),
 590         invalidStatusCodeMessage(REQUEST_TYPE, statusCode));
 591         Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
 592     }
 593      */
 594
 595     /* (non-Javadoc)
 596      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#updateNonExistent(java.lang.String)
 597      */
 598     @Override
 599 //    @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
 600 //        dependsOnMethods = {"update", "testSubmitRequest"})
 601     public void updateNonExistent(String testName) throws Exception {
 602         // Perform setup.
 603         setupUpdateNonExistent();
 604
 605         // Submit the request to the service and store the response.
 606         // Note: The ID used in this 'create' call may be arbitrary.
 607         // The only relevant ID may be the one used in update(), below.
 608         AcquisitionClient client = new AcquisitionClient();
 609         PoxPayloadOut multipart = createAcquisitionInstance(NON_EXISTENT_ID);
 610         ClientResponse<String> res =
 611             client.update(NON_EXISTENT_ID, multipart);
 612         int statusCode = res.getStatus();
 613
 614         // Check the status code of the response: does it match
 615         // the expected response(s)?
 616         if(logger.isDebugEnabled()){
 617             logger.debug(testName + ": status = " + statusCode);
 618         }
 619         Assert.assertTrue(testRequestType.isValidStatusCode(statusCode),
 620                 invalidStatusCodeMessage(testRequestType, statusCode));
 621         Assert.assertEquals(statusCode, testExpectedStatusCode);
 622     }
 623
 624     // ---------------------------------------------------------------
 625     // CRUD tests : DELETE tests
 626     // ---------------------------------------------------------------
 627     // Success outcomes
 628     /* (non-Javadoc)
 629      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#delete(java.lang.String)
 630      */
 631     @Override
 632 //    @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
 633 //        dependsOnMethods = {"create", "read", "update"})
 634     public void delete(String testName) throws Exception {
 635         // Perform setup.
 636         setupDelete();
 637
 638         // Submit the request to the service and store the response.
 639         AcquisitionClient client = new AcquisitionClient();
 640         ClientResponse<Response> res = client.delete(knownResourceId);
 641         int statusCode = res.getStatus();
 642
 643         // Check the status code of the response: does it match
 644         // the expected response(s)?
 645         if(logger.isDebugEnabled()){
 646             logger.debug(testName + ": status = " + statusCode);
 647         }
 648         Assert.assertTrue(testRequestType.isValidStatusCode(statusCode),
 649                 invalidStatusCodeMessage(testRequestType, statusCode));
 650         Assert.assertEquals(statusCode, testExpectedStatusCode);
 651     }
 652
 653     // Failure outcomes
 654     /* (non-Javadoc)
 655      * @see org.collectionspace.services.client.test.AbstractServiceTestImpl#deleteNonExistent(java.lang.String)
 656      */
 657     @Override
 658 //    @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
 659 //        dependsOnMethods = {"delete"})
 660     public void deleteNonExistent(String testName) throws Exception {
 661         // Perform setup.
 662         setupDeleteNonExistent();
 663
 664         // Submit the request to the service and store the response.
 665         AcquisitionClient client = new AcquisitionClient();
 666         ClientResponse<Response> res = client.delete(NON_EXISTENT_ID);
 667         int statusCode = res.getStatus();
 668
 669         // Check the status code of the response: does it match
 670         // the expected response(s)?
 671         if(logger.isDebugEnabled()){
 672             logger.debug(testName + ": status = " + statusCode);
 673         }
 674         Assert.assertTrue(testRequestType.isValidStatusCode(statusCode),
 675                 invalidStatusCodeMessage(testRequestType, statusCode));
 676         Assert.assertEquals(statusCode, testExpectedStatusCode);
 677     }
 678
 679     // ---------------------------------------------------------------
 680     // Utility tests : tests of code used in tests above
 681     // ---------------------------------------------------------------
 682
 683     @Override
 684     protected PoxPayloadOut createInstance(String identifier) {
 685         return createAcquisitionInstance(identifier);
 686     }
 687
 688     /**
 689      * Creates the acquisition instance.
 690      *
 691      * @param identifier the identifier
 692      * @return the multipart output
 693      */
 694     private PoxPayloadOut createAcquisitionInstance(String identifier) {
 695         AcquisitionsCommon acquisition = new AcquisitionsCommon();
 696         acquisition.setAcquisitionReferenceNumber("acquisitionReferenceNumber-"  + identifier);
 697
 698         AcquisitionSourceList acqSourcesList = new AcquisitionSourceList();
 699         List<String> acqSources = acqSourcesList.getAcquisitionSource();
 700         // FIXME Use properly formatted refNames for representative acquisition
 701         // sources in this example test record. The following are mere placeholders.
 702         acqSources.add("Donor Acquisition Source-" + identifier);
 703         acqSources.add("Museum Acquisition Source-" + identifier);
 704         acquisition.setAcquisitionSources(acqSourcesList);
 705
 706         AcquisitionDateGroupList acqDatesList = new AcquisitionDateGroupList();
 707         List<StructuredDateGroup> acqDates = acqDatesList.getAcquisitionDateGroup();
 708         StructuredDateGroup acqDate1 = new StructuredDateGroup();
 709         acqDate1.setDateDisplayDate(CURRENT_DATE_UTC);
 710         StructuredDateGroup acqDate2 = new StructuredDateGroup();
 711         acqDate2.setDateDisplayDate(CURRENT_DATE_UTC);
 712         acqDates.add(acqDate1);
 713         acqDates.add(acqDate2);
 714         acquisition.setAcquisitionDateGroupList(acqDatesList);
 715
 716         OwnerList ownersList = new OwnerList();
 717         List<String> owners = ownersList.getOwner();
 718         // FIXME Use properly formatted refNames for representative owners
 719         // in this example test record. The following are mere placeholders.
 720         owners.add("First Owner -" + identifier);
 721         owners.add("Second Owner-" + identifier);
 722         acquisition.setOwners(ownersList);
 723
 724         PoxPayloadOut multipart = new PoxPayloadOut(AcquisitionClient.SERVICE_PAYLOAD_NAME);
 725         PayloadOutputPart commonPart = multipart.addPart(acquisition,
 726             MediaType.APPLICATION_XML_TYPE);
 727         commonPart.setLabel(new AcquisitionClient().getCommonPartName());
 728
 729         if(logger.isDebugEnabled()){
 730             logger.debug("to be created, acquisition common");
 731             logger.debug(objectAsXmlString(acquisition, AcquisitionsCommon.class));
 732         }
 733         return multipart;
 734     }
 735
 736     // FIXME: The following methods might be made generic and moved to a common package.
 737
 738     /**
 739      * Retrives an XML document from the given file, and uses
 740      * the JAXB unmarshaller to create a Java object representation
 741      * and ultimately a multipart payload that can be submitted in
 742      * a create or update request.
 743      *
 744      * @param commonPartName
 745      * @param commonPartFileName
 746      * @return
 747      * @throws Exception
 748      */
 749     private PoxPayloadOut createAcquisitionInstanceFromXml(String testName, String commonPartName,
 750             String commonPartFileName) throws Exception {
 751
 752         AcquisitionsCommon acquisition =
 753                 (AcquisitionsCommon) getObjectFromFile(AcquisitionsCommon.class,
 754                 commonPartFileName);
 755         PoxPayloadOut multipart = new PoxPayloadOut(AcquisitionClient.SERVICE_PAYLOAD_NAME);
 756         PayloadOutputPart commonPart = multipart.addPart(acquisition,
 757                 MediaType.APPLICATION_XML_TYPE);
 758         commonPart.setLabel(commonPartName);
 759
 760         if (logger.isDebugEnabled()) {
 761             logger.debug(testName + " to be created, acquisitions common");
 762             logger.debug(objectAsXmlString(acquisition,
 763                     AcquisitionsCommon.class));
 764         }
 765         return multipart;
 766
 767     }
 768
 769     /**
 770      * Creates a record / resource from the data in an XML file.
 771      *
 772      * @param testName the test name
 773      * @param fileName the file name
 774      * @param useJaxb the use jaxb
 775      * @return the string
 776      * @throws Exception the exception
 777      */
 778     private String createFromXmlFile(String testName, String fileName, boolean useJaxb) throws Exception {
 779
 780         // Perform setup.
 781         setupCreate();
 782
 783         PoxPayloadOut multipart = null;
 784
 785         AcquisitionClient client = new AcquisitionClient();
 786         if (useJaxb) {
 787             multipart = createAcquisitionInstanceFromXml(testName,
 788                     client.getCommonPartName(), fileName);
 789         } else {
 790
 791             multipart = createAcquisitionInstanceFromRawXml(testName,
 792                     client.getCommonPartName(), fileName);
 793         }
 794         Response res = client.create(multipart);
 795         int statusCode = res.getStatus();
 796
 797         if (logger.isDebugEnabled()) {
 798             logger.debug(testName + ": status = " + statusCode);
 799         }
 800         Assert.assertTrue(testRequestType.isValidStatusCode(statusCode),
 801                 invalidStatusCodeMessage(testRequestType, statusCode));
 802         Assert.assertEquals(statusCode, testExpectedStatusCode);
 803         String newId = extractId(res);
 804         allResourceIdsCreated.add(newId);
 805         return newId;
 806     }
 807
 808      /**
 809      * Returns a multipart payload that can be submitted with a
 810      * create or update request, by reading from an XML file.
 811      *
 812      * @param commonPartName
 813      * @param commonPartFileName
 814      * @return
 815      * @throws Exception
 816      */
 817     private PoxPayloadOut createAcquisitionInstanceFromRawXml(String testName, String commonPartName,
 818             String commonPartFileName) throws Exception {
 819
 820         PoxPayloadOut multipart = new PoxPayloadOut(AcquisitionClient.SERVICE_PAYLOAD_NAME);
 821         String stringObject = getXmlDocumentAsString(commonPartFileName);
 822         if (logger.isDebugEnabled()) {
 823             logger.debug(testName + " to be created, acquisition common " + "\n" + stringObject);
 824         }
 825         PayloadOutputPart commonPart = multipart.addPart(stringObject, stringObject);
 826         commonPart.setLabel(commonPartName);
 827
 828         return multipart;
 829
 830     }
 831
 832     // FIXME: This duplicates code in read(), and should be consolidated.
 833     // This is an expedient to support reading and verifying the contents
 834     // of resources that have been created from test data XML files.
 835     private AcquisitionsCommon readAcquisitionCommonPart(String csid)
 836         throws Exception {
 837
 838         String testName = "readAcquisitionCommonPart";
 839
 840         setupRead();
 841
 842         // Submit the request to the service and store the response.
 843         AcquisitionClient client = new AcquisitionClient();
 844         ClientResponse<String> res = client.read(csid);
 845         AcquisitionsCommon acquisition = null;
 846         try {
 847                 // Check the status code of the response: does it match
 848                 // the expected response(s)?
 849                 assertStatusCode(res, testName);
 850                 PoxPayloadIn input = new PoxPayloadIn(res.getEntity());
 851
 852                 if (logger.isDebugEnabled()) {
 853                     logger.debug(testName + ": Reading Common part ...");
 854                 }
 855                 acquisition = (AcquisitionsCommon) extractPart(input,
 856                         client.getCommonPartName(), AcquisitionsCommon.class);
 857                 Assert.assertNotNull(acquisition);
 858         } finally {
 859                 if (res != null) {
 860                 res.releaseConnection();
 861             }
 862         }
 863
 864         return acquisition;
 865      }
 866
 867
 868         @Override
 869         protected PoxPayloadOut createInstance(String commonPartName,
 870                         String identifier) {
 871                 // TODO Auto-generated method stub
 872                 return null;
 873         }
 874
 875         @Override
 876         protected AcquisitionsCommon updateInstance(
 877                         AcquisitionsCommon commonPartObject) {
 878                 // TODO Auto-generated method stub
 879                 return null;
 880         }
 881
 882         @Override
 883         protected void compareUpdatedInstances(AcquisitionsCommon original,
 884                         AcquisitionsCommon updated) throws Exception {
 885                 // TODO Auto-generated method stub
 886
 887         }
 888
 889     /*
 890      * For convenience and terseness, this test method is the base of the test execution dependency chain.  Other test methods may
 891      * refer to this method in their @Test annotation declarations.
 892      */
 893     @Override
 894     @Test(dataProvider = "testName",
 895                 dependsOnMethods = {
 896                         "org.collectionspace.services.client.test.AbstractServiceTestImpl.baseCRUDTests"})
 897     public void CRUDTests(String testName) {
 898         // Do nothing.  Simply here to for a TestNG execution order for our tests
 899     }
 900 }
 901