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.ArrayList;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29
  30 import javax.ws.rs.core.Response;
  31
  32 import org.collectionspace.services.LocationJAXBSchema;
  33 import org.collectionspace.services.client.AbstractCommonListUtils;
  34 import org.collectionspace.services.client.AuthorityClient;
  35 import org.collectionspace.services.client.CollectionSpaceClient;
  36 import org.collectionspace.services.client.PayloadOutputPart;
  37 import org.collectionspace.services.client.PoxPayloadIn;
  38 import org.collectionspace.services.client.PoxPayloadOut;
  39 import org.collectionspace.services.client.LocationAuthorityClient;
  40 import org.collectionspace.services.client.LocationAuthorityClientUtils;
  41 import org.collectionspace.services.common.api.GregorianCalendarDateTimeUtils;
  42 import org.collectionspace.services.jaxb.AbstractCommonList;
  43 import org.collectionspace.services.location.LocTermGroup;
  44 import org.collectionspace.services.location.LocTermGroupList;
  45 import org.collectionspace.services.location.LocationauthoritiesCommon;
  46 import org.collectionspace.services.location.LocationsCommon;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49 import org.testng.Assert;
  50 import org.testng.annotations.AfterClass;
  51 import org.testng.annotations.Test;
  52
  53 /**
  54  * LocationAuthorityServiceTest, carries out tests against a
  55  * deployed and running LocationAuthority Service.
  56  *
  57  * $LastChangedRevision: 753 $
  58  * $LastChangedDate: 2009-09-23 11:03:36 -0700 (Wed, 23 Sep 2009) $
  59  */
  60 public class LocationAuthorityServiceTest extends AbstractAuthorityServiceTest<LocationauthoritiesCommon, LocationsCommon> {
  61
  62     /** The logger. */
  63     private final Logger logger = LoggerFactory.getLogger(LocationAuthorityServiceTest.class);
  64     private final static String CURRENT_DATE_UTC = GregorianCalendarDateTimeUtils.currentDateUTC();
  65
  66     /**
  67      * Default constructor.  Used to set the short ID for all tests authority items
  68      */
  69     public LocationAuthorityServiceTest() {
  70         super();
  71         TEST_SHORTID = "shelf1";
  72     }
  73
  74         @Override
  75         public String getServicePathComponent() {
  76                 return LocationAuthorityClient.SERVICE_PATH_COMPONENT;
  77         }
  78
  79         @Override
  80         protected String getServiceName() {
  81                 return LocationAuthorityClient.SERVICE_NAME;
  82         }
  83
  84     public String getItemServicePathComponent() {
  85         return AuthorityClient.ITEMS;
  86     }
  87
  88     // Instance variables specific to this test.
  89
  90     final String TEST_NAME = "Shelf 1";
  91     final String TEST_CONDITION_NOTE = "Basically clean";
  92     final String TEST_CONDITION_NOTE_DATE = CURRENT_DATE_UTC;
  93     final String TEST_SECURITY_NOTE = "Kind of safe";
  94     final String TEST_ACCESS_NOTE = "Only right-thinkers may see";
  95     final String TEST_ADDRESS = "123 Main Street, Anytown USA";
  96     // TODO Make loc type be a controlled vocab term.
  97     final String TEST_LOCATION_TYPE = "Shelf";
  98     // TODO Make status type be a controlled vocab term.
  99     final String TEST_STATUS = "Approved";
 100
 101     /** The known resource id. */
 102     private String knownLocationTypeRefName = null;
 103
 104     /* (non-Javadoc)
 105      * @see org.collectionspace.services.client.test.BaseServiceTest#getClientInstance()
 106      */
 107     @Override
 108     protected CollectionSpaceClient getClientInstance() {
 109         return new LocationAuthorityClient();
 110     }
 111
 112     @Override
 113     protected CollectionSpaceClient getClientInstance(String clientPropertiesFilename) {
 114         return new LocationAuthorityClient(clientPropertiesFilename);
 115     }
 116
 117         @Override
 118         protected String createItemInAuthority(AuthorityClient client, String vcsid, String shortId) {
 119                 return createItemInAuthority(client, vcsid, shortId, null/*refname*/);
 120         }
 121
 122     /**
 123      * Creates the item in authority.
 124      *
 125      * @param vcsid the vcsid
 126      * @param authRefName the auth ref name
 127      * @return the string
 128      */
 129     private String createItemInAuthority(AuthorityClient client, String vcsid, String shortId, String authRefName) {
 130         final String testName = "createItemInAuthority("+vcsid+","+authRefName+")";
 131
 132         // Submit the request to the service and store the response.
 133         Map<String, String> shelf1Map = new HashMap<String,String>();
 134         // TODO Make loc type and status be controlled vocabs.
 135         shelf1Map.put(LocationJAXBSchema.SHORT_IDENTIFIER, shortId);
 136         shelf1Map.put(LocationJAXBSchema.CONDITION_NOTE, TEST_CONDITION_NOTE);
 137         shelf1Map.put(LocationJAXBSchema.CONDITION_NOTE_DATE, TEST_CONDITION_NOTE_DATE);
 138         shelf1Map.put(LocationJAXBSchema.SECURITY_NOTE, TEST_SECURITY_NOTE);
 139         shelf1Map.put(LocationJAXBSchema.ACCESS_NOTE, TEST_ACCESS_NOTE);
 140         shelf1Map.put(LocationJAXBSchema.ADDRESS, TEST_ADDRESS);
 141         shelf1Map.put(LocationJAXBSchema.LOCATION_TYPE, TEST_LOCATION_TYPE);
 142
 143         List<LocTermGroup> shelf1Terms = new ArrayList<LocTermGroup>();
 144         LocTermGroup term = new LocTermGroup();
 145         term.setTermDisplayName(TEST_NAME);
 146         term.setTermName(TEST_NAME);
 147         term.setTermStatus(TEST_STATUS);
 148         shelf1Terms.add(term);
 149                 shelf1Map.put(LocationJAXBSchema.TERM_STATUS, TEST_STATUS);
 150
 151         String newID = LocationAuthorityClientUtils.createItemInAuthority(vcsid,
 152                         authRefName, shelf1Map, shelf1Terms, (LocationAuthorityClient) client);
 153
 154         // Store the ID returned from the first item resource created
 155         // for additional tests below.
 156         if (knownItemResourceId == null){
 157                 setKnownItemResource(newID, shortId);
 158             if (logger.isDebugEnabled()) {
 159                 logger.debug(testName + ": knownItemResourceId=" + newID);
 160             }
 161         }
 162
 163         // Store the IDs from any item resources created
 164         // by tests, along with the IDs of their parents, so these items
 165         // can be deleted after all tests have been run.
 166         allResourceItemIdsCreated.put(newID, vcsid);
 167
 168         return newID;
 169     }
 170
 171     /**
 172      * Verify illegal item display name.
 173      *
 174      * @param testName the test name
 175      * @throws Exception the exception
 176      */
 177     @Test(dataProvider="testName")
 178     public void verifyIllegalItemDisplayName(String testName) throws Exception {
 179         // Perform setup for read.
 180         setupRead();
 181
 182         // Submit the request to the service and store the response.
 183         LocationAuthorityClient client = new LocationAuthorityClient();
 184         Response res = client.readItem(knownResourceId, knownItemResourceId);
 185         LocationsCommon location = null;
 186         try {
 187             assertStatusCode(res, testName);
 188                 PoxPayloadIn input = new PoxPayloadIn(res.readEntity(String.class));
 189                 location = (LocationsCommon) extractPart(input,
 190                         client.getItemCommonPartName(), LocationsCommon.class);
 191                 Assert.assertNotNull(location);
 192             } finally {
 193                 if (res != null) {
 194                 res.close();
 195             }
 196             }
 197
 198         //
 199         // Make an invalid UPDATE request, without a display name
 200         //
 201         LocTermGroupList termList = location.getLocTermGroupList();
 202         Assert.assertNotNull(termList);
 203         List<LocTermGroup> terms = termList.getLocTermGroup();
 204         Assert.assertNotNull(terms);
 205         Assert.assertTrue(terms.size() > 0);
 206         terms.get(0).setTermDisplayName(null);
 207         terms.get(0).setTermName(null);
 208
 209         setupUpdateWithInvalidBody(); // we expect a failure
 210
 211         // Submit the updated resource to the service and store the response.
 212         PoxPayloadOut output = new PoxPayloadOut(LocationAuthorityClient.SERVICE_ITEM_PAYLOAD_NAME);
 213         PayloadOutputPart commonPart = output.addPart(client.getItemCommonPartName(), location);
 214         setupUpdateWithInvalidBody(); // we expected a failure here.
 215         res = client.updateItem(knownResourceId, knownItemResourceId, output);
 216         try {
 217                 assertStatusCode(res, testName);
 218         } finally {
 219                 if (res != null) {
 220                 res.close();
 221             }
 222         }
 223     }
 224
 225     /**
 226      * Read item list.
 227      */
 228     @Test(dataProvider = "testName", groups = {"readList"},
 229                 dependsOnMethods = {"readList"})
 230     public void readItemList(String testName) {
 231         readItemList(knownAuthorityWithItems, null);
 232     }
 233
 234     /**
 235      * Read item list by authority name.
 236      */
 237     @Test(dataProvider = "testName", groups = {"readList"},
 238                 dependsOnMethods = {"readItemList"})
 239     public void readItemListByAuthorityName(String testName) {
 240         readItemList(null, READITEMS_SHORT_IDENTIFIER);
 241     }
 242
 243         /**
 244          * Read item list.
 245          *
 246          * @param vcsid
 247          *            the vcsid
 248          * @param name
 249          *            the name
 250          */
 251         private void readItemList(String vcsid, String shortId) {
 252                 String testName = "readItemList";
 253
 254                 // Perform setup.
 255                 setupReadList();
 256
 257                 // Submit the request to the service and store the response.
 258                 LocationAuthorityClient client = new LocationAuthorityClient();
 259                 Response res = null;
 260                 if (vcsid != null) {
 261                         res = client.readItemList(vcsid, null, null);
 262                 } else if (shortId != null) {
 263                         res = client.readItemListForNamedAuthority(shortId, null, null);
 264                 } else {
 265                         Assert.fail("readItemList passed null csid and name!");
 266                 }
 267
 268                 AbstractCommonList list = null;
 269                 try {
 270                         assertStatusCode(res, testName);
 271                         list = res.readEntity(AbstractCommonList.class);
 272                 } finally {
 273                         if (res != null) {
 274                 res.close();
 275             }
 276                 }
 277
 278                 List<AbstractCommonList.ListItem> items = list.getListItem();
 279                 int nItemsReturned = items.size();
 280                 // There will be 'nItemsToCreateInList'
 281                 // items created by the createItemList test,
 282                 // all associated with the same parent resource.
 283                 int nExpectedItems = nItemsToCreateInList;
 284                 if (logger.isDebugEnabled()) {
 285                         logger.debug(testName + ": Expected " + nExpectedItems
 286                                         + " items; got: " + nItemsReturned);
 287                 }
 288                 Assert.assertEquals(nItemsReturned, nExpectedItems);
 289
 290                 for (AbstractCommonList.ListItem item : items) {
 291                         String value = AbstractCommonListUtils.ListItemGetElementValue(
 292                                         item, LocationJAXBSchema.REF_NAME);
 293                         Assert.assertTrue((null != value), "Item refName is null!");
 294                         value = AbstractCommonListUtils.ListItemGetElementValue(item,
 295                                         LocationJAXBSchema.TERM_DISPLAY_NAME);
 296                         Assert.assertTrue((null != value), "Item termDisplayName is null!");
 297                 }
 298                 if (logger.isTraceEnabled()) {
 299                         AbstractCommonListUtils.ListItemsInAbstractCommonList(list, logger,
 300                                         testName);
 301                 }
 302         }
 303
 304     @Override
 305     public void delete(String testName) throws Exception {
 306         // Do nothing.  See localDelete().  This ensure proper test order.
 307     }
 308
 309     @Test(dataProvider = "testName", dependsOnMethods = {"localDeleteItem"})
 310     public void localDelete(String testName) throws Exception {
 311         super.delete(testName);
 312     }
 313
 314     @Override
 315     public void deleteItem(String testName) throws Exception {
 316         // Do nothing.  We need to wait until after the test "localDelete" gets run.  When it does,
 317         // its dependencies will get run first and then we can call the base class' delete method.
 318     }
 319
 320     @Test(dataProvider = "testName", groups = {"delete"},
 321         dependsOnMethods = {"verifyIllegalItemDisplayName"})
 322     public void localDeleteItem(String testName) throws Exception {
 323         super.deleteItem(testName);
 324     }
 325
 326     // ---------------------------------------------------------------
 327     // Cleanup of resources created during testing
 328     // ---------------------------------------------------------------
 329
 330     /**
 331      * Deletes all resources created by tests, after all tests have been run.
 332      *
 333      * This cleanup method will always be run, even if one or more tests fail.
 334      * For this reason, it attempts to remove all resources created
 335      * at any point during testing, even if some of those resources
 336      * may be expected to be deleted by certain tests.
 337      */
 338
 339     @AfterClass(alwaysRun=true)
 340     public void cleanUp() {
 341         String noTest = System.getProperty("noTestCleanup");
 342         if(Boolean.TRUE.toString().equalsIgnoreCase(noTest)) {
 343             if (logger.isDebugEnabled()) {
 344                 logger.debug("Skipping Cleanup phase ...");
 345             }
 346             return;
 347         }
 348         if (logger.isDebugEnabled()) {
 349             logger.debug("Cleaning up temporary resources created for testing ...");
 350         }
 351         String parentResourceId;
 352         String itemResourceId;
 353         // Clean up contact resources.
 354         LocationAuthorityClient client = new LocationAuthorityClient();
 355         parentResourceId = knownResourceId;
 356         // Clean up item resources.
 357         for (Map.Entry<String, String> entry : allResourceItemIdsCreated.entrySet()) {
 358             itemResourceId = entry.getKey();
 359             parentResourceId = entry.getValue();
 360             // Note: Any non-success responses from the delete operation
 361             // below are ignored and not reported.
 362             client.deleteItem(parentResourceId, itemResourceId).close();
 363         }
 364         // Clean up parent resources.
 365         for (String resourceId : allResourceIdsCreated) {
 366             // Note: Any non-success responses from the delete operation
 367             // below are ignored and not reported.
 368             client.delete(resourceId).close();
 369         }
 370     }
 371
 372     // ---------------------------------------------------------------
 373     // Utility methods used by tests above
 374     // ---------------------------------------------------------------
 375     /* (non-Javadoc)
 376      * @see org.collectionspace.services.client.test.BaseServiceTest#getServicePathComponent()
 377      */
 378
 379     /**
 380      * Returns the root URL for the item service.
 381      *
 382      * This URL consists of a base URL for all services, followed by
 383      * a path component for the owning parent, followed by the
 384      * path component for the items.
 385      *
 386      * @param  parentResourceIdentifier  An identifier (such as a UUID) for the
 387      * parent authority resource of the relevant item resource.
 388      *
 389      * @return The root URL for the item service.
 390      */
 391     protected String getItemServiceRootURL(String parentResourceIdentifier) {
 392         return getResourceURL(parentResourceIdentifier) + "/" + getItemServicePathComponent();
 393     }
 394
 395     /**
 396      * Returns the URL of a specific item resource managed by a service, and
 397      * designated by an identifier (such as a universally unique ID, or UUID).
 398      *
 399      * @param  parentResourceIdentifier  An identifier (such as a UUID) for the
 400      * parent authority resource of the relevant item resource.
 401      *
 402      * @param  itemResourceIdentifier  An identifier (such as a UUID) for an
 403      * item resource.
 404      *
 405      * @return The URL of a specific item resource managed by a service.
 406      */
 407     protected String getItemResourceURL(String parentResourceIdentifier, String itemResourceIdentifier) {
 408         return getItemServiceRootURL(parentResourceIdentifier) + "/" + itemResourceIdentifier;
 409     }
 410
 411         @Override
 412         public void authorityTests(String testName) {
 413                 // TODO Auto-generated method stub
 414
 415         }
 416
 417         //
 418         // Location specific overrides
 419         //
 420
 421         @Override
 422         protected PoxPayloadOut createInstance(String commonPartName,
 423                         String identifier) {
 424         // Submit the request to the service and store the response.
 425         String shortId = identifier;
 426         String displayName = "displayName-" + shortId;
 427         // String baseRefName = LocationAuthorityClientUtils.createLocationAuthRefName(shortId, null);
 428         PoxPayloadOut result =
 429             LocationAuthorityClientUtils.createLocationAuthorityInstance(
 430             displayName, shortId, commonPartName);
 431                 return result;
 432         }
 433
 434         @Override
 435     protected PoxPayloadOut createNonExistenceInstance(String commonPartName, String identifier) {
 436         String displayName = "displayName-NON_EXISTENT_ID";
 437         PoxPayloadOut result = LocationAuthorityClientUtils.createLocationAuthorityInstance(
 438                                 displayName, "nonEx", commonPartName);
 439         return result;
 440     }
 441
 442         @Override
 443         protected LocationauthoritiesCommon updateInstance(LocationauthoritiesCommon locationauthoritiesCommon) {
 444                 LocationauthoritiesCommon result = new LocationauthoritiesCommon();
 445
 446                 result.setDisplayName("updated-" + locationauthoritiesCommon.getDisplayName());
 447                 result.setVocabType("updated-" + locationauthoritiesCommon.getVocabType());
 448
 449                 return result;
 450         }
 451
 452         @Override
 453         protected void compareUpdatedInstances(LocationauthoritiesCommon original,
 454                         LocationauthoritiesCommon updated) throws Exception {
 455         Assert.assertEquals(updated.getDisplayName(),
 456                         original.getDisplayName(),
 457                 "Display name in updated object did not match submitted data.");
 458         }
 459
 460         protected void compareReadInstances(LocationauthoritiesCommon original,
 461                         LocationauthoritiesCommon fromRead) throws Exception {
 462         Assert.assertNotNull(fromRead.getDisplayName());
 463         Assert.assertNotNull(fromRead.getShortIdentifier());
 464         Assert.assertNotNull(fromRead.getRefName());
 465         }
 466
 467         //
 468         // Authority item specific overrides
 469         //
 470
 471         @Override
 472         protected LocationsCommon updateItemInstance(LocationsCommon locationsCommon) {
 473
 474             LocTermGroupList termList = locationsCommon.getLocTermGroupList();
 475             Assert.assertNotNull(termList);
 476             List<LocTermGroup> terms = termList.getLocTermGroup();
 477             Assert.assertNotNull(terms);
 478             Assert.assertTrue(terms.size() > 0);
 479             terms.get(0).setTermDisplayName("updated-" + terms.get(0).getTermDisplayName());
 480             terms.get(0).setTermName("updated-" + terms.get(0).getTermName());
 481             locationsCommon.setLocTermGroupList(termList);
 482
 483             return locationsCommon;
 484
 485         }
 486
 487         @Override
 488         protected void compareUpdatedItemInstances(LocationsCommon original,
 489                         LocationsCommon updated) throws Exception {
 490             LocTermGroupList originalTermList = original.getLocTermGroupList();
 491             Assert.assertNotNull(originalTermList);
 492             List<LocTermGroup> originalTerms = originalTermList.getLocTermGroup();
 493             Assert.assertNotNull(originalTerms);
 494             Assert.assertTrue(originalTerms.size() > 0);
 495
 496             LocTermGroupList updatedTermList = updated.getLocTermGroupList();
 497             Assert.assertNotNull(updatedTermList);
 498             List<LocTermGroup> updatedTerms = updatedTermList.getLocTermGroup();
 499             Assert.assertNotNull(updatedTerms);
 500             Assert.assertTrue(updatedTerms.size() > 0);
 501
 502             Assert.assertEquals(updatedTerms.get(0).getTermDisplayName(),
 503                 originalTerms.get(0).getTermDisplayName(),
 504                 "Value in updated record did not match submitted data.");
 505         }
 506
 507         @Override
 508         protected void verifyReadItemInstance(LocationsCommon item)
 509                         throws Exception {
 510                 // TODO Auto-generated method stub
 511
 512         }
 513
 514         @Override
 515         protected PoxPayloadOut createNonExistenceItemInstance(
 516                         String commonPartName, String identifier) {
 517             Map<String, String> nonexMap = new HashMap<String, String>();
 518             nonexMap.put(LocationJAXBSchema.SHORT_IDENTIFIER, "nonExistent");
 519             final String EMPTY_REFNAME = "";
 520             PoxPayloadOut result =
 521                 LocationAuthorityClientUtils.createLocationInstance(EMPTY_REFNAME, nonexMap,
 522                 LocationAuthorityClientUtils.getTermGroupInstance(""), commonPartName);
 523             return result;
 524
 525         }
 526 }