[Batchserver-cvs] batchserver/test/org/jmonks/batch/framework/repository/db4o Db4oRepositoryTest.java, NONE, 1.1

[Suresh <sur...@us...>]

Update of /cvsroot/batchserver/batchserver/test/org/jmonks/batch/framework/repository/db4o
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv28821

Added Files:
	Db4oRepositoryTest.java 
Log Message:
no message

--- NEW FILE: Db4oRepositoryTest.java ---
/*
 * Db4oRepositoryTest.java
 * JUnit based test
 *
 * Created on March 14, 2006, 3:54 PM
 */
package org.jmonks.batch.framework.repository.db4o; 

import com.db4o.ObjectSet;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;
import junit.framework.*;
import org.jmonks.batch.framework.ErrorCode;
import org.jmonks.batch.framework.JobStatistics;







/**
 *
 * @author w951h8m
 */
public class Db4oRepositoryTest extends TestCase
{
    
    public Db4oRepositoryTest(String testName)
    {
        super(testName);
    }

    protected void setUp() throws Exception
    {
    }

    protected void tearDown() throws Exception
    {
    }

    public static Test suite()
    {
        TestSuite suite = new TestSuite();
        suite.addTest(new Db4oRepositoryTest("testInit"));
        suite.addTest(new Db4oRepositoryTest("testLogJobStatistics"));
        suite.addTest(new Db4oRepositoryTest("testJobDataTransfer"));
        suite.addTest(new Db4oRepositoryTest("testJobMgmtMntrInfoHolder"));
        return suite;
    }

    
    /**
     * Test to make sure this is not returning null.
     */
    public void testInit()
    {
        try
        {
            TestDb4oRepository repository=new TestDb4oRepository();
            repository.init(getDb4oConfigMap());
            assertNotNull(repository);
        }
        catch(Exception exception)
        {
            fail("Unable to initialize the db4o repository.");
        }
    }
    
    /**
     *  Test method to test the logJobStatistics API of repository.
     */
    public void testLogJobStatistics()
    {
        TestDb4oRepository repository=new TestDb4oRepository();
        repository.init(getDb4oConfigMap());
        repository.setJobName("process_file_xyz");

        JobStatistics statistics=new JobStatistics("process_file_xyz");
        statistics.setStartTime(Calendar.getInstance().getTime());
        statistics.setEndTime(Calendar.getInstance().getTime());
        statistics.setExitCode(ErrorCode.createErrorCode(10001, "This is my error code"));
        statistics.setMaxMemeoryUsage(1000);
        statistics.setRecordsProcessed(50000);
        boolean logged=repository.logStatistics(statistics);
        assertTrue(logged);
        
        JobStatistics[] loggedStats=repository.getStatistics();
        assertNotNull(loggedStats);
        assertTrue(loggedStats.length>=1);
    }

    public void testJobDataTransfer()
    {
        TestDb4oRepository repository1=new TestDb4oRepository();
        repository1.init(getDb4oConfigMap());
        repository1.setJobName("process_file_abc");

        Map data=new HashMap();
        data.put("author", "Suresh");
        boolean sent=repository1.sendDataToNextJob("first_data", "process_file_xyz", data);
        assertTrue(sent);
        
        TestDb4oRepository repository2=new TestDb4oRepository();
        repository2.init(getDb4oConfigMap());
        repository2.setJobName("process_file_xyz");
        
        Object receivedData=repository2.getDataFromPreviousJob("first_data", "process_file_abc");
        assertNotNull(receivedData);
        Map verifyMap=(Map)receivedData;
        assertEquals("Suresh",(String)verifyMap.get("author"));
        
        boolean cleared=repository1.clearDataTransferredFromThisJob();
        assertTrue(cleared);
        receivedData=repository2.getDataFromPreviousJob("first_data", "process_file_abc");
        assertNull(receivedData);
    }
    
    public void testJobMgmtMntrInfoHolder()
    {
        TestDb4oRepository repository1=new TestDb4oRepository();
        repository1.init(getDb4oConfigMap());
        repository1.setJobName("process_file_abc");

        Map data=new HashMap();
        data.put("author", "Suresh");
        boolean registered=repository1.registerJobMgmtMntrInfo(data);
        assertTrue(registered);
        
        
        Object lookupData=repository1.lookupJobMgmtMntrInfo();
        assertNotNull(lookupData);
        Map verifyMap=(Map)lookupData;
        assertEquals("Suresh",(String)verifyMap.get("author"));
        
        boolean unregistered=repository1.unregisterJobMgmtMntrInfo();
        assertTrue(unregistered);
        
        lookupData=repository1.lookupJobMgmtMntrInfo();
        assertNull(lookupData);        
    }

    private Map getDb4oConfigMap()
    {
        Map configMap=new HashMap();
        configMap.put(Db4oRepository.PROPERTY_REPOSIOTRY_LOCATION, "/batchserver/repository");
        return configMap;
    }
    
    class TestDb4oRepository extends Db4oRepository
    {
        TestDb4oRepository()
        {
        }
        
        public void init(Map configMap)
        {
            super.init(configMap);
        }
        
        public void setJobName(String jobName)
        {
            this.jobName=jobName;
        }
        
        public Object lookupJobMgmtMntrInfo()
        {
//            logger.trace("Entering lookupJobMgmtMntrInfo");
//            logger.debug("lookupJobMgmtMntrInfo :: job name = " + jobName);
//
//            if(jobName==null)
//                throw new IllegalArgumentException("jobName cannot be null to lookup the mgmt and mntr information.");

            Object registratInfo=null;
            if(container==null)
                registratInfo=null;
            else
            {
                ObjectSet mgmtMntrInfoHolderResultSet=container.query(new Db4oJobMgmtMntrInfoHolderPredicate(this.jobName));
                if(mgmtMntrInfoHolderResultSet.hasNext())
                {
                    registratInfo=((Db4oJobMgmtMntrInfoHolder)mgmtMntrInfoHolderResultSet.next()).getMgmtMntrInfo();
                    //logger.debug(jobName + " management and monitoring information has been found and being returned");
                }
                else
                    registratInfo=null;
            }
            //logger.trace("Exiting lookupJobMgmtMntrInfo");        
            return registratInfo;
        }

        public JobStatistics[] getStatistics()
        {
//            logger.trace("Entering getStatistics");                                        
//            logger.debug("getStatistics :: job name = " + jobName);
//
//            if(jobName==null)
//                throw new IllegalArgumentException("job name cannot be null for querying the job statistics.");

            JobStatistics[] statistics=null;

            if(container==null)
                statistics=new JobStatistics[0];
            else
            {
                ObjectSet statisticsResultSet=container.query(new Db4oJobStatisticsPredicate(this.jobName));
                //logger.debug("Number of statistics objects = " + statisticsResultSet.size());
                statistics=new JobStatistics[statisticsResultSet.size()];
                for(int i=0;statisticsResultSet.hasNext();i++)
                    statistics[i]=(JobStatistics)statisticsResultSet.next();
            }
            //logger.trace("Exiting getStatistics");
            return statistics;
        }

    }
}