@Override public <T> T getLegalForParam(int paramPosition) { Type type = method. getGenericParameterTypes()[paramPosition]; MockeryMetadata mockery = mockeryMetadata .fromParam(providersClass, method, null, paramPosition); checkSupportType.from(providersClass, method, mockery, type); return (T) mockery.legal(); }
@Override public <T> T getIllegalForParam(int paramPosition) { Type type = method. getGenericParameterTypes()[paramPosition]; MockeryMetadata mockery = mockeryMetadata .fromParam(providersClass, method, null, paramPosition); checkSupportType.from(providersClass, method, mockery, type); return (T) mockery.illegal(); }
private void applyValidationsToParams(Method method, Object[] args) { Type[] typeParams = method.getGenericParameterTypes(); for (int i = 0; i < typeParams.length; i++) { Type typeParam = typeParams[i]; MockeryMetadata mockery = getMockeryMetadata .fromParam(mockingClass, method, args, i); if (mockery == null) { String message = Messages.noMockeryFoundOnParam(mockingClass, method, i); throw new RuntimeException(message); } checkSupportType.from(mockingClass, method, mockery, typeParam); Object valueParam = args[i]; mockery.validate(valueParam); } }
@Override public void validateResponse(Object response) { interceptorMetadata.validate(response); Type typeMethod = method.getGenericReturnType(); Type adaptedTypeMethod = interceptorMetadata.adaptType(typeMethod); Object adaptedResponse = interceptorMetadata.adaptResponse(response); MockeryMetadata mockeryMethod = mockeryMetadata .fromMethod(providersClass, method, adaptedTypeMethod, null); checkSupportType.from(providersClass, method, mockeryMethod, adaptedTypeMethod); mockeryMethod.validate(adaptedResponse); }
@Test public void When_Get_Mockery_Metadata_From_Param_And_Type_Is_Supported_Then_Not_Get_Exception() throws NoSuchMethodException { Method method = Providers.class.getMethod("supportedTypeParam", String.class); Type type = method.getGenericParameterTypes()[0]; MockeryMetadata mockery = getMockeryMetadata .fromParam(Providers.class, method, null, 0); checkSupportTypeUT.from(Providers.class, method, mockery, type); }
@Test public void When_Get_Mockery_Metadata_From_Method_And_Type_Is_Supported_Then_Not_Get_Exception() throws NoSuchMethodException { Method method = Providers.class.getMethod("supportedTypeMethod"); Type type = method.getGenericReturnType(); MockeryMetadata mockery = getMockeryMetadata .fromMethod(Providers.class, method, type, null); checkSupportTypeUT.from(Providers.class, method, mockery, type); }
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (method.getDeclaringClass() == Object.class) { return method.invoke(this, args); } InterceptorMetadata interceptor = getInterceptorMetadata. with(mockingClass, method, args); try { applyValidationsToParams(method, args); Type adaptedTypeMethod = interceptor .adaptType(method.getGenericReturnType()); MockeryMetadata mockery = getMockeryMetadata .fromMethod(mockingClass, method, adaptedTypeMethod, args); checkSupportType.from(mockingClass, method, mockery, adaptedTypeMethod); Object response = mockery.legal(); return interceptor.onLegalMock(response); } catch (AssertionError e) { return interceptor.onIllegalMock(e); } }
@Test public void When_Get_Mockery_Metadata_From_Method_But_Method_Type_Is_Not_Supported_Then_Get_Exception() throws NoSuchMethodException { Method method = Providers.class.getMethod("notSupportedTypeMethod"); Type type = method.getGenericReturnType(); try { MockeryMetadata mockery = getMockeryMetadata .fromMethod(Providers.class, method, type, null); checkSupportTypeUT.from(Providers.class, method, mockery, type); fail(); } catch (RuntimeException e) { assertThat(e.getMessage(), is("When checking ValidMockery on method Providers#notSupportedTypeMethod \n" + " an attempt to use it with class java.lang.Object was found. But it is not a supported type for ValidMockery.\n" + "To fix it, use ValidMockery with: [double, class java.lang.Double, float, class java.lang.Float, int, class java.lang.Integer, long, class java.lang.Long, class java.lang.String, class java.lang.Character].\n")); } }
@Test public void When_Get_Mockery_Metadata_From_Param_But_Param_Type_Is_Not_Supported_Then_Get_Exception() throws NoSuchMethodException { Method method = Providers.class.getMethod("notSupportedTypeParam", Object.class); Type type = method.getGenericParameterTypes()[0]; try { MockeryMetadata mockery = getMockeryMetadata .fromParam(Providers.class, method, null, 0); checkSupportTypeUT.from(Providers.class, method, mockery, type); fail(); } catch (RuntimeException e) { assertThat(e.getMessage(), is("When checking ValidMockery on method Providers#notSupportedTypeParam \n" + " an attempt to use it with class java.lang.Object was found. But it is not a supported type for ValidMockery.\n" + "To fix it, use ValidMockery with: [double, class java.lang.Double, float, class java.lang.Float, int, class java.lang.Integer, long, class java.lang.Long, class java.lang.String, class java.lang.Character].\n")); } }