How to create jUnit test cases for a method using DB

A mock is a something like a dummy. To mock a DB would mean to simulate it by some Java object instead of accessing the real DB (thus avoiding dependencies). In your case, if DummyApc7DAOFactory would be an interface (see Abstract Factory pattern), then you could implement a Junit version of the interface which returns an instance of DummyApc7 with values you can test against (using assert methods of the JUnit framework).

For this to work, you have to redesign your code accordingly (and make sure that LogCvaultImport does not cause any trouble). Classes with static methods in your application code are always another source of dependencies you would want to avoid when it comes to unit testing.

In proper TDD (test driven development) approach you would set up Apc7Engine with a unit testing friendly instance of DummyApc7DAOFactory which does the call in retrievePlannings() like this dummyApc7DAOFactory.getDAO().getDummyApc7(); (note that this is not an abstract method call, anymore). The additional code would look like this:

//AbstractDummyApc7DAOFactory.java
public class AbstractDummyApc7DAOFactory {
    /** @param real true, for real DAOFactory, false for Junit testing*/
    public static DummyApc7DAOFactory create(boolean real) {
        if (real) {
            //create and return the real DAOFactory object
        }
        else {
            //return dummy implementation for Junit testing, better define in separate class
            return new DummyApc7DAOFactory() {
                public DummyApc7DAO getDAO() {
                    return new DummyApc7DAO() {
                        public List getDummyApc7() {
                            List dummyList = new ArrayList();
                            testApc7 = new DummyApc7();
                            testApc7.setVersion("1.Unit.Test");
                            //....
                            dummyList.add(testApc7);
                            return dummyList;
                        }
                    };
                }
            };
        }
    }
}

//test code in junit test class
@Test
public void testRetrievePlannings() {
    DummyApc7DAOFactory fac = AbstractDummyApc7DAOFactory.create(false);
    testObj.setDummyApc7DAOFactory(fac);
    testObj.retrievePlannings();
    PlanningObject testPO = test.getListPlanningObject().get(0);
    assertEquals(testApc7.getVersion(), testPO.getVersion()); 
    //...
}

If redesigning of the code is not an option, Mockito might help. Here you do not have to mock the DB but stub the mehod call of your DummyApc7DAOFactory class. There are limitations however: Mockito cannot stub final or anonymous classes. If that is the case, you have to redesign the code. If not, a quick and dirty solution might look like this:

public class  RetrievePlanningsTest {       
        private DummyApc7 testApc7;
        private Apc7Engine testObj = new Apc7Engine();

        @Before
        public void setUp() {
            DummyApc7DAOFactory mockedObj = mock(DummyApc7DAOFactory.class);
            List dummyList = new ArrayList();
            testApc7 = new DummyApc7();
            testApc7.setVersion("1.Unit.Test");
            //....
            dummyList.add(testApc7);
            when(DummyApc7DAOFactory.getDAO().getDummyApc7()).thenReturn(dummyList);
        }

        @Test
        public void testRetrievePlannings() {
            testObj.retrievePlannings();
            PlanningObject testPO = testObj.getListPlanningObject().get(0);
            assertEquals(testApc7.getVersion(), testPO.getVersion()); 
            //...
        }
}