Mockito/Spring MVC-(注释驱动)请求映射动态验证

Question

我目前正在编写一个基于Spring MVC的Web应用程序。

与其为每个带注释的方法编写一个测试，我更希望从参数化JUnit runner中获益。

最后，我几乎可以工作了，尽管我必须在控制器方法中将所有原始参数更改为它们的包装器对应参数（然后手动对空引用进行健全性检查）。

如果它可以帮助，这里是代码（这也取决于Guava）：

@RunWith(Parameterized.class)
public class MyControllerMappingTest {
    private MockHttpServletRequest request;
    private MockHttpServletResponse response;
    private MyController mockedController;
    private AnnotationMethodHandlerAdapter annotationHandlerAdapter;
    private final String httpMethod;
    private final String uri;
    private final String controllerMethod;
    private final Class<?>[] parameterTypes;
    private final Object[] parameterValues;
    @Before
    public void setup() {
        request = new MockHttpServletRequest();
        response = new MockHttpServletResponse();
        mockedController = mock(MyController.class);
        annotationHandlerAdapter = new AnnotationMethodHandlerAdapter();
    }
    @Parameters
    public static Collection<Object[]> requestMappings() {
        return asList(new Object[][] {
                {"GET", "/my/uri/0", "index", arguments(new MethodArgument(Integer.class, 0))}
        });
    }
    private static List<MethodArgument> arguments(MethodArgument... arguments) {
        return asList(arguments);
    }
    public MyControllerMappingTest(String httpMethod, String uri, String controllerMethod, List<MethodArgument> additionalParameters) {
        this.httpMethod = httpMethod;
        this.uri = uri;
        this.controllerMethod = controllerMethod;
        this.parameterTypes = new Class<?>[additionalParameters.size()];
        initializeParameterTypes(additionalParameters);
        this.parameterValues = newArrayList(transform(additionalParameters, valueExtractor())).toArray();
}
    private void initializeParameterTypes(List<MethodArgument> additionalParameters) {
        Iterable<Class<?>> classes = transform(additionalParameters, typeExtractor());
        int i = 0;
        for (Class<?> parameterClass : classes) {
            parameterTypes[i++] = parameterClass;
        }
    }
    @Test
    public void when_matching_mapping_constraints_then_controller_method_automatically_called() throws Exception {
        request.setMethod(httpMethod);
        request.setRequestURI(uri);
        annotationHandlerAdapter.handle(request, response, mockedController);
        Method method = MyController.class.getMethod(controllerMethod, parameterTypes);
        method.invoke(verify(mockedController), parameterValues);
    }
}

自定义类MethodArgument如下：

public class MethodArgument {
    private final Class<?> type;
    private final Object value;
    public MethodArgument(final Class<?> type, final Object value) {
        this.type = type;
        this.value = value;
    }
    public Object getValue() {
        return value;
    }
    public Class<?> getType() {
        return type;
    }
    public static Function<MethodArgument, Class<?>> typeExtractor() {
        return new Function<MethodArgument, Class<?>>() {
            @Override
            public Class<?> apply(MethodArgument argument) {
                return argument.getType();
            }
        };
    }
    public static Function<MethodArgument, Object> valueExtractor() {
        return new Function<MethodArgument, Object>() {
            @Override
            public Object apply(MethodArgument argument) {
                return argument.getValue();
            }
        };
    }
}

所以，我差不多到了，这里唯一的测试用例是因为Java Integer缓存而工作的，因此Integer实例在整个调用链中都是相同的。。。然而，这对自定义对象不起作用，我总是以InvocationTargetException结束（原因："参数不同！"）。。。

类型是正确的，但传递的实例与@Parameters方法中设置的实例不同。

知道如何解决这个问题吗？

Answer 1

小心！

SpringSource正在烘焙一个spring测试mvc模块：https://github.com/SpringSource/spring-test-mvc

Answer 2

如果您不提供有效的示例，而是提供不有效的示例并提供stacktrace，那就太好了。

我很快查看了谷歌，似乎Mockito不能很好地处理间谍对象的反射。

如果你真的想走这条路，可能还有另一种方法：提供预期的被调用方法作为参数化数据的一部分，不是通过提供反射数据，而是通过从那里实际调用mock。

我在没有任何IDE的情况下写这篇文章，所以可能会有编译错误，但你会得到这样的想法：

@RunWith(Parameterized.class)
public class MyControllerMappingTest {
    public interface VerifyCall<T> {
        void on(T controller);
    }
    @Parameters
    public static Collection<Object[]> requestMappings() {
        Object[][] testCases = {    
            {"GET", "/my/uri/0", new VerifyCall<MyController>() {
                @Override
                public void on(MyController controller) {
                    controller.index(0);
                }
            }}  
        };
        return asList(testCases);
    }
    private MockHttpServletRequest request;
    private MockHttpServletResponse response;
    private MyController mockedController;
    private AnnotationMethodHandlerAdapter annotationHandlerAdapter;
    private final String httpMethod;
    private final String uri;
    private final VerifyCall<MyController> verifyCall;
    public MyControllerMappingTest(String httpMethod, String uri, VerifyCall<MyController> verifyCall) {
        this.httpMethod = httpMethod;
        this.uri = uri;
        this.verifyCall = verifyCall;
    }
    @Before
    public void setup() {
        request = new MockHttpServletRequest();
        response = new MockHttpServletResponse();
        mockedController = mock(MyController.class);
        annotationHandlerAdapter = new AnnotationMethodHandlerAdapter();
    }
    @Test
    public void when_matching_mapping_constraints_then_controller_method_automatically_called() throws Exception {
        request.setMethod(httpMethod);
        request.setRequestURI(uri);
        annotationHandlerAdapter.handle(request, response, mockedController);
        verifyCall.on(verify(mockedController));
    }
}

当然，拥有JavaLambas将有助于提高可读性。

您也可以使用FunkyJFunctional:

@RunWith(Parameterized.class)
public class MyControllerMappingTest {
    @Parameters
    public static Collection<Object[]> requestMappings() {
        class IndexZero extends FF<MyController, Void> {{ in.index(0); }}
        Object[][] testCases = { //           
                {"GET", "/my/uri/0", withF(IndexZero.clas)}
        };
        return asList(testCases);
    }
    private MockHttpServletRequest request;
    private MockHttpServletResponse response;
    private MyController mockedController;
    private AnnotationMethodHandlerAdapter annotationHandlerAdapter;
    private final String httpMethod;
    private final String uri;
    private final Function<MyController, Void> verifyCall;
    public MyControllerMappingTest(String httpMethod, String uri, Function<MyController, Void> verifyCall) {
        this.httpMethod = httpMethod;
        this.uri = uri;
        this.verifyCall = verifyCall;
    }
    @Before
    public void setup() {
        request = new MockHttpServletRequest();
        response = new MockHttpServletResponse();
        mockedController = mock(MyController.class);
        annotationHandlerAdapter = new AnnotationMethodHandlerAdapter();
    }
    @Test
    public void when_matching_mapping_constraints_then_controller_method_automatically_called() throws Exception {
        request.setMethod(httpMethod);
        request.setRequestURI(uri);
        annotationHandlerAdapter.handle(request, response, mockedController);
        verifyCall.apply(verify(mockedController));
    }
}

一些旁注：

• 为了可读性，在类中把静态成员放在第一位是一种很好的做法。实例方法（setup()）也应该在构造函数之后。

• 数组语法：

代替此语法：

return asList(new Object[][] {
    {},
    {}
};

我发现这个语法更可读：

Object[][] testCases = {
    {},
    {}
};
return asList(testCases);