Example #1
0
 @Test
 public void testResetNew() throws Exception {
   SpecimenWrapper newSpec = SpecimenHelper.newSpecimen(parentSpc.getSpecimenType());
   newSpec.setInventoryId("toto");
   newSpec.reset();
   Assert.assertEquals(null, newSpec.getInventoryId());
 }
Example #2
0
  @Test
  public void testCheckPosition() throws Exception {
    ContainerWrapper container = childSpc.getParentContainer();

    Assert.assertFalse(container.isPositionFree(childSpc.getPosition()));
    Assert.assertTrue(container.isPositionFree(new RowColPos(2, 3)));
  }
Example #3
0
  @Test
  public void testPersistCheckInventoryIdUniqueCaseSensitive()
      throws BiobankCheckException, Exception {
    int i = r.nextInt();
    parentSpc.setInventoryId("toto" + i);
    parentSpc.persist();

    SpecimenWrapper duplicate =
        SpecimenHelper.newSpecimen(
            parentSpc,
            childSpc.getSpecimenType(),
            ActivityStatus.ACTIVE,
            childSpc.getProcessingEvent(),
            childSpc.getParentContainer(),
            2,
            2);
    duplicate.setInventoryId("toto" + i);

    try {
      duplicate.persist();
      Assert.fail("same inventory id !");
    } catch (DuplicatePropertySetException dee) {
      Assert.assertTrue(true);
    }

    duplicate.setInventoryId("TOTO" + r.nextInt());
    duplicate.persist();
  }
Example #4
0
 @Test
 public void testResetAlreadyInDatabase() throws Exception {
   parentSpc.persist();
   String old = parentSpc.getInventoryId();
   parentSpc.setInventoryId("toto");
   parentSpc.reset();
   Assert.assertEquals(old, parentSpc.getInventoryId());
 }
Example #5
0
  @Test
  public void testGetFormattedLinkDate() throws Exception {
    Date date = Utils.getRandomDate();
    parentSpc.setCreatedAt(date);

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    Assert.assertTrue(sdf.format(date).equals(parentSpc.getFormattedCreatedAt()));
  }
Example #6
0
 @Test
 public void testCheckProcessingEventNotNull() throws BiobankCheckException, Exception {
   parentSpc.setCollectionEvent(null);
   try {
     parentSpc.persist();
     Assert.fail("Patient visit should be set!");
   } catch (ValueNotSetException vnse) {
     Assert.assertTrue(true);
   }
 }
Example #7
0
  @Test
  public void testGetSpecimen() throws Exception {
    SpecimenWrapper foundSpecimen =
        SpecimenWrapper.getSpecimen(appService, childSpc.getInventoryId());
    Assert.assertNotNull(foundSpecimen);
    Assert.assertEquals(foundSpecimen, childSpc);

    foundSpecimen = SpecimenWrapper.getSpecimen(appService, Utils.getRandomString(5));
    Assert.assertNull(foundSpecimen);
    Assert.fail("how to test the exception throwing?");
  }
Example #8
0
 @Test
 public void testPersistFailActivityStatusNull() throws Exception {
   parentSpc.setActivityStatus(null);
   try {
     parentSpc.persist();
     Assert.fail("Should not insert the specimen : no activity status");
   } catch (ValueNotSetException vnse) {
     Assert.assertTrue(true);
   }
   parentSpc.setActivityStatus(ActivityStatus.ACTIVE);
   parentSpc.persist();
 }
Example #9
0
 @Test
 public void testHasUnknownImportType() throws ApplicationException {
   Assert.assertFalse(childSpc.hasUnknownImportType());
   SpecimenTypeWrapper unknownType = null;
   for (SpecimenTypeWrapper type :
       SpecimenTypeWrapper.getAllSourceOnlySpecimenTypes(appService, false)) {
     if (type.isUnknownImport()) {
       unknownType = type;
       break;
     }
   }
   childSpc.setSpecimenType(unknownType);
   Assert.assertTrue(childSpc.hasUnknownImportType());
 }
Example #10
0
  @Test
  public void testPersistCheckParentAcceptSpecimenType() throws BiobankCheckException, Exception {
    SpecimenTypeWrapper oldSpecimenType = childSpc.getSpecimenType();

    SpecimenTypeWrapper type2 = SpecimenTypeHelper.addSpecimenType("sampletype_2");
    childSpc.setSpecimenType(type2);
    try {
      childSpc.persist();
      Assert.fail("Container can't hold this type !");
    } catch (InvalidOptionException e) {
      Assert.assertTrue(true);
    }

    childSpc.setSpecimenType(oldSpecimenType);
    childSpc.persist();
  }
Example #11
0
  @Test
  public void testGetPositionString() throws Exception {
    childSpc.setParentFromPositionString("A1", childSpc.getParentContainer());
    Assert.assertTrue(childSpc.getPositionString(false, false).equals("A1"));
    String parentLabel = childSpc.getParentContainer().getLabel();
    Assert.assertTrue(childSpc.getPositionString(true, false).equals(parentLabel + "A1"));
    // getPositionString with no parameters is equivalent to
    // getPositionString(true, true)
    Assert.assertTrue(
        childSpc
            .getPositionString()
            .equals(parentLabel + "A1 (" + topContainer.getContainerType().getNameShort() + ")"));

    childSpc.setParent(null, null);
    Assert.assertNull(childSpc.getPositionString(false, false));
  }
Example #12
0
  @Test
  public void testGetSetSpecimenType() throws BiobankCheckException, Exception {
    SpecimenTypeWrapper stw = parentSpc.getSpecimenType();
    SpecimenTypeWrapper newType = SpecimenTypeHelper.addSpecimenType("newStw");
    stw.persist();
    Assert.assertTrue(stw.getId() != newType.getId());
    parentSpc.setSpecimenType(newType);
    Assert.assertTrue(newType.getId() == parentSpc.getSpecimenType().getId());

    SpecimenWrapper sample1 = new SpecimenWrapper(appService);
    sample1.setSpecimenType(null);
    Assert.assertNull(sample1.getSpecimenType());
  }
Example #13
0
  @Test
  public void testGetCenterString() throws Exception {
    String name = "testGetCenterString" + r.nextInt();
    ClinicWrapper clinic = ClinicHelper.addClinic(name);
    StudyWrapper study = StudyHelper.addStudy(name);
    PatientWrapper patient = PatientHelper.addPatient(name, study);

    SpecimenWrapper spc = SpecimenHelper.addParentSpecimen(clinic, study, patient);

    Assert.assertTrue(spc.getCenterString().equals(clinic.getNameShort()));

    spc.setCurrentCenter(null);
    spc.persist();
    Assert.assertFalse(spc.getCenterString().equals(clinic.getNameShort()));
    Assert.assertNotNull(spc.getCenterString());
    Assert.assertFalse("".equals(spc.getCenterString()));
  }
Example #14
0
  @Test
  public void testGetSetQuantityFromType() throws Exception {
    BigDecimal quantity = parentSpc.getQuantity();
    parentSpc.setQuantityFromType();
    // no sample storages defined yet, should be null
    Assert.assertTrue(quantity == null);

    ActivityStatus activeStatus = ActivityStatus.ACTIVE;

    AliquotedSpecimenWrapper ss1 = new AliquotedSpecimenWrapper(appService);
    ss1.setSpecimenType(SpecimenTypeHelper.addSpecimenType("ss1"));
    ss1.setVolume(new BigDecimal(1.0));
    ss1.setStudy(parentSpc.getCollectionEvent().getPatient().getStudy());
    ss1.setActivityStatus(activeStatus);
    ss1.persist();
    AliquotedSpecimenWrapper ss2 = new AliquotedSpecimenWrapper(appService);
    ss2.setSpecimenType(SpecimenTypeHelper.addSpecimenType("ss2"));
    ss2.setVolume(new BigDecimal(2.0));
    ss2.setStudy(parentSpc.getCollectionEvent().getPatient().getStudy());
    ss2.setActivityStatus(activeStatus);
    ss2.persist();
    AliquotedSpecimenWrapper ss3 = new AliquotedSpecimenWrapper(appService);
    ss3.setSpecimenType(parentSpc.getSpecimenType());
    ss3.setVolume(new BigDecimal(3.0));
    ss3.setStudy(parentSpc.getCollectionEvent().getPatient().getStudy());
    ss3.setActivityStatus(activeStatus);
    ss3.persist();
    parentSpc
        .getCollectionEvent()
        .getPatient()
        .getStudy()
        .addToAliquotedSpecimenCollection(Arrays.asList(ss1, ss2, ss3));
    // should be 3
    parentSpc.setQuantityFromType();
    Assert.assertTrue(parentSpc.getQuantity().equals(3.0));
  }
Example #15
0
  @Test
  public void testCheckInventoryIdUnique() throws BiobankCheckException, Exception {
    SpecimenWrapper duplicate =
        SpecimenHelper.newSpecimen(
            parentSpc,
            childSpc.getSpecimenType(),
            ActivityStatus.ACTIVE,
            childSpc.getProcessingEvent(),
            childSpc.getParentContainer(),
            2,
            2);

    duplicate.setInventoryId(parentSpc.getInventoryId());
    try {
      duplicate.checkInventoryIdUnique();
      Assert.fail("The check should detect that this is the same");
    } catch (DuplicateEntryException e) {
      Assert.assertTrue(true);
    }
  }
Example #16
0
  @Test
  public void testDelete() throws Exception {
    String name = "testDelete" + r.nextInt();
    SpecimenTypeWrapper type1 = childSpc.getSpecimenType();

    try {
      type1.delete();
      Assert.fail("cannot delete a type in use by a specimen");
    } catch (ModelIsUsedException e) {
      Assert.assertTrue(true);
    }

    SpecimenTypeWrapper type2 = SpecimenTypeHelper.addSpecimenType(name + "_st2");
    SpecimenTypeHelper.removeFromCreated(type2);

    ContainerTypeWrapper typeChild = childSpc.getParentContainer().getContainerType();

    typeChild.addToSpecimenTypeCollection(Arrays.asList(type2));
    typeChild.persist();

    childSpc.reload();
    childSpc.setSpecimenType(type2);
    childSpc.persist();

    try {
      type2.delete();
      Assert.fail("cannot delete a type in use by a specimen");
    } catch (ModelIsUsedException e) {
      Assert.assertTrue(true);
    }

    childSpc.setSpecimenType(type1);
    childSpc.persist();

    typeChild.removeFromSpecimenTypeCollectionWithCheck(Arrays.asList(type2));
    typeChild.persist();

    type2.delete();
  }
Example #17
0
 @Test
 public void testGetTop() throws Exception {
   Assert.assertFalse(childSpc.getParentContainer().equals(childSpc.getTop()));
   Assert.assertEquals(topContainer, childSpc.getTop());
 }
Example #18
0
 @Test
 public void testIsActive() {
   Assert.assertTrue(parentSpc.isActive());
 }
Example #19
0
 @Test
 public void testFlagged() {
   Assert.assertFalse(parentSpc.isFlagged());
   parentSpc.setActivityStatus(ActivityStatus.FLAGGED);
   Assert.assertTrue(parentSpc.isFlagged());
 }
Example #20
0
  @Test
  public void testSetQuantityFromType() throws Exception {
    SpecimenTypeWrapper type = parentSpc.getSpecimenType();
    Assert.assertNull(parentSpc.getQuantity());

    parentSpc.setSpecimenType(null);
    parentSpc.setQuantityFromType();
    // no specimen type, no change
    Assert.assertNull(parentSpc.getQuantity());

    parentSpc.setSpecimenType(type);
    parentSpc.setQuantityFromType();
    // no aliquotedspecimen with this type in study, no change
    Assert.assertNull(parentSpc.getQuantity());

    StudyWrapper study = parentSpc.getCollectionEvent().getPatient().getStudy();
    AliquotedSpecimenWrapper as =
        AliquotedSpecimenHelper.addAliquotedSpecimen(study, parentSpc.getSpecimenType());
    study.reload();
    Assert.assertNotNull(as.getVolume());
    Assert.assertTrue(!as.getVolume().equals(BigDecimal.ZERO));

    parentSpc.setQuantityFromType();

    Assert.assertTrue(as.getVolume().equals(parentSpc.getQuantity()));
  }
Example #21
0
 @Test
 public void testToString() {
   String res = parentSpc.toString();
   Assert.assertNotNull(res);
   Assert.assertFalse(res.isEmpty());
 }
Example #22
0
  /*
   * childSpc created in setUp()
   */
  @Test
  public void testGetDispatches() throws Exception {
    String name = "testGetDispatches" + r.nextInt();
    SiteWrapper destSite = SiteHelper.addSite(name);
    ShippingMethodWrapper method = ShippingMethodWrapper.getShippingMethods(appService).get(0);
    DispatchWrapper d = DispatchHelper.addDispatch(site, destSite, method);

    d.addSpecimens(Arrays.asList(childSpc), DispatchSpecimenState.NONE);
    d.persist();
    childSpc.reload();

    List<DispatchWrapper> specimenDispatches = childSpc.getDispatches();
    Assert.assertEquals(1, specimenDispatches.size());
    Assert.assertTrue(specimenDispatches.contains(d));

    Assert.assertTrue(d.isInCreationState());

    // site send specimens
    d.setState(DispatchState.IN_TRANSIT);
    d.persist();
    Assert.assertTrue(d.isInTransitState());

    // dest site receive specimen
    d.setState(DispatchState.RECEIVED);
    d.receiveSpecimens(Arrays.asList(childSpc));
    d.persist();
    Assert.assertTrue(d.isInReceivedState());

    // make sure spc now belongs to destSite
    destSite.reload();
    childSpc.reload();
    Assert.assertEquals(destSite, childSpc.getCurrentCenter());

    // dispatch specimen to second site
    SiteWrapper destSite2 = SiteHelper.addSite(name + "_2");

    DispatchWrapper d2 = DispatchHelper.addDispatch(destSite, destSite2, method);
    d2.addSpecimens(Arrays.asList(childSpc), DispatchSpecimenState.NONE);

    parentSpc.reload();
    // assign a position to this specimen
    ContainerTypeWrapper topType =
        ContainerTypeHelper.addContainerType(destSite, "ct11", "ct11", 1, 5, 6, true);
    ContainerWrapper topCont = ContainerHelper.addContainer("11", "11", destSite, topType);
    ContainerTypeWrapper childType =
        ContainerTypeHelper.addContainerType(destSite, "ct22", "ct22", 2, 4, 7, false);
    topType.addToChildContainerTypeCollection(Arrays.asList(childType));
    topType.persist();
    ContainerWrapper cont =
        ContainerHelper.addContainer("22", "22", topCont, destSite, childType, 4, 5);
    childType.addToSpecimenTypeCollection(Arrays.asList(childSpc.getSpecimenType()));
    childType.persist();
    cont.reload();
    cont.addSpecimen(2, 3, childSpc);
    parentSpc.persist();

    // add to new dispatch
    d2.addSpecimens(Arrays.asList(childSpc), DispatchSpecimenState.NONE);
    d2.persist();

    // make sure spc still belongs to destSite
    destSite2.reload();
    childSpc.reload();
    Assert.assertEquals(destSite2, childSpc.getCurrentCenter());

    childSpc.reload();
    specimenDispatches = childSpc.getDispatches();
    Assert.assertEquals(2, specimenDispatches.size());
    Assert.assertTrue(specimenDispatches.contains(d));
    Assert.assertTrue(specimenDispatches.contains(d2));
  }
Example #23
0
  @Test
  public void testGetSetPosition() throws Exception {
    RowColPos position = new RowColPos(1, 3);
    childSpc.setParent(childSpc.getParentContainer(), position);
    RowColPos newPosition = childSpc.getPosition();
    Assert.assertEquals(position.getRow(), newPosition.getRow());
    Assert.assertEquals(position.getCol(), newPosition.getCol());

    // ensure position remains after persist
    childSpc.persist();
    childSpc.reload();
    newPosition = childSpc.getPosition();
    Assert.assertEquals(position.getRow(), newPosition.getRow());
    Assert.assertEquals(position.getCol(), newPosition.getCol());

    // test setting position to null
    childSpc.setParent(null, null);
    childSpc.persist();
    childSpc.reload();
    Assert.assertEquals(null, childSpc.getPosition());
    Assert.assertEquals(null, childSpc.getParentContainer());
  }
Example #24
0
  @Test
  public void testDebugRandomMethods() throws Exception {
    System.out.println(parentSpc.getProcessingEvent());
    System.out.println(childSpc.getProcessingEvent());

    ContainerWrapper container = childSpc.getParentContainer();
    ContainerTypeWrapper containerType = container.getContainerType();
    SpecimenTypeWrapper spcType = containerType.getSpecimenTypeCollection(false).get(0);
    Assert.assertNotNull(spcType);

    System.out.println(parentSpc.getProcessingEvent());
    System.out.println(childSpc.getProcessingEvent());

    ProcessingEventWrapper pevent =
        ProcessingEventHelper.addProcessingEvent(
            childSpc.getCurrentCenter(), Utils.getRandomDate());

    // add aliquoted specimen
    SpecimenWrapper specimen =
        SpecimenHelper.newSpecimen(
            parentSpc,
            childSpc.getSpecimenType(),
            ActivityStatus.ACTIVE,
            childSpc.getProcessingEvent(),
            childSpc.getParentContainer(),
            2,
            3);
    specimen.setInventoryId(Utils.getRandomString(5));
    specimen.persist();

    pevent.addToSpecimenCollection(Arrays.asList(parentSpc));
    pevent.persist();

    SpecimenWrapper s2 =
        SpecimenHelper.newSpecimen(
            childSpc,
            childSpc.getSpecimenType(),
            ActivityStatus.ACTIVE,
            childSpc.getProcessingEvent(),
            childSpc.getParentContainer(),
            2,
            4);
    s2.setParent(null, null);
    s2.setParentSpecimen(null);
    s2.persist();

    try {
      // should find at least one specimen with a parent that is inside a
      // processing event
      Assert.assertTrue(
          DebugUtil.getRandomLinkedAliquotedSpecimens(appService, site.getId()).size() > 0);
      Assert.assertTrue(DebugUtil.getRandomAssignedSpecimens(appService, site.getId()).size() > 0);
      List<SpecimenWrapper> randomNonAssociatedNonDispatchedSpecimens =
          DebugUtil.getRandomNonAssignedNonDispatchedSpecimens(appService, site.getId(), 10);
      Assert.assertTrue(randomNonAssociatedNonDispatchedSpecimens.size() > 0);
    } catch (Exception e) {
      Assert.fail(e.getCause().getMessage());
    }

    try {
      s2.delete();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Example #25
0
  @Test
  public void testCompareTo() throws BiobankCheckException, Exception {
    parentSpc.setInventoryId("defgh");
    parentSpc.persist();
    SpecimenWrapper sample2 =
        SpecimenHelper.newSpecimen(
            parentSpc,
            childSpc.getSpecimenType(),
            ActivityStatus.ACTIVE,
            childSpc.getProcessingEvent(),
            childSpc.getParentContainer(),
            2,
            3);
    sample2.setInventoryId("awert");
    sample2.persist();
    Assert.assertTrue(parentSpc.compareTo(sample2) > 0);

    sample2.setInventoryId("qwerty");
    sample2.persist();
    Assert.assertTrue(parentSpc.compareTo(sample2) < 0);

    SpecimenBaseWrapper sb = new SpecimenBaseWrapper(appService);
    Assert.assertEquals(0, parentSpc.compareTo(sb));

    // test with a position because compare with position in this case:
    // childSpc is in topD4B1
    // sample2 is in topD4C4
    Assert.assertTrue(childSpc.compareTo(sample2) < 0);
  }
Example #26
0
 @Test(expected = UnsupportedOperationException.class)
 public void testToSpecimen() {
   childSpc.setTopSpecimen(null);
 }
Example #27
0
  @Test
  public void testSetSpecimenPositionFromString() throws Exception {
    childSpc.setParentFromPositionString("A1", childSpc.getParentContainer());
    childSpc.persist();
    Assert.assertTrue(childSpc.getPositionString(false, false).equals("A1"));
    RowColPos pos = childSpc.getPosition();
    Assert.assertTrue((pos.getCol() == 0) && (pos.getRow() == 0));

    childSpc.setParentFromPositionString("C2", childSpc.getParentContainer());
    childSpc.persist();
    Assert.assertTrue(childSpc.getPositionString(false, false).equals("C2"));
    pos = childSpc.getPosition();
    Assert.assertTrue((pos.getCol() == 1) && (pos.getRow() == 2));

    try {
      childSpc.setParentFromPositionString("79", childSpc.getParentContainer());
      Assert.fail("invalid position");
    } catch (Exception bce) {
      Assert.assertTrue(true);
    }

    SpecimenWrapper specimen = new SpecimenWrapper(appService);
    Assert.assertNull(specimen.getPositionString());
  }
Example #28
0
  @Test
  public void testGetSpecimensInSiteWithPositionLabel() throws Exception {
    ContainerWrapper container = childSpc.getParentContainer();
    ContainerTypeWrapper containerType = container.getContainerType();
    SpecimenTypeWrapper sampleType = containerType.getSpecimenTypeCollection(false).get(0);
    Assert.assertNotNull(sampleType);
    childSpc.setInventoryId(Utils.getRandomString(5));
    childSpc.persist();

    SpecimenHelper.newSpecimen(
        childSpc,
        childSpc.getSpecimenType(),
        ActivityStatus.ACTIVE,
        childSpc.getProcessingEvent(),
        childSpc.getParentContainer(),
        0,
        1);

    SpecimenHelper.newSpecimen(
        childSpc,
        childSpc.getSpecimenType(),
        ActivityStatus.ACTIVE,
        childSpc.getProcessingEvent(),
        childSpc.getParentContainer(),
        1,
        0);

    childSpc =
        SpecimenHelper.newSpecimen(
            childSpc,
            childSpc.getSpecimenType(),
            ActivityStatus.ACTIVE,
            childSpc.getProcessingEvent(),
            childSpc.getParentContainer(),
            0,
            2);
    childSpc.setInventoryId(Utils.getRandomString(5));
    childSpc.persist();

    List<SpecimenWrapper> specimens =
        SpecimenWrapper.getSpecimensInSiteWithPositionLabel(
            appService, site, childSpc.getPositionString(true, false));
    Assert.assertEquals(1, specimens.size());
    Assert.assertEquals(specimens.get(0), childSpc);
  }
Example #29
0
  @Test
  public void testGetSpecimensNonActive() throws Exception {
    ContainerWrapper container = childSpc.getParentContainer();
    ContainerTypeWrapper containerType = container.getContainerType();
    SpecimenTypeWrapper sampleType = containerType.getSpecimenTypeCollection(false).get(0);
    Assert.assertNotNull(sampleType);

    ActivityStatus activityStatusNonActive = ActivityStatus.CLOSED;

    List<SpecimenWrapper> activeSpecimens = new ArrayList<SpecimenWrapper>();
    List<SpecimenWrapper> nonActiveSpecimens = new ArrayList<SpecimenWrapper>();

    activeSpecimens.add(childSpc);
    for (int i = 1, n = container.getColCapacity(); i < n; ++i) {
      activeSpecimens.add(
          SpecimenHelper.newSpecimen(
              parentSpc,
              childSpc.getSpecimenType(),
              ActivityStatus.ACTIVE,
              childSpc.getProcessingEvent(),
              childSpc.getParentContainer(),
              0,
              i));

      SpecimenWrapper a =
          SpecimenHelper.newSpecimen(
              parentSpc,
              childSpc.getSpecimenType(),
              ActivityStatus.ACTIVE,
              childSpc.getProcessingEvent(),
              childSpc.getParentContainer(),
              1,
              i);
      a.setActivityStatus(activityStatusNonActive);
      a.persist();
      nonActiveSpecimens.add(a);
    }

    List<SpecimenWrapper> specimens =
        SpecimenWrapper.getSpecimensNonActiveInCenter(appService, site);
    Assert.assertEquals(nonActiveSpecimens.size(), specimens.size());
    Assert.assertTrue(specimens.containsAll(nonActiveSpecimens));
    Assert.assertFalse(specimens.containsAll(activeSpecimens));
  }
Example #30
0
  @Test
  public void testGetSetParent() throws Exception {
    Assert.assertTrue(childSpc.hasParent());
    ContainerWrapper oldParent = childSpc.getParentContainer();
    ContainerTypeWrapper type =
        ContainerTypeHelper.addContainerType(site, "newCtType", "ctNew", 1, 4, 5, true);
    type.addToSpecimenTypeCollection(Arrays.asList(childSpc.getSpecimenType()));
    type.persist();
    ContainerWrapper parent =
        ContainerHelper.addContainer("newcontainerParent", "ccNew", site, type);

    childSpc.setParent(parent, childSpc.getPosition());
    childSpc.persist();
    // check to make sure gone from old parent
    oldParent.reload();
    Assert.assertTrue(oldParent.getSpecimens().size() == 0);
    // check to make sure added to new parent
    parent.reload();
    Assert.assertTrue(childSpc.getParentContainer() != null);
    Collection<SpecimenWrapper> sampleWrappers = parent.getSpecimens().values();
    boolean found = false;
    for (SpecimenWrapper sampleWrapper : sampleWrappers) {
      if (sampleWrapper.getId().equals(childSpc.getId())) found = true;
    }
    Assert.assertTrue(found);

    // test for no parent
    SpecimenWrapper specimen2 = new SpecimenWrapper(appService);
    Assert.assertFalse(specimen2.hasParent());
  }