Сейчас же, я, как и обещал, хочу рассказать о том, что стоит за сценой.
Итак, главным помощником в нашем нелегком деле является BlockJUnit4ClassRunner, являющийся ответственным за выполнение тестов в классе по умолчанию. От него мы и унаследуемся.
public class EasyMockRunner extends BlockJUnit4ClassRunner {
public EasyMockRunner(Class<?> klass) throws InitializationError {
super(klass);
...
}
...
}
Теперь мы сможем использовать этот класс, указав его в качестве раннера для нашего тестового класса.
@RunWith(EasyMockRunner.class)
public class SomeObjectTest {
...
}
Счастье было бы неполным, если бы мы не смогли добавить логику перед вызовом и после завершения каждого тестового метода. Видимо разработчики JUnit посчитали, что несчастный разработчик - плохой разработчик, и позаботились о такой возможности. Представляю Вашему вниманию methodInvoker
@Override
protected Statement methodInvoker(final FrameworkMethod method, final Object test) {
return super.methodInvoker(method, test);
}
В качестве аргументов он принимает экземпляр тестового класса и информацию о выполняемом методе, на основе которых выдает Statement (нечто очень похожее на Runnable), который будет выполнен вызовом метода statement.evaluate(). Отсюда закономерно возникает точка расширения - оборачиваем родительский стейтмент в свой и добавляем требуемую логику.
Теперь мы имеем достаточно, для того, чтобы реализовать функциональность, описанную в предыдущем посте.
1. Собираем все поля помеченные аннотацией @Mock
public EasyMockRunner(Class<?> klass) throws InitializationError {
super(klass);
collectMockedFields();
}
private void collectMockedFields() throws InitializationError {
mockedFields = new HashMap<PropertyDescriptor, FrameworkField>();
Listfields = getTestClass().getAnnotatedFields(Mock.class);
for (FrameworkField field : fields) {
Mock mock = field.getField().getAnnotation(Mock.class);
field.getField().setAccessible(true);
PropertyDescriptor[] descriptors = PropertyUtils.getPropertyDescriptors(getTestObjectField().getType());
PropertyDescriptor targetProperty = null;
for (PropertyDescriptor descriptor : descriptors) {
if (descriptor.getPropertyType().isAssignableFrom(field.getField().getType()) && (mock.property().isEmpty() || descriptor.getName().equals(mock.property()))) {
if (targetProperty != null) {
throw new InitializationError("Target object have more than one property with type");
} else {
targetProperty = descriptor;
}
}
}
if (targetProperty == null) {
throw new InitializationError(String.format("Test object doesn't have property with type: %s", field.getField().getType().getName()));
} else {
mockedFields.put(targetProperty, field);
}
}
}
2. Находим поле для тестового объекта (если есть поле помеченное аннотацией @TestObject, то используем его, в противном случае пытаемся найти поле по типу ClazzTest
private Field getTestObjectField() throws InitializationError {
if (testObjectField == null) {
List<FrameworkField> fields = getTestClass().getAnnotatedFields(TestObject.class);
if (fields.size() > 1) {
throw new InitializationError("No unique test object was found");
}
if (fields.size() == 0) {
Class testClass = getTestClass().getJavaClass();
String testClassName = testClass.getName();
Class testObjectClass;
try {
testObjectClass = Class.forName(testClassName.replaceFirst("Test$", ""));
} catch (ClassNotFoundException e) {
throw new InitializationError("Test object class not found. You can set it explicitly using @Describes(clazz = TestObject.class) annotation");
}
Field targetField = null;
for (Field field : getTestClass().getJavaClass().getDeclaredFields()) {
if (testObjectClass.isAssignableFrom(field.getType())) {
if (targetField != null) {
throw new InitializationError("No unique test object was found");
}
targetField = field;
}
}
if (targetField == null) {
throw new InitializationError("Test object field was not found");
}
testObjectField = targetField;
} else {
testObjectField = fields.get(0).getField();
}
testObjectField.setAccessible(true);
}
return testObjectField;
}
3. Создаем тестовый объект
private Object createTestObject(FrameworkMethod method, List mocks) throws InitializationError, InstantiationException, IllegalAccessException {
Object testObject;Field testObjectField = getTestObjectField();
Class testObjectClass = testObjectField.getType();
MockMethodNames mockMethodNames = method.getAnnotation(MockMethodNames.class);
MockMethods mockMethodsAnnotation = method.getAnnotation(MockMethods.class);
MockMethod mockMethodAnnotation = method.getAnnotation(MockMethod.class);
ListmockMethods = new ArrayList ();
if (mockMethodsAnnotation != null) {
mockMethods.addAll(Arrays.asList(mockMethodsAnnotation.value()));
}
if (mockMethodAnnotation != null) {
mockMethods.add(mockMethodAnnotation);
}
if (mockMethodNames != null || !mockMethods.isEmpty()) {
IMockBuilder builder = EasyMock.createMockBuilder(testObjectClass);
if (mockMethodNames != null) {
builder.addMockedMethods(mockMethodNames.value());
}
if (!mockMethods.isEmpty()) {
Method[] methods = new Method[mockMethods.size()];
int i = 0;
for (MockMethod mockMethod : mockMethods) {
Method mockedMethod = MethodUtils.getAccessibleMethod(testObjectClass, mockMethod.name(), mockMethod.parameters());
if (mockedMethod == null) {
throw new RuntimeException(String.format("Method to mock was not found: %s", mockMethod.name()));
}
methods[i++] = mockedMethod;
}
builder.addMockedMethods(methods);
}
testObject = builder.createMock();
mocks.add(testObject);
} else {
testObject = testObjectClass.newInstance();
}
return testObject;
}
4. Оборачиваем вызов теста
@Override
protected Statement methodInvoker(final FrameworkMethod method, final Object test) {
try {
final List mocks = new ArrayList();
Object testObject = createTestObject(method, mocks);
getTestObjectField().set(test, testObject);
for (Map.Entry<PropertyDescriptor, FrameworkField> entry : this.mockedFields.entrySet()) {
Object value = EasyMock.createMock(entry.getValue().getField().getType());
mocks.add(value);
entry.getValue().getField().set(test, value);
entry.getKey().getWriteMethod().invoke(testObject, value);
}
final Statement statement = super.methodInvoker(method, test);
return new Statement() {
@Override
public void evaluate() throws Throwable {
CurrentMocks.remember(mocks);
try {
statement.evaluate();
CurrentMocks.verify();
} finally {
CurrentMocks.forgetAll();
}
}
};
} catch (Exception e) {
throw new RuntimeException(e);
}
}
5. Добавляем вспомогательный класс для связи со внешним миром
public class CurrentMocks {
private static ThreadLocal<List> currentMocks = new ThreadLocal<List>();
/**
* Remember mocks for future replay and verify
* @param mocks mocks
*/
public static void remember(Object... mocks) {
remember(Arrays.asList(mocks));
}
/**
* Remember mocks for future replay and verify
* @param mocks mocks
*/
public static void remember(List mocks) {
List allMocks = currentMocks.get();
if (allMocks != null) {
allMocks.addAll(mocks);
} else {
currentMocks.set(new ArrayList(mocks));
}
}
/**
* Shortcut for sequence:
*
* remember(mocks);
* replay();
*
* @see ru.km.easymock.CurrentMocks#remember(Object...)
* @see ru.km.easymock.CurrentMocks#replay()
* @see ru.km.easymock.CurrentMocks#verify()
* @param mocks mocks to replay and remember
*/
public static void replay(Object... mocks) {
remember(mocks);
replay();
}
/**
* Replay all remembered mocks
*/
public static void replay() {
List mocks = currentMocks.get();
if (mocks != null) {
EasyMock.replay(currentMocks.get().toArray());
}
}
/**
* Verify all remembered mocks and forget them
*/
public static void verify() {
List mocks = currentMocks.get();
if (mocks != null) {
EasyMock.verify(currentMocks.get().toArray());
forgetAll();
}
}
/**
* Forget all mocks
*/
public static void forgetAll() {
currentMocks.set(null);
}
}
6. Добавляем классы для аннотаций, которые я здесь приводить не буду, в силу их предельной простоты
