Beispiel #1
0
  @Override
  @Before
  public void setUp() throws Exception {
    super.setUp();

    parentSpc = SpecimenHelper.addParentSpecimen();
    site = SiteHelper.addSite("testsite" + r.nextInt());
    ContainerTypeWrapper typeChild =
        ContainerTypeHelper.addContainerType(
            site, "ctTypeChild" + r.nextInt(), "ctChild", 1, 4, 5, false);
    typeChild.addToSpecimenTypeCollection(
        Arrays.asList(
            DbHelper.chooseRandomlyInList(
                SpecimenTypeWrapper.getAllSpecimenTypes(appService, false))));
    typeChild.persist();

    ContainerTypeWrapper topType =
        ContainerTypeHelper.addContainerType(site, "topType" + r.nextInt(), "ct", 1, 4, 5, true);
    topType.addToChildContainerTypeCollection(Arrays.asList(typeChild));
    topType.persist();

    topContainer = ContainerHelper.addContainer("top" + r.nextInt(), "cc", site, topType);

    ContainerWrapper container =
        ContainerHelper.addContainer(null, "2nd", topContainer, site, typeChild, 3, 3);

    childSpc = SpecimenHelper.addSpecimens(parentSpc, container, 0, 0, 1).get(0);
  }
Beispiel #2
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());
  }
Beispiel #3
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));
  }