示例#1
0
  @Test
  public void testPersistPositionAlreadyUsed() throws BiobankCheckException, Exception {
    parentSpc.persist();
    RowColPos pos = childSpc.getPosition();

    SpecimenWrapper duplicate =
        SpecimenHelper.newSpecimen(
            parentSpc,
            childSpc.getSpecimenType(),
            ActivityStatus.ACTIVE,
            childSpc.getProcessingEvent(),
            childSpc.getParentContainer(),
            pos.getRow(),
            pos.getCol());

    try {
      duplicate.persist();
      Assert.fail("should not be allowed to add an specimen in a position that is not empty");
    } catch (BiobankSessionException bce) {
      Assert.assertTrue(true);
    }

    duplicate.setParent(duplicate.getParentContainer(), new RowColPos(2, 3));
    duplicate.persist();

    duplicate.setInventoryId(Utils.getRandomString(5));
    duplicate.persist();
  }
示例#2
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);
  }
示例#3
0
  @Test
  public void testPersistCheckInventoryIdUnique() throws BiobankCheckException, Exception {

    SpecimenWrapper duplicate =
        SpecimenHelper.newSpecimen(
            parentSpc,
            childSpc.getSpecimenType(),
            ActivityStatus.ACTIVE,
            childSpc.getProcessingEvent(),
            childSpc.getParentContainer(),
            2,
            2);
    duplicate.setInventoryId(parentSpc.getInventoryId());

    try {
      duplicate.persist();
      Assert.fail("same inventory id !");
    } catch (DuplicatePropertySetException e) {
      Assert.assertTrue(true);
    }
    duplicate.setInventoryId("qqqq" + r.nextInt());
    duplicate.persist();

    duplicate.setInventoryId(parentSpc.getInventoryId());
    try {
      duplicate.persist();
      Assert.fail(
          "still can't save it with  the same inventoryId after a first add with anotehr inventoryId!");
    } catch (DuplicatePropertySetException e) {
      Assert.assertTrue(true);
    }
  }
示例#4
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();
  }
示例#5
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();
 }
示例#6
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());
  }
示例#7
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();
  }
示例#8
0
 @Test
 public void testResetAlreadyInDatabase() throws Exception {
   parentSpc.persist();
   String old = parentSpc.getInventoryId();
   parentSpc.setInventoryId("toto");
   parentSpc.reset();
   Assert.assertEquals(old, parentSpc.getInventoryId());
 }
示例#9
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);
  }
示例#10
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);
   }
 }
示例#11
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();
  }
示例#12
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());
  }
示例#13
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());
  }
示例#14
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()));
  }
示例#15
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));
  }
示例#16
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));
  }
示例#17
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();
    }
  }