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.io.UnsupportedEncodingException;
  26 import java.net.URLEncoder;
  27 import java.util.ArrayList;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31 import javax.ws.rs.core.Response;
  32
  33 import org.collectionspace.services.PersonJAXBSchema;
  34 import org.collectionspace.services.client.CollectionSpaceClient;
  35 import org.collectionspace.services.client.PersonAuthorityClient;
  36 import org.collectionspace.services.client.PersonAuthorityClientUtils;
  37 import org.collectionspace.services.client.PoxPayloadOut;
  38 import org.collectionspace.services.jaxb.AbstractCommonList;
  39 import org.jboss.resteasy.client.ClientResponse;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42 import org.testng.Assert;
  43 import org.testng.annotations.AfterClass;
  44 import org.testng.annotations.BeforeClass;
  45 import org.testng.annotations.Test;
  46
  47 /**
  48  * PersonAuthoritySearchTest, carries out search (e.g. partial
  49  * term matching) tests against a deployed and running PersonAuthority Service.
  50  *
  51  * $LastChangedRevision: 753 $
  52  * $LastChangedDate: 2009-09-23 11:03:36 -0700 (Wed, 23 Sep 2009) $
  53  */
  54 public class PersonAuthoritySearchTest extends BaseServiceTest<AbstractCommonList> {
  55
  56     private final String CLASS_NAME = PersonAuthoritySearchTest.class.getName();
  57     private final Logger logger = LoggerFactory.getLogger(CLASS_NAME);
  58
  59         @Override
  60         public String getServicePathComponent() {
  61                 return PersonAuthorityClient.SERVICE_PATH_COMPONENT;
  62         }
  63
  64         @Override
  65         protected String getServiceName() {
  66                 return PersonAuthorityClient.SERVICE_NAME;
  67         }
  68
  69     final String UTF8_CHARSET_NAME = "UTF-8";
  70
  71     // Test name for partial term matching: Lech Wałęsa
  72     //
  73     // For details regarding the łę characters in the last name, see:
  74     // http://en.wikipedia.org/wiki/L_with_stroke
  75     // http://en.wikipedia.org/wiki/%C4%98
  76     //
  77     // Forename
  78     final String TEST_PARTIAL_TERM_FORE_NAME = "Lech";
  79     //
  80     // Surname (contains single quote character)
  81     final String TEST_PARTIAL_TERM_SUR_NAME_QUOTE = "O'Hara";
  82     //
  83     // Surname (contains two non-USASCII range Unicode UTF-8 characters)
  84     final String TEST_PARTIAL_TERM_SUR_NAME_UNICODE = "Wałęsa";
  85         // Wrong: "Wa" + "\u0142" + "\u0119" + "sa";
  86         // Should also work: "Wa" + '\u0142' + '\u0119' + "sa";
  87         // Should also work: "Wa\u0142\u0119sa";
  88     //
  89     //
  90     // Displayname
  91     final String TEST_PARTIAL_TERM_DISPLAY_NAME_UNICODE =
  92             TEST_PARTIAL_TERM_FORE_NAME + " " + TEST_PARTIAL_TERM_SUR_NAME_UNICODE;
  93     //
  94     // Displayname
  95     final String TEST_PARTIAL_TERM_DISPLAY_NAME_QUOTE =
  96             TEST_PARTIAL_TERM_FORE_NAME + " " + TEST_PARTIAL_TERM_SUR_NAME_QUOTE;
  97     //
  98     // shortId
  99     final String TEST_SHORT_ID_UNICODE = "lechWalesa";
 100     //
 101     // shortId
 102     final String TEST_SHORT_ID_QUOTE = "lechOHara";
 103
 104     final String TEST_KWD_BIRTH_PLACE = "Popowo, Poland";
 105
 106     final String TEST_KWD_UTF8_STYLE = "Appliqu"+'\u00e8'+"d Arts";
 107
 108     final String TEST_KWD_BIO_NOTE_NO_QUOTES =
 109         "This is a silly bionote with no so-called quotes.";
 110
 111     final String TEST_KWD_BIO_NOTE_DBL_QUOTES =
 112         "This is a silly \"bionote\" for testing so called quote_handling";
 113
 114     final String TEST_KWD_NO_MATCH = "Foobar";
 115
 116     // Non-existent partial term name (first letters of each of the words
 117     // in a pangram for the English alphabet).
 118     private static final String TEST_PARTIAL_TERM_NON_EXISTENT = "jlmbsoq";
 119
 120     /** The known resource id. */
 121     private String knownResourceId = null;
 122
 123     /** The known resource ref name. */
 124     //private String knownResourceRefName = null;
 125
 126     /** The known item resource id. */
 127     private String knownItemResourceId = null;
 128
 129     // The resource ID of an item resource used for partial term matching tests.
 130     private String knownItemPartialTermResourceId = null;
 131
 132     private List<String> allResourceIdsCreated = new ArrayList<String>();
 133
 134     /** The all item resource ids created. */
 135     private Map<String, String> allItemResourceIdsCreated =
 136         new HashMap<String, String>();
 137
 138     // The number of matches expected on each partial term.
 139     final int NUM_MATCHES_EXPECTED_COMMON = 2;
 140     final int NUM_MATCHES_EXPECTED_SPECIFIC = 1;
 141
 142     // The minimum number of characters that must be included
 143     // a partial term, in order to permit matching to occur.
 144     final int PARTIAL_TERM_MIN_LENGTH = 1;
 145
 146     /* (non-Javadoc)
 147      * @see org.collectionspace.services.client.test.BaseServiceTest#getClientInstance()
 148      */
 149     @Override
 150     protected CollectionSpaceClient getClientInstance() {
 151         return new PersonAuthorityClient();
 152     }
 153
 154     /* (non-Javadoc)
 155      * @see org.collectionspace.services.client.test.BaseServiceTest#getAbstractCommonList(org.jboss.resteasy.client.ClientResponse)
 156      */
 157     @Override
 158     protected AbstractCommonList getCommonList(
 159                     ClientResponse<AbstractCommonList> response) {
 160     return response.getEntity(AbstractCommonList.class);
 161     }
 162
 163     private String getPartialTermCommon() {
 164         return TEST_PARTIAL_TERM_FORE_NAME;
 165     }
 166
 167     private String getPartialTermUtf8() {
 168         return TEST_PARTIAL_TERM_SUR_NAME_UNICODE;
 169     }
 170
 171     private String getPartialTermQuote() {
 172         return TEST_PARTIAL_TERM_SUR_NAME_QUOTE;
 173     }
 174
 175     private String getPartialTermNonExistent() {
 176         return TEST_PARTIAL_TERM_NON_EXISTENT;
 177     }
 178
 179     private String getPartialTermMinimumLength() {
 180         String partialTerm = getPartialTermCommon();
 181         if (partialTerm == null || partialTerm.trim().isEmpty()) {
 182             return partialTerm;
 183         }
 184         if (partialTerm.length() > PARTIAL_TERM_MIN_LENGTH) {
 185             return partialTerm.substring(0, PARTIAL_TERM_MIN_LENGTH);
 186         } else {
 187           return partialTerm;
 188         }
 189     }
 190
 191     private String getKwdTerm() {
 192         return TEST_KWD_BIRTH_PLACE;
 193     }
 194
 195     private String getKwdTermUTF8() {
 196         return TEST_KWD_UTF8_STYLE;
 197     }
 198
 199     private String getKwdTermNonExistent() {
 200         return TEST_KWD_NO_MATCH;
 201     }
 202
 203     @BeforeClass
 204     public void setup() {
 205         try {
 206             createAuthority();
 207         } catch (Exception e) {
 208             Assert.fail("Could not create new Authority for search tests.", e);
 209         }
 210         try {
 211             createItemsInAuthorityForPartialTermMatch(knownResourceId, null ); //knownResourceRefName);
 212         } catch (Exception e) {
 213             Assert.fail("Could not create new item in Authority for search tests.", e);
 214         }
 215     }
 216
 217     // ---------------------------------------------------------------
 218     // CRUD tests : READ_LIST tests by partial term match.
 219     // ---------------------------------------------------------------
 220
 221     // Success outcomes
 222
 223     /**
 224      * Reads an item list by partial term.
 225      */
 226     @Test(dataProvider="testName", groups = {"readListByPartialTerm"})
 227     public void partialTermMatch(String testName) {
 228         int numMatchesFound = 0;
 229         String partialTerm = getPartialTermCommon();
 230         if (logger.isDebugEnabled()) {
 231             logger.debug("Attempting match on partial term '" + partialTerm + "' ...");
 232         }
 233         numMatchesFound = readItemListWithFilters(testName, knownResourceId, partialTerm, null);
 234         if (logger.isDebugEnabled()) {
 235             logger.debug("Found " + numMatchesFound + " match(es), expected " +
 236                 NUM_MATCHES_EXPECTED_COMMON + " match(es).");
 237         }
 238         Assert.assertEquals(numMatchesFound, NUM_MATCHES_EXPECTED_COMMON);
 239     }
 240
 241     /**
 242      * Reads an item list by partial term, with a partial term that consists
 243      * of an all-lowercase variation of the expected match, to test case-insensitive
 244      * matching.
 245      */
 246     @Test(dataProvider="testName", groups = {"readListByPartialTerm"},
 247                 dependsOnMethods = {"partialTermMatch"})
 248     public void partialTermMatchCaseInsensitiveLowerCase(String testName) {
 249         int numMatchesFound = 0;
 250
 251         final String partialTerm = getPartialTermCommon().toLowerCase();
 252         if (logger.isDebugEnabled()) {
 253             logger.debug("Attempting match on partial term '" + partialTerm + "' ...");
 254         }
 255         numMatchesFound =
 256                 readItemListWithFilters(testName, knownResourceId, partialTerm, null);
 257                 if (logger.isDebugEnabled()) {
 258         logger.debug("Found " + numMatchesFound + " match(es), expected " +
 259                         NUM_MATCHES_EXPECTED_COMMON + " match(es).");
 260         }
 261         Assert.assertEquals(numMatchesFound, NUM_MATCHES_EXPECTED_COMMON);
 262     }
 263
 264     /**
 265      * Reads an item list by partial term, with a partial term that consists
 266      * of an all-uppercase variation of the expected match, to test case-insensitive
 267      * matching.
 268      */
 269     @Test(dataProvider="testName",
 270         groups = {"readListByPartialTerm"}, dependsOnMethods = {"partialTermMatch"})
 271     public void partialTermMatchCaseInsensitiveUpperCase(String testName) {
 272         int numMatchesFound = 0;
 273
 274         final String partialTerm = getPartialTermCommon().toUpperCase();
 275         if (logger.isDebugEnabled()) {
 276             logger.debug("Attempting match on partial term '" + partialTerm + "' ...");
 277         }
 278         numMatchesFound =
 279                 readItemListWithFilters(testName, knownResourceId, partialTerm, null);
 280         if (logger.isDebugEnabled()) {
 281             logger.debug("Found " + numMatchesFound + " match(es), expected " +
 282                         NUM_MATCHES_EXPECTED_COMMON + " match(es).");
 283         }
 284         Assert.assertEquals(numMatchesFound, NUM_MATCHES_EXPECTED_COMMON);
 285     }
 286
 287     /**
 288      * Reads an item list by partial term, with a partial term that is of
 289      * the minimum character length that may be expected to be matched.
 290      */
 291     @Test(dataProvider="testName",
 292         groups = {"readListByPartialTerm"}, dependsOnMethods = {"partialTermMatch"})
 293     public void partialTermMatchMinimumLength(String testName) {
 294         int numMatchesFound = 0;
 295         String partialTerm = getPartialTermMinimumLength();
 296         if (logger.isDebugEnabled()) {
 297             logger.debug("Attempting match on partial term '" + partialTerm + "' ...");
 298         }
 299         numMatchesFound = readItemListWithFilters(testName, knownResourceId, partialTerm, null);
 300         // Zero matches are expected on a non-existent term.
 301         if (logger.isDebugEnabled()) {
 302             logger.debug("Found " + numMatchesFound + " match(es), expected " +
 303                         NUM_MATCHES_EXPECTED_COMMON + " match(es).");
 304         }
 305         Assert.assertEquals(numMatchesFound, NUM_MATCHES_EXPECTED_COMMON);
 306     }
 307
 308     /**
 309      * Reads an item list by partial term, with a partial term that contains
 310      * at least one Unicode UTF-8 character (outside the USASCII range).
 311      */
 312     @Test(dataProvider="testName",
 313         groups = {"readListByPartialTerm"}, dependsOnMethods = {"partialTermMatch"})
 314     public void partialTermMatchUTF8(String testName) {
 315         int numMatchesFound = 0;
 316         String partialTerm = getPartialTermUtf8();
 317         String ptEncoded;
 318         try {
 319                 ptEncoded = URLEncoder.encode(partialTerm, UTF8_CHARSET_NAME);
 320         }
 321         catch (UnsupportedEncodingException ex) {
 322           throw new RuntimeException("Broken VM does not support UTF-8");
 323         }
 324         if (logger.isDebugEnabled()) {
 325             logger.debug("Attempting match on partial term '" + partialTerm + "', Encoded:'"+ptEncoded+"' ...");
 326         }
 327         numMatchesFound =
 328                 readItemListWithFilters(testName, knownResourceId, partialTerm, null);
 329         if (logger.isDebugEnabled()) {
 330             logger.debug("Found " + numMatchesFound + " match(es), expected " +
 331                 NUM_MATCHES_EXPECTED_SPECIFIC + " match(es).");
 332         }
 333         Assert.assertEquals(numMatchesFound, NUM_MATCHES_EXPECTED_SPECIFIC);
 334     }
 335
 336     /**
 337      * Reads an item list by partial term, with a partial term that contains
 338      * at least one Unicode UTF-8 character (outside the USASCII range).
 339      */
 340     @Test(dataProvider="testName",
 341         groups = {"readListByPartialTerm"}, dependsOnMethods = {"partialTermMatch"})
 342     public void partialTermMatchQuote(String testName) {
 343         int numMatchesFound = 0;
 344         String partialTerm = getPartialTermQuote();
 345         if (logger.isDebugEnabled()) {
 346             logger.debug("Attempting match on partial term '" + partialTerm + "' ...");
 347         }
 348         numMatchesFound =
 349                 readItemListWithFilters(testName, knownResourceId, partialTerm, null);
 350         if (logger.isDebugEnabled()) {
 351             logger.debug("Found " + numMatchesFound + " match(es), expected " +
 352                 NUM_MATCHES_EXPECTED_SPECIFIC + " match(es).");
 353         }
 354         Assert.assertEquals(numMatchesFound, NUM_MATCHES_EXPECTED_SPECIFIC);
 355     }
 356
 357     /**
 358      * Finds terms by keywords.
 359      */
 360     @Test(dataProvider="testName", groups = {"readListByKwdTerm"})
 361     public void keywordTermMatch(String testName) {
 362         int numMatchesFound = 0;
 363         String kwdTerm = getKwdTerm();
 364         if (logger.isDebugEnabled()) {
 365             logger.debug("Attempting match on kwd term '" + kwdTerm + "' ...");
 366         }
 367         numMatchesFound = readItemListWithFilters(testName, knownResourceId, null, kwdTerm);
 368         if (logger.isDebugEnabled()) {
 369             logger.debug("Found " + numMatchesFound + " match(es), expected " +
 370                     NUM_MATCHES_EXPECTED_COMMON + " match(es).");
 371         }
 372         Assert.assertEquals(numMatchesFound, NUM_MATCHES_EXPECTED_COMMON);
 373     }
 374
 375     /**
 376      * Finds terms by keywords.
 377      */
 378     @Test(dataProvider="testName",
 379         groups = {"readListByKwdTerm"}, dependsOnMethods = {"keywordTermMatch"})
 380     public void keywordTermMatchUTF8(String testName) {
 381         int numMatchesFound = 0;
 382         String kwdTerm = getKwdTermUTF8();
 383         if (logger.isDebugEnabled()) {
 384             logger.debug("Attempting match on kwd term '" + kwdTerm + "' ...");
 385         }
 386         numMatchesFound = readItemListWithFilters(testName, knownResourceId, null, kwdTerm);
 387         if (logger.isDebugEnabled()) {
 388             logger.debug("Found " + numMatchesFound + " match(es), expected " +
 389                 NUM_MATCHES_EXPECTED_COMMON + " match(es).");
 390         }
 391         Assert.assertEquals(numMatchesFound, NUM_MATCHES_EXPECTED_COMMON);
 392     }
 393
 394
 395
 396     // Failure outcomes
 397
 398     /**
 399      * Reads an item list by partial term, with a partial term that is not
 400      * expected to be matched by any term in any resource.
 401      */
 402     @Test(dataProvider="testName",
 403         groups = {"readListByPartialTerm"}, dependsOnMethods = {"partialTermMatch"})
 404     public void partialTermMatchOnNonexistentTerm(String testName) {
 405         int numMatchesFound = 0;
 406         int ZERO_MATCHES_EXPECTED = 0;
 407         String partialTerm = getPartialTermNonExistent();
 408         if (logger.isDebugEnabled()) {
 409             logger.debug("Attempting match on partial term '" + partialTerm + "' ...");
 410         }
 411         numMatchesFound = readItemListWithFilters(testName, knownResourceId, partialTerm, null);
 412         // Zero matches are expected on a non-existent term.
 413         if (logger.isDebugEnabled()) {
 414             logger.debug("Found " + numMatchesFound + " match(es), expected " +
 415                 ZERO_MATCHES_EXPECTED + " match(es).");
 416         }
 417         Assert.assertEquals(numMatchesFound, ZERO_MATCHES_EXPECTED);
 418     }
 419
 420     /**
 421      * Reads an item list by partial term, with a partial term that is not
 422      * expected to be matched by any term in any resource.
 423      */
 424     @Test(dataProvider="testName", groups = {"readListByKwdTerm"},
 425                 dependsOnMethods = {"keywordTermMatch"})
 426     public void keywordTermMatchOnNonexistentTerm(String testName) {
 427         int numMatchesFound = 0;
 428         int ZERO_MATCHES_EXPECTED = 0;
 429         String kwdTerm = getKwdTermNonExistent();
 430         if (logger.isDebugEnabled()) {
 431             logger.debug("Attempting match on kwd term '" + kwdTerm + "' ...");
 432         }
 433         numMatchesFound = readItemListWithFilters(testName, knownResourceId, null, kwdTerm);
 434         // Zero matches are expected on a non-existent term.
 435         if (logger.isDebugEnabled()) {
 436             logger.debug("Found " + numMatchesFound + " match(es), expected " +
 437                 ZERO_MATCHES_EXPECTED + " match(es).");
 438         }
 439         Assert.assertEquals(numMatchesFound, ZERO_MATCHES_EXPECTED);
 440     }
 441
 442     /**
 443      * Reads an item list by partial term or keywords, given an authority and a term.
 444      * Only one of partialTerm or keywords should be specified.
 445      * If both are specified, keywords will be ignored.
 446      *
 447      * @param testName Calling test name
 448      * @param authorityCsid The CSID of the authority within which partial term matching
 449      *     will be performed.
 450      * @param partialTerm A partial term to match item resources.
 451      * @param partialTerm A keyword list to match item resources.
 452      * @return The number of item resources matched by the partial term.
 453      */
 454     private int readItemListWithFilters(String testName,
 455                 String authorityCsid, String partialTerm, String keywords) {
 456
 457         // Perform setup.
 458         int expectedStatusCode = Response.Status.OK.getStatusCode();
 459         ServiceRequestType requestType = ServiceRequestType.READ_LIST;
 460         testSetup(expectedStatusCode, requestType);
 461
 462         // Submit the request to the service and store the response.
 463         PersonAuthorityClient client = new PersonAuthorityClient();
 464         ClientResponse<AbstractCommonList> res = null;
 465         if (authorityCsid != null) {
 466                 res = client.readItemList(authorityCsid, partialTerm, keywords);
 467         } else {
 468             Assert.fail("readItemListByPartialTerm passed null csid!");
 469         }
 470         AbstractCommonList list = null;
 471         try {
 472             assertStatusCode(res, testName);
 473             list = res.getEntity();
 474         } finally {
 475                 if (res != null) {
 476                 res.releaseConnection();
 477             }
 478         }
 479
 480         List<AbstractCommonList.ListItem> items = list.getListItem();
 481         int nItemsReturned = items.size();
 482
 483         return nItemsReturned;
 484     }
 485
 486     // ---------------------------------------------------------------
 487     // Cleanup of resources created during testing
 488     // ---------------------------------------------------------------
 489
 490     /**
 491      * Deletes all resources created by tests, after all tests have been run.
 492      *
 493      * This cleanup method will always be run, even if one or more tests fail.
 494      * For this reason, it attempts to remove all resources created
 495      * at any point during testing, even if some of those resources
 496      * may be expected to be deleted by certain tests.
 497      */
 498     @AfterClass(alwaysRun=true)
 499     public void cleanUp() {
 500         String noTest = System.getProperty("noTestCleanup");
 501         if(Boolean.TRUE.toString().equalsIgnoreCase(noTest)) {
 502             if (logger.isDebugEnabled()) {
 503                 logger.debug("Skipping Cleanup phase ...");
 504             }
 505             return;
 506         }
 507         if (logger.isDebugEnabled()) {
 508             logger.debug("Cleaning up temporary resources created for testing ...");
 509         }
 510         String parentResourceId;
 511         String itemResourceId;
 512         PersonAuthorityClient client = new PersonAuthorityClient();
 513         parentResourceId = knownResourceId;
 514         // Clean up item resources.
 515         for (Map.Entry<String, String> entry : allItemResourceIdsCreated.entrySet()) {
 516             itemResourceId = entry.getKey();
 517             parentResourceId = entry.getValue();
 518             // Note: Any non-success responses from the delete operation
 519             // below are ignored and not reported.
 520             ClientResponse<Response> res =
 521                 client.deleteItem(parentResourceId, itemResourceId);
 522             res.releaseConnection();
 523         }
 524         // Clean up authority resources.
 525         for (String resourceId : allResourceIdsCreated) {
 526             // Note: Any non-success responses are ignored and not reported.
 527             client.delete(resourceId).releaseConnection();
 528         }
 529     }
 530
 531     // ---------------------------------------------------------------
 532     // Utility methods used by tests above
 533     // ---------------------------------------------------------------
 534
 535     // ---------------------------------------------------------------
 536     // Utilities: setup routines for search tests
 537     // ---------------------------------------------------------------
 538
 539     public void createAuthority() throws Exception {
 540
 541         String testName = "createAuthority";
 542         if (logger.isDebugEnabled()) {
 543             logger.debug(getTestBanner(testName, CLASS_NAME));
 544         }
 545
 546         // Perform setup.
 547         int expectedStatusCode = Response.Status.CREATED.getStatusCode();
 548         ServiceRequestType requestType = ServiceRequestType.CREATE;
 549         testSetup(expectedStatusCode, requestType);
 550
 551         // Submit the request to the service and store the response.
 552         PersonAuthorityClient client = new PersonAuthorityClient();
 553         String shortId = createIdentifier();
 554         String displayName = "displayName-" + shortId;
 555         //String baseRefName = PersonAuthorityClientUtils.createPersonAuthRefName(shortId, null);
 556         PoxPayloadOut multipart =
 557             PersonAuthorityClientUtils.createPersonAuthorityInstance(
 558             displayName, shortId, client.getCommonPartName());
 559
 560         String newID = null;
 561         ClientResponse<Response> res = client.create(multipart);
 562         try {
 563             assertStatusCode(res, testName);
 564             newID = PersonAuthorityClientUtils.extractId(res);
 565         } finally {
 566                 if (res != null) {
 567                 res.releaseConnection();
 568             }
 569         }
 570         // Store the refname from the first resource created
 571         // for additional tests below.
 572         //knownResourceRefName = baseRefName;
 573         // Store the ID returned from the first resource created
 574         // for additional tests below.
 575         if (knownResourceId == null){
 576             knownResourceId = newID;
 577             //knownResourceRefName = baseRefName;
 578         }
 579
 580         // Store the IDs from every resource created by tests,
 581         // so they can be deleted after tests have been run.
 582         allResourceIdsCreated.add(newID);
 583     }
 584
 585      /**
 586      * Creates an item in the authority, used for partial term matching tests.
 587      *
 588      * @param authorityCsid The CSID of the Authority in which the term will be created.
 589      * @param authRefName The refName of the Authority in which the term will be created.
 590      */
 591     private void createItemsInAuthorityForPartialTermMatch(
 592                 String authorityCsid, String authRefName)
 593         throws Exception {
 594
 595         String testName = "createItemsInAuthorityForPartialTermMatch";
 596
 597         int expectedStatusCode = Response.Status.CREATED.getStatusCode();
 598         ServiceRequestType requestType = ServiceRequestType.CREATE;
 599         testSetup(expectedStatusCode, requestType);
 600
 601         // Submit the request to the service and store the response.
 602         PersonAuthorityClient client = new PersonAuthorityClient();
 603         Map<String, String> partialTermPersonMap = new HashMap<String,String>();
 604         //
 605         // Fill the property map for the UNICODE item
 606         //
 607         partialTermPersonMap.put(PersonJAXBSchema.SHORT_IDENTIFIER, TEST_SHORT_ID_UNICODE );
 608         partialTermPersonMap.put(PersonJAXBSchema.DISPLAY_NAME_COMPUTED, "false");
 609         partialTermPersonMap.put(PersonJAXBSchema.DISPLAY_NAME, TEST_PARTIAL_TERM_DISPLAY_NAME_UNICODE);
 610         partialTermPersonMap.put(PersonJAXBSchema.FORE_NAME, TEST_PARTIAL_TERM_FORE_NAME);
 611         partialTermPersonMap.put(PersonJAXBSchema.SUR_NAME, TEST_PARTIAL_TERM_SUR_NAME_UNICODE);
 612         partialTermPersonMap.put(PersonJAXBSchema.BIRTH_PLACE, TEST_KWD_BIRTH_PLACE);
 613         partialTermPersonMap.put(PersonJAXBSchema.GENDER, "male");
 614         partialTermPersonMap.put(PersonJAXBSchema.BIO_NOTE, TEST_KWD_BIO_NOTE_NO_QUOTES);
 615
 616         Map<String, List<String>> partialTermRepeatablesMap = new HashMap<String, List<String>>();
 617         ArrayList<String> styles = new ArrayList<String>();
 618         styles.add(TEST_KWD_UTF8_STYLE);
 619         partialTermRepeatablesMap.put(PersonJAXBSchema.SCHOOLS_OR_STYLES, styles);
 620
 621         createItem(testName, authorityCsid, null /*authRefName*/, client,
 622                 partialTermPersonMap, partialTermRepeatablesMap);
 623         //
 624         // Adjust the property map for the QUOTE item
 625         //
 626         partialTermPersonMap.put(PersonJAXBSchema.SHORT_IDENTIFIER, TEST_SHORT_ID_QUOTE );
 627         partialTermPersonMap.put(PersonJAXBSchema.DISPLAY_NAME, TEST_PARTIAL_TERM_DISPLAY_NAME_QUOTE);
 628         partialTermPersonMap.put(PersonJAXBSchema.SUR_NAME, TEST_PARTIAL_TERM_SUR_NAME_QUOTE);
 629         partialTermPersonMap.put(PersonJAXBSchema.BIO_NOTE, TEST_KWD_BIO_NOTE_DBL_QUOTES);
 630
 631         createItem(testName, authorityCsid, null /*authRefName*/, client,
 632                 partialTermPersonMap, partialTermRepeatablesMap);
 633     }
 634
 635     private void createItem(
 636                 String testName,
 637                 String authorityCsid,
 638                 String authRefName,
 639                 PersonAuthorityClient client,
 640                 Map<String, String> partialTermPersonMap,
 641                 Map<String, List<String>> partialTermRepeatablesMap) throws Exception {
 642         PoxPayloadOut multipart =
 643             PersonAuthorityClientUtils.createPersonInstance(authorityCsid, null, //authRefName,
 644                 partialTermPersonMap, partialTermRepeatablesMap, client.getItemCommonPartName() );
 645
 646         String newID = null;
 647         ClientResponse<Response> res = client.createItem(authorityCsid, multipart);
 648         try {
 649             newID = PersonAuthorityClientUtils.extractId(res);
 650         } finally {
 651                 if (res != null) {
 652                 res.releaseConnection();
 653             }
 654         }
 655
 656         // Store the ID returned from the first item resource created
 657         // for additional tests below.
 658         if (knownItemResourceId == null){
 659             knownItemResourceId = newID;
 660             if (logger.isDebugEnabled()) {
 661                 logger.debug(testName + ": knownItemPartialTermResourceId=" + knownItemPartialTermResourceId);
 662             }
 663         }
 664
 665         // Store the IDs from any item resources created
 666         // by tests, along with the IDs of their parents, so these items
 667         // can be deleted after all tests have been run.
 668         allItemResourceIdsCreated.put(newID, authorityCsid);
 669     }
 670
 671 }