wamblee.org Git - utils/blob - support/general/src/test/java/org/wamblee/test/ResettableMock.java

   1 /**
   2  *
   3  */
   4 package org.wamblee.test;
   5
   6 import static org.mockito.Mockito.*;
   7
   8 import java.lang.reflect.InvocationHandler;
   9 import java.lang.reflect.Method;
  10 import java.lang.reflect.Proxy;
  11
  12 /**
  13  * Resettable mock is a utility to support reset functionality for mockito.
  14  * @author Erik Brakkee
  15  *
  16  * @param <T>
  17  */
  18 public class ResettableMock<T> {
  19
  20         private static class MockitoInvocationHandler<T> implements
  21                         InvocationHandler {
  22
  23                 private Class<T> _class;
  24                 private T _mock;
  25
  26                 public MockitoInvocationHandler(Class<T> aClass) {
  27                         _class = aClass;
  28                         _mock = mock(aClass);
  29                 }
  30
  31                 public void reset() {
  32                         _mock = mock(_class);
  33                 }
  34
  35                 public T getMock() {
  36                         return _mock;
  37                 }
  38
  39                 @Override
  40                 public Object invoke(Object aProxy, Method aMethod, Object[] aArgs)
  41                                 throws Throwable {
  42                         return aMethod.invoke(_mock, aArgs);
  43                 }
  44         }
  45
  46         /**
  47          * Invocation handler that delegates to the current mockito mock and allows
  48          * creation of a new mock.
  49          */
  50         private ResettableMock.MockitoInvocationHandler<T> _handler;
  51
  52         /**
  53          * Proxy object to be passed to tested classes.
  54          */
  55         private T _proxy;
  56
  57         /**
  58          * Constructs the resettable mock.
  59          * @param aType Type to mock. Must be an interface type.
  60          */
  61         public ResettableMock(Class<T> aType) {
  62                 if ( !aType.isInterface()) {
  63                         throw new IllegalArgumentException("Class '" + aType.getName() + "' must be an interface");
  64                 }
  65                 _handler = new MockitoInvocationHandler(aType);
  66                 _proxy = (T) Proxy.newProxyInstance(aType.getClassLoader(),
  67                                 new Class[] { aType }, _handler);
  68         }
  69
  70         /**
  71          * Resets the mock effectively forgetting all previous interactions and verifications.
  72          */
  73         public void reset() {
  74                 _handler.reset();
  75         }
  76
  77         /**
  78          * Gets the current mock object to pass to mockito calls.
  79          *
  80          * @return Mock object.
  81          */
  82         public T getMock() {
  83                 return _handler.getMock();
  84         }
  85
  86         /**
  87          * Returns the proxy that your tested classes will used.
  88          *
  89          * @return Proxy object.
  90          */
  91         public T getProxy() {
  92                 return _proxy;
  93         }
  94
  95 }