Mockito：模拟一个类，但在构造函数受保护时设置final字段的值

Question

Here's the class:

public class A {

   public final SqlOperator op;
   public final ImmutableList<RexNode> operands;
   public final RelDataType type;

   protected A(RelDataType type,SqlOperator op,List<? extends RexNode> operands) {
     assert type != null : "precondition: type != null";
     assert op != null : "precondition: op != null";
     assert operands != null : "precondition: operands != null";
     this.type = type;
     this.op = op;
     this.operands = ImmutableList.copyOf(operands);
     assert op.getKind() != null : op;
     assert op.validRexOperands(operands.size(), Litmus.THROW) : this;
}

I want to mock class A but set the value of "operands" field to an empty list. The field being final I cannot modify it outside the constructor when I mock the class.

I tried to use Reflection but that didn't work with Mockito.

The code for which test case is needed:

public static String extractGranularity(A call) {
    if (call.getKind() != SqlKind.FLOOR || call.getOperands().size() != 2) {
        return null;
    }
    final B flag = (B) call.operands.get(1);   // This is the problem area
    final TimeUnitRange timeUnit = (TimeUnitRange) flag.getValue();
    if (timeUnit == null) {
        return null;
    }
    return timeUnitSwitch(timeUnit);
}

Answer 1

OK so here's something based on the classes you did post (I assume the real ones are a little bit different):

package so45078998;

import com.google.common.collect.ImmutableList;
import java.util.List;

public class A {

    public final SqlOperator op;
    public final ImmutableList<RexNode> operands;
    public final RelDataType type;

    protected A(RelDataType type, SqlOperator op, List<? extends RexNode> operands) {
        assert type != null : "precondition: type != null";
        assert op != null : "precondition: op != null";
        assert operands != null : "precondition: operands != null";
        this.type = type;
        this.op = op;
        this.operands = ImmutableList.copyOf(operands);
        assert op.getKind() != null : op;
        assert op.validRexOperands(operands.size(), Litmus.THROW) : this;
    }

    public Object getKind() {
        return op.getKind();
    }

    public ImmutableList<RexNode> getOperands() {
        return operands;
    }

    static class SqlOperator{

        private Object kind;

        public Object getKind() {
            return kind;
        }

        void setKind(final Object kind) {
            this.kind = kind;
        }

        boolean validRexOperands(int size, Litmus litmus) {
            return true;
        }
    }

    static class RexNode{
        private Object value;

        public Object getValue() {
            return value;
        }

        void setValue(final Object value) {
            this.value = value;
        }
    }
    static class RelDataType{}
    static enum Litmus{ THROW }
}

// ------------------------------------------------------

package so45078998;

public class ToTest {
    public static String extractGranularity(A call) {
        if (call.getKind() != SqlKind.FLOOR || call.getOperands().size() != 2) {
            return null;
        }
        final B flag = (B) call.operands.get(1);   // This is the problem area
        final TimeUnitRange timeUnit = (TimeUnitRange) flag.getValue();
        if (timeUnit == null) {
            return null;
        }
        return timeUnitSwitch(timeUnit);
    }

    private static String timeUnitSwitch(final TimeUnitRange timeUnit) {
        return "OK";
    }

    enum SqlKind { FLOOR, OTHER }
    static class TimeUnitRange {}
    static class B extends A.RexNode {}
}

And the test class (both tests are green here):

package so45078998;

import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;

public class ToTestTest {
    @Test
    public void testExtractGranularityWithKindNotFloor() throws Exception {
        ToTest.B rexNode1 = new ToTest.B();
        ToTest.B rexNode2 = new ToTest.B();
        List<A.RexNode> operands = new ArrayList<>();
        operands.add(rexNode1);
        operands.add(rexNode2);
        final A.RelDataType relDataType = new A.RelDataType();
        final A.SqlOperator sqlOperator = new A.SqlOperator();
        sqlOperator.setKind(ToTest.SqlKind.OTHER);
        A a = new A(relDataType, sqlOperator, operands);

        Assert.assertNull(ToTest.extractGranularity(a));
    }

    @Test
    public void testExtractGranularity() throws Exception {
        ToTest.B rexNode1 = new ToTest.B();
        ToTest.B rexNode2 = new ToTest.B();
        rexNode2.setValue(new ToTest.TimeUnitRange());
        List<A.RexNode> operands = new ArrayList<>();
        operands.add(rexNode1);
        operands.add(rexNode2);
        final A.RelDataType relDataType = new A.RelDataType();
        final A.SqlOperator sqlOperator = new A.SqlOperator();
        sqlOperator.setKind(ToTest.SqlKind.FLOOR);
        A a = new A(relDataType, sqlOperator, operands);

        Assert.assertEquals("OK", ToTest.extractGranularity(a));
    }
}

This works because the test class and the tested class share the same package name (and so you can call directly new A(...) ).

No if you want to suppress some A behavior, use a spy and use it to control the behavior when required.

I hope that helps.

Answer 2

Maybe you can try hacking with Unsafe:

sun.misc.Unsafe unsafe = null;
try {
  final PrivilegedExceptionAction<sun.misc.Unsafe> action = () -> {
    Field unsafe = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
    unsafe.setAccessible(true);
    return (sun.misc.Unsafe) unsafe.get(null);
  };
  unsafe = AccessController.doPrivileged(action);
} catch (Exception e) {
  throw new RuntimeException("Unable to load unsafe", e);
}
long operandsOffset = unsafe.objectFieldOffset(
                                A.class.getDeclaredField("operands"));
A instance = // your instance of A
ImmutableList<RexNode> yourOverridingList = ...
unsafe.getAndSetObject(instance, operandsOffset, yourOverridingList);

Answer 3

Encapsulate , you fool!!!

Encapsulating is hiding the actual implementation details of a class. So in your case right now you use myA.operands to access the actual operands. And that could potentially bring some troubles. Instead of having all your attributes public make them private and add some accessor methods:

public class A {

   private final ImmutableList<RexNode> operands;
   // rest of attributes and constructor...

   public ImmutableList<RexNode> getOperands() {
       return operands;
   }
}

Not only you'll be following a good practice but also mocking it will be easier:

A myA = mock(A.class);
Mockito.when(myA.getOperands())
    .thenReturn(/* what you want it to return */);