TravelEntertainmentServiceTest.java example

Explorer
kfs-master
/*
 * The Kuali Financial System, a comprehensive financial management system for higher education.
 * 
 * Copyright 2005-2014 The Kuali Foundation
 * 
 * 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/>.
 */
package org.kuali.kfs.module.tem.document.service;

import static org.kuali.kfs.sys.fixture.UserNameFixture.khuntley;

import java.sql.Timestamp;
import java.util.List;

import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.kuali.kfs.module.ar.businessobject.Customer;
import org.kuali.kfs.module.tem.TemConstants;
import org.kuali.kfs.module.tem.businessobject.TravelPayment;
import org.kuali.kfs.module.tem.businessobject.TravelerDetail;
import org.kuali.kfs.module.tem.document.TravelEntertainmentDocument;
import org.kuali.kfs.module.tem.pdf.Coversheet;
import org.kuali.kfs.sys.ConfigureContext;
import org.kuali.kfs.sys.DocumentTestUtils;
import org.kuali.kfs.sys.context.KualiTestBase;
import org.kuali.kfs.sys.context.SpringContext;
import org.kuali.kfs.sys.document.validation.event.AccountingDocumentSaveWithNoLedgerEntryGenerationEvent;
import org.kuali.rice.kew.api.exception.WorkflowException;
import org.kuali.rice.krad.service.DocumentService;

@ConfigureContext(session = khuntley)
public class TravelEntertainmentServiceTest extends KualiTestBase {
    private static final int EXPENSE_AMOUNT = 100;
    private TravelEntertainmentDocument ent = null;
    private TravelerDetail traveler = null;

    private TravelEntertainmentDocumentService entservice;
    private TravelDocumentService service;
    private DocumentService documentService;

    private static final Logger LOG = Logger.getLogger(TravelEntertainmentServiceTest.class);

    @Override
    @Before
    public void setUp() throws Exception {
        super.setUp();
        // setup services
        entservice = SpringContext.getBean(TravelEntertainmentDocumentService.class);
        documentService = SpringContext.getBean(DocumentService.class);

        ent = DocumentTestUtils.createDocument(documentService, TravelEntertainmentDocument.class);
        documentService.prepareWorkflowDocument(ent);

        // setup traveler
        traveler = new TravelerDetail() {
            @Override
            public void refreshReferenceObject(String referenceObjectName) {
                // do nothing
            }
        };
        traveler.setTravelerTypeCode(TemConstants.EMP_TRAVELER_TYP_CD);
        traveler.setCustomer(new Customer());
        ent.setTraveler(traveler);
        ent.setHostAsPayee(true);
        ent.setTravelPayment(new TravelPayment());
        ent.getTravelPayment().setDocumentationLocationCode("N");
    }

    @Override
    @After
    public void tearDown() throws Exception {
        entservice = null;
        super.tearDown();
    }

    /**
     * This method test {@link TravelEntertainmentDocumentService#findByTravelId(Integer)} using travelDocumentIdentifier
     */
    @Test
    public void testFindByTravelDocumentIdentifier() throws WorkflowException {
        documentService.saveDocument(ent, AccountingDocumentSaveWithNoLedgerEntryGenerationEvent.class);

        // test find for non existent travelDocumentIdentifier
        List<TravelEntertainmentDocument> result = (List<TravelEntertainmentDocument>) entservice.findByTravelId("-1");
        assertNotNull(result);
        assertTrue(result.isEmpty());

        // test find for existing travelDocument
        result = (List<TravelEntertainmentDocument>) entservice.findByTravelId(ent.getTravelDocumentIdentifier());
        assertNotNull(result);
        assertFalse(result.isEmpty());
    }

    /**
     * This method test {@link TravelEntertainmentDocumentService#find(String)} using documentNumber
     */
    @Test
    public void testFindByDocumentNumber() throws WorkflowException {
        // test find for non existent documentNumber
        assertNull(entservice.find(ent.getDocumentHeader().getDocumentNumber()));

        // test find for existent documentNumber
        documentService.saveDocument(ent, AccountingDocumentSaveWithNoLedgerEntryGenerationEvent.class);
        assertNotNull(entservice.find(ent.getDocumentHeader().getDocumentNumber()));
    }

    /**
     * This method tests {@link TravelEntertainmentDocumentService#addListenersTo(TravelEntertainmentDocument)}
     */
    @Test
    public void testAddListenersTo() {
        boolean success = false;

        try {
            entservice.addListenersTo(ent);
            success = true;
        }
        catch (NullPointerException e) {
            success = false;
            LOG.warn("NPE.", e);
        }

        assertTrue(success);
    }



    /**
     * This method tests {@link TravelEntertainmentDocumentService#calculateTotalsFor(TravelEntertainmentDocument)}
     *
     * @throws WorkflowException

    @Test
    public void testCalculateTotalsFor() throws WorkflowException {
        ent = new TravelEntertainmentDocument();

        traveler.setTravelerTypeCode(TemConstants.EMP_TRAVELER_TYP_CD);
        ent.setTraveler(traveler);

        List<ActualExpense> oteList = new ArrayList<ActualExpense>();
        ent.setActualExpenses(oteList);
        ent.setPerDiemExpenses(new ArrayList<PerDiemExpense>());

        // test with empty actualExpenseList
        Map<String, Object> resultMap = service.calculateTotalsFor(ent);
        assertTrue(((KualiDecimal) resultMap.get(TemConstants.NON_REIMBURSABLE_ATTRIBUTE)).equals(KualiDecimal.ZERO));

        // Override refreshReferenceObject - setting travelExpenseTypeCode manually
        ActualExpense ote = new ActualExpense() {
            public void refreshReferenceObject(String referenceObjectName) {
                // do nothing;
            }
        };
        ote.setExpenseAmount(new KualiDecimal(EXPENSE_AMOUNT));
        ote.setNonReimbursable(true);
        //ote.setTravelExpenseTypeCode(new TemTravelExpenseTypeCode());
        oteList.add(ote);

        ent.setActualExpenses(oteList);

        // test with non-reimbursable other expense
        resultMap = service.calculateTotalsFor(ent);
        assertTrue(((KualiDecimal) resultMap.get(TemConstants.NON_REIMBURSABLE_ATTRIBUTE)).equals(new KualiDecimal(EXPENSE_AMOUNT)));
    }
     */


    /**
     * This method tests {@link TravelEntertainmentDocumentService#generateCoversheetFor(TravelEntertainmentDocument)}
     *
     * @throws Exception
     */
    @Test
    public void testGenerateCoversheetFor() throws Exception {
        Coversheet cover = null;

        try {
            cover = entservice.generateCoversheetFor(new TravelEntertainmentDocument());
        }
        catch (RuntimeException e) {
            LOG.warn("Workflow doc is null.", e);
        }

        assertNull(cover);

        ent.setTripBegin(new Timestamp(new java.util.Date().getTime()));
        ent.setTripEnd(new Timestamp(new java.util.Date().getTime()));

        cover = entservice.generateCoversheetFor(ent);
        assertNotNull(cover);
    }
}