如何模拟抽象 class 的抽象方法？

Question

I have a below method in which I am using this line ProcBOF.getInstance().find to get some data.

  private static Map<Long, Long> getAll(Map<Long, Event> holder) throws FinderException {
    Map<Long, Long> map = new HashMap<>();
    if (holder.isEmpty()) {
      return map;
    }
    Set<Long> items = holder.keySet();
    long[] itemIds = Longs.toArray(items);
    List<TeraBo> teraBos = TBOF.getInstance().findItemIdsIn(itemIds);
    for (TeraBo tBo : teraBos) {
      ProcessBo bo = ProcBOF.getInstance().find(tBo, holder.get(tBo.getItem().getId()).getDataId(), ReadSet.FULL, null);
      bo.getVar();
      map.put(tBo.getItem().getId(), bo.getVar());
    }
    return map;
  }

Now I want to mock the find method of ProcBOF class so that it can return some dummy ProcessBo object from which we can call getVar() method but the issue is ProcBOF is an abstract class and find is an abstract method so I am not able to understand how to mock this abstract method of abstract class.

public interface ProcessBo extends BOI {
    //...
}

public abstract class ProcBOF extends BaseBof {
    //...
    public abstract ProcessBo find(TeraBo saleBo, long dataId, ReadSet readSet, Filter filter) throws FinderException;
}

Answer 1

You're implementation it's a little weird, so I'm not sure If I was able to reproduce it corretly (a getInstance() method on an abstract class is weird).

But, I think that with something like this it should work:

import mockit.Expectations;
import mockit.Mocked;
import mockit.Tested;
import mockit.integration.junit4.JMockit;
import org.junit.runner.RunWith;

import java.util.HashMap;
import java.util.Map;

import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;

@RunWith(JMockit.class)
public class Test {

    // Constants -----------------------------------------------------

    // Attributes ----------------------------------------------------

    /**Tested class*/
    @Tested
    private Foo foo;

    /**Mocked so that all instances are a mock*/
    @Mocked
    private ProcBOF procBOF;

    /**Mocked so that all instances are a mock*/
    @Mocked
    private ProcessBo processBo;

    // Constructors --------------------------------------------------

    // Static --------------------------------------------------------

    // Public --------------------------------------------------------

    @org.junit.Test
    public void name() throws Exception {
        // GIVEN
        new Expectations() {{
            // we mock the getInstance method and return always the mocked instance
            ProcBOF.getInstance();
            result = procBOF;

            // we mock the find method and return the mocked process Bo
            procBOF.find((TeraBo) any, 2L, ReadSet.FULL, null);
            result = processBo;

            // we also mock the getVar method
            processBo.getVar();
            result = "foo";
        }};

        // test data
        Map<Long, Event> map = new HashMap<>();
        map.put(1L, new Event());

        // WHEN
        // call the getAll method
        Map<Long, Object> ret = foo.getAll(map);

        // THEN
        // we get the mocked value
        assertThat(ret.get(1L), is("foo"));
    }

    // Package protected ---------------------------------------------

    // Protected -----------------------------------------------------

    // Private -------------------------------------------------------

    // Inner classes -------------------------------------------------

}