Java tutorial
/* * This program is part of the OpenLMIS logistics management information system platform software. * Copyright 2013 VillageReach * * This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. * You should have received a copy of the GNU Affero General Public License along with this program. If not, see http://www.gnu.org/licenses. For additional information contact info@OpenLMIS.org. */ package org.openlmis.rnr.repository.mapper; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.Predicate; import org.junit.Before; import org.junit.Test; import org.junit.experimental.categories.Category; import org.junit.runner.RunWith; import org.openlmis.core.builder.ProcessingScheduleBuilder; import org.openlmis.core.builder.ProductBuilder; import org.openlmis.core.builder.ProgramBuilder; import org.openlmis.core.domain.*; import org.openlmis.core.query.QueryExecutor; import org.openlmis.core.repository.mapper.*; import org.openlmis.db.categories.IntegrationTests; import org.openlmis.rnr.builder.RequisitionBuilder; import org.openlmis.rnr.builder.RnrLineItemBuilder; import org.openlmis.rnr.domain.*; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.context.transaction.TransactionConfiguration; import org.springframework.transaction.annotation.Transactional; import java.util.Calendar; import java.util.Date; import java.util.List; import static com.natpryce.makeiteasy.MakeItEasy.*; import static java.util.Arrays.asList; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.nullValue; import static org.junit.Assert.*; import static org.openlmis.core.builder.FacilityApprovedProductBuilder.defaultFacilityApprovedProduct; import static org.openlmis.core.builder.FacilityBuilder.defaultFacility; import static org.openlmis.core.builder.ProcessingPeriodBuilder.defaultProcessingPeriod; import static org.openlmis.core.builder.ProcessingPeriodBuilder.name; import static org.openlmis.core.builder.ProcessingPeriodBuilder.scheduleId; import static org.openlmis.core.builder.ProgramBuilder.PROGRAM_ID; import static org.openlmis.rnr.builder.RnrLineItemBuilder.*; import static org.openlmis.rnr.domain.RnrStatus.*; @Category(IntegrationTests.class) @ContextConfiguration(locations = "classpath:test-applicationContext-requisition.xml") @RunWith(SpringJUnit4ClassRunner.class) @Transactional @TransactionConfiguration(defaultRollback = true, transactionManager = "openLmisTransactionManager") public class RnrLineItemMapperIT { public static final Long MODIFIED_BY = 1L; @Autowired private FacilityMapper facilityMapper; @Autowired private ProductMapper productMapper; @Autowired private ProgramProductMapper programProductMapper; @Autowired private FacilityApprovedProductMapper facilityApprovedProductMapper; @Autowired private RequisitionMapper requisitionMapper; @Autowired private RnrLineItemMapper rnrLineItemMapper; @Autowired private ProgramMapper programMapper; @Autowired private LossesAndAdjustmentsMapper lossesAndAdjustmentsMapper; @Autowired private ProcessingPeriodMapper processingPeriodMapper; @Autowired private ProcessingScheduleMapper processingScheduleMapper; @Autowired private ProductCategoryMapper categoryMapper; @Autowired private RequisitionStatusChangeMapper requisitionStatusChangeMapper; @Autowired private ProductCategoryMapper productCategoryMapper; @Autowired QueryExecutor queryExecutor; private FacilityTypeApprovedProduct facilityTypeApprovedProduct; private Facility facility; private Rnr rnr; Program program; ProcessingPeriod processingPeriod; ProcessingPeriod processingPeriod2; ProcessingPeriod processingPeriod3; @Before public void setUp() { Product product = make(a(ProductBuilder.defaultProduct)); productMapper.insert(product); program = make(a(ProgramBuilder.defaultProgram)); programMapper.insert(program); ProductCategory category = new ProductCategory("C1", "Category 1", 1); productCategoryMapper.insert(category); ProgramProduct programProduct = new ProgramProduct(program, product, 30, true, new Money("12.5000")); programProduct.setProductCategory(category); programProduct.setFullSupply(product.getFullSupply()); programProductMapper.insert(programProduct); facility = make(a(defaultFacility)); facilityMapper.insert(facility); facilityTypeApprovedProduct = make(a(defaultFacilityApprovedProduct)); facilityTypeApprovedProduct.setProgramProduct(programProduct); facilityApprovedProductMapper.insert(facilityTypeApprovedProduct); ProcessingSchedule processingSchedule = make(a(ProcessingScheduleBuilder.defaultProcessingSchedule)); processingScheduleMapper.insert(processingSchedule); processingPeriod = make( a(defaultProcessingPeriod, with(scheduleId, processingSchedule.getId()), with(name, "month1"))); processingPeriodMapper.insert(processingPeriod); processingPeriod2 = make( a(defaultProcessingPeriod, with(scheduleId, processingSchedule.getId()), with(name, "month2"))); processingPeriodMapper.insert(processingPeriod2); processingPeriod3 = make( a(defaultProcessingPeriod, with(scheduleId, processingSchedule.getId()), with(name, "month3"))); processingPeriodMapper.insert(processingPeriod3); rnr = new Rnr(facility, new Program(PROGRAM_ID), processingPeriod, false, MODIFIED_BY, 1L); rnr.setStatus(INITIATED); } @Test public void shouldReturnRnrLineItemsByRnrId() { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); lineItem.setPacksToShip(20); lineItem.setBeginningBalance(5); lineItem.setFullSupply(true); lineItem.setReportingDays(10); lineItem.setPreviousStockInHand(5); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); LossesAndAdjustments lossesAndAdjustmentsClinicReturn = new LossesAndAdjustments(); LossesAndAdjustmentsType lossesAndAdjustmentsTypeClinicReturn = new LossesAndAdjustmentsType(); lossesAndAdjustmentsTypeClinicReturn.setName("CLINIC_RETURN"); lossesAndAdjustmentsClinicReturn.setType(lossesAndAdjustmentsTypeClinicReturn); lossesAndAdjustmentsClinicReturn.setQuantity(20); LossesAndAdjustments lossesAndAdjustmentsTransferIn = new LossesAndAdjustments(); LossesAndAdjustmentsType lossesAndAdjustmentsTypeTransferIn = new LossesAndAdjustmentsType(); lossesAndAdjustmentsTypeTransferIn.setName("TRANSFER_IN"); lossesAndAdjustmentsTransferIn.setType(lossesAndAdjustmentsTypeTransferIn); lossesAndAdjustmentsTransferIn.setQuantity(45); lossesAndAdjustmentsMapper.insert(lineItem, lossesAndAdjustmentsClinicReturn); lossesAndAdjustmentsMapper.insert(lineItem, lossesAndAdjustmentsTransferIn); List<RnrLineItem> rnrLineItems = rnrLineItemMapper.getRnrLineItemsByRnrId(rnr.getId()); assertThat(rnrLineItems.size(), is(1)); RnrLineItem rnrLineItem = rnrLineItems.get(0); assertThat(rnrLineItem.getId(), is(lineItem.getId())); assertThat(rnrLineItem.getLossesAndAdjustments().size(), is(2)); assertThat(rnrLineItem.getRnrId(), is(rnr.getId())); assertThat(rnrLineItem.getDosesPerMonth(), is(30)); assertThat(rnrLineItem.getDosesPerDispensingUnit(), is(10)); assertThat(rnrLineItem.getProduct(), is("Primary Name Tablet strength mg")); assertThat(rnrLineItem.getPacksToShip(), is(20)); assertThat(rnrLineItem.getDispensingUnit(), is("Strip")); assertThat(rnrLineItem.getRoundToZero(), is(true)); assertThat(rnrLineItem.getPackSize(), is(10)); assertThat(rnrLineItem.getPrice().compareTo(new Money("12.5")), is(0)); assertThat(rnrLineItem.getBeginningBalance(), is(5)); assertThat(rnrLineItem.getPreviousStockInHand(), is(5)); assertThat(rnrLineItem.getProductCategory(), is("Category 1")); assertThat(rnrLineItem.getReportingDays(), is(10)); } @Test public void shouldReturnNonFullSupplyLineItemsByRnrId() throws Exception { requisitionMapper.insert(rnr); RnrLineItem nonFullSupplyLineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); nonFullSupplyLineItem.setQuantityRequested(20); nonFullSupplyLineItem.setReasonForRequestedQuantity("More patients"); nonFullSupplyLineItem.setFullSupply(false); rnrLineItemMapper.insertNonFullSupply(nonFullSupplyLineItem); List<RnrLineItem> fetchedNonSupplyLineItems = rnrLineItemMapper .getNonFullSupplyRnrLineItemsByRnrId(rnr.getId()); assertThat(fetchedNonSupplyLineItems.size(), is(1)); assertThat(fetchedNonSupplyLineItems.get(0).getQuantityRequested(), is(20)); assertThat(fetchedNonSupplyLineItems.get(0).getReasonForRequestedQuantity(), is("More patients")); assertThat(fetchedNonSupplyLineItems.get(0).getProductCategory(), is("Category 1")); } @Test public void shouldReturnNonFullSupplyLineItemByRnrIdAndProductCode() throws Exception { requisitionMapper.insert(rnr); RnrLineItem nonFullSupplyLineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); nonFullSupplyLineItem.setQuantityRequested(20); nonFullSupplyLineItem.setReasonForRequestedQuantity("More patients"); nonFullSupplyLineItem.setFullSupply(false); rnrLineItemMapper.insertNonFullSupply(nonFullSupplyLineItem); RnrLineItem fetchedNonSupplyLineItem = rnrLineItemMapper.getExistingNonFullSupplyItemByRnrIdAndProductCode( rnr.getId(), nonFullSupplyLineItem.getProductCode()); assertThat(fetchedNonSupplyLineItem.getQuantityRequested(), is(20)); assertThat(fetchedNonSupplyLineItem.getReasonForRequestedQuantity(), is("More patients")); assertThat(fetchedNonSupplyLineItem.getProductCategory(), is("Category 1")); } @Test public void shouldUpdateRnrLineItem() { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); Long anotherModifiedBy = 2L; lineItem.setModifiedBy(anotherModifiedBy); lineItem.setBeginningBalance(43); lineItem.setTotalLossesAndAdjustments(20); lineItem.setNormalizedConsumption(12); lineItem.setPeriodNormalizedConsumption(12); lineItem.setExpirationDate("12/2014"); lineItem.setReasonForRequestedQuantity("Quantity Requested more in liu of coming rains"); lineItem.setReportingDays(5); int updateCount = rnrLineItemMapper.update(lineItem); assertThat(updateCount, is(1)); List<RnrLineItem> rnrLineItems = rnrLineItemMapper.getRnrLineItemsByRnrId(rnr.getId()); assertThat(rnrLineItems.get(0).getBeginningBalance(), is(43)); assertThat(rnrLineItems.get(0).getTotalLossesAndAdjustments(), is(20)); assertThat(rnrLineItems.get(0).getProduct(), is("Primary Name Tablet strength mg")); assertThat(rnrLineItems.get(0).getNormalizedConsumption(), is(12)); assertThat(rnrLineItems.get(0).getPeriodNormalizedConsumption(), is(12)); assertThat(rnrLineItems.get(0).getExpirationDate(), is("12/2014")); assertThat(rnrLineItems.get(0).getReportingDays(), is(5)); assertThat(rnrLineItems.get(0).getReasonForRequestedQuantity(), is("Quantity Requested more in liu of coming rains")); } @Test public void shouldUpdateSkipFlag() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); lineItem.setSkipped(true); rnrLineItemMapper.update(lineItem); List<RnrLineItem> rnrLineItems = rnrLineItemMapper.getRnrLineItemsByRnrId(rnr.getId()); assertTrue(rnrLineItems.get(0).getSkipped()); lineItem.setSkipped(false); rnrLineItemMapper.update(lineItem); rnrLineItems = rnrLineItemMapper.getRnrLineItemsByRnrId(rnr.getId()); assertFalse(rnrLineItems.get(0).getSkipped()); } @Test public void shouldInsertNonFullSupplyLineItem() { requisitionMapper.insert(rnr); RnrLineItem requisitionLineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); requisitionLineItem.setFullSupply(false); rnrLineItemMapper.insertNonFullSupply(requisitionLineItem); assertNotNull(requisitionLineItem.getId()); List<RnrLineItem> nonFullSupplyLineItems = rnrLineItemMapper .getNonFullSupplyRnrLineItemsByRnrId(rnr.getId()); RnrLineItem nonFullSupply = nonFullSupplyLineItems.get(0); assertThat(nonFullSupply.getQuantityReceived(), is(0)); assertThat(nonFullSupply.getQuantityDispensed(), is(0)); assertThat(nonFullSupply.getBeginningBalance(), is(0)); assertThat(nonFullSupply.getStockInHand(), is(0)); assertThat(nonFullSupply.getTotalLossesAndAdjustments(), is(0)); assertThat(nonFullSupply.getCalculatedOrderQuantity(), is(0)); assertThat(nonFullSupply.getNewPatientCount(), is(0)); assertThat(nonFullSupply.getStockOutDays(), is(0)); assertThat(nonFullSupply.getNormalizedConsumption(), is(0)); assertThat(nonFullSupply.getAmc(), is(0)); assertThat(nonFullSupply.getMaxStockQuantity(), is(0)); assertThat(nonFullSupply.getProductCategory(), is("Category 1")); } @Test public void shouldDeleteAllNonFullSupplyLineItemsForRnr() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = make(a(defaultRnrLineItem, with(fullSupply, false))); lineItem.setRnrId(rnr.getId()); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); RnrLineItem lineItem2 = make(a(defaultRnrLineItem, with(fullSupply, true))); lineItem2.setRnrId(rnr.getId()); rnrLineItemMapper.insert(lineItem2, lineItem.getPreviousNormalizedConsumptions().toString()); rnrLineItemMapper.deleteAllNonFullSupplyForRequisition(rnr.getId()); assertThat(rnrLineItemMapper.getRnrLineItemsByRnrId(rnr.getId()).size(), is(1)); assertThat(rnrLineItemMapper.getRnrLineItemsByRnrId(rnr.getId()).get(0).getProductCode(), is(lineItem2.getProductCode())); assertThat(rnrLineItemMapper.getRnrLineItemsByRnrId(rnr.getId()).get(0).getProductCategory(), is(lineItem2.getProductCategory())); } @Test public void shouldReturnCategoryCountForFullSupplyLineItems() { requisitionMapper.insert(rnr); boolean fullSupplyFlag = true; for (int index = 1; index <= 10; index++) { String productCode = "P" + index; ProductCategory category = new ProductCategory(); category.setCode("C_" + index); category.setName("Category " + index); category.setDisplayOrder(1); categoryMapper.insert(category); Product product = make(a(ProductBuilder.defaultProduct, with(ProductBuilder.code, productCode), with(ProductBuilder.fullSupply, fullSupplyFlag))); productMapper.insert(product); ProgramProduct programProduct = new ProgramProduct(program, product, 30, true, new Money("12.5000")); programProduct.setFullSupply(product.getFullSupply()); programProduct.setProductCategory(category); programProductMapper.insert(programProduct); FacilityTypeApprovedProduct facilityTypeApprovedProduct = make(a(defaultFacilityApprovedProduct)); facilityTypeApprovedProduct.setProgramProduct(programProduct); facilityApprovedProductMapper.insert(facilityTypeApprovedProduct); RnrLineItem item = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, 1L, 1L); rnrLineItemMapper.insert(item, null); } assertThat(rnrLineItemMapper.getCategoryCount(rnr, fullSupplyFlag), is(10)); } @Test public void shouldUpdateApprovedQuantityAndRemarks() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); rnr.setStatus(AUTHORIZED); lineItem.setQuantityApproved(23); lineItem.setRemarks("Updated Remarks"); lineItem.setPacksToShip(2); rnrLineItemMapper.updateOnApproval(lineItem); RnrLineItem returnedRnrLineItem = rnrLineItemMapper.getRnrLineItemsByRnrId(lineItem.getRnrId()).get(0); assertThat(returnedRnrLineItem.getQuantityApproved(), is(23)); assertThat(returnedRnrLineItem.getPacksToShip(), is(2)); assertThat(returnedRnrLineItem.getRemarks(), is("Updated Remarks")); } @Test public void shouldGetCreatedDateForMostRecentNonSkippedAuthorizedLineItem() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); rnr.setStatus(AUTHORIZED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr)); queryExecutor.executeUpdate("UPDATE requisition_status_changes SET createdDate = ? WHERE rnrId = ?", getDateByDays(-3), rnr.getId()); Rnr rnr1 = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod2))); requisitionMapper.insert(rnr1); RnrLineItem rnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); rnrLineItem.setRnrId(rnr1.getId()); rnrLineItemMapper.insert(rnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); rnr1.setStatus(AUTHORIZED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr1)); List<RequisitionStatusChange> changeList = requisitionStatusChangeMapper.getByRnrId(rnr1.getId()); Rnr currentRnr = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod3))); RnrLineItem currentRnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); requisitionMapper.insert(currentRnr); currentRnrLineItem.setRnrId(currentRnr.getId()); rnrLineItemMapper.insert(currentRnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); Date createdDateForPreviousLineItem = rnrLineItemMapper.getAuthorizedDateForPreviousLineItem(currentRnr, lineItem.getProductCode(), getDateByDays(-4)); assertThat(createdDateForPreviousLineItem, is(changeList.get(0).getCreatedDate())); } @Test public void shouldNotGetCreatedDateIfNoAuthorizedLineItemExistAfterGivenDateForAProduct() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); rnr.setStatus(AUTHORIZED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr)); queryExecutor.executeUpdate("UPDATE requisition_status_changes SET createdDate = ? WHERE rnrId = ?", getDateByDays(-3), rnr.getId()); Rnr rnr1 = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod2))); requisitionMapper.insert(rnr1); RnrLineItem rnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); rnrLineItem.setRnrId(rnr1.getId()); rnrLineItemMapper.insert(rnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); rnr1.setStatus(SUBMITTED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr1)); Rnr currentRnr = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod3))); RnrLineItem currentRnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); requisitionMapper.insert(currentRnr); currentRnrLineItem.setRnrId(currentRnr.getId()); rnrLineItemMapper.insert(currentRnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); Date createdDateForPreviousLineItem = rnrLineItemMapper.getAuthorizedDateForPreviousLineItem(currentRnr, lineItem.getProductCode(), getDateByDays(-2)); assertNull(createdDateForPreviousLineItem); } @Test public void shouldGetPreviousNRnrLineItemsForGivenProductCode() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); lineItem.setNormalizedConsumption(3); lineItem.setStockInHand(0); rnrLineItemMapper.update(lineItem); rnr.setStatus(AUTHORIZED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr)); Rnr rnr1 = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod2))); requisitionMapper.insert(rnr1); RnrLineItem rnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); rnrLineItem.setRnrId(rnr1.getId()); rnrLineItemMapper.insert(rnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); rnr1.setStatus(SUBMITTED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr1)); Rnr currentRnr = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod3))); RnrLineItem currentRnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); requisitionMapper.insert(currentRnr); currentRnrLineItem.setRnrId(currentRnr.getId()); rnrLineItemMapper.insert(currentRnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); List<RnrLineItem> rnrLineItems = rnrLineItemMapper.getAuthorizedRegularUnSkippedLineItems( lineItem.getProductCode(), currentRnr, 2, getDateByDays(-3)); assertThat(rnrLineItems.size(), is(1)); assertThat(rnrLineItems.get(0).getNormalizedConsumption(), is(3)); assertThat(rnrLineItems.get(0).getStockInHand(), is(0)); } @Test public void shouldNotGetPreviousNNormalizedConsumptionsGivenProductCodeIfNoAuthorizedRnrExist() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); lineItem.setNormalizedConsumption(3); rnrLineItemMapper.update(lineItem); rnr.setStatus(SUBMITTED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr)); Rnr rnr1 = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod2))); requisitionMapper.insert(rnr1); RnrLineItem rnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); rnrLineItem.setRnrId(rnr1.getId()); rnrLineItemMapper.insert(rnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); rnr1.setStatus(SUBMITTED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr1)); Rnr currentRnr = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod3))); RnrLineItem currentRnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); requisitionMapper.insert(currentRnr); currentRnrLineItem.setRnrId(currentRnr.getId()); rnrLineItemMapper.insert(currentRnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); List<RnrLineItem> rnrLineItems = rnrLineItemMapper.getAuthorizedRegularUnSkippedLineItems( lineItem.getProductCode(), currentRnr, 2, getDateByDays(-3)); assertThat(rnrLineItems.size(), is(0)); } @Test public void shouldGetPreviousNNormalizedConsumptionsGivenProductCodeIfTwoRequisitionsAuthorized() { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); lineItem.setNormalizedConsumption(3); rnrLineItemMapper.update(lineItem); rnr.setStatus(AUTHORIZED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr)); Rnr rnr1 = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod2))); requisitionMapper.insert(rnr1); RnrLineItem rnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); rnrLineItem.setRnrId(rnr1.getId()); rnrLineItemMapper.insert(rnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); rnrLineItem.setNormalizedConsumption(9); rnrLineItemMapper.update(rnrLineItem); rnr1.setStatus(AUTHORIZED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr1)); Rnr currentRnr = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod3))); RnrLineItem currentRnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); requisitionMapper.insert(currentRnr); currentRnrLineItem.setRnrId(currentRnr.getId()); rnrLineItemMapper.insert(currentRnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); List<RnrLineItem> rnrLineItems = rnrLineItemMapper.getAuthorizedRegularUnSkippedLineItems( lineItem.getProductCode(), currentRnr, 2, getDateByDays(-3)); assertThat(rnrLineItems.size(), is(2)); assertContainsLineItemWithNC(rnrLineItems, 3); assertContainsLineItemWithNC(rnrLineItems, 9); } private void assertContainsLineItemWithNC(List<RnrLineItem> rnrLineItems, final Integer expectedNormalizedConsumption) { assertTrue(CollectionUtils.exists(rnrLineItems, new Predicate() { @Override public boolean evaluate(Object o) { RnrLineItem lineItem = (RnrLineItem) o; return lineItem.getNormalizedConsumption().equals(expectedNormalizedConsumption); } })); } @Test public void shouldInsertPreviousNormalizedConsumptions() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); lineItem.setPreviousNormalizedConsumptions(asList(4, 6)); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); List<RnrLineItem> lineItems = rnrLineItemMapper.getRnrLineItemsByRnrId(rnr.getId()); assertThat(lineItems.get(0).getPreviousNormalizedConsumptions(), is(asList(4, 6))); } @Test public void shouldGetLineItemWithRnrIdAndProductCode() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); lineItem.setPacksToShip(20); lineItem.setBeginningBalance(5); lineItem.setFullSupply(true); lineItem.setReportingDays(10); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); RnrLineItem actualLineItem = rnrLineItemMapper.getNonSkippedLineItem(rnr.getId(), facilityTypeApprovedProduct.getProgramProduct().getProduct().getCode()); assertThat(actualLineItem, is(lineItem)); } @Test public void shouldNotGetSkippedLineItemsWithRnrIdAndProductCode() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); lineItem.setPacksToShip(20); lineItem.setBeginningBalance(5); lineItem.setFullSupply(true); lineItem.setReportingDays(10); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); lineItem.setSkipped(true); rnrLineItemMapper.update(lineItem); RnrLineItem actualLineItem = rnrLineItemMapper.getNonSkippedLineItem(rnr.getId(), facilityTypeApprovedProduct.getProgramProduct().getProduct().getCode()); assertThat(actualLineItem, is(nullValue())); } @Test public void shouldNotIncludeEmergencyRnrWhileFetchingPreviousNC() throws Exception { requisitionMapper.insert(rnr); RnrLineItem lineItem = new RnrLineItem(rnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); rnrLineItemMapper.insert(lineItem, lineItem.getPreviousNormalizedConsumptions().toString()); lineItem.setNormalizedConsumption(3); rnrLineItemMapper.update(lineItem); rnr.setStatus(AUTHORIZED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(rnr)); Rnr emergencyRnr = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod2), with(RequisitionBuilder.emergency, true))); requisitionMapper.insert(emergencyRnr); RnrLineItem rnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); rnrLineItem.setRnrId(emergencyRnr.getId()); rnrLineItemMapper.insert(rnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); rnrLineItem.setNormalizedConsumption(9); rnrLineItemMapper.update(rnrLineItem); emergencyRnr.setStatus(AUTHORIZED); requisitionStatusChangeMapper.insert(new RequisitionStatusChange(emergencyRnr)); Rnr currentRnr = make(a(RequisitionBuilder.defaultRequisition, with(RequisitionBuilder.facility, facility), with(RequisitionBuilder.program, new Program(PROGRAM_ID)), with(RequisitionBuilder.period, processingPeriod3))); RnrLineItem currentRnrLineItem = make(a(defaultRnrLineItem, with(productCode, lineItem.getProductCode()))); requisitionMapper.insert(currentRnr); currentRnrLineItem.setRnrId(currentRnr.getId()); rnrLineItemMapper.insert(currentRnrLineItem, lineItem.getPreviousNormalizedConsumptions().toString()); List<RnrLineItem> lineItems = rnrLineItemMapper.getAuthorizedRegularUnSkippedLineItems( lineItem.getProductCode(), currentRnr, 2, getDateByDays(-3)); assertThat(lineItems.size(), is(1)); assertThat(lineItems.get(0).getNormalizedConsumption(), is(3)); } @Test public void shouldReturnAllNonSkippedNonFullSupplyRnrLineItems() { Rnr newRnr = new Rnr(facility, new Program(PROGRAM_ID), processingPeriod, false, MODIFIED_BY, 1L); newRnr.setStatus(INITIATED); requisitionMapper.insert(newRnr); RnrLineItem fullSupplyLineItem = new RnrLineItem(newRnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); fullSupplyLineItem.setQuantityRequested(20); fullSupplyLineItem.setReasonForRequestedQuantity("More patients"); fullSupplyLineItem.setFullSupply(false); fullSupplyLineItem.setSkipped(false); rnrLineItemMapper.insert(fullSupplyLineItem, fullSupplyLineItem.getPreviousNormalizedConsumptions().toString()); rnrLineItemMapper.update(fullSupplyLineItem); RnrLineItem skippedLineItem = new RnrLineItem(newRnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); skippedLineItem.setFullSupply(false); skippedLineItem.setSkipped(true); rnrLineItemMapper.insert(skippedLineItem, skippedLineItem.getPreviousNormalizedConsumptions().toString()); rnrLineItemMapper.update(skippedLineItem); RnrLineItem nonFullSupplyLineItem = new RnrLineItem(newRnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); nonFullSupplyLineItem.setQuantityRequested(20); nonFullSupplyLineItem.setReasonForRequestedQuantity("More patients"); nonFullSupplyLineItem.setFullSupply(true); nonFullSupplyLineItem.setSkipped(false); rnrLineItemMapper.insert(nonFullSupplyLineItem, nonFullSupplyLineItem.getPreviousNormalizedConsumptions().toString()); rnrLineItemMapper.update(nonFullSupplyLineItem); List<RnrLineItem> fetchedNonSkippedNonSupplyLineItems = rnrLineItemMapper .getNonSkippedNonFullSupplyRnrLineItemsByRnrId(newRnr.getId()); assertThat(fetchedNonSkippedNonSupplyLineItems.size(), is(1)); assertThat(fetchedNonSkippedNonSupplyLineItems.get(0).getQuantityRequested(), is(20)); } @Test public void shouldReturnAllNonSkippedFullSupplyRnrLineItems() { Rnr newRnr = new Rnr(facility, new Program(PROGRAM_ID), processingPeriod, false, MODIFIED_BY, 1L); newRnr.setStatus(INITIATED); requisitionMapper.insert(newRnr); RnrLineItem nonFullSupplyLineItem = new RnrLineItem(newRnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); nonFullSupplyLineItem.setQuantityRequested(20); nonFullSupplyLineItem.setReasonForRequestedQuantity("More patients"); nonFullSupplyLineItem.setFullSupply(true); nonFullSupplyLineItem.setSkipped(false); rnrLineItemMapper.insert(nonFullSupplyLineItem, nonFullSupplyLineItem.getPreviousNormalizedConsumptions().toString()); rnrLineItemMapper.update(nonFullSupplyLineItem); RnrLineItem fullSupplyLineItem = new RnrLineItem(newRnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); fullSupplyLineItem.setQuantityRequested(20); fullSupplyLineItem.setReasonForRequestedQuantity("More patients"); fullSupplyLineItem.setFullSupply(false); fullSupplyLineItem.setSkipped(false); rnrLineItemMapper.insert(fullSupplyLineItem, fullSupplyLineItem.getPreviousNormalizedConsumptions().toString()); rnrLineItemMapper.update(fullSupplyLineItem); RnrLineItem skippedLineItem = new RnrLineItem(newRnr.getId(), facilityTypeApprovedProduct, MODIFIED_BY, 1L); skippedLineItem.setFullSupply(true); skippedLineItem.setSkipped(true); rnrLineItemMapper.insert(skippedLineItem, skippedLineItem.getPreviousNormalizedConsumptions().toString()); rnrLineItemMapper.update(skippedLineItem); List<RnrLineItem> fetchedNonSkippedNonSupplyLineItems = rnrLineItemMapper .getNonSkippedNonFullSupplyRnrLineItemsByRnrId(newRnr.getId()); assertThat(fetchedNonSkippedNonSupplyLineItems.size(), is(1)); assertThat(fetchedNonSkippedNonSupplyLineItems.get(0).getQuantityRequested(), is(20)); } private java.sql.Date getDateByDays(int days) { Calendar currentDate = Calendar.getInstance(); currentDate.add(Calendar.DATE, days); return new java.sql.Date(currentDate.getTimeInMillis()); } }